mongoose 8.0.2 → 8.0.3

package/lib/document.js

@@ -3691,8 +3691,7 @@ Document.prototype.$toObject = function(options, json) {
   const schemaOptions = this.$__schema && this.$__schema.options || {};
   // merge base default options with Schema's set default options if available.
   // `clone` is necessary here because `utils.options` directly modifies the second input.
-  defaultOptions = utils.options(defaultOptions, clone(baseOptions));
-  defaultOptions = utils.options(defaultOptions, clone(schemaOptions[path] || {}));
+  defaultOptions = { ...defaultOptions, ...baseOptions, ...schemaOptions[path] };
 
   // If options do not exist or is not an object, set it to empty object
   options = utils.isPOJO(options) ? { ...options } : {};
@@ -3754,7 +3753,7 @@ Document.prototype.$toObject = function(options, json) {
   }
 
   // merge default options with input options.
-  options = utils.options(defaultOptions, options);
+  options = { ...defaultOptions, ...options };
   options._isNested = true;
   options.json = json;
   options.minimize = _minimize;

package/lib/helpers/clone.js

@@ -54,7 +54,7 @@ function clone(obj, options, isArrayChild) {
       ret = obj.toObject(options);
     }
 
-    if (options && options.minimize && isSingleNested && Object.keys(ret).length === 0) {
+    if (options && options.minimize && !obj.constructor.$__required && isSingleNested && Object.keys(ret).length === 0) {
       return undefined;
     }
 

package/lib/helpers/discriminator/applyEmbeddedDiscriminators.js

@@ -0,0 +1,23 @@
+'use strict';
+
+module.exports = applyEmbeddedDiscriminators;
+
+function applyEmbeddedDiscriminators(schema, seen = new WeakSet()) {
+  if (seen.has(schema)) {
+    return;
+  }
+  seen.add(schema);
+  for (const path of Object.keys(schema.paths)) {
+    const schemaType = schema.paths[path];
+    if (!schemaType.schema) {
+      continue;
+    }
+    applyEmbeddedDiscriminators(schemaType.schema, seen);
+    if (!schemaType.schema._applyDiscriminators) {
+      continue;
+    }
+    for (const disc of schemaType.schema._applyDiscriminators.keys()) {
+      schemaType.discriminator(disc, schemaType.schema._applyDiscriminators.get(disc));
+    }
+  }
+}

package/lib/helpers/populate/assignVals.js

@@ -39,8 +39,10 @@ module.exports = function assignVals(o) {
   const options = o.options;
   const count = o.count && o.isVirtual;
   let i;
+  let setValueIndex = 0;
 
   function setValue(val) {
+    ++setValueIndex;
     if (count) {
       return val;
     }
@@ -80,11 +82,14 @@ module.exports = function assignVals(o) {
       return valueFilter(val[0], options, populateOptions, _allIds);
     } else if (o.justOne === false && !Array.isArray(val)) {
       return valueFilter([val], options, populateOptions, _allIds);
+    } else if (o.justOne === true && !Array.isArray(val) && Array.isArray(_allIds)) {
+      return valueFilter(val, options, populateOptions, val == null ? val : _allIds[setValueIndex - 1]);
     }
     return valueFilter(val, options, populateOptions, _allIds);
   }
 
   for (i = 0; i < docs.length; ++i) {
+    setValueIndex = 0;
     const _path = o.path.endsWith('.$*') ? o.path.slice(0, -3) : o.path;
     const existingVal = mpath.get(_path, docs[i], lookupLocalFields);
     if (existingVal == null && !getVirtual(o.originalModel.schema, _path)) {

package/lib/helpers/projection/isExclusive.js

@@ -12,13 +12,12 @@ module.exports = function isExclusive(projection) {
   }
 
   const keys = Object.keys(projection);
-  let ki = keys.length;
   let exclude = null;
 
-  if (ki === 1 && keys[0] === '_id') {
+  if (keys.length === 1 && keys[0] === '_id') {
     exclude = !projection._id;
   } else {
-    while (ki--) {
+    for (let ki = 0; ki < keys.length; ++ki) {
       // Does this projection explicitly define inclusion/exclusion?
       // Explicitly avoid `$meta` and `$slice`
       const key = keys[ki];

package/lib/model.js

@@ -4300,7 +4300,7 @@ function populate(model, docs, options, callback) {
         select = select.replace(excludeIdRegGlobal, ' ');
       } else {
         // preserve original select conditions by copying
-        select = utils.object.shallowCopy(select);
+        select = { ...select };
         delete select._id;
       }
     }

package/lib/mongoose.js

@@ -30,6 +30,7 @@ const sanitizeFilter = require('./helpers/query/sanitizeFilter');
 const isBsonType = require('./helpers/isBsonType');
 const MongooseError = require('./error/mongooseError');
 const SetOptionError = require('./error/setOptionError');
+const applyEmbeddedDiscriminators = require('./helpers/discriminator/applyEmbeddedDiscriminators');
 
 const defaultMongooseSymbol = Symbol.for('mongoose:default');
 
@@ -627,6 +628,8 @@ Mongoose.prototype._model = function(name, schema, collection, options) {
     }
   }
 
+  applyEmbeddedDiscriminators(schema);
+
   return model;
 };
 

package/lib/query.js

@@ -4791,16 +4791,14 @@ Query.prototype._castFields = function _castFields(fields) {
       elemMatchKeys,
       keys,
       key,
-      out,
-      i;
+      out;
 
   if (fields) {
     keys = Object.keys(fields);
     elemMatchKeys = [];
-    i = keys.length;
 
     // collect $elemMatch args
-    while (i--) {
+    for (let i = 0; i < keys.length; ++i) {
       key = keys[i];
       if (fields[key].$elemMatch) {
         selected || (selected = {});
@@ -4819,8 +4817,7 @@ Query.prototype._castFields = function _castFields(fields) {
     }
 
     // apply the casted field args
-    i = elemMatchKeys.length;
-    while (i--) {
+    for (let i = 0; i < elemMatchKeys.length; ++i) {
       key = elemMatchKeys[i];
       fields[key] = out[key];
     }

package/lib/queryHelpers.js

@@ -180,11 +180,12 @@ exports.applyPaths = function applyPaths(fields, schema) {
       if (!isDefiningProjection(field)) {
         continue;
       }
-      // `_id: 1, name: 0` is a mixed inclusive/exclusive projection in
-      // MongoDB 4.0 and earlier, but not in later versions.
       if (keys[keyIndex] === '_id' && keys.length > 1) {
         continue;
       }
+      if (keys[keyIndex] === schema.options.discriminatorKey && keys.length > 1 && field != null && !field) {
+        continue;
+      }
       exclude = !field;
       break;
     }

package/lib/schema/bigint.js

@@ -7,7 +7,6 @@
 const CastError = require('../error/cast');
 const SchemaType = require('../schemaType');
 const castBigInt = require('../cast/bigint');
-const utils = require('../utils');
 
 /**
  * BigInt SchemaType constructor.
@@ -177,12 +176,13 @@ SchemaBigInt.prototype.cast = function(value) {
  * ignore
  */
 
-SchemaBigInt.$conditionalHandlers = utils.options(SchemaType.prototype.$conditionalHandlers, {
+SchemaBigInt.$conditionalHandlers = {
+  ...SchemaType.prototype.$conditionalHandlers,
   $gt: handleSingle,
   $gte: handleSingle,
   $lt: handleSingle,
   $lte: handleSingle
-});
+};
 
 /*!
  * ignore

package/lib/schema/boolean.js

@@ -7,7 +7,6 @@
 const CastError = require('../error/cast');
 const SchemaType = require('../schemaType');
 const castBoolean = require('../cast/boolean');
-const utils = require('../utils');
 
 /**
  * Boolean SchemaType constructor.
@@ -235,8 +234,7 @@ SchemaBoolean.prototype.cast = function(value) {
   }
 };
 
-SchemaBoolean.$conditionalHandlers =
-    utils.options(SchemaType.prototype.$conditionalHandlers, {});
+SchemaBoolean.$conditionalHandlers = { ...SchemaType.prototype.$conditionalHandlers };
 
 /**
  * Casts contents for queries.

package/lib/schema/buffer.js

@@ -250,17 +250,17 @@ function handleSingle(val, context) {
   return this.castForQuery(null, val, context);
 }
 
-SchemaBuffer.prototype.$conditionalHandlers =
-    utils.options(SchemaType.prototype.$conditionalHandlers, {
-      $bitsAllClear: handleBitwiseOperator,
-      $bitsAnyClear: handleBitwiseOperator,
-      $bitsAllSet: handleBitwiseOperator,
-      $bitsAnySet: handleBitwiseOperator,
-      $gt: handleSingle,
-      $gte: handleSingle,
-      $lt: handleSingle,
-      $lte: handleSingle
-    });
+SchemaBuffer.prototype.$conditionalHandlers = {
+  ...SchemaType.prototype.$conditionalHandlers,
+  $bitsAllClear: handleBitwiseOperator,
+  $bitsAnyClear: handleBitwiseOperator,
+  $bitsAllSet: handleBitwiseOperator,
+  $bitsAnySet: handleBitwiseOperator,
+  $gt: handleSingle,
+  $gte: handleSingle,
+  $lt: handleSingle,
+  $lte: handleSingle
+};
 
 /**
  * Casts contents for queries.

package/lib/schema/date.js

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

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.

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,

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.

package/lib/schema.js

@@ -560,7 +560,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 +577,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) + '`');
@@ -1122,15 +1123,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/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.3",
   "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.5",
+    "@babel/preset-env": "7.23.5",
     "@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.55.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",
@@ -66,7 +66,7 @@
     "sinon": "17.0.1",
     "stream-browserify": "3.0.0",
     "tsd": "0.29.0",
-    "typescript": "5.2.2",
+    "typescript": "5.3.2",
     "uuid": "9.0.1",
     "webpack": "5.89.0"
   },

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

@@ -183,6 +183,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
@@ -395,6 +399,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; }
@@ -608,11 +616,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'>;