mongoose 6.2.6 → 6.2.9

package/types/index.d.ts

@@ -2,13 +2,13 @@
 /// <reference path="./cursor.d.ts" />
 /// <reference path="./document.d.ts" />
 /// <reference path="./error.d.ts" />
+/// <reference path="./mongooseoptions.d.ts" />
 /// <reference path="./pipelinestage.d.ts" />
 /// <reference path="./schemaoptions.d.ts" />
 
 import events = require('events');
 import mongodb = require('mongodb');
 import mongoose = require('mongoose');
-import stream = require('stream');
 
 declare module 'mongoose' {
 
@@ -175,121 +175,10 @@ declare module 'mongoose' {
 
   type Mongoose = typeof mongoose;
 
-  interface MongooseOptions {
-    /** true by default. Set to false to skip applying global plugins to child schemas */
-    applyPluginsToChildSchemas?: boolean;
-
-    /**
-     * false by default. Set to true to apply global plugins to discriminator schemas.
-     * This typically isn't necessary because plugins are applied to the base schema and
-     * discriminators copy all middleware, methods, statics, and properties from the base schema.
-     */
-    applyPluginsToDiscriminators?: boolean;
-
-    /**
-     * Set to `true` to make Mongoose call` Model.createCollection()` automatically when you
-     * create a model with `mongoose.model()` or `conn.model()`. This is useful for testing
-     * transactions, change streams, and other features that require the collection to exist.
-     */
-    autoCreate?: boolean;
-
-    /**
-     * true by default. Set to false to disable automatic index creation
-     * for all models associated with this Mongoose instance.
-     */
-    autoIndex?: boolean;
-
-    /** enable/disable mongoose's buffering mechanism for all connections and models */
-    bufferCommands?: boolean;
-
-    bufferTimeoutMS?: number;
-
-    /** false by default. Set to `true` to `clone()` all schemas before compiling into a model. */
-    cloneSchemas?: boolean;
-
-    /**
-     * If `true`, prints the operations mongoose sends to MongoDB to the console.
-     * If a writable stream is passed, it will log to that stream, without colorization.
-     * If a callback function is passed, it will receive the collection name, the method
-     * name, then all arguments passed to the method. For example, if you wanted to
-     * replicate the default logging, you could output from the callback
-     * `Mongoose: ${collectionName}.${methodName}(${methodArgs.join(', ')})`.
-     */
-    debug?:
-      | boolean
-      | { color?: boolean; shell?: boolean }
-      | stream.Writable
-      | ((collectionName: string, methodName: string, ...methodArgs: any[]) => void);
-
-    /** If set, attaches [maxTimeMS](https://docs.mongodb.com/manual/reference/operator/meta/maxTimeMS/) to every query */
-    maxTimeMS?: number;
-
-    /**
-     * true by default. Mongoose adds a getter to MongoDB ObjectId's called `_id` that
-     * returns `this` for convenience with populate. Set this to false to remove the getter.
-     */
-    objectIdGetter?: boolean;
-
-    /**
-     * Set to `true` to default to overwriting models with the same name when calling
-     * `mongoose.model()`, as opposed to throwing an `OverwriteModelError`.
-     */
-    overwriteModels?: boolean;
-
-    /**
-     * If `false`, changes the default `returnOriginal` option to `findOneAndUpdate()`,
-     * `findByIdAndUpdate`, and `findOneAndReplace()` to false. This is equivalent to
-     * setting the `new` option to `true` for `findOneAndX()` calls by default. Read our
-     * `findOneAndUpdate()` [tutorial](https://mongoosejs.com/docs/tutorials/findoneandupdate.html)
-     * for more information.
-     */
-    returnOriginal?: boolean;
-
-    /**
-     * false by default. Set to true to enable [update validators](
-     * https://mongoosejs.com/docs/validation.html#update-validators
-     * ) for all validators by default.
-     */
-    runValidators?: boolean;
-
-    sanitizeFilter?: boolean;
-
-    sanitizeProjection?: boolean;
-
-    /**
-     * true by default. Set to false to opt out of Mongoose adding all fields that you `populate()`
-     * to your `select()`. The schema-level option `selectPopulatedPaths` overwrites this one.
-     */
-    selectPopulatedPaths?: boolean;
-
-    setDefaultsOnInsert?: boolean;
-
-    /** true by default, may be `false`, `true`, or `'throw'`. Sets the default strict mode for schemas. */
-    strict?: boolean | 'throw';
-
-    /** true by default. set to `false` to allow populating paths that aren't in the schema */
-    strictPopulate?: boolean;
-
-    /**
-     * false by default, may be `false`, `true`, or `'throw'`. Sets the default
-     * [strictQuery](https://mongoosejs.com/docs/guide.html#strictQuery) mode for schemas.
-     */
-    strictQuery?: boolean | 'throw';
-
-    /**
-     * `{ transform: true, flattenDecimals: true }` by default. Overwrites default objects to
-     * `toJSON()`, for determining how Mongoose documents get serialized by `JSON.stringify()`
-     */
-    toJSON?: ToObjectOptions;
-
-    /** `{ transform: true, flattenDecimals: true }` by default. Overwrites default objects to `toObject()` */
-    toObject?: ToObjectOptions;
-  }
-
   // 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
    */
@@ -342,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 });
 
@@ -421,8 +312,8 @@ declare module 'mongoose' {
      * mongoose will not create the collection for the model until any documents are
      * created. Use this method to create the collection explicitly.
      */
-    createCollection<T>(options?: mongodb.CreateCollectionOptions): Promise<mongodb.Collection<T>>;
-    createCollection<T>(options: mongodb.CreateCollectionOptions | null, callback: Callback<mongodb.Collection<T>>): void;
+    createCollection<T>(options?: mongodb.CreateCollectionOptions & Pick<SchemaOptions, 'expires'>): Promise<mongodb.Collection<T>>;
+    createCollection<T>(options: mongodb.CreateCollectionOptions & Pick<SchemaOptions, 'expires'> | null, callback: Callback<mongodb.Collection<T>>): void;
 
     /**
      * Similar to `ensureIndexes()`, except for it uses the [`createIndex`](http://mongodb.github.io/node-mongodb-native/2.2/api/Collection.html#createIndex)
@@ -820,6 +711,8 @@ declare module 'mongoose' {
     model?: string | Model<any>;
     /** optional query options like sort, limit, etc */
     options?: any;
+    /** optional boolean, set to `false` to allow populating paths that aren't in the schema */
+    strictPopulate?: boolean;
     /** deep populate */
     populate?: string | PopulateOptions | (string | PopulateOptions)[];
     /**
@@ -868,7 +761,7 @@ declare module 'mongoose' {
   export type PostMiddlewareFunction<ThisType = any, ResType = any> = (this: ThisType, res: ResType, next: CallbackWithoutResultAndOptionalError) => void | Promise<void>;
   export type ErrorHandlingMiddlewareFunction<ThisType = any, ResType = any> = (this: ThisType, err: NativeError, res: ResType, next: CallbackWithoutResultAndOptionalError) => void;
 
-  class Schema<DocType = any, M = Model<DocType, any, any, any>, TInstanceMethods = any, TQueryHelpers = any> extends events.EventEmitter {
+  class Schema<DocType = any, M = Model<DocType, any, any, any>, TInstanceMethods = {}, TQueryHelpers = {}> extends events.EventEmitter {
     /**
      * Create a new schema
      */
@@ -922,7 +815,7 @@ declare module 'mongoose' {
     method(obj: Partial<TInstanceMethods>): this;
 
     /** Object of currently defined methods on this schema. */
-    methods: { [F in keyof TInstanceMethods]: TInstanceMethods[F] };
+    methods: { [F in keyof TInstanceMethods]: TInstanceMethods[F] } & AnyObject;
 
     /** The original object passed to the schema constructor */
     obj: SchemaDefinition<SchemaDefinitionType<DocType>>;
@@ -1015,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
@@ -1044,22 +937,24 @@ declare module 'mongoose' {
   type AnyArray<T> = T[] | ReadonlyArray<T>;
   type SchemaValidator<T> = RegExp | [RegExp, string] | Function | [Function, string] | ValidateOpts<T> | ValidateOpts<T>[];
 
+  type ExtractMongooseArray<T> = T extends Types.Array<any> ? AnyArray<Unpacked<T>> : T;
+
   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;
@@ -1081,7 +976,7 @@ declare module 'mongoose' {
      * The default value for this path. If a function, Mongoose executes the function
      * and uses the return value as the default.
      */
-    default?: T | ((this: any, doc: any) => Partial<T>);
+    default?: ExtractMongooseArray<T> | ((this: any, doc: any) => Partial<ExtractMongooseArray<T>>);
 
     /**
      * The model that `populate()` should use if populating this path.
@@ -1204,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 {
     /**
@@ -1572,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;
@@ -1881,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;
@@ -2072,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;
@@ -2092,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
@@ -2139,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]>;
   };
@@ -2169,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]>[];
 
@@ -2203,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;
 
@@ -2217,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> {
     /**

package/types/mongooseoptions.d.ts

@@ -0,0 +1,180 @@
+import stream = require('stream');
+
+declare module 'mongoose' {
+
+  interface MongooseOptions {
+    /**
+     * Set to false to skip applying global plugins to child schemas.
+     *
+     * @default true
+     */
+    applyPluginsToChildSchemas?: boolean;
+
+    /**
+     * Set to true to apply global plugins to discriminator schemas.
+     * This typically isn't necessary because plugins are applied to the base schema and
+     * discriminators copy all middleware, methods, statics, and properties from the base schema.
+     *
+     * @default false
+     */
+    applyPluginsToDiscriminators?: boolean;
+
+    /**
+     * autoCreate is true by default unless readPreference is secondary or secondaryPreferred,
+     * which means Mongoose will attempt to create every model's underlying collection before
+     * creating indexes. If readPreference is secondary or secondaryPreferred, Mongoose will
+     * default to false for both autoCreate and autoIndex because both createCollection() and
+     * createIndex() will fail when connected to a secondary.
+     */
+    autoCreate?: boolean;
+
+    /**
+     * Set to false to disable automatic index creation for all models associated with this Mongoose instance.
+     *
+     * @default true
+     */
+    autoIndex?: boolean;
+
+    /**
+     * enable/disable mongoose's buffering mechanism for all connections and models.
+     *
+     * @default true
+     */
+    bufferCommands?: boolean;
+
+    /**
+     * If bufferCommands is on, this option sets the maximum amount of time Mongoose
+     * buffering will wait before throwing an error.
+     * If not specified, Mongoose will use 10000 (10 seconds).
+     *
+     * @default 10000
+     */
+    bufferTimeoutMS?: number;
+
+    /**
+     * Set to `true` to `clone()` all schemas before compiling into a model.
+     *
+     * @default false
+     */
+    cloneSchemas?: boolean;
+
+    /**
+     * If `true`, prints the operations mongoose sends to MongoDB to the console.
+     * If a writable stream is passed, it will log to that stream, without colorization.
+     * If a callback function is passed, it will receive the collection name, the method
+     * name, then all arguments passed to the method. For example, if you wanted to
+     * replicate the default logging, you could output from the callback
+     * `Mongoose: ${collectionName}.${methodName}(${methodArgs.join(', ')})`.
+     *
+     * @default false
+     */
+    debug?:
+    | boolean
+    | { color?: boolean; shell?: boolean; }
+    | stream.Writable
+    | ((collectionName: string, methodName: string, ...methodArgs: any[]) => void);
+
+    /** If set, attaches [maxTimeMS](https://docs.mongodb.com/manual/reference/operator/meta/maxTimeMS/) to every query */
+    maxTimeMS?: number;
+
+    /**
+     * Mongoose adds a getter to MongoDB ObjectId's called `_id` that
+     * returns `this` for convenience with populate. Set this to false to remove the getter.
+     *
+     * @default true
+     */
+    objectIdGetter?: boolean;
+
+    /**
+     * Set to `true` to default to overwriting models with the same name when calling
+     * `mongoose.model()`, as opposed to throwing an `OverwriteModelError`.
+     *
+     * @default false
+     */
+    overwriteModels?: boolean;
+
+    /**
+     * If `false`, changes the default `returnOriginal` option to `findOneAndUpdate()`,
+     * `findByIdAndUpdate`, and `findOneAndReplace()` to false. This is equivalent to
+     * setting the `new` option to `true` for `findOneAndX()` calls by default. Read our
+     * `findOneAndUpdate()` [tutorial](https://mongoosejs.com/docs/tutorials/findoneandupdate.html)
+     * for more information.
+     *
+     * @default true
+     */
+    returnOriginal?: boolean;
+
+    /**
+     * Set to true to enable [update validators](
+     * https://mongoosejs.com/docs/validation.html#update-validators
+     * ) for all validators by default.
+     *
+     * @default false
+     */
+    runValidators?: boolean;
+
+    /**
+     * Sanitizes query filters against [query selector injection attacks](
+     * https://thecodebarbarian.com/2014/09/04/defending-against-query-selector-injection-attacks.html
+     * ) by wrapping any nested objects that have a property whose name starts with $ in a $eq.
+     */
+    sanitizeFilter?: boolean;
+
+    sanitizeProjection?: boolean;
+
+    /**
+     * Set to false to opt out of Mongoose adding all fields that you `populate()`
+     * to your `select()`. The schema-level option `selectPopulatedPaths` overwrites this one.
+     *
+     * @default true
+     */
+    selectPopulatedPaths?: boolean;
+
+    /**
+     * Mongoose also sets defaults on update() and findOneAndUpdate() when the upsert option is
+     * set by adding your schema's defaults to a MongoDB $setOnInsert operator. You can disable
+     * this behavior by setting the setDefaultsOnInsert option to false.
+     *
+     * @default true
+     */
+    setDefaultsOnInsert?: boolean;
+
+    /**
+     * Sets the default strict mode for schemas.
+     * May be `false`, `true`, or `'throw'`.
+     *
+     * @default true
+     */
+    strict?: boolean | 'throw';
+
+    /**
+     * Set to `false` to allow populating paths that aren't in the schema.
+     *
+     * @default true
+     */
+    strictPopulate?: boolean;
+
+    /**
+     * Sets the default [strictQuery](https://mongoosejs.com/docs/guide.html#strictQuery) mode for schemas.
+     * May be `false`, `true`, or `'throw'`.
+     *
+     * @default false
+     */
+    strictQuery?: boolean | 'throw';
+
+    /**
+     * Overwrites default objects to `toJSON()`, for determining how Mongoose
+     * documents get serialized by `JSON.stringify()`
+     *
+     * @default { transform: true, flattenDecimals: true }
+     */
+    toJSON?: ToObjectOptions;
+
+    /**
+     * Overwrites default objects to `toObject()`
+     *
+     * @default { transform: true, flattenDecimals: true }
+     */
+    toObject?: ToObjectOptions;
+  }
+}