mongoose 6.2.1 → 6.2.4

package/types/index.d.ts

@@ -1,16 +1,13 @@
+/// <reference path="./Error.d.ts" />
+/// <reference path="./PipelineStage.d.ts" />
+/// <reference path="./Connection.d.ts" />
+
+import events = require('events');
+import mongodb = require('mongodb');
+import mongoose = require('mongoose');
+import stream = require('stream');
+
 declare module 'mongoose' {
-  import events = require('events');
-  import mongodb = require('mongodb');
-  import mongoose = require('mongoose');
-  import stream = require('stream');
-
-  export enum ConnectionStates {
-    disconnected = 0,
-    connected = 1,
-    connecting = 2,
-    disconnecting = 3,
-    uninitialized = 99,
-  }
 
   class NativeDate extends global.Date {}
 
@@ -60,9 +57,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;
@@ -96,10 +90,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.
@@ -114,7 +109,7 @@ declare module 'mongoose' {
   /** Gets mongoose options */
   export function get<K extends keyof MongooseOptions>(key: K): MongooseOptions[K];
 
-  /*! ignore */
+  /* ! ignore */
   type CompileModelOptions = { overwriteModels?: boolean, connection?: Connection };
 
   /**
@@ -284,190 +279,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
@@ -910,12 +721,12 @@ declare module 'mongoose' {
     init(callback?: CallbackWithoutResult): Promise<HydratedDocument<T, TMethodsAndOverrides, TVirtuals>>;
 
     /** Inserts one or more new documents as a single `insertMany` call to the MongoDB server. */
-    insertMany(docs: Array<AnyKeys<T> | AnyObject>, options: InsertManyOptions & { rawResult: true }): Promise<InsertManyResult>;
+    insertMany(docs: Array<AnyKeys<T> | AnyObject>, options: InsertManyOptions & { rawResult: true }): Promise<InsertManyResult<T>>;
     insertMany(docs: Array<AnyKeys<T> | AnyObject>, options?: InsertManyOptions): Promise<Array<HydratedDocument<T, TMethodsAndOverrides, TVirtuals>>>;
-    insertMany(doc: AnyKeys<T> | AnyObject, options: InsertManyOptions & { rawResult: true }): Promise<InsertManyResult>;
+    insertMany(doc: AnyKeys<T> | AnyObject, options: InsertManyOptions & { rawResult: true }): Promise<InsertManyResult<T>>;
     insertMany(doc: AnyKeys<T> | AnyObject, options?: InsertManyOptions): Promise<HydratedDocument<T, TMethodsAndOverrides, TVirtuals>[]>;
-    insertMany(doc: AnyKeys<T> | AnyObject, options?: InsertManyOptions, callback?: Callback<HydratedDocument<T, TMethodsAndOverrides, TVirtuals>[] | InsertManyResult>): void;
-    insertMany(docs: Array<AnyKeys<T> | AnyObject>, options?: InsertManyOptions, callback?: Callback<Array<HydratedDocument<T, TMethodsAndOverrides, TVirtuals>> | InsertManyResult>): void;
+    insertMany(doc: AnyKeys<T> | AnyObject, options?: InsertManyOptions, callback?: Callback<HydratedDocument<T, TMethodsAndOverrides, TVirtuals>[] | InsertManyResult<T>>): void;
+    insertMany(docs: Array<AnyKeys<T> | AnyObject>, options?: InsertManyOptions, callback?: Callback<Array<HydratedDocument<T, TMethodsAndOverrides, TVirtuals>> | InsertManyResult<T>>): void;
 
     /**
      * Lists the indexes currently defined in MongoDB. This may or may not be
@@ -977,7 +788,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>;
@@ -1166,9 +977,13 @@ declare module 'mongoose' {
     populate?: string | string[] | PopulateOptions | PopulateOptions[];
   }
 
-  interface InsertManyResult extends mongodb.InsertManyResult {
-    mongoose?: { validationErrors?: Array<Error.CastError | Error.ValidatorError> }
-  }
+  type InferIdType<T> = T extends { _id?: any } ? T['_id'] : Types.ObjectId;
+  type InsertManyResult<T> = mongodb.InsertManyResult<T> & {
+    insertedIds: {
+      [key: number]: InferIdType<T>;
+    };
+    mongoose?: { validationErrors?: Array<Error.CastError | Error.ValidatorError> };
+  };
 
   interface MapReduceOptions<T, Key, Val> {
     map: Function | string;
@@ -1301,6 +1116,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 };
 
@@ -1374,7 +1192,9 @@ declare module 'mongoose' {
 
     /** Defines a pre hook for the model. */
     pre<T = HydratedDocument<DocType, TInstanceMethods>>(method: 'save', fn: PreSaveMiddlewareFunction<T>): this;
+    pre<T = HydratedDocument<DocType, TInstanceMethods>>(method: 'save', options: SchemaPreOptions, fn: PreSaveMiddlewareFunction<T>): this;
     pre<T = HydratedDocument<DocType, TInstanceMethods>>(method: MongooseDocumentMiddleware | MongooseDocumentMiddleware[] | RegExp, fn: PreMiddlewareFunction<T>): this;
+    pre<T = HydratedDocument<DocType, TInstanceMethods>>(method: MongooseDocumentMiddleware | MongooseDocumentMiddleware[] | RegExp, options: SchemaPreOptions, fn: PreMiddlewareFunction<T>): this;
     pre<T extends Query<any, any>>(method: MongooseDocumentMiddleware | MongooseDocumentMiddleware[] | RegExp, options: SchemaPreOptions, fn: PreMiddlewareFunction<T>): this;
     pre<T extends Query<any, any>>(method: MongooseQueryMiddleware | MongooseQueryMiddleware[] | string | RegExp, fn: PreMiddlewareFunction<T>): this;
     pre<T extends Query<any, any>>(method: MongooseQueryMiddleware | MongooseQueryMiddleware[] | string | RegExp, options: SchemaPreOptions, fn: PreMiddlewareFunction<T>): this;
@@ -1598,6 +1418,13 @@ declare module 'mongoose' {
      * 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 {
@@ -1611,6 +1438,7 @@ declare module 'mongoose' {
     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?:
@@ -1633,7 +1461,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;
@@ -2246,7 +2074,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;
@@ -2659,6 +2487,13 @@ 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> = {
@@ -2716,6 +2551,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> = {
@@ -2758,6 +2600,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 :
@@ -2997,272 +2845,6 @@ declare module 'mongoose' {
     next(callback: Callback): void;
   }
 
-  /**
-   * [Stages reference](https://docs.mongodb.com/manual/reference/operator/aggregation-pipeline/#aggregation-pipeline-stages)
-   */
-  export type PipelineStage =
-    | PipelineStage.AddFields
-    | PipelineStage.Bucket
-    | PipelineStage.BucketAuto
-    | PipelineStage.CollStats
-    | PipelineStage.Count
-    | PipelineStage.Facet
-    | PipelineStage.GeoNear
-    | PipelineStage.GraphLookup
-    | PipelineStage.Group
-    | PipelineStage.IndexStats
-    | PipelineStage.Limit
-    | PipelineStage.ListSessions
-    | PipelineStage.Lookup
-    | PipelineStage.Match
-    | PipelineStage.Merge
-    | PipelineStage.Out
-    | PipelineStage.PlanCacheStats
-    | PipelineStage.Project
-    | PipelineStage.Redact
-    | PipelineStage.ReplaceRoot
-    | PipelineStage.ReplaceWith
-    | PipelineStage.Sample
-    | PipelineStage.Search
-    | PipelineStage.Set
-    | PipelineStage.SetWindowFields
-    | PipelineStage.Skip
-    | PipelineStage.Sort
-    | PipelineStage.SortByCount
-    | PipelineStage.UnionWith
-    | PipelineStage.Unset
-    | PipelineStage.Unwind
-
-  export namespace PipelineStage {
-    export interface AddFields {
-      /** [`$addFields` reference](https://docs.mongodb.com/manual/reference/operator/aggregation/addFields/) */
-      $addFields: Record<string, any>
-    }
-
-    export interface Bucket {
-      /** [`$bucket` reference](https://docs.mongodb.com/manual/reference/operator/aggregation/bucket/) */
-      $bucket: {
-        groupBy: any
-        boundaries: any[]
-        default?: any
-        output?: Record<string, { [op in AccumulatorOperator]?: any }>
-      }
-    }
-
-    export interface BucketAuto {
-      /** [`$bucketAuto` reference](https://docs.mongodb.com/manual/reference/operator/aggregation/bucketAuto/) */
-      $bucketAuto: {
-        groupBy: any
-        buckets: number
-        output?: Record<string, { [op in AccumulatorOperator]?: any }>
-        granularity?: 'R5' | 'R10' | 'R20' | 'R40' | 'R80' | '1-2-5' | 'E6' | 'E12' | 'E24' | 'E48' | 'E96' | 'E192' | 'POWERSOF2'
-      }
-    }
-
-    export interface CollStats {
-      /** [`$collStats` reference](https://docs.mongodb.com/manual/reference/operator/aggregation/collStats/) */
-      $collStats: {
-        latencyStats?: { histograms?: boolean }
-        storageStats?: { scale?: number }
-        count?: {}
-        queryExecStats?: {}
-      }
-    }
-
-    export interface Count {
-      /** [`$count` reference](https://docs.mongodb.com/manual/reference/operator/aggregation/count/) */
-      $count: string
-    }
-
-    export interface Facet {
-      /** [`$facet` reference](https://docs.mongodb.com/manual/reference/operator/aggregation/facet/) */
-      $facet: Record<string, FacetPipelineStage[]>
-    }
-
-    export type FacetPipelineStage = Exclude<PipelineStage, PipelineStage.CollStats | PipelineStage.Facet | PipelineStage.GeoNear | PipelineStage.IndexStats | PipelineStage.Out | PipelineStage.Merge | PipelineStage.PlanCacheStats>
-
-    export interface GeoNear {
-      /** [`$geoNear` reference](https://docs.mongodb.com/manual/reference/operator/aggregation/geoNear/) */
-      $geoNear: {
-        near: { type: 'Point'; coordinates: [number, number] } | [number, number]
-        distanceField: string
-        distanceMultiplier?: number
-        includeLocs?: string
-        key?: string
-        maxDistance?: number
-        minDistance?: number
-        query?: AnyObject
-        spherical?: boolean
-        uniqueDocs?: boolean
-      }
-    }
-
-    export interface GraphLookup {
-      /** [`$graphLookup` reference](https://docs.mongodb.com/manual/reference/operator/aggregation/graphLookup/) */
-      $graphLookup: {
-        from: string
-        startWith: any
-        connectFromField: string
-        connectToField: string
-        as: string
-        maxDepth?: number
-        depthField?: string
-        restrictSearchWithMatch?: AnyObject
-      }
-    }
-
-    export interface Group {
-      /** [`$group` reference](https://docs.mongodb.com/manual/reference/operator/aggregation/group) */
-      $group: { _id: any } | { [key: string]: { [op in AccumulatorOperator]?: any } }
-    }
-
-    export interface IndexStats {
-      /** [`$indexStats` reference](https://docs.mongodb.com/manual/reference/operator/aggregation/indexStats/) */
-      $indexStats: {}
-    }
-
-    export interface Limit {
-      /** [`$limit` reference](https://docs.mongodb.com/manual/reference/operator/aggregation/limit/) */
-      $limit: number
-    }
-
-    export interface ListSessions {
-      /** [`$listSessions` reference](https://docs.mongodb.com/manual/reference/operator/aggregation/listSessions/) */
-      $listSessions: { users?: { user: string; db: string }[] } | { allUsers?: true }
-    }
-
-    export interface Lookup {
-      /** [`$lookup` reference](https://docs.mongodb.com/manual/reference/operator/aggregation/lookup/) */
-      $lookup: {
-        from: string
-        as: string
-        localField?: string
-        foreignField?: string
-        let?: Record<string, any>
-        pipeline?: Exclude<PipelineStage, PipelineStage.Merge | PipelineStage.Out | PipelineStage.Search>[]
-      }
-    }
-
-    export interface Match {
-      /** [`$match` reference](https://docs.mongodb.com/manual/reference/operator/aggregation/match/) */
-      $match: AnyObject
-    }
-
-    export interface Merge {
-      /** [`$merge` reference](https://docs.mongodb.com/manual/reference/operator/aggregation/merge/) */
-      $merge: {
-        into: string | { db: string; coll: string }
-        on?: string | string[]
-        let?: Record<string, any>
-        whenMatched?: 'replace' | 'keepExisting' | 'merge' | 'fail' | Extract<PipelineStage, PipelineStage.AddFields | PipelineStage.Set | PipelineStage.Project | PipelineStage.Unset | PipelineStage.ReplaceRoot | PipelineStage.ReplaceWith>[]
-        whenNotMatched?: 'insert' | 'discard' | 'fail'
-      }
-    }
-
-    export interface Out {
-      /** [`$out` reference](https://docs.mongodb.com/manual/reference/operator/aggregation/out/) */
-      $out: string | { db: string; coll: string }
-    }
-
-    export interface PlanCacheStats {
-      /** [`$planCacheStats` reference](https://docs.mongodb.com/manual/reference/operator/aggregation/planCacheStats/) */
-      $planCacheStats: {}
-    }
-
-    export interface Project {
-      /** [`$project` reference](https://docs.mongodb.com/manual/reference/operator/aggregation/project/) */
-      $project: { [field: string]: any }
-    }
-
-    export interface Redact {
-      /** [`$redact` reference](https://docs.mongodb.com/manual/reference/operator/aggregation/redact/) */
-      $redact: any
-    }
-
-    export interface ReplaceRoot {
-      /** [`$replaceRoot` reference](https://docs.mongodb.com/manual/reference/operator/aggregation/replaceRoot/) */
-      $replaceRoot: { newRoot: any }
-    }
-
-    export interface ReplaceWith {
-      /** [`$replaceWith` reference](https://docs.mongodb.com/manual/reference/operator/aggregation/replaceWith/) */
-      $replaceWith: any
-    }
-
-    export interface Sample {
-      /** [`$sample` reference](https://docs.mongodb.com/manual/reference/operator/aggregation/sample/) */
-      $sample: { size: number }
-    }
-
-    export interface Search {
-      /** [`$search` reference](https://docs.atlas.mongodb.com/reference/atlas-search/query-syntax/) */
-      $search: {
-        [key: string]: any
-        index?: string
-        highlight?: { path: string; maxCharsToExamine?: number; maxNumPassages?: number }
-      }
-    }
-
-    export interface Set {
-      /** [`$set` reference](https://docs.mongodb.com/manual/reference/operator/aggregation/set/) */
-      $set: Record<string, any>
-    }
-
-    export interface SetWindowFields {
-      /** [`$setWindowFields` reference](https://docs.mongodb.com/manual/reference/operator/aggregation/setWindowFields/) */
-      $setWindowFields: {
-        partitionBy?: any
-        sortBy?: Record<string, 1 | -1>
-        output: Record<
-          string,
-          { [op in WindowOperator]?: any } & {
-            window?: {
-              documents?: [string | number, string | number]
-              range?: [string | number, string | number]
-              unit?: 'year' | 'quarter' | 'month' | 'week' | 'day' | 'hour' | 'minute' | 'second' | 'millisecond'
-            }
-          }
-        >
-      }
-    }
-
-    export interface Skip {
-      /** [`$skip` reference](https://docs.mongodb.com/manual/reference/operator/aggregation/skip/) */
-      $skip: number
-    }
-
-    export interface Sort {
-      /** [`$sort` reference](https://docs.mongodb.com/manual/reference/operator/aggregation/sort/) */
-      $sort: Record<string, 1 | -1 | { $meta: 'textScore' }>
-    }
-
-    export interface SortByCount {
-      /** [`$sortByCount` reference](https://docs.mongodb.com/manual/reference/operator/aggregation/sortByCount/) */
-      $sortByCount: any
-    }
-
-    export interface UnionWith {
-      /** [`$unionWith` reference](https://docs.mongodb.com/manual/reference/operator/aggregation/unionWith/) */
-      $unionWith:
-        | string
-        | { coll: string; pipeline?: Exclude<PipelineStage, PipelineStage.Out | PipelineStage.Merge>[] }
-    }
-
-    export interface Unset {
-      /** [`$unset` reference](https://docs.mongodb.com/manual/reference/operator/aggregation/unset/) */
-      $unset: string | string[]
-    }
-
-    export interface Unwind {
-      /** [`$unwind` reference](https://docs.mongodb.com/manual/reference/operator/aggregation/unwind/) */
-      $unwind: string | { path: string; includeArrayIndex?: string; preserveNullAndEmptyArrays?: boolean }
-    }
-
-    type AccumulatorOperator = '$accumulator' | '$addToSet' | '$avg' | '$count' | '$first' | '$last' | '$max' | '$mergeObjects' | '$min' | '$push' | '$stdDevPop' | '$stdDevSamp' | '$sum'
-
-    type WindowOperator = '$addToSet' | '$avg' | '$count' | '$covariancePop' | '$covarianceSamp' | '$derivative' | '$expMovingAvg' | '$integral' | '$max' | '$min' | '$push' | '$stdDevSamp' | '$stdDevPop' | '$sum' | '$first' | '$last' | '$shift' | '$denseRank' | '$documentNumber' | '$rank'
-  }
-
   class SchemaType {
     /** SchemaType constructor */
     constructor(path: string, options?: AnyObject, instance?: string);
@@ -3361,131 +2943,8 @@ declare module 'mongoose' {
 
   type CallbackWithoutResult = (error: CallbackError) => void;
 
-  class NativeError extends global.Error { }
-  type CallbackError = NativeError | null;
-
-  class Error extends global.Error {
-    constructor(msg: string);
-
-    /** The type of error. "MongooseError" for generic errors. */
-    name: string;
-
-    static messages: any;
-
-    static Messages: any;
-  }
-
-  namespace Error {
-    export class CastError extends Error {
-      name: 'CastError';
-      stringValue: string;
-      kind: string;
-      value: any;
-      path: string;
-      reason?: NativeError | null;
-      model?: any;
-
-      constructor(type: string, value: any, path: string, reason?: NativeError, schemaType?: SchemaType);
-    }
-    export class SyncIndexesError extends Error {
-      name: 'SyncIndexesError';
-      errors?: Record<string, mongodb.MongoServerError>;
-
-      constructor(type: string, value: any, path: string, reason?: NativeError, schemaType?: SchemaType);
-    }
-
-    export class DisconnectedError extends Error {
-      name: 'DisconnectedError';
-    }
-
-    export class DivergentArrayError extends Error {
-      name: 'DivergentArrayError';
-    }
-
-    export class MissingSchemaError extends Error {
-      name: 'MissingSchemaError';
-    }
-
-    export class DocumentNotFoundError extends Error {
-      name: 'DocumentNotFoundError';
-      result: any;
-      numAffected: number;
-      filter: any;
-      query: any;
-    }
-
-    export class ObjectExpectedError extends Error {
-      name: 'ObjectExpectedError';
-      path: string;
-    }
-
-    export class ObjectParameterError extends Error {
-      name: 'ObjectParameterError';
-    }
-
-    export class OverwriteModelError extends Error {
-      name: 'OverwriteModelError';
-    }
-
-    export class ParallelSaveError extends Error {
-      name: 'ParallelSaveError';
-    }
-
-    export class ParallelValidateError extends Error {
-      name: 'ParallelValidateError';
-    }
-
-    export class MongooseServerSelectionError extends Error {
-      name: 'MongooseServerSelectionError';
-    }
-
-    export class StrictModeError extends Error {
-      name: 'StrictModeError';
-      isImmutableError: boolean;
-      path: string;
-    }
-
-    export class ValidationError extends Error {
-      name: 'ValidationError';
-
-      errors: { [path: string]: ValidatorError | CastError | ValidationError };
-      addError: (path: string, error: ValidatorError | CastError | ValidationError) => void;
-
-      constructor(instance?: Error);
-    }
-
-    export class ValidatorError extends Error {
-      name: 'ValidatorError';
-      properties: {
-        message: string,
-        type?: string,
-        path?: string,
-        value?: any,
-        reason?: any
-      };
-      kind: string;
-      path: string;
-      value: any;
-      reason?: Error | null;
-
-      constructor(properties: {
-        message?: string,
-        type?: string,
-        path?: string,
-        value?: any,
-        reason?: any
-      });
-    }
-
-    export class VersionError extends Error {
-      name: 'VersionError';
-      version: number;
-      modifiedPaths: Array<string>;
-
-      constructor(doc: Document, currentVersion: number, modifiedPaths: Array<string>);
-    }
-  }
-
   /* for ts-mongoose */
   class mquery {}
 }
+
+export default mongoose;