mongoose 6.6.7 → 6.7.0

package/lib/schema/uuid.js

@@ -0,0 +1,329 @@
+/*!
+ * Module dependencies.
+ */
+
+'use strict';
+
+const MongooseBuffer = require('../types/buffer');
+const SchemaType = require('../schematype');
+const CastError = SchemaType.CastError;
+const utils = require('../utils');
+const isBsonType = require('../helpers/isBsonType');
+const handleBitwiseOperator = require('./operators/bitwise');
+
+const UUID_FORMAT = /[0-9a-f]{8}-[0-9a-f]{4}-[0-9][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}/i;
+const Binary = MongooseBuffer.Binary;
+
+/**
+ * Helper function to convert the input hex-string to a buffer
+ * @param {String} hex The hex string to convert
+ * @returns {Buffer} The hex as buffer
+ * @api private
+ */
+
+function hex2buffer(hex) {
+  // use buffer built-in function to convert from hex-string to buffer
+  const buff = Buffer.from(hex, 'hex');
+  return buff;
+}
+
+/**
+ * Helper function to convert the buffer input to a string
+ * @param {Buffer} buf The buffer to convert to a hex-string
+ * @returns {String} The buffer as a hex-string
+ * @api private
+ */
+
+function binary2hex(buf) {
+  // use buffer built-in function to convert from buffer to hex-string
+  const hex = buf.toString('hex');
+  return hex;
+}
+
+/**
+ * Convert a String to Binary
+ * @param {String} uuidStr The value to process
+ * @returns {MongooseBuffer} The binary to store
+ * @api private
+ */
+
+function stringToBinary(uuidStr) {
+  // Protect against undefined & throwing err
+  if (typeof uuidStr !== 'string') uuidStr = '';
+  const hex = uuidStr.replace(/[{}-]/g, ''); // remove extra characters
+  const bytes = hex2buffer(hex);
+  const buff = new MongooseBuffer(bytes);
+  buff._subtype = 4;
+
+  return buff;
+}
+
+/**
+ * Convert binary to a uuid string
+ * @param {Buffer|Binary|String} uuidBin The value to process
+ * @returns {String} The completed uuid-string
+ * @api private
+ */
+function binaryToString(uuidBin) {
+  // i(hasezoey) dont quite know why, but "uuidBin" may sometimes also be the already processed string
+  let hex;
+  if (typeof uuidBin !== 'string') {
+    hex = binary2hex(uuidBin);
+    const uuidStr = hex.substring(0, 8) + '-' + hex.substring(8, 8 + 4) + '-' + hex.substring(12, 12 + 4) + '-' + hex.substring(16, 16 + 4) + '-' + hex.substring(20, 20 + 12);
+    return uuidStr;
+  }
+  return uuidBin;
+}
+
+/**
+ * UUIDv1 SchemaType constructor.
+ *
+ * @param {String} key
+ * @param {Object} options
+ * @inherits SchemaType
+ * @api public
+ */
+
+function SchemaUUID(key, options) {
+  SchemaType.call(this, key, options, 'UUID');
+  this.getters.push(binaryToString);
+}
+
+/**
+ * This schema type's name, to defend against minifiers that mangle
+ * function names.
+ *
+ * @api public
+ */
+SchemaUUID.schemaName = 'UUID';
+
+SchemaUUID.defaultOptions = {};
+
+/*!
+ * Inherits from SchemaType.
+ */
+SchemaUUID.prototype = Object.create(SchemaType.prototype);
+SchemaUUID.prototype.constructor = SchemaUUID;
+
+/*!
+ * ignore
+ */
+
+SchemaUUID._cast = function(value) {
+  if (value === null) {
+    return value;
+  }
+
+  function newBuffer(initbuff) {
+    const buff = new MongooseBuffer(initbuff);
+    buff._subtype = 4;
+    return buff;
+  }
+
+  if (typeof value === 'string') {
+    if (UUID_FORMAT.test(value)) {
+      return stringToBinary(value);
+    } else {
+      throw new CastError(SchemaUUID.schemaName, value, this.path);
+    }
+  }
+
+  if (Buffer.isBuffer(value)) {
+    return newBuffer(value);
+  }
+
+  if (value instanceof Binary) {
+    return newBuffer(value.value(true));
+  }
+
+  // Re: gh-647 and gh-3030, we're ok with casting using `toString()`
+  // **unless** its the default Object.toString, because "[object Object]"
+  // doesn't really qualify as useful data
+  if (value.toString && value.toString !== Object.prototype.toString) {
+    if (UUID_FORMAT.test(value.toString())) {
+      return stringToBinary(value.toString());
+    }
+  }
+
+  throw new CastError(SchemaUUID.schemaName, value, this.path);
+};
+
+/**
+ * Sets a default option for all UUID instances.
+ *
+ * #### Example:
+ *
+ *     // Make all UUIDs have `required` of true by default.
+ *     mongoose.Schema.UUID.set('required', true);
+ *
+ *     const User = mongoose.model('User', new Schema({ test: mongoose.UUID }));
+ *     new User({ }).validateSync().errors.test.message; // Path `test` is required.
+ *
+ * @param {String} option The option you'd like to set the value for
+ * @param {Any} value value for option
+ * @return {undefined}
+ * @function set
+ * @static
+ * @api public
+ */
+
+SchemaUUID.set = SchemaType.set;
+
+/**
+ * Get/set the function used to cast arbitrary values to UUIDs.
+ *
+ * #### Example:
+ *
+ *     // Make Mongoose refuse to cast UUIDs with 0 length
+ *     const original = mongoose.Schema.Types.UUID.cast();
+ *     mongoose.UUID.cast(v => {
+ *       assert.ok(typeof v === "string" && v.length > 0);
+ *       return original(v);
+ *     });
+ *
+ *     // Or disable casting entirely
+ *     mongoose.UUID.cast(false);
+ *
+ * @param {Function} [caster]
+ * @return {Function}
+ * @function get
+ * @static
+ * @api public
+ */
+
+SchemaUUID.cast = function cast(caster) {
+  if (arguments.length === 0) {
+    return this._cast;
+  }
+  if (caster === false) {
+    caster = this._defaultCaster;
+  }
+  this._cast = caster;
+
+  return this._cast;
+};
+
+/*!
+ * ignore
+ */
+
+SchemaUUID._checkRequired = v => v != null;
+
+/**
+ * Override the function the required validator uses to check whether a string
+ * passes the `required` check.
+ *
+ * @param {Function} fn
+ * @return {Function}
+ * @function checkRequired
+ * @static
+ * @api public
+ */
+
+SchemaUUID.checkRequired = SchemaType.checkRequired;
+
+/**
+ * Check if the given value satisfies a required validator.
+ *
+ * @param {Any} value
+ * @return {Boolean}
+ * @api public
+ */
+
+SchemaUUID.prototype.checkRequired = function checkRequired(value) {
+  return UUID_FORMAT.test(value);
+};
+
+/**
+ * Casts to UUID
+ *
+ * @param {Object} value
+ * @param {Object} doc
+ * @param {Boolean} init whether this is an initialization cast
+ * @api private
+ */
+
+SchemaUUID.prototype.cast = function(value, doc, init) {
+  if (SchemaType._isRef(this, value, doc, init)) {
+    if (isBsonType(value, 'UUID')) {
+      return value;
+    }
+
+    return this._castRef(value, doc, init);
+  }
+
+  let castFn;
+  if (typeof this._castFunction === 'function') {
+    castFn = this._castFunction;
+  } else if (typeof this.constructor.cast === 'function') {
+    castFn = this.constructor.cast();
+  } else {
+    castFn = SchemaUUID.cast();
+  }
+
+  try {
+    return castFn(value);
+  } catch (error) {
+    throw new CastError(SchemaUUID.schemaName, value, this.path, error, this);
+  }
+};
+
+/*!
+ * ignore
+ */
+
+function handleSingle(val) {
+  return this.cast(val);
+}
+
+/*!
+ * ignore
+ */
+
+function handleArray(val) {
+  return val.map((m) => {
+    return this.cast(m);
+  });
+}
+
+SchemaUUID.prototype.$conditionalHandlers =
+utils.options(SchemaType.prototype.$conditionalHandlers, {
+  $bitsAllClear: handleBitwiseOperator,
+  $bitsAnyClear: handleBitwiseOperator,
+  $bitsAllSet: handleBitwiseOperator,
+  $bitsAnySet: handleBitwiseOperator,
+  $all: handleArray,
+  $gt: handleSingle,
+  $gte: handleSingle,
+  $in: handleArray,
+  $lt: handleSingle,
+  $lte: handleSingle,
+  $ne: handleSingle,
+  $nin: handleArray
+});
+
+/**
+ * Casts contents for queries.
+ *
+ * @param {String} $conditional
+ * @param {any} val
+ * @api private
+ */
+
+SchemaUUID.prototype.castForQuery = function($conditional, val) {
+  let handler;
+  if (arguments.length === 2) {
+    handler = this.$conditionalHandlers[$conditional];
+    if (!handler)
+      throw new Error('Can\'t use ' + $conditional + ' with UUID.');
+    return handler.call(this, val);
+  } else {
+    return this.cast($conditional);
+  }
+};
+
+/*!
+ * Module exports.
+ */
+
+module.exports = SchemaUUID;

package/lib/schema.js

@@ -170,17 +170,49 @@ function Schema(obj, options) {
  * @api private
  */
 function aliasFields(schema, paths) {
-  paths = paths || Object.keys(schema.paths);
-  for (const path of paths) {
-    const options = get(schema.paths[path], 'options');
-    if (options == null) {
+  for (const path of Object.keys(paths)) {
+    let alias = null;
+    if (paths[path] != null) {
+      alias = paths[path];
+    } else {
+      const options = get(schema.paths[path], 'options');
+      if (options == null) {
+        continue;
+      }
+
+      alias = options.alias;
+    }
+
+    if (!alias) {
       continue;
     }
 
     const prop = schema.paths[path].path;
-    const alias = options.alias;
+    if (Array.isArray(alias)) {
+      for (const a of alias) {
+        if (typeof a !== 'string') {
+          throw new Error('Invalid value for alias option on ' + prop + ', got ' + a);
+        }
+
+        schema.aliases[a] = prop;
+
+        schema.
+          virtual(a).
+          get((function(p) {
+            return function() {
+              if (typeof this.get === 'function') {
+                return this.get(p);
+              }
+              return this[p];
+            };
+          })(prop)).
+          set((function(p) {
+            return function(v) {
+              return this.$set(p, v);
+            };
+          })(prop));
+      }
 
-    if (!alias) {
       continue;
     }
 
@@ -659,9 +691,44 @@ Schema.prototype.add = function add(obj, prefix) {
     }
   }
 
-  const addedKeys = Object.keys(obj).
-    map(key => prefix ? prefix + key : key);
-  aliasFields(this, addedKeys);
+  const aliasObj = Object.fromEntries(
+    Object.entries(obj).map(([key]) => ([prefix + key, null]))
+  );
+  aliasFields(this, aliasObj);
+  return this;
+};
+
+/**
+ * Add an alias for `path`. This means getting or setting the `alias`
+ * is equivalent to getting or setting the `path`.
+ *
+ * #### Example:
+ *
+ *     const toySchema = new Schema({ n: String });
+ *
+ *     // Make 'name' an alias for 'n'
+ *     toySchema.alias('n', 'name');
+ *
+ *     const Toy = mongoose.model('Toy', toySchema);
+ *     const turboMan = new Toy({ n: 'Turbo Man' });
+ *
+ *     turboMan.name; // 'Turbo Man'
+ *     turboMan.n; // 'Turbo Man'
+ *
+ *     turboMan.name = 'Turbo Man Action Figure';
+ *     turboMan.n; // 'Turbo Man Action Figure'
+ *
+ *     await turboMan.save(); // Saves { _id: ..., n: 'Turbo Man Action Figure' }
+ *
+ *
+ * @param {String} path real path to alias
+ * @param {String|String[]} alias the path(s) to use as an alias for `path`
+ * @return {Schema} the Schema instance
+ * @api public
+ */
+
+Schema.prototype.alias = function alias(path, alias) {
+  aliasFields(this, { [path]: alias });
   return this;
 };
 
@@ -1106,6 +1173,7 @@ Schema.prototype.interpretAsType = function(path, obj, options) {
   // 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;
+  const Types = this.base != null ? this.base.Types : require('./types');
 
   if (!utils.isPOJO(obj) && !(obj instanceof SchemaTypeOptions)) {
     const constructorName = utils.getFunctionName(obj.constructor);
@@ -1240,6 +1308,10 @@ Schema.prototype.interpretAsType = function(path, obj, options) {
     name = 'Buffer';
   } else if (typeof type === 'function' || typeof type === 'object') {
     name = type.schemaName || utils.getFunctionName(type);
+  } else if (type === Types.ObjectId) {
+    name = 'ObjectId';
+  } else if (type === Types.Decimal128) {
+    name = 'Decimal128';
   } else {
     name = type == null ? '' + type : type.toString();
   }
@@ -1717,6 +1789,7 @@ Schema.prototype.post = function(name) {
  *
  * @param {Function} plugin The Plugin's callback
  * @param {Object} [opts] Options to pass to the plugin
+ * @param {Boolean} [opts.deduplicate=false] If true, ignore duplicate plugins (same `fn` argument using `===`)
  * @see plugins /docs/plugins.html
  * @api public
  */

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "mongoose",
   "description": "Mongoose MongoDB ODM",
-  "version": "6.6.7",
+  "version": "6.7.0",
   "author": "Guillermo Rauch <guillermo@learnboost.com>",
   "keywords": [
     "mongodb",
@@ -21,7 +21,7 @@
   "dependencies": {
     "bson": "^4.6.5",
     "kareem": "2.4.1",
-    "mongodb": "4.9.1",
+    "mongodb": "4.11.0",
     "mpath": "0.9.0",
     "mquery": "4.0.3",
     "ms": "2.1.3",

package/types/aggregate.d.ts

@@ -133,6 +133,9 @@ declare module 'mongoose' {
     /** Combines multiple aggregation pipelines. */
     facet(options: PipelineStage.Facet['$facet']): this;
 
+    /** Appends a new $fill operator to this aggregate pipeline */
+    fill(arg: PipelineStage.Fill['$fill']): this;
+
     /** Appends new custom $graphLookup operator(s) to this aggregate pipeline, performing a recursive search on a collection. */
     graphLookup(options: PipelineStage.GraphLookup['$graphLookup']): this;
 

package/types/expressions.d.ts

@@ -1190,6 +1190,26 @@ declare module 'mongoose' {
       $last: Expression;
     }
 
+    export interface LinearFill {
+      /**
+       * Fills null and missing fields in a window using linear interpolation based on surrounding field values.
+       *
+       * @version 5.3
+       * @see https://www.mongodb.com/docs/manual/reference/operator/aggregation/linearFill
+       */
+      $linearFill: Expression
+    }
+
+    export interface Locf {
+      /**
+       * Last observation carried forward. Sets values for null and missing fields in a window to the last non-null value for the field.
+       *
+       * @version 5.2
+       * @see https://www.mongodb.com/docs/manual/reference/operator/aggregation/locf
+       */
+      $locf: Expression
+    }
+
     export interface Map {
       /**
        * Applies a subexpression to each element of an array and returns the array of resulting values in order. Accepts named parameters.
@@ -2745,6 +2765,8 @@ declare module 'mongoose' {
     Expression.First |
     Expression.Integral |
     Expression.Last |
+    Expression.LinearFill |
+    Expression.Locf |
     Expression.Max |
     Expression.Min |
     Expression.Push |

package/types/index.d.ts

@@ -109,6 +109,7 @@ declare module 'mongoose' {
 
   /** Sets mongoose options */
   export function set<K extends keyof MongooseOptions>(key: K, value: MongooseOptions[K]): Mongoose;
+  export function set(options: { [K in keyof MongooseOptions]: MongooseOptions[K] }): Mongoose;
 
   /** The Mongoose version */
   export const version: string;
@@ -195,6 +196,12 @@ declare module 'mongoose' {
     /** Adds key path / schema type pairs to this schema. */
     add(obj: SchemaDefinition<SchemaDefinitionType<EnforcedDocType>> | Schema, prefix?: string): this;
 
+    /**
+     * Add an alias for `path`. This means getting or setting the `alias`
+     * is equivalent to getting or setting the `path`.
+     */
+    alias(path: string, alias: string | string[]): this;
+
     /**
      * Array of child schemas (from document arrays and single nested subdocs)
      * and their corresponding compiled models. Each element of the array is

package/types/inferschematype.d.ts

@@ -31,14 +31,14 @@ declare module 'mongoose' {
 
   /**
    * @summary Obtains document schema type from Schema instance.
-   * @param {SchemaType} SchemaType A generic of schema type instance.
+   * @param {Schema} TSchema `typeof` a schema instance.
    * @example
    * const userSchema = new Schema({userName:String});
    * type UserType = InferSchemaType<typeof userSchema>;
    * // result
    * type UserType = {userName?: string}
    */
-  type InferSchemaType<SchemaType> = ObtainSchemaGeneric<SchemaType, 'DocType'>;
+  type InferSchemaType<TSchema> = ObtainSchemaGeneric<TSchema, 'DocType'>;
 
   /**
    * @summary Obtains schema Generic type by using generic alias.
@@ -65,7 +65,7 @@ declare module 'mongoose' {
  * @param {P} P Document path.
  * @param {TypeKey} TypeKey A generic of literal string type."Refers to the property used for path type definition".
  */
-type IsPathRequired<P, TypeKey extends TypeKeyBaseType> =
+type IsPathRequired<P, TypeKey extends TypeKeyBaseType = DefaultTypeKey> =
   P extends { required: true | [true, string | undefined] } | ArrayConstructor | any[]
     ? true
     : P extends (Record<TypeKey, ArrayConstructor | any[]>)
@@ -83,7 +83,7 @@ type IsPathRequired<P, TypeKey extends TypeKeyBaseType> =
  * @description It helps to check if a path is defined by TypeKey OR not.
  * @param {TypeKey} TypeKey A literal string refers to path type property key.
  */
-type PathWithTypePropertyBaseType<TypeKey extends TypeKeyBaseType> = { [k in TypeKey]: any };
+type PathWithTypePropertyBaseType<TypeKey extends TypeKeyBaseType = DefaultTypeKey> = { [k in TypeKey]: any };
 
 /**
  * @summary A Utility to obtain schema's required path keys.
@@ -91,7 +91,7 @@ type PathWithTypePropertyBaseType<TypeKey extends TypeKeyBaseType> = { [k in Typ
  * @param {TypeKey} TypeKey A generic of literal string type."Refers to the property used for path type definition".
  * @returns required paths keys of document definition.
  */
-type RequiredPathKeys<T, TypeKey extends TypeKeyBaseType> = {
+type RequiredPathKeys<T, TypeKey extends TypeKeyBaseType = DefaultTypeKey> = {
   [K in keyof T]: IsPathRequired<T[K], TypeKey> extends true ? IfEquals<T[K], any, never, K> : never;
 }[keyof T];
 
@@ -101,7 +101,7 @@ type RequiredPathKeys<T, TypeKey extends TypeKeyBaseType> = {
  * @param {TypeKey} TypeKey A generic of literal string type."Refers to the property used for path type definition".
  * @returns a record contains required paths with the corresponding type.
  */
-type RequiredPaths<T, TypeKey extends TypeKeyBaseType> = {
+type RequiredPaths<T, TypeKey extends TypeKeyBaseType = DefaultTypeKey> = {
   [K in RequiredPathKeys<T, TypeKey>]: T[K];
 };
 
@@ -111,7 +111,7 @@ type RequiredPaths<T, TypeKey extends TypeKeyBaseType> = {
  * @param {TypeKey} TypeKey A generic of literal string type."Refers to the property used for path type definition".
  * @returns optional paths keys of document definition.
  */
-type OptionalPathKeys<T, TypeKey extends TypeKeyBaseType> = {
+type OptionalPathKeys<T, TypeKey extends TypeKeyBaseType = DefaultTypeKey> = {
   [K in keyof T]: IsPathRequired<T[K], TypeKey> extends true ? never : K;
 }[keyof T];
 
@@ -121,7 +121,7 @@ type OptionalPathKeys<T, TypeKey extends TypeKeyBaseType> = {
  * @param {TypeKey} TypeKey A generic of literal string type."Refers to the property used for path type definition".
  * @returns a record contains optional paths with the corresponding type.
  */
-type OptionalPaths<T, TypeKey extends TypeKeyBaseType> = {
+type OptionalPaths<T, TypeKey extends TypeKeyBaseType = DefaultTypeKey> = {
   [K in OptionalPathKeys<T, TypeKey>]?: T[K];
 };
 
@@ -131,7 +131,7 @@ type OptionalPaths<T, TypeKey extends TypeKeyBaseType> = {
  * @param {PathValueType} PathValueType Document definition path type.
  * @param {TypeKey} TypeKey A generic refers to document definition.
  */
-type ObtainDocumentPathType<PathValueType, TypeKey extends TypeKeyBaseType> = PathValueType extends Schema<any>
+type ObtainDocumentPathType<PathValueType, TypeKey extends TypeKeyBaseType = DefaultTypeKey> = PathValueType extends Schema<any>
   ? InferSchemaType<PathValueType>
   : ResolvePathType<
   PathValueType extends PathWithTypePropertyBaseType<TypeKey> ? PathValueType[TypeKey] : PathValueType,
@@ -154,19 +154,28 @@ type PathEnumOrString<T extends SchemaTypeOptions<string>['enum']> = T extends (
  */
 type ResolvePathType<PathValueType, Options extends SchemaTypeOptions<PathValueType> = {}, TypeKey extends TypeKeyBaseType = DefaultTypeKey> =
   PathValueType extends Schema ? InferSchemaType<PathValueType> :
-    PathValueType extends (infer Item)[] ? IfEquals<Item, never, any[], Item extends Schema ? Types.DocumentArray<ResolvePathType<Item>> : ResolvePathType<Item>[]> :
+    PathValueType extends (infer Item)[] ? IfEquals<Item, never, any[], Item extends Schema ? Types.DocumentArray<ObtainDocumentPathType<Item, TypeKey>> : ObtainDocumentPathType<Item, TypeKey>[]> :
       PathValueType extends StringSchemaDefinition ? PathEnumOrString<Options['enum']> :
-        PathValueType extends NumberSchemaDefinition ? Options['enum'] extends ReadonlyArray<any> ? Options['enum'][number] : number :
-          PathValueType extends DateSchemaDefinition ? Date :
-            PathValueType extends typeof Buffer | 'buffer' | 'Buffer' | typeof Schema.Types.Buffer ? Buffer :
-              PathValueType extends BooleanSchemaDefinition ? boolean :
-                PathValueType extends ObjectIdSchemaDefinition ? Types.ObjectId :
-                  PathValueType extends 'decimal128' | 'Decimal128' | typeof Schema.Types.Decimal128 ? Types.Decimal128 :
-                    PathValueType extends MapConstructor ? 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> :
-                                  unknown;
+        IfEquals<PathValueType, Schema.Types.String> extends true ? PathEnumOrString<Options['enum']> :
+          IfEquals<PathValueType, String> extends true ? PathEnumOrString<Options['enum']> :
+            PathValueType extends NumberSchemaDefinition ? Options['enum'] extends ReadonlyArray<any> ? Options['enum'][number] : number :
+              IfEquals<PathValueType, Schema.Types.Number> extends true ? number :
+                PathValueType extends DateSchemaDefinition ? Date :
+                  IfEquals<PathValueType, Schema.Types.Date> extends true ? Date :
+                    PathValueType extends typeof Buffer | 'buffer' | 'Buffer' | typeof Schema.Types.Buffer ? Buffer :
+                      PathValueType extends BooleanSchemaDefinition ? boolean :
+                        IfEquals<PathValueType, Schema.Types.Boolean> extends true ? boolean :
+                          PathValueType extends ObjectIdSchemaDefinition ? Types.ObjectId :
+                            IfEquals<PathValueType, Types.ObjectId> extends true ? Types.ObjectId :
+                              IfEquals<PathValueType, Schema.Types.ObjectId> extends true ? Types.ObjectId :
+                                PathValueType extends 'decimal128' | 'Decimal128' | typeof Schema.Types.Decimal128 ? Types.Decimal128 :
+                                  IfEquals<PathValueType, Schema.Types.Decimal128> extends true ? Types.Decimal128 :
+                                    IfEquals<PathValueType, Types.Decimal128> extends true ? Types.Decimal128 :
+                                      PathValueType extends MapConstructor ? 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> :
+                                                    unknown;

package/types/models.d.ts

@@ -1,10 +1,17 @@
 declare module 'mongoose' {
   import mongodb = require('mongodb');
 
+  export interface DiscriminatorOptions {
+    value?: string | number | ObjectId;
+    clone?: boolean;
+    overwriteModels?: boolean;
+    mergeHooks?: boolean;
+  }
+
   export interface AcceptsDiscriminator {
     /** Adds a discriminator type. */
-    discriminator<D>(name: string | number, schema: Schema, value?: string | number | ObjectId): Model<D>;
-    discriminator<T, U>(name: string | number, schema: Schema<T, U>, value?: string | number | ObjectId): U;
+    discriminator<D>(name: string | number, schema: Schema, value?: string | number | ObjectId | DiscriminatorOptions): Model<D>;
+    discriminator<T, U>(name: string | number, schema: Schema<T, U>, value?: string | number | ObjectId | DiscriminatorOptions): U;
   }
 
   interface MongooseBulkWriteOptions {