mongoose 8.0.2 → 8.0.4

package/lib/schema/decimal128.js

@@ -7,7 +7,6 @@
 const SchemaType = require('../schemaType');
 const CastError = SchemaType.CastError;
 const castDecimal128 = require('../cast/decimal128');
-const utils = require('../utils');
 const isBsonType = require('../helpers/isBsonType');
 
 /**
@@ -214,13 +213,13 @@ function handleSingle(val) {
   return this.cast(val);
 }
 
-SchemaDecimal128.prototype.$conditionalHandlers =
-    utils.options(SchemaType.prototype.$conditionalHandlers, {
-      $gt: handleSingle,
-      $gte: handleSingle,
-      $lt: handleSingle,
-      $lte: handleSingle
-    });
+SchemaDecimal128.prototype.$conditionalHandlers = {
+  ...SchemaType.prototype.$conditionalHandlers,
+  $gt: handleSingle,
+  $gte: handleSingle,
+  $lt: handleSingle,
+  $lte: handleSingle
+};
 
 /*!
  * Module exports.

package/lib/schema/documentArray.js

@@ -88,12 +88,6 @@ function SchemaDocumentArray(key, schema, options, schemaOptions) {
 
   this.$embeddedSchemaType.caster = this.Constructor;
   this.$embeddedSchemaType.schema = this.schema;
-
-  if (schema._applyDiscriminators != null && !options?._skipApplyDiscriminators) {
-    for (const disc of schema._applyDiscriminators.keys()) {
-      this.discriminator(disc, schema._applyDiscriminators.get(disc));
-    }
-  }
 }
 
 /**
@@ -528,7 +522,7 @@ SchemaDocumentArray.prototype.cast = function(value, doc, init, prev, options) {
 
 SchemaDocumentArray.prototype.clone = function() {
   const options = Object.assign({}, this.options);
-  const schematype = new this.constructor(this.path, this.schema, { ...options, _skipApplyDiscriminators: true }, this.schemaOptions);
+  const schematype = new this.constructor(this.path, this.schema, options, this.schemaOptions);
   schematype.validators = this.validators.slice();
   if (this.requiredValidator !== undefined) {
     schematype.requiredValidator = this.requiredValidator;

package/lib/schema/number.js

@@ -399,18 +399,18 @@ function handleArray(val) {
   });
 }
 
-SchemaNumber.prototype.$conditionalHandlers =
-    utils.options(SchemaType.prototype.$conditionalHandlers, {
-      $bitsAllClear: handleBitwiseOperator,
-      $bitsAnyClear: handleBitwiseOperator,
-      $bitsAllSet: handleBitwiseOperator,
-      $bitsAnySet: handleBitwiseOperator,
-      $gt: handleSingle,
-      $gte: handleSingle,
-      $lt: handleSingle,
-      $lte: handleSingle,
-      $mod: handleArray
-    });
+SchemaNumber.prototype.$conditionalHandlers = {
+  ...SchemaType.prototype.$conditionalHandlers,
+  $bitsAllClear: handleBitwiseOperator,
+  $bitsAnyClear: handleBitwiseOperator,
+  $bitsAllSet: handleBitwiseOperator,
+  $bitsAnySet: handleBitwiseOperator,
+  $gt: handleSingle,
+  $gte: handleSingle,
+  $lt: handleSingle,
+  $lte: handleSingle,
+  $mod: handleArray
+};
 
 /**
  * Casts contents for queries.
@@ -429,7 +429,16 @@ SchemaNumber.prototype.castForQuery = function($conditional, val, context) {
     }
     return handler.call(this, val, context);
   }
-  val = this.applySetters(val, context);
+
+  try {
+    val = this.applySetters(val, context);
+  } catch (err) {
+    if (err instanceof CastError && err.path === this.path && this.$fullPath != null) {
+      err.path = this.$fullPath;
+    }
+    throw err;
+  }
+
   return val;
 };
 

package/lib/schema/objectId.js

@@ -259,13 +259,13 @@ function handleSingle(val) {
   return this.cast(val);
 }
 
-SchemaObjectId.prototype.$conditionalHandlers =
-    utils.options(SchemaType.prototype.$conditionalHandlers, {
-      $gt: handleSingle,
-      $gte: handleSingle,
-      $lt: handleSingle,
-      $lte: handleSingle
-    });
+SchemaObjectId.prototype.$conditionalHandlers = {
+  ...SchemaType.prototype.$conditionalHandlers,
+  $gt: handleSingle,
+  $gte: handleSingle,
+  $lt: handleSingle,
+  $lte: handleSingle
+};
 
 /*!
  * ignore

package/lib/schema/string.js

@@ -641,7 +641,8 @@ function handleSingleNoSetters(val) {
   return this.cast(val, this);
 }
 
-const $conditionalHandlers = utils.options(SchemaType.prototype.$conditionalHandlers, {
+const $conditionalHandlers = {
+  ...SchemaType.prototype.$conditionalHandlers,
   $all: handleArray,
   $gt: handleSingle,
   $gte: handleSingle,
@@ -656,7 +657,7 @@ const $conditionalHandlers = utils.options(SchemaType.prototype.$conditionalHand
     return handleSingleNoSetters.call(this, val);
   },
   $not: handleSingle
-});
+};
 
 Object.defineProperty(SchemaString.prototype, '$conditionalHandlers', {
   configurable: false,
@@ -687,7 +688,14 @@ SchemaString.prototype.castForQuery = function($conditional, val, context) {
     return val;
   }
 
-  return this.applySetters(val, context);
+  try {
+    return this.applySetters(val, context);
+  } catch (err) {
+    if (err instanceof CastError && err.path === this.path && this.$fullPath != null) {
+      err.path = this.$fullPath;
+    }
+    throw err;
+  }
 };
 
 /*!

package/lib/schema/subdocument.js

@@ -48,18 +48,13 @@ function SchemaSubdocument(schema, path, options) {
 
   schema = handleIdOption(schema, options);
 
-  this.caster = _createConstructor(schema);
+  this.caster = _createConstructor(schema, null, options);
   this.caster.path = path;
   this.caster.prototype.$basePath = path;
   this.schema = schema;
   this.$isSingleNested = true;
   this.base = schema.base;
   SchemaType.call(this, path, options, 'Embedded');
-  if (schema._applyDiscriminators != null && !options?._skipApplyDiscriminators) {
-    for (const disc of schema._applyDiscriminators.keys()) {
-      this.discriminator(disc, schema._applyDiscriminators.get(disc));
-    }
-  }
 }
 
 /*!
@@ -74,7 +69,7 @@ SchemaSubdocument.prototype.OptionsConstructor = SchemaSubdocumentOptions;
  * ignore
  */
 
-function _createConstructor(schema, baseClass) {
+function _createConstructor(schema, baseClass, options) {
   // lazy load
   SubdocumentType || (SubdocumentType = require('../types/subdocument'));
 
@@ -94,6 +89,7 @@ function _createConstructor(schema, baseClass) {
   _embedded.prototype = Object.create(proto);
   _embedded.prototype.$__setSchema(schema);
   _embedded.prototype.constructor = _embedded;
+  _embedded.$__required = options?.required;
   _embedded.base = schema.base;
   _embedded.schema = schema;
   _embedded.$isSingleNested = true;

package/lib/schema/uuid.js

@@ -313,8 +313,8 @@ function handleArray(val) {
   });
 }
 
-SchemaUUID.prototype.$conditionalHandlers =
-utils.options(SchemaType.prototype.$conditionalHandlers, {
+SchemaUUID.prototype.$conditionalHandlers = {
+  ...SchemaType.prototype.$conditionalHandlers,
   $bitsAllClear: handleBitwiseOperator,
   $bitsAnyClear: handleBitwiseOperator,
   $bitsAllSet: handleBitwiseOperator,
@@ -327,7 +327,7 @@ utils.options(SchemaType.prototype.$conditionalHandlers, {
   $lte: handleSingle,
   $ne: handleSingle,
   $nin: handleArray
-});
+};
 
 /**
  * Casts contents for queries.
@@ -344,8 +344,15 @@ SchemaUUID.prototype.castForQuery = function($conditional, val, context) {
     if (!handler)
       throw new Error('Can\'t use ' + $conditional + ' with UUID.');
     return handler.call(this, val, context);
-  } else {
-    return this.cast(val);
+  }
+
+  try {
+    return this.applySetters(val, context);
+  } catch (err) {
+    if (err instanceof CastError && err.path === this.path && this.$fullPath != null) {
+      err.path = this.$fullPath;
+    }
+    throw err;
   }
 };
 

package/lib/schema.js

@@ -25,6 +25,8 @@ const utils = require('./utils');
 const validateRef = require('./helpers/populate/validateRef');
 const util = require('util');
 
+const hasNumericSubpathRegex = /\.\d+(\.|$)/;
+
 let MongooseTypes;
 
 const queryHooks = require('./helpers/query/applyQueryMiddleware').
@@ -49,7 +51,7 @@ const numberRE = /^\d+$/;
  *     const Tree = mongoose.model('Tree', schema);
  *
  *     // setting schema options
- *     new Schema({ name: String }, { _id: false, autoIndex: false })
+ *     new Schema({ name: String }, { id: false, autoIndex: false })
  *
  * #### Options:
  *
@@ -560,7 +562,7 @@ Schema.prototype.defaultOptions = function(options) {
   const strict = 'strict' in baseOptions ? baseOptions.strict : true;
   const strictQuery = 'strictQuery' in baseOptions ? baseOptions.strictQuery : false;
   const id = 'id' in baseOptions ? baseOptions.id : true;
-  options = utils.options({
+  options = {
     strict,
     strictQuery,
     bufferCommands: true,
@@ -577,8 +579,9 @@ Schema.prototype.defaultOptions = function(options) {
     // the following are only applied at construction time
     _id: true,
     id: id,
-    typeKey: 'type'
-  }, clone(options));
+    typeKey: 'type',
+    ...options
+  };
 
   if (options.versionKey && typeof options.versionKey !== 'string') {
     throw new MongooseError('`versionKey` must be falsy or string, got `' + (typeof options.versionKey) + '`');
@@ -1007,7 +1010,7 @@ Schema.prototype.path = function(path, obj) {
     }
 
     // subpaths?
-    return /\.\d+\.?.*$/.test(path)
+    return hasNumericSubpathRegex.test(path)
       ? getPositionalPath(this, path, cleanPath)
       : undefined;
   }
@@ -1122,15 +1125,14 @@ Schema.prototype.path = function(path, obj) {
       if (_schemaType.$isMongooseDocumentArray) {
         _schemaType.$embeddedSchemaType._arrayPath = arrayPath;
         _schemaType.$embeddedSchemaType._arrayParentPath = path;
-        _schemaType = _schemaType.$embeddedSchemaType.clone();
+        _schemaType = _schemaType.$embeddedSchemaType;
       } else {
         _schemaType.caster._arrayPath = arrayPath;
         _schemaType.caster._arrayParentPath = path;
-        _schemaType = _schemaType.caster.clone();
+        _schemaType = _schemaType.caster;
       }
 
-      _schemaType.path = arrayPath;
-      toAdd.push(_schemaType);
+      this.subpaths[arrayPath] = _schemaType;
     }
 
     for (const _schemaType of toAdd) {

package/lib/schemaType.js

@@ -1630,7 +1630,14 @@ SchemaType.prototype.castForQuery = function($conditional, val, context) {
     return handler.call(this, val, context);
   }
 
-  return this.applySetters(val, context);
+  try {
+    return this.applySetters(val, context);
+  } catch (err) {
+    if (err instanceof CastError && err.path === this.path && this.$fullPath != null) {
+      err.path = this.$fullPath;
+    }
+    throw err;
+  }
 };
 
 /**

package/lib/types/subdocument.js

@@ -182,7 +182,7 @@ Subdocument.prototype.markModified = function(path) {
  * ignore
  */
 
-Subdocument.prototype.isModified = function(paths, modifiedPaths) {
+Subdocument.prototype.isModified = function(paths, options, modifiedPaths) {
   const parent = this.$parent();
   if (parent != null) {
     if (Array.isArray(paths) || typeof paths === 'string') {
@@ -192,10 +192,10 @@ Subdocument.prototype.isModified = function(paths, modifiedPaths) {
       paths = this.$__pathRelativeToParent();
     }
 
-    return parent.$isModified(paths, modifiedPaths);
+    return parent.$isModified(paths, options, modifiedPaths);
   }
 
-  return Document.prototype.isModified.call(this, paths, modifiedPaths);
+  return Document.prototype.isModified.call(this, paths, options, modifiedPaths);
 };
 
 /**

package/lib/utils.js

@@ -227,33 +227,6 @@ exports.omit = function omit(obj, keys) {
   return ret;
 };
 
-
-/**
- * Shallow copies defaults into options.
- *
- * @param {Object} defaults
- * @param {Object} [options]
- * @return {Object} the merged object
- * @api private
- */
-
-exports.options = function(defaults, options) {
-  const keys = Object.keys(defaults);
-  let i = keys.length;
-  let k;
-
-  options = options || {};
-
-  while (i--) {
-    k = keys[i];
-    if (!(k in options)) {
-      options[k] = defaults[k];
-    }
-  }
-
-  return options;
-};
-
 /**
  * Merges `from` into `to` without overwriting existing properties.
  *
@@ -687,12 +660,6 @@ exports.object.vals = function vals(o) {
   return ret;
 };
 
-/**
- * @see exports.options
- */
-
-exports.object.shallowCopy = exports.options;
-
 const hop = Object.prototype.hasOwnProperty;
 
 /**

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "mongoose",
   "description": "Mongoose MongoDB ODM",
-  "version": "8.0.2",
+  "version": "8.0.4",
   "author": "Guillermo Rauch <guillermo@learnboost.com>",
   "keywords": [
     "mongodb",
@@ -28,8 +28,8 @@
     "sift": "16.0.1"
   },
   "devDependencies": {
-    "@babel/core": "7.23.2",
-    "@babel/preset-env": "7.22.20",
+    "@babel/core": "7.23.7",
+    "@babel/preset-env": "7.23.7",
     "@typescript-eslint/eslint-plugin": "^6.2.1",
     "@typescript-eslint/parser": "^6.2.1",
     "acquit": "1.3.0",
@@ -45,15 +45,15 @@
     "crypto-browserify": "3.12.0",
     "dotenv": "16.3.1",
     "dox": "1.0.0",
-    "eslint": "8.52.0",
+    "eslint": "8.56.0",
     "eslint-plugin-markdown": "^3.0.1",
     "eslint-plugin-mocha-no-only": "1.1.1",
     "express": "^4.18.1",
-    "fs-extra": "~11.1.1",
+    "fs-extra": "~11.2.0",
     "highlight.js": "11.8.0",
     "lodash.isequal": "4.5.0",
     "lodash.isequalwith": "4.4.0",
-    "markdownlint-cli2": "^0.10.0",
+    "markdownlint-cli2": "^0.11.0",
     "marked": "4.3.0",
     "mkdirp": "^3.0.1",
     "mocha": "10.2.0",
@@ -65,8 +65,8 @@
     "q": "1.5.1",
     "sinon": "17.0.1",
     "stream-browserify": "3.0.0",
-    "tsd": "0.29.0",
-    "typescript": "5.2.2",
+    "tsd": "0.30.3",
+    "typescript": "5.3.3",
     "uuid": "9.0.1",
     "webpack": "5.89.0"
   },

package/types/document.d.ts

@@ -184,8 +184,8 @@ declare module 'mongoose' {
      * Returns true if any of the given paths are modified, else false. If no arguments, returns `true` if any path
      * in this document is modified.
      */
-    isModified<T extends keyof DocType>(path?: T | Array<T>): boolean;
-    isModified(path?: string | Array<string>): boolean;
+    isModified<T extends keyof DocType>(path?: T | Array<T>, options?: { ignoreAtomics?: boolean } | null): boolean;
+    isModified(path?: string | Array<string>, options?: { ignoreAtomics?: boolean } | null): boolean;
 
     /** Boolean flag specifying if the document is new. */
     isNew: boolean;

package/types/index.d.ts

@@ -302,6 +302,9 @@ declare module 'mongoose' {
     /** The original object passed to the schema constructor */
     obj: SchemaDefinition<SchemaDefinitionType<EnforcedDocType>, EnforcedDocType>;
 
+    /** Returns a new schema that has the `paths` from the original schema, minus the omitted ones. */
+    omit<T = this>(paths: string[], options?: SchemaOptions): T;
+
     /** Gets/sets schema paths. */
     path<ResultType extends SchemaType = SchemaType<any, THydratedDocumentType>>(path: string): ResultType;
     path<pathGeneric extends keyof EnforcedDocType>(path: pathGeneric): SchemaType<EnforcedDocType[pathGeneric]>;

package/types/inferschematype.d.ts

@@ -262,15 +262,16 @@ type ResolvePathType<PathValueType, Options extends SchemaTypeOptions<PathValueT
                                     IfEquals<PathValueType, Schema.Types.Decimal128> extends true ? Types.Decimal128 :
                                       IfEquals<PathValueType, Types.Decimal128> extends true ? Types.Decimal128 :
                                         IfEquals<PathValueType, Schema.Types.BigInt> extends true ? bigint :
-                                          PathValueType extends 'bigint' | 'BigInt' | typeof Schema.Types.BigInt ? bigint :
-                                            PathValueType extends 'uuid' | 'UUID' | typeof Schema.Types.UUID ? Buffer :
-                                              IfEquals<PathValueType, Schema.Types.UUID> extends true ? Buffer :
-                                                PathValueType extends MapConstructor | 'Map' ? Map<string, ResolvePathType<Options['of']>> :
-                                                  IfEquals<PathValueType, typeof Schema.Types.Map> extends true ? Map<string, ResolvePathType<Options['of']>> :
-                                                    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> ? ObtainDocumentType<PathValueType, any, { typeKey: TypeKey }> :
-                                                                unknown;
+                                          IfEquals<PathValueType, BigInt> extends true ? bigint :
+                                            PathValueType extends 'bigint' | 'BigInt' | typeof Schema.Types.BigInt | typeof BigInt ? bigint :
+                                              PathValueType extends 'uuid' | 'UUID' | typeof Schema.Types.UUID ? Buffer :
+                                                IfEquals<PathValueType, Schema.Types.UUID> extends true ? Buffer :
+                                                  PathValueType extends MapConstructor | 'Map' ? Map<string, ResolvePathType<Options['of']>> :
+                                                    IfEquals<PathValueType, typeof Schema.Types.Map> extends true ? Map<string, ResolvePathType<Options['of']>> :
+                                                      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> ? ObtainDocumentType<PathValueType, any, { typeKey: TypeKey }> :
+                                                                  unknown;

package/types/models.d.ts

@@ -27,11 +27,12 @@ declare module 'mongoose' {
     skipValidation?: boolean;
     throwOnValidationError?: boolean;
     timestamps?: boolean;
+    strict?: boolean | 'throw';
   }
 
   interface MongooseBulkWritePerWriteOptions {
     timestamps?: boolean;
-    strict?: boolean;
+    strict?: boolean | 'throw';
     session?: ClientSession;
     skipValidation?: boolean;
   }
@@ -183,6 +184,10 @@ declare module 'mongoose' {
     /* Cast the given POJO to the model's schema */
     castObject(obj: AnyObject, options?: { ignoreCastErrors?: boolean }): TRawDocType;
 
+    /* Apply defaults to the given document or POJO. */
+    applyDefaults(obj: AnyObject): AnyObject;
+    applyDefaults(obj: TRawDocType): TRawDocType;
+
     /**
      * Sends multiple `insertOne`, `updateOne`, `updateMany`, `replaceOne`,
      * `deleteOne`, and/or `deleteMany` operations to the MongoDB server in one
@@ -218,7 +223,7 @@ declare module 'mongoose' {
     /** Creates a `countDocuments` query: counts the number of documents that match `filter`. */
     countDocuments(
       filter?: FilterQuery<TRawDocType>,
-      options?: QueryOptions<TRawDocType>
+      options?: (mongodb.CountOptions & Omit<MongooseSpecificQueryOptions, 'lean' | 'timestamps'>) | null
     ): QueryWithHelpers<
       number,
       THydratedDocumentType,
@@ -250,7 +255,7 @@ declare module 'mongoose' {
      */
     deleteMany(
       filter?: FilterQuery<TRawDocType>,
-      options?: QueryOptions<TRawDocType>
+      options?: (mongodb.DeleteOptions & Omit<MongooseSpecificQueryOptions, 'lean' | 'timestamps'>) | null
     ): QueryWithHelpers<
       mongodb.DeleteResult,
       THydratedDocumentType,
@@ -275,7 +280,7 @@ declare module 'mongoose' {
      */
     deleteOne(
       filter?: FilterQuery<TRawDocType>,
-      options?: QueryOptions<TRawDocType>
+      options?: (mongodb.DeleteOptions & Omit<MongooseSpecificQueryOptions, 'lean' | 'timestamps'>) | null
     ): QueryWithHelpers<
       mongodb.DeleteResult,
       THydratedDocumentType,
@@ -395,6 +400,10 @@ declare module 'mongoose' {
       docs: Array<TRawDocType>,
       options: InsertManyOptions & { rawResult: true; }
     ): Promise<mongodb.InsertManyResult<Require_id<THydratedDocumentType>>>;
+    insertMany(
+      doc: Array<TRawDocType>,
+      options: InsertManyOptions
+    ): Promise<Array<THydratedDocumentType>>;
     insertMany<DocContents = TRawDocType>(
       docs: Array<DocContents | TRawDocType>,
       options: InsertManyOptions & { lean: true; }
@@ -556,8 +565,8 @@ declare module 'mongoose' {
       'findOneAndDelete'
     >;
     findByIdAndDelete<ResultDoc = THydratedDocumentType>(
-      id?: mongodb.ObjectId | any,
-      options?: QueryOptions<TRawDocType> & { includeResultMetadata: true }
+      id: mongodb.ObjectId | any,
+      options: QueryOptions<TRawDocType> & { includeResultMetadata: true }
     ): QueryWithHelpers<ModifyResult<ResultDoc>, ResultDoc, TQueryHelpers, TRawDocType, 'findOneAndDelete'>;
     findByIdAndDelete<ResultDoc = THydratedDocumentType>(
       id?: mongodb.ObjectId | any,
@@ -608,11 +617,11 @@ declare module 'mongoose' {
       'findOneAndDelete'
     >;
     findOneAndDelete<ResultDoc = THydratedDocumentType>(
-      filter?: FilterQuery<TRawDocType>,
-      options?: QueryOptions<TRawDocType> & { includeResultMetadata: true }
+      filter: FilterQuery<TRawDocType>,
+      options: QueryOptions<TRawDocType> & { includeResultMetadata: true }
     ): QueryWithHelpers<ModifyResult<ResultDoc>, ResultDoc, TQueryHelpers, TRawDocType, 'findOneAndDelete'>;
     findOneAndDelete<ResultDoc = THydratedDocumentType>(
-      filter?: FilterQuery<TRawDocType>,
+      filter?: FilterQuery<TRawDocType> | null,
       options?: QueryOptions<TRawDocType> | null
     ): QueryWithHelpers<ResultDoc | null, ResultDoc, TQueryHelpers, TRawDocType, 'findOneAndDelete'>;
 
@@ -681,7 +690,7 @@ declare module 'mongoose' {
     replaceOne<ResultDoc = THydratedDocumentType>(
       filter?: FilterQuery<TRawDocType>,
       replacement?: TRawDocType | AnyObject,
-      options?: QueryOptions<TRawDocType> | null
+      options?: (mongodb.ReplaceOptions & MongooseSpecificQueryOptions) | null
     ): QueryWithHelpers<UpdateWriteOpResult, ResultDoc, TQueryHelpers, TRawDocType, 'replaceOne'>;
 
     /** Schema the model uses. */
@@ -691,14 +700,14 @@ declare module 'mongoose' {
     updateMany<ResultDoc = THydratedDocumentType>(
       filter?: FilterQuery<TRawDocType>,
       update?: UpdateQuery<TRawDocType> | UpdateWithAggregationPipeline,
-      options?: QueryOptions<TRawDocType> | null
+      options?: (mongodb.UpdateOptions & Omit<MongooseSpecificQueryOptions, 'lean'>) | null
     ): QueryWithHelpers<UpdateWriteOpResult, ResultDoc, TQueryHelpers, TRawDocType, 'updateMany'>;
 
     /** Creates a `updateOne` query: updates the first document that matches `filter` with `update`. */
     updateOne<ResultDoc = THydratedDocumentType>(
       filter?: FilterQuery<TRawDocType>,
       update?: UpdateQuery<TRawDocType> | UpdateWithAggregationPipeline,
-      options?: QueryOptions<TRawDocType> | null
+      options?: (mongodb.UpdateOptions & Omit<MongooseSpecificQueryOptions, 'lean'>) | null
     ): QueryWithHelpers<UpdateWriteOpResult, ResultDoc, TQueryHelpers, TRawDocType, 'updateOne'>;
 
     /** Creates a Query, applies the passed conditions, and returns the Query. */