@Prop decorator for specific nested objects in array

I think you need to first define the schemas in the order of their dependencies, like this:

import mongoose, { Document, Mongoose } from 'mongoose';
import { Prop, Schema, SchemaFactory } from '@nestjs/mongoose';

export type ReviewDocument = Review & Document;

@Schema()
export class UserComment {
    @Prop({ type: String })
    text: string;

    @Prop({ type: String })
    originalText: string;

    @Prop({ type: String })
    lastModified: string;

    @Prop({ type: Number })
    starRating: number;

    @Prop({ type: String })
    reviewerLanguage: string;
}

@Schema()
export class DeveloperComment {
    @Prop({ type: String })
    text: string;

    @Prop({ type: String })
    lastModified: string;
}

@Schema()
export class Comments {
    @Prop({ type: mongoose.Schema.Types.ObjectId })
    userComment: UserComment;

    @Prop({ type: mongoose.Schema.Types.ObjectId })
    developerComment: DeveloperComment;
}

@Schema()
export class Review {
    @Prop({ type: String, required: true })
    reviewId: string;

    @Prop({ type: String })
    authorName: string;

    @Prop({ type: mongoose.Schema.Types.Array })
    comments: Comments[];
}

export const ReviewSchema = SchemaFactory.createForClass(Review);

There are a few things to notice when you define a mongoose schema:

1. The schema types of primitive properties (e.g. string, number) are automatically inferred, so you don't need to explicitly specify { type: String} in the decorator.
2. In order to preserve the nested schema validation, each object has to have its own schema or be defined using the raw schema definition.
3. For each nested schema please mind the default properties created by mongoose, such as timestamps, _id, __v, and so on. You could manipulate them by passing options object in the @Schema() decorator.

Here is the schema definition for your use case:

import { Prop, raw, Schema, SchemaFactory } from '@nestjs/mongoose';
import { Document, Types } from 'mongoose';

@Schema({ _id: false })
class UserComment {
  @Prop({ required: true })
  text: string;

  @Prop(raw({ seconds: { type: Number } }))
  lastModified: Record<string, number>;

  @Prop({ required: true })
  starRating: number;

  @Prop({ required: true })
  reviewerLanguage: string;
}
const UserCommentSchema = SchemaFactory.createForClass(UserComment);

@Schema({ _id: false })
class DeveloperComment {
  @Prop({ required: true })
  text: string;

  @Prop(raw({ seconds: { type: Number } }))
  lastModified: Record<string, number>;
}

const DeveloperCommentSchema = SchemaFactory.createForClass(DeveloperComment);

@Schema({ _id: false })
class Comment {
  @Prop({ type: UserCommentSchema })
  userComment?: UserComment;

  @Prop({ type: DeveloperCommentSchema })
  developerComment?: DeveloperComment;
}

const CommentSchema = SchemaFactory.createForClass(Comment);

@Schema({ timestamps: true, versionKey: false })
export class Review {
  _id: Types.ObjectId;
  createdAt: Date;
  updatedAt: Date;

  @Prop({ unique: true, required: true })
  reviewId: string;

  @Prop({ required: true })
  authorName: string;

  @Prop({ type: [CommentSchema], default: [] })
  comments: Comment[];
}

export type ReviewDocument = Review & Document;
export const ReviewSchema = SchemaFactory.createForClass(Review);

PS: In this documentation page you could find plenty of use cases: https://docs.nestjs.com/techniques/mongodb