mongoose 6.4.7 → 6.5.2

package/{build-browser.js → scripts/build-browser.js}

@@ -1,6 +1,6 @@
 'use strict';
 
-const config = require('./webpack.config.js');
+const config = require('../webpack.config.js');
 const webpack = require('webpack');
 
 const compiler = webpack(config);

package/types/connection.d.ts

@@ -142,9 +142,15 @@ declare module 'mongoose' {
     readonly models: Readonly<{ [index: string]: Model<any> }>;
 
     /** Defines or retrieves a model. */
+    model<TSchema extends Schema = any>(
+      name: string,
+      schema?: TSchema,
+      collection?: string,
+      options?: CompileModelOptions
+    ): Model<InferSchemaType<TSchema>, ObtainSchemaGeneric<TSchema, 'TQueryHelpers'>, ObtainSchemaGeneric<TSchema, 'TInstanceMethods'>, {}, TSchema> & ObtainSchemaGeneric<TSchema, 'TStaticMethods'>;
     model<T, U, TQueryHelpers = {}>(
       name: string,
-      schema?: Schema<T, U, TQueryHelpers>,
+      schema?: Schema<T, U, any, TQueryHelpers, any, any>,
       collection?: string,
       options?: CompileModelOptions
     ): U;

package/types/document.d.ts

@@ -26,7 +26,7 @@ declare module 'mongoose' {
     __v?: any;
 
     /** Assert that a given path or paths is populated. Throws an error if not populated. */
-    $assertPopulated<Paths = {}>(paths: string | string[]): Omit<this, keyof Paths> & Paths;
+    $assertPopulated<Paths = {}>(paths: string | string[]): Omit<DocType, keyof Paths> & Paths;
 
     /* Get all subdocs (by bfs) */
     $getAllSubdocs(): Document[];
@@ -43,6 +43,13 @@ declare module 'mongoose' {
     /** Returns an array of all populated documents associated with the query */
     $getPopulatedDocs(): Document[];
 
+    /**
+     * Increments the numeric value at `path` by the given `val`.
+     * When you call `save()` on this document, Mongoose will send a
+     * `$inc` as opposed to a `$set`.
+     */
+    $inc(path: string | string[], val?: number): this;
+
     /**
      * Returns true if the given path is nullish or only contains empty objects.
      * Useful for determining whether this subdoc will get stripped out by the

package/types/expressions.d.ts

@@ -1977,7 +1977,7 @@ declare module 'mongoose' {
        * @version 5.0
        * @see https://docs.mongodb.com/manual/reference/operator/aggregation/count/#mongodb-expression-exp.-count
        */
-      $count: Record<string | number | symbol, never>;
+      $count: Record<string | number | symbol, never> | Path;
     }
 
     export interface CovariancePop {

package/types/index.d.ts

@@ -21,6 +21,7 @@
 /// <reference path="./utility.d.ts" />
 /// <reference path="./validation.d.ts" />
 /// <reference path="./inferschematype.d.ts" />
+/// <reference path="./virtuals.d.ts" />
 
 declare class NativeDate extends global.Date { }
 
@@ -74,7 +75,7 @@ declare module 'mongoose' {
 
   export function model<T, U, TQueryHelpers = {}>(
     name: string,
-    schema?: Schema<T, any, TQueryHelpers>,
+    schema?: Schema<T, any, any, TQueryHelpers, any, any>,
     collection?: string,
     options?: CompileModelOptions
   ): U;
@@ -156,7 +157,20 @@ declare module 'mongoose' {
 
   type QueryResultType<T> = T extends Query<infer ResultType, any> ? ResultType : never;
 
-  export class Schema<EnforcedDocType = any, M = Model<EnforcedDocType, any, any, any>, TInstanceMethods = {}, TQueryHelpers = {}, TVirtuals = any,
+  type PluginFunction<
+    DocType,
+    M = Model<DocType, any, any, any>,
+    TInstanceMethods = {},
+    TQueryHelpers = {},
+    TVirtuals = {},
+    TStaticMethods = {}> = (schema: Schema<DocType, M, TInstanceMethods, TQueryHelpers, TVirtuals, TStaticMethods>, opts?: any) => void;
+
+  export class Schema<
+    EnforcedDocType = any,
+    M = Model<EnforcedDocType, any, any, any>,
+    TInstanceMethods = {},
+    TQueryHelpers = {},
+    TVirtuals = {},
     TStaticMethods = {},
     TPathTypeKey extends TypeKeyBaseType = DefaultTypeKey,
     DocType extends ObtainDocumentType<DocType, EnforcedDocType, TPathTypeKey> = ObtainDocumentType<any, EnforcedDocType, TPathTypeKey>>
@@ -164,7 +178,7 @@ declare module 'mongoose' {
     /**
      * Create a new schema
      */
-    constructor(definition?: SchemaDefinition<SchemaDefinitionType<EnforcedDocType>> | DocType, options?: SchemaOptions<TPathTypeKey, FlatRecord<DocType>, TInstanceMethods, TQueryHelpers, TStaticMethods>);
+    constructor(definition?: SchemaDefinition<SchemaDefinitionType<EnforcedDocType>> | DocType, options?: SchemaOptions<TPathTypeKey, FlatRecord<DocType>, TInstanceMethods, TQueryHelpers, TStaticMethods, TVirtuals>);
 
     /** Adds key path / schema type pairs to this schema. */
     add(obj: SchemaDefinition<SchemaDefinitionType<EnforcedDocType>> | Schema, prefix?: string): this;
@@ -238,7 +252,7 @@ declare module 'mongoose' {
     pathType(path: string): string;
 
     /** Registers a plugin for this schema. */
-    plugin(fn: (schema: Schema<DocType>, opts?: any) => void, opts?: any): this;
+    plugin<PFunc extends PluginFunction<DocType, M, TInstanceMethods, TQueryHelpers, TVirtuals, TStaticMethods>, POptions extends Parameters<PFunc>[1] = Parameters<PFunc>[1]>(fn: PFunc, opts?: POptions): this;
 
     /** Defines a post hook for the model. */
     post<T = HydratedDocument<DocType, TInstanceMethods>>(method: MongooseDocumentMiddleware | MongooseDocumentMiddleware[] | RegExp, fn: PostMiddlewareFunction<T, T>): this;
@@ -291,15 +305,16 @@ declare module 'mongoose' {
     set<K extends keyof SchemaOptions>(key: K, value: SchemaOptions[K], _tags?: any): this;
 
     /** Adds static "class" methods to Models compiled from this schema. */
+    static<K extends keyof TStaticMethods>(name: K, fn: TStaticMethods[K]): this;
+    static(obj: { [F in keyof TStaticMethods]: TStaticMethods[F] } & { [name: string]: (this: M, ...args: any[]) => any }): this;
     static(name: string, fn: (this: M, ...args: any[]) => any): this;
-    static(obj: { [name: string]: (this: M, ...args: any[]) => any }): this;
 
     /** Object of currently defined statics on this schema. */
-    statics: { [name: string]: (this: M, ...args: any[]) => any };
+    statics: { [F in keyof TStaticMethods]: TStaticMethods[F] } & { [name: string]: (this: M, ...args: any[]) => any };
 
     /** Creates a virtual type with the given name. */
     virtual<T = HydratedDocument<DocType, TInstanceMethods>>(
-      name: string,
+      name: keyof TVirtuals | string,
       options?: VirtualTypeOptions<T, DocType>
     ): VirtualType<T>;
 
@@ -456,9 +471,9 @@ declare module 'mongoose' {
     /** @see https://docs.mongodb.com/manual/reference/operator/update-array/ */
     $addToSet?: Mutable<mongodb.SetFields<TSchema>>;
     $pop?: AnyKeys<TSchema> & AnyObject;
-    $pull?: Mutable<mongodb.PullOperator<TSchema>>;
-    $push?: Mutable<mongodb.PushOperator<TSchema>>;
-    $pullAll?: mongodb.PullAllOperator<TSchema>;
+    $pull?: AnyKeys<TSchema> & AnyObject;
+    $push?: AnyKeys<TSchema> & AnyObject;
+    $pullAll?: AnyKeys<TSchema> & AnyObject;
 
     /** @see https://docs.mongodb.com/manual/reference/operator/update-bitwise/ */
     $bit?: Record<string, mongodb.NumericType>;
@@ -506,24 +521,14 @@ declare module 'mongoose' {
   export type actualPrimitives = string | boolean | number | bigint | symbol | null | undefined;
   export type TreatAsPrimitives = actualPrimitives | NativeDate | RegExp | symbol | Error | BigInt | Types.ObjectId;
 
-  // This will -- when possible -- extract the original type of the subdocument in question
-  type LeanSubdocument<T> = T extends (Types.Subdocument<Require_id<T>['_id']> & infer U) ? LeanDocument<U> : Omit<LeanDocument<T>, '$isSingleNested' | 'ownerDocument' | 'parent'>;
-
   export type LeanType<T> =
     0 extends (1 & T) ? T : // any
       T extends TreatAsPrimitives ? T : // primitives
-        T extends Types.Subdocument ? LeanSubdocument<T> : // subdocs
+        T extends Types.Subdocument ? Omit<LeanDocument<T>, '$isSingleNested' | 'ownerDocument' | 'parent'> :
           LeanDocument<T>; // Documents and everything else
 
-  // Used only when collapsing lean arrays for ts performance reasons:
-  type LeanTypeOrArray<T> = T extends unknown[] ? LeanArray<T> : LeanType<T>;
 
-  export type LeanArray<T extends unknown[]> =
-    // By checking if it extends Types.Array we can get the original base type before collapsing down,
-    // rather than trying to manually remove the old types. This matches both Array and DocumentArray
-    T extends Types.Array<infer U> ? LeanTypeOrArray<U>[] :
-    // If it isn't a custom mongoose type we fall back to "do our best"
-      T extends unknown[][] ? LeanArray<T[number]>[] : LeanType<T[number]>[];
+  export type LeanArray<T extends unknown[]> = T extends unknown[][] ? LeanArray<T[number]>[] : LeanType<T[number]>[];
 
   export type _LeanDocument<T> = {
     [K in keyof T]: LeanDocumentElement<T[K]>;
@@ -533,10 +538,9 @@ declare module 'mongoose' {
   // This way, the conditional type is distributive over union types.
   // This is required for PopulatedDoc.
   export type LeanDocumentElement<T> =
-    0 extends (1 & T) ? T :// any
-      T extends unknown[] ? LeanArray<T> : // Array
-        T extends Document ? LeanDocument<T> : // Subdocument
-          T;
+    T extends unknown[] ? LeanArray<T> : // Array
+      T extends Document ? LeanDocument<T> : // Subdocument
+        T;
 
   export type SchemaDefinitionType<T> = T extends Document ? Omit<T, Exclude<keyof Document, '_id' | 'id' | '__v'>> : T;
 
@@ -571,8 +575,7 @@ declare module 'mongoose' {
    * Plain old JavaScript object documents (POJO).
    * @see https://mongoosejs.com/docs/tutorials/lean.html
    */
-  export type LeanDocument<T> = BaseDocumentType<T> extends Document ? _LeanDocument<BaseDocumentType<T>> :
-    Omit<_LeanDocument<T>, Exclude<keyof Document, '_id' | 'id' | '__v'> | '$isSingleNested'>;
+  export type LeanDocument<T> = Omit<_LeanDocument<T>, Exclude<keyof Document, '_id' | 'id' | '__v'> | '$isSingleNested'>;
 
   export type LeanDocumentOrArray<T> = 0 extends (1 & T) ? T :
     T extends unknown[] ? LeanDocument<T[number]>[] :

package/types/inferschematype.d.ts

@@ -11,7 +11,8 @@ import {
   DateSchemaDefinition,
   ObtainDocumentType,
   DefaultTypeKey,
-  ObjectIdSchemaDefinition
+  ObjectIdSchemaDefinition,
+  IfEquals
 } from 'mongoose';
 
 declare module 'mongoose' {
@@ -37,7 +38,7 @@ declare module 'mongoose' {
    * // result
    * type UserType = {userName?: string}
    */
-  type InferSchemaType<SchemaType> = ObtainSchemaGeneric<SchemaType, 'DocType'> ;
+  type InferSchemaType<SchemaType> = ObtainSchemaGeneric<SchemaType, 'DocType'>;
 
   /**
    * @summary Obtains schema Generic type by using generic alias.
@@ -58,24 +59,6 @@ declare module 'mongoose' {
       }[alias]
       : unknown;
 }
-/**
- * @summary Checks if a type is "Record" or "any".
- * @description It Helps to check if user has provided schema type "EnforcedDocType"
- * @param {T} T A generic type to be checked.
- * @returns true if {@link T} is Record OR false if {@link T} is of any type.
- */
-type IsItRecordAndNotAny<T> = IfEquals<T, any, false, T extends Record<any, any> ? true : false>;
-
-/**
- * @summary Checks if two types are identical.
- * @param {T} T The first type to be compared with {@link U}.
- * @param {U} U The seconde type to be compared with {@link T}.
- * @param {Y} Y A type to be returned if {@link T} &  {@link U} are identical.
- * @param {N} N A type to be returned if {@link T} &  {@link U} are not identical.
- */
-type IfEquals<T, U, Y = true, N = false> =
-    (<G>() => G extends T ? 1 : 0) extends
-    (<G>() => G extends U ? 1 : 0) ? Y : N;
 
 /**
  * @summary Checks if a document path is required or optional.

package/types/models.d.ts

@@ -119,7 +119,8 @@ declare module 'mongoose' {
     AcceptsDiscriminator,
     IndexManager,
     SessionStarter {
-    new <DocType = T>(doc?: DocType, fields?: any | null, options?: boolean | AnyObject): HydratedDocument<T, TMethodsAndOverrides, TVirtuals> & ObtainSchemaGeneric<TSchema, 'TStaticMethods'>;
+    new <DocType = T>(doc?: DocType, fields?: any | null, options?: boolean | AnyObject): HydratedDocument<T, TMethodsAndOverrides,
+    IfEquals<TVirtuals, {}, ObtainSchemaGeneric<TSchema, 'TVirtuals'>, TVirtuals>> & ObtainSchemaGeneric<TSchema, 'TStaticMethods'>;
 
     aggregate<R = any>(pipeline?: PipelineStage[], options?: mongodb.AggregateOptions, callback?: Callback<R[]>): Aggregate<Array<R>>;
     aggregate<R = any>(pipeline: PipelineStage[], callback?: Callback<R[]>): Aggregate<Array<R>>;
@@ -128,28 +129,31 @@ declare module 'mongoose' {
     base: Mongoose;
 
     /**
-   * If this is a discriminator model, `baseModelName` is the name of
-   * the base model.
-   */
+     * If this is a discriminator model, `baseModelName` is the name of
+     * the base model.
+     */
     baseModelName: string | undefined;
 
+    /* Cast the given POJO to the model's schema */
+    castObject(obj: AnyObject): T;
+
     /**
-   * Sends multiple `insertOne`, `updateOne`, `updateMany`, `replaceOne`,
-   * `deleteOne`, and/or `deleteMany` operations to the MongoDB server in one
-   * command. This is faster than sending multiple independent operations (e.g.
-   * if you use `create()`) because with `bulkWrite()` there is only one network
-   * round trip to the MongoDB server.
-   */
-    bulkWrite(writes: Array<mongodb.AnyBulkWriteOperation>, options: mongodb.BulkWriteOptions & MongooseBulkWriteOptions, callback: Callback<mongodb.BulkWriteResult>): void;
-    bulkWrite(writes: Array<mongodb.AnyBulkWriteOperation>, callback: Callback<mongodb.BulkWriteResult>): void;
-    bulkWrite(writes: Array<mongodb.AnyBulkWriteOperation>, options?: mongodb.BulkWriteOptions & MongooseBulkWriteOptions): Promise<mongodb.BulkWriteResult>;
+     * Sends multiple `insertOne`, `updateOne`, `updateMany`, `replaceOne`,
+     * `deleteOne`, and/or `deleteMany` operations to the MongoDB server in one
+     * command. This is faster than sending multiple independent operations (e.g.
+     * if you use `create()`) because with `bulkWrite()` there is only one network
+     * round trip to the MongoDB server.
+     */
+    bulkWrite(writes: Array<mongodb.AnyBulkWriteOperation<T extends {} ? T : any>>, options: mongodb.BulkWriteOptions & MongooseBulkWriteOptions, callback: Callback<mongodb.BulkWriteResult>): void;
+    bulkWrite(writes: Array<mongodb.AnyBulkWriteOperation<T extends {} ? T : any>>, callback: Callback<mongodb.BulkWriteResult>): void;
+    bulkWrite(writes: Array<mongodb.AnyBulkWriteOperation<T extends {} ? T : any>>, options?: mongodb.BulkWriteOptions & MongooseBulkWriteOptions): Promise<mongodb.BulkWriteResult>;
 
     /**
-   * Sends multiple `save()` calls in a single `bulkWrite()`. This is faster than
-   * sending multiple `save()` calls because with `bulkSave()` there is only one
-   * network round trip to the MongoDB server.
-   */
-    bulkSave(documents: Array<Document>, options?: mongodb.BulkWriteOptions): Promise<mongodb.BulkWriteResult>;
+     * Sends multiple `save()` calls in a single `bulkWrite()`. This is faster than
+     * sending multiple `save()` calls because with `bulkSave()` there is only one
+     * network round trip to the MongoDB server.
+     */
+    bulkSave(documents: Array<Document>, options?: mongodb.BulkWriteOptions & { timestamps?: boolean }): Promise<mongodb.BulkWriteResult>;
 
     /** Collection the model uses. */
     collection: Collection;
@@ -170,10 +174,10 @@ declare module 'mongoose' {
     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,
-   * mongoose will not create the collection for the model until any documents are
-   * created. Use this method to create the collection explicitly.
-   */
+     * Create the collection for this model. By default, if no indexes are specified,
+     * mongoose will not create the collection for the model until any documents are
+     * created. Use this method to create the collection explicitly.
+     */
     createCollection<T extends mongodb.Document>(options: mongodb.CreateCollectionOptions & Pick<SchemaOptions, 'expires'> | null, callback: Callback<mongodb.Collection<T>>): void;
     createCollection<T extends mongodb.Document>(callback: Callback<mongodb.Collection<T>>): void;
     createCollection<T extends mongodb.Document>(options?: mongodb.CreateCollectionOptions & Pick<SchemaOptions, 'expires'>): Promise<mongodb.Collection<T>>;
@@ -182,34 +186,34 @@ declare module 'mongoose' {
     db: Connection;
 
     /**
-   * Deletes all of the documents that match `conditions` from the collection.
-   * Behaves like `remove()`, but deletes all documents that match `conditions`
-   * regardless of the `single` option.
-   */
+     * Deletes all of the documents that match `conditions` from the collection.
+     * Behaves like `remove()`, but deletes all documents that match `conditions`
+     * regardless of the `single` option.
+     */
     deleteMany(filter?: FilterQuery<T>, options?: QueryOptions<T>, callback?: CallbackWithoutResult): QueryWithHelpers<mongodb.DeleteResult, HydratedDocument<T, TMethodsAndOverrides, TVirtuals>, TQueryHelpers, T>;
     deleteMany(filter: FilterQuery<T>, callback: CallbackWithoutResult): QueryWithHelpers<mongodb.DeleteResult, HydratedDocument<T, TMethodsAndOverrides, TVirtuals>, TQueryHelpers, T>;
     deleteMany(callback: CallbackWithoutResult): QueryWithHelpers<mongodb.DeleteResult, HydratedDocument<T, TMethodsAndOverrides, TVirtuals>, TQueryHelpers, T>;
 
     /**
-   * Deletes the first document that matches `conditions` from the collection.
-   * Behaves like `remove()`, but deletes at most one document regardless of the
-   * `single` option.
-   */
+     * Deletes the first document that matches `conditions` from the collection.
+     * Behaves like `remove()`, but deletes at most one document regardless of the
+     * `single` option.
+     */
     deleteOne(filter?: FilterQuery<T>, options?: QueryOptions<T>, callback?: CallbackWithoutResult): QueryWithHelpers<mongodb.DeleteResult, HydratedDocument<T, TMethodsAndOverrides, TVirtuals>, TQueryHelpers, T>;
     deleteOne(filter: FilterQuery<T>, callback: CallbackWithoutResult): QueryWithHelpers<mongodb.DeleteResult, HydratedDocument<T, TMethodsAndOverrides, TVirtuals>, TQueryHelpers, T>;
     deleteOne(callback: CallbackWithoutResult): QueryWithHelpers<mongodb.DeleteResult, HydratedDocument<T, TMethodsAndOverrides, TVirtuals>, TQueryHelpers, T>;
 
     /**
-   * Event emitter that reports any errors that occurred. Useful for global error
-   * handling.
-   */
+     * Event emitter that reports any errors that occurred. Useful for global error
+     * handling.
+     */
     events: NodeJS.EventEmitter;
 
     /**
-   * Finds a single document by its _id field. `findById(id)` is almost*
-   * equivalent to `findOne({ _id: id })`. If you want to query by a document's
-   * `_id`, use `findById()` instead of `findOne()`.
-   */
+     * Finds a single document by its _id field. `findById(id)` is almost*
+     * equivalent to `findOne({ _id: id })`. If you want to query by a document's
+     * `_id`, use `findById()` instead of `findOne()`.
+     */
     findById<ResultDoc = HydratedDocument<T, TMethodsAndOverrides, TVirtuals>>(
       id: any,
       projection?: ProjectionType<T> | null,
@@ -240,19 +244,19 @@ declare module 'mongoose' {
     ): QueryWithHelpers<ResultDoc | null, ResultDoc, TQueryHelpers, T>;
 
     /**
-   * Shortcut for creating a new Document from existing raw data, pre-saved in the DB.
-   * The document returned has no paths marked as modified initially.
-   */
-    hydrate(obj: any): HydratedDocument<T, TMethodsAndOverrides, TVirtuals>;
+     * Shortcut for creating a new Document from existing raw data, pre-saved in the DB.
+     * The document returned has no paths marked as modified initially.
+     */
+    hydrate(obj: any, projection?: AnyObject, options?: { setters?: boolean }): HydratedDocument<T, TMethodsAndOverrides, TVirtuals>;
 
     /**
-   * This function is responsible for building [indexes](https://docs.mongodb.com/manual/indexes/),
-   * unless [`autoIndex`](http://mongoosejs.com/docs/guide.html#autoIndex) is turned off.
-   * Mongoose calls this function automatically when a model is created using
-   * [`mongoose.model()`](/docs/api.html#mongoose_Mongoose-model) or
-   * [`connection.model()`](/docs/api.html#connection_Connection-model), so you
-   * don't need to call it.
-   */
+     * This function is responsible for building [indexes](https://docs.mongodb.com/manual/indexes/),
+     * unless [`autoIndex`](http://mongoosejs.com/docs/guide.html#autoIndex) is turned off.
+     * Mongoose calls this function automatically when a model is created using
+     * [`mongoose.model()`](/docs/api.html#mongoose_Mongoose-model) or
+     * [`connection.model()`](/docs/api.html#connection_Connection-model), so you
+     * don't need to call it.
+     */
     init(callback?: CallbackWithoutResult): Promise<HydratedDocument<T, TMethodsAndOverrides, TVirtuals>>;
 
     /** Inserts one or more new documents as a single `insertMany` call to the MongoDB server. */
@@ -288,7 +292,7 @@ declare module 'mongoose' {
     validate(optional: any, pathsToValidate: PathsToValidate, callback?: CallbackWithoutResult): Promise<void>;
 
     /** Watches the underlying collection for changes using [MongoDB change streams](https://docs.mongodb.com/manual/changeStreams/). */
-    watch<ResultType extends mongodb.Document = any>(pipeline?: Array<Record<string, unknown>>, options?: mongodb.ChangeStreamOptions): mongodb.ChangeStream<ResultType>;
+    watch<ResultType extends mongodb.Document = any>(pipeline?: Array<Record<string, unknown>>, options?: mongodb.ChangeStreamOptions & { hydrate?: boolean }): mongodb.ChangeStream<ResultType>;
 
     /** Adds a `$where` clause to this query */
     $where(argument: string | Function): QueryWithHelpers<Array<HydratedDocument<T, TMethodsAndOverrides, TVirtuals>>, HydratedDocument<T, TMethodsAndOverrides, TVirtuals>, TQueryHelpers, T>;

package/types/mongooseoptions.d.ts

@@ -79,6 +79,12 @@ declare module 'mongoose' {
     | stream.Writable
     | ((collectionName: string, methodName: string, ...methodArgs: any[]) => void);
 
+    /**
+     * If `true`, adds a `id` virtual to all schemas unless overwritten on a per-schema basis.
+     * @defaultValue true
+     */
+    id?: boolean;
+
     /**
      * If `false`, it will change the `createdAt` field to be [`immutable: false`](https://mongoosejs.com/docs/api/schematype.html#schematype_SchemaType-immutable)
      * which means you can update the `createdAt`.

package/types/schemaoptions.d.ts

@@ -10,7 +10,7 @@ declare module 'mongoose' {
   type TypeKeyBaseType = string;
 
   type DefaultTypeKey = 'type';
-  interface SchemaOptions<PathTypeKey extends TypeKeyBaseType = DefaultTypeKey, DocType = unknown, InstanceMethods = {}, QueryHelpers = {}, StaticMethods = {}, virtuals = {}> {
+  interface SchemaOptions<PathTypeKey extends TypeKeyBaseType = DefaultTypeKey, DocType = unknown, TInstanceMethods = {}, QueryHelpers = {}, TStaticMethods = {}, TVirtuals = {}> {
     /**
      * By default, Mongoose's init() function creates all the indexes defined in your model's schema by
      * calling Model.createIndexes() after you successfully connect to MongoDB. If you want to disable
@@ -191,16 +191,27 @@ declare module 'mongoose' {
     /**
      * Model Statics methods.
      */
-    statics?: Record<any, (this: Model<DocType>, ...args: any) => unknown> | StaticMethods,
+    statics?: Record<any, (this: Model<DocType>, ...args: any) => unknown> | TStaticMethods,
 
     /**
      * Document instance methods.
      */
-    methods?: Record<any, (this: HydratedDocument<DocType>, ...args: any) => unknown> | InstanceMethods,
+    methods?: Record<any, (this: HydratedDocument<DocType>, ...args: any) => unknown> | TInstanceMethods,
 
     /**
-     * Query helper functions
+     * Query helper functions.
      */
     query?: Record<any, <T extends QueryWithHelpers<unknown, DocType>>(this: T, ...args: any) => T> | QueryHelpers,
+
+    /**
+     * Set whether to cast non-array values to arrays.
+     * @default true
+     */
+    castNonArrays?: boolean;
+
+    /**
+     * Virtual paths.
+     */
+    virtuals?: SchemaOptionsVirtualsPropertyType<DocType, TVirtuals, TInstanceMethods>,
   }
 }

package/types/utility.d.ts

@@ -19,4 +19,23 @@ declare module 'mongoose' {
    */
    type FlatRecord<T> = { [K in keyof T]: T[K] };
 
+   /**
+ * @summary Checks if a type is "Record" or "any".
+ * @description It Helps to check if user has provided schema type "EnforcedDocType"
+ * @param {T} T A generic type to be checked.
+ * @returns true if {@link T} is Record OR false if {@link T} is of any type.
+ */
+type IsItRecordAndNotAny<T> = IfEquals<T, any, false, T extends Record<any, any> ? true : false>;
+
+/**
+ * @summary Checks if two types are identical.
+ * @param {T} T The first type to be compared with {@link U}.
+ * @param {U} U The seconde type to be compared with {@link T}.
+ * @param {Y} Y A type to be returned if {@link T} &  {@link U} are identical.
+ * @param {N} N A type to be returned if {@link T} &  {@link U} are not identical.
+ */
+type IfEquals<T, U, Y = true, N = false> =
+    (<G>() => G extends T ? 1 : 0) extends
+    (<G>() => G extends U ? 1 : 0) ? Y : N;
+
 }

package/types/virtuals.d.ts

@@ -0,0 +1,14 @@
+declare module 'mongoose' {
+    type VirtualPathFunctions<DocType = {}, PathValueType = unknown, TInstanceMethods = {}> = {
+      get?: TVirtualPathFN<DocType, PathValueType, TInstanceMethods, PathValueType>;
+      set?: TVirtualPathFN<DocType, PathValueType, TInstanceMethods, void>;
+      options?: VirtualTypeOptions<HydratedDocument<DocType, TInstanceMethods>, DocType>;
+    };
+
+  type TVirtualPathFN<DocType = {}, PathType = unknown, TInstanceMethods = {}, TReturn = unknown> =
+    <T = HydratedDocument<DocType, TInstanceMethods>>(this: Document<any, any, DocType> & DocType, value: PathType, virtual: VirtualType<T>, doc: Document<any, any, DocType> & DocType) => TReturn;
+
+    type SchemaOptionsVirtualsPropertyType<DocType = any, VirtualPaths = Record<any, unknown>, TInstanceMethods = {}> = {
+      [K in keyof VirtualPaths]: VirtualPathFunctions<IsItRecordAndNotAny<DocType> extends true ? DocType : any, VirtualPaths[K], TInstanceMethods>
+    };
+}