mongoose 6.2.8 → 6.2.9

package/types/connection.d.ts

@@ -3,7 +3,7 @@ import events = require('events');
 
 declare module 'mongoose' {
 
-    /**
+  /**
      * Connection ready state
      *
      * - 0 = disconnected
@@ -12,147 +12,147 @@ declare module 'mongoose' {
      * - 3 = disconnecting
      * - 99 = uninitialized
      */
-    export enum ConnectionStates {
-        disconnected = 0,
-        connected = 1,
-        connecting = 2,
-        disconnecting = 3,
-        uninitialized = 99,
-    }
-
-    /** Expose connection states for user-land */
-    export const STATES: typeof ConnectionStates;
-
-    interface ConnectOptions extends mongodb.MongoClientOptions {
-        /** Set to false to [disable buffering](http://mongoosejs.com/docs/faq.html#callback_never_executes) on all models associated with this connection. */
-        bufferCommands?: boolean;
-        /** The name of the database you want to use. If not provided, Mongoose uses the database name from connection string. */
-        dbName?: string;
-        /** username for authentication, equivalent to `options.auth.user`. Maintained for backwards compatibility. */
-        user?: string;
-        /** password for authentication, equivalent to `options.auth.password`. Maintained for backwards compatibility. */
-        pass?: string;
-        /** Set to false to disable automatic index creation for all models associated with this connection. */
-        autoIndex?: boolean;
-        /** Set to `true` to make Mongoose automatically call `createCollection()` on every model created on this connection. */
-        autoCreate?: boolean;
-    }
-
-    class Connection extends events.EventEmitter {
-      /** Returns a promise that resolves when this connection successfully connects to MongoDB */
-      asPromise(): Promise<this>;
-
-      /** Closes the connection */
-      close(force: boolean, callback: CallbackWithoutResult): void;
-      close(callback: CallbackWithoutResult): void;
-      close(force?: boolean): Promise<void>;
-
-      /** Retrieves a collection, creating it if not cached. */
-      collection<T extends AnyObject = AnyObject>(name: string, options?: mongodb.CreateCollectionOptions): Collection<T>;
-
-      /** A hash of the collections associated with this connection */
-      readonly collections: { [index: string]: Collection };
-
-      /** A hash of the global options that are associated with this connection */
-      readonly config: any;
-
-      /** The mongodb.Db instance, set when the connection is opened */
-      readonly db: mongodb.Db;
-
-      /**
+  export enum ConnectionStates {
+    disconnected = 0,
+    connected = 1,
+    connecting = 2,
+    disconnecting = 3,
+    uninitialized = 99,
+  }
+
+  /** Expose connection states for user-land */
+  export const STATES: typeof ConnectionStates;
+
+  interface ConnectOptions extends mongodb.MongoClientOptions {
+    /** Set to false to [disable buffering](http://mongoosejs.com/docs/faq.html#callback_never_executes) on all models associated with this connection. */
+    bufferCommands?: boolean;
+    /** The name of the database you want to use. If not provided, Mongoose uses the database name from connection string. */
+    dbName?: string;
+    /** username for authentication, equivalent to `options.auth.user`. Maintained for backwards compatibility. */
+    user?: string;
+    /** password for authentication, equivalent to `options.auth.password`. Maintained for backwards compatibility. */
+    pass?: string;
+    /** Set to false to disable automatic index creation for all models associated with this connection. */
+    autoIndex?: boolean;
+    /** Set to `true` to make Mongoose automatically call `createCollection()` on every model created on this connection. */
+    autoCreate?: boolean;
+  }
+
+  class Connection extends events.EventEmitter {
+    /** Returns a promise that resolves when this connection successfully connects to MongoDB */
+    asPromise(): Promise<this>;
+
+    /** Closes the connection */
+    close(force: boolean, callback: CallbackWithoutResult): void;
+    close(callback: CallbackWithoutResult): void;
+    close(force?: boolean): Promise<void>;
+
+    /** Retrieves a collection, creating it if not cached. */
+    collection<T extends AnyObject = AnyObject>(name: string, options?: mongodb.CreateCollectionOptions): Collection<T>;
+
+    /** A hash of the collections associated with this connection */
+    readonly collections: { [index: string]: Collection };
+
+    /** A hash of the global options that are associated with this connection */
+    readonly config: any;
+
+    /** The mongodb.Db instance, set when the connection is opened */
+    readonly db: mongodb.Db;
+
+    /**
        * Helper for `createCollection()`. Will explicitly create the given collection
        * with specified options. Used to create [capped collections](https://docs.mongodb.com/manual/core/capped-collections/)
        * and [views](https://docs.mongodb.com/manual/core/views/) from mongoose.
        */
-      createCollection<T extends AnyObject = AnyObject>(name: string, options: mongodb.CreateCollectionOptions, callback: Callback<mongodb.Collection<T>>): void;
-      createCollection<T extends AnyObject = AnyObject>(name: string, callback: Callback<mongodb.Collection<T>>): void;
-      createCollection<T extends AnyObject = AnyObject>(name: string, options?: mongodb.CreateCollectionOptions): Promise<mongodb.Collection<T>>;
+    createCollection<T extends AnyObject = AnyObject>(name: string, options: mongodb.CreateCollectionOptions, callback: Callback<mongodb.Collection<T>>): void;
+    createCollection<T extends AnyObject = AnyObject>(name: string, callback: Callback<mongodb.Collection<T>>): void;
+    createCollection<T extends AnyObject = AnyObject>(name: string, options?: mongodb.CreateCollectionOptions): Promise<mongodb.Collection<T>>;
 
-      /**
+    /**
        * Removes the model named `name` from this connection, if it exists. You can
        * use this function to clean up any models you created in your tests to
        * prevent OverwriteModelErrors.
        */
-      deleteModel(name: string): this;
+    deleteModel(name: string): this;
 
-      /**
+    /**
        * Helper for `dropCollection()`. Will delete the given collection, including
        * all documents and indexes.
        */
-      dropCollection(collection: string, callback: CallbackWithoutResult): void;
-      dropCollection(collection: string): Promise<void>;
+    dropCollection(collection: string, callback: CallbackWithoutResult): void;
+    dropCollection(collection: string): Promise<void>;
 
-      /**
+    /**
        * Helper for `dropDatabase()`. Deletes the given database, including all
        * collections, documents, and indexes.
        */
-      dropDatabase(callback: CallbackWithoutResult): void;
-      dropDatabase(): Promise<void>;
+    dropDatabase(callback: CallbackWithoutResult): void;
+    dropDatabase(): Promise<void>;
 
-      /** Gets the value of the option `key`. */
-      get(key: string): any;
+    /** Gets the value of the option `key`. */
+    get(key: string): any;
 
-      /**
+    /**
        * Returns the [MongoDB driver `MongoClient`](http://mongodb.github.io/node-mongodb-native/3.5/api/MongoClient.html) instance
        * that this connection uses to talk to MongoDB.
        */
-      getClient(): mongodb.MongoClient;
+    getClient(): mongodb.MongoClient;
 
-      /**
+    /**
        * The host name portion of the URI. If multiple hosts, such as a replica set,
        * this will contain the first host name in the URI
        */
-      readonly host: string;
+    readonly host: string;
 
-      /**
+    /**
        * A number identifier for this connection. Used for debugging when
        * you have [multiple connections](/docs/connections.html#multiple_connections).
        */
-      readonly id: number;
+    readonly id: number;
 
-      /**
+    /**
        * A [POJO](https://masteringjs.io/tutorials/fundamentals/pojo) containing
        * a map from model names to models. Contains all models that have been
        * added to this connection using [`Connection#model()`](/docs/api/connection.html#connection_Connection-model).
        */
-      readonly models: Readonly<{ [index: string]: Model<any> }>;
+    readonly models: Readonly<{ [index: string]: Model<any> }>;
 
-      /** Defines or retrieves a model. */
-      model<T, U, TQueryHelpers = {}>(
-            name: string,
-            schema?: Schema<T, U, TQueryHelpers>,
-            collection?: string,
-            options?: CompileModelOptions
-        ): U;
-      model<T>(name: string, schema?: Schema<T>, collection?: string, options?: CompileModelOptions): Model<T>;
+    /** Defines or retrieves a model. */
+    model<T, U, TQueryHelpers = {}>(
+      name: string,
+      schema?: Schema<T, U, TQueryHelpers>,
+      collection?: string,
+      options?: CompileModelOptions
+    ): U;
+    model<T>(name: string, schema?: Schema<T>, collection?: string, options?: CompileModelOptions): Model<T>;
 
-      /** Returns an array of model names created on this connection. */
-      modelNames(): Array<string>;
+    /** Returns an array of model names created on this connection. */
+    modelNames(): Array<string>;
 
-      /** The name of the database this connection points to. */
-      readonly name: string;
+    /** The name of the database this connection points to. */
+    readonly name: string;
 
-      /** Opens the connection with a URI using `MongoClient.connect()`. */
-      openUri(uri: string, options: ConnectOptions, callback: Callback<Connection>): Connection;
-      openUri(uri: string, callback: Callback<Connection>): Connection;
-      openUri(uri: string, options?: ConnectOptions): Promise<Connection>;
+    /** Opens the connection with a URI using `MongoClient.connect()`. */
+    openUri(uri: string, options: ConnectOptions, callback: Callback<Connection>): Connection;
+    openUri(uri: string, callback: Callback<Connection>): Connection;
+    openUri(uri: string, options?: ConnectOptions): Promise<Connection>;
 
-      /** The password specified in the URI */
-      readonly pass: string;
+    /** The password specified in the URI */
+    readonly pass: string;
 
-      /**
+    /**
        * The port portion of the URI. If multiple hosts, such as a replica set,
        * this will contain the port from the first host name in the URI.
        */
-      readonly port: number;
+    readonly port: number;
 
-      /** Declares a plugin executed on all schemas you pass to `conn.model()` */
-      plugin<S extends Schema = Schema, O = AnyObject>(fn: (schema: S, opts?: any) => void, opts?: O): Connection;
+    /** Declares a plugin executed on all schemas you pass to `conn.model()` */
+    plugin<S extends Schema = Schema, O = AnyObject>(fn: (schema: S, opts?: any) => void, opts?: O): Connection;
 
-      /** The plugins that will be applied to all models created on this connection. */
-      plugins: Array<any>;
+    /** The plugins that will be applied to all models created on this connection. */
+    plugins: Array<any>;
 
-      /**
+    /**
        * Connection ready state
        *
        * - 0 = disconnected
@@ -161,52 +161,52 @@ declare module 'mongoose' {
        * - 3 = disconnecting
        * - 99 = uninitialized
        */
-      readonly readyState: ConnectionStates;
+    readonly readyState: ConnectionStates;
 
-      /** Sets the value of the option `key`. */
-      set(key: string, value: any): any;
+    /** Sets the value of the option `key`. */
+    set(key: string, value: any): any;
 
-      /**
+    /**
        * Set the [MongoDB driver `MongoClient`](http://mongodb.github.io/node-mongodb-native/3.5/api/MongoClient.html) instance
        * that this connection uses to talk to MongoDB. This is useful if you already have a MongoClient instance, and want to
        * reuse it.
        */
-      setClient(client: mongodb.MongoClient): this;
+    setClient(client: mongodb.MongoClient): this;
 
-      /**
+    /**
        * _Requires MongoDB >= 3.6.0._ Starts a [MongoDB session](https://docs.mongodb.com/manual/release-notes/3.6/#client-sessions)
        * for benefits like causal consistency, [retryable writes](https://docs.mongodb.com/manual/core/retryable-writes/),
        * and [transactions](http://thecodebarbarian.com/a-node-js-perspective-on-mongodb-4-transactions.html).
        */
-      startSession(options: mongodb.ClientSessionOptions | undefined | null, callback: Callback<mongodb.ClientSession>): void;
-      startSession(callback: Callback<mongodb.ClientSession>): void;
-      startSession(options?: mongodb.ClientSessionOptions): Promise<mongodb.ClientSession>;
+    startSession(options: mongodb.ClientSessionOptions | undefined | null, callback: Callback<mongodb.ClientSession>): void;
+    startSession(callback: Callback<mongodb.ClientSession>): void;
+    startSession(options?: mongodb.ClientSessionOptions): Promise<mongodb.ClientSession>;
 
-      /**
+    /**
        * Makes the indexes in MongoDB match the indexes defined in every model's
        * schema. This function will drop any indexes that are not defined in
        * the model's schema except the `_id` index, and build any indexes that
        * are in your schema but not in MongoDB.
        */
-      syncIndexes(options: SyncIndexesOptions | undefined | null, callback: Callback<ConnectionSyncIndexesResult>): void;
-      syncIndexes(options?: SyncIndexesOptions): Promise<ConnectionSyncIndexesResult>;
+    syncIndexes(options: SyncIndexesOptions | undefined | null, callback: Callback<ConnectionSyncIndexesResult>): void;
+    syncIndexes(options?: SyncIndexesOptions): Promise<ConnectionSyncIndexesResult>;
 
-      /**
+    /**
        * _Requires MongoDB >= 3.6.0._ Executes the wrapped async function
        * in a transaction. Mongoose will commit the transaction if the
        * async function executes successfully and attempt to retry if
        * there was a retryable error.
        */
-      transaction<U = any>(fn: (session: mongodb.ClientSession) => Promise<U>): Promise<U>;
+    transaction<U = any>(fn: (session: mongodb.ClientSession) => Promise<U>): Promise<U>;
 
-      /** Switches to a different database using the same connection pool. */
-      useDb(name: string, options?: { useCache?: boolean, noListener?: boolean }): Connection;
+    /** Switches to a different database using the same connection pool. */
+    useDb(name: string, options?: { useCache?: boolean, noListener?: boolean }): Connection;
 
-      /** The username specified in the URI */
-      readonly user: string;
+    /** The username specified in the URI */
+    readonly user: string;
 
-      /** Watches the entire underlying database for changes. Similar to [`Model.watch()`](/docs/api/model.html#model_Model.watch). */
-      watch<ResultType = any>(pipeline?: Array<any>, options?: mongodb.ChangeStreamOptions): mongodb.ChangeStream<ResultType>;
-    }
+    /** Watches the entire underlying database for changes. Similar to [`Model.watch()`](/docs/api/model.html#model_Model.watch). */
+    watch<ResultType = any>(pipeline?: Array<any>, options?: mongodb.ChangeStreamOptions): mongodb.ChangeStream<ResultType>;
+  }
 
 }

package/types/error.d.ts

@@ -2,7 +2,7 @@ import mongodb = require('mongodb');
 
 declare module 'mongoose' {
 
-    class NativeError extends global.Error { }
+  class NativeError extends global.Error { }
     type CallbackError = NativeError | null;
 
     class MongooseError extends global.Error {
@@ -126,4 +126,4 @@ declare module 'mongoose' {
         constructor(doc: Document, currentVersion: number, modifiedPaths: Array<string>);
       }
     }
-  }
+}

package/types/index.d.ts

@@ -178,7 +178,7 @@ declare module 'mongoose' {
   // eslint-disable-next-line @typescript-eslint/no-empty-interface
   interface ClientSession extends mongodb.ClientSession { }
 
-   /*
+  /*
    * section collection.js
    * http://mongoosejs.com/docs/api.html#collection-js
    */
@@ -231,7 +231,9 @@ declare module 'mongoose' {
   }
 
   type AnyKeys<T> = { [P in keyof T]?: T[P] | any };
-  interface AnyObject { [k: string]: any }
+  interface AnyObject {
+    [k: string]: any
+  }
 
   type Require_id<T> = T extends { _id?: any } ? (T & { _id: T['_id'] }) : (T & { _id: Types.ObjectId });
 
@@ -906,22 +908,22 @@ declare module 'mongoose' {
   type SchemaDefinitionWithBuiltInClass<T> = T extends number
     ? NumberSchemaDefinition
     : T extends string
-    ? StringSchemaDefinition
-    : T extends boolean
-    ? BooleanSchemaDefinition
-    : T extends NativeDate
-    ? DateSchemaDefinition
-    : (Function | string);
+      ? StringSchemaDefinition
+      : T extends boolean
+        ? BooleanSchemaDefinition
+        : T extends NativeDate
+          ? DateSchemaDefinition
+          : (Function | string);
 
   type SchemaDefinitionProperty<T = undefined> = SchemaDefinitionWithBuiltInClass<T> |
-    SchemaTypeOptions<T extends undefined ? any : T> |
+  SchemaTypeOptions<T extends undefined ? any : T> |
     typeof SchemaType |
-    Schema<any, any, any> |
-    Schema<any, any, any>[] |
-    SchemaTypeOptions<T extends undefined ? any : Unpacked<T>>[] |
-    Function[] |
-    SchemaDefinition<T> |
-    SchemaDefinition<Unpacked<T>>[] |
+  Schema<any, any, any> |
+  Schema<any, any, any>[] |
+  SchemaTypeOptions<T extends undefined ? any : Unpacked<T>>[] |
+  Function[] |
+  SchemaDefinition<T> |
+  SchemaDefinition<Unpacked<T>>[] |
     typeof SchemaTypes.Mixed;
 
   type SchemaDefinition<T = undefined> = T extends undefined
@@ -939,20 +941,20 @@ declare module 'mongoose' {
 
   export class SchemaTypeOptions<T> {
     type?:
-      T extends string ? StringSchemaDefinition :
+    T extends string ? StringSchemaDefinition :
       T extends number ? NumberSchemaDefinition :
-      T extends boolean ? BooleanSchemaDefinition :
-      T extends NativeDate ? DateSchemaDefinition :
-      T extends Map<any, any> ? SchemaDefinition<typeof Map> :
-      T extends Buffer ? SchemaDefinition<typeof Buffer> :
-      T extends Types.ObjectId ? ObjectIdSchemaDefinition :
-      T extends Types.ObjectId[] ? AnyArray<ObjectIdSchemaDefinition> | AnyArray<SchemaTypeOptions<ObjectId>> :
-      T extends object[] ? (AnyArray<Schema<any, any, any>> | AnyArray<SchemaDefinition<Unpacked<T>>> | AnyArray<SchemaTypeOptions<Unpacked<T>>>) :
-      T extends string[] ? AnyArray<StringSchemaDefinition> | AnyArray<SchemaTypeOptions<string>> :
-      T extends number[] ? AnyArray<NumberSchemaDefinition> | AnyArray<SchemaTypeOptions<number>> :
-      T extends boolean[] ? AnyArray<BooleanSchemaDefinition> | AnyArray<SchemaTypeOptions<boolean>> :
-      T extends Function[] ? AnyArray<Function | string> | AnyArray<SchemaTypeOptions<Unpacked<T>>> :
-      T | typeof SchemaType | Schema<any, any, any> | SchemaDefinition<T> | Function | AnyArray<Function>;
+        T extends boolean ? BooleanSchemaDefinition :
+          T extends NativeDate ? DateSchemaDefinition :
+            T extends Map<any, any> ? SchemaDefinition<typeof Map> :
+              T extends Buffer ? SchemaDefinition<typeof Buffer> :
+                T extends Types.ObjectId ? ObjectIdSchemaDefinition :
+                  T extends Types.ObjectId[] ? AnyArray<ObjectIdSchemaDefinition> | AnyArray<SchemaTypeOptions<ObjectId>> :
+                    T extends object[] ? (AnyArray<Schema<any, any, any>> | AnyArray<SchemaDefinition<Unpacked<T>>> | AnyArray<SchemaTypeOptions<Unpacked<T>>>) :
+                      T extends string[] ? AnyArray<StringSchemaDefinition> | AnyArray<SchemaTypeOptions<string>> :
+                        T extends number[] ? AnyArray<NumberSchemaDefinition> | AnyArray<SchemaTypeOptions<number>> :
+                          T extends boolean[] ? AnyArray<BooleanSchemaDefinition> | AnyArray<SchemaTypeOptions<boolean>> :
+                            T extends Function[] ? AnyArray<Function | string> | AnyArray<SchemaTypeOptions<Unpacked<T>>> :
+                              T | typeof SchemaType | Schema<any, any, any> | SchemaDefinition<T> | Function | AnyArray<Function>;
 
     /** Defines a virtual with the given name that gets/sets this path. */
     alias?: string;
@@ -1097,7 +1099,7 @@ declare module 'mongoose' {
   export type PopulatedDoc<
     PopulatedType,
     RawId extends RefType = (PopulatedType extends { _id?: RefType; } ? NonNullable<PopulatedType['_id']> : mongoose.Types.ObjectId) | undefined
-    > = PopulatedType | RawId;
+  > = PopulatedType | RawId;
 
   interface IndexOptions extends mongodb.CreateIndexesOptions {
     /**
@@ -1465,17 +1467,17 @@ declare module 'mongoose' {
     }
   }
 
-  type ReturnsNewDoc = { new: true } | { returnOriginal: false } | {returnDocument: 'after'};
+  type ReturnsNewDoc = { new: true } | { returnOriginal: false } | { returnDocument: 'after' };
 
   type QueryWithHelpers<ResultType, DocType, THelpers = {}, RawDocType = DocType> = Query<ResultType, DocType, THelpers, RawDocType> & THelpers;
 
-  type UnpackedIntersection<T, U> = T extends (infer A)[]
+  type UnpackedIntersection<T, U> = T extends null ? null : T extends (infer A)[]
     ? (Omit<A, keyof U> & U)[]
     : keyof U extends never
-    ? T
-  : Omit<T, keyof U> & U;
+      ? T
+      : Omit<T, keyof U> & U;
 
-  type ProjectionFields<DocType> = {[Key in keyof Omit<LeanDocument<DocType>, '__v'>]?: any} & Record<string, any>;
+  type ProjectionFields<DocType> = { [Key in keyof Omit<LeanDocument<DocType>, '__v'>]?: any } & Record<string, any>;
 
   class Query<ResultType, DocType, THelpers = {}, RawDocType = DocType> {
     _mongooseOptions: MongooseQueryOptions;
@@ -1774,8 +1776,8 @@ declare module 'mongoose' {
     polygon(path: string, ...coordinatePairs: number[][]): this;
 
     /** Specifies paths which should be populated with other documents. */
-    populate<Paths = {}>(path: string | string[], select?: string | any, model?: string | Model<any, THelpers>, match?: any): QueryWithHelpers<UnpackedIntersection<ResultType, Paths>, DocType, THelpers, RawDocType>;
-    populate<Paths = {}>(options: PopulateOptions | (PopulateOptions | string)[]): QueryWithHelpers<UnpackedIntersection<ResultType, Paths>, DocType, THelpers, RawDocType>;
+    populate<Paths = {}>(path: string | string[], select?: string | any, model?: string | Model<any, THelpers>, match?: any): QueryWithHelpers<UnpackedIntersection<ResultType, Paths>, DocType, THelpers, UnpackedIntersection<RawDocType, Paths>>;
+    populate<Paths = {}>(options: PopulateOptions | (PopulateOptions | string)[]): QueryWithHelpers<UnpackedIntersection<ResultType, Paths>, DocType, THelpers, UnpackedIntersection<RawDocType, Paths>>;
 
     /** Get/set the current projection (AKA fields). Pass `null` to remove the current projection. */
     projection(): ProjectionFields<DocType> | null;
@@ -1965,10 +1967,10 @@ declare module 'mongoose' {
     $or?: Array<FilterQuery<T>>;
     /** @see https://docs.mongodb.com/manual/reference/operator/query/text */
     $text?: {
-        $search: string;
-        $language?: string;
-        $caseSensitive?: boolean;
-        $diacriticSensitive?: boolean;
+      $search: string;
+      $language?: string;
+      $caseSensitive?: boolean;
+      $diacriticSensitive?: boolean;
     };
     /** @see https://docs.mongodb.com/manual/reference/operator/query/where/#op._S_where */
     $where?: string | Function;
@@ -1985,7 +1987,7 @@ declare module 'mongoose' {
   type _FilterQuery<T> = {
     [P in keyof T]?: Condition<T[P]>;
   } &
-    RootQuerySelector<T>;
+  RootQuerySelector<T>;
 
   /**
    * Filter query to select the documents that match the query
@@ -2032,21 +2034,21 @@ declare module 'mongoose' {
 
     /** @see https://docs.mongodb.com/manual/reference/operator/update-bitwise/ */
     $bit?: {
-        [key: string]: { [key in 'and' | 'or' | 'xor']?: number };
+      [key: string]: { [key in 'and' | 'or' | 'xor']?: number };
     };
   };
 
   type UpdateWithAggregationPipeline = UpdateAggregationStage[];
   type UpdateAggregationStage = { $addFields: any } |
-    { $set: any } |
-    { $project: any } |
-    { $unset: any } |
-    { $replaceRoot: any } |
-    { $replaceWith: any };
+  { $set: any } |
+  { $project: any } |
+  { $unset: any } |
+  { $replaceRoot: any } |
+  { $replaceWith: any };
 
   type __UpdateDefProperty<T> =
     [Extract<T, mongodb.ObjectId>] extends [never] ? T :
-    T | string;
+      T | string;
   type _UpdateQueryDef<T> = {
     [K in keyof T]?: __UpdateDefProperty<T[K]>;
   };
@@ -2062,28 +2064,28 @@ declare module 'mongoose' {
 
   export type DocumentDefinition<T> = {
     [K in keyof Omit<T, Exclude<keyof Document, '_id' | 'id' | '__v'>>]:
-      [Extract<T[K], mongodb.ObjectId>] extends [never]
+    [Extract<T[K], mongodb.ObjectId>] extends [never]
       ? T[K] extends TreatAsPrimitives
         ? T[K]
         : LeanDocumentElement<T[K]>
       : T[K] | string;
-    };
+  };
 
   export type FlattenMaps<T> = {
     [K in keyof T]: T[K] extends Map<any, any>
       ? AnyObject : T[K] extends TreatAsPrimitives
-      ? T[K] : FlattenMaps<T[K]>;
+        ? T[K] : FlattenMaps<T[K]>;
   };
 
   type actualPrimitives = string | boolean | number | bigint | symbol | null | undefined;
   type TreatAsPrimitives = actualPrimitives |
-    NativeDate | RegExp | symbol | Error | BigInt | Types.ObjectId;
+  NativeDate | RegExp | symbol | Error | BigInt | Types.ObjectId;
 
   type LeanType<T> =
     0 extends (1 & T) ? T : // any
-    T extends TreatAsPrimitives ? T : // primitives
-    T extends Types.Subdocument ? Omit<LeanDocument<T>, '$isSingleNested' | 'ownerDocument' | 'parent'> : // subdocs
-    LeanDocument<T>; // Documents and everything else
+      T extends TreatAsPrimitives ? T : // primitives
+        T extends Types.Subdocument ? Omit<LeanDocument<T>, '$isSingleNested' | 'ownerDocument' | 'parent'> : // subdocs
+          LeanDocument<T>; // Documents and everything else
 
   type LeanArray<T extends unknown[]> = T extends unknown[][] ? LeanArray<T[number]>[] : LeanType<T[number]>[];
 
@@ -2096,8 +2098,8 @@ declare module 'mongoose' {
   // This is required for PopulatedDoc.
   type LeanDocumentElement<T> =
     T extends unknown[] ? LeanArray<T> : // Array
-    T extends Document ? LeanDocument<T> : // Subdocument
-    T;
+      T extends Document ? LeanDocument<T> : // Subdocument
+        T;
 
   export type SchemaDefinitionType<T> = T extends Document ? Omit<T, Exclude<keyof Document, '_id' | 'id' | '__v'>> : T;
 
@@ -2110,13 +2112,13 @@ declare module 'mongoose' {
 
   export type LeanDocumentOrArray<T> = 0 extends (1 & T) ? T :
     T extends unknown[] ? LeanDocument<T[number]>[] :
-    T extends Document ? LeanDocument<T> :
-    T;
+      T extends Document ? LeanDocument<T> :
+        T;
 
   export type LeanDocumentOrArrayWithRawType<T, RawDocType> = 0 extends (1 & T) ? T :
     T extends unknown[] ? RawDocType[] :
-    T extends Document ? RawDocType :
-    T;
+      T extends Document ? RawDocType :
+        T;
 
   class Aggregate<R> {
     /**