mongoose 6.2.3 → 6.2.6

package/types/index.d.ts

@@ -1,5 +1,9 @@
-/// <reference path="./Error.d.ts" />
-/// <reference path="./PipelineStage.d.ts" />
+/// <reference path="./connection.d.ts" />
+/// <reference path="./cursor.d.ts" />
+/// <reference path="./document.d.ts" />
+/// <reference path="./error.d.ts" />
+/// <reference path="./pipelinestage.d.ts" />
+/// <reference path="./schemaoptions.d.ts" />
 
 import events = require('events');
 import mongodb = require('mongodb');
@@ -8,14 +12,6 @@ import stream = require('stream');
 
 declare module 'mongoose' {
 
-  export enum ConnectionStates {
-    disconnected = 0,
-    connected = 1,
-    connecting = 2,
-    disconnecting = 3,
-    uninitialized = 99,
-  }
-
   class NativeDate extends global.Date {}
 
   /** The Mongoose Date [SchemaType](/docs/schematypes.html). */
@@ -64,9 +60,6 @@ declare module 'mongoose' {
   /** The various Mongoose SchemaTypes. */
   export const SchemaTypes: typeof Schema.Types;
 
-  /** Expose connection states for user-land */
-  export const STATES: typeof ConnectionStates;
-
   /** Opens Mongoose's default connection to MongoDB, see [connections docs](https://mongoosejs.com/docs/connections.html) */
   export function connect(uri: string, options: ConnectOptions, callback: CallbackWithoutResult): void;
   export function connect(uri: string, callback: CallbackWithoutResult): void;
@@ -100,10 +93,11 @@ declare module 'mongoose' {
 
   /** An array containing all models associated with this Mongoose instance. */
   export const models: Models;
+
   /** Creates a Connection instance. */
+  export function createConnection(uri: string, options: ConnectOptions, callback: Callback<Connection>): void;
   export function createConnection(uri: string, options?: ConnectOptions): Connection;
   export function createConnection(): Connection;
-  export function createConnection(uri: string, options: ConnectOptions, callback: Callback<Connection>): void;
 
   /**
    * Removes the model named `name` from the default connection, if it exists.
@@ -128,6 +122,13 @@ declare module 'mongoose' {
   export function isValidObjectId(v: Types.ObjectId): true;
   export function isValidObjectId(v: any): boolean;
 
+  /**
+   * Returns true if the given value is a Mongoose ObjectId (using `instanceof`) or if the
+   * given value is a 24 character hex string, which is the most commonly used string representation
+   * of an ObjectId.
+   */
+  export function isObjectIdOrHexString(v: any): boolean;
+
   export function model<T>(name: string, schema?: Schema<T, any, any> | Schema<T & Document, any, any>, collection?: string, options?: CompileModelOptions): Model<T>;
   export function model<T, U, TQueryHelpers = {}>(
     name: string,
@@ -288,190 +289,6 @@ declare module 'mongoose' {
   // eslint-disable-next-line @typescript-eslint/no-empty-interface
   interface ClientSession extends mongodb.ClientSession { }
 
-  interface ConnectOptions extends mongodb.MongoClientOptions {
-    /** Set to false to [disable buffering](http://mongoosejs.com/docs/faq.html#callback_never_executes) on all models associated with this connection. */
-    bufferCommands?: boolean;
-    /** The name of the database you want to use. If not provided, Mongoose uses the database name from connection string. */
-    dbName?: string;
-    /** username for authentication, equivalent to `options.auth.user`. Maintained for backwards compatibility. */
-    user?: string;
-    /** password for authentication, equivalent to `options.auth.password`. Maintained for backwards compatibility. */
-    pass?: string;
-    /** Set to false to disable automatic index creation for all models associated with this connection. */
-    autoIndex?: boolean;
-    /** Set to `true` to make Mongoose automatically call `createCollection()` on every model created on this connection. */
-    autoCreate?: boolean;
-  }
-
-  class Connection extends events.EventEmitter {
-    /** Returns a promise that resolves when this connection successfully connects to MongoDB */
-    asPromise(): Promise<this>;
-
-    /** Closes the connection */
-    close(callback: CallbackWithoutResult): void;
-    close(force: boolean, callback: CallbackWithoutResult): void;
-    close(force?: boolean): Promise<void>;
-
-    /** Retrieves a collection, creating it if not cached. */
-    collection<T = AnyObject>(name: string, options?: mongodb.CreateCollectionOptions): Collection<T>;
-
-    /** A hash of the collections associated with this connection */
-    collections: { [index: string]: Collection };
-
-    /** A hash of the global options that are associated with this connection */
-    config: any;
-
-    /** The mongodb.Db instance, set when the connection is opened */
-    db: mongodb.Db;
-
-    /**
-     * Helper for `createCollection()`. Will explicitly create the given collection
-     * with specified options. Used to create [capped collections](https://docs.mongodb.com/manual/core/capped-collections/)
-     * and [views](https://docs.mongodb.com/manual/core/views/) from mongoose.
-     */
-    createCollection<T = AnyObject>(name: string, options?: mongodb.CreateCollectionOptions): Promise<mongodb.Collection<T>>;
-    createCollection<T = AnyObject>(name: string, cb: Callback<mongodb.Collection<T>>): void;
-    createCollection<T = AnyObject>(name: string, options: mongodb.CreateCollectionOptions, cb?: Callback<mongodb.Collection<T>>): Promise<mongodb.Collection<T>>;
-
-    /**
-     * Removes the model named `name` from this connection, if it exists. You can
-     * use this function to clean up any models you created in your tests to
-     * prevent OverwriteModelErrors.
-     */
-    deleteModel(name: string): this;
-
-    /**
-     * Helper for `dropCollection()`. Will delete the given collection, including
-     * all documents and indexes.
-     */
-    dropCollection(collection: string): Promise<void>;
-    dropCollection(collection: string, cb: CallbackWithoutResult): void;
-
-    /**
-     * Helper for `dropDatabase()`. Deletes the given database, including all
-     * collections, documents, and indexes.
-     */
-    dropDatabase(): Promise<void>;
-    dropDatabase(cb: CallbackWithoutResult): void;
-
-    /** Gets the value of the option `key`. Equivalent to `conn.options[key]` */
-    get(key: string): any;
-
-    /**
-     * Returns the [MongoDB driver `MongoClient`](http://mongodb.github.io/node-mongodb-native/3.5/api/MongoClient.html) instance
-     * that this connection uses to talk to MongoDB.
-     */
-    getClient(): mongodb.MongoClient;
-
-    /**
-     * The host name portion of the URI. If multiple hosts, such as a replica set,
-     * this will contain the first host name in the URI
-     */
-    host: string;
-
-    /**
-     * A number identifier for this connection. Used for debugging when
-     * you have [multiple connections](/docs/connections.html#multiple_connections).
-     */
-    id: number;
-
-    /**
-     * A [POJO](https://masteringjs.io/tutorials/fundamentals/pojo) containing
-     * a map from model names to models. Contains all models that have been
-     * added to this connection using [`Connection#model()`](/docs/api/connection.html#connection_Connection-model).
-     */
-    models: { [index: string]: Model<any> };
-
-    /** Defines or retrieves a model. */
-    model<T>(name: string, schema?: Schema<any>, collection?: string, options?: CompileModelOptions): Model<T>;
-    model<T, U, TQueryHelpers = {}>(
-      name: string,
-      schema?: Schema<T, U, TQueryHelpers>,
-      collection?: string,
-      options?: CompileModelOptions
-    ): U;
-
-    /** Returns an array of model names created on this connection. */
-    modelNames(): Array<string>;
-
-    /** The name of the database this connection points to. */
-    name: string;
-
-    /** Opens the connection with a URI using `MongoClient.connect()`. */
-    openUri(uri: string, options?: ConnectOptions): Promise<Connection>;
-    openUri(uri: string, callback: (err: CallbackError, conn?: Connection) => void): Connection;
-    openUri(uri: string, options: ConnectOptions, callback: (err: CallbackError, conn?: Connection) => void): Connection;
-
-    /** The password specified in the URI */
-    pass: string;
-
-    /**
-     * The port portion of the URI. If multiple hosts, such as a replica set,
-     * this will contain the port from the first host name in the URI.
-     */
-    port: number;
-
-    /** Declares a plugin executed on all schemas you pass to `conn.model()` */
-    plugin(fn: (schema: Schema, opts?: any) => void, opts?: any): Connection;
-
-    /** The plugins that will be applied to all models created on this connection. */
-    plugins: Array<any>;
-
-    /**
-     * Connection ready state
-     *
-     * - 0 = disconnected
-     * - 1 = connected
-     * - 2 = connecting
-     * - 3 = disconnecting
-     */
-    readyState: number;
-
-    /** Sets the value of the option `key`. Equivalent to `conn.options[key] = val` */
-    set(key: string, value: any): any;
-
-    /**
-     * Set the [MongoDB driver `MongoClient`](http://mongodb.github.io/node-mongodb-native/3.5/api/MongoClient.html) instance
-     * that this connection uses to talk to MongoDB. This is useful if you already have a MongoClient instance, and want to
-     * reuse it.
-     */
-    setClient(client: mongodb.MongoClient): this;
-
-    /**
-     * _Requires MongoDB >= 3.6.0._ Starts a [MongoDB session](https://docs.mongodb.com/manual/release-notes/3.6/#client-sessions)
-     * for benefits like causal consistency, [retryable writes](https://docs.mongodb.com/manual/core/retryable-writes/),
-     * and [transactions](http://thecodebarbarian.com/a-node-js-perspective-on-mongodb-4-transactions.html).
-     */
-    startSession(options?: mongodb.ClientSessionOptions): Promise<mongodb.ClientSession>;
-    startSession(options: mongodb.ClientSessionOptions, cb: Callback<mongodb.ClientSession>): void;
-
-    /**
-     * Makes the indexes in MongoDB match the indexes defined in every model's
-     * schema. This function will drop any indexes that are not defined in
-     * the model's schema except the `_id` index, and build any indexes that
-     * are in your schema but not in MongoDB.
-     */
-    syncIndexes(options?: SyncIndexesOptions): Promise<ConnectionSyncIndexesResult>;
-    syncIndexes(options: SyncIndexesOptions | null, callback: Callback<ConnectionSyncIndexesResult>): void;
-
-    /**
-     * _Requires MongoDB >= 3.6.0._ Executes the wrapped async function
-     * in a transaction. Mongoose will commit the transaction if the
-     * async function executes successfully and attempt to retry if
-     * there was a retryable error.
-     */
-    transaction(fn: (session: mongodb.ClientSession) => Promise<any>): Promise<any>;
-
-    /** Switches to a different database using the same connection pool. */
-    useDb(name: string, options?: { useCache?: boolean, noListener?: boolean }): Connection;
-
-    /** The username specified in the URI */
-    user: string;
-
-    /** Watches the entire underlying database for changes. Similar to [`Model.watch()`](/docs/api/model.html#model_Model.watch). */
-    watch<ResultType = any>(pipeline?: Array<any>, options?: mongodb.ChangeStreamOptions): mongodb.ChangeStream<ResultType>;
-  }
-
    /*
    * section collection.js
    * http://mongoosejs.com/docs/api.html#collection-js
@@ -515,247 +332,8 @@ declare module 'mongoose' {
     getIndexes(): any;
   }
 
-  class Document<T = any, TQueryHelpers = any, DocType = any> {
-    constructor(doc?: any);
-
-    /** This documents _id. */
-    _id?: T;
-
-    /** This documents __v. */
-    __v?: any;
-
-    /* Get all subdocs (by bfs) */
-    $getAllSubdocs(): Document[];
-
-    /** Don't run validation on this path or persist changes to this path. */
-    $ignore(path: string): void;
-
-    /** Checks if a path is set to its default. */
-    $isDefault(path: string): boolean;
-
-    /** Getter/setter, determines whether the document was removed or not. */
-    $isDeleted(val?: boolean): boolean;
-
-    /** Returns an array of all populated documents associated with the query */
-    $getPopulatedDocs(): Document[];
-
-    /**
-     * 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
-     * [minimize option](/docs/guide.html#minimize).
-     */
-    $isEmpty(path: string): boolean;
-
-    /** Checks if a path is invalid */
-    $isValid(path: string): boolean;
-
-    /**
-     * Empty object that you can use for storing properties on the document. This
-     * is handy for passing data to middleware without conflicting with Mongoose
-     * internals.
-     */
-    $locals: Record<string, unknown>;
-
-    /** Marks a path as valid, removing existing validation errors. */
-    $markValid(path: string): void;
-
-    /**
-     * A string containing the current operation that Mongoose is executing
-     * on this document. May be `null`, `'save'`, `'validate'`, or `'remove'`.
-     */
-    $op: string | null;
-
-    /**
-     * Getter/setter around the session associated with this document. Used to
-     * automatically set `session` if you `save()` a doc that you got from a
-     * query with an associated session.
-     */
-    $session(session?: mongodb.ClientSession | null): mongodb.ClientSession;
-
-    /** Alias for `set()`, used internally to avoid conflicts */
-    $set(path: string, val: any, options?: any): this;
-    $set(path: string, val: any, type: any, options?: any): this;
-    $set(value: any): this;
-
-    /** Set this property to add additional query filters when Mongoose saves this document and `isNew` is false. */
-    $where: Record<string, unknown>;
-
-    /** If this is a discriminator model, `baseModelName` is the name of the base model. */
-    baseModelName?: string;
-
-    /** Collection the model uses. */
-    collection: Collection;
-
-    /** Connection the model uses. */
-    db: Connection;
-
-    /** Removes this document from the db. */
-    delete(options?: QueryOptions): QueryWithHelpers<any, this, TQueryHelpers>;
-    delete(options: QueryOptions, cb?: Callback): void;
-    delete(cb: Callback): void;
-
-    /** Removes this document from the db. */
-    deleteOne(options?: QueryOptions): QueryWithHelpers<any, this, TQueryHelpers>;
-    deleteOne(options: QueryOptions, cb?: Callback): void;
-    deleteOne(cb: Callback): void;
-
-    /**
-     * Takes a populated field and returns it to its unpopulated state. If called with
-     * no arguments, then all populated fields are returned to their unpopulated state.
-     */
-    depopulate(path?: string | string[]): this;
-
-    /**
-     * Returns the list of paths that have been directly modified. A direct
-     * modified path is a path that you explicitly set, whether via `doc.foo = 'bar'`,
-     * `Object.assign(doc, { foo: 'bar' })`, or `doc.set('foo', 'bar')`.
-     */
-    directModifiedPaths(): Array<string>;
-
-    /**
-     * Returns true if this document is equal to another document.
-     *
-     * Documents are considered equal when they have matching `_id`s, unless neither
-     * document has an `_id`, in which case this function falls back to using
-     * `deepEqual()`.
-     */
-    equals(doc: Document<T>): boolean;
-
-    /** Hash containing current validation errors. */
-    errors?: Error.ValidationError;
-
-    /** Returns the value of a path. */
-    get(path: string, type?: any, options?: any): any;
-
-    /**
-     * Returns the changes that happened to the document
-     * in the format that will be sent to MongoDB.
-     */
-    getChanges(): UpdateQuery<this>;
-
-    /** The string version of this documents _id. */
-    id?: any;
-
-    /** Signal that we desire an increment of this documents version. */
-    increment(): this;
-
-    /**
-     * Initializes the document without setters or marking anything modified.
-     * Called internally after a document is returned from mongodb. Normally,
-     * you do **not** need to call this function on your own.
-     */
-    init(obj: any, opts?: any, cb?: Callback<this>): this;
-
-    /** Marks a path as invalid, causing validation to fail. */
-    invalidate(path: string, errorMsg: string | NativeError, value?: any, kind?: string): NativeError | null;
-
-    /** Returns true if `path` was directly set and modified, else false. */
-    isDirectModified(path: string): boolean;
-
-    /** Checks if `path` was explicitly selected. If no projection, always returns true. */
-    isDirectSelected(path: string): boolean;
-
-    /** Checks if `path` is in the `init` state, that is, it was set by `Document#init()` and not modified since. */
-    isInit(path: string): boolean;
-
-    /**
-     * Returns true if any of the given paths is modified, else false. If no arguments, returns `true` if any path
-     * in this document is modified.
-     */
-    isModified(path?: string | Array<string>): boolean;
-
-    /** Boolean flag specifying if the document is new. */
-    isNew: boolean;
-
-    /** Checks if `path` was selected in the source query which initialized this document. */
-    isSelected(path: string): boolean;
-
-    /** Marks the path as having pending changes to write to the db. */
-    markModified(path: string, scope?: any): void;
-
-    /** Returns the list of paths that have been modified. */
-    modifiedPaths(options?: { includeChildren?: boolean }): Array<string>;
-
-    /** The name of the model */
-    modelName: string;
-
-    /**
-     * Overwrite all values in this document with the values of `obj`, except
-     * for immutable properties. Behaves similarly to `set()`, except for it
-     * unsets all properties that aren't in `obj`.
-     */
-    overwrite(obj: AnyObject): this;
-
-    /**
-     * If this document is a subdocument or populated document, returns the
-     * document's parent. Returns undefined otherwise.
-     */
-    $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, names: string): Promise<this & Paths>;
-    populate<Paths = {}>(path: string, names: string, callback: Callback<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;
-
-    /** Removes this document from the db. */
-    remove(options?: QueryOptions): Promise<this>;
-    remove(options?: QueryOptions, cb?: Callback): void;
-
-    /** Sends a replaceOne command with this document `_id` as the query selector. */
-    replaceOne(replacement?: AnyObject, options?: QueryOptions | null, callback?: Callback): Query<any, this>;
-    replaceOne(replacement?: AnyObject, options?: QueryOptions | null, callback?: Callback): Query<any, this>;
-
-    /** Saves this document by inserting a new document into the database if [document.isNew](/docs/api.html#document_Document-isNew) is `true`, or sends an [updateOne](/docs/api.html#document_Document-updateOne) operation with just the modified paths if `isNew` is `false`. */
-    save(options?: SaveOptions): Promise<this>;
-    save(options?: SaveOptions, fn?: Callback<this>): void;
-    save(fn?: Callback<this>): void;
-
-    /** The document's schema. */
-    schema: Schema;
-
-    /** Sets the value of a path, or many paths. */
-    set(path: string, val: any, options?: any): this;
-    set(path: string, val: any, type: any, options?: any): this;
-    set(value: any): this;
-
-    /** The return value of this method is used in calls to JSON.stringify(doc). */
-    toJSON(options: ToObjectOptions & { flattenMaps: false }): LeanDocument<this>;
-    toJSON(options?: ToObjectOptions): FlattenMaps<LeanDocument<this>>;
-    toJSON<T = FlattenMaps<DocType>>(options?: ToObjectOptions): T;
-
-    /** Converts this document into a plain-old JavaScript object ([POJO](https://masteringjs.io/tutorials/fundamentals/pojo)). */
-    toObject(options?: ToObjectOptions): LeanDocument<this>;
-    toObject<T = DocType>(options?: ToObjectOptions): T;
-
-    /** Clears the modified state on the specified path. */
-    unmarkModified(path: string): void;
-
-    /** Sends an update command with this document `_id` as the query selector. */
-    update(update?: UpdateQuery<this> | UpdateWithAggregationPipeline, options?: QueryOptions | null, callback?: Callback): Query<any, this>;
-
-    /** Sends an updateOne command with this document `_id` as the query selector. */
-    updateOne(update?: UpdateQuery<this> | UpdateWithAggregationPipeline, options?: QueryOptions | null, callback?: Callback): Query<any, this>;
-
-    /** Executes registered validation rules for this document. */
-    validate(options:{ pathsToSkip?: pathsToSkip }): Promise<void>;
-    validate(pathsToValidate?: pathsToValidate, options?: any): Promise<void>;
-    validate(callback: CallbackWithoutResult): void;
-    validate(pathsToValidate: pathsToValidate, callback: CallbackWithoutResult): void;
-    validate(pathsToValidate: pathsToValidate, options: any, callback: CallbackWithoutResult): void;
-
-    /** Executes registered validation rules (skipping asynchronous validators) for this document. */
-    validateSync(options:{pathsToSkip?: pathsToSkip, [k:string]: any }): Error.ValidationError | null;
-    validateSync(pathsToValidate?: Array<string>, options?: any): Error.ValidationError | null;
-  }
-
   /** A list of paths to validate. If set, Mongoose will validate only the modified paths that are in the given list. */
   type pathsToValidate = string[] | string;
-  /** A list of paths to skip. If set, Mongoose will validate every modified path that is not in this list. */
-  type pathsToSkip = string[] | string;
 
   interface AcceptsDiscriminator {
     /** Adds a discriminator type. */
@@ -981,7 +559,7 @@ declare module 'mongoose' {
     translateAliases(raw: any): any;
 
     /** Creates a `distinct` query: returns the distinct values of the given `field` that match `filter`. */
-    distinct(field: string, filter?: FilterQuery<T>, callback?: Callback<number>): QueryWithHelpers<Array<any>, HydratedDocument<T, TMethodsAndOverrides, TVirtuals>, TQueryHelpers, T>;
+    distinct<ReturnType = any>(field: string, filter?: FilterQuery<T>, callback?: Callback<number>): QueryWithHelpers<Array<ReturnType>, HydratedDocument<T, TMethodsAndOverrides, TVirtuals>, TQueryHelpers, T>;
 
     /** Creates a `estimatedDocumentCount` query: counts the number of documents in the collection. */
     estimatedDocumentCount(options?: QueryOptions, callback?: Callback<number>): QueryWithHelpers<number, HydratedDocument<T, TMethodsAndOverrides, TVirtuals>, TQueryHelpers, T>;
@@ -1285,10 +863,10 @@ declare module 'mongoose' {
   type IndexDirection = 1 | -1 | '2d' | '2dsphere' | 'geoHaystack' | 'hashed' | 'text';
   type IndexDefinition = Record<string, IndexDirection>;
 
-  type PreMiddlewareFunction<T> = (this: T, next: (err?: CallbackError) => void) => void | Promise<void>;
-  type PreSaveMiddlewareFunction<T> = (this: T, next: (err?: CallbackError) => void, opts: SaveOptions) => void | Promise<void>;
-  type PostMiddlewareFunction<ThisType, ResType = any> = (this: ThisType, res: ResType, next: (err?: CallbackError) => void) => void | Promise<void>;
-  type ErrorHandlingMiddlewareFunction<ThisType, ResType = any> = (this: ThisType, err: NativeError, res: ResType, next: (err?: CallbackError) => void) => void;
+  export type PreMiddlewareFunction<ThisType = any> = (this: ThisType, next: CallbackWithoutResultAndOptionalError) => void | Promise<void>;
+  export type PreSaveMiddlewareFunction<ThisType = any> = (this: ThisType, next: CallbackWithoutResultAndOptionalError, opts: SaveOptions) => void | Promise<void>;
+  export type PostMiddlewareFunction<ThisType = any, ResType = any> = (this: ThisType, res: ResType, next: CallbackWithoutResultAndOptionalError) => void | Promise<void>;
+  export type ErrorHandlingMiddlewareFunction<ThisType = any, ResType = any> = (this: ThisType, err: NativeError, res: ResType, next: CallbackWithoutResultAndOptionalError) => void;
 
   class Schema<DocType = any, M = Model<DocType, any, any, any>, TInstanceMethods = any, TQueryHelpers = any> extends events.EventEmitter {
     /**
@@ -1309,6 +887,9 @@ declare module 'mongoose' {
     /** Returns a copy of this schema */
     clone<T = this>(): T;
 
+    /** Returns a new schema that has the picked `paths` from this schema. */
+    pick<T = this>(paths: string[], options?: SchemaOptions): T;
+
     /** Object containing discriminators defined on this schema */
     discriminators?: { [name: string]: Schema };
 
@@ -1416,7 +997,7 @@ declare module 'mongoose' {
     statics: { [name: string]: (this: M, ...args: any[]) => any };
 
     /** Creates a virtual type with the given name. */
-    virtual(name: string, options?: VirtualTypeOptions): VirtualType;
+    virtual<T = HydratedDocument<DocType, TInstanceMethods>>(name: string, options?: VirtualTypeOptions<T>): VirtualType;
 
     /** Object of currently defined virtuals on this schema */
     virtuals: any;
@@ -1446,188 +1027,22 @@ declare module 'mongoose' {
     typeof SchemaType |
     Schema<any, any, any> |
     Schema<any, any, any>[] |
-    SchemaTypeOptions<T extends undefined ? any : T>[] |
+    SchemaTypeOptions<T extends undefined ? any : Unpacked<T>>[] |
     Function[] |
     SchemaDefinition<T> |
-    SchemaDefinition<T>[] |
+    SchemaDefinition<Unpacked<T>>[] |
     typeof SchemaTypes.Mixed;
 
   type SchemaDefinition<T = undefined> = T extends undefined
     ? { [path: string]: SchemaDefinitionProperty; }
     : { [path in keyof T]?: SchemaDefinitionProperty<T[path]>; };
 
-  interface SchemaOptions {
-    /**
-     * 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
-     * automatic index builds, you can set autoIndex to false.
-     */
-    autoIndex?: boolean;
-    /**
-     * If set to `true`, Mongoose will call Model.createCollection() to create the underlying collection
-     * in MongoDB if autoCreate is set to true. Calling createCollection() sets the collection's default
-     * collation based on the collation option and establishes the collection as a capped collection if
-     * you set the capped schema option.
-     */
-    autoCreate?: boolean;
-    /**
-     * By default, mongoose buffers commands when the connection goes down until the driver manages to reconnect.
-     * To disable buffering, set bufferCommands to false.
-     */
-    bufferCommands?: boolean;
-    /**
-     * If bufferCommands is on, this option sets the maximum amount of time Mongoose buffering will wait before
-     * throwing an error. If not specified, Mongoose will use 10000 (10 seconds).
-     */
-    bufferTimeoutMS?: number;
-    /**
-     * Mongoose supports MongoDBs capped collections. To specify the underlying MongoDB collection be capped, set
-     * the capped option to the maximum size of the collection in bytes.
-     */
-    capped?: boolean | number | { size?: number; max?: number; autoIndexId?: boolean; };
-    /** Sets a default collation for every query and aggregation. */
-    collation?: mongodb.CollationOptions;
-
-    /** The timeseries option to use when creating the model's collection. */
-    timeseries?: mongodb.TimeSeriesCollectionOptions;
-
-    /**
-     * Mongoose by default produces a collection name by passing the model name to the utils.toCollectionName
-     * method. This method pluralizes the name. Set this option if you need a different name for your collection.
-     */
-    collection?: string;
-    /**
-     * When you define a [discriminator](/docs/discriminators.html), Mongoose adds a path to your
-     * schema that stores which discriminator a document is an instance of. By default, Mongoose
-     * adds an `__t` path, but you can set `discriminatorKey` to overwrite this default.
-     */
-    discriminatorKey?: string;
-    /** defaults to false. */
-    emitIndexErrors?: boolean;
-    excludeIndexes?: any;
-    /**
-     * Mongoose assigns each of your schemas an id virtual getter by default which returns the document's _id field
-     * cast to a string, or in the case of ObjectIds, its hexString.
-     */
-    id?: boolean;
-    /**
-     * Mongoose assigns each of your schemas an _id field by default if one is not passed into the Schema
-     * constructor. The type assigned is an ObjectId to coincide with MongoDB's default behavior. If you
-     * don't want an _id added to your schema at all, you may disable it using this option.
-     */
-    _id?: boolean;
-    /**
-     * Mongoose will, by default, "minimize" schemas by removing empty objects. This behavior can be
-     * overridden by setting minimize option to false. It will then store empty objects.
-     */
-    minimize?: boolean;
-    /**
-     * Optimistic concurrency is a strategy to ensure the document you're updating didn't change between when you
-     * loaded it using find() or findOne(), and when you update it using save(). Set to `true` to enable
-     * optimistic concurrency.
-     */
-    optimisticConcurrency?: boolean;
-    /**
-     * If `plugin()` called with tags, Mongoose will only apply plugins to schemas that have
-     * a matching tag in `pluginTags`
-     */
-    pluginTags?: string[];
-    /**
-     * Allows setting query#read options at the schema level, providing us a way to apply default ReadPreferences
-     * to all queries derived from a model.
-     */
-    read?: string;
-    /** Allows setting write concern at the schema level. */
-    writeConcern?: WriteConcern;
-    /** defaults to true. */
-    safe?: boolean | { w?: number | string; wtimeout?: number; j?: boolean };
-    /**
-     * The shardKey option is used when we have a sharded MongoDB architecture. Each sharded collection is
-     * given a shard key which must be present in all insert/update operations. We just need to set this
-     * schema option to the same shard key and we'll be all set.
-     */
-    shardKey?: Record<string, unknown>;
-    /**
-     * The strict option, (enabled by default), ensures that values passed to our model constructor that were not
-     * specified in our schema do not get saved to the db.
-     */
-    strict?: boolean | 'throw';
-    /**
-     * equal to `strict` by default, may be `false`, `true`, or `'throw'`. Sets the default
-     * [strictQuery](https://mongoosejs.com/docs/guide.html#strictQuery) mode for schemas.
-     */
-    strictQuery?: boolean | 'throw';
-    /** Exactly the same as the toObject option but only applies when the document's toJSON method is called. */
-    toJSON?: ToObjectOptions;
-    /**
-     * Documents have a toObject method which converts the mongoose document into a plain JavaScript object.
-     * This method accepts a few options. Instead of applying these options on a per-document basis, we may
-     * declare the options at the schema level and have them applied to all of the schema's documents by
-     * default.
-     */
-    toObject?: ToObjectOptions;
-    /**
-     * By default, if you have an object with key 'type' in your schema, mongoose will interpret it as a
-     * type declaration. However, for applications like geoJSON, the 'type' property is important. If you want to
-     * control which key mongoose uses to find type declarations, set the 'typeKey' schema option.
-     */
-    typeKey?: string;
-
-    /**
-     * By default, documents are automatically validated before they are saved to the database. This is to
-     * prevent saving an invalid document. If you want to handle validation manually, and be able to save
-     * objects which don't pass validation, you can set validateBeforeSave to false.
-     */
-    validateBeforeSave?: boolean;
-    /**
-     * The versionKey is a property set on each document when first created by Mongoose. This keys value
-     * contains the internal revision of the document. The versionKey option is a string that represents
-     * the path to use for versioning. The default is '__v'.
-     */
-    versionKey?: string | boolean;
-    /**
-     * By default, Mongoose will automatically select() any populated paths for you, unless you explicitly exclude them.
-     */
-    selectPopulatedPaths?: boolean;
-    /**
-     * skipVersioning allows excluding paths from versioning (i.e., the internal revision will not be
-     * incremented even if these paths are updated). DO NOT do this unless you know what you're doing.
-     * For subdocuments, include this on the parent document using the fully qualified path.
-     */
-    skipVersioning?: any;
-    /**
-     * Validation errors in a single nested schema are reported
-     * both on the child and on the parent schema.
-     * Set storeSubdocValidationError to false on the child schema
-     * to make Mongoose only report the parent error.
-     */
-    storeSubdocValidationError?: boolean;
-    /**
-     * The timestamps option tells mongoose to assign createdAt and updatedAt fields to your schema. The type
-     * assigned is Date. By default, the names of the fields are createdAt and updatedAt. Customize the
-     * field names by setting timestamps.createdAt and timestamps.updatedAt.
-     */
-    timestamps?: boolean | SchemaTimestampsConfig;
-
-    /**
-     * Using `save`, `isNew`, and other Mongoose reserved names as schema path names now triggers a warning, not an error.
-     * You can suppress the warning by setting { supressReservedKeysWarning: true } schema options. Keep in mind that this
-     * can break plugins that rely on these reserved names.
-     */
-     supressReservedKeysWarning?: boolean
-  }
-
-  interface SchemaTimestampsConfig {
-    createdAt?: boolean | string;
-    updatedAt?: boolean | string;
-    currentTime?: () => (NativeDate | number);
-  }
-
   type Unpacked<T> = T extends (infer U)[] ?
     U :
     T extends ReadonlyArray<infer U> ? U : T;
 
   type AnyArray<T> = T[] | ReadonlyArray<T>;
+  type SchemaValidator<T> = RegExp | [RegExp, string] | Function | [Function, string] | ValidateOpts<T> | ValidateOpts<T>[];
 
   export class SchemaTypeOptions<T> {
     type?:
@@ -1650,7 +1065,7 @@ declare module 'mongoose' {
     alias?: string;
 
     /** Function or object describing how to validate this schematype. See [validation docs](https://mongoosejs.com/docs/validation.html). */
-    validate?: RegExp | [RegExp, string] | Function | [Function, string] | ValidateOpts<T> | ValidateOpts<T>[];
+    validate?: SchemaValidator<T> | AnyArray<SchemaValidator<T>>;
 
     /** Allows overriding casting logic for this individual path. If a string, the given string overwrites Mongoose's default cast error message. */
     cast?: string;
@@ -1846,15 +1261,15 @@ declare module 'mongoose' {
 
   type InferId<T> = T extends { _id?: any } ? T['_id'] : Types.ObjectId;
 
-  interface VirtualTypeOptions {
+  interface VirtualTypeOptions<HydratedDocType = Document> {
     /** If `ref` is not nullish, this becomes a populated virtual. */
     ref?: string | Function;
 
     /**  The local field to populate on if this is a populated virtual. */
-    localField?: string | Function;
+    localField?: string | ((this: HydratedDocType, doc: HydratedDocType) => string);
 
     /** The foreign field to populate on if this is a populated virtual. */
-    foreignField?: string | Function;
+    foreignField?: string | ((this: HydratedDocType, doc: HydratedDocType) => string);
 
     /**
      * By default, a populated virtual is an array. If you set `justOne`,
@@ -2161,8 +1576,11 @@ declare module 'mongoose' {
 
   type QueryWithHelpers<ResultType, DocType, THelpers = {}, RawDocType = DocType> = Query<ResultType, DocType, THelpers, RawDocType> & THelpers;
 
-  type UnpackedIntersection<T, U> = T extends (infer V)[] ? (V & U)[] : T & U;
-  type UnpackedIntersectionWithNull<T, U> = T extends null ? UnpackedIntersection<T, U> | null : UnpackedIntersection<T, U>;
+  type UnpackedIntersection<T, U> = T extends (infer A)[]
+    ? (Omit<A, keyof U> & U)[]
+    : keyof U extends never
+    ? T
+  : Omit<T, keyof U> & U;
 
   type ProjectionFields<DocType> = {[Key in keyof Omit<LeanDocument<DocType>, '__v'>]?: any} & Record<string, any>;
 
@@ -2242,7 +1660,7 @@ declare module 'mongoose' {
      * Returns a wrapper around a [mongodb driver cursor](http://mongodb.github.io/node-mongodb-native/2.1/api/Cursor.html).
      * A QueryCursor exposes a Streams3 interface, as well as a `.next()` function.
      */
-    cursor(options?: any): QueryCursor<DocType>;
+    cursor(options?: QueryOptions): Cursor<DocType, QueryOptions>;
 
     /**
      * Declare and/or execute this query as a `deleteMany()` operation. Works like
@@ -2263,7 +1681,7 @@ declare module 'mongoose' {
     deleteOne(callback: Callback): QueryWithHelpers<any, DocType, THelpers, RawDocType>;
 
     /** Creates a `distinct` query: returns the distinct values of the given `field` that match `filter`. */
-    distinct(field: string, filter?: FilterQuery<DocType>, callback?: Callback<number>): QueryWithHelpers<Array<any>, DocType, THelpers, RawDocType>;
+    distinct<ReturnType = any>(field: string, filter?: FilterQuery<DocType>, callback?: Callback<number>): QueryWithHelpers<Array<ReturnType>, DocType, THelpers, RawDocType>;
 
     /** Specifies a `$elemMatch` query condition. When called with one argument, the most recent path passed to `where()` is used. */
     elemMatch(val: Function | any): this;
@@ -2463,8 +1881,8 @@ declare module 'mongoose' {
     polygon(path: string, ...coordinatePairs: number[][]): this;
 
     /** Specifies paths which should be populated with other documents. */
-    populate<Paths = {}>(path: string | any, select?: string | any, model?: string | Model<any, THelpers>, match?: any): QueryWithHelpers<UnpackedIntersectionWithNull<ResultType, Paths>, DocType, THelpers, RawDocType>;
-    populate<Paths = {}>(options: PopulateOptions | Array<PopulateOptions>): QueryWithHelpers<UnpackedIntersectionWithNull<ResultType, Paths>, DocType, THelpers, RawDocType>;
+    populate<Paths = {}>(path: string | string[], select?: string | any, model?: string | Model<any, THelpers>, match?: any): QueryWithHelpers<UnpackedIntersection<ResultType, Paths>, DocType, THelpers, RawDocType>;
+    populate<Paths = {}>(options: PopulateOptions | (PopulateOptions | string)[]): QueryWithHelpers<UnpackedIntersection<ResultType, Paths>, DocType, THelpers, RawDocType>;
 
     /** Get/set the current projection (AKA fields). Pass `null` to remove the current projection. */
     projection(): ProjectionFields<DocType> | null;
@@ -2676,13 +2094,20 @@ declare module 'mongoose' {
   } &
     RootQuerySelector<T>;
 
+  /**
+   * Filter query to select the documents that match the query
+   * @example
+   * ```js
+   * { age: { $gte: 30 } }
+   * ```
+   */
   export type FilterQuery<T> = _FilterQuery<T>;
 
   type AddToSetOperators<Type> = {
     $each: Type;
   };
 
-  type SortValues = -1 | 1 | 'asc' | 'desc';
+  type SortValues = -1 | 1 | 'asc' | 'ascending' | 'desc' | 'descending';
 
   type ArrayOperator<Type> = {
     $each: Type;
@@ -2733,6 +2158,13 @@ declare module 'mongoose' {
     [K in keyof T]?: __UpdateDefProperty<T[K]>;
   };
 
+  /**
+   * Update query command to perform on the document
+   * @example
+   * ```js
+   * { age: 30 }
+   * ```
+   */
   export type UpdateQuery<T> = _UpdateQuery<_UpdateQueryDef<T>> & AnyObject;
 
   export type DocumentDefinition<T> = {
@@ -2775,6 +2207,12 @@ declare module 'mongoose' {
     T;
 
   export type SchemaDefinitionType<T> = T extends Document ? Omit<T, Exclude<keyof Document, '_id' | 'id' | '__v'>> : T;
+
+  /**
+   * Documents returned from queries with the lean option enabled.
+   * Plain old JavaScript object documents (POJO).
+   * @see https://mongoosejs.com/docs/tutorials/lean.html
+   */
   export type LeanDocument<T> = Omit<_LeanDocument<T>, Exclude<keyof Document, '_id' | 'id' | '__v'> | '$isSingleNested'>;
 
   export type LeanDocumentOrArray<T> = 0 extends (1 & T) ? T :
@@ -2787,49 +2225,6 @@ declare module 'mongoose' {
     T extends Document ? RawDocType :
     T;
 
-  class QueryCursor<DocType> extends stream.Readable {
-    [Symbol.asyncIterator](): AsyncIterableIterator<DocType>;
-
-    /**
-     * Adds a [cursor flag](http://mongodb.github.io/node-mongodb-native/2.2/api/Cursor.html#addCursorFlag).
-     * Useful for setting the `noCursorTimeout` and `tailable` flags.
-     */
-    addCursorFlag(flag: string, value: boolean): this;
-
-    /**
-     * Marks this cursor as closed. Will stop streaming and subsequent calls to
-     * `next()` will error.
-     */
-    close(): Promise<void>;
-    close(callback: CallbackWithoutResult): void;
-
-    /**
-     * Execute `fn` for every document(s) in the cursor. If batchSize is provided
-     * `fn` will be executed for each batch of documents. If `fn` returns a promise,
-     * will wait for the promise to resolve before iterating on to the next one.
-     * Returns a promise that resolves when done.
-     */
-    eachAsync(fn: (doc: DocType) => any, options?: { parallel?: number }): Promise<void>;
-    eachAsync(fn: (doc: DocType[]) => any, options: { parallel?: number, batchSize: number }): Promise<void>;
-    eachAsync(fn: (doc: DocType) => any, options?: { parallel?: number, batchSize?: number }, cb?: CallbackWithoutResult): void;
-    eachAsync(fn: (doc: DocType[]) => any, options: { parallel?: number, batchSize: number }, cb?: CallbackWithoutResult): void;
-
-    /**
-     * Registers a transform function which subsequently maps documents retrieved
-     * via the streams interface or `.next()`
-     */
-    map<ResultType>(fn: (res: DocType) => ResultType): QueryCursor<ResultType>;
-
-    /**
-     * Get the next document from this cursor. Will return `null` when there are
-     * no documents left.
-     */
-    next(): Promise<DocType>;
-    next(callback: Callback<DocType | null>): void;
-
-    options: any;
-  }
-
   class Aggregate<R> {
     /**
      * Returns an asyncIterator for use with [`for/await/of` loops](https://thecodebarbarian.com/getting-started-with-async-iterators-in-node-js
@@ -2871,7 +2266,7 @@ declare module 'mongoose' {
     /**
      * Sets the cursor option for the aggregation query (ignored for < 2.6.0).
      */
-    cursor(options?: Record<string, unknown>): AggregationCursor;
+    cursor<DocType = any>(options?: Record<string, unknown>): Cursor<DocType>;
 
     /** Executes the aggregate pipeline on the currently bound Model. */
     exec(callback?: Callback<R>): Promise<R>;
@@ -2959,7 +2354,7 @@ declare module 'mongoose' {
     skip(num: number): this;
 
     /** Appends a new $sort operator to this aggregate pipeline. */
-    sort(arg: PipelineStage.Sort['$sort']): this;
+    sort(arg: string | Record<string, SortValues> | PipelineStage.Sort['$sort']): this;
 
     /** Provides promise for aggregate. */
     then: Promise<R>['then'];
@@ -2977,43 +2372,6 @@ declare module 'mongoose' {
     unwind(...args: PipelineStage.Unwind['$unwind'][]): this;
   }
 
-  class AggregationCursor extends stream.Readable {
-    /**
-     * Adds a [cursor flag](http://mongodb.github.io/node-mongodb-native/2.2/api/Cursor.html#addCursorFlag).
-     * Useful for setting the `noCursorTimeout` and `tailable` flags.
-     */
-    addCursorFlag(flag: string, value: boolean): this;
-
-    /**
-     * Marks this cursor as closed. Will stop streaming and subsequent calls to
-     * `next()` will error.
-     */
-    close(): Promise<void>;
-    close(callback: CallbackWithoutResult): void;
-
-    /**
-     * Execute `fn` for every document(s) in the cursor. If batchSize is provided
-     * `fn` will be executed for each batch of documents. If `fn` returns a promise,
-     * will wait for the promise to resolve before iterating on to the next one.
-     * Returns a promise that resolves when done.
-     */
-    eachAsync(fn: (doc: any) => any, options?: { parallel?: number, batchSize?: number }): Promise<void>;
-    eachAsync(fn: (doc: any) => any, options?: { parallel?: number, batchSize?: number }, cb?: CallbackWithoutResult): void;
-
-    /**
-     * Registers a transform function which subsequently maps documents retrieved
-     * via the streams interface or `.next()`
-     */
-    map(fn: (res: any) => any): this;
-
-    /**
-     * Get the next document from this cursor. Will return `null` when there are
-     * no documents left.
-     */
-    next(): Promise<any>;
-    next(callback: Callback): void;
-  }
-
   class SchemaType {
     /** SchemaType constructor */
     constructor(path: string, options?: AnyObject, instance?: string);
@@ -3111,6 +2469,7 @@ declare module 'mongoose' {
   type Callback<T = any> = (error: CallbackError, result: T) => void;
 
   type CallbackWithoutResult = (error: CallbackError) => void;
+  type CallbackWithoutResultAndOptionalError = (error?: CallbackError) => void;
 
   /* for ts-mongoose */
   class mquery {}