mongoose 6.2.4 → 6.2.7

package/types/index.d.ts

@@ -1,11 +1,14 @@
-/// <reference path="./Error.d.ts" />
-/// <reference path="./PipelineStage.d.ts" />
-/// <reference path="./Connection.d.ts" />
+/// <reference path="./connection.d.ts" />
+/// <reference path="./cursor.d.ts" />
+/// <reference path="./document.d.ts" />
+/// <reference path="./error.d.ts" />
+/// <reference path="./mongooseoptions.d.ts" />
+/// <reference path="./pipelinestage.d.ts" />
+/// <reference path="./schemaoptions.d.ts" />
 
 import events = require('events');
 import mongodb = require('mongodb');
 import mongoose = require('mongoose');
-import stream = require('stream');
 
 declare module 'mongoose' {
 
@@ -119,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,
@@ -165,117 +175,6 @@ declare module 'mongoose' {
 
   type Mongoose = typeof mongoose;
 
-  interface MongooseOptions {
-    /** true by default. Set to false to skip applying global plugins to child schemas */
-    applyPluginsToChildSchemas?: boolean;
-
-    /**
-     * false by default. Set to true to apply global plugins to discriminator schemas.
-     * This typically isn't necessary because plugins are applied to the base schema and
-     * discriminators copy all middleware, methods, statics, and properties from the base schema.
-     */
-    applyPluginsToDiscriminators?: boolean;
-
-    /**
-     * Set to `true` to make Mongoose call` Model.createCollection()` automatically when you
-     * create a model with `mongoose.model()` or `conn.model()`. This is useful for testing
-     * transactions, change streams, and other features that require the collection to exist.
-     */
-    autoCreate?: boolean;
-
-    /**
-     * true by default. Set to false to disable automatic index creation
-     * for all models associated with this Mongoose instance.
-     */
-    autoIndex?: boolean;
-
-    /** enable/disable mongoose's buffering mechanism for all connections and models */
-    bufferCommands?: boolean;
-
-    bufferTimeoutMS?: number;
-
-    /** false by default. Set to `true` to `clone()` all schemas before compiling into a model. */
-    cloneSchemas?: boolean;
-
-    /**
-     * If `true`, prints the operations mongoose sends to MongoDB to the console.
-     * If a writable stream is passed, it will log to that stream, without colorization.
-     * If a callback function is passed, it will receive the collection name, the method
-     * name, then all arguments passed to the method. For example, if you wanted to
-     * replicate the default logging, you could output from the callback
-     * `Mongoose: ${collectionName}.${methodName}(${methodArgs.join(', ')})`.
-     */
-    debug?:
-      | boolean
-      | { color?: boolean; shell?: boolean }
-      | stream.Writable
-      | ((collectionName: string, methodName: string, ...methodArgs: any[]) => void);
-
-    /** If set, attaches [maxTimeMS](https://docs.mongodb.com/manual/reference/operator/meta/maxTimeMS/) to every query */
-    maxTimeMS?: number;
-
-    /**
-     * true by default. Mongoose adds a getter to MongoDB ObjectId's called `_id` that
-     * returns `this` for convenience with populate. Set this to false to remove the getter.
-     */
-    objectIdGetter?: boolean;
-
-    /**
-     * Set to `true` to default to overwriting models with the same name when calling
-     * `mongoose.model()`, as opposed to throwing an `OverwriteModelError`.
-     */
-    overwriteModels?: boolean;
-
-    /**
-     * If `false`, changes the default `returnOriginal` option to `findOneAndUpdate()`,
-     * `findByIdAndUpdate`, and `findOneAndReplace()` to false. This is equivalent to
-     * setting the `new` option to `true` for `findOneAndX()` calls by default. Read our
-     * `findOneAndUpdate()` [tutorial](https://mongoosejs.com/docs/tutorials/findoneandupdate.html)
-     * for more information.
-     */
-    returnOriginal?: boolean;
-
-    /**
-     * false by default. Set to true to enable [update validators](
-     * https://mongoosejs.com/docs/validation.html#update-validators
-     * ) for all validators by default.
-     */
-    runValidators?: boolean;
-
-    sanitizeFilter?: boolean;
-
-    sanitizeProjection?: boolean;
-
-    /**
-     * true by default. Set to false to opt out of Mongoose adding all fields that you `populate()`
-     * to your `select()`. The schema-level option `selectPopulatedPaths` overwrites this one.
-     */
-    selectPopulatedPaths?: boolean;
-
-    setDefaultsOnInsert?: boolean;
-
-    /** true by default, may be `false`, `true`, or `'throw'`. Sets the default strict mode for schemas. */
-    strict?: boolean | 'throw';
-
-    /** true by default. set to `false` to allow populating paths that aren't in the schema */
-    strictPopulate?: boolean;
-
-    /**
-     * false 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';
-
-    /**
-     * `{ transform: true, flattenDecimals: true }` by default. Overwrites default objects to
-     * `toJSON()`, for determining how Mongoose documents get serialized by `JSON.stringify()`
-     */
-    toJSON?: ToObjectOptions;
-
-    /** `{ transform: true, flattenDecimals: true }` by default. Overwrites default objects to `toObject()` */
-    toObject?: ToObjectOptions;
-  }
-
   // eslint-disable-next-line @typescript-eslint/no-empty-interface
   interface ClientSession extends mongodb.ClientSession { }
 
@@ -322,247 +221,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. */
@@ -650,8 +310,8 @@ declare module 'mongoose' {
      * mongoose will not create the collection for the model until any documents are
      * created. Use this method to create the collection explicitly.
      */
-    createCollection<T>(options?: mongodb.CreateCollectionOptions): Promise<mongodb.Collection<T>>;
-    createCollection<T>(options: mongodb.CreateCollectionOptions | null, callback: Callback<mongodb.Collection<T>>): void;
+    createCollection<T>(options?: mongodb.CreateCollectionOptions & Pick<SchemaOptions, 'expires'>): Promise<mongodb.Collection<T>>;
+    createCollection<T>(options: mongodb.CreateCollectionOptions & Pick<SchemaOptions, 'expires'> | null, callback: Callback<mongodb.Collection<T>>): void;
 
     /**
      * Similar to `ensureIndexes()`, except for it uses the [`createIndex`](http://mongodb.github.io/node-mongodb-native/2.2/api/Collection.html#createIndex)
@@ -1092,10 +752,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 {
     /**
@@ -1226,7 +886,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;
@@ -1256,183 +916,16 @@ 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;
@@ -1657,15 +1150,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`,
@@ -1972,8 +1465,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>;
 
@@ -2053,7 +1549,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
@@ -2274,8 +1770,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;
@@ -2500,7 +1996,7 @@ declare module 'mongoose' {
     $each: Type;
   };
 
-  type SortValues = -1 | 1 | 'asc' | 'desc';
+  type SortValues = -1 | 1 | 'asc' | 'ascending' | 'desc' | 'descending';
 
   type ArrayOperator<Type> = {
     $each: Type;
@@ -2618,49 +2114,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
@@ -2702,7 +2155,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>;
@@ -2790,7 +2243,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'];
@@ -2808,43 +2261,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);
@@ -2942,6 +2358,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 {}