diff --git a/test/types/lean.test.ts b/test/types/lean.test.ts
index a35d0f7ad0..eb8196412a 100644
--- a/test/types/lean.test.ts
+++ b/test/types/lean.test.ts
@@ -144,6 +144,24 @@ async function gh13010() {
   expectType<Record<string, string>>(country.name);
 }
 
+async function gh13010_1() {
+  const schema = Schema.create({
+    name: { required: true, type: Map, of: String }
+  });
+
+  const CountryModel = model('Country', schema);
+
+  await CountryModel.create({
+    name: {
+      en: 'Croatia',
+      ru: 'Хорватия'
+    }
+  });
+
+  const country = await CountryModel.findOne().lean().orFail().exec();
+  expectType<Record<string, string | undefined>>(country.name);
+}
+
 async function gh13345_1() {
   const imageSchema = new Schema({
     url: { required: true, type: String }
diff --git a/test/types/maps.test.ts b/test/types/maps.test.ts
index 69cd016c74..7817373456 100644
--- a/test/types/maps.test.ts
+++ b/test/types/maps.test.ts
@@ -70,7 +70,7 @@ function gh10575() {
 function gh10872(): void {
   const doc = new Test({});
 
-  doc.toJSON().map1.foo;
+  doc.toJSON({ flattenMaps: true }).map1.foo;
 }
 
 function gh13755() {
diff --git a/test/types/models.test.ts b/test/types/models.test.ts
index d7474e61ef..f6d4f73908 100644
--- a/test/types/models.test.ts
+++ b/test/types/models.test.ts
@@ -16,7 +16,8 @@ import mongoose, {
   WithLevel1NestedPaths,
   createConnection,
   connection,
-  model
+  model,
+  ObtainSchemaGeneric
 } from 'mongoose';
 import { expectAssignable, expectError, expectType } from 'tsd';
 import { AutoTypedSchemaType, autoTypedSchema } from './schema.test';
@@ -575,12 +576,14 @@ async function gh12319() {
   );
 
   const ProjectModel = model('Project', projectSchema);
+  const doc = new ProjectModel();
+  doc.doSomething();
 
   type ProjectModelHydratedDoc = HydratedDocumentFromSchema<
     typeof projectSchema
   >;
 
-  expectType<ProjectModelHydratedDoc>(await ProjectModel.findOne().orFail());
+  expectAssignable<ProjectModelHydratedDoc>(await ProjectModel.findOne().orFail());
 }
 
 function findWithId() {
diff --git a/test/types/schema.create.test.ts b/test/types/schema.create.test.ts
index 5ade3ab253..a839860e0a 100644
--- a/test/types/schema.create.test.ts
+++ b/test/types/schema.create.test.ts
@@ -415,8 +415,8 @@ export function autoTypedSchema() {
     objectId2?: Types.ObjectId | null;
     objectId3?: Types.ObjectId | null;
     customSchema?: Int8 | null;
-    map1?: Map<string, string> | null;
-    map2?: Map<string, number> | null;
+    map1?: Record<string, string | undefined> | null;
+    map2?: Record<string, number | undefined> | null;
     array1: string[];
     array2: any[];
     array3: any[];
@@ -736,17 +736,26 @@ function gh12030() {
     } & { _id: Types.ObjectId }>;
   } & { _id: Types.ObjectId }>({} as InferSchemaType<typeof Schema3>);
 
+  type RawDocType3 = ObtainSchemaGeneric<typeof Schema3, 'DocType'>;
   type HydratedDoc3 = ObtainSchemaGeneric<typeof Schema3, 'THydratedDocumentType'>;
   expectType<
     HydratedDocument<{
       users: Types.DocumentArray<
         { credit: number; username?: string | null; } & { _id: Types.ObjectId },
-        Types.Subdocument<Types.ObjectId, unknown, { credit: number; username?: string | null; } & { _id: Types.ObjectId }> & { credit: number; username?: string | null; } & { _id: Types.ObjectId }
+        Types.Subdocument<
+          Types.ObjectId,
+          unknown,
+          { credit: number; username?: string | null; } & { _id: Types.ObjectId }
+        > & { credit: number; username?: string | null; } & { _id: Types.ObjectId }
       >;
-    } & { _id: Types.ObjectId }>
+    } & { _id: Types.ObjectId }, {}, {}, {}, RawDocType3>
   >({} as HydratedDoc3);
   expectType<
-    Types.Subdocument<Types.ObjectId, unknown, { credit: number; username?: string | null; } & { _id: Types.ObjectId }> & { credit: number; username?: string | null; } & { _id: Types.ObjectId }
+    Types.Subdocument<
+      Types.ObjectId,
+      unknown,
+      { credit: number; username?: string | null; } & { _id: Types.ObjectId }
+    > & { credit: number; username?: string | null; } & { _id: Types.ObjectId }
   >({} as HydratedDoc3['users'][0]);
 
   const Schema4 = Schema.create({
@@ -1166,6 +1175,9 @@ function maps() {
   const doc = new Test({ myMap: { answer: 42 } });
   expectType<Map<string, number>>(doc.myMap);
   expectType<number | undefined>(doc.myMap!.get('answer'));
+
+  const obj = doc.toObject();
+  expectType<Record<string, number | undefined>>(obj.myMap);
 }
 
 function gh13514() {
@@ -1699,7 +1711,12 @@ async function gh14950() {
   const doc = await TestModel.findOne().orFail();
 
   expectType<string>(doc.location!.type);
-  expectType<number[]>(doc.location!.coordinates);
+  expectType<Types.Array<number>>(doc.location!.coordinates);
+
+  const lean = await TestModel.findOne().lean().orFail();
+
+  expectType<string>(lean.location!.type);
+  expectType<number[]>(lean.location!.coordinates);
 }
 
 async function gh14902() {
@@ -1750,7 +1767,7 @@ async function gh14451() {
       subdocProp?: string | undefined | null
     } | null,
     docArr: { nums: number[], times: string[] }[],
-    myMap?: Record<string, string> | null | undefined,
+    myMap?: Record<string, string | undefined> | null | undefined,
     _id: string
   }>({} as TestJSON);
 }
@@ -1860,7 +1877,7 @@ function testInferRawDocTypeFromSchema() {
     arr: number[],
     docArr: ({ name: string } & { _id: Types.ObjectId })[],
     subdoc?: ({ answer: number } & { _id: Types.ObjectId }) | null | undefined,
-    map?: Map<string, string> | null | undefined
+    map?: Record<string, string | undefined> | null | undefined;
   } & { _id: Types.ObjectId };
 
   expectType<Expected>({} as RawDocType);
diff --git a/types/document.d.ts b/types/document.d.ts
index ea2798566c..33dbb2a5c7 100644
--- a/types/document.d.ts
+++ b/types/document.d.ts
@@ -256,23 +256,34 @@ declare module 'mongoose' {
     set(value: string | Record<string, any>): this;
 
     /** The return value of this method is used in calls to JSON.stringify(doc). */
+    toJSON(options: ToObjectOptions & { flattenMaps: true, flattenObjectIds: true, virtuals: true }): FlattenMaps<ObjectIdToString<Default__v<Require_id<DocType & TVirtuals>>>>;
+    toJSON(options: ToObjectOptions & { flattenMaps: true, flattenObjectIds: true }): FlattenMaps<ObjectIdToString<Default__v<Require_id<DocType>>>>;
+    toJSON(options: ToObjectOptions & { flattenMaps: true, virtuals: true }): FlattenMaps<Default__v<Require_id<DocType & TVirtuals>>>;
+    toJSON(options: ToObjectOptions & { flattenObjectIds: true, virtuals: true }): ObjectIdToString<Default__v<Require_id<DocType & TVirtuals>>>;
+    toJSON(options: ToObjectOptions & { flattenMaps: true }): FlattenMaps<Default__v<Require_id<DocType>>>;
+    toJSON(options: ToObjectOptions & { flattenObjectIds: true }): ObjectIdToString<Default__v<Require_id<DocType>>>;
     toJSON(options: ToObjectOptions & { virtuals: true }): Default__v<Require_id<DocType & TVirtuals>>;
-    toJSON(options?: ToObjectOptions & { flattenMaps?: true, flattenObjectIds?: false }): FlattenMaps<Default__v<Require_id<DocType>>>;
-    toJSON(options: ToObjectOptions & { flattenObjectIds: false }): FlattenMaps<Default__v<Require_id<DocType>>>;
-    toJSON(options: ToObjectOptions & { flattenObjectIds: true }): ObjectIdToString<FlattenMaps<Default__v<Require_id<DocType>>>>;
-    toJSON(options: ToObjectOptions & { flattenMaps: false }): Default__v<Require_id<DocType>>;
-    toJSON(options: ToObjectOptions & { flattenMaps: false; flattenObjectIds: true }): ObjectIdToString<Default__v<Require_id<DocType>>>;
-
-    toJSON<T = Default__v<Require_id<DocType>>>(options?: ToObjectOptions & { flattenMaps?: true, flattenObjectIds?: false }): FlattenMaps<T>;
-    toJSON<T = Default__v<Require_id<DocType>>>(options: ToObjectOptions & { flattenObjectIds: false }): FlattenMaps<T>;
-    toJSON<T = Default__v<Require_id<DocType>>>(options: ToObjectOptions & { flattenObjectIds: true }): ObjectIdToString<FlattenMaps<T>>;
-    toJSON<T = Default__v<Require_id<DocType>>>(options: ToObjectOptions & { flattenMaps: false }): T;
-    toJSON<T = Default__v<Require_id<DocType>>>(options: ToObjectOptions & { flattenMaps: false; flattenObjectIds: true }): ObjectIdToString<T>;
+    toJSON(options?: ToObjectOptions): Default__v<Require_id<DocType>>;
+
+    toJSON<T = Default__v<Require_id<DocType>>>(options: ToObjectOptions & { flattenMaps: true, flattenObjectIds: true }): FlattenMaps<ObjectIdToString<T>>;
+    toJSON<T = Default__v<Require_id<DocType>>>(options: ToObjectOptions & { flattenObjectIds: true }): ObjectIdToString<T>;
+    toJSON<T = Default__v<Require_id<DocType>>>(options: ToObjectOptions & { flattenMaps: true }): FlattenMaps<T>;
+    toJSON<T = Default__v<Require_id<DocType>>>(options?: ToObjectOptions): T;
 
     /** Converts this document into a plain-old JavaScript object ([POJO](https://masteringjs.io/tutorials/fundamentals/pojo)). */
+    toObject(options: ToObjectOptions & { flattenMaps: true, flattenObjectIds: true, virtuals: true }): FlattenMaps<ObjectIdToString<Default__v<Require_id<DocType & TVirtuals>>>>;
+    toObject(options: ToObjectOptions & { flattenMaps: true, flattenObjectIds: true }): FlattenMaps<ObjectIdToString<Default__v<Require_id<DocType>>>>;
+    toObject(options: ToObjectOptions & { flattenMaps: true, virtuals: true }): FlattenMaps<Default__v<Require_id<DocType & TVirtuals>>>;
+    toObject(options: ToObjectOptions & { flattenObjectIds: true, virtuals: true }): ObjectIdToString<Default__v<Require_id<DocType & TVirtuals>>>;
+    toObject(options: ToObjectOptions & { flattenMaps: true }): FlattenMaps<Default__v<Require_id<DocType>>>;
+    toObject(options: ToObjectOptions & { flattenObjectIds: true }): ObjectIdToString<Default__v<Require_id<DocType>>>;
     toObject(options: ToObjectOptions & { virtuals: true }): Default__v<Require_id<DocType & TVirtuals>>;
     toObject(options?: ToObjectOptions): Default__v<Require_id<DocType>>;
-    toObject<T>(options?: ToObjectOptions): Default__v<Require_id<T>>;
+
+    toObject<T = Default__v<Require_id<DocType>>>(options: ToObjectOptions & { flattenMaps: true, flattenObjectIds: true }): FlattenMaps<ObjectIdToString<T>>;
+    toObject<T = Default__v<Require_id<DocType>>>(options: ToObjectOptions & { flattenObjectIds: true }): ObjectIdToString<T>;
+    toObject<T = Default__v<Require_id<DocType>>>(options: ToObjectOptions & { flattenMaps: true }): FlattenMaps<T>;
+    toObject<T = Default__v<Require_id<DocType>>>(options?: ToObjectOptions): T;
 
     /** Clears the modified state on the specified path. */
     unmarkModified<T extends keyof DocType>(path: T): void;
diff --git a/types/index.d.ts b/types/index.d.ts
index adf91ef2d6..a18c30e599 100644
--- a/types/index.d.ts
+++ b/types/index.d.ts
@@ -85,17 +85,22 @@ declare module 'mongoose' {
     collection?: string,
     options?: CompileModelOptions
   ): Model<
-  InferSchemaType<TSchema>,
-  ObtainSchemaGeneric<TSchema, 'TQueryHelpers'>,
-  ObtainSchemaGeneric<TSchema, 'TInstanceMethods'>,
-  ObtainSchemaGeneric<TSchema, 'TVirtuals'>,
-  HydratedDocument<
-  InferSchemaType<TSchema>,
-  ObtainSchemaGeneric<TSchema, 'TVirtuals'> & ObtainSchemaGeneric<TSchema, 'TInstanceMethods'>,
-  ObtainSchemaGeneric<TSchema, 'TQueryHelpers'>,
-  ObtainSchemaGeneric<TSchema, 'TVirtuals'>
-  >,
-  TSchema
+    InferSchemaType<TSchema>,
+    ObtainSchemaGeneric<TSchema, 'TQueryHelpers'>,
+    ObtainSchemaGeneric<TSchema, 'TInstanceMethods'>,
+    ObtainSchemaGeneric<TSchema, 'TVirtuals'>,
+    // If first schema generic param is set, that means we have an explicit raw doc type,
+    // so user should also specify a hydrated doc type if the auto inferred one isn't correct.
+    IsItRecordAndNotAny<ObtainSchemaGeneric<TSchema, 'EnforcedDocType'>> extends true
+      ? ObtainSchemaGeneric<TSchema, 'THydratedDocumentType'>
+      : HydratedDocument<
+        InferSchemaType<TSchema>,
+        ObtainSchemaGeneric<TSchema, 'TVirtuals'> & ObtainSchemaGeneric<TSchema, 'TInstanceMethods'>,
+        ObtainSchemaGeneric<TSchema, 'TQueryHelpers'>,
+        ObtainSchemaGeneric<TSchema, 'TVirtuals'>
+      >,
+    TSchema,
+    ObtainSchemaGeneric<TSchema, 'TLeanResultType'>
   > & ObtainSchemaGeneric<TSchema, 'TStaticMethods'>;
 
   export function model<T>(name: string, schema?: Schema<T, any, any> | Schema<T & Document, any, any>, collection?: string, options?: CompileModelOptions): Model<T>;
@@ -147,24 +152,26 @@ declare module 'mongoose' {
 
   /** Helper type for getting the hydrated document type from the raw document type. The hydrated document type is what `new MyModel()` returns. */
   export type HydratedDocument<
-    DocType,
+    HydratedDocPathsType,
     TOverrides = {},
     TQueryHelpers = {},
-    TVirtuals = {}
+    TVirtuals = {},
+    RawDocType = HydratedDocPathsType
   > = IfAny<
-    DocType,
+    HydratedDocPathsType,
     any,
     TOverrides extends Record<string, never> ?
-      Document<unknown, TQueryHelpers, DocType, TVirtuals> & Default__v<Require_id<DocType>> :
+      Document<unknown, TQueryHelpers, RawDocType, TVirtuals> & Default__v<Require_id<HydratedDocPathsType>> :
       IfAny<
         TOverrides,
-        Document<unknown, TQueryHelpers, DocType, TVirtuals> & Default__v<Require_id<DocType>>,
-        Document<unknown, TQueryHelpers, DocType, TVirtuals> & MergeType<
-          Default__v<Require_id<DocType>>,
+        Document<unknown, TQueryHelpers, RawDocType, TVirtuals> & Default__v<Require_id<HydratedDocPathsType>>,
+        Document<unknown, TQueryHelpers, RawDocType, TVirtuals> & MergeType<
+          Default__v<Require_id<HydratedDocPathsType>>,
           TOverrides
         >
       >
   >;
+
   export type HydratedSingleSubdocument<
     DocType,
     TOverrides = {}
@@ -274,8 +281,9 @@ declare module 'mongoose' {
       ObtainDocumentType<any, RawDocType, ResolveSchemaOptions<TSchemaOptions>>,
       ResolveSchemaOptions<TSchemaOptions>
     >,
-    THydratedDocumentType = HydratedDocument<FlatRecord<DocType>, TVirtuals & TInstanceMethods, {}, TVirtuals>,
-    TSchemaDefinition = SchemaDefinition<SchemaDefinitionType<RawDocType>, RawDocType, THydratedDocumentType>
+    THydratedDocumentType = HydratedDocument<DocType, TVirtuals & TInstanceMethods, {}, TVirtuals>,
+    TSchemaDefinition = SchemaDefinition<SchemaDefinitionType<RawDocType>, RawDocType, THydratedDocumentType>,
+    LeanResultType = IsItRecordAndNotAny<RawDocType> extends true ? RawDocType : Default__v<Require_id<BufferToBinary<FlattenMaps<DocType>>>>
   >
     extends events.EventEmitter {
     /**
@@ -291,7 +299,13 @@ declare module 'mongoose' {
         InferRawDocType<TSchemaDefinition, ResolveSchemaOptions<TSchemaOptions>>,
         ResolveSchemaOptions<TSchemaOptions>
       >,
-      THydratedDocumentType extends AnyObject = HydratedDocument<InferHydratedDocType<TSchemaDefinition, ResolveSchemaOptions<TSchemaOptions>>>
+      THydratedDocumentType extends AnyObject = HydratedDocument<
+        InferHydratedDocType<TSchemaDefinition, ResolveSchemaOptions<TSchemaOptions>>,
+        TSchemaOptions extends { methods: infer M } ? M : {},
+        TSchemaOptions extends { query: any } ? TSchemaOptions['query'] : {},
+        TSchemaOptions extends { virtuals: any } ? TSchemaOptions['virtuals'] : {},
+        RawDocType
+      >
     >(def: TSchemaDefinition): Schema<
       RawDocType,
       Model<RawDocType, any, any, any>,
@@ -305,7 +319,11 @@ declare module 'mongoose' {
         ResolveSchemaOptions<TSchemaOptions>
       >,
       THydratedDocumentType,
-      TSchemaDefinition
+      TSchemaDefinition,
+      ApplySchemaOptions<
+        InferRawDocType<TSchemaDefinition, ResolveSchemaOptions<TSchemaOptions>, { bufferToBinary: true }>,
+        ResolveSchemaOptions<TSchemaOptions>
+      >
     >;
 
     static create<
@@ -329,7 +347,11 @@ declare module 'mongoose' {
         ResolveSchemaOptions<TSchemaOptions>
       >,
       THydratedDocumentType,
-      TSchemaDefinition
+      TSchemaDefinition,
+      ApplySchemaOptions<
+        InferRawDocType<TSchemaDefinition, ResolveSchemaOptions<TSchemaOptions>, { bufferToBinary: true }>,
+        ResolveSchemaOptions<TSchemaOptions>
+      >
     >;
 
     /** Adds key path / schema type pairs to this schema. */
diff --git a/types/inferrawdoctype.d.ts b/types/inferrawdoctype.d.ts
index 1fa67b0f9f..c5bf201ddf 100644
--- a/types/inferrawdoctype.d.ts
+++ b/types/inferrawdoctype.d.ts
@@ -6,7 +6,7 @@ import {
   PathWithTypePropertyBaseType,
   PathEnumOrString
 } from './inferschematype';
-import { UUID } from 'mongodb';
+import { Binary, UUID } from 'mongodb';
 
 declare module 'mongoose' {
   export type InferRawDocTypeFromSchema<TSchema extends Schema<any>> = IsItRecordAndNotAny<ObtainSchemaGeneric<TSchema, 'EnforcedDocType'>> extends true
@@ -14,15 +14,16 @@ declare module 'mongoose' {
     : FlattenMaps<SubdocsToPOJOs<ObtainSchemaGeneric<TSchema, 'DocType'>>>;
 
   export type InferRawDocType<
-    DocDefinition,
-    TSchemaOptions extends Record<any, any> = DefaultSchemaOptions
+    SchemaDefinition,
+    TSchemaOptions extends Record<any, any> = DefaultSchemaOptions,
+    TTransformOptions = { bufferToBinary: false }
   > = Require_id<ApplySchemaOptions<{
     [
-    K in keyof (RequiredPaths<DocDefinition, TSchemaOptions['typeKey']> &
-    OptionalPaths<DocDefinition, TSchemaOptions['typeKey']>)
-    ]: IsPathRequired<DocDefinition[K], TSchemaOptions['typeKey']> extends true
-      ? ObtainRawDocumentPathType<DocDefinition[K], TSchemaOptions['typeKey']>
-      : ObtainRawDocumentPathType<DocDefinition[K], TSchemaOptions['typeKey']> | null;
+    K in keyof (RequiredPaths<SchemaDefinition, TSchemaOptions['typeKey']> &
+    OptionalPaths<SchemaDefinition, TSchemaOptions['typeKey']>)
+    ]: IsPathRequired<SchemaDefinition[K], TSchemaOptions['typeKey']> extends true
+      ? ObtainRawDocumentPathType<SchemaDefinition[K], TSchemaOptions['typeKey'], TTransformOptions>
+      : ObtainRawDocumentPathType<SchemaDefinition[K], TSchemaOptions['typeKey'], TTransformOptions> | null;
   }, TSchemaOptions>>;
 
   /**
@@ -38,7 +39,8 @@ declare module 'mongoose' {
    */
   type ObtainRawDocumentPathType<
     PathValueType,
-    TypeKey extends string = DefaultTypeKey
+    TypeKey extends string = DefaultTypeKey,
+    TTransformOptions = { bufferToBinary: false }
   > = ResolveRawPathType<
     PathValueType extends PathWithTypePropertyBaseType<TypeKey>
       ? PathValueType[TypeKey] extends PathWithTypePropertyBaseType<TypeKey>
@@ -51,6 +53,7 @@ declare module 'mongoose' {
         : Omit<PathValueType, TypeKey>
       : {},
     TypeKey,
+    TTransformOptions,
     RawDocTypeHint<PathValueType>
   >;
 
@@ -67,44 +70,44 @@ declare module 'mongoose' {
    * @param {TypeKey} TypeKey A generic of literal string type."Refers to the property used for path type definition".
    * @returns Number, "Number" or "number" will be resolved to number type.
    */
-  type ResolveRawPathType<PathValueType, Options extends SchemaTypeOptions<PathValueType> = {}, TypeKey extends string = DefaultSchemaOptions['typeKey'], TypeHint = never> =
+  type ResolveRawPathType<PathValueType, Options extends SchemaTypeOptions<PathValueType> = {}, TypeKey extends string = DefaultSchemaOptions['typeKey'], TTransformOptions = { bufferToBinary: false }, TypeHint = never> =
   IfEquals<TypeHint, never,
     PathValueType extends Schema<infer RawDocType, any, any, any, any, any, any, any, any, infer TSchemaDefinition> ?
-      IsItRecordAndNotAny<RawDocType> extends true ? RawDocType : InferRawDocType<TSchemaDefinition> :
+      IsItRecordAndNotAny<RawDocType> extends true ? RawDocType : InferRawDocType<TSchemaDefinition, DefaultSchemaOptions, TTransformOptions> :
       PathValueType extends (infer Item)[] ?
         IfEquals<Item, never, any[], Item extends Schema<infer RawDocType, any, any, any, any, any, any, any, any, infer TSchemaDefinition> ?
           // If Item is a schema, infer its type.
-          Array<IsItRecordAndNotAny<RawDocType> extends true ? RawDocType : InferRawDocType<TSchemaDefinition>> :
+          Array<IsItRecordAndNotAny<RawDocType> extends true ? RawDocType : InferRawDocType<TSchemaDefinition, DefaultSchemaOptions, TTransformOptions>> :
           Item extends Record<TypeKey, any> ?
             Item[TypeKey] extends Function | String ?
               // If Item has a type key that's a string or a callable, it must be a scalar,
               // so we can directly obtain its path type.
-              ObtainRawDocumentPathType<Item, TypeKey>[] :
+              ObtainRawDocumentPathType<Item, TypeKey, TTransformOptions>[] :
               // If the type key isn't callable, then this is an array of objects, in which case
               // we need to call InferRawDocType to correctly infer its type.
-              Array<InferRawDocType<Item>> :
+              Array<InferRawDocType<Item, DefaultSchemaOptions, TTransformOptions>> :
             IsSchemaTypeFromBuiltinClass<Item> extends true ?
-              ObtainRawDocumentPathType<Item, TypeKey>[] :
+              ObtainRawDocumentPathType<Item, TypeKey, TTransformOptions>[] :
               IsItRecordAndNotAny<Item> extends true ?
                 Item extends Record<string, never> ?
-                  ObtainRawDocumentPathType<Item, TypeKey>[] :
-                  Array<InferRawDocType<Item>> :
-                ObtainRawDocumentPathType<Item, TypeKey>[]
+                  ObtainRawDocumentPathType<Item, TypeKey, TTransformOptions>[] :
+                  Array<InferRawDocType<Item, DefaultSchemaOptions, TTransformOptions>> :
+                ObtainRawDocumentPathType<Item, TypeKey, TTransformOptions>[]
         >:
         PathValueType extends ReadonlyArray<infer Item> ?
           IfEquals<Item, never, any[], Item extends Schema<infer RawDocType, any, any, any, any, any, any, any, any, infer TSchemaDefinition> ?
-            Array<IsItRecordAndNotAny<RawDocType> extends true ? RawDocType : InferRawDocType<TSchemaDefinition>> :
+            Array<IsItRecordAndNotAny<RawDocType> extends true ? RawDocType : InferRawDocType<TSchemaDefinition, DefaultSchemaOptions, TTransformOptions>> :
             Item extends Record<TypeKey, any> ?
               Item[TypeKey] extends Function | String ?
-                ObtainRawDocumentPathType<Item, TypeKey>[] :
-                InferRawDocType<Item>[]:
+                ObtainRawDocumentPathType<Item, TypeKey, TTransformOptions>[] :
+                InferRawDocType<Item, DefaultSchemaOptions, TTransformOptions>[]:
               IsSchemaTypeFromBuiltinClass<Item> extends true ?
-                ObtainRawDocumentPathType<Item, TypeKey>[] :
+                ObtainRawDocumentPathType<Item, TypeKey, TTransformOptions>[] :
                 IsItRecordAndNotAny<Item> extends true ?
                   Item extends Record<string, never> ?
-                    ObtainRawDocumentPathType<Item, TypeKey>[] :
-                    Array<InferRawDocType<Item>> :
-                  ObtainRawDocumentPathType<Item, TypeKey>[]
+                    ObtainRawDocumentPathType<Item, TypeKey, TTransformOptions>[] :
+                    Array<InferRawDocType<Item, DefaultSchemaOptions, TTransformOptions>> :
+                  ObtainRawDocumentPathType<Item, TypeKey, TTransformOptions>[]
           >:
           PathValueType extends StringSchemaDefinition ? PathEnumOrString<Options['enum']> :
             IfEquals<PathValueType, Schema.Types.String> extends true ? PathEnumOrString<Options['enum']> :
@@ -113,7 +116,7 @@ declare module 'mongoose' {
                   IfEquals<PathValueType, Schema.Types.Number> extends true ? number :
                     PathValueType extends DateSchemaDefinition ? NativeDate :
                       IfEquals<PathValueType, Schema.Types.Date> extends true ? NativeDate :
-                        PathValueType extends typeof Buffer | 'buffer' | 'Buffer' | typeof Schema.Types.Buffer ? Buffer :
+                        PathValueType extends typeof Buffer | 'buffer' | 'Buffer' | typeof Schema.Types.Buffer ? TTransformOptions extends { bufferToBinary: true } ? Binary : Buffer :
                           PathValueType extends BooleanSchemaDefinition ? boolean :
                             IfEquals<PathValueType, Schema.Types.Boolean> extends true ? boolean :
                               PathValueType extends ObjectIdSchemaDefinition ? Types.ObjectId :
@@ -127,15 +130,15 @@ declare module 'mongoose' {
                                               PathValueType extends 'bigint' | 'BigInt' | typeof Schema.Types.BigInt | typeof BigInt ? bigint :
                                                 PathValueType extends 'uuid' | 'UUID' | typeof Schema.Types.UUID ? UUID :
                                                   PathValueType extends 'double' | 'Double' | typeof Schema.Types.Double ? Types.Double :
-                                                    IfEquals<PathValueType, Schema.Types.UUID> extends true ? Buffer :
-                                                      PathValueType extends MapConstructor | 'Map' ? Map<string, ResolveRawPathType<Options['of']>> :
-                                                        IfEquals<PathValueType, typeof Schema.Types.Map> extends true ? Map<string, ResolveRawPathType<Options['of']>> :
+                                                    IfEquals<PathValueType, Schema.Types.UUID> extends true ? UUID :
+                                                      PathValueType extends MapConstructor | 'Map' ? Record<string, ResolveRawPathType<Options['of']> | undefined> :
+                                                        IfEquals<PathValueType, typeof Schema.Types.Map> extends true ? Record<string, ResolveRawPathType<Options['of']> | undefined> :
                                                           PathValueType extends ArrayConstructor ? any[] :
                                                             PathValueType extends typeof Schema.Types.Mixed ? any:
                                                               IfEquals<PathValueType, ObjectConstructor> extends true ? any:
                                                                 IfEquals<PathValueType, {}> extends true ? any:
                                                                   PathValueType extends typeof SchemaType ? PathValueType['prototype'] :
-                                                                    PathValueType extends Record<string, any> ? InferRawDocType<PathValueType, { typeKey: TypeKey }> :
+                                                                    PathValueType extends Record<string, any> ? InferRawDocType<PathValueType, { typeKey: TypeKey }, TTransformOptions> :
                                                                       unknown,
   TypeHint>;
 }
diff --git a/types/inferschematype.d.ts b/types/inferschematype.d.ts
index 2b01fd40c9..8149e60d37 100644
--- a/types/inferschematype.d.ts
+++ b/types/inferschematype.d.ts
@@ -56,8 +56,8 @@ declare module 'mongoose' {
    * @param {TSchema} TSchema A generic of schema type instance.
    * @param {alias} alias Targeted generic alias.
    */
-  type ObtainSchemaGeneric<TSchema, alias extends 'EnforcedDocType' | 'M' | 'TInstanceMethods' | 'TQueryHelpers' | 'TVirtuals' | 'TStaticMethods' | 'TSchemaOptions' | 'DocType' | 'THydratedDocumentType' | 'TSchemaDefinition'> =
-   TSchema extends Schema<infer EnforcedDocType, infer M, infer TInstanceMethods, infer TQueryHelpers, infer TVirtuals, infer TStaticMethods, infer TSchemaOptions, infer DocType, infer THydratedDocumentType, infer TSchemaDefinition>
+  type ObtainSchemaGeneric<TSchema, alias extends 'EnforcedDocType' | 'M' | 'TInstanceMethods' | 'TQueryHelpers' | 'TVirtuals' | 'TStaticMethods' | 'TSchemaOptions' | 'DocType' | 'THydratedDocumentType' | 'TSchemaDefinition' | 'TLeanResultType'> =
+   TSchema extends Schema<infer EnforcedDocType, infer M, infer TInstanceMethods, infer TQueryHelpers, infer TVirtuals, infer TStaticMethods, infer TSchemaOptions, infer DocType, infer THydratedDocumentType, infer TSchemaDefinition, infer TLeanResultType>
      ? {
        EnforcedDocType: EnforcedDocType;
        M: M;
@@ -69,6 +69,7 @@ declare module 'mongoose' {
        DocType: DocType;
        THydratedDocumentType: THydratedDocumentType;
        TSchemaDefinition: TSchemaDefinition;
+       TLeanResultType: TLeanResultType;
      }[alias]
      : unknown;
 
diff --git a/types/models.d.ts b/types/models.d.ts
index bc205aed74..df9ac8e6ae 100644
--- a/types/models.d.ts
+++ b/types/models.d.ts
@@ -264,7 +264,8 @@ declare module 'mongoose' {
     TInstanceMethods = {},
     TVirtuals = {},
     THydratedDocumentType = HydratedDocument<TRawDocType, TVirtuals & TInstanceMethods, TQueryHelpers, TVirtuals>,
-    TSchema = any> extends
+    TSchema = any,
+    TLeanResultType = TRawDocType> extends
     NodeJS.EventEmitter,
     AcceptsDiscriminator,
     IndexManager,
@@ -387,7 +388,7 @@ declare module 'mongoose' {
       mongodb.DeleteResult,
       THydratedDocumentType,
       TQueryHelpers,
-      TRawDocType,
+      TLeanResultType,
       'deleteMany',
       TInstanceMethods & TVirtuals
     >;
@@ -404,7 +405,7 @@ declare module 'mongoose' {
       mongodb.DeleteResult,
       THydratedDocumentType,
       TQueryHelpers,
-      TRawDocType,
+      TLeanResultType,
       'deleteOne',
       TInstanceMethods & TVirtuals
     >;
@@ -414,7 +415,7 @@ declare module 'mongoose' {
       mongodb.DeleteResult,
       THydratedDocumentType,
       TQueryHelpers,
-      TRawDocType,
+      TLeanResultType,
       'deleteOne',
       TInstanceMethods & TVirtuals
     >;
@@ -444,7 +445,7 @@ declare module 'mongoose' {
       GetLeanResultType<TRawDocType, TRawDocType, 'findOne'> | null,
       ResultDoc,
       TQueryHelpers,
-      TRawDocType,
+      TLeanResultType,
       'findOne',
       TInstanceMethods & TVirtuals
     >;
@@ -467,7 +468,7 @@ declare module 'mongoose' {
       GetLeanResultType<TRawDocType, TRawDocType, 'findOne'> | null,
       ResultDoc,
       TQueryHelpers,
-      TRawDocType,
+      TLeanResultType,
       'findOne',
       TInstanceMethods & TVirtuals
     >;
@@ -475,14 +476,14 @@ declare module 'mongoose' {
       filter?: RootFilterQuery<TRawDocType>,
       projection?: ProjectionType<TRawDocType> | null,
       options?: QueryOptions<TRawDocType> | null
-    ): QueryWithHelpers<ResultDoc | null, ResultDoc, TQueryHelpers, TRawDocType, 'findOne', TInstanceMethods & TVirtuals>;
+    ): QueryWithHelpers<ResultDoc | null, ResultDoc, TQueryHelpers, TLeanResultType, 'findOne', TInstanceMethods & TVirtuals>;
     findOne<ResultDoc = THydratedDocumentType>(
       filter?: RootFilterQuery<TRawDocType>,
       projection?: ProjectionType<TRawDocType> | null
-    ): QueryWithHelpers<ResultDoc | null, ResultDoc, TQueryHelpers, TRawDocType, 'findOne', TInstanceMethods & TVirtuals>;
+    ): QueryWithHelpers<ResultDoc | null, ResultDoc, TQueryHelpers, TLeanResultType, 'findOne', TInstanceMethods & TVirtuals>;
     findOne<ResultDoc = THydratedDocumentType>(
       filter?: RootFilterQuery<TRawDocType>
-    ): QueryWithHelpers<ResultDoc | null, ResultDoc, TQueryHelpers, TRawDocType, 'findOne', TInstanceMethods & TVirtuals>;
+    ): QueryWithHelpers<ResultDoc | null, ResultDoc, TQueryHelpers, TLeanResultType, 'findOne', TInstanceMethods & TVirtuals>;
 
     /**
      * Shortcut for creating a new Document from existing raw data, pre-saved in the DB.
@@ -659,7 +660,7 @@ declare module 'mongoose' {
       >,
       THydratedDocumentType,
       TQueryHelpers,
-      TRawDocType,
+      TLeanResultType,
       'distinct',
       TInstanceMethods & TVirtuals
     >;
@@ -669,7 +670,7 @@ declare module 'mongoose' {
       number,
       THydratedDocumentType,
       TQueryHelpers,
-      TRawDocType,
+      TLeanResultType,
       'estimatedDocumentCount',
       TInstanceMethods & TVirtuals
     >;
@@ -684,7 +685,7 @@ declare module 'mongoose' {
       { _id: InferId<TRawDocType> } | null,
       THydratedDocumentType,
       TQueryHelpers,
-      TRawDocType,
+      TLeanResultType,
       'findOne',
       TInstanceMethods & TVirtuals
     >;
@@ -698,7 +699,7 @@ declare module 'mongoose' {
       GetLeanResultType<TRawDocType, TRawDocType[], 'find'>,
       ResultDoc,
       TQueryHelpers,
-      TRawDocType,
+      TLeanResultType,
       'find',
       TInstanceMethods & TVirtuals
     >;
@@ -706,37 +707,37 @@ declare module 'mongoose' {
       filter: RootFilterQuery<TRawDocType>,
       projection?: ProjectionType<TRawDocType> | null | undefined,
       options?: QueryOptions<TRawDocType> | null | undefined
-    ): QueryWithHelpers<Array<ResultDoc>, ResultDoc, TQueryHelpers, TRawDocType, 'find', TInstanceMethods & TVirtuals>;
+    ): QueryWithHelpers<Array<ResultDoc>, ResultDoc, TQueryHelpers, TLeanResultType, 'find', TInstanceMethods & TVirtuals>;
     find<ResultDoc = THydratedDocumentType>(
       filter: RootFilterQuery<TRawDocType>,
       projection?: ProjectionType<TRawDocType> | null | undefined
-    ): QueryWithHelpers<Array<ResultDoc>, ResultDoc, TQueryHelpers, TRawDocType, 'find', TInstanceMethods & TVirtuals>;
+    ): QueryWithHelpers<Array<ResultDoc>, ResultDoc, TQueryHelpers, TLeanResultType, 'find', TInstanceMethods & TVirtuals>;
     find<ResultDoc = THydratedDocumentType>(
       filter: RootFilterQuery<TRawDocType>
-    ): QueryWithHelpers<Array<ResultDoc>, ResultDoc, TQueryHelpers, TRawDocType, 'find', TInstanceMethods & TVirtuals>;
+    ): QueryWithHelpers<Array<ResultDoc>, ResultDoc, TQueryHelpers, TLeanResultType, 'find', TInstanceMethods & TVirtuals>;
     find<ResultDoc = THydratedDocumentType>(
-    ): QueryWithHelpers<Array<ResultDoc>, ResultDoc, TQueryHelpers, TRawDocType, 'find', TInstanceMethods & TVirtuals>;
+    ): QueryWithHelpers<Array<ResultDoc>, ResultDoc, TQueryHelpers, TLeanResultType, 'find', TInstanceMethods & TVirtuals>;
 
     /** Creates a `findByIdAndDelete` query, filtering by the given `_id`. */
     findByIdAndDelete<ResultDoc = THydratedDocumentType>(
       id: mongodb.ObjectId | any,
       options: QueryOptions<TRawDocType> & { lean: true }
     ): QueryWithHelpers<
-      GetLeanResultType<TRawDocType, TRawDocType, 'findOneAndDelete'> | null,
+      TLeanResultType | null,
       ResultDoc,
       TQueryHelpers,
-      TRawDocType,
+      TLeanResultType,
       'findOneAndDelete',
       TInstanceMethods & TVirtuals
     >;
     findByIdAndDelete<ResultDoc = THydratedDocumentType>(
       id: mongodb.ObjectId | any,
       options: QueryOptions<TRawDocType> & { includeResultMetadata: true }
-    ): QueryWithHelpers<ModifyResult<ResultDoc>, ResultDoc, TQueryHelpers, TRawDocType, 'findOneAndDelete', TInstanceMethods & TVirtuals>;
+    ): QueryWithHelpers<ModifyResult<ResultDoc>, ResultDoc, TQueryHelpers, TLeanResultType, 'findOneAndDelete', TInstanceMethods & TVirtuals>;
     findByIdAndDelete<ResultDoc = THydratedDocumentType>(
       id?: mongodb.ObjectId | any,
       options?: QueryOptions<TRawDocType> | null
-    ): QueryWithHelpers<ResultDoc | null, ResultDoc, TQueryHelpers, TRawDocType, 'findOneAndDelete', TInstanceMethods & TVirtuals>;
+    ): QueryWithHelpers<ResultDoc | null, ResultDoc, TQueryHelpers, TLeanResultType, 'findOneAndDelete', TInstanceMethods & TVirtuals>;
 
     /** Creates a `findOneAndUpdate` query, filtering by the given `_id`. */
     findByIdAndUpdate<ResultDoc = THydratedDocumentType>(
@@ -747,7 +748,7 @@ declare module 'mongoose' {
       ModifyResult<TRawDocType>,
       ResultDoc,
       TQueryHelpers,
-      TRawDocType,
+      TLeanResultType,
       'findOneAndUpdate',
       TInstanceMethods & TVirtuals
     >;
@@ -756,10 +757,10 @@ declare module 'mongoose' {
       update: UpdateQuery<TRawDocType>,
       options: QueryOptions<TRawDocType> & { lean: true }
     ): QueryWithHelpers<
-      GetLeanResultType<TRawDocType, TRawDocType, 'findOneAndUpdate'> | null,
+      TLeanResultType | null,
       ResultDoc,
       TQueryHelpers,
-      TRawDocType,
+      TLeanResultType,
       'findOneAndUpdate',
       TInstanceMethods & TVirtuals
     >;
@@ -767,42 +768,42 @@ declare module 'mongoose' {
       id: mongodb.ObjectId | any,
       update: UpdateQuery<TRawDocType>,
       options: QueryOptions<TRawDocType> & { includeResultMetadata: true }
-    ): QueryWithHelpers<ModifyResult<ResultDoc>, ResultDoc, TQueryHelpers, TRawDocType, 'findOneAndUpdate', TInstanceMethods & TVirtuals>;
+    ): QueryWithHelpers<ModifyResult<ResultDoc>, ResultDoc, TQueryHelpers, TLeanResultType, 'findOneAndUpdate', TInstanceMethods & TVirtuals>;
     findByIdAndUpdate<ResultDoc = THydratedDocumentType>(
       id: mongodb.ObjectId | any,
       update: UpdateQuery<TRawDocType>,
       options: QueryOptions<TRawDocType> & { upsert: true } & ReturnsNewDoc
-    ): QueryWithHelpers<ResultDoc, ResultDoc, TQueryHelpers, TRawDocType, 'findOneAndUpdate', TInstanceMethods & TVirtuals>;
+    ): QueryWithHelpers<ResultDoc, ResultDoc, TQueryHelpers, TLeanResultType, 'findOneAndUpdate', TInstanceMethods & TVirtuals>;
     findByIdAndUpdate<ResultDoc = THydratedDocumentType>(
       id?: mongodb.ObjectId | any,
       update?: UpdateQuery<TRawDocType>,
       options?: QueryOptions<TRawDocType> | null
-    ): QueryWithHelpers<ResultDoc | null, ResultDoc, TQueryHelpers, TRawDocType, 'findOneAndUpdate', TInstanceMethods & TVirtuals>;
+    ): QueryWithHelpers<ResultDoc | null, ResultDoc, TQueryHelpers, TLeanResultType, 'findOneAndUpdate', TInstanceMethods & TVirtuals>;
     findByIdAndUpdate<ResultDoc = THydratedDocumentType>(
       id: mongodb.ObjectId | any,
       update: UpdateQuery<TRawDocType>
-    ): QueryWithHelpers<ResultDoc | null, ResultDoc, TQueryHelpers, TRawDocType, 'findOneAndUpdate', TInstanceMethods & TVirtuals>;
+    ): QueryWithHelpers<ResultDoc | null, ResultDoc, TQueryHelpers, TLeanResultType, 'findOneAndUpdate', TInstanceMethods & TVirtuals>;
 
     /** Creates a `findOneAndDelete` query: atomically finds the given document, deletes it, and returns the document as it was before deletion. */
     findOneAndDelete<ResultDoc = THydratedDocumentType>(
       filter: RootFilterQuery<TRawDocType>,
       options: QueryOptions<TRawDocType> & { lean: true }
     ): QueryWithHelpers<
-      GetLeanResultType<TRawDocType, TRawDocType, 'findOneAndDelete'> | null,
+      TLeanResultType | null,
       ResultDoc,
       TQueryHelpers,
-      TRawDocType,
+      TLeanResultType,
       'findOneAndDelete',
       TInstanceMethods & TVirtuals
     >;
     findOneAndDelete<ResultDoc = THydratedDocumentType>(
       filter: RootFilterQuery<TRawDocType>,
       options: QueryOptions<TRawDocType> & { includeResultMetadata: true }
-    ): QueryWithHelpers<ModifyResult<ResultDoc>, ResultDoc, TQueryHelpers, TRawDocType, 'findOneAndDelete', TInstanceMethods & TVirtuals>;
+    ): QueryWithHelpers<ModifyResult<ResultDoc>, ResultDoc, TQueryHelpers, TLeanResultType, 'findOneAndDelete', TInstanceMethods & TVirtuals>;
     findOneAndDelete<ResultDoc = THydratedDocumentType>(
       filter?: RootFilterQuery<TRawDocType> | null,
       options?: QueryOptions<TRawDocType> | null
-    ): QueryWithHelpers<ResultDoc | null, ResultDoc, TQueryHelpers, TRawDocType, 'findOneAndDelete', TInstanceMethods & TVirtuals>;
+    ): QueryWithHelpers<ResultDoc | null, ResultDoc, TQueryHelpers, TLeanResultType, 'findOneAndDelete', TInstanceMethods & TVirtuals>;
 
     /** Creates a `findOneAndReplace` query: atomically finds the given document and replaces it with `replacement`. */
     findOneAndReplace<ResultDoc = THydratedDocumentType>(
@@ -810,10 +811,10 @@ declare module 'mongoose' {
       replacement: TRawDocType | AnyObject,
       options: QueryOptions<TRawDocType> & { lean: true }
     ): QueryWithHelpers<
-      GetLeanResultType<TRawDocType, TRawDocType, 'findOneAndReplace'> | null,
+      TLeanResultType | null,
       ResultDoc,
       TQueryHelpers,
-      TRawDocType,
+      TLeanResultType,
       'findOneAndReplace',
       TInstanceMethods & TVirtuals
     >;
@@ -821,17 +822,17 @@ declare module 'mongoose' {
       filter: RootFilterQuery<TRawDocType>,
       replacement: TRawDocType | AnyObject,
       options: QueryOptions<TRawDocType> & { includeResultMetadata: true }
-    ): QueryWithHelpers<ModifyResult<ResultDoc>, ResultDoc, TQueryHelpers, TRawDocType, 'findOneAndReplace', TInstanceMethods & TVirtuals>;
+    ): QueryWithHelpers<ModifyResult<ResultDoc>, ResultDoc, TQueryHelpers, TLeanResultType, 'findOneAndReplace', TInstanceMethods & TVirtuals>;
     findOneAndReplace<ResultDoc = THydratedDocumentType>(
       filter: RootFilterQuery<TRawDocType>,
       replacement: TRawDocType | AnyObject,
       options: QueryOptions<TRawDocType> & { upsert: true } & ReturnsNewDoc
-    ): QueryWithHelpers<ResultDoc, ResultDoc, TQueryHelpers, TRawDocType, 'findOneAndReplace', TInstanceMethods & TVirtuals>;
+    ): QueryWithHelpers<ResultDoc, ResultDoc, TQueryHelpers, TLeanResultType, 'findOneAndReplace', TInstanceMethods & TVirtuals>;
     findOneAndReplace<ResultDoc = THydratedDocumentType>(
       filter?: RootFilterQuery<TRawDocType>,
       replacement?: TRawDocType | AnyObject,
       options?: QueryOptions<TRawDocType> | null
-    ): QueryWithHelpers<ResultDoc | null, ResultDoc, TQueryHelpers, TRawDocType, 'findOneAndReplace', TInstanceMethods & TVirtuals>;
+    ): QueryWithHelpers<ResultDoc | null, ResultDoc, TQueryHelpers, TLeanResultType, 'findOneAndReplace', TInstanceMethods & TVirtuals>;
 
     /** Creates a `findOneAndUpdate` query: atomically find the first document that matches `filter` and apply `update`. */
     findOneAndUpdate<ResultDoc = THydratedDocumentType>(
@@ -842,7 +843,7 @@ declare module 'mongoose' {
       ModifyResult<TRawDocType>,
       ResultDoc,
       TQueryHelpers,
-      TRawDocType,
+      TLeanResultType,
       'findOneAndUpdate',
       TInstanceMethods & TVirtuals
     >;
@@ -854,7 +855,7 @@ declare module 'mongoose' {
       GetLeanResultType<TRawDocType, TRawDocType, 'findOneAndUpdate'> | null,
       ResultDoc,
       TQueryHelpers,
-      TRawDocType,
+      TLeanResultType,
       'findOneAndUpdate',
       TInstanceMethods & TVirtuals
     >;
@@ -862,24 +863,24 @@ declare module 'mongoose' {
       filter: RootFilterQuery<TRawDocType>,
       update: UpdateQuery<TRawDocType>,
       options: QueryOptions<TRawDocType> & { includeResultMetadata: true }
-    ): QueryWithHelpers<ModifyResult<ResultDoc>, ResultDoc, TQueryHelpers, TRawDocType, 'findOneAndUpdate', TInstanceMethods & TVirtuals>;
+    ): QueryWithHelpers<ModifyResult<ResultDoc>, ResultDoc, TQueryHelpers, TLeanResultType, 'findOneAndUpdate', TInstanceMethods & TVirtuals>;
     findOneAndUpdate<ResultDoc = THydratedDocumentType>(
       filter: RootFilterQuery<TRawDocType>,
       update: UpdateQuery<TRawDocType>,
       options: QueryOptions<TRawDocType> & { upsert: true } & ReturnsNewDoc
-    ): QueryWithHelpers<ResultDoc, ResultDoc, TQueryHelpers, TRawDocType, 'findOneAndUpdate', TInstanceMethods & TVirtuals>;
+    ): QueryWithHelpers<ResultDoc, ResultDoc, TQueryHelpers, TLeanResultType, 'findOneAndUpdate', TInstanceMethods & TVirtuals>;
     findOneAndUpdate<ResultDoc = THydratedDocumentType>(
       filter?: RootFilterQuery<TRawDocType>,
       update?: UpdateQuery<TRawDocType>,
       options?: QueryOptions<TRawDocType> | null
-    ): QueryWithHelpers<ResultDoc | null, ResultDoc, TQueryHelpers, TRawDocType, 'findOneAndUpdate', TInstanceMethods & TVirtuals>;
+    ): QueryWithHelpers<ResultDoc | null, ResultDoc, TQueryHelpers, TLeanResultType, 'findOneAndUpdate', TInstanceMethods & TVirtuals>;
 
     /** Creates a `replaceOne` query: finds the first document that matches `filter` and replaces it with `replacement`. */
     replaceOne<ResultDoc = THydratedDocumentType>(
       filter?: RootFilterQuery<TRawDocType>,
       replacement?: TRawDocType | AnyObject,
       options?: (mongodb.ReplaceOptions & MongooseQueryOptions<TRawDocType>) | null
-    ): QueryWithHelpers<UpdateWriteOpResult, ResultDoc, TQueryHelpers, TRawDocType, 'replaceOne', TInstanceMethods & TVirtuals>;
+    ): QueryWithHelpers<UpdateWriteOpResult, ResultDoc, TQueryHelpers, TLeanResultType, 'replaceOne', TInstanceMethods & TVirtuals>;
 
     /** Apply changes made to this model's schema after this model was compiled. */
     recompileSchema(): void;
@@ -892,17 +893,17 @@ declare module 'mongoose' {
       filter: RootFilterQuery<TRawDocType>,
       update: UpdateQuery<TRawDocType> | UpdateWithAggregationPipeline,
       options?: (mongodb.UpdateOptions & MongooseUpdateQueryOptions<TRawDocType>) | null
-    ): QueryWithHelpers<UpdateWriteOpResult, ResultDoc, TQueryHelpers, TRawDocType, 'updateMany', TInstanceMethods & TVirtuals>;
+    ): QueryWithHelpers<UpdateWriteOpResult, ResultDoc, TQueryHelpers, TLeanResultType, 'updateMany', TInstanceMethods & TVirtuals>;
 
     /** Creates a `updateOne` query: updates the first document that matches `filter` with `update`. */
     updateOne<ResultDoc = THydratedDocumentType>(
       filter: RootFilterQuery<TRawDocType>,
       update: UpdateQuery<TRawDocType> | UpdateWithAggregationPipeline,
       options?: (mongodb.UpdateOptions & MongooseUpdateQueryOptions<TRawDocType>) | null
-    ): QueryWithHelpers<UpdateWriteOpResult, ResultDoc, TQueryHelpers, TRawDocType, 'updateOne', TInstanceMethods & TVirtuals>;
+    ): QueryWithHelpers<UpdateWriteOpResult, ResultDoc, TQueryHelpers, TLeanResultType, 'updateOne', TInstanceMethods & TVirtuals>;
     updateOne<ResultDoc = THydratedDocumentType>(
       update: UpdateQuery<TRawDocType> | UpdateWithAggregationPipeline
-    ): QueryWithHelpers<UpdateWriteOpResult, ResultDoc, TQueryHelpers, TRawDocType, 'updateOne', TInstanceMethods & TVirtuals>;
+    ): QueryWithHelpers<UpdateWriteOpResult, ResultDoc, TQueryHelpers, TLeanResultType, 'updateOne', TInstanceMethods & TVirtuals>;
 
     /** Creates a Query, applies the passed conditions, and returns the Query. */
     where<ResultDoc = THydratedDocumentType>(
@@ -913,7 +914,7 @@ declare module 'mongoose' {
       Array<ResultDoc>,
       ResultDoc,
       TQueryHelpers,
-      TRawDocType,
+      TLeanResultType,
       'find',
       TInstanceMethods & TVirtuals
     >;
@@ -921,7 +922,7 @@ declare module 'mongoose' {
       Array<ResultDoc>,
       ResultDoc,
       TQueryHelpers,
-      TRawDocType,
+      TLeanResultType,
       'find',
       TInstanceMethods & TVirtuals
     >;
diff --git a/types/query.d.ts b/types/query.d.ts
index bdcb20cab4..75e53d85fb 100644
--- a/types/query.d.ts
+++ b/types/query.d.ts
@@ -237,7 +237,7 @@ declare module 'mongoose' {
   type QueryOpThatReturnsDocument = 'find' | 'findOne' | 'findOneAndUpdate' | 'findOneAndReplace' | 'findOneAndDelete';
 
   type GetLeanResultType<RawDocType, ResultType, QueryOp> = QueryOp extends QueryOpThatReturnsDocument
-    ? (ResultType extends any[] ? Default__v<Require_id<FlattenMaps<BufferToBinary<RawDocType>>>>[] : Default__v<Require_id<FlattenMaps<BufferToBinary<RawDocType>>>>)
+    ? (ResultType extends any[] ? Default__v<Require_id<RawDocType>>[] : Default__v<Require_id<RawDocType>>)
     : ResultType;
 
   type MergePopulatePaths<RawDocType, ResultType, QueryOp, Paths, TQueryHelpers, TDocOverrides = Record<string, never>> = QueryOp extends QueryOpThatReturnsDocument