mongoose 8.0.1 → 8.0.2

package/lib/aggregate.js

@@ -665,7 +665,7 @@ Aggregate.prototype.unionWith = function(options) {
  *     await Model.aggregate(pipeline).read('primaryPreferred');
  *
  * @param {String|ReadPreference} pref one of the listed preference options or their aliases
- * @param {Array} [tags] optional tags for this query. DEPRECATED
+ * @param {Array} [tags] optional tags for this query.
  * @return {Aggregate} this
  * @api public
  * @see mongodb https://www.mongodb.com/docs/manual/applications/replication/#read-preference

package/lib/helpers/populate/assignRawDocsToIdStructure.js

@@ -32,9 +32,13 @@ const kHasArray = Symbol('mongoose#assignRawDocsToIdStructure#hasArray');
  */
 
 function assignRawDocsToIdStructure(rawIds, resultDocs, resultOrder, options, recursed) {
-  // honor user specified sort order
+  // honor user specified sort order, unless we're populating a single
+  // virtual underneath an array (e.g. populating `employees.mostRecentShift` where
+  // `mostRecentShift` is a virtual with `justOne`)
   const newOrder = [];
-  const sorting = options.sort && rawIds.length > 1;
+  const sorting = options.isVirtual && options.justOne && rawIds.length > 1
+    ? false :
+    options.sort && rawIds.length > 1;
   const nullIfNotFound = options.$nullIfNotFound;
   let doc;
   let sid;

package/lib/helpers/populate/assignVals.js

@@ -19,7 +19,8 @@ module.exports = function assignVals(o) {
   // `o.options` contains options explicitly listed in `populateOptions`, like
   // `match` and `limit`.
   const populateOptions = Object.assign({}, o.options, userOptions, {
-    justOne: o.justOne
+    justOne: o.justOne,
+    isVirtual: o.isVirtual
   });
   populateOptions.$nullIfNotFound = o.isVirtual;
   const populatedModel = o.populatedModel;
@@ -144,7 +145,6 @@ module.exports = function assignVals(o) {
 
     const parts = _path.split('.');
     let cur = docs[i];
-    const curPath = parts[0];
     for (let j = 0; j < parts.length - 1; ++j) {
       // If we get to an array with a dotted path, like `arr.foo`, don't set
       // `foo` on the array.
@@ -160,6 +160,7 @@ module.exports = function assignVals(o) {
         // If nothing to set, avoid creating an unnecessary array. Otherwise
         // we'll end up with a single doc in the array with only defaults.
         // See gh-8342, gh-8455
+        const curPath = parts.slice(0, j + 1).join('.');
         const schematype = originalSchema._getSchema(curPath);
         if (valueToSet == null && schematype != null && schematype.$isMongooseArray) {
           break;

package/lib/stateMachine.js

@@ -65,7 +65,11 @@ StateMachine.ctor = function() {
  */
 
 StateMachine.prototype._changeState = function _changeState(path, nextState) {
-  const prevBucket = this.states[this.paths[path]];
+  const prevState = this.paths[path];
+  if (prevState === nextState) {
+    return;
+  }
+  const prevBucket = this.states[prevState];
   if (prevBucket) delete prevBucket[path];
 
   this.paths[path] = nextState;

package/lib/types/array/methods/index.js

@@ -374,7 +374,15 @@ const methods = {
       if (val != null && utils.hasUserDefinedProperty(val, '$each')) {
         atomics.$push = val;
       } else {
-        atomics.$push.$each = atomics.$push.$each.concat(val);
+        if (val.length === 1) {
+          atomics.$push.$each.push(val[0]);
+        } else if (val.length < 10000) {
+          atomics.$push.$each.push(...val);
+        } else {
+          for (const v of val) {
+            atomics.$push.$each.push(v);
+          }
+        }
       }
     } else {
       atomics[op] = val;
@@ -403,8 +411,7 @@ const methods = {
   addToSet() {
     _checkManualPopulation(this, arguments);
 
-    let values = [].map.call(arguments, this._mapCast, this);
-    values = this[arraySchemaSymbol].applySetters(values, this[arrayParentSymbol]);
+    const values = [].map.call(arguments, this._mapCast, this);
     const added = [];
     let type = '';
     if (values[0] instanceof ArraySubdocument) {
@@ -415,7 +422,7 @@ const methods = {
       type = 'ObjectId';
     }
 
-    const rawValues = utils.isMongooseArray(values) ? values.__array : this;
+    const rawValues = utils.isMongooseArray(values) ? values.__array : values;
     const rawArray = utils.isMongooseArray(this) ? this.__array : this;
 
     rawValues.forEach(function(v) {
@@ -682,10 +689,7 @@ const methods = {
 
     _checkManualPopulation(this, values);
 
-    const parent = this[arrayParentSymbol];
     values = [].map.call(values, this._mapCast, this);
-    values = this[arraySchemaSymbol].applySetters(values, parent, undefined,
-      undefined, { skipDocumentArrayCast: true });
     let ret;
     const atomics = this[arrayAtomicsSymbol];
     this._markModified();
@@ -711,7 +715,7 @@ const methods = {
           'with different `$position`');
       }
       atomic = values;
-      ret = [].push.apply(arr, values);
+      ret = _basePush.apply(arr, values);
     }
 
     this._registerAtomic('$push', atomic);
@@ -917,7 +921,6 @@ const methods = {
       values = arguments;
     } else {
       values = [].map.call(arguments, this._cast, this);
-      values = this[arraySchemaSymbol].applySetters(values, this[arrayParentSymbol]);
     }
 
     const arr = utils.isMongooseArray(this) ? this.__array : this;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "mongoose",
   "description": "Mongoose MongoDB ODM",
-  "version": "8.0.1",
+  "version": "8.0.2",
   "author": "Guillermo Rauch <guillermo@learnboost.com>",
   "keywords": [
     "mongodb",
@@ -93,10 +93,10 @@
     "docs:merge:6x": "git merge 6.x",
     "docs:test": "npm run docs:generate && npm run docs:generate:search",
     "docs:view": "node ./scripts/static.js",
-    "docs:prepare:publish:stable": "npm run docs:checkout:gh-pages && npm run docs:merge:stable && npm run docs:clean:stable && npm run docs:generate && npm run docs:generate:search",
+    "docs:prepare:publish:stable": "npm run docs:checkout:gh-pages && npm run docs:merge:stable && npm run docs:generate && npm run docs:generate:search",
     "docs:prepare:publish:5x": "npm run docs:checkout:5x && npm run docs:merge:5x && npm run docs:clean:stable && npm run docs:generate && npm run docs:copy:tmp && npm run docs:checkout:gh-pages && npm run docs:copy:tmp:5x",
     "docs:prepare:publish:6x": "npm run docs:checkout:6x && npm run docs:merge:6x && npm run docs:clean:stable && env DOCS_DEPLOY=true npm run docs:generate && npm run docs:move:6x:tmp && npm run docs:checkout:gh-pages && npm run docs:copy:tmp:6x",
-    "docs:prepare:publish:7x": "git checkout 7.x && npm run docs:clean:stable && env DOCS_DEPLOY=true npm run docs:generate && mv ./docs/7.x ./tmp && npm run docs:checkout:gh-pages && rimraf ./docs/7.x && ncp ./tmp ./docs/7.x",
+    "docs:prepare:publish:7x": "env DOCS_DEPLOY=true npm run docs:generate && npm run docs:checkout:gh-pages && rimraf ./docs/7.x && mv ./tmp ./docs/7.x",
     "docs:check-links": "blc http://127.0.0.1:8089 -ro",
     "lint": "eslint .",
     "lint-js": "eslint . --ext .js --ext .cjs",

package/types/document.d.ts

@@ -108,7 +108,13 @@ declare module 'mongoose' {
     db: Connection;
 
     /** Removes this document from the db. */
-    deleteOne(options?: QueryOptions): Promise<this>;
+    deleteOne(options?: QueryOptions): QueryWithHelpers<
+      mongodb.DeleteResult,
+      this,
+      TQueryHelpers,
+      DocType,
+      'deleteOne'
+    >;
 
     /**
      * Takes a populated field and returns it to its unpopulated state. If called with

package/types/index.d.ts

@@ -336,6 +336,7 @@ declare module 'mongoose' {
     post<T = THydratedDocumentType>(method: MongooseDistinctDocumentMiddleware|MongooseDistinctDocumentMiddleware[], options: SchemaPostOptions & SchemaPostOptions, fn: PostMiddlewareFunction<T, T>): this;
     post<T = THydratedDocumentType>(method: MongooseQueryOrDocumentMiddleware | MongooseQueryOrDocumentMiddleware[] | RegExp, options: SchemaPostOptions & { document: true, query: false }, fn: PostMiddlewareFunction<T, T>): this;
     // this = Query
+    post<T = Query<any, any>>(method: MongooseRawResultQueryMiddleware|MongooseRawResultQueryMiddleware[], fn: PostMiddlewareFunction<T, null | QueryResultType<T> | ModifyResult<QueryResultType<T>>>): this;
     post<T = Query<any, any>>(method: MongooseDefaultQueryMiddleware|MongooseDefaultQueryMiddleware[], fn: PostMiddlewareFunction<T, QueryResultType<T>>): this;
     post<T = Query<any, any>>(method: MongooseDistinctQueryMiddleware|MongooseDistinctQueryMiddleware[], options: SchemaPostOptions, fn: PostMiddlewareFunction<T, QueryResultType<T>>): this;
     post<T = Query<any, any>>(method: MongooseQueryOrDocumentMiddleware | MongooseQueryOrDocumentMiddleware[] | RegExp, options: SchemaPostOptions & { document: false, query: true }, fn: PostMiddlewareFunction<T, QueryResultType<T>>): this;
@@ -633,7 +634,7 @@ declare module 'mongoose' {
    * { age: 30 }
    * ```
    */
-  export type UpdateQuery<T> = _UpdateQuery<T> & AnyObject;
+  export type UpdateQuery<T> = AnyKeys<T> & _UpdateQuery<T> & AnyObject;
 
   /**
    * A more strict form of UpdateQuery that enforces updating only

package/types/inferschematype.d.ts

@@ -13,7 +13,8 @@ import {
   DefaultTypeKey,
   ObjectIdSchemaDefinition,
   IfEquals,
-  DefaultSchemaOptions
+  DefaultSchemaOptions,
+  IsItRecordAndNotAny
 } from 'mongoose';
 
 declare module 'mongoose' {
@@ -176,6 +177,30 @@ TypeKey
  */
 type PathEnumOrString<T extends SchemaTypeOptions<string>['enum']> = T extends ReadonlyArray<infer E> ? E : T extends { values: any } ? PathEnumOrString<T['values']> : string;
 
+type IsSchemaTypeFromBuiltinClass<T> = T extends (typeof String)
+  ? true
+  : T extends (typeof Number)
+    ? true
+    : T extends (typeof Boolean)
+      ? true
+      : T extends (typeof Buffer)
+        ? true
+        : T extends (typeof Schema.Types.ObjectId)
+          ? true
+          : T extends (typeof Schema.Types.UUID)
+            ? true
+            : T extends (typeof Schema.Types.Decimal128)
+              ? true
+              : T extends Types.ObjectId
+                ? true
+                : T extends Types.Decimal128
+                  ? true
+                  : T extends Buffer
+                    ? true
+                    : T extends (typeof Schema.Types.Mixed)
+                      ? true
+                      : IfEquals<T, Schema.Types.ObjectId, true, false>;
+
 /**
  * @summary Resolve path type by returning the corresponding type.
  * @param {PathValueType} PathValueType Document definition path type.
@@ -189,15 +214,21 @@ type ResolvePathType<PathValueType, Options extends SchemaTypeOptions<PathValueT
       IfEquals<Item, never, any[], Item extends Schema ?
         // If Item is a schema, infer its type.
         Types.DocumentArray<InferSchemaType<Item>> :
-        Item extends Record<TypeKey, any>?
+        Item extends Record<TypeKey, any> ?
           Item[TypeKey] extends Function | String ?
             // If Item has a type key that's a string or a callable, it must be a scalar,
             // so we can directly obtain its path type.
             ObtainDocumentPathType<Item, TypeKey>[] :
             // If the type key isn't callable, then this is an array of objects, in which case
             // we need to call ObtainDocumentType to correctly infer its type.
-            ObtainDocumentType<Item, any, { typeKey: TypeKey }>[]:
-          ObtainDocumentPathType<Item, TypeKey>[]
+            ObtainDocumentType<Item, any, { typeKey: TypeKey }>[] :
+          IsSchemaTypeFromBuiltinClass<Item> extends true ?
+            ObtainDocumentPathType<Item, TypeKey>[] :
+            IsItRecordAndNotAny<Item> extends true ?
+              Item extends Record<string, never> ?
+                ObtainDocumentPathType<Item, TypeKey>[] :
+                Types.DocumentArray<ObtainDocumentType<Item, any, { typeKey: TypeKey }>> :
+              ObtainDocumentPathType<Item, TypeKey>[]
       >:
       PathValueType extends ReadonlyArray<infer Item> ?
         IfEquals<Item, never, any[], Item extends Schema ?
@@ -206,7 +237,13 @@ type ResolvePathType<PathValueType, Options extends SchemaTypeOptions<PathValueT
             Item[TypeKey] extends Function | String ?
               ObtainDocumentPathType<Item, TypeKey>[] :
               ObtainDocumentType<Item, any, { typeKey: TypeKey }>[]:
-            ObtainDocumentPathType<Item, TypeKey>[]
+            IsSchemaTypeFromBuiltinClass<Item> extends true ?
+              ObtainDocumentPathType<Item, TypeKey>[] :
+              IsItRecordAndNotAny<Item> extends true ?
+                Item extends Record<string, never> ?
+                  ObtainDocumentPathType<Item, TypeKey>[] :
+                  Types.DocumentArray<ObtainDocumentType<Item, any, { typeKey: TypeKey }>> :
+                ObtainDocumentPathType<Item, TypeKey>[]
         >:
         PathValueType extends StringSchemaDefinition ? PathEnumOrString<Options['enum']> :
           IfEquals<PathValueType, Schema.Types.String> extends true ? PathEnumOrString<Options['enum']> :

package/types/middlewares.d.ts

@@ -5,7 +5,9 @@ declare module 'mongoose' {
   type MongooseDistinctDocumentMiddleware = 'save' | 'init' | 'validate';
   type MongooseDocumentMiddleware = MongooseDistinctDocumentMiddleware | MongooseQueryAndDocumentMiddleware;
 
+  type MongooseRawResultQueryMiddleware = 'findOneAndUpdate' | 'findOneAndReplace' | 'findOneAndDelete';
   type MongooseDistinctQueryMiddleware = 'estimatedDocumentCount' | 'countDocuments' | 'deleteMany' | 'distinct' | 'find' | 'findOne' | 'findOneAndDelete' | 'findOneAndReplace' | 'findOneAndUpdate' | 'replaceOne' | 'updateMany';
+
   type MongooseDefaultQueryMiddleware = MongooseDistinctQueryMiddleware | 'updateOne' | 'deleteOne';
   type MongooseQueryMiddleware = MongooseDistinctQueryMiddleware | MongooseQueryAndDocumentMiddleware;
 

package/types/models.d.ts

@@ -26,6 +26,14 @@ declare module 'mongoose' {
   interface MongooseBulkWriteOptions {
     skipValidation?: boolean;
     throwOnValidationError?: boolean;
+    timestamps?: boolean;
+  }
+
+  interface MongooseBulkWritePerWriteOptions {
+    timestamps?: boolean;
+    strict?: boolean;
+    session?: ClientSession;
+    skipValidation?: boolean;
   }
 
   interface InsertManyOptions extends
@@ -183,11 +191,17 @@ declare module 'mongoose' {
      * round trip to the MongoDB server.
      */
     bulkWrite<DocContents = TRawDocType>(
-      writes: Array<mongodb.AnyBulkWriteOperation<DocContents extends Document ? any : (DocContents extends {} ? DocContents : any)>>,
+      writes: Array<
+        mongodb.AnyBulkWriteOperation<
+          DocContents extends mongodb.Document ? DocContents : any
+        > & MongooseBulkWritePerWriteOptions>,
       options: mongodb.BulkWriteOptions & MongooseBulkWriteOptions & { ordered: false }
     ): Promise<mongodb.BulkWriteResult & { mongoose?: { validationErrors: Error[] } }>;
     bulkWrite<DocContents = TRawDocType>(
-      writes: Array<mongodb.AnyBulkWriteOperation<DocContents extends Document ? any : (DocContents extends {} ? DocContents : any)>>,
+      writes: Array<
+        mongodb.AnyBulkWriteOperation<
+          DocContents extends mongodb.Document ? DocContents : any
+        > & MongooseBulkWritePerWriteOptions>,
       options?: mongodb.BulkWriteOptions & MongooseBulkWriteOptions
     ): Promise<mongodb.BulkWriteResult>;
 
@@ -452,8 +466,9 @@ declare module 'mongoose' {
 
     /** Casts and validates the given object against this model's schema, passing the given `context` to custom validators. */
     validate(): Promise<void>;
-    validate(optional: any): Promise<void>;
-    validate(optional: any, pathsToValidate: PathsToValidate): Promise<void>;
+    validate(obj: any): Promise<void>;
+    validate(obj: any, pathsOrOptions: PathsToValidate): Promise<void>;
+    validate(obj: any, pathsOrOptions: { pathsToSkip?: pathsToSkip }): Promise<void>;
 
     /** Watches the underlying collection for changes using [MongoDB change streams](https://www.mongodb.com/docs/manual/changeStreams/). */
     watch<ResultType extends mongodb.Document = any, ChangeType extends mongodb.ChangeStreamDocument = any>(pipeline?: Array<Record<string, unknown>>, options?: mongodb.ChangeStreamOptions & { hydrate?: boolean }): mongodb.ChangeStream<ResultType, ChangeType>;
@@ -542,21 +557,9 @@ declare module 'mongoose' {
     >;
     findByIdAndDelete<ResultDoc = THydratedDocumentType>(
       id?: mongodb.ObjectId | any,
-      options?: QueryOptions<TRawDocType> | null
-    ): QueryWithHelpers<ResultDoc | null, ResultDoc, TQueryHelpers, TRawDocType, 'findOneAndDelete'>;
-
-    /** Creates a `findByIdAndRemove` query, filtering by the given `_id`. */
-    findByIdAndRemove<ResultDoc = THydratedDocumentType>(
-      id: mongodb.ObjectId | any,
-      options: QueryOptions<TRawDocType> & { lean: true }
-    ): QueryWithHelpers<
-      GetLeanResultType<TRawDocType, TRawDocType, 'findOneAndDelete'> | null,
-      ResultDoc,
-      TQueryHelpers,
-      TRawDocType,
-      'findOneAndDelete'
-    >;
-    findByIdAndRemove<ResultDoc = THydratedDocumentType>(
+      options?: QueryOptions<TRawDocType> & { includeResultMetadata: true }
+    ): QueryWithHelpers<ModifyResult<ResultDoc>, ResultDoc, TQueryHelpers, TRawDocType, 'findOneAndDelete'>;
+    findByIdAndDelete<ResultDoc = THydratedDocumentType>(
       id?: mongodb.ObjectId | any,
       options?: QueryOptions<TRawDocType> | null
     ): QueryWithHelpers<ResultDoc | null, ResultDoc, TQueryHelpers, TRawDocType, 'findOneAndDelete'>;
@@ -578,11 +581,6 @@ declare module 'mongoose' {
       update: UpdateQuery<TRawDocType>,
       options: QueryOptions<TRawDocType> & { includeResultMetadata: true }
     ): QueryWithHelpers<ModifyResult<ResultDoc>, ResultDoc, TQueryHelpers, TRawDocType, 'findOneAndUpdate'>;
-    findByIdAndUpdate<ResultDoc = THydratedDocumentType>(
-      id: mongodb.ObjectId | any,
-      update: UpdateQuery<TRawDocType>,
-      options: QueryOptions<TRawDocType> & { includeResultMetadata: true }
-    ): QueryWithHelpers<ModifyResult<ResultDoc>, ResultDoc, TQueryHelpers, TRawDocType, 'findOneAndUpdate'>;
     findByIdAndUpdate<ResultDoc = THydratedDocumentType>(
       id: mongodb.ObjectId | any,
       update: UpdateQuery<TRawDocType>,
@@ -609,6 +607,10 @@ declare module 'mongoose' {
       TRawDocType,
       'findOneAndDelete'
     >;
+    findOneAndDelete<ResultDoc = THydratedDocumentType>(
+      filter?: FilterQuery<TRawDocType>,
+      options?: QueryOptions<TRawDocType> & { includeResultMetadata: true }
+    ): QueryWithHelpers<ModifyResult<ResultDoc>, ResultDoc, TQueryHelpers, TRawDocType, 'findOneAndDelete'>;
     findOneAndDelete<ResultDoc = THydratedDocumentType>(
       filter?: FilterQuery<TRawDocType>,
       options?: QueryOptions<TRawDocType> | null
@@ -631,11 +633,6 @@ declare module 'mongoose' {
       replacement: TRawDocType | AnyObject,
       options: QueryOptions<TRawDocType> & { includeResultMetadata: true }
     ): QueryWithHelpers<ModifyResult<ResultDoc>, ResultDoc, TQueryHelpers, TRawDocType, 'findOneAndReplace'>;
-    findOneAndReplace<ResultDoc = THydratedDocumentType>(
-      filter: FilterQuery<TRawDocType>,
-      replacement: TRawDocType | AnyObject,
-      options: QueryOptions<TRawDocType> & { includeResultMetadata: true }
-    ): QueryWithHelpers<ModifyResult<ResultDoc>, ResultDoc, TQueryHelpers, TRawDocType, 'findOneAndReplace'>;
     findOneAndReplace<ResultDoc = THydratedDocumentType>(
       filter: FilterQuery<TRawDocType>,
       replacement: TRawDocType | AnyObject,

package/types/query.d.ts

@@ -212,7 +212,7 @@ declare module 'mongoose' {
     allowDiskUse(value: boolean): this;
 
     /** Specifies arguments for an `$and` condition. */
-    and(array: FilterQuery<DocType>[]): this;
+    and(array: FilterQuery<RawDocType>[]): this;
 
     /** Specifies the batchSize option. */
     batchSize(val: number): this;
@@ -261,7 +261,7 @@ declare module 'mongoose' {
 
     /** Specifies this query as a `countDocuments` query. */
     countDocuments(
-      criteria?: FilterQuery<DocType>,
+      criteria?: FilterQuery<RawDocType>,
       options?: QueryOptions<DocType>
     ): QueryWithHelpers<number, DocType, THelpers, RawDocType, 'countDocuments'>;
 
@@ -277,10 +277,10 @@ declare module 'mongoose' {
      * collection, regardless of the value of `single`.
      */
     deleteMany(
-      filter?: FilterQuery<DocType>,
+      filter?: FilterQuery<RawDocType>,
       options?: QueryOptions<DocType>
     ): QueryWithHelpers<any, DocType, THelpers, RawDocType, 'deleteMany'>;
-    deleteMany(filter: FilterQuery<DocType>): QueryWithHelpers<
+    deleteMany(filter: FilterQuery<RawDocType>): QueryWithHelpers<
       any,
       DocType,
       THelpers,
@@ -295,10 +295,10 @@ declare module 'mongoose' {
      * option.
      */
     deleteOne(
-      filter?: FilterQuery<DocType>,
+      filter?: FilterQuery<RawDocType>,
       options?: QueryOptions<DocType>
     ): QueryWithHelpers<any, DocType, THelpers, RawDocType, 'deleteOne'>;
-    deleteOne(filter: FilterQuery<DocType>): QueryWithHelpers<
+    deleteOne(filter: FilterQuery<RawDocType>): QueryWithHelpers<
       any,
       DocType,
       THelpers,
@@ -310,7 +310,7 @@ declare module 'mongoose' {
     /** Creates a `distinct` query: returns the distinct values of the given `field` that match `filter`. */
     distinct<DocKey extends string, ResultType = unknown>(
       field: DocKey,
-      filter?: FilterQuery<DocType>
+      filter?: FilterQuery<RawDocType>
     ): QueryWithHelpers<Array<DocKey extends keyof DocType ? Unpacked<DocType[DocKey]> : ResultType>, DocType, THelpers, RawDocType, 'distinct'>;
 
     /** Specifies a `$elemMatch` query condition. When called with one argument, the most recent path passed to `where()` is used. */
@@ -350,65 +350,65 @@ declare module 'mongoose' {
 
     /** Creates a `find` query: gets a list of documents that match `filter`. */
     find(
-      filter: FilterQuery<DocType>,
-      projection?: ProjectionType<DocType> | null,
+      filter: FilterQuery<RawDocType>,
+      projection?: ProjectionType<RawDocType> | null,
       options?: QueryOptions<DocType> | null
     ): QueryWithHelpers<Array<DocType>, DocType, THelpers, RawDocType, 'find'>;
     find(
-      filter: FilterQuery<DocType>,
-      projection?: ProjectionType<DocType> | null
+      filter: FilterQuery<RawDocType>,
+      projection?: ProjectionType<RawDocType> | null
     ): QueryWithHelpers<Array<DocType>, DocType, THelpers, RawDocType, 'find'>;
     find(
-      filter: FilterQuery<DocType>
-    ): QueryWithHelpers<Array<DocType>, DocType, THelpers, RawDocType, 'find'>;
+      filter: FilterQuery<RawDocType>
+    ): QueryWithHelpers<Array<RawDocType>, DocType, THelpers, RawDocType, 'find'>;
     find(): QueryWithHelpers<Array<DocType>, DocType, THelpers, RawDocType, 'find'>;
 
     /** Declares the query a findOne operation. When executed, returns the first found document. */
     findOne(
-      filter?: FilterQuery<DocType>,
-      projection?: ProjectionType<DocType> | null,
+      filter?: FilterQuery<RawDocType>,
+      projection?: ProjectionType<RawDocType> | null,
       options?: QueryOptions<DocType> | null
     ): QueryWithHelpers<DocType | null, DocType, THelpers, RawDocType, 'findOne'>;
     findOne(
-      filter?: FilterQuery<DocType>,
-      projection?: ProjectionType<DocType> | null
+      filter?: FilterQuery<RawDocType>,
+      projection?: ProjectionType<RawDocType> | null
     ): QueryWithHelpers<DocType | null, DocType, THelpers, RawDocType, 'findOne'>;
     findOne(
-      filter?: FilterQuery<DocType>
-    ): QueryWithHelpers<DocType | null, DocType, THelpers, RawDocType, 'findOne'>;
+      filter?: FilterQuery<RawDocType>
+    ): QueryWithHelpers<DocType | null, RawDocType, THelpers, RawDocType, 'findOne'>;
 
     /** Creates a `findOneAndDelete` query: atomically finds the given document, deletes it, and returns the document as it was before deletion. */
     findOneAndDelete(
-      filter?: FilterQuery<DocType>,
+      filter?: FilterQuery<RawDocType>,
       options?: QueryOptions<DocType> | null
     ): QueryWithHelpers<DocType | null, DocType, THelpers, RawDocType, 'findOneAndDelete'>;
 
     /** Creates a `findOneAndUpdate` query: atomically find the first document that matches `filter` and apply `update`. */
     findOneAndUpdate(
-      filter: FilterQuery<DocType>,
-      update: UpdateQuery<DocType>,
+      filter: FilterQuery<RawDocType>,
+      update: UpdateQuery<RawDocType>,
       options: QueryOptions<DocType> & { includeResultMetadata: true }
     ): QueryWithHelpers<ModifyResult<DocType>, DocType, THelpers, RawDocType, 'findOneAndUpdate'>;
     findOneAndUpdate(
-      filter: FilterQuery<DocType>,
-      update: UpdateQuery<DocType>,
+      filter: FilterQuery<RawDocType>,
+      update: UpdateQuery<RawDocType>,
       options: QueryOptions<DocType> & { upsert: true } & ReturnsNewDoc
     ): QueryWithHelpers<DocType, DocType, THelpers, RawDocType, 'findOneAndUpdate'>;
     findOneAndUpdate(
-      filter?: FilterQuery<DocType>,
-      update?: UpdateQuery<DocType>,
+      filter?: FilterQuery<RawDocType>,
+      update?: UpdateQuery<RawDocType>,
       options?: QueryOptions<DocType> | null
     ): QueryWithHelpers<DocType | null, DocType, THelpers, RawDocType, 'findOneAndUpdate'>;
 
     /** Declares the query a findById operation. When executed, returns the document with the given `_id`. */
     findById(
       id: mongodb.ObjectId | any,
-      projection?: ProjectionType<DocType> | null,
+      projection?: ProjectionType<RawDocType> | null,
       options?: QueryOptions<DocType> | null
     ): QueryWithHelpers<DocType | null, DocType, THelpers, RawDocType, 'findOne'>;
     findById(
       id: mongodb.ObjectId | any,
-      projection?: ProjectionType<DocType> | null
+      projection?: ProjectionType<RawDocType> | null
     ): QueryWithHelpers<DocType | null, DocType, THelpers, RawDocType, 'findOne'>;
     findById(
       id: mongodb.ObjectId | any
@@ -423,22 +423,22 @@ declare module 'mongoose' {
     /** Creates a `findOneAndUpdate` query, filtering by the given `_id`. */
     findByIdAndUpdate(
       id: mongodb.ObjectId | any,
-      update: UpdateQuery<DocType>,
+      update: UpdateQuery<RawDocType>,
       options: QueryOptions<DocType> & { includeResultMetadata: true }
     ): QueryWithHelpers<any, DocType, THelpers, RawDocType, 'findOneAndUpdate'>;
     findByIdAndUpdate(
       id: mongodb.ObjectId | any,
-      update: UpdateQuery<DocType>,
+      update: UpdateQuery<RawDocType>,
       options: QueryOptions<DocType> & { upsert: true } & ReturnsNewDoc
     ): QueryWithHelpers<DocType, DocType, THelpers, RawDocType, 'findOneAndUpdate'>;
     findByIdAndUpdate(
       id?: mongodb.ObjectId | any,
-      update?: UpdateQuery<DocType>,
+      update?: UpdateQuery<RawDocType>,
       options?: QueryOptions<DocType> | null
     ): QueryWithHelpers<DocType | null, DocType, THelpers, RawDocType, 'findOneAndUpdate'>;
     findByIdAndUpdate(
       id: mongodb.ObjectId | any,
-      update: UpdateQuery<DocType>
+      update: UpdateQuery<RawDocType>
     ): QueryWithHelpers<DocType | null, DocType, THelpers, RawDocType, 'findOneAndUpdate'>;
 
     /** Specifies a `$geometry` condition */
@@ -452,7 +452,7 @@ declare module 'mongoose' {
     get(path: string): any;
 
     /** Returns the current query filter (also known as conditions) as a POJO. */
-    getFilter(): FilterQuery<DocType>;
+    getFilter(): FilterQuery<RawDocType>;
 
     /** Gets query options. */
     getOptions(): QueryOptions<DocType>;
@@ -461,7 +461,7 @@ declare module 'mongoose' {
     getPopulatedPaths(): Array<string>;
 
     /** Returns the current query filter. Equivalent to `getFilter()`. */
-    getQuery(): FilterQuery<DocType>;
+    getQuery(): FilterQuery<RawDocType>;
 
     /** Returns the current update operations as a JSON object. */
     getUpdate(): UpdateQuery<DocType> | UpdateWithAggregationPipeline | null;
@@ -531,7 +531,7 @@ declare module 'mongoose' {
     maxTimeMS(ms: number): this;
 
     /** Merges another Query or conditions object into this one. */
-    merge(source: Query<any, any> | FilterQuery<DocType>): this;
+    merge(source: Query<any, any> | FilterQuery<RawDocType>): this;
 
     /** Specifies a `$mod` condition, filters documents for documents whose `path` property is a number that is equal to `remainder` modulo `divisor`. */
     mod<K = string>(path: K, val: number): this;
@@ -559,10 +559,10 @@ declare module 'mongoose' {
     nin(val: Array<any>): this;
 
     /** Specifies arguments for an `$nor` condition. */
-    nor(array: Array<FilterQuery<DocType>>): this;
+    nor(array: Array<FilterQuery<RawDocType>>): this;
 
     /** Specifies arguments for an `$or` condition. */
-    or(array: Array<FilterQuery<DocType>>): this;
+    or(array: Array<FilterQuery<RawDocType>>): this;
 
     /**
      * Make this query throw an error if no documents match the given `filter`.
@@ -619,7 +619,7 @@ declare module 'mongoose' {
      * not accept any [atomic](https://www.mongodb.com/docs/manual/tutorial/model-data-for-atomic-operations/#pattern) operators (`$set`, etc.)
      */
     replaceOne(
-      filter?: FilterQuery<DocType>,
+      filter?: FilterQuery<RawDocType>,
       replacement?: DocType | AnyObject,
       options?: QueryOptions<DocType> | null
     ): QueryWithHelpers<any, DocType, THelpers, RawDocType, 'replaceOne'>;
@@ -678,9 +678,9 @@ declare module 'mongoose' {
     setOptions(options: QueryOptions<DocType>, overwrite?: boolean): this;
 
     /** Sets the query conditions to the provided JSON object. */
-    setQuery(val: FilterQuery<DocType> | null): void;
+    setQuery(val: FilterQuery<RawDocType> | null): void;
 
-    setUpdate(update: UpdateQuery<DocType> | UpdateWithAggregationPipeline): void;
+    setUpdate(update: UpdateQuery<RawDocType> | UpdateWithAggregationPipeline): void;
 
     /** Specifies an `$size` query condition. When called with one argument, the most recent path passed to `where()` is used. */
     size<K = string>(path: K, val: number): this;
@@ -718,8 +718,8 @@ declare module 'mongoose' {
      * the `multi` option.
      */
     updateMany(
-      filter?: FilterQuery<DocType>,
-      update?: UpdateQuery<DocType> | UpdateWithAggregationPipeline,
+      filter?: FilterQuery<RawDocType>,
+      update?: UpdateQuery<RawDocType> | UpdateWithAggregationPipeline,
       options?: QueryOptions<DocType> | null
     ): QueryWithHelpers<UpdateWriteOpResult, DocType, THelpers, RawDocType, 'updateMany'>;
 
@@ -728,8 +728,8 @@ declare module 'mongoose' {
      * `update()`, except it does not support the `multi` or `overwrite` options.
      */
     updateOne(
-      filter?: FilterQuery<DocType>,
-      update?: UpdateQuery<DocType> | UpdateWithAggregationPipeline,
+      filter?: FilterQuery<RawDocType>,
+      update?: UpdateQuery<RawDocType> | UpdateWithAggregationPipeline,
       options?: QueryOptions<DocType> | null
     ): QueryWithHelpers<UpdateWriteOpResult, DocType, THelpers, RawDocType, 'updateOne'>;