mongoose 8.17.1 → 8.18.0

package/lib/document.js

@@ -4070,15 +4070,17 @@ Document.prototype.$__toObjectShallow = function $__toObjectShallow(schemaFields
  *
  * If you want to skip transformations, use `transform: false`:
  *
- *     schema.options.toObject.hide = '_id';
- *     schema.options.toObject.transform = function (doc, ret, options) {
- *       if (options.hide) {
- *         options.hide.split(' ').forEach(function (prop) {
- *           delete ret[prop];
- *         });
+ *     schema.options.toObject = {
+ *       hide: '_id',
+ *       transform: function(doc, ret, options) {
+ *         if (options.hide) {
+ *           options.hide.split(' ').forEach(function(prop) {
+ *             delete ret[prop];
+ *           });
+ *         }
+ *         return ret;
  *       }
- *       return ret;
- *     }
+ *     };
  *
  *     const doc = new Doc({ _id: 'anId', secret: 47, name: 'Wreck-it Ralph' });
  *     doc.toObject();                                        // { secret: 47, name: 'Wreck-it Ralph' }

package/lib/error/messages.js

@@ -43,5 +43,5 @@ msg.Date.max = 'Path `{PATH}` ({VALUE}) is after maximum allowed value ({MAX}).'
 msg.String = {};
 msg.String.enum = '`{VALUE}` is not a valid enum value for path `{PATH}`.';
 msg.String.match = 'Path `{PATH}` is invalid ({VALUE}).';
-msg.String.minlength = 'Path `{PATH}` (`{VALUE}`) is shorter than the minimum allowed length ({MINLENGTH}).';
-msg.String.maxlength = 'Path `{PATH}` (`{VALUE}`) is longer than the maximum allowed length ({MAXLENGTH}).';
+msg.String.minlength = 'Path `{PATH}` (`{VALUE}`, length {LENGTH}) is shorter than the minimum allowed length ({MINLENGTH}).';
+msg.String.maxlength = 'Path `{PATH}` (`{VALUE}`, length {LENGTH}) is longer than the maximum allowed length ({MAXLENGTH}).';

package/lib/model.js

@@ -4304,6 +4304,10 @@ Model.validate = async function validate(obj, pathsOrOptions, context) {
   let remaining = paths.size;
 
   return new Promise((resolve, reject) => {
+    if (remaining === 0) {
+      return settle();
+    }
+
     for (const path of paths) {
       const schemaType = schema.path(path);
       if (schemaType == null) {
@@ -4328,13 +4332,17 @@ Model.validate = async function validate(obj, pathsOrOptions, context) {
       }, context, { path: path });
     }
 
+    function settle() {
+      if (error) {
+        reject(error);
+      } else {
+        resolve(obj);
+      }
+    }
+
     function _checkDone() {
       if (--remaining <= 0) {
-        if (error) {
-          reject(error);
-        } else {
-          resolve(obj);
-        }
+        return settle();
       }
     }
   });

package/lib/options/schemaUnionOptions.js

@@ -0,0 +1,32 @@
+'use strict';
+
+const SchemaTypeOptions = require('./schemaTypeOptions');
+
+/**
+ * The options defined on a Union schematype.
+ *
+ * @api public
+ * @inherits SchemaTypeOptions
+ * @constructor SchemaUnionOptions
+ */
+
+class SchemaUnionOptions extends SchemaTypeOptions {}
+
+const opts = require('./propertyOptions');
+
+/**
+ * If set, specifies the types that this union can take. Mongoose will cast
+ * the value to one of the given types.
+ *
+ * If not set, Mongoose will not cast the value to any specific type.
+ *
+ * @api public
+ * @property of
+ * @memberOf SchemaUnionOptions
+ * @type {Function|Function[]|string|string[]}
+ * @instance
+ */
+
+Object.defineProperty(SchemaUnionOptions.prototype, 'of', opts);
+
+module.exports = SchemaUnionOptions;

package/lib/schema/array.js

@@ -654,6 +654,8 @@ function cast$elemMatch(val, context) {
  * For example, `$conditionalHandlers.$all` is the function Mongoose calls to cast `$all` filter operators.
  *
  * @property $conditionalHandlers
+ * @memberOf SchemaArray
+ * @instance
  * @api public
  */
 

package/lib/schema/bigint.js

@@ -100,7 +100,7 @@ SchemaBigInt.get = SchemaType.get;
  *
  * @param {Function} caster
  * @return {Function}
- * @function get
+ * @function cast
  * @static
  * @api public
  */
@@ -190,6 +190,8 @@ const $conditionalHandlers = {
  * For example, `$conditionalHandlers.$in` is the function Mongoose calls to cast `$in` filter operators.
  *
  * @property $conditionalHandlers
+ * @memberOf SchemaBigInt
+ * @instance
  * @api public
  */
 

package/lib/schema/boolean.js

@@ -105,7 +105,7 @@ SchemaBoolean.get = SchemaType.get;
  *
  * @param {Function} caster
  * @return {Function}
- * @function get
+ * @function cast
  * @static
  * @api public
  */
@@ -242,6 +242,8 @@ const $conditionalHandlers = { ...SchemaType.prototype.$conditionalHandlers };
  * For example, `$conditionalHandlers.$in` is the function Mongoose calls to cast `$in` filter operators.
  *
  * @property $conditionalHandlers
+ * @memberOf SchemaBoolean
+ * @instance
  * @api public
  */
 

package/lib/schema/buffer.js

@@ -276,6 +276,8 @@ const $conditionalHandlers = {
  * For example, `$conditionalHandlers.$exists` is the function Mongoose calls to cast `$exists` filter operators.
  *
  * @property $conditionalHandlers
+ * @memberOf SchemaBuffer
+ * @instance
  * @api public
  */
 

package/lib/schema/date.js

@@ -111,7 +111,7 @@ SchemaDate.get = SchemaType.get;
  *
  * @param {Function} caster
  * @return {Function}
- * @function get
+ * @function cast
  * @static
  * @api public
  */
@@ -402,6 +402,8 @@ const $conditionalHandlers = {
  * For example, `$conditionalHandlers.$gte` is the function Mongoose calls to cast `$gte` filter operators.
  *
  * @property $conditionalHandlers
+ * @memberOf SchemaDate
+ * @instance
  * @api public
  */
 

package/lib/schema/decimal128.js

@@ -227,6 +227,8 @@ const $conditionalHandlers = {
  * For example, `$conditionalHandlers.$lte` is the function Mongoose calls to cast `$lte` filter operators.
  *
  * @property $conditionalHandlers
+ * @memberOf SchemaDecimal128
+ * @instance
  * @api public
  */
 

package/lib/schema/documentArray.js

@@ -122,6 +122,8 @@ SchemaDocumentArray.prototype.OptionsConstructor = SchemaDocumentArrayOptions;
  * For example, `$conditionalHandlers.$size` is the function Mongoose calls to cast `$size` filter operators.
  *
  * @property $conditionalHandlers
+ * @memberOf SchemaDocumentArray
+ * @instance
  * @api public
  */
 

package/lib/schema/double.js

@@ -115,7 +115,7 @@ SchemaDouble._defaultCaster = v => {
  *
  * @param {Function} caster
  * @return {Function}
- * @function get
+ * @function cast
  * @static
  * @api public
  */
@@ -210,6 +210,8 @@ const $conditionalHandlers = {
  * For example, `$conditionalHandlers.$lt` is the function Mongoose calls to cast `$lt` filter operators.
  *
  * @property $conditionalHandlers
+ * @memberOf SchemaDouble
+ * @instance
  * @api public
  */
 

package/lib/schema/index.js

@@ -12,6 +12,8 @@ exports.Buffer = require('./buffer');
 exports.Date = require('./date');
 exports.Decimal128 = exports.Decimal = require('./decimal128');
 exports.DocumentArray = require('./documentArray');
+exports.Double = require('./double');
+exports.Int32 = require('./int32');
 exports.Map = require('./map');
 exports.Mixed = require('./mixed');
 exports.Number = require('./number');
@@ -19,8 +21,7 @@ exports.ObjectId = require('./objectId');
 exports.String = require('./string');
 exports.Subdocument = require('./subdocument');
 exports.UUID = require('./uuid');
-exports.Double = require('./double');
-exports.Int32 = require('./int32');
+exports.Union = require('./union');
 
 // alias
 

package/lib/schema/int32.js

@@ -119,7 +119,7 @@ SchemaInt32._defaultCaster = v => {
  *
  * @param {Function} caster
  * @return {Function}
- * @function get
+ * @function cast
  * @static
  * @api public
  */
@@ -214,6 +214,8 @@ const $conditionalHandlers = {
  * For example, `$conditionalHandlers.$gt` is the function Mongoose calls to cast `$gt` filter operators.
  *
  * @property $conditionalHandlers
+ * @memberOf SchemaInt32
+ * @instance
  * @api public
  */
 

package/lib/schema/number.js

@@ -93,7 +93,7 @@ SchemaNumber._cast = castNumber;
  *
  * @param {Function} caster
  * @return {Function}
- * @function get
+ * @function cast
  * @static
  * @api public
  */
@@ -418,6 +418,8 @@ const $conditionalHandlers = {
  * For example, `$conditionalHandlers.$gte` is the function Mongoose calls to cast `$gte` filter operators.
  *
  * @property $conditionalHandlers
+ * @memberOf SchemaNumber
+ * @instance
  * @api public
  */
 

package/lib/schema/objectId.js

@@ -143,7 +143,7 @@ SchemaObjectId._cast = castObjectId;
  *
  * @param {Function} caster
  * @return {Function}
- * @function get
+ * @function cast
  * @static
  * @api public
  */
@@ -273,6 +273,8 @@ const $conditionalHandlers = {
  * For example, `$conditionalHandlers.$in` is the function Mongoose calls to cast `$in` filter operators.
  *
  * @property $conditionalHandlers
+ * @memberOf SchemaObjectId
+ * @instance
  * @api public
  */
 
@@ -310,6 +312,7 @@ function resetId(v) {
  * @param [options]
  * @param [options.useBsonType=false] If true, return a representation with `bsonType` for use with MongoDB's `$jsonSchema`.
  * @returns {Object} JSON schema properties
+ * @api public
  */
 
 SchemaObjectId.prototype.toJSONSchema = function toJSONSchema(options) {

package/lib/schema/string.js

@@ -75,7 +75,7 @@ SchemaString._cast = castString;
  *
  * @param {Function} caster
  * @return {Function}
- * @function get
+ * @function cast
  * @static
  * @api public
  */
@@ -665,6 +665,8 @@ const $conditionalHandlers = {
  * For example, `$conditionalHandlers.$exists` is the function Mongoose calls to cast `$exists` filter operators.
  *
  * @property $conditionalHandlers
+ * @memberOf SchemaString
+ * @instance
  * @api public
  */
 

package/lib/schema/subdocument.js

@@ -158,6 +158,8 @@ $conditionalHandlers.$exists = $exists;
  * For example, `$conditionalHandlers.$exists` is the function Mongoose calls to cast `$exists` filter operators.
  *
  * @property $conditionalHandlers
+ * @memberOf SchemaSubdocument
+ * @instance
  * @api public
  */
 

package/lib/schema/union.js

@@ -0,0 +1,105 @@
+'use strict';
+
+/*!
+ * ignore
+ */
+
+const SchemaUnionOptions = require('../options/schemaUnionOptions');
+const SchemaType = require('../schemaType');
+
+const firstValueSymbol = Symbol('firstValue');
+
+/*!
+ * ignore
+ */
+
+class Union extends SchemaType {
+  constructor(key, options, schemaOptions = {}) {
+    super(key, options, 'Union');
+    if (!options || !Array.isArray(options.of) || options.of.length === 0) {
+      throw new Error('Union schema type requires an array of types');
+    }
+    this.schemaTypes = options.of.map(obj => options.parentSchema.interpretAsType(key, obj, schemaOptions));
+  }
+
+  cast(val, doc, init, prev, options) {
+    let firstValue = firstValueSymbol;
+    let lastError;
+    // Loop through each schema type in the union. If one of the schematypes returns a value that is `=== val`, then
+    // use `val`. Otherwise, if one of the schematypes casted successfully, use the first successfully casted value.
+    // Finally, if none of the schematypes casted successfully, throw the error from the last schema type in the union.
+    // The `=== val` check is a workaround to ensure that the original value is returned if it matches one of the schema types,
+    // avoiding cases like where numbers are casted to strings or dates even if the schema type is a number.
+    for (let i = 0; i < this.schemaTypes.length; ++i) {
+      try {
+        const casted = this.schemaTypes[i].cast(val, doc, init, prev, options);
+        if (casted === val) {
+          return casted;
+        }
+        if (firstValue === firstValueSymbol) {
+          firstValue = casted;
+        }
+      } catch (error) {
+        lastError = error;
+      }
+    }
+    if (firstValue !== firstValueSymbol) {
+      return firstValue;
+    }
+    throw lastError;
+  }
+
+  // Setters also need to be aware of casting - we need to apply the setters of the entry in the union we choose.
+  applySetters(val, doc, init, prev, options) {
+    let firstValue = firstValueSymbol;
+    let lastError;
+    // Loop through each schema type in the union. If one of the schematypes returns a value that is `=== val`, then
+    // use `val`. Otherwise, if one of the schematypes casted successfully, use the first successfully casted value.
+    // Finally, if none of the schematypes casted successfully, throw the error from the last schema type in the union.
+    // The `=== val` check is a workaround to ensure that the original value is returned if it matches one of the schema types,
+    // avoiding cases like where numbers are casted to strings or dates even if the schema type is a number.
+    for (let i = 0; i < this.schemaTypes.length; ++i) {
+      try {
+        let castedVal = this.schemaTypes[i]._applySetters(val, doc, init, prev, options);
+        if (castedVal == null) {
+          castedVal = this.schemaTypes[i]._castNullish(castedVal);
+        } else {
+          castedVal = this.schemaTypes[i].cast(castedVal, doc, init, prev, options);
+        }
+        if (castedVal === val) {
+          return castedVal;
+        }
+        if (firstValue === firstValueSymbol) {
+          firstValue = castedVal;
+        }
+      } catch (error) {
+        lastError = error;
+      }
+    }
+    if (firstValue !== firstValueSymbol) {
+      return firstValue;
+    }
+    throw lastError;
+  }
+
+  clone() {
+    const schematype = super.clone();
+
+    schematype.schemaTypes = this.schemaTypes.map(schemaType => schemaType.clone());
+    return schematype;
+  }
+}
+
+/**
+ * This schema type's name, to defend against minifiers that mangle
+ * function names.
+ *
+ * @api public
+ */
+Union.schemaName = 'Union';
+
+Union.defaultOptions = {};
+
+Union.prototype.OptionsConstructor = SchemaUnionOptions;
+
+module.exports = Union;

package/lib/schema/uuid.js

@@ -263,6 +263,8 @@ const $conditionalHandlers = {
  * For example, `$conditionalHandlers.$exists` is the function Mongoose calls to cast `$exists` filter operators.
  *
  * @property $conditionalHandlers
+ * @memberOf SchemaUUID
+ * @instance
  * @api public
  */
 

package/lib/schema.js

@@ -1525,7 +1525,7 @@ Object.defineProperty(Schema.prototype, 'base', {
  *
  * @param {String} path
  * @param {Object} obj constructor
- * @param {Object} options
+ * @param {Object} options schema options
  * @api private
  */
 
@@ -1539,7 +1539,6 @@ Schema.prototype.interpretAsType = function(path, obj, options) {
     return clone;
   }
 
-
   // If this schema has an associated Mongoose object, use the Mongoose object's
   // copy of SchemaTypes re: gh-7158 gh-6933
   const MongooseTypes = this.base != null ? this.base.Schema.Types : Schema.Types;
@@ -1740,7 +1739,10 @@ Schema.prototype.interpretAsType = function(path, obj, options) {
       'https://bit.ly/mongoose-schematypes for a list of valid schema types.');
   }
 
-  const schemaType = new MongooseTypes[name](path, obj);
+  if (name === 'Union') {
+    obj.parentSchema = this;
+  }
+  const schemaType = new MongooseTypes[name](path, obj, options);
 
   if (schemaType.$isSchemaMap) {
     createMapNestedSchemaType(this, schemaType, path, obj, options);

package/lib/schemaType.js

@@ -1349,6 +1349,12 @@ SchemaType.prototype.doValidate = function(value, fn, scope, options) {
     validatorProperties.path = options && options.path ? options.path : path;
     validatorProperties.fullPath = this.$fullPath;
     validatorProperties.value = value;
+    if (typeof value === 'string') {
+      validatorProperties.length = value.length;
+      if (validatorProperties.value.length > 30) {
+        validatorProperties.value = validatorProperties.value.slice(0, 30) + '...';
+      }
+    }
 
     if (validator instanceof RegExp) {
       validate(validator.test(value), validatorProperties, scope);
@@ -1470,6 +1476,12 @@ SchemaType.prototype.doValidateSync = function(value, scope, options) {
     validatorProperties.path = options && options.path ? options.path : path;
     validatorProperties.fullPath = this.$fullPath;
     validatorProperties.value = value;
+    if (typeof value === 'string') {
+      validatorProperties.length = value.length;
+      if (validatorProperties.value.length > 30) {
+        validatorProperties.value = validatorProperties.value.slice(0, 30) + '...';
+      }
+    }
     let ok = false;
 
     // Skip any explicit async validators. Validators that return a promise
@@ -1643,6 +1655,8 @@ function handle$in(val, context) {
  * For example, `$conditionalHandlers.$exists` is the function Mongoose calls to cast `$exists` filter operators.
  *
  * @property $conditionalHandlers
+ * @memberOf SchemaType
+ * @instance
  * @api public
  */
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "mongoose",
   "description": "Mongoose MongoDB ODM",
-  "version": "8.17.1",
+  "version": "8.18.0",
   "author": "Guillermo Rauch <guillermo@learnboost.com>",
   "keywords": [
     "mongodb",

package/types/collection.d.ts

@@ -1,46 +1,49 @@
 declare module 'mongoose' {
   import mongodb = require('mongodb');
 
-  /*
-   * section collection.js
-   */
-  interface CollectionBase<T extends mongodb.Document> extends mongodb.Collection<T> {
-    /*
-     * Abstract methods. Some of these are already defined on the
-     * mongodb.Collection interface so they've been commented out.
+  export class BaseCollection<T extends mongodb.Document> extends mongodb.Collection<T> {
+    /**
+     * Collection constructor
+     * @param name name of the collection
+     * @param conn A MongooseConnection instance
+     * @param opts optional collection options
      */
+    constructor(name: string, conn: Connection, opts?: any);
+
+    /*
+    * Abstract methods. Some of these are already defined on the
+    * mongodb.Collection interface so they've been commented out.
+    */
     ensureIndex(...args: any[]): any;
     findAndModify(...args: any[]): any;
     getIndexes(...args: any[]): any;
 
+    /** Formatter for debug print args */
+    $format(arg: any, color?: boolean, shell?: boolean): string;
+    /** Debug print helper */
+    $print(name: string, i: string | number, args: any[], color?: boolean, shell?: boolean): void;
+
     /** The collection name */
-    collectionName: string;
+    get collectionName(): string;
     /** The Connection instance */
     conn: Connection;
     /** The collection name */
     name: string;
   }
 
-  export type BaseCollection<T extends mongodb.Document> = CollectionBase<T>;
-
   /*
    * section drivers/node-mongodb-native/collection.js
    */
-  interface Collection<T extends mongodb.Document = mongodb.Document> extends CollectionBase<T> {
+  class Collection<T extends mongodb.Document = mongodb.Document> extends BaseCollection<T> {
     /**
      * Collection constructor
      * @param name name of the collection
      * @param conn A MongooseConnection instance
      * @param opts optional collection options
      */
-    // eslint-disable-next-line @typescript-eslint/no-misused-new
-    new(name: string, conn: Connection, opts?: any): Collection<T>;
-    /** Formatter for debug print args */
-    $format(arg: any, color?: boolean, shell?: boolean): string;
-    /** Debug print helper */
-    $print(name: string, i: string | number, args: any[], color?: boolean, shell?: boolean): void;
+    constructor(name: string, conn: Connection, opts?: any);
+
     /** Retrieves information about this collections indexes. */
     getIndexes(): ReturnType<mongodb.Collection<T>['indexInformation']>;
   }
-  let Collection: Collection;
 }

package/types/connection.d.ts

@@ -71,8 +71,6 @@ declare module 'mongoose' {
       };
   }[keyof SchemaMap];
 
-  export type BaseConnection = Connection;
-
   class Connection extends events.EventEmitter implements SessionStarter {
     /** Runs a [db-level aggregate()](https://www.mongodb.com/docs/manual/reference/method/db.aggregate/) on this connection's underlying `db` */
     aggregate<ResultType = unknown>(pipeline?: PipelineStage[] | null, options?: AggregateOptions): Aggregate<Array<ResultType>>;
@@ -286,4 +284,5 @@ declare module 'mongoose' {
     withSession<T = any>(executor: (session: ClientSession) => Promise<T>): Promise<T>;
   }
 
+  export class BaseConnection extends Connection {}
 }

package/types/document.d.ts

@@ -256,12 +256,17 @@ declare module 'mongoose' {
     set(value: string | Record<string, any>): this;
 
     /** The return value of this method is used in calls to JSON.stringify(doc). */
-    toJSON(options: ToObjectOptions & { virtuals: true }): Default__v<Require_id<DocType & TVirtuals>, TSchemaOptions>;
-    toJSON(options?: ToObjectOptions & { flattenMaps?: true, flattenObjectIds?: false }): FlattenMaps<Default__v<Require_id<DocType>, TSchemaOptions>>;
-    toJSON(options: ToObjectOptions & { flattenObjectIds: false }): FlattenMaps<Default__v<Require_id<DocType>, TSchemaOptions>>;
-    toJSON(options: ToObjectOptions & { flattenObjectIds: true }): ObjectIdToString<FlattenMaps<Default__v<Require_id<DocType>, TSchemaOptions>>>;
-    toJSON(options: ToObjectOptions & { flattenMaps: false }): Default__v<Require_id<DocType>, TSchemaOptions>;
-    toJSON(options: ToObjectOptions & { flattenMaps: false; flattenObjectIds: true }): ObjectIdToString<Default__v<Require_id<DocType>, TSchemaOptions>>;
+    toJSON(options: ToObjectOptions & { versionKey: false, virtuals: true, flattenObjectIds: true }): Omit<ObjectIdToString<FlattenMaps<Require_id<DocType & TVirtuals>>>, '__v'>;
+    toJSON(options: ToObjectOptions & { virtuals: true, flattenObjectIds: true }): ObjectIdToString<FlattenMaps<Default__v<Require_id<DocType & TVirtuals>, ResolveSchemaOptions<TSchemaOptions>>>>;
+    toJSON(options: ToObjectOptions & { versionKey: false, virtuals: true }): Omit<Require_id<DocType & TVirtuals>, '__v'>;
+    toJSON(options: ToObjectOptions & { versionKey: false, flattenObjectIds: true }): ObjectIdToString<FlattenMaps<Omit<Require_id<DocType>, '__v'>>>;
+    toJSON(options: ToObjectOptions & { virtuals: true }): Default__v<Require_id<DocType & TVirtuals>, ResolveSchemaOptions<TSchemaOptions>>;
+    toJSON(options: ToObjectOptions & { versionKey: false }): Omit<Require_id<DocType & TVirtuals>, '__v'>;
+    toJSON(options?: ToObjectOptions & { flattenMaps?: true, flattenObjectIds?: false }): FlattenMaps<Default__v<Require_id<DocType>, ResolveSchemaOptions<TSchemaOptions>>>;
+    toJSON(options: ToObjectOptions & { flattenObjectIds: false }): FlattenMaps<Default__v<Require_id<DocType>, ResolveSchemaOptions<TSchemaOptions>>>;
+    toJSON(options: ToObjectOptions & { flattenObjectIds: true }): ObjectIdToString<FlattenMaps<Default__v<Require_id<DocType>, ResolveSchemaOptions<TSchemaOptions>>>>;
+    toJSON(options: ToObjectOptions & { flattenMaps: false }): Default__v<Require_id<DocType>, ResolveSchemaOptions<TSchemaOptions>>;
+    toJSON(options: ToObjectOptions & { flattenMaps: false, flattenObjectIds: true }): ObjectIdToString<Default__v<Require_id<DocType>, ResolveSchemaOptions<TSchemaOptions>>>;
 
     toJSON<T = Default__v<Require_id<DocType>, TSchemaOptions>>(options?: ToObjectOptions & { flattenMaps?: true, flattenObjectIds?: false }): FlattenMaps<T>;
     toJSON<T = Default__v<Require_id<DocType>, TSchemaOptions>>(options: ToObjectOptions & { flattenObjectIds: false }): FlattenMaps<T>;
@@ -270,9 +275,15 @@ declare module 'mongoose' {
     toJSON<T = Default__v<Require_id<DocType>, TSchemaOptions>>(options: ToObjectOptions & { flattenMaps: false, flattenObjectIds: true }): ObjectIdToString<T>;
 
     /** Converts this document into a plain-old JavaScript object ([POJO](https://masteringjs.io/tutorials/fundamentals/pojo)). */
-    toObject(options: ToObjectOptions & { virtuals: true }): Default__v<Require_id<DocType & TVirtuals>, TSchemaOptions>;
-    toObject(options?: ToObjectOptions): Default__v<Require_id<DocType>, TSchemaOptions>;
-    toObject<T>(options?: ToObjectOptions): Default__v<Require_id<T>, TSchemaOptions>;
+    toObject(options: ToObjectOptions & { versionKey: false, virtuals: true, flattenObjectIds: true }): Omit<ObjectIdToString<Require_id<DocType & TVirtuals>>, '__v'>;
+    toObject(options: ToObjectOptions & { virtuals: true, flattenObjectIds: true }): ObjectIdToString<Default__v<Require_id<DocType & TVirtuals>, ResolveSchemaOptions<TSchemaOptions>>>;
+    toObject(options: ToObjectOptions & { versionKey: false, flattenObjectIds: true }): Omit<ObjectIdToString<Require_id<DocType & TVirtuals>>, '__v'>;
+    toObject(options: ToObjectOptions & { versionKey: false, virtuals: true }): Omit<Require_id<DocType & TVirtuals>, '__v'>;
+    toObject(options: ToObjectOptions & { virtuals: true }): Default__v<Require_id<DocType & TVirtuals>, ResolveSchemaOptions<TSchemaOptions>>;
+    toObject(options: ToObjectOptions & { versionKey: false }): Omit<Require_id<DocType & TVirtuals>, '__v'>;
+    toObject(options: ToObjectOptions & { flattenObjectIds: true }): ObjectIdToString<Default__v<Require_id<DocType & TVirtuals>, ResolveSchemaOptions<TSchemaOptions>>>;
+    toObject(options?: ToObjectOptions): Default__v<Require_id<DocType>, ResolveSchemaOptions<TSchemaOptions>>;
+    toObject<T>(options?: ToObjectOptions): Default__v<Require_id<T>, ResolveSchemaOptions<TSchemaOptions>>;
 
     /** Clears the modified state on the specified path. */
     unmarkModified<T extends keyof DocType>(path: T): void;