mongodb 6.10.0 → 6.11.0-dev.20241128.sha.4842cd8a

package/mongodb.d.ts

@@ -43,6 +43,7 @@ export declare abstract class AbstractCursor<TSchema = any, CursorEvents extends
     /* Excluded from this release type: isClosed */
     /* Excluded from this release type: isKilled */
     /* Excluded from this release type: cursorOptions */
+    /* Excluded from this release type: timeoutContext */
     /** @event */
     static readonly CLOSE: "close";
     /* Excluded from this release type: deserializationOptions */
@@ -100,7 +101,9 @@ export declare abstract class AbstractCursor<TSchema = any, CursorEvents extends
     /**
      * Frees any client-side resources used by the cursor.
      */
-    close(): Promise<void>;
+    close(options?: {
+        timeoutMS?: number;
+    }): Promise<void>;
     /**
      * Returns an array of documents. The caller is responsible for making sure that there
      * is enough memory to store the results. Note that the array only contains partial
@@ -251,7 +254,39 @@ export declare interface AbstractCursorOptions extends BSONSerializeOptions {
      */
     awaitData?: boolean;
     noCursorTimeout?: boolean;
-    /* Excluded from this release type: timeoutMS */
+    /** Specifies the time an operation will run until it throws a timeout error. See {@link AbstractCursorOptions.timeoutMode} for more details on how this option applies to cursors. */
+    timeoutMS?: number;
+    /**
+     * @public
+     * @experimental
+     * Specifies how `timeoutMS` is applied to the cursor. Can be either `'cursorLifeTime'` or `'iteration'`
+     * When set to `'iteration'`, the deadline specified by `timeoutMS` applies to each call of
+     * `cursor.next()`.
+     * When set to `'cursorLifetime'`, the deadline applies to the life of the entire cursor.
+     *
+     * Depending on the type of cursor being used, this option has different default values.
+     * For non-tailable cursors, this value defaults to `'cursorLifetime'`
+     * For tailable cursors, this value defaults to `'iteration'` since tailable cursors, by
+     * definition can have an arbitrarily long lifetime.
+     *
+     * @example
+     * ```ts
+     * const cursor = collection.find({}, {timeoutMS: 100, timeoutMode: 'iteration'});
+     * for await (const doc of cursor) {
+     *  // process doc
+     *  // This will throw a timeout error if any of the iterator's `next()` calls takes more than 100ms, but
+     *  // will continue to iterate successfully otherwise, regardless of the number of batches.
+     * }
+     * ```
+     *
+     * @example
+     * ```ts
+     * const cursor = collection.find({}, { timeoutMS: 1000, timeoutMode: 'cursorLifetime' });
+     * const docs = await cursor.toArray(); // This entire line will throw a timeout error if all batches are not fetched and returned within 1000ms.
+     * ```
+     */
+    timeoutMode?: CursorTimeoutMode;
+    /* Excluded from this release type: timeoutContext */
 }
 
 /* Excluded from this release type: AbstractOperation */
@@ -377,7 +412,9 @@ export declare interface AggregateOptions extends Omit<CommandOperationOptions,
     bypassDocumentValidation?: boolean;
     /** Return the query as cursor, on 2.6 \> it returns as a real cursor on pre 2.6 it returns as an emulated cursor. */
     cursor?: Document;
-    /** specifies a cumulative time limit in milliseconds for processing operations on the cursor. MongoDB interrupts the operation at the earliest following interrupt point. */
+    /**
+     * Specifies a cumulative time limit in milliseconds for processing operations on the cursor. MongoDB interrupts the operation at the earliest following interrupt point.
+     */
     maxTimeMS?: number;
     /** The maximum amount of time for the server to wait on new documents to satisfy a tailable cursor query. */
     maxAwaitTimeMS?: number;
@@ -394,6 +431,7 @@ export declare interface AggregateOptions extends Omit<CommandOperationOptions,
      * or `db.aggregate().explain()`.
      */
     explain?: ExplainOptions['explain'];
+    /* Excluded from this release type: timeoutMode */
 }
 
 /**
@@ -403,7 +441,7 @@ export declare interface AggregateOptions extends Omit<CommandOperationOptions,
  * or higher stream
  * @public
  */
-export declare class AggregationCursor<TSchema = any> extends AbstractCursor<TSchema> {
+export declare class AggregationCursor<TSchema = any> extends ExplainableCursor<TSchema> {
     readonly pipeline: Document[];
     /* Excluded from this release type: aggregateOptions */
     /* Excluded from this release type: __constructor */
@@ -411,7 +449,14 @@ export declare class AggregationCursor<TSchema = any> extends AbstractCursor<TSc
     map<T>(transform: (doc: TSchema) => T): AggregationCursor<T>;
     /* Excluded from this release type: _initialize */
     /** Execute the explain for the cursor */
-    explain(verbosity?: ExplainVerbosityLike | ExplainCommandOptions): Promise<Document>;
+    explain(): Promise<Document>;
+    explain(verbosity: ExplainVerbosityLike | ExplainCommandOptions): Promise<Document>;
+    explain(options: {
+        timeoutMS?: number;
+    }): Promise<Document>;
+    explain(verbosity: ExplainVerbosityLike | ExplainCommandOptions, options: {
+        timeoutMS?: number;
+    }): Promise<Document>;
     /** Add a stage to the aggregation pipeline
      * @example
      * ```
@@ -588,7 +633,7 @@ export declare interface AuthMechanismProperties extends Document {
     /** A user provided OIDC human interacted callback function. */
     OIDC_HUMAN_CALLBACK?: OIDCCallbackFunction;
     /** The OIDC environment. Note that 'test' is for internal use only. */
-    ENVIRONMENT?: 'test' | 'azure' | 'gcp';
+    ENVIRONMENT?: 'test' | 'azure' | 'gcp' | 'k8s';
     /** Allowed hosts that OIDC auth can connect to. */
     ALLOWED_HOSTS?: string[];
     /** The resource token for OIDC auth in Azure and GCP. */
@@ -973,6 +1018,7 @@ export declare interface BulkWriteOptions extends CommandOperationOptions {
     forceServerObjectId?: boolean;
     /** Map of parameter names and values that can be accessed using $$var (requires MongoDB 5.0). */
     let?: Document;
+    /* Excluded from this release type: timeoutContext */
 }
 
 /**
@@ -1084,6 +1130,13 @@ export declare class ChangeStream<TSchema extends Document = Document, TChange e
      * @event
      */
     static readonly RESUME_TOKEN_CHANGED: "resumeTokenChanged";
+    private timeoutContext?;
+    /**
+     * Note that this property is here to uniquely identify a ChangeStream instance as the owner of
+     * the {@link CursorTimeoutContext} instance (see {@link ChangeStream._createChangeStreamCursor}) to ensure
+     * that {@link AbstractCursor.close} does not mutate the timeoutContext.
+     */
+    private contextOwner;
     /* Excluded from this release type: __constructor */
     /* Excluded from this release type: cursorStream */
     /** The cached resume token that is used to resume after the most recently returned change. */
@@ -1121,6 +1174,7 @@ export declare class ChangeStream<TSchema extends Document = Document, TChange e
     /* Excluded from this release type: _processChange */
     /* Excluded from this release type: _processErrorStreamMode */
     /* Excluded from this release type: _processErrorIteratorMode */
+    private _resume;
 }
 
 /**
@@ -1296,7 +1350,14 @@ export declare type ChangeStreamEvents<TSchema extends Document = Document, TCha
     end(): void;
     error(error: Error): void;
     change(change: TChange): void;
-} & AbstractCursorEvents;
+    /**
+     * @remarks Note that the `close` event is currently emitted whenever the internal `ChangeStreamCursor`
+     * instance is closed, which can occur multiple times for a given `ChangeStream` instance.
+     *
+     * TODO(NODE-6434): address this issue in NODE-6434
+     */
+    close(): void;
+};
 
 /**
  * @public
@@ -1635,6 +1696,7 @@ export declare class ClientEncryption {
     /* Excluded from this release type: _proxyOptions */
     /* Excluded from this release type: _tlsOptions */
     /* Excluded from this release type: _kmsProviders */
+    /* Excluded from this release type: _timeoutMS */
     /* Excluded from this release type: _mongoCrypt */
     /* Excluded from this release type: getMongoCrypt */
     /**
@@ -1938,6 +2000,7 @@ export declare interface ClientEncryptionCreateDataKeyProviderOptions {
     keyAltNames?: string[] | undefined;
     /** @experimental */
     keyMaterial?: Buffer | Binary;
+    /* Excluded from this release type: timeoutContext */
 }
 
 /**
@@ -2004,6 +2067,38 @@ export declare interface ClientEncryptionOptions {
      * TLS options for kms providers to use.
      */
     tlsOptions?: CSFLEKMSTlsOptions;
+    /**
+     * @experimental
+     *
+     * The timeout setting to be used for all the operations on ClientEncryption.
+     *
+     * When provided, `timeoutMS` is used as the timeout for each operation executed on
+     * the ClientEncryption object.  For example:
+     *
+     * ```typescript
+     * const clientEncryption = new ClientEncryption(client, {
+     *  timeoutMS: 1_000
+     *  kmsProviders: { local: { key: '<KEY>' } }
+     * });
+     *
+     * // `1_000` is used as the timeout for createDataKey call
+     * await clientEncryption.createDataKey('local');
+     * ```
+     *
+     * If `timeoutMS` is configured on the provided client, the client's `timeoutMS` value
+     * will be used unless `timeoutMS` is also provided as a client encryption option.
+     *
+     * ```typescript
+     * const client = new MongoClient('<uri>', { timeoutMS: 2_000 });
+     *
+     * // timeoutMS is set to 1_000 on clientEncryption
+     * const clientEncryption = new ClientEncryption(client, {
+     *  timeoutMS: 1_000
+     *  kmsProviders: { local: { key: '<KEY>' } }
+     * });
+     * ```
+     */
+    timeoutMS?: number;
 }
 
 /**
@@ -2062,7 +2157,7 @@ export declare interface ClientInsertOneResult {
 
 /**
  * @public
- * @see https://github.com/mongodb/specifications/blob/master/source/mongodb-handshake/handshake.rst#hello-command
+ * @see https://github.com/mongodb/specifications/blob/master/source/mongodb-handshake/handshake.md#hello-command
  */
 export declare interface ClientMetadata {
     driver: {
@@ -2127,7 +2222,7 @@ export declare class ClientSession extends TypedEventEmitter<ClientSessionEvents
     /* Excluded from this release type: client */
     /* Excluded from this release type: sessionPool */
     hasEnded: boolean;
-    clientOptions?: MongoOptions;
+    clientOptions: MongoOptions;
     supports: {
         causalConsistency: boolean;
     };
@@ -2143,7 +2238,12 @@ export declare class ClientSession extends TypedEventEmitter<ClientSessionEvents
     /* Excluded from this release type: [kSnapshotEnabled] */
     /* Excluded from this release type: [kPinnedConnection] */
     /* Excluded from this release type: [kTxnNumberIncrement] */
-    /* Excluded from this release type: timeoutMS */
+    /**
+     * @experimental
+     * Specifies the time an operation in a given `ClientSession` will run until it throws a timeout error
+     */
+    timeoutMS?: number;
+    /* Excluded from this release type: timeoutContext */
     /* Excluded from this release type: __constructor */
     /** The server id associated with this session */
     get id(): ServerSessionId | undefined;
@@ -2208,12 +2308,21 @@ export declare class ClientSession extends TypedEventEmitter<ClientSessionEvents
     startTransaction(options?: TransactionOptions): void;
     /**
      * Commits the currently active transaction in this session.
+     *
+     * @param options - Optional options, can be used to override `defaultTimeoutMS`.
      */
-    commitTransaction(): Promise<void>;
+    commitTransaction(options?: {
+        timeoutMS?: number;
+    }): Promise<void>;
     /**
      * Aborts the currently active transaction in this session.
+     *
+     * @param options - Optional options, can be used to override `defaultTimeoutMS`.
      */
-    abortTransaction(): Promise<void>;
+    abortTransaction(options?: {
+        timeoutMS?: number;
+    }): Promise<void>;
+    /* Excluded from this release type: abortTransaction */
     /**
      * This is here to ensure that ClientSession is never serialized to BSON.
      */
@@ -2227,6 +2336,9 @@ export declare class ClientSession extends TypedEventEmitter<ClientSessionEvents
      * `Promise.allSettled`, `Promise.race`, etc to parallelize operations inside a transaction is
      * undefined behaviour.
      *
+     * **IMPORTANT:** When running an operation inside a `withTransaction` callback, if it is not
+     * provided the explicit session in its options, it will not be part of the transaction and it will not respect timeoutMS.
+     *
      *
      * @remarks
      * - If all operations successfully complete and the `commitTransaction` operation is successful, then the provided function will return the result of the provided function.
@@ -2250,7 +2362,16 @@ export declare class ClientSession extends TypedEventEmitter<ClientSessionEvents
      * @param options - optional settings for the transaction
      * @returns A raw command response or undefined
      */
-    withTransaction<T = any>(fn: WithTransactionCallback<T>, options?: TransactionOptions): Promise<T>;
+    withTransaction<T = any>(fn: WithTransactionCallback<T>, options?: TransactionOptions & {
+        /**
+         * Configures a timeoutMS expiry for the entire withTransactionCallback.
+         *
+         * @remarks
+         * - The remaining timeout will not be applied to callback operations that do not use the ClientSession.
+         * - Overriding timeoutMS for operations executed using the explicit session inside the provided callback will result in a client-side error.
+         */
+        timeoutMS?: number;
+    }): Promise<T>;
 }
 
 /** @public */
@@ -2266,7 +2387,13 @@ export declare interface ClientSessionOptions {
     snapshot?: boolean;
     /** The default TransactionOptions to use for transactions started on this session. */
     defaultTransactionOptions?: TransactionOptions;
-    /* Excluded from this release type: defaultTimeoutMS */
+    /**
+     * @public
+     * @experimental
+     * An overriding timeoutMS value to use for a client-side timeout.
+     * If not provided the session uses the timeoutMS specified on the MongoClient.
+     */
+    defaultTimeoutMS?: number;
     /* Excluded from this release type: owner */
     /* Excluded from this release type: explicit */
     /* Excluded from this release type: initialClusterTime */
@@ -2468,6 +2595,7 @@ export declare class Collection<TSchema extends Document = Document> {
     /** The current index hint for the collection */
     get hint(): Hint | undefined;
     set hint(v: Hint | undefined);
+    get timeoutMS(): number | undefined;
     /**
      * Inserts a single document into MongoDB. If documents passed in do not contain the **_id** field,
      * one will be added to each of the documents missing it by the driver, mutating the document. This behavior
@@ -2576,10 +2704,10 @@ export declare class Collection<TSchema extends Document = Document> {
      */
     findOne(): Promise<WithId<TSchema> | null>;
     findOne(filter: Filter<TSchema>): Promise<WithId<TSchema> | null>;
-    findOne(filter: Filter<TSchema>, options: FindOptions): Promise<WithId<TSchema> | null>;
+    findOne(filter: Filter<TSchema>, options: Omit<FindOptions, 'timeoutMode'>): Promise<WithId<TSchema> | null>;
     findOne<T = TSchema>(): Promise<T | null>;
     findOne<T = TSchema>(filter: Filter<TSchema>): Promise<T | null>;
-    findOne<T = TSchema>(filter: Filter<TSchema>, options?: FindOptions): Promise<T | null>;
+    findOne<T = TSchema>(filter: Filter<TSchema>, options?: Omit<FindOptions, 'timeoutMode'>): Promise<T | null>;
     /**
      * Creates a cursor for a filter that can be used to iterate over results from MongoDB
      *
@@ -2850,6 +2978,59 @@ export declare class Collection<TSchema extends Document = Document> {
      *   });
      * ```
      *
+     * @remarks
+     * When `timeoutMS` is configured for a change stream, it will have different behaviour depending
+     * on whether the change stream is in iterator mode or emitter mode. In both cases, a change
+     * stream will time out if it does not receive a change event within `timeoutMS` of the last change
+     * event.
+     *
+     * Note that if a change stream is consistently timing out when watching a collection, database or
+     * client that is being changed, then this may be due to the server timing out before it can finish
+     * processing the existing oplog. To address this, restart the change stream with a higher
+     * `timeoutMS`.
+     *
+     * If the change stream times out the initial aggregate operation to establish the change stream on
+     * the server, then the client will close the change stream. If the getMore calls to the server
+     * time out, then the change stream will be left open, but will throw a MongoOperationTimeoutError
+     * when in iterator mode and emit an error event that returns a MongoOperationTimeoutError in
+     * emitter mode.
+     *
+     * To determine whether or not the change stream is still open following a timeout, check the
+     * {@link ChangeStream.closed} getter.
+     *
+     * @example
+     * In iterator mode, if a next() call throws a timeout error, it will attempt to resume the change stream.
+     * The next call can just be retried after this succeeds.
+     * ```ts
+     * const changeStream = collection.watch([], { timeoutMS: 100 });
+     * try {
+     *     await changeStream.next();
+     * } catch (e) {
+     *     if (e instanceof MongoOperationTimeoutError && !changeStream.closed) {
+     *       await changeStream.next();
+     *     }
+     *     throw e;
+     * }
+     * ```
+     *
+     * @example
+     * In emitter mode, if the change stream goes `timeoutMS` without emitting a change event, it will
+     * emit an error event that returns a MongoOperationTimeoutError, but will not close the change
+     * stream unless the resume attempt fails. There is no need to re-establish change listeners as
+     * this will automatically continue emitting change events once the resume attempt completes.
+     *
+     * ```ts
+     * const changeStream = collection.watch([], { timeoutMS: 100 });
+     * changeStream.on('change', console.log);
+     * changeStream.on('error', e => {
+     *     if (e instanceof MongoOperationTimeoutError && !changeStream.closed) {
+     *         // do nothing
+     *     } else {
+     *         changeStream.close();
+     *     }
+     * });
+     * ```
+     *
      * @param pipeline - An array of {@link https://www.mongodb.com/docs/manual/reference/operator/aggregation-pipeline/|aggregation pipeline stages} through which to pass change stream documents. This allows for filtering (using $match) and manipulating the change stream documents.
      * @param options - Optional settings for the command
      * @typeParam TLocal - Type of the data being detected by the change stream
@@ -2960,7 +3141,11 @@ export declare interface CollectionOptions extends BSONSerializeOptions, WriteCo
     readConcern?: ReadConcernLike;
     /** The preferred read preference (ReadPreference.PRIMARY, ReadPreference.PRIMARY_PREFERRED, ReadPreference.SECONDARY, ReadPreference.SECONDARY_PREFERRED, ReadPreference.NEAREST). */
     readPreference?: ReadPreferenceLike;
-    /* Excluded from this release type: timeoutMS */
+    /**
+     * @experimental
+     * Specifies the time an operation will run until it throws a timeout error
+     */
+    timeoutMS?: number;
 }
 
 /* Excluded from this release type: CollectionPrivate */
@@ -3003,6 +3188,9 @@ export declare interface CommandOperationOptions extends OperationOptions, Write
     readConcern?: ReadConcernLike;
     /** Collation */
     collation?: CollationOptions;
+    /**
+     * maxTimeMS is a server-side time limit in milliseconds for processing an operation.
+     */
     maxTimeMS?: number;
     /**
      * Comment to apply to the operation.
@@ -3377,7 +3565,9 @@ export declare interface CountOptions extends CommandOperationOptions {
     skip?: number;
     /** The maximum amounts to count before aborting. */
     limit?: number;
-    /** Number of milliseconds to wait before aborting the query. */
+    /**
+     * Number of milliseconds to wait before aborting the query.
+     */
     maxTimeMS?: number;
     /** An index name hint for the query. */
     hint?: string | Document;
@@ -3474,6 +3664,10 @@ export declare type CSFLEKMSTlsOptions = {
     [key: string]: ClientEncryptionTlsOptions | undefined;
 };
 
+/* Excluded from this release type: CSOTTimeoutContext */
+
+/* Excluded from this release type: CSOTTimeoutContextOptions */
+
 /** @public */
 export declare const CURSOR_FLAGS: readonly ["tailable", "oplogReplay", "noCursorTimeout", "awaitData", "exhaust", "partial"];
 
@@ -3488,6 +3682,48 @@ export declare interface CursorStreamOptions {
     transform?(this: void, doc: Document): Document;
 }
 
+/* Excluded from this release type: CursorTimeoutContext */
+
+/**
+ * @public
+ * @experimental
+ * Specifies how `timeoutMS` is applied to the cursor. Can be either `'cursorLifeTime'` or `'iteration'`
+ * When set to `'iteration'`, the deadline specified by `timeoutMS` applies to each call of
+ * `cursor.next()`.
+ * When set to `'cursorLifetime'`, the deadline applies to the life of the entire cursor.
+ *
+ * Depending on the type of cursor being used, this option has different default values.
+ * For non-tailable cursors, this value defaults to `'cursorLifetime'`
+ * For tailable cursors, this value defaults to `'iteration'` since tailable cursors, by
+ * definition can have an arbitrarily long lifetime.
+ *
+ * @example
+ * ```ts
+ * const cursor = collection.find({}, {timeoutMS: 100, timeoutMode: 'iteration'});
+ * for await (const doc of cursor) {
+ *  // process doc
+ *  // This will throw a timeout error if any of the iterator's `next()` calls takes more than 100ms, but
+ *  // will continue to iterate successfully otherwise, regardless of the number of batches.
+ * }
+ * ```
+ *
+ * @example
+ * ```ts
+ * const cursor = collection.find({}, { timeoutMS: 1000, timeoutMode: 'cursorLifetime' });
+ * const docs = await cursor.toArray(); // This entire line will throw a timeout error if all batches are not fetched and returned within 1000ms.
+ * ```
+ */
+export declare const CursorTimeoutMode: Readonly<{
+    readonly ITERATION: "iteration";
+    readonly LIFETIME: "cursorLifetime";
+}>;
+
+/**
+ * @public
+ * @experimental
+ */
+export declare type CursorTimeoutMode = (typeof CursorTimeoutMode)[keyof typeof CursorTimeoutMode];
+
 /**
  * @public
  * The schema for a DataKey in the key vault collection.
@@ -3559,6 +3795,7 @@ export declare class Db {
     get bsonOptions(): BSONSerializeOptions;
     get writeConcern(): WriteConcern | undefined;
     get namespace(): string;
+    get timeoutMS(): number | undefined;
     /**
      * Create a new collection on a server with the specified options. Use this to create capped collections.
      * More information about command options available at https://www.mongodb.com/docs/manual/reference/command/create/
@@ -3714,6 +3951,58 @@ export declare class Db {
      * - The first is to provide the schema that may be defined for all the collections within this database
      * - The second is to override the shape of the change stream document entirely, if it is not provided the type will default to ChangeStreamDocument of the first argument
      *
+     * @remarks
+     * When `timeoutMS` is configured for a change stream, it will have different behaviour depending
+     * on whether the change stream is in iterator mode or emitter mode. In both cases, a change
+     * stream will time out if it does not receive a change event within `timeoutMS` of the last change
+     * event.
+     *
+     * Note that if a change stream is consistently timing out when watching a collection, database or
+     * client that is being changed, then this may be due to the server timing out before it can finish
+     * processing the existing oplog. To address this, restart the change stream with a higher
+     * `timeoutMS`.
+     *
+     * If the change stream times out the initial aggregate operation to establish the change stream on
+     * the server, then the client will close the change stream. If the getMore calls to the server
+     * time out, then the change stream will be left open, but will throw a MongoOperationTimeoutError
+     * when in iterator mode and emit an error event that returns a MongoOperationTimeoutError in
+     * emitter mode.
+     *
+     * To determine whether or not the change stream is still open following a timeout, check the
+     * {@link ChangeStream.closed} getter.
+     *
+     * @example
+     * In iterator mode, if a next() call throws a timeout error, it will attempt to resume the change stream.
+     * The next call can just be retried after this succeeds.
+     * ```ts
+     * const changeStream = collection.watch([], { timeoutMS: 100 });
+     * try {
+     *     await changeStream.next();
+     * } catch (e) {
+     *     if (e instanceof MongoOperationTimeoutError && !changeStream.closed) {
+     *       await changeStream.next();
+     *     }
+     *     throw e;
+     * }
+     * ```
+     *
+     * @example
+     * In emitter mode, if the change stream goes `timeoutMS` without emitting a change event, it will
+     * emit an error event that returns a MongoOperationTimeoutError, but will not close the change
+     * stream unless the resume attempt fails. There is no need to re-establish change listeners as
+     * this will automatically continue emitting change events once the resume attempt completes.
+     *
+     * ```ts
+     * const changeStream = collection.watch([], { timeoutMS: 100 });
+     * changeStream.on('change', console.log);
+     * changeStream.on('error', e => {
+     *     if (e instanceof MongoOperationTimeoutError && !changeStream.closed) {
+     *         // do nothing
+     *     } else {
+     *         changeStream.close();
+     *     }
+     * });
+     * ```
      * @param pipeline - An array of {@link https://www.mongodb.com/docs/manual/reference/operator/aggregation-pipeline/|aggregation pipeline stages} through which to pass change stream documents. This allows for filtering (using $match) and manipulating the change stream documents.
      * @param options - Optional settings for the command
      * @typeParam TSchema - Type of the data being detected by the change stream
@@ -3748,7 +4037,11 @@ export declare interface DbOptions extends BSONSerializeOptions, WriteConcernOpt
     readConcern?: ReadConcern;
     /** Should retry failed writes */
     retryWrites?: boolean;
-    /* Excluded from this release type: timeoutMS */
+    /**
+     * @experimental
+     * Specifies the time an operation will run until it throws a timeout error
+     */
+    timeoutMS?: number;
 }
 
 /* Excluded from this release type: DbPrivate */
@@ -3851,6 +4144,8 @@ export declare interface EndSessionOptions {
     /* Excluded from this release type: error */
     force?: boolean;
     forceClear?: boolean;
+    /** Specifies the time an operation will run until it throws a timeout error */
+    timeoutMS?: number;
 }
 
 /** TypeScript Omit (Exclude to be specific) does not work for objects with an "any" indexed type, and breaks discriminated unions @public */
@@ -3888,6 +4183,38 @@ export declare type EventsDescription = Record<string, GenericListener>;
 
 /* Excluded from this release type: Explain */
 
+/**
+ * @public
+ *
+ * A base class for any cursors that have `explain()` methods.
+ */
+export declare abstract class ExplainableCursor<TSchema> extends AbstractCursor<TSchema> {
+    /** Execute the explain for the cursor */
+    abstract explain(): Promise<Document>;
+    abstract explain(verbosity: ExplainVerbosityLike | ExplainCommandOptions): Promise<Document>;
+    abstract explain(options: {
+        timeoutMS?: number;
+    }): Promise<Document>;
+    abstract explain(verbosity: ExplainVerbosityLike | ExplainCommandOptions, options: {
+        timeoutMS?: number;
+    }): Promise<Document>;
+    abstract explain(verbosity?: ExplainVerbosityLike | ExplainCommandOptions | {
+        timeoutMS?: number;
+    }, options?: {
+        timeoutMS?: number;
+    }): Promise<Document>;
+    protected resolveExplainTimeoutOptions(verbosity?: ExplainVerbosityLike | ExplainCommandOptions | {
+        timeoutMS?: number;
+    }, options?: {
+        timeoutMS?: number;
+    }): {
+        timeout?: {
+            timeoutMS?: number;
+        };
+        explain?: ExplainVerbosityLike | ExplainCommandOptions;
+    };
+}
+
 /** @public */
 export declare interface ExplainCommandOptions {
     /** The explain verbosity for the command. */
@@ -3998,7 +4325,7 @@ export declare interface FilterOperators<TValue> extends NonObjectIdLikeDocument
 }
 
 /** @public */
-export declare class FindCursor<TSchema = any> extends AbstractCursor<TSchema> {
+export declare class FindCursor<TSchema = any> extends ExplainableCursor<TSchema> {
     /* Excluded from this release type: cursorFilter */
     /* Excluded from this release type: numReturned */
     /* Excluded from this release type: findOptions */
@@ -4013,7 +4340,14 @@ export declare class FindCursor<TSchema = any> extends AbstractCursor<TSchema> {
      */
     count(options?: CountOptions): Promise<number>;
     /** Execute the explain for the cursor */
-    explain(verbosity?: ExplainVerbosityLike | ExplainCommandOptions): Promise<Document>;
+    explain(): Promise<Document>;
+    explain(verbosity: ExplainVerbosityLike | ExplainCommandOptions): Promise<Document>;
+    explain(options: {
+        timeoutMS?: number;
+    }): Promise<Document>;
+    explain(verbosity: ExplainVerbosityLike | ExplainCommandOptions, options: {
+        timeoutMS?: number;
+    }): Promise<Document>;
     /** Set the cursor query */
     filter(filter: Document): this;
     /**
@@ -4243,7 +4577,7 @@ export declare class FindOperators {
  * @public
  * @typeParam TSchema - Unused schema definition, deprecated usage, only specify `FindOptions` with no generic
  */
-export declare interface FindOptions<TSchema extends Document = Document> extends Omit<CommandOperationOptions, 'writeConcern' | 'explain'> {
+export declare interface FindOptions<TSchema extends Document = Document> extends Omit<CommandOperationOptions, 'writeConcern' | 'explain'>, AbstractCursorOptions {
     /** Sets the limit of documents returned in the query. */
     limit?: number;
     /** Set to sort the documents coming back from the query. Array of indexes, `[['a', 1]]` etc. */
@@ -4296,6 +4630,7 @@ export declare interface FindOptions<TSchema extends Document = Document> extend
      * @deprecated This API is deprecated in favor of `collection.find().explain()`.
      */
     explain?: ExplainOptions['explain'];
+    /* Excluded from this release type: timeoutMode */
 }
 
 /** @public */
@@ -4395,7 +4730,9 @@ export declare class GridFSBucket extends TypedEventEmitter<GridFSBucketEvents>
      *
      * @param id - The id of the file doc
      */
-    delete(id: ObjectId): Promise<void>;
+    delete(id: ObjectId, options?: {
+        timeoutMS: number;
+    }): Promise<void>;
     /** Convenience wrapper around find on the files collection */
     find(filter?: Filter<GridFSFile>, options?: FindOptions): FindCursor<GridFSFile>;
     /**
@@ -4412,9 +4749,13 @@ export declare class GridFSBucket extends TypedEventEmitter<GridFSBucketEvents>
      * @param id - the id of the file to rename
      * @param filename - new name for the file
      */
-    rename(id: ObjectId, filename: string): Promise<void>;
+    rename(id: ObjectId, filename: string, options?: {
+        timeoutMS: number;
+    }): Promise<void>;
     /** Removes this bucket's files collection, followed by its chunks collection. */
-    drop(): Promise<void>;
+    drop(options?: {
+        timeoutMS: number;
+    }): Promise<void>;
 }
 
 /** @public */
@@ -4430,7 +4771,12 @@ export declare interface GridFSBucketOptions extends WriteConcernOptions {
     chunkSizeBytes?: number;
     /** Read preference to be passed to read operations */
     readPreference?: ReadPreference;
-    /* Excluded from this release type: timeoutMS */
+    /**
+     * @experimental
+     * Specifies the lifetime duration of a gridFS stream. If any async operations are in progress
+     * when this timeout expires, the stream will throw a timeout error.
+     */
+    timeoutMS?: number;
 }
 
 /* Excluded from this release type: GridFSBucketPrivate */
@@ -4487,7 +4833,11 @@ export declare interface GridFSBucketReadStreamOptions {
      * to be returned by the stream. `end` is non-inclusive
      */
     end?: number;
-    /* Excluded from this release type: timeoutMS */
+    /**
+     * @experimental
+     * Specifies the time an operation will run until it throws a timeout error
+     */
+    timeoutMS?: number;
 }
 
 /** @public */
@@ -4558,6 +4908,7 @@ export declare class GridFSBucketWriteStream extends Writable {
      * ```
      */
     gridFSFile: GridFSFile | null;
+    /* Excluded from this release type: timeoutContext */
     /* Excluded from this release type: __constructor */
     /* Excluded from this release type: _construct */
     /* Excluded from this release type: _write */
@@ -4587,7 +4938,11 @@ export declare interface GridFSBucketWriteStreamOptions extends WriteConcernOpti
      * @deprecated Will be removed in the next major version. Add an aliases field to the metadata document instead.
      */
     aliases?: string[];
-    /* Excluded from this release type: timeoutMS */
+    /**
+     * @experimental
+     * Specifies the time an operation will run until it throws a timeout error
+     */
+    timeoutMS?: number;
 }
 
 /** @public */
@@ -4944,6 +5299,10 @@ export declare interface KMSProviders {
 
 /* Excluded from this release type: kWaitQueue_2 */
 
+/* Excluded from this release type: LegacyTimeoutContext */
+
+/* Excluded from this release type: LegacyTimeoutContextOptions */
+
 /** @public */
 export declare const LEGAL_TCP_SOCKET_OPTIONS: readonly ["autoSelectFamily", "autoSelectFamilyAttemptTimeout", "family", "hints", "localAddress", "localPort", "lookup"];
 
@@ -4970,6 +5329,8 @@ export declare interface ListCollectionsOptions extends Omit<CommandOperationOpt
     authorizedCollections?: boolean;
     /** The batchSize for the returned command cursor or if pre 2.8 the systems batch collection */
     batchSize?: number;
+    /* Excluded from this release type: timeoutMode */
+    /* Excluded from this release type: timeoutContext */
 }
 
 /** @public */
@@ -5004,7 +5365,9 @@ export declare class ListIndexesCursor extends AbstractCursor {
 }
 
 /** @public */
-export declare type ListIndexesOptions = AbstractCursorOptions;
+export declare type ListIndexesOptions = AbstractCursorOptions & {
+    /* Excluded from this release type: omitMaxTimeMS */
+};
 
 /** @public */
 export declare class ListSearchIndexesCursor extends AggregationCursor<{
@@ -5269,6 +5632,7 @@ export declare class MongoClient extends TypedEventEmitter<MongoClientEvents> im
     get writeConcern(): WriteConcern | undefined;
     get readPreference(): ReadPreference;
     get bsonOptions(): BSONSerializeOptions;
+    get timeoutMS(): number | undefined;
     /**
      * Executes a client bulk write operation, available on server 8.0+.
      * @param models - The client bulk write models.
@@ -5279,6 +5643,13 @@ export declare class MongoClient extends TypedEventEmitter<MongoClientEvents> im
     /**
      * Connect to MongoDB using a url
      *
+     * @remarks
+     * Calling `connect` is optional since the first operation you perform will call `connect` if it's needed.
+     * `timeoutMS` will bound the time any operation can take before throwing a timeout error.
+     * However, when the operation being run is automatically connecting your `MongoClient` the `timeoutMS` will not apply to the time taken to connect the MongoClient.
+     * This means the time to setup the `MongoClient` does not count against `timeoutMS`.
+     * If you are using `timeoutMS` we recommend connecting your client explicitly in advance of any operation to avoid this inconsistent execution time.
+     *
      * @see docs.mongodb.org/manual/reference/connection-string/
      */
     connect(): Promise<this>;
@@ -5308,6 +5679,13 @@ export declare class MongoClient extends TypedEventEmitter<MongoClientEvents> im
      * Connect to MongoDB using a url
      *
      * @remarks
+     * Calling `connect` is optional since the first operation you perform will call `connect` if it's needed.
+     * `timeoutMS` will bound the time any operation can take before throwing a timeout error.
+     * However, when the operation being run is automatically connecting your `MongoClient` the `timeoutMS` will not apply to the time taken to connect the MongoClient.
+     * This means the time to setup the `MongoClient` does not count against `timeoutMS`.
+     * If you are using `timeoutMS` we recommend connecting your client explicitly in advance of any operation to avoid this inconsistent execution time.
+     *
+     * @remarks
      * The programmatically provided options take precedence over the URI options.
      *
      * @see https://www.mongodb.com/docs/manual/reference/connection-string/
@@ -5341,6 +5719,58 @@ export declare class MongoClient extends TypedEventEmitter<MongoClientEvents> im
      * - The first is to provide the schema that may be defined for all the data within the current cluster
      * - The second is to override the shape of the change stream document entirely, if it is not provided the type will default to ChangeStreamDocument of the first argument
      *
+     * @remarks
+     * When `timeoutMS` is configured for a change stream, it will have different behaviour depending
+     * on whether the change stream is in iterator mode or emitter mode. In both cases, a change
+     * stream will time out if it does not receive a change event within `timeoutMS` of the last change
+     * event.
+     *
+     * Note that if a change stream is consistently timing out when watching a collection, database or
+     * client that is being changed, then this may be due to the server timing out before it can finish
+     * processing the existing oplog. To address this, restart the change stream with a higher
+     * `timeoutMS`.
+     *
+     * If the change stream times out the initial aggregate operation to establish the change stream on
+     * the server, then the client will close the change stream. If the getMore calls to the server
+     * time out, then the change stream will be left open, but will throw a MongoOperationTimeoutError
+     * when in iterator mode and emit an error event that returns a MongoOperationTimeoutError in
+     * emitter mode.
+     *
+     * To determine whether or not the change stream is still open following a timeout, check the
+     * {@link ChangeStream.closed} getter.
+     *
+     * @example
+     * In iterator mode, if a next() call throws a timeout error, it will attempt to resume the change stream.
+     * The next call can just be retried after this succeeds.
+     * ```ts
+     * const changeStream = collection.watch([], { timeoutMS: 100 });
+     * try {
+     *     await changeStream.next();
+     * } catch (e) {
+     *     if (e instanceof MongoOperationTimeoutError && !changeStream.closed) {
+     *       await changeStream.next();
+     *     }
+     *     throw e;
+     * }
+     * ```
+     *
+     * @example
+     * In emitter mode, if the change stream goes `timeoutMS` without emitting a change event, it will
+     * emit an error event that returns a MongoOperationTimeoutError, but will not close the change
+     * stream unless the resume attempt fails. There is no need to re-establish change listeners as
+     * this will automatically continue emitting change events once the resume attempt completes.
+     *
+     * ```ts
+     * const changeStream = collection.watch([], { timeoutMS: 100 });
+     * changeStream.on('change', console.log);
+     * changeStream.on('error', e => {
+     *     if (e instanceof MongoOperationTimeoutError && !changeStream.closed) {
+     *         // do nothing
+     *     } else {
+     *         changeStream.close();
+     *     }
+     * });
+     * ```
      * @param pipeline - An array of {@link https://www.mongodb.com/docs/manual/reference/operator/aggregation-pipeline/|aggregation pipeline stages} through which to pass change stream documents. This allows for filtering (using $match) and manipulating the change stream documents.
      * @param options - Optional settings for the command
      * @typeParam TSchema - Type of the data being detected by the change stream
@@ -5438,7 +5868,11 @@ export declare type MongoClientEvents = Pick<TopologyEvents, (typeof MONGO_CLIEN
 export declare interface MongoClientOptions extends BSONSerializeOptions, SupportedNodeConnectionOptions {
     /** Specifies the name of the replica set, if the mongod is a member of a replica set. */
     replicaSet?: string;
-    /* Excluded from this release type: timeoutMS */
+    /**
+     * @experimental
+     * Specifies the time an operation will run until it throws a timeout error
+     */
+    timeoutMS?: number;
     /** Enables or disables TLS/SSL for the connection. */
     tls?: boolean;
     /** A boolean to enable or disables TLS/SSL for the connection. (The ssl option is equivalent to the tls option.) */
@@ -5558,7 +5992,7 @@ export declare interface MongoClientOptions extends BSONSerializeOptions, Suppor
      *
      * @remarks
      *  Automatic encryption is an enterprise only feature that only applies to operations on a collection. Automatic encryption is not supported for operations on a database or view, and operations that are not bypassed will result in error
-     *  (see [libmongocrypt: Auto Encryption Allow-List](https://github.com/mongodb/specifications/blob/master/source/client-side-encryption/client-side-encryption.rst#libmongocrypt-auto-encryption-allow-list)). To bypass automatic encryption for all operations, set bypassAutoEncryption=true in AutoEncryptionOpts.
+     *  (see [libmongocrypt: Auto Encryption Allow-List](https://github.com/mongodb/specifications/blob/master/source/client-side-encryption/client-side-encryption.md#libmongocrypt-auto-encryption-allow-list)). To bypass automatic encryption for all operations, set bypassAutoEncryption=true in AutoEncryptionOpts.
      *
      *  Automatic encryption requires the authenticated user to have the [listCollections privilege action](https://www.mongodb.com/docs/manual/reference/command/listCollections/#dbcmd.listCollections).
      *
@@ -6262,6 +6696,29 @@ export declare class MongoOIDCError extends MongoRuntimeError {
     get name(): string;
 }
 
+/**
+ * @public
+ * @category Error
+ *
+ * The `MongoOperationTimeoutError` class represents an error that occurs when an operation could not be completed within the specified `timeoutMS`.
+ * It is generated by the driver in support of the "client side operation timeout" feature so inherits from `MongoDriverError`.
+ * When `timeoutMS` is enabled `MongoServerError`s relating to `MaxTimeExpired` errors will be converted to `MongoOperationTimeoutError`
+ *
+ * @example
+ * ```ts
+ * try {
+ *   await blogs.insertOne(blogPost, { timeoutMS: 60_000 })
+ * } catch (error) {
+ *   if (error instanceof MongoOperationTimeoutError) {
+ *     console.log(`Oh no! writer's block!`, error);
+ *   }
+ * }
+ * ```
+ */
+export declare class MongoOperationTimeoutError extends MongoDriverError {
+    get name(): string;
+}
+
 /**
  * Parsed Mongo Client Options.
  *
@@ -6350,7 +6807,7 @@ export declare interface MongoOptions extends Required<Pick<MongoClientOptions,
     /* Excluded from this release type: __index */
     /* Excluded from this release type: mongoLoggerOptions */
     /* Excluded from this release type: mongodbLogPath */
-    /* Excluded from this release type: timeoutMS */
+    timeoutMS?: number;
 }
 
 /**
@@ -6376,7 +6833,7 @@ export declare class MongoParseError extends MongoDriverError {
 
 /**
  * An error generated when the driver encounters unexpected input
- * or reaches an unexpected/invalid internal state
+ * or reaches an unexpected/invalid internal state.
  *
  * @privateRemarks
  * Should **never** be directly instantiated.
@@ -6764,7 +7221,12 @@ export declare interface OperationOptions extends BSONSerializeOptions {
     readPreference?: ReadPreferenceLike;
     /* Excluded from this release type: bypassPinningCheck */
     omitReadPreference?: boolean;
-    /* Excluded from this release type: timeoutMS */
+    /* Excluded from this release type: omitMaxTimeMS */
+    /**
+     * @experimental
+     * Specifies the time an operation will run until it throws a timeout error
+     */
+    timeoutMS?: number;
 }
 
 /* Excluded from this release type: OperationParent */
@@ -7153,7 +7615,7 @@ export declare class RunCommandCursor extends AbstractCursor {
     setMaxTimeMS(maxTimeMS: number): this;
     /**
      * Controls the `getMore.batchSize` field
-     * @param maxTimeMS - the number documents to return in the `nextBatch`
+     * @param batchSize - the number documents to return in the `nextBatch`
      */
     setBatchSize(batchSize: number): this;
     /** Unsupported for RunCommandCursor */
@@ -7162,7 +7624,9 @@ export declare class RunCommandCursor extends AbstractCursor {
     withReadConcern(_: ReadConcernLike): never;
     /** Unsupported for RunCommandCursor: various cursor flags must be configured directly on command document */
     addCursorFlag(_: string, __: boolean): never;
-    /** Unsupported for RunCommandCursor: maxTimeMS must be configured directly on command document */
+    /**
+     * Unsupported for RunCommandCursor: maxTimeMS must be configured directly on command document
+     */
     maxTimeMS(_: number): never;
     /** Unsupported for RunCommandCursor: batchSize must be configured directly on command document */
     batchSize(_: number): never;
@@ -7178,12 +7642,57 @@ export declare type RunCommandOptions = {
     session?: ClientSession;
     /** The read preference */
     readPreference?: ReadPreferenceLike;
+    /**
+     * @experimental
+     * Specifies the time an operation will run until it throws a timeout error
+     */
+    timeoutMS?: number;
+    /* Excluded from this release type: omitMaxTimeMS */
 } & BSONSerializeOptions;
 
 /** @public */
 export declare type RunCursorCommandOptions = {
     readPreference?: ReadPreferenceLike;
     session?: ClientSession;
+    /**
+     * @experimental
+     * Specifies the time an operation will run until it throws a timeout error. Note that if
+     * `maxTimeMS` is provided in the command in addition to setting `timeoutMS` in the options, then
+     * the original value of `maxTimeMS` will be overwritten.
+     */
+    timeoutMS?: number;
+    /**
+     * @public
+     * @experimental
+     * Specifies how `timeoutMS` is applied to the cursor. Can be either `'cursorLifeTime'` or `'iteration'`
+     * When set to `'iteration'`, the deadline specified by `timeoutMS` applies to each call of
+     * `cursor.next()`.
+     * When set to `'cursorLifetime'`, the deadline applies to the life of the entire cursor.
+     *
+     * Depending on the type of cursor being used, this option has different default values.
+     * For non-tailable cursors, this value defaults to `'cursorLifetime'`
+     * For tailable cursors, this value defaults to `'iteration'` since tailable cursors, by
+     * definition can have an arbitrarily long lifetime.
+     *
+     * @example
+     * ```ts
+     * const cursor = collection.find({}, {timeoutMS: 100, timeoutMode: 'iteration'});
+     * for await (const doc of cursor) {
+     *  // process doc
+     *  // This will throw a timeout error if any of the iterator's `next()` calls takes more than 100ms, but
+     *  // will continue to iterate successfully otherwise, regardless of the number of batches.
+     * }
+     * ```
+     *
+     * @example
+     * ```ts
+     * const cursor = collection.find({}, { timeoutMS: 1000, timeoutMode: 'cursorLifetime' });
+     * const docs = await cursor.toArray(); // This entire line will throw a timeout error if all batches are not fetched and returned within 1000ms.
+     * ```
+     */
+    timeoutMode?: CursorTimeoutMode;
+    tailable?: boolean;
+    awaitData?: boolean;
 } & BSONSerializeOptions;
 
 /** @public */
@@ -7213,7 +7722,7 @@ export declare interface SelectServerOptions {
     session?: ClientSession;
     operationName: string;
     previousServer?: ServerDescription;
-    /* Excluded from this release type: timeout */
+    /* Excluded from this release type: timeoutContext */
 }
 
 export { serialize }
@@ -7283,6 +7792,8 @@ export declare class ServerClosedEvent {
     /* Excluded from this release type: __constructor */
 }
 
+/* Excluded from this release type: ServerCommandOptions */
+
 /**
  * The client's view of a single server, based on the most recent hello outcome.
  *
@@ -7317,6 +7828,8 @@ export declare class ServerDescription {
     maxWriteBatchSize: number | null;
     /** The max bson object size. */
     maxBsonObjectSize: number | null;
+    /** Indicates server is a mongocryptd instance. */
+    iscryptd: boolean;
     $clusterTime?: ClusterTime;
     /* Excluded from this release type: __constructor */
     get hostAddress(): HostAddress;
@@ -7330,8 +7843,8 @@ export declare class ServerDescription {
     get host(): string;
     get port(): number;
     /**
-     * Determines if another `ServerDescription` is equal to this one per the rules defined
-     * in the {@link https://github.com/mongodb/specifications/blob/master/source/server-discovery-and-monitoring/server-discovery-and-monitoring.rst#serverdescription|SDAM spec}
+     * Determines if another `ServerDescription` is equal to this one per the rules defined in the SDAM specification.
+     * @see https://github.com/mongodb/specifications/blob/master/source/server-discovery-and-monitoring/server-discovery-and-monitoring.md
      */
     equals(other?: ServerDescription | null): boolean;
 }
@@ -7478,7 +7991,6 @@ export declare class ServerSession {
      * @param sessionTimeoutMinutes - The server's "logicalSessionTimeoutMinutes"
      */
     hasTimedOut(sessionTimeoutMinutes: number): boolean;
-    /* Excluded from this release type: clone */
 }
 
 /** @public */
@@ -7652,7 +8164,9 @@ export declare type TagSet = {
 
 /* Excluded from this release type: Timeout */
 
-/* Excluded from this release type: TimerQueue */
+/* Excluded from this release type: TimeoutContext */
+
+/* Excluded from this release type: TimeoutContextOptions */
 
 /** @public
  * Configuration options for timeseries collections
@@ -7836,7 +8350,7 @@ export declare class Transaction {
  * Configuration options for a transaction.
  * @public
  */
-export declare interface TransactionOptions extends CommandOperationOptions {
+export declare interface TransactionOptions extends Omit<CommandOperationOptions, 'timeoutMS'> {
     /** A default read concern for commands in this transaction */
     readConcern?: ReadConcernLike;
     /** A default writeConcern for commands in this transaction */
@@ -8115,7 +8629,9 @@ export declare class WriteConcern {
     readonly w?: W;
     /** Request acknowledgment that the write operation has been written to the on-disk journal */
     readonly journal?: boolean;
-    /** Specify a time limit to prevent write operations from blocking indefinitely */
+    /**
+     * Specify a time limit to prevent write operations from blocking indefinitely.
+     */
     readonly wtimeoutMS?: number;
     /**
      * Specify a time limit to prevent write operations from blocking indefinitely.
@@ -8200,7 +8716,9 @@ export declare interface WriteConcernOptions {
 export declare interface WriteConcernSettings {
     /** The write concern */
     w?: W;
-    /** The write concern timeout */
+    /**
+     * The write concern timeout.
+     */
     wtimeoutMS?: number;
     /** The journal write concern */
     journal?: boolean;
@@ -8211,7 +8729,6 @@ export declare interface WriteConcernSettings {
     j?: boolean;
     /**
      * The write concern timeout.
-     * @deprecated Will be removed in the next major version. Please use the wtimeoutMS option.
      */
     wtimeout?: number;
     /**