mongoose 6.2.10 → 6.3.1

package/lib/schema.js

@@ -22,6 +22,7 @@ const readPref = require('./driver').get().ReadPreference;
 const setupTimestamps = require('./helpers/timestamps/setupTimestamps');
 const utils = require('./utils');
 const validateRef = require('./helpers/populate/validateRef');
+const util = require('util');
 
 let MongooseTypes;
 
@@ -53,7 +54,7 @@ let id = 0;
  * - [autoCreate](/docs/guide.html#autoCreate): bool - defaults to null (which means use the connection's autoCreate option)
  * - [bufferCommands](/docs/guide.html#bufferCommands): bool - defaults to true
  * - [bufferTimeoutMS](/docs/guide.html#bufferTimeoutMS): number - defaults to 10000 (10 seconds). If `bufferCommands` is enabled, the amount of time Mongoose will wait for connectivity to be restablished before erroring out.
- * - [capped](/docs/guide.html#capped): bool - defaults to false
+ * - [capped](/docs/guide.html#capped): bool | number | object - defaults to false
  * - [collection](/docs/guide.html#collection): string - no default
  * - [discriminatorKey](/docs/guide.html#discriminatorKey): string - defaults to `__t`
  * - [id](/docs/guide.html#id): bool - defaults to true
@@ -370,6 +371,9 @@ Schema.prototype._clone = function _clone(Constructor) {
   if (this.discriminators != null) {
     s.discriminators = Object.assign({}, this.discriminators);
   }
+  if (this._applyDiscriminators != null) {
+    s._applyDiscriminators = Object.assign({}, this._applyDiscriminators);
+  }
 
   s.aliases = Object.assign({}, this.aliases);
 
@@ -469,6 +473,11 @@ Schema.prototype.defaultOptions = function(options) {
   return options;
 };
 
+Schema.prototype.discriminator = function(name, schema) {
+  this._applyDiscriminators = {};
+  this._applyDiscriminators[name] = schema;
+};
+
 /**
  * Adds key path / schema type pairs to this schema.
  *
@@ -510,7 +519,6 @@ Schema.prototype.add = function add(obj, prefix) {
 
   const keys = Object.keys(obj);
   const typeKey = this.options.typeKey;
-
   for (const key of keys) {
     const fullPath = prefix + key;
     const val = obj[key];
@@ -540,6 +548,25 @@ Schema.prototype.add = function add(obj, prefix) {
         this.nested[prefix.substring(0, prefix.length - 1)] = true;
       }
       this.path(prefix + key, val);
+      if (val[0] != null && !(val[0].instanceOfSchema) && utils.isPOJO(val[0].discriminators)) {
+        const schemaType = this.path(prefix + key);
+        for (const key in val[0].discriminators) {
+          schemaType.discriminator(key, val[0].discriminators[key]);
+        }
+      } else if (val[0] != null && val[0].instanceOfSchema && utils.isPOJO(val[0]._applyDiscriminators)) {
+        const applyDiscriminators = val[0]._applyDiscriminators || [];
+        const schemaType = this.path(prefix + key);
+        for (const disc in applyDiscriminators) {
+          schemaType.discriminator(disc, applyDiscriminators[disc]);
+        }
+      }
+      else if (val != null && val.instanceOfSchema && utils.isPOJO(val._applyDiscriminators)) {
+        const applyDiscriminators = val._applyDiscriminators || [];
+        const schemaType = this.path(prefix + key);
+        for (const disc in applyDiscriminators) {
+          schemaType.discriminator(disc, applyDiscriminators[disc]);
+        }
+      }
     } else if (Object.keys(val).length < 1) {
       // Special-case: {} always interpreted as Mixed path so leaf at this node
       if (prefix) {
@@ -569,6 +596,12 @@ Schema.prototype.add = function add(obj, prefix) {
           this.nested[prefix.substring(0, prefix.length - 1)] = true;
         }
         this.path(prefix + key, val);
+        if (val != null && !(val.instanceOfSchema) && utils.isPOJO(val.discriminators)) {
+          const schemaType = this.path(prefix + key);
+          for (const key in val.discriminators) {
+            schemaType.discriminator(key, val.discriminators[key]);
+          }
+        }
       }
     }
   }
@@ -579,6 +612,86 @@ Schema.prototype.add = function add(obj, prefix) {
   return this;
 };
 
+/**
+ * Remove an index by name or index specification.
+ *
+ * removeIndex only removes indexes from your schema object. Does **not** affect the indexes
+ * in MongoDB.
+ *
+ * ####Example:
+ *
+ *     const ToySchema = new Schema({ name: String, color: String, price: Number });
+ *
+ *     // Add a new index on { name, color }
+ *     ToySchema.index({ name: 1, color: 1 });
+ *
+ *     // Remove index on { name, color }
+ *     // Keep in mind that order matters! `removeIndex({ color: 1, name: 1 })` won't remove the index
+ *     ToySchema.removeIndex({ name: 1, color: 1 });
+ *
+ *     // Add an index with a custom name
+ *     ToySchema.index({ color: 1 }, { name: 'my custom index name' });
+ *     // Remove index by name
+ *     ToySchema.removeIndex('my custom index name');
+ *
+ * @param {Object|string} index name or index specification
+ * @return {Schema} the Schema instance
+ * @api public
+ */
+
+Schema.prototype.removeIndex = function removeIndex(index) {
+  if (arguments.length > 1) {
+    throw new Error('removeIndex() takes only 1 argument');
+  }
+
+  if (typeof index !== 'object' && typeof index !== 'string') {
+    throw new Error('removeIndex() may only take either an object or a string as an argument');
+  }
+
+  if (typeof index === 'object') {
+    for (let i = this._indexes.length - 1; i >= 0; --i) {
+      if (util.isDeepStrictEqual(this._indexes[i][0], index)) {
+        this._indexes.splice(i, 1);
+      }
+    }
+  } else {
+    for (let i = this._indexes.length - 1; i >= 0; --i) {
+      if (this._indexes[i][1] != null && this._indexes[i][1].name === index) {
+        this._indexes.splice(i, 1);
+      }
+    }
+  }
+
+  return this;
+};
+
+/**
+ * Remove all indexes from this schema.
+ *
+ * clearIndexes only removes indexes from your schema object. Does **not** affect the indexes
+ * in MongoDB.
+ *
+ * ####Example:
+ *
+ *     const ToySchema = new Schema({ name: String, color: String, price: Number });
+ *     ToySchema.index({ name: 1 });
+ *     ToySchema.index({ color: 1 });
+ *
+ *     // Remove all indexes on this schema
+ *     ToySchema.clearIndexes();
+ *
+ *     ToySchema.indexes(); // []
+ *
+ * @return {Schema} the Schema instance
+ * @api public
+ */
+
+Schema.prototype.clearIndexes = function clearIndexes() {
+  this._indexes.length = 0;
+
+  return this;
+};
+
 /**
  * Reserved document keys.
  *
@@ -1010,6 +1123,7 @@ Schema.prototype.interpretAsType = function(path, obj, options) {
         if (options.hasOwnProperty('strict')) {
           childSchemaOptions.strict = options.strict;
         }
+
         if (this._userProvidedOptions.hasOwnProperty('_id')) {
           childSchemaOptions._id = this._userProvidedOptions._id;
         } else if (Schema.Types.DocumentArray.defaultOptions._id != null) {
@@ -1466,7 +1580,7 @@ Schema.prototype.pre = function(name) {
  *     });
  *
  *     schema.post(/Many$/, function(res) {
- *       console.log('this fired after you ran `updateMany()` or `deleteMany()`);
+ *       console.log('this fired after you ran `updateMany()` or `deleteMany()`');
  *     });
  *
  *     const Model = mongoose.model('Model', schema);

package/lib/schematype.js

@@ -1128,7 +1128,6 @@ SchemaType.prototype.getDefault = function(scope, init) {
     ret = this.defaultValue;
   }
 
-
   if (ret !== null && ret !== undefined) {
     if (typeof ret === 'object' && (!this.options || !this.options.shared)) {
       ret = utils.clone(ret);
@@ -1149,7 +1148,7 @@ SchemaType.prototype.getDefault = function(scope, init) {
  * @api private
  */
 
-SchemaType.prototype._applySetters = function(value, scope, init, priorVal) {
+SchemaType.prototype._applySetters = function(value, scope, init, priorVal, options) {
   let v = value;
   if (init) {
     return v;
@@ -1157,7 +1156,7 @@ SchemaType.prototype._applySetters = function(value, scope, init, priorVal) {
   const setters = this.setters;
 
   for (let i = setters.length - 1; i >= 0; i--) {
-    v = setters[i].call(scope, v, priorVal, this);
+    v = setters[i].call(scope, v, priorVal, this, options);
   }
 
   return v;

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

@@ -311,8 +311,8 @@ const methods = {
       return this;
     }
     const value = methods._cast.call(this, val, i);
-    arr[i] = value;
     methods._markModified.call(this, i);
+    arr[i] = value;
     return this;
   },
 

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

@@ -149,7 +149,7 @@ const methods = {
    *
    * #### NOTE:
    *
-   * _Calling this mulitple times on an array before saving sends the same command as calling it once._
+   * _Calling this multiple times on an array before saving sends the same command as calling it once._
    * _This update is implemented using the MongoDB [$pop](https://www.mongodb.org/display/DOCS/Updating/#Updating-%24pop) method which enforces this restriction._
    *
    *      doc.array = [1,2,3];
@@ -414,9 +414,9 @@ const methods = {
       }
 
       if (!found) {
+        this._markModified();
         rawArray.push(v);
         this._registerAtomic('$addToSet', v);
-        this._markModified();
         [].push.call(added, v);
       }
     }, this);
@@ -510,9 +510,9 @@ const methods = {
 
   nonAtomicPush() {
     const values = [].map.call(arguments, this._mapCast, this);
+    this._markModified();
     const ret = [].push.apply(this, values);
     this._registerAtomic('$set', this);
-    this._markModified();
     return ret;
   },
 
@@ -530,9 +530,9 @@ const methods = {
    */
 
   pop() {
+    this._markModified();
     const ret = [].pop.call(this);
     this._registerAtomic('$set', this);
-    this._markModified();
     return ret;
   },
 
@@ -572,6 +572,7 @@ const methods = {
     const cur = this[arrayParentSymbol].get(this[arrayPathSymbol]);
     let i = cur.length;
     let mem;
+    this._markModified();
 
     while (i--) {
       mem = cur[i];
@@ -595,7 +596,6 @@ const methods = {
       this._registerAtomic('$pullAll', values);
     }
 
-    this._markModified();
 
     // Might have modified child paths and then pulled, like
     // `doc.children[1].name = 'test';` followed by
@@ -657,7 +657,7 @@ const methods = {
       undefined, { skipDocumentArrayCast: true });
     let ret;
     const atomics = this[arrayAtomicsSymbol];
-
+    this._markModified();
     if (isOverwrite) {
       atomic.$each = values;
 
@@ -684,7 +684,6 @@ const methods = {
     }
 
     this._registerAtomic('$push', atomic);
-    this._markModified();
     return ret;
   },
 
@@ -737,8 +736,8 @@ const methods = {
       return this;
     }
     const value = methods._cast.call(this, val, i);
-    arr[i] = value;
     methods._markModified.call(this, i);
+    arr[i] = value;
     return this;
   },
 
@@ -763,9 +762,9 @@ const methods = {
 
   shift() {
     const arr = utils.isMongooseArray(this) ? this.__array : this;
+    this._markModified();
     const ret = [].shift.call(arr);
     this._registerAtomic('$set', this);
-    this._markModified();
     return ret;
   },
 
@@ -890,9 +889,9 @@ const methods = {
     }
 
     const arr = utils.isMongooseArray(this) ? this.__array : this;
+    this._markModified();
     [].unshift.apply(arr, values);
     this._registerAtomic('$set', this);
-    this._markModified();
     return this.length;
   }
 };

package/lib/types/subdocument.js

@@ -269,6 +269,35 @@ Subdocument.prototype.ownerDocument = function() {
   return this.$__.ownerDocument;
 };
 
+/*!
+ * ignore
+ */
+
+Subdocument.prototype.$__fullPathWithIndexes = function() {
+  let parent = this; // eslint-disable-line consistent-this
+  const paths = [];
+  const seenDocs = new Set([parent]);
+
+  while (true) {
+    if (typeof parent.$__pathRelativeToParent !== 'function') {
+      break;
+    }
+    paths.unshift(parent.$__pathRelativeToParent(void 0, false));
+    const _parent = parent.$parent();
+    if (_parent == null) {
+      break;
+    }
+    parent = _parent;
+    if (seenDocs.has(parent)) {
+      throw new Error('Infinite subdocument loop: subdoc with _id ' + parent._id + ' is a parent of itself');
+    }
+
+    seenDocs.add(parent);
+  }
+
+  return paths.join('.');
+};
+
 /**
  * Returns this sub-documents parent document.
  *

package/lib/validoptions.js

@@ -6,6 +6,7 @@
 'use strict';
 
 const VALID_OPTIONS = Object.freeze([
+  'allowDiskUse',
   'applyPluginsToChildSchemas',
   'applyPluginsToDiscriminators',
   'autoCreate',

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "mongoose",
   "description": "Mongoose MongoDB ODM",
-  "version": "6.2.10",
+  "version": "6.3.1",
   "author": "Guillermo Rauch <guillermo@learnboost.com>",
   "keywords": [
     "mongodb",
@@ -19,9 +19,9 @@
   ],
   "license": "MIT",
   "dependencies": {
-    "bson": "^4.2.2",
+    "bson": "^4.6.2",
     "kareem": "2.3.5",
-    "mongodb": "4.3.1",
+    "mongodb": "4.5.0",
     "mpath": "0.8.4",
     "mquery": "4.0.2",
     "ms": "2.1.3",
@@ -35,11 +35,13 @@
     "acquit": "1.2.1",
     "acquit-ignore": "0.2.0",
     "acquit-require": "0.1.1",
+    "assert-browserify": "npm:assert@^2.0.0",
     "axios": "0.26.1",
     "babel-loader": "8.2.4",
     "benchmark": "2.1.4",
     "bluebird": "3.7.2",
     "cheerio": "1.0.0-rc.10",
+    "crypto-browserify": "3.12.0",
     "dox": "0.3.1",
     "eslint": "8.12.0",
     "eslint-plugin-mocha-no-only": "1.1.1",
@@ -49,21 +51,25 @@
     "marked": "4.0.12",
     "mocha": "9.2.2",
     "moment": "2.x",
-    "mongodb-memory-server": "^8.3.0",
-    "nyc": "^15.1.0",
+    "mongodb-memory-server": "8.3.0",
+    "nyc": "15.1.0",
     "pug": "3.0.2",
     "q": "1.5.1",
     "serve-handler": "6.1.3",
-    "tsd": "0.20.0",
+    "sinon": "13.0.0",
+    "stream-browserify": "3.0.0",
+    "tsd": "0.19.1",
     "typescript": "4.6.3",
     "uuid": "8.3.2",
-    "webpack": "4.44.1"
+    "webpack": "5.70.0"
   },
   "directories": {
     "lib": "./lib/mongoose"
   },
   "scripts": {
     "lint": "eslint .",
+    "lint-js": "eslint . --ext .js",
+    "lint-ts": "eslint . --ext .ts",
     "build-browser": "node build-browser.js",
     "prepublishOnly": "npm run build-browser",
     "release": "git pull && git push origin master --tags && npm publish",

package/tools/repl.js

@@ -17,7 +17,8 @@ async function run() {
       // Set the expiry job in MongoDB to run every second
       {
         port: 27017,
-        args: ['--setParameter', 'ttlMonitorSleepSecs=1'] }
+        args: ['--setParameter', 'ttlMonitorSleepSecs=1']
+      }
     ],
     dbName: 'mongoose_test',
     replSet: {

package/tsconfig.json

@@ -1,8 +1,9 @@
 {
   "compilerOptions": {
+    "strictNullChecks": true,
     "paths": {
       "mongoose" : ["./types/index.d.ts"]
     }
   },
-  "strictNullChecks": true
+  "include": ["types/*"]
 }

package/types/aggregate.d.ts

@@ -0,0 +1,223 @@
+import mongodb = require('mongodb');
+
+declare module 'mongoose' {
+
+  interface AggregateOptions {
+    /**
+     * If true, the MongoDB server will use the hard drive to store data during this aggregation.
+     */
+    allowDiskUse?: boolean;
+    /**
+     * Applicable only if you specify the $out or $merge aggregation stages.
+     *
+     * Enables db.collection.aggregate() to bypass document validation during the operation. This lets you insert documents that do not meet the validation requirements.
+     */
+    bypassDocumentValidation?: boolean;
+    /**
+     * The BSON-serializer will check if keys are valid
+     */
+    collation?: mongodb.CollationOptions;
+    /**
+     * Users can specify an arbitrary string to help trace the operation through the database profiler, currentOp, and logs.
+     */
+    comment?: string;
+    /**
+     *  Specifies the initial batch size for the cursor. The value of the cursor field is a document with the field batchSize.
+     */
+    cursor?: { batchSize?: number; };
+    /**
+     * Specifies to return the information on the processing of the pipeline. See Return Information on Aggregation Pipeline Operation for an example.
+     *
+     * Not available in multi-document transactions.
+     */
+    explain?: mongodb.ExplainVerbosityLike;
+    /**
+     * The index to use for the aggregation. The index is on the initial collection/view against which the aggregation is run.
+     */
+    hint?: string | AnyObject;
+    /**
+     * Specifies a document with a list of variables. This allows you to improve command readability by separating the variables from the query text.
+     */
+    let?: AnyObject;
+    /**
+     * Specifies a time limit in milliseconds for processing operations on a cursor. If you do not specify a value for maxTimeMS, operations will not time out. A value of 0 explicitly specifies the default unbounded behavior.
+     *
+     * @see https://docs.mongodb.com/manual/reference/operator/meta/maxTimeMS/
+     */
+    maxTimeMS?: number;
+    /**
+     * Return BSON filled buffers from operations.
+     */
+    raw?: boolean;
+    /**
+     * Specifies the read concern.
+     */
+    readConcern?: mongodb.ReadConcernLike;
+    /**
+     * The preferred read preference.
+     */
+    readPreference?: mongodb.ReadPreferenceLike;
+    /** The ClientSession for this aggregation */
+    session?: mongodb.ClientSession;
+    /**
+     * Specifies the write concern.
+     */
+    writeConcern?: mongodb.WriteConcern;
+    [key: string]: 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
+     * You do not need to call this function explicitly, the JavaScript runtime
+     * will call it for you.
+     */
+    [Symbol.asyncIterator](): AsyncIterableIterator<Unpacked<R>>;
+
+    options: AggregateOptions;
+
+    /**
+     * Sets an option on this aggregation. This function will be deprecated in a
+     * future release.
+     *
+     * @deprecated
+     */
+    addCursorFlag(flag: CursorFlag, value: boolean): this;
+
+    /**
+     * Appends a new $addFields operator to this aggregate pipeline.
+     * Requires MongoDB v3.4+ to work
+     */
+    addFields(arg: PipelineStage.AddFields['$addFields']): this;
+
+    /** Sets the allowDiskUse option for the aggregation query (ignored for < 2.6.0) */
+    allowDiskUse(value: boolean): this;
+
+    /** Appends new operators to this aggregate pipeline */
+    append(...args: PipelineStage[]): this;
+
+    /**
+     * Executes the query returning a `Promise` which will be
+     * resolved with either the doc(s) or rejected with the error.
+     * Like [`.then()`](#query_Query-then), but only takes a rejection handler.
+     */
+    catch: Promise<R>['catch'];
+
+    /** Set the collation. */
+    collation(options: mongodb.CollationOptions): this;
+
+    /** Appends a new $count operator to this aggregate pipeline. */
+    count(fieldName: PipelineStage.Count['$count']): this;
+
+    /**
+     * Sets the cursor option for the aggregation query (ignored for < 2.6.0).
+     */
+    cursor<DocType = any>(options?: Record<string, unknown>): Cursor<DocType>;
+
+    /** Executes the aggregate pipeline on the currently bound Model. */
+    exec(callback: Callback<R>): void;
+    exec(): Promise<R>;
+
+    /** Execute the aggregation with explain */
+    explain(verbosity: mongodb.ExplainVerbosityLike, callback: Callback<AnyObject>): void;
+    explain(verbosity: mongodb.ExplainVerbosityLike): Promise<AnyObject>;
+    explain(callback: Callback<AnyObject>): void;
+    explain(): Promise<AnyObject>;
+
+    /** Combines multiple aggregation pipelines. */
+    facet(options: PipelineStage.Facet['$facet']): this;
+
+    /** Appends new custom $graphLookup operator(s) to this aggregate pipeline, performing a recursive search on a collection. */
+    graphLookup(options: PipelineStage.GraphLookup['$graphLookup']): this;
+
+    /** Appends new custom $group operator to this aggregate pipeline. */
+    group(arg: PipelineStage.Group['$group']): this;
+
+    /** Sets the hint option for the aggregation query (ignored for < 3.6.0) */
+    hint(value: Record<string, unknown> | string): this;
+
+    /**
+     * Appends a new $limit operator to this aggregate pipeline.
+     * @param num maximum number of records to pass to the next stage
+     */
+    limit(num: PipelineStage.Limit['$limit']): this;
+
+    /** Appends new custom $lookup operator to this aggregate pipeline. */
+    lookup(options: PipelineStage.Lookup['$lookup']): this;
+
+    /**
+     * Appends a new custom $match operator to this aggregate pipeline.
+     * @param arg $match operator contents
+     */
+    match(arg: PipelineStage.Match['$match']): this;
+
+    /**
+     * Binds this aggregate to a model.
+     * @param model the model to which the aggregate is to be bound
+     */
+    model(model: Model<any>): this;
+
+    /**
+     * Append a new $near operator to this aggregation pipeline
+     * @param arg $near operator contents
+     */
+    near(arg: { near?: number[]; distanceField: string; maxDistance?: number; query?: Record<string, any>; includeLocs?: string; num?: number; uniqueDocs?: boolean }): this;
+
+    /** Returns the current pipeline */
+    pipeline(): PipelineStage[];
+
+    /** Appends a new $project operator to this aggregate pipeline. */
+    project(arg: PipelineStage.Project['$project']): this;
+
+    /** Sets the readPreference option for the aggregation query. */
+    read(pref: mongodb.ReadPreferenceLike): this;
+
+    /** Sets the readConcern level for the aggregation query. */
+    readConcern(level: string): this;
+
+    /** Appends a new $redact operator to this aggregate pipeline. */
+    redact(expression: PipelineStage.Redact['$redact'], thenExpr: '$$DESCEND' | '$$PRUNE' | '$$KEEP' | AnyObject, elseExpr: '$$DESCEND' | '$$PRUNE' | '$$KEEP' | AnyObject): this;
+
+    /** Appends a new $replaceRoot operator to this aggregate pipeline. */
+    replaceRoot(newRoot: PipelineStage.ReplaceRoot['$replaceRoot']['newRoot'] | string): this;
+
+    /**
+     * Helper for [Atlas Text Search](https://docs.atlas.mongodb.com/reference/atlas-search/tutorial/)'s
+     * `$search` stage.
+     */
+    search(options: PipelineStage.Search['$search']): this;
+
+    /** Lets you set arbitrary options, for middlewares or plugins. */
+    option(value: AggregateOptions): this;
+
+    /** Appends new custom $sample operator to this aggregate pipeline. */
+    sample(arg: PipelineStage.Sample['$sample']['size']): this;
+
+    /** Sets the session for this aggregation. Useful for [transactions](/docs/transactions.html). */
+    session(session: mongodb.ClientSession | null): this;
+
+    /**
+     * Appends a new $skip operator to this aggregate pipeline.
+     * @param num number of records to skip before next stage
+     */
+    skip(num: PipelineStage.Skip['$skip']): this;
+
+    /** Appends a new $sort operator to this aggregate pipeline. */
+    sort(arg: string | Record<string, SortValues> | PipelineStage.Sort['$sort']): this;
+
+    /** Provides promise for aggregate. */
+    then: Promise<R>['then'];
+
+    /**
+     * Appends a new $sortByCount operator to this aggregate pipeline. Accepts either a string field name
+     * or a pipeline object.
+     */
+    sortByCount(arg: string | PipelineStage.SortByCount['$sortByCount']): this;
+
+    /** Appends new $unionWith operator to this aggregate pipeline. */
+    unionWith(options: PipelineStage.UnionWith['$unionWith']): this;
+
+    /** Appends new custom $unwind operator(s) to this aggregate pipeline. */
+    unwind(...args: PipelineStage.Unwind['$unwind'][]): this;
+  }
+}