diff --git a/test/types/populate.test.ts b/test/types/populate.test.ts
index cc34233254..6014fcceed 100644
--- a/test/types/populate.test.ts
+++ b/test/types/populate.test.ts
@@ -420,6 +420,136 @@ function gh14441() {
       const docObject = docs[0]!.toObject();
       ExpectType<string>(docObject.child.name);
     });
+
+  interface ArrayParent {
+    children?: Types.ObjectId[];
+    title?: string;
+  }
+  const ArrayParentModel = model<ArrayParent>(
+    'ArrayParent',
+    new Schema({
+      title: String,
+      children: [{ type: Schema.Types.ObjectId, ref: 'Child' }]
+    })
+  );
+
+  type PopulatedChildren = {
+    children: mongoose.Types.DocumentArray<mongoose.HydratedDocFromModel<typeof ChildModel>>;
+  };
+
+  ArrayParentModel.findOne({})
+    .orFail()
+    .then(async doc => {
+      const populatedDoc = await doc.populate<PopulatedChildren>('children');
+
+      // Populating changes the path type from ObjectIds to documents, so the result should
+      // not be assignable back to the model's original hydrated type.
+      // @ts-expect-error Type 'PopulateDocumentResult<Document<unknown, {}, ArrayParent, {}, DefaultSchemaOptions> & ArrayParent...'
+      const hydratedDoc: mongoose.HydratedDocFromModel<typeof ArrayParentModel> = populatedDoc;
+      ExpectAssignable<Document<any>>()(populatedDoc);
+      ExpectAssignable<Document<unknown>>()(populatedDoc);
+      ExpectType<string | undefined>(populatedDoc.children[0]?.name);
+      const plainObject = populatedDoc.toObject();
+      ExpectType<string>(plainObject.children[0].name);
+      const depopulatedObject = populatedDoc.toObject({ depopulate: true });
+      ExpectType<Types.ObjectId>(depopulatedObject.children![0]);
+
+      const objectWithVirtuals = populatedDoc.toObject({ virtuals: true });
+      ExpectType<string>(objectWithVirtuals.children![0].name);
+
+      const objectWithFlattenObjectIds = populatedDoc.toObject({ flattenObjectIds: true });
+      ExpectType<string>(objectWithFlattenObjectIds.children![0].name);
+
+      const depopulatedAndFlattened = populatedDoc.toObject({ depopulate: true, flattenObjectIds: true });
+      ExpectType<string>(depopulatedAndFlattened.children![0]);
+
+      const jsonObject = populatedDoc.toJSON();
+      ExpectType<string>(jsonObject.children![0].name);
+      const jsonObjectWithVirtuals = populatedDoc.toJSON({ virtuals: true });
+      ExpectType<string>(jsonObjectWithVirtuals.children![0].name);
+      const jsonDepopulated = populatedDoc.toJSON({ depopulate: true });
+      ExpectType<Types.ObjectId>(jsonDepopulated.children![0]);
+
+      // Known limitation: structural wrappers that drop the marker lose the populated toObject() behavior.
+      const strippedMarkerDoc: Omit<typeof populatedDoc, keyof mongoose.PopulatedDocumentMarker<any, any>> =
+        populatedDoc;
+      const strippedMarkerObject = strippedMarkerDoc.toObject();
+      // @ts-expect-error Property 'name' does not exist on type 'ObjectId'
+      ExpectType<string>(strippedMarkerObject.children![0].name);
+
+      // Known limitation: generic helpers that erase the marker only see the base toObject() typing.
+      function toObjectWithBaseTyping<T extends Document<unknown, any, ArrayParent>>(input: T) {
+        return input.toObject();
+      }
+      const genericObject = toObjectWithBaseTyping(populatedDoc);
+      // Generic helper removed the populated behavior so we only get the raw ObjectId back.
+      ExpectType<Types.ObjectId>(genericObject.children![0]);
+    });
+
+  ArrayParentModel.findOne({})
+    .populate<PopulatedChildren>('children')
+    .orFail()
+    .then(populatedDoc => {
+      ExpectAssignable<Document<any>>()(populatedDoc);
+      ExpectAssignable<Document<unknown>>()(populatedDoc);
+      ExpectType<string | undefined>(populatedDoc.children[0]?.name);
+      const plainObject = populatedDoc.toObject();
+      ExpectType<string>(plainObject.children[0].name);
+      const depopulatedObject = populatedDoc.toObject({ depopulate: true });
+      ExpectType<Types.ObjectId>(depopulatedObject.children![0]);
+    });
+
+  ArrayParentModel.findOne({})
+    .orFail()
+    .then(async doc => {
+      const populatedDoc = await ArrayParentModel.populate<PopulatedChildren>(doc, 'children');
+
+      // @ts-expect-error Type 'PopulateDocumentResult<Document<unknown, {}, ArrayParent, {}, DefaultSchemaOptions> & ArrayParent...'
+      const hydratedDoc: mongoose.HydratedDocFromModel<typeof ArrayParentModel> = populatedDoc;
+      ExpectAssignable<Document<any>>()(populatedDoc);
+      ExpectAssignable<Document<unknown>>()(populatedDoc);
+      ExpectType<string | undefined>(populatedDoc.children[0]?.name);
+      const plainObject = populatedDoc.toObject();
+      ExpectType<string>(plainObject.children[0].name);
+      const depopulatedObject = populatedDoc.toObject({ depopulate: true });
+      ExpectType<Types.ObjectId>(depopulatedObject.children![0]);
+    });
+
+  interface MultiPopulateParent {
+    firstChild?: Types.ObjectId;
+    secondChild?: Types.ObjectId;
+  }
+
+  const MultiPopulateParentModel = model<MultiPopulateParent>(
+    'MultiPopulateParent',
+    new Schema({
+      firstChild: { type: Schema.Types.ObjectId, ref: 'Child' },
+      secondChild: { type: Schema.Types.ObjectId, ref: 'Child' }
+    })
+  );
+
+  type PopulatedFirstChild = {
+    firstChild: mongoose.HydratedDocFromModel<typeof ChildModel>;
+  };
+
+  type PopulatedSecondChild = {
+    secondChild: mongoose.HydratedDocFromModel<typeof ChildModel>;
+  };
+
+  MultiPopulateParentModel.findOne({})
+    .populate<PopulatedFirstChild>('firstChild')
+    .populate<PopulatedSecondChild>('secondChild')
+    .orFail()
+    .then(populatedDoc => {
+      ExpectType<string | undefined>(populatedDoc.firstChild?.name);
+      ExpectType<string | undefined>(populatedDoc.secondChild?.name);
+      const plainObject = populatedDoc.toObject();
+      ExpectType<string>(plainObject.firstChild!.name);
+      ExpectType<string>(plainObject.secondChild!.name);
+      const depopulatedObject = populatedDoc.toObject({ depopulate: true });
+      ExpectType<Types.ObjectId>(depopulatedObject.firstChild!);
+      ExpectType<Types.ObjectId>(depopulatedObject.secondChild!);
+    });
 }
 
 async function gh14574() {
diff --git a/types/document.d.ts b/types/document.d.ts
index bfe8c8357d..77af4e3366 100644
--- a/types/document.d.ts
+++ b/types/document.d.ts
@@ -32,7 +32,7 @@ declare module 'mongoose' {
     _id: T;
 
     /** Assert that a given path or paths is populated. Throws an error if not populated. */
-    $assertPopulated<Paths = {}>(path: string | string[], values?: Partial<Paths>): Omit<this, keyof Paths> & Paths;
+    $assertPopulated<Paths = {}>(path: string | string[], values?: Partial<Paths>): PopulateDocumentResult<this, Paths, PopulatedPathsDocumentType<DocType, Paths>, DocType>;
 
     /** Clear the document's modified paths. */
     $clearModifiedPaths(): this;
@@ -238,8 +238,8 @@ declare module 'mongoose' {
     $parent(): Document | undefined;
 
     /** Populates document references. */
-    populate<Paths = {}>(path: string | PopulateOptions | (string | PopulateOptions)[]): Promise<MergeType<this, Paths>>;
-    populate<Paths = {}>(path: string, select?: string | AnyObject, model?: Model<any>, match?: AnyObject, options?: PopulateOptions): Promise<MergeType<this, Paths>>;
+    populate<Paths = {}>(path: string | PopulateOptions | (string | PopulateOptions)[]): Promise<PopulateDocumentResult<this, Paths, PopulatedPathsDocumentType<DocType, Paths>, DocType>>;
+    populate<Paths = {}>(path: string, select?: string | AnyObject, model?: Model<any>, match?: AnyObject, options?: PopulateOptions): Promise<PopulateDocumentResult<this, Paths, PopulatedPathsDocumentType<DocType, Paths>, DocType>>;
 
     /** Gets _id(s) used during population of the given `path`. If the path was not populated, returns `undefined`. */
     populated(path: string): any;
@@ -262,11 +262,41 @@ declare module 'mongoose' {
     toBSON(): Require_id<DocType>;
 
     /** The return value of this method is used in calls to JSON.stringify(doc). */
+    toJSON<PopulatedRawDocType, DepopulatedRawDocType>(
+      this: PopulatedDocumentMarker<PopulatedRawDocType, DepopulatedRawDocType>,
+      options: { depopulate: true }
+    ): Default__v<Require_id<DepopulatedRawDocType>, TSchemaOptions>;
+    toJSON<PopulatedRawDocType, DepopulatedRawDocType, O extends ToObjectOptions & { depopulate: true }>(
+      this: PopulatedDocumentMarker<PopulatedRawDocType, DepopulatedRawDocType>,
+      options: O
+    ): ToObjectReturnType<DepopulatedRawDocType, TVirtuals, O, TSchemaOptions>;
+    toJSON<PopulatedRawDocType, O extends ToObjectOptions>(
+      this: PopulatedDocumentMarker<PopulatedRawDocType, any>,
+      options: O
+    ): ToObjectReturnType<PopulatedRawDocType, TVirtuals, O, TSchemaOptions>;
+    toJSON<PopulatedRawDocType>(
+      this: PopulatedDocumentMarker<PopulatedRawDocType, any>
+    ): Default__v<Require_id<PopulatedRawDocType>, TSchemaOptions>;
     toJSON<O extends ToObjectOptions>(options: O): ToObjectReturnType<DocType, TVirtuals, O, TSchemaOptions>;
     toJSON(options?: ToObjectOptions): Default__v<Require_id<DocType>, TSchemaOptions>;
     toJSON<T>(options?: ToObjectOptions): Default__v<Require_id<T>, ResolveSchemaOptions<TSchemaOptions>>;
 
     /** Converts this document into a plain-old JavaScript object ([POJO](https://masteringjs.io/tutorials/fundamentals/pojo)). */
+    toObject<PopulatedRawDocType, DepopulatedRawDocType>(
+      this: PopulatedDocumentMarker<PopulatedRawDocType, DepopulatedRawDocType>,
+      options: { depopulate: true }
+    ): Default__v<Require_id<DepopulatedRawDocType>, TSchemaOptions>;
+    toObject<PopulatedRawDocType, DepopulatedRawDocType, O extends ToObjectOptions & { depopulate: true }>(
+      this: PopulatedDocumentMarker<PopulatedRawDocType, DepopulatedRawDocType>,
+      options: O
+    ): ToObjectReturnType<DepopulatedRawDocType, TVirtuals, O, TSchemaOptions>;
+    toObject<PopulatedRawDocType, O extends ToObjectOptions>(
+      this: PopulatedDocumentMarker<PopulatedRawDocType, any>,
+      options: O
+    ): ToObjectReturnType<PopulatedRawDocType, TVirtuals, O, TSchemaOptions>;
+    toObject<PopulatedRawDocType>(
+      this: PopulatedDocumentMarker<PopulatedRawDocType, any>
+    ): Default__v<Require_id<PopulatedRawDocType>, TSchemaOptions>;
     toObject<O extends ToObjectOptions>(options: O): ToObjectReturnType<DocType, TVirtuals, O, TSchemaOptions>;
     toObject(options?: ToObjectOptions): Default__v<Require_id<DocType>, TSchemaOptions>;
     toObject<T>(options?: ToObjectOptions): Default__v<Require_id<T>, ResolveSchemaOptions<TSchemaOptions>>;
diff --git a/types/index.d.ts b/types/index.d.ts
index 4b30322868..99f69fcc58 100644
--- a/types/index.d.ts
+++ b/types/index.d.ts
@@ -1088,6 +1088,9 @@ declare module 'mongoose' {
     // Handle DocumentArray - recurse into items
     : T extends Types.DocumentArray<infer ItemType>
       ? Types.DocumentArray<ApplyFlattenTransforms<ItemType, O>>
+    // Handle plain arrays - recurse into items
+    : T extends Array<infer ItemType>
+      ? ApplyFlattenTransforms<ItemType, O>[]
     // Handle Subdocument - recurse into subdoc type
     : T extends Types.Subdocument<unknown, unknown, infer SubdocType>
       ? HydratedSingleSubdocument<ApplyFlattenTransforms<SubdocType, O>>
diff --git a/types/models.d.ts b/types/models.d.ts
index 9de93b8d2c..ff99e26301 100644
--- a/types/models.d.ts
+++ b/types/models.d.ts
@@ -628,10 +628,10 @@ declare module 'mongoose' {
     populate<Paths>(
       docs: Array<any>,
       options: PopulateOptions | Array<PopulateOptions> | string
-    ): Promise<Array<MergeType<THydratedDocumentType, Paths>>>;
+    ): Promise<Array<PopulateDocumentResult<THydratedDocumentType, Paths, PopulatedPathsDocumentType<TRawDocType, Paths>, TRawDocType>>>;
     populate<Paths>(
       doc: any, options: PopulateOptions | Array<PopulateOptions> | string
-    ): Promise<MergeType<THydratedDocumentType, Paths>>;
+    ): Promise<PopulateDocumentResult<THydratedDocumentType, Paths, PopulatedPathsDocumentType<TRawDocType, Paths>, TRawDocType>>;
 
     /**
      * Update an existing [Atlas search index](https://www.mongodb.com/docs/atlas/atlas-search/create-index/).
diff --git a/types/populate.d.ts b/types/populate.d.ts
index dac2a24821..aa96d0b328 100644
--- a/types/populate.d.ts
+++ b/types/populate.d.ts
@@ -8,6 +8,50 @@ declare module 'mongoose' {
     RawId extends RefType = (PopulatedType extends { _id?: RefType; } ? NonNullable<PopulatedType['_id']> : Types.ObjectId) | undefined
   > = PopulatedType | RawId;
 
+  const mongoosePopulatedDocumentMarker: unique symbol;
+
+  type ExtractDocumentObjectType<T> = T extends infer ObjectType & Document ? FlatRecord<ObjectType> : T;
+
+  type PopulatePathToRawDocType<T> =
+    T extends Types.DocumentArray<any, infer ItemType>
+      ? PopulatePathToRawDocType<ItemType>[]
+      : T extends Array<infer ItemType>
+        ? PopulatePathToRawDocType<ItemType>[]
+        : T extends Document
+          ? SubdocsToPOJOs<ExtractDocumentObjectType<T>>
+          : T extends Record<string, any>
+            ? { [K in keyof T]: PopulatePathToRawDocType<T[K]> }
+            : T;
+
+  type PopulatedPathsDocumentType<RawDocType, Paths> = UnpackedIntersection<RawDocType, PopulatePathToRawDocType<Paths>>;
+
+  type PopulatedDocumentMarker<
+    PopulatedRawDocType,
+    DepopulatedRawDocType,
+  > = {
+    [mongoosePopulatedDocumentMarker]?: {
+      populated: PopulatedRawDocType,
+      depopulated: DepopulatedRawDocType
+    }
+  };
+
+  type ResolvePopulatedRawDocType<
+    ThisType,
+    FallbackRawDocType,
+    O = never
+  > = ThisType extends PopulatedDocumentMarker<infer PopulatedRawDocType, infer DepopulatedRawDocType>
+    ? O extends { depopulate: true }
+      ? DepopulatedRawDocType
+      : PopulatedRawDocType
+    : FallbackRawDocType;
+
+  type PopulateDocumentResult<
+    Doc,
+    Paths,
+    PopulatedRawDocType,
+    DepopulatedRawDocType = PopulatedRawDocType
+  > = MergeType<Doc, Paths> & PopulatedDocumentMarker<PopulatedRawDocType, DepopulatedRawDocType>;
+
   interface PopulateOptions {
     /** space delimited path(s) to populate */
     path: string;
diff --git a/types/query.d.ts b/types/query.d.ts
index d4874350d5..3bcd6cc858 100644
--- a/types/query.d.ts
+++ b/types/query.d.ts
@@ -201,10 +201,10 @@ declare module 'mongoose' {
       ? ResultType
       : ResultType extends (infer U)[]
         ? U extends Document
-          ? HydratedDocument<MergeType<RawDocType, Paths>, TDocOverrides, TQueryHelpers>[]
+          ? PopulateDocumentResult<U, Paths, MergeType<RawDocType, Paths>, RawDocType>[]
           : (MergeType<U, Paths>)[]
         : ResultType extends Document
-          ? HydratedDocument<MergeType<RawDocType, Paths>, TDocOverrides, TQueryHelpers>
+          ? PopulateDocumentResult<ResultType, Paths, MergeType<RawDocType, Paths>, RawDocType>
           : MergeType<ResultType, Paths>
     : MergeType<ResultType, Paths>;