mongoose 6.4.1 → 6.4.4

package/lib/types/map.js

@@ -42,6 +42,14 @@ class MongooseMap extends Map {
     super.set(key, value);
   }
 
+  /**
+   * Overwrites native Map's `get()` function to support Mongoose getters.
+   *
+   * @api public
+   * @method get
+   * @memberOf Map
+   */
+
   get(key, options) {
     if (isBsonType(key, 'ObjectID')) {
       key = key.toString();
@@ -54,6 +62,20 @@ class MongooseMap extends Map {
     return this.$__schemaType.applyGetters(super.get(key), this.$__parent);
   }
 
+  /**
+   * Overwrites native Map's `set()` function to support setters, `populate()`,
+   * and change tracking. Note that Mongoose maps _only_ support strings and
+   * ObjectIds as keys.
+   *
+   * #### Example:
+   *     doc.myMap.set('test', 42); // works
+   *     doc.myMap.set({ obj: 42 }, 42); // Throws "Mongoose maps only support string keys"
+   *
+   * @api public
+   * @method set
+   * @memberOf Map
+   */
+
   set(key, value) {
     if (isBsonType(key, 'ObjectID')) {
       key = key.toString();
@@ -108,6 +130,14 @@ class MongooseMap extends Map {
     }
   }
 
+  /**
+   * Overwrites native Map's `clear()` function to support change tracking.
+   *
+   * @api public
+   * @method clear
+   * @memberOf Map
+   */
+
   clear() {
     super.clear();
     const parent = this.$__parent;
@@ -116,6 +146,14 @@ class MongooseMap extends Map {
     }
   }
 
+  /**
+   * Overwrites native Map's `delete()` function to support change tracking.
+   *
+   * @api public
+   * @method delete
+   * @memberOf Map
+   */
+
   delete(key) {
     if (isBsonType(key, 'ObjectID')) {
       key = key.toString();
@@ -125,6 +163,14 @@ class MongooseMap extends Map {
     super.delete(key);
   }
 
+  /**
+   * Converts this map to a native JavaScript Map so the MongoDB driver can serialize it.
+   *
+   * @api public
+   * @method toBSON
+   * @memberOf Map
+   */
+
   toBSON() {
     return new Map(this);
   }
@@ -146,6 +192,21 @@ class MongooseMap extends Map {
     return this.constructor.prototype.toObject.apply(this, arguments);
   }
 
+  /**
+   * Converts this map to a native JavaScript Map for `JSON.stringify()`. Set
+   * the `flattenMaps` option to convert this map to a POJO instead.
+   *
+   * #### Example:
+   *     doc.myMap.toJSON() instanceof Map; // true
+   *     doc.myMap.toJSON({ flattenMaps: true }) instanceof Map; // false
+   *
+   * @api public
+   * @method toJSON
+   * @param {Object} [options]
+   * @param {Boolean} [options.flattenMaps=false] set to `true` to convert the map to a POJO rather than a native JavaScript map
+   * @memberOf Map
+   */
+
   toJSON(options) {
     if (typeof (options && options.flattenMaps) === 'boolean' ? options.flattenMaps : true) {
       const ret = {};
@@ -209,6 +270,15 @@ Object.defineProperty(MongooseMap.prototype, '$__schemaType', {
   configurable: false
 });
 
+/**
+ * Set to `true` for all Mongoose map instances
+ *
+ * @api public
+ * @property $isMongooseMap
+ * @memberOf MongooseMap
+ * @instance
+ */
+
 Object.defineProperty(MongooseMap.prototype, '$isMongooseMap', {
   enumerable: false,
   writable: false,

package/lib/types/objectid.js

@@ -1,7 +1,7 @@
 /**
  * ObjectId type constructor
  *
- * #### Example
+ * #### Example:
  *
  *     const id = new mongoose.Types.ObjectId;
  *

package/lib/types/subdocument.js

@@ -188,7 +188,7 @@ Subdocument.prototype.isModified = function(paths, modifiedPaths) {
  * @param {String} path the field to mark as valid
  * @api private
  * @method $markValid
- * @receiver Subdocument
+ * @memberOf Subdocument
  */
 
 Subdocument.prototype.$markValid = function(path) {

package/lib/virtualtype.js

@@ -75,7 +75,7 @@ VirtualType.prototype.clone = function() {
  * Mongoose calls the getter function with the below 3 parameters.
  *
  * - `value`: the value returned by the previous getter. If there is only one getter, `value` will be `undefined`.
- * - `virtual`: the virtual object you called `.get()` on
+ * - `virtual`: the virtual object you called `.get()` on.
  * - `doc`: the document this virtual is attached to. Equivalent to `this`.
  *
  * #### Example:
@@ -85,7 +85,7 @@ VirtualType.prototype.clone = function() {
  *       return this.name.first + ' ' + this.name.last;
  *     });
  *
- * @param {Function(Any, VirtualType, Document)} fn
+ * @param {function} fn
  * @return {VirtualType} this
  * @api public
  */
@@ -100,8 +100,8 @@ VirtualType.prototype.get = function(fn) {
  *
  * Mongoose calls the setter function with the below 3 parameters.
  *
- * - `value`: the value being set
- * - `virtual`: the virtual object you're calling `.set()` on
+ * - `value`: the value being set.
+ * - `virtual`: the virtual object you're calling `.set()` on.
  * - `doc`: the document this virtual is attached to. Equivalent to `this`.
  *
  * #### Example:
@@ -120,7 +120,7 @@ VirtualType.prototype.get = function(fn) {
  *     doc.name.first; // 'Jean-Luc'
  *     doc.name.last; // 'Picard'
  *
- * @param {Function(Any, VirtualType, Document)} fn
+ * @param {function} fn
  * @return {VirtualType} this
  * @api public
  */

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "mongoose",
   "description": "Mongoose MongoDB ODM",
-  "version": "6.4.1",
+  "version": "6.4.4",
   "author": "Guillermo Rauch <guillermo@learnboost.com>",
   "keywords": [
     "mongodb",
@@ -28,9 +28,9 @@
     "sift": "16.0.0"
   },
   "devDependencies": {
-    "@babel/core": "7.18.2",
-    "@typescript-eslint/eslint-plugin": "5.27.0",
-    "@typescript-eslint/parser": "5.27.0",
+    "@babel/core": "7.18.6",
+    "@typescript-eslint/eslint-plugin": "5.30.3",
+    "@typescript-eslint/parser": "5.30.3",
     "acquit": "1.2.1",
     "acquit-ignore": "0.2.0",
     "acquit-require": "0.1.1",
@@ -40,19 +40,19 @@
     "benchmark": "2.1.4",
     "bluebird": "3.7.2",
     "buffer": "^5.6.0",
-    "cheerio": "1.0.0-rc.11",
+    "cheerio": "1.0.0-rc.12",
     "crypto-browserify": "3.12.0",
-    "dox": "0.3.1",
-    "eslint": "8.16.0",
+    "dox": "0.9.1",
+    "eslint": "8.19.0",
     "eslint-plugin-mocha-no-only": "1.1.1",
     "highlight.js": "11.5.1",
     "lodash.isequal": "4.5.0",
     "lodash.isequalwith": "4.4.0",
-    "marked": "4.0.16",
+    "marked": "4.0.17",
     "mkdirp": "^1.0.4",
     "mocha": "10.0.0",
     "moment": "2.x",
-    "mongodb-memory-server": "8.6.0",
+    "mongodb-memory-server": "8.7.2",
     "ncp": "^2.0.0",
     "nyc": "15.1.0",
     "pug": "3.0.2",
@@ -62,9 +62,9 @@
     "stream-browserify": "3.0.0",
     "ts-benchmark": "^1.0.2",
     "tsd": "0.20.0",
-    "typescript": "4.7.2",
+    "typescript": "4.7.4",
     "uuid": "8.3.2",
-    "webpack": "5.72.1"
+    "webpack": "5.73.0"
   },
   "directories": {
     "lib": "./lib/mongoose"
@@ -98,7 +98,7 @@
     "test-tsd": "node ./test/types/check-types-filename && tsd",
     "tdd": "mocha ./test/*.test.js --inspect --watch --recursive --watch-files ./**/*.{js,ts}",
     "test-coverage": "nyc --reporter=html --reporter=text npm test",
-    "ts-benchmark": "ts-benchmark -p ./benchmarks/typescript/simple -f 17 18 29 32",
+    "ts-benchmark": "node ./benchmarks/typescript.js",
     "ts-benchmark-watch": "ts-benchmark -p ./benchmarks/typescript/simple -w ./types -i -s -f 17 18 29 32 -b master"
   },
   "main": "./index.js",
@@ -145,4 +145,4 @@
       "target": "ES2017"
     }
   }
-}
+}

package/types/collection.d.ts

@@ -43,4 +43,4 @@ declare module 'mongoose' {
     getIndexes(): ReturnType<mongodb.Collection<T>['indexInformation']>;
   }
   let Collection: Collection;
-}
+}

package/types/document.d.ts

@@ -200,10 +200,10 @@ declare module 'mongoose' {
     $parent(): Document | undefined;
 
     /** Populates document references. */
-    populate<Paths = {}>(path: string | PopulateOptions | (string | PopulateOptions)[]): Promise<this & Paths>;
-    populate<Paths = {}>(path: string | PopulateOptions | (string | PopulateOptions)[], callback: Callback<this & Paths>): void;
-    populate<Paths = {}>(path: string, select?: string | AnyObject, model?: Model<any>, match?: AnyObject, options?: PopulateOptions): Promise<this & Paths>;
-    populate<Paths = {}>(path: string, select?: string | AnyObject, model?: Model<any>, match?: AnyObject, options?: PopulateOptions, callback?: Callback<this & Paths>): void;
+    populate<Paths = {}>(path: string | PopulateOptions | (string | PopulateOptions)[]): Promise<MergeType<this, Paths>>;
+    populate<Paths = {}>(path: string | PopulateOptions | (string | PopulateOptions)[], callback: Callback<MergeType<this, Paths>>): void;
+    populate<Paths = {}>(path: string, select?: string | AnyObject, model?: Model<any>, match?: AnyObject, options?: PopulateOptions): Promise<MergeType<this, Paths>>;
+    populate<Paths = {}>(path: string, select?: string | AnyObject, model?: Model<any>, match?: AnyObject, options?: PopulateOptions, callback?: Callback<MergeType<this, Paths>>): void;
 
     /** Gets _id(s) used during population of the given `path`. If the path was not populated, returns `undefined`. */
     populated(path: string): any;

package/types/expressions.d.ts

@@ -32,7 +32,7 @@ declare module 'mongoose' {
        *
        * @see https://docs.mongodb.com/manual/reference/operator/aggregation/add/#mongodb-expression-exp.-add
        */
-      $add: (NumberExpression | DateExpression)[];
+      $add: Expression[];
     }
 
     export interface Ceil {
@@ -1034,7 +1034,7 @@ declare module 'mongoose' {
        *
        * @see https://docs.mongodb.com/manual/reference/operator/aggregation/ne/#mongodb-expression-exp.-ne
        */
-      $ne: Expression | [Expression, Expression] | null;
+      $ne: Expression | [Expression, Expression | NullExpression] | null;
     }
 
     export interface Cond {
@@ -1043,7 +1043,7 @@ declare module 'mongoose' {
        *
        * @see https://docs.mongodb.com/manual/reference/operator/aggregation/cond/#mongodb-expression-exp.-cond
        */
-      $cond: { if: BooleanExpression, then: AnyExpression, else: AnyExpression } | [BooleanExpression, AnyExpression, AnyExpression];
+      $cond: { if: Expression, then: AnyExpression, else: AnyExpression } | [BooleanExpression, AnyExpression, AnyExpression];
     }
 
     export interface IfNull {
@@ -1957,7 +1957,7 @@ declare module 'mongoose' {
        * @version 5.0
        * @see https://docs.mongodb.com/manual/reference/operator/aggregation/addToSet/#mongodb-expression-exp.-addToSet
        */
-      $addToSet: ArrayExpression;
+      $addToSet: Expression | Record<string, Expression>;
     }
 
     export interface Avg {
@@ -1967,7 +1967,7 @@ declare module 'mongoose' {
        * @version 5.0
        * @see https://docs.mongodb.com/manual/reference/operator/aggregation/avg/#mongodb-expression-exp.-avg
        */
-      $avg: ArrayExpression;
+      $avg: Expression;
     }
 
     export interface Count {
@@ -2316,6 +2316,21 @@ declare module 'mongoose' {
       $toObjectId: Expression;
     }
 
+    export interface Top {
+      $top: {
+        sortBy: AnyObject,
+        output: Expression
+      };
+    }
+
+    export interface TopN {
+      $topN: {
+        n: Expression,
+        sortBy: AnyObject,
+        output: Expression
+      };
+    }
+
     export interface ToString {
       /**
        * Converts a value to a string. If the value cannot be converted to a string, $toString errors. If the value is
@@ -2406,7 +2421,10 @@ declare module 'mongoose' {
     TypeExpressionOperator |
     AccumulatorOperator |
     VariableExpressionOperator |
-    WindowOperator;
+    WindowOperator |
+    Expression.Top |
+    Expression.TopN |
+    any;
 
   export type NullExpression = null;
 
@@ -2478,7 +2496,8 @@ declare module 'mongoose' {
     DataSizeOperatorReturningNumber |
     CustomAggregationExpressionOperatorReturningAny |
     TypeExpressionOperatorReturningNumber |
-    DateExpression;
+    DateExpression |
+    DateExpressionOperatorReturningNumber;
 
   export type ObjectExpression =
     Path |
@@ -2879,4 +2898,4 @@ declare module 'mongoose' {
   export type DateExpressionOperatorReturningString =
     Expression.DateToString;
 
-}
+}

package/types/index.d.ts

@@ -166,7 +166,7 @@ declare module 'mongoose' {
     /**
      * Create a new schema
      */
-    constructor(definition?: SchemaDefinition<SchemaDefinitionType<EnforcedDocType>> | DocType, options?: SchemaOptions<TPathTypeKey, DocType, TInstanceMethods, TQueryHelpers, TStaticMethods>);
+    constructor(definition?: SchemaDefinition<SchemaDefinitionType<EnforcedDocType>> | DocType, options?: SchemaOptions<TPathTypeKey, FlatRecord<DocType>, TInstanceMethods, TQueryHelpers, TStaticMethods>);
 
     /** Adds key path / schema type pairs to this schema. */
     add(obj: SchemaDefinition<SchemaDefinitionType<EnforcedDocType>> | Schema, prefix?: string): this;
@@ -227,6 +227,7 @@ declare module 'mongoose' {
     obj: SchemaDefinition<SchemaDefinitionType<EnforcedDocType>>;
 
     /** Gets/sets schema paths. */
+    path<pathGeneric extends keyof EnforcedDocType>(path: pathGeneric): SchemaType<EnforcedDocType[pathGeneric]>;
     path<ResultType extends SchemaType = SchemaType>(path: string): ResultType;
     path(path: string, constructor: any): this;
 

package/types/indexes.d.ts

@@ -93,6 +93,6 @@ declare module 'mongoose' {
      * ```
      */
     expires?: number | string;
-    weights?: AnyObject;
+    weights?: Record<string, number>;
   }
-}
+}

package/types/inferschematype.d.ts

@@ -1,4 +1,4 @@
-import { Schema, InferSchemaType, SchemaType, SchemaTypeOptions, TypeKeyBaseType } from 'mongoose';
+import { Schema, InferSchemaType, SchemaType, SchemaTypeOptions, TypeKeyBaseType, Types, NumberSchemaDefinition, StringSchemaDefinition, BooleanSchemaDefinition, DateSchemaDefinition } from 'mongoose';
 
 declare module 'mongoose' {
   /**
@@ -6,13 +6,13 @@ declare module 'mongoose' {
    * @description Obtains document schema type from document Definition OR returns enforced schema type if it's provided.
    * @param {DocDefinition} DocDefinition A generic equals to the type of document definition "provided in as first parameter in Schema constructor".
    * @param {EnforcedDocType} EnforcedDocType A generic type enforced by user "provided before schema constructor".
-   * @param {TypeKey} TypeKey A generic of literal string type.
+   * @param {TypeKey} TypeKey A generic of literal string type."Refers to the property used for path type definition".
    */
-  type ObtainDocumentType<DocDefinition, EnforcedDocType = any, TypeKey extends TypeKeyBaseType = DefaultTypeKey> =
-    IsItRecordAndNotAny<EnforcedDocType> extends true ? EnforcedDocType : {
-      [K in keyof (RequiredPaths<DocDefinition> &
-      OptionalPaths<DocDefinition>)]: ObtainDocumentPathType<DocDefinition[K], TypeKey>;
-    };
+   type ObtainDocumentType<DocDefinition, EnforcedDocType = any, TypeKey extends TypeKeyBaseType = DefaultTypeKey> =
+   IsItRecordAndNotAny<EnforcedDocType> extends true ? EnforcedDocType : {
+     [K in keyof (RequiredPaths<DocDefinition, TypeKey> &
+     OptionalPaths<DocDefinition, TypeKey>)]: ObtainDocumentPathType<DocDefinition[K], TypeKey>;
+   };
 
   /**
    * @summary Obtains document schema type from Schema instance.
@@ -64,10 +64,22 @@ type IfEquals<T, U, Y = true, N = false> =
     (<G>() => G extends U ? 1 : 0) ? Y : N;
 
 /**
- * @summary Required path base type.
- * @description It helps to check whereas if a path is required OR optional.
+ * @summary Checks if a document path is required or optional.
+ * @param {P} P Document path.
+ * @param {TypeKey} TypeKey A generic of literal string type."Refers to the property used for path type definition".
  */
-type RequiredPathBaseType = { required: true | [true, string | undefined] };
+type IsPathRequired<P, TypeKey extends TypeKeyBaseType> =
+  P extends { required: true | [true, string | undefined] } | ArrayConstructor | any[]
+    ? true
+    : P extends (Record<TypeKey, ArrayConstructor | any[]>)
+      ? P extends { default: undefined }
+        ? false
+        : true
+      : P extends (Record<TypeKey, NumberSchemaDefinition | StringSchemaDefinition | BooleanSchemaDefinition | DateSchemaDefinition>)
+        ? P extends { default: ResolvePathType<P[TypeKey]> }
+          ? true
+          : false
+        : false;
 
 /**
  * @summary Path base type defined by using TypeKey
@@ -79,37 +91,41 @@ type PathWithTypePropertyBaseType<TypeKey extends TypeKeyBaseType> = { [k in Typ
 /**
  * @summary A Utility to obtain schema's required path keys.
  * @param {T} T A generic refers to document definition.
+ * @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> = {
-  [K in keyof T]: T[K] extends RequiredPathBaseType ? IfEquals<T[K], any, never, K> : never;
+type RequiredPathKeys<T, TypeKey extends TypeKeyBaseType> = {
+  [K in keyof T]: IsPathRequired<T[K], TypeKey> extends true ? IfEquals<T[K], any, never, K> : never;
 }[keyof T];
 
 /**
  * @summary A Utility to obtain schema's required paths.
  * @param {T} T A generic refers to document definition.
+ * @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> = {
-  [K in RequiredPathKeys<T>]: T[K];
+type RequiredPaths<T, TypeKey extends TypeKeyBaseType> = {
+  [K in RequiredPathKeys<T, TypeKey>]: T[K];
 };
 
 /**
  * @summary A Utility to obtain schema's optional path keys.
  * @param {T} T A generic refers to document definition.
+ * @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> = {
-  [K in keyof T]: T[K] extends RequiredPathBaseType ? never : K;
+type OptionalPathKeys<T, TypeKey extends TypeKeyBaseType> = {
+  [K in keyof T]: IsPathRequired<T[K], TypeKey> extends true ? never : K;
 }[keyof T];
 
 /**
  * @summary A Utility to obtain schema's optional paths.
  * @param {T} T A generic refers to document definition.
+ * @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> = {
-  [K in OptionalPathKeys<T>]?: T[K];
+type OptionalPaths<T, TypeKey extends TypeKeyBaseType> = {
+  [K in OptionalPathKeys<T, TypeKey>]?: T[K];
 };
 
 /**
@@ -138,18 +154,20 @@ type PathEnumOrString<T extends SchemaTypeOptions<string>['enum']> = T extends (
  * @returns Number, "Number" or "number" will be resolved to string type.
  */
 type ResolvePathType<PathValueType, Options extends SchemaTypeOptions<PathValueType> = {}> =
-  PathValueType extends (infer Item)[] ? IfEquals<Item, never, any, ResolvePathType<Item>>[] :
-    PathValueType extends StringConstructor | 'string' | 'String' | typeof Schema.Types.String ? PathEnumOrString<Options['enum']> :
-      PathValueType extends NumberConstructor | 'number' | 'Number' | typeof Schema.Types.Number ? number :
-        PathValueType extends DateConstructor | 'date' | 'Date' | typeof Schema.Types.Date ? Date :
-          PathValueType extends typeof Buffer | 'buffer' | 'Buffer' | typeof Schema.Types.Buffer ? Buffer :
-            PathValueType extends BooleanConstructor | 'boolean' | 'Boolean' | typeof Schema.Types.Boolean ? boolean :
-              PathValueType extends 'objectId' | 'ObjectId' | typeof Schema.Types.ObjectId ? Schema.Types.ObjectId :
-                PathValueType extends 'decimal128' | 'Decimal128' | typeof Schema.Types.Decimal128 ? Schema.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'] :
-                              unknown;
+  PathValueType extends Schema ? InferSchemaType<PathValueType> :
+    PathValueType extends (infer Item)[] ? IfEquals<Item, never, any, ResolvePathType<Item>>[] :
+      PathValueType extends StringSchemaDefinition ? PathEnumOrString<Options['enum']> :
+        PathValueType extends NumberSchemaDefinition ? number :
+          PathValueType extends DateSchemaDefinition ? Date :
+            PathValueType extends typeof Buffer | 'buffer' | 'Buffer' | typeof Schema.Types.Buffer ? Buffer :
+              PathValueType extends BooleanSchemaDefinition ? boolean :
+                PathValueType extends 'objectId' | 'ObjectId' | typeof Schema.Types.ObjectId ? 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 {} ? PathValueType :
+                                  unknown;

package/types/middlewares.d.ts

@@ -11,4 +11,4 @@ declare module 'mongoose' {
   type PreSaveMiddlewareFunction<ThisType = any> = (this: ThisType, next: CallbackWithoutResultAndOptionalError, opts: SaveOptions) => void | Promise<void>;
   type PostMiddlewareFunction<ThisType = any, ResType = any> = (this: ThisType, res: ResType, next: CallbackWithoutResultAndOptionalError) => void | Promise<void>;
   type ErrorHandlingMiddlewareFunction<ThisType = any, ResType = any> = (this: ThisType, err: NativeError, res: ResType, next: CallbackWithoutResultAndOptionalError) => void;
-}
+}

package/types/models.d.ts

@@ -106,7 +106,7 @@ declare module 'mongoose' {
     checkKeys?: boolean;
     j?: boolean;
     safe?: boolean | WriteConcern;
-    timestamps?: boolean;
+    timestamps?: boolean | QueryTimestampsConfig;
     validateBeforeSave?: boolean;
     validateModifiedOnly?: boolean;
     w?: number | string;
@@ -163,11 +163,11 @@ declare module 'mongoose' {
     countDocuments(callback?: Callback<number>): QueryWithHelpers<number, HydratedDocument<T, TMethodsAndOverrides, TVirtuals>, TQueryHelpers, T>;
 
     /** Creates a new document or documents */
-    create<DocContents = T>(docs: Array<T | DocContents>, options?: SaveOptions): Promise<HydratedDocument<MergeType<MergeType<T, DocContents>, RequireOnlyTypedId<T>>, TMethodsAndOverrides, TVirtuals>[]>;
-    create<DocContents = T>(docs: Array<T | DocContents>, callback: Callback<HydratedDocument<MergeType<MergeType<T, DocContents>, RequireOnlyTypedId<T>>, TMethodsAndOverrides, TVirtuals>[]>): void;
-    create<DocContents = T>(doc: DocContents | T): Promise<HydratedDocument<MergeType<MergeType<T, DocContents>, RequireOnlyTypedId<T>>, TMethodsAndOverrides, TVirtuals>>;
-    create<DocContents = T>(...docs: Array<T | DocContents>): Promise<HydratedDocument<MergeType<MergeType<T, DocContents>, RequireOnlyTypedId<T>>, TMethodsAndOverrides, TVirtuals>[]>;
-    create<DocContents = T>(doc: T | DocContents, callback: Callback<HydratedDocument<MergeType<MergeType<T, DocContents>, RequireOnlyTypedId<T>>, TMethodsAndOverrides, TVirtuals>>): void;
+    create<DocContents = AnyKeys<T>>(docs: Array<T | DocContents>, options?: SaveOptions): Promise<HydratedDocument<T, TMethodsAndOverrides, TVirtuals>[]>;
+    create<DocContents = AnyKeys<T>>(docs: Array<T | DocContents>, callback: Callback<HydratedDocument<T, TMethodsAndOverrides, TVirtuals>[]>): void;
+    create<DocContents = AnyKeys<T>>(doc: DocContents | T): Promise<HydratedDocument<T, TMethodsAndOverrides, TVirtuals>>;
+    create<DocContents = AnyKeys<T>>(...docs: Array<T | DocContents>): Promise<HydratedDocument<T, TMethodsAndOverrides, TVirtuals>[]>;
+    create<DocContents = AnyKeys<T>>(doc: T | DocContents, callback: Callback<HydratedDocument<T, TMethodsAndOverrides, TVirtuals>>): void;
 
     /**
    * Create the collection for this model. By default, if no indexes are specified,
@@ -351,6 +351,7 @@ declare module 'mongoose' {
     findOneAndRemove<ResultDoc = HydratedDocument<T, TMethodsAndOverrides, TVirtuals>>(filter?: FilterQuery<T>, options?: QueryOptions<T> | null, callback?: (err: CallbackError, doc: ResultDoc | null, res: any) => void): QueryWithHelpers<ResultDoc | null, ResultDoc, TQueryHelpers, T>;
 
     /** Creates a `findOneAndReplace` query: atomically finds the given document and replaces it with `replacement`. */
+    findOneAndReplace<ResultDoc = HydratedDocument<T, TMethodsAndOverrides, TVirtuals>>(filter: FilterQuery<T>, replacement: T | AnyObject, options: QueryOptions<T> & { rawResult: true }, callback?: (err: CallbackError, doc: any, res: any) => void): QueryWithHelpers<ModifyResult<ResultDoc>, ResultDoc, TQueryHelpers, T>;
     findOneAndReplace<ResultDoc = HydratedDocument<T, TMethodsAndOverrides, TVirtuals>>(filter: FilterQuery<T>, replacement: T | AnyObject, options: QueryOptions<T> & { upsert: true } & ReturnsNewDoc, callback?: (err: CallbackError, doc: ResultDoc, res: any) => void): QueryWithHelpers<ResultDoc, ResultDoc, TQueryHelpers, T>;
     findOneAndReplace<ResultDoc = HydratedDocument<T, TMethodsAndOverrides, TVirtuals>>(filter?: FilterQuery<T>, replacement?: T | AnyObject, options?: QueryOptions<T> | null, callback?: (err: CallbackError, doc: ResultDoc | null, res: any) => void): QueryWithHelpers<ResultDoc | null, ResultDoc, TQueryHelpers, T>;
 
@@ -431,4 +432,4 @@ declare module 'mongoose' {
     where<ResultDoc = HydratedDocument<T, TMethodsAndOverrides, TVirtuals>>(obj: object): QueryWithHelpers<Array<ResultDoc>, ResultDoc, TQueryHelpers, T>;
     where<ResultDoc = HydratedDocument<T, TMethodsAndOverrides, TVirtuals>>(): QueryWithHelpers<Array<ResultDoc>, ResultDoc, TQueryHelpers, T>;
   }
-}
+}

package/types/mongooseoptions.d.ts

@@ -190,4 +190,4 @@ declare module 'mongoose' {
      */
     toObject?: ToObjectOptions;
   }
-}
+}

package/types/pipelinestage.d.ts

@@ -212,7 +212,7 @@ declare module 'mongoose' {
 
     export interface Set {
       /** [`$set` reference](https://docs.mongodb.com/manual/reference/operator/aggregation/set/) */
-      $set: Record<string, AnyExpression>
+      $set: Record<string, AnyExpression | any>
     }
 
     export interface SetWindowFields {

package/types/query.d.ts

@@ -90,6 +90,11 @@ declare module 'mongoose' {
     [key: string]: any;
   };
 
+  interface QueryTimestampsConfig {
+    createdAt?: boolean;
+    updatedAt?: boolean;
+  }
+
   interface QueryOptions<DocType = unknown> extends
     PopulateOption,
     SessionOption {
@@ -157,7 +162,7 @@ declare module 'mongoose' {
      * skip timestamps for this update. Note that this allows you to overwrite
      * timestamps. Does nothing if schema-level timestamps are not set.
      */
-    timestamps?: boolean;
+    timestamps?: boolean | QueryTimestampsConfig;
     upsert?: boolean;
     writeConcern?: mongodb.WriteConcern;
 

package/types/schemaoptions.d.ts

@@ -203,4 +203,4 @@ declare module 'mongoose' {
      */
     query?: Record<any, <T extends QueryWithHelpers<unknown, DocType>>(this: T, ...args: any) => T> | QueryHelpers,
   }
-}
+}

package/types/utility.d.ts

@@ -12,4 +12,11 @@ declare module 'mongoose' {
 
   type MergeType<A, B> = Omit<A, keyof B> & B;
 
+  /**
+   * @summary Converts Unions to one record "object".
+   * @description It makes intellisense dialog box easier to read as a single object instead of showing that in multiple object unions.
+   * @param {T} T The type to be converted.
+   */
+   type FlatRecord<T> = { [K in keyof T]: T[K] };
+
 }