mongodb 4.0.0 → 4.1.2

package/mongodb.d.ts

@@ -1,4 +1,5 @@
 /// <reference types="node" />
+
 import { Binary } from 'bson';
 import { BSONRegExp } from 'bson';
 import { BSONSymbol } from 'bson';
@@ -58,33 +59,41 @@ export declare abstract class AbstractCursor<TSchema = any, CursorEvents extends
     /* Excluded from this release type: cursorOptions */
     get closed(): boolean;
     get killed(): boolean;
+    get loadBalanced(): boolean;
     /** Returns current buffered documents length */
     bufferedCount(): number;
     /** Returns current buffered documents */
     readBufferedDocuments(number?: number): TSchema[];
-    [Symbol.asyncIterator](): AsyncIterator<TSchema | null>;
+    [Symbol.asyncIterator](): AsyncIterator<TSchema, void>;
     stream(options?: CursorStreamOptions): Readable;
     hasNext(): Promise<boolean>;
     hasNext(callback: Callback<boolean>): void;
     /** Get the next available document from the cursor, returns null if no more documents are available. */
-    next<T = TSchema>(): Promise<T | null>;
-    next<T = TSchema>(callback: Callback<T | null>): void;
+    next(): Promise<TSchema | null>;
+    next(callback: Callback<TSchema | null>): void;
+    next(callback?: Callback<TSchema | null>): Promise<TSchema | null> | void;
     /**
      * Try to get the next available document from the cursor or `null` if an empty batch is returned
      */
-    tryNext<T = TSchema>(): Promise<T | null>;
-    tryNext<T = TSchema>(callback: Callback<T | null>): void;
+    tryNext(): Promise<TSchema | null>;
+    tryNext(callback: Callback<TSchema | null>): void;
     /**
      * Iterates over all the documents for this cursor using the iterator, callback pattern.
      *
      * @param iterator - The iteration callback.
      * @param callback - The end callback.
      */
-    forEach<T = TSchema>(iterator: (doc: T) => boolean | void): Promise<void>;
-    forEach<T = TSchema>(iterator: (doc: T) => boolean | void, callback: Callback<void>): void;
+    forEach(iterator: (doc: TSchema) => boolean | void): Promise<void>;
+    forEach(iterator: (doc: TSchema) => boolean | void, callback: Callback<void>): void;
     close(): void;
     close(callback: Callback): void;
+    /**
+     * @deprecated options argument is deprecated
+     */
     close(options: CursorCloseOptions): Promise<void>;
+    /**
+     * @deprecated options argument is deprecated
+     */
     close(options: CursorCloseOptions, callback: Callback): void;
     /**
      * Returns an array of documents. The caller is responsible for making sure that there
@@ -94,8 +103,8 @@ export declare abstract class AbstractCursor<TSchema = any, CursorEvents extends
      *
      * @param callback - The result callback.
      */
-    toArray<T = TSchema>(): Promise<T[]>;
-    toArray<T = TSchema>(callback: Callback<T[]>): void;
+    toArray(): Promise<TSchema[]>;
+    toArray(callback: Callback<TSchema[]>): void;
     /**
      * Add a cursor flag to the cursor
      *
@@ -107,11 +116,12 @@ export declare abstract class AbstractCursor<TSchema = any, CursorEvents extends
      * Map all documents using the provided function
      * If there is a transform set on the cursor, that will be called first and the result passed to
      * this function's transform.
-     * @remarks
      *
-     * **NOTE:** adding a transform changes the return type of the iteration of this cursor, it **does not** return
-     * a new instance of a cursor. This means when calling map, you should always assign the result to a new
-     * variable. Take note of the following example:
+     * @remarks
+     * **Note for Typescript Users:** adding a transform changes the return type of the iteration of this cursor,
+     * it **does not** return a new instance of a cursor. This means when calling map,
+     * you should always assign the result to a new variable in order to get a correctly typed cursor variable.
+     * Take note of the following example:
      *
      * @example
      * ```typescript
@@ -379,7 +389,6 @@ export declare interface AggregateOptions extends CommandOperationOptions {
  * @public
  */
 export declare class AggregationCursor<TSchema = Document> extends AbstractCursor<TSchema> {
-    /* Excluded from this release type: [kParent] */
     /* Excluded from this release type: [kPipeline] */
     /* Excluded from this release type: [kOptions] */
     /* Excluded from this release type: __constructor */
@@ -397,8 +406,11 @@ export declare class AggregationCursor<TSchema = Document> extends AbstractCurso
     limit($limit: number): this;
     /** Add a match stage to the aggregation pipeline */
     match($match: Document): this;
-    /** Add a out stage to the aggregation pipeline */
-    out($out: number): this;
+    /** Add an out stage to the aggregation pipeline */
+    out($out: {
+        db: string;
+        coll: string;
+    } | string): this;
     /**
      * Add a project stage to the aggregation pipeline
      *
@@ -406,18 +418,41 @@ export declare class AggregationCursor<TSchema = Document> extends AbstractCurso
      * In order to strictly type this function you must provide an interface
      * that represents the effect of your projection on the result documents.
      *
-     * **NOTE:** adding a projection changes the return type of the iteration of this cursor,
+     * By default chaining a projection to your cursor changes the returned type to the generic {@link Document} type.
+     * You should specify a parameterized type to have assertions on your final results.
+     *
+     * @example
+     * ```typescript
+     * // Best way
+     * const docs: AggregationCursor<{ a: number }> = cursor.project<{ a: number }>({ _id: 0, a: true });
+     * // Flexible way
+     * const docs: AggregationCursor<Document> = cursor.project({ _id: 0, a: true });
+     * ```
+     *
+     * @remarks
+     * In order to strictly type this function you must provide an interface
+     * that represents the effect of your projection on the result documents.
+     *
+     * **Note for Typescript Users:** adding a transform changes the return type of the iteration of this cursor,
      * it **does not** return a new instance of a cursor. This means when calling project,
-     * you should always assign the result to a new variable. Take note of the following example:
+     * you should always assign the result to a new variable in order to get a correctly typed cursor variable.
+     * Take note of the following example:
      *
      * @example
      * ```typescript
      * const cursor: AggregationCursor<{ a: number; b: string }> = coll.aggregate([]);
-     * const projectCursor = cursor.project<{ a: number }>({ a: true });
+     * const projectCursor = cursor.project<{ a: number }>({ _id: 0, a: true });
      * const aPropOnlyArray: {a: number}[] = await projectCursor.toArray();
+     *
+     * // or always use chaining and save the final cursor
+     *
+     * const cursor = coll.aggregate().project<{ a: string }>({
+     *   _id: 0,
+     *   a: { $convert: { input: '$a', to: 'string' }
+     * }});
      * ```
      */
-    project<T = TSchema>($project: Projection<T>): AggregationCursor<T>;
+    project<T extends Document = Document>($project: Document): AggregationCursor<T>;
     /** Add a lookup stage to the aggregation pipeline */
     lookup($lookup: Document): this;
     /** Add a redact stage to the aggregation pipeline */
@@ -493,6 +528,14 @@ export declare const AuthMechanism: Readonly<{
 /** @public */
 export declare type AuthMechanism = typeof AuthMechanism[keyof typeof AuthMechanism];
 
+/** @public */
+export declare interface AuthMechanismProperties extends Document {
+    SERVICE_NAME?: string;
+    SERVICE_REALM?: string;
+    CANONICALIZE_HOST_NAME?: boolean;
+    AWS_SESSION_TOKEN?: string;
+}
+
 /** @public */
 export declare interface AutoEncrypter {
     new (client: MongoClient, options: AutoEncryptionOptions): AutoEncrypter;
@@ -629,10 +672,12 @@ export declare const BatchType: Readonly<{
 
 /** @public */
 export declare type BatchType = typeof BatchType[keyof typeof BatchType];
+
 export { Binary }
 
 /** @public */
-export declare type BitwiseFilter = number /** numeric bit mask */ | Binary /** BinData bit mask */ | number[];
+export declare type BitwiseFilter = number /** numeric bit mask */ | Binary /** BinData bit mask */ | ReadonlyArray<number>;
+
 export { BSONRegExp }
 
 /**
@@ -643,6 +688,7 @@ export declare interface BSONSerializeOptions extends Omit<SerializeOptions, 'in
     /** Return BSON filled buffers from operations */
     raw?: boolean;
 }
+
 export { BSONSymbol }
 
 /** @public */
@@ -769,6 +815,7 @@ export declare interface BulkWriteOperationError {
     index: number;
     code: number;
     errmsg: string;
+    errInfo: Document;
     op: Document | UpdateStatement | DeleteStatement;
 }
 
@@ -1061,12 +1108,18 @@ export declare class ClientSession extends TypedEventEmitter<ClientSessionEvents
     /* Excluded from this release type: [kServerSession] */
     /* Excluded from this release type: [kSnapshotTime] */
     /* Excluded from this release type: [kSnapshotEnabled] */
+    /* Excluded from this release type: [kPinnedConnection] */
     /* Excluded from this release type: __constructor */
     /** The server id associated with this session */
     get id(): ServerSessionId | undefined;
     get serverSession(): ServerSession;
     /** Whether or not this session is configured for snapshot reads */
     get snapshotEnabled(): boolean;
+    get loadBalanced(): boolean;
+    /* Excluded from this release type: pinnedConnection */
+    /* Excluded from this release type: pin */
+    /* Excluded from this release type: unpin */
+    get isPinned(): boolean;
     /**
      * Ends this session on the server
      *
@@ -1075,14 +1128,20 @@ export declare class ClientSession extends TypedEventEmitter<ClientSessionEvents
      */
     endSession(): Promise<void>;
     endSession(callback: Callback<void>): void;
-    endSession(options: Record<string, unknown>): Promise<void>;
-    endSession(options: Record<string, unknown>, callback: Callback<void>): void;
+    endSession(options: EndSessionOptions): Promise<void>;
+    endSession(options: EndSessionOptions, callback: Callback<void>): void;
     /**
      * Advances the operationTime for a ClientSession.
      *
      * @param operationTime - the `BSON.Timestamp` of the operation type it is desired to advance to
      */
     advanceOperationTime(operationTime: Timestamp): void;
+    /**
+     * Advances the clusterTime for a ClientSession to the provided clusterTime of another ClientSession
+     *
+     * @param clusterTime - the $clusterTime returned by the server from another session in the form of a document containing the `BSON.Timestamp` clusterTime and signature
+     */
+    advanceClusterTime(clusterTime: ClusterTime): void;
     /**
      * Used to determine if this session equals another
      *
@@ -1162,6 +1221,7 @@ export declare interface ClusterTime {
         keyId: Long;
     };
 }
+
 export { Code }
 
 /** @public */
@@ -1308,10 +1368,10 @@ export declare class Collection<TSchema extends Document = Document> {
      * @param options - Optional settings for the command
      * @param callback - An optional callback, a Promise will be returned if none is provided
      */
-    updateOne(filter: Filter<TSchema>, update: UpdateFilter<TSchema> | Partial<TSchema>): Promise<UpdateResult | Document>;
-    updateOne(filter: Filter<TSchema>, update: UpdateFilter<TSchema> | Partial<TSchema>, callback: Callback<UpdateResult | Document>): void;
-    updateOne(filter: Filter<TSchema>, update: UpdateFilter<TSchema> | Partial<TSchema>, options: UpdateOptions): Promise<UpdateResult | Document>;
-    updateOne(filter: Filter<TSchema>, update: UpdateFilter<TSchema> | Partial<TSchema>, options: UpdateOptions, callback: Callback<UpdateResult | Document>): void;
+    updateOne(filter: Filter<TSchema>, update: UpdateFilter<TSchema> | Partial<TSchema>): Promise<UpdateResult>;
+    updateOne(filter: Filter<TSchema>, update: UpdateFilter<TSchema> | Partial<TSchema>, callback: Callback<UpdateResult>): void;
+    updateOne(filter: Filter<TSchema>, update: UpdateFilter<TSchema> | Partial<TSchema>, options: UpdateOptions): Promise<UpdateResult>;
+    updateOne(filter: Filter<TSchema>, update: UpdateFilter<TSchema> | Partial<TSchema>, options: UpdateOptions, callback: Callback<UpdateResult>): void;
     /**
      * Replace a document in a collection with another document
      *
@@ -1370,7 +1430,7 @@ export declare class Collection<TSchema extends Document = Document> {
      */
     rename(newName: string): Promise<Collection>;
     rename(newName: string, callback: Callback<Collection>): void;
-    rename(newName: string, options: RenameOptions): Promise<Collection> | void;
+    rename(newName: string, options: RenameOptions): Promise<Collection>;
     rename(newName: string, options: RenameOptions, callback: Callback<Collection>): void;
     /**
      * Drop the collection from the database, removing it permanently. New accesses will create a new collection.
@@ -1389,25 +1449,25 @@ export declare class Collection<TSchema extends Document = Document> {
      * @param options - Optional settings for the command
      * @param callback - An optional callback, a Promise will be returned if none is provided
      */
-    findOne(): Promise<TSchema | undefined>;
-    findOne(callback: Callback<TSchema | undefined>): void;
-    findOne(filter: Filter<TSchema>): Promise<TSchema | undefined>;
-    findOne(filter: Filter<TSchema>, callback: Callback<TSchema | undefined>): void;
-    findOne(filter: Filter<TSchema>, options: FindOptions<TSchema>): Promise<TSchema | undefined>;
-    findOne(filter: Filter<TSchema>, options: FindOptions<TSchema>, callback: Callback<TSchema | undefined>): void;
-    findOne<T = TSchema>(): Promise<T | undefined>;
-    findOne<T = TSchema>(callback: Callback<T | undefined>): void;
-    findOne<T = TSchema>(filter: Filter<T>): Promise<T | undefined>;
-    findOne<T = TSchema>(filter: Filter<T>, options?: FindOptions<T>): Promise<T | undefined>;
-    findOne<T = TSchema>(filter: Filter<T>, options?: FindOptions<T>, callback?: Callback<T | undefined>): void;
+    findOne(): Promise<TSchema | null>;
+    findOne(callback: Callback<TSchema | null>): void;
+    findOne(filter: Filter<TSchema>): Promise<TSchema | null>;
+    findOne(filter: Filter<TSchema>, callback: Callback<TSchema | null>): void;
+    findOne(filter: Filter<TSchema>, options: FindOptions): Promise<TSchema | null>;
+    findOne(filter: Filter<TSchema>, options: FindOptions, callback: Callback<TSchema | null>): void;
+    findOne<T = TSchema>(): Promise<T | null>;
+    findOne<T = TSchema>(callback: Callback<T | null>): void;
+    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?: FindOptions, callback?: Callback<T | null>): void;
     /**
      * Creates a cursor for a filter that can be used to iterate over results from MongoDB
      *
      * @param filter - The filter predicate. If unspecified, then all documents in the collection will match the predicate
      */
     find(): FindCursor<TSchema>;
-    find(filter: Filter<TSchema>, options?: FindOptions<TSchema>): FindCursor<TSchema>;
-    find<T = TSchema>(filter: Filter<T>, options?: FindOptions<T>): FindCursor<T>;
+    find(filter: Filter<TSchema>, options?: FindOptions): FindCursor<TSchema>;
+    find<T>(filter: Filter<TSchema>, options?: FindOptions): FindCursor<T>;
     /**
      * Returns the options of the collection.
      *
@@ -1614,10 +1674,10 @@ export declare class Collection<TSchema extends Document = Document> {
      * @param options - Optional settings for the command
      * @param callback - An optional callback, a Promise will be returned if none is provided
      */
-    indexes(): Promise<Document>;
-    indexes(callback: Callback<Document>): void;
-    indexes(options: IndexInformationOptions): Promise<Document>;
-    indexes(options: IndexInformationOptions, callback: Callback<Document>): void;
+    indexes(): Promise<Document[]>;
+    indexes(callback: Callback<Document[]>): void;
+    indexes(options: IndexInformationOptions): Promise<Document[]>;
+    indexes(options: IndexInformationOptions, callback: Callback<Document[]>): void;
     /**
      * Get all the collection statistics.
      *
@@ -1636,8 +1696,8 @@ export declare class Collection<TSchema extends Document = Document> {
      * @param callback - An optional callback, a Promise will be returned if none is provided
      */
     findOneAndDelete(filter: Filter<TSchema>): Promise<ModifyResult<TSchema>>;
-    findOneAndDelete(filter: Filter<TSchema>, callback: Callback<ModifyResult<TSchema>>): void;
     findOneAndDelete(filter: Filter<TSchema>, options: FindOneAndDeleteOptions): Promise<ModifyResult<TSchema>>;
+    findOneAndDelete(filter: Filter<TSchema>, callback: Callback<ModifyResult<TSchema>>): void;
     findOneAndDelete(filter: Filter<TSchema>, options: FindOneAndDeleteOptions, callback: Callback<ModifyResult<TSchema>>): void;
     /**
      * Find a document and replace it in one atomic operation. Requires a write lock for the duration of the operation.
@@ -1842,14 +1902,16 @@ export declare class CommandFailedEvent {
     duration: number;
     commandName: string;
     failure: Error;
+    serviceId?: ObjectId;
     /* Excluded from this release type: __constructor */
+    get hasServiceId(): boolean;
 }
 
 /* Excluded from this release type: CommandOperation */
 
 /** @public */
 export declare interface CommandOperationOptions extends OperationOptions, WriteConcernOptions, ExplainOptions {
-    /** Return the full server response for the command */
+    /** @deprecated This option does nothing */
     fullResponse?: boolean;
     /** Specify a read concern and level for the collection. (only MongoDB 3.2 or higher supported) */
     readConcern?: ReadConcernLike;
@@ -1865,23 +1927,7 @@ export declare interface CommandOperationOptions extends OperationOptions, Write
     noResponse?: boolean;
 }
 
-/** @public */
-export declare interface CommandOptions extends BSONSerializeOptions {
-    command?: boolean;
-    slaveOk?: boolean;
-    /** Specify read preference if command supports it */
-    readPreference?: ReadPreferenceLike;
-    raw?: boolean;
-    monitoring?: boolean;
-    fullResult?: boolean;
-    socketTimeoutMS?: number;
-    /** Session to use for the operation */
-    session?: ClientSession;
-    documentsReturnedIn?: string;
-    noResponse?: boolean;
-    willRetryWrite?: boolean;
-    writeConcern?: WriteConcernOptions | WriteConcern | W;
-}
+/* Excluded from this release type: CommandOptions */
 
 /**
  * An event indicating the start of a given
@@ -1896,7 +1942,9 @@ export declare class CommandStartedEvent {
     command: Document;
     address: string;
     connectionId?: string | number;
+    serviceId?: ObjectId;
     /* Excluded from this release type: __constructor */
+    get hasServiceId(): boolean;
 }
 
 /**
@@ -1911,7 +1959,9 @@ export declare class CommandSucceededEvent {
     duration: number;
     commandName: string;
     reply: unknown;
+    serviceId?: ObjectId;
     /* Excluded from this release type: __constructor */
+    get hasServiceId(): boolean;
 }
 
 /** @public */
@@ -1987,6 +2037,7 @@ export declare class ConnectionClosedEvent extends ConnectionPoolMonitoringEvent
     connectionId: number | '<monitor>';
     /** The reason the connection was closed */
     reason: string;
+    serviceId?: ObjectId;
     /* Excluded from this release type: __constructor */
 }
 
@@ -2009,6 +2060,8 @@ export declare type ConnectionEvents = {
     clusterTimeReceived(clusterTime: Document): void;
     close(): void;
     message(message: any): void;
+    pinned(pinType: string): void;
+    unpinned(pinType: string): void;
 };
 
 /** @public */
@@ -2039,6 +2092,7 @@ export declare interface ConnectionOptions extends SupportedNodeConnectionOption
  * @category Event
  */
 export declare class ConnectionPoolClearedEvent extends ConnectionPoolMonitoringEvent {
+    /* Excluded from this release type: serviceId */
     /* Excluded from this release type: __constructor */
 }
 
@@ -2076,6 +2130,8 @@ export declare type ConnectionPoolEvents = {
     connectionCheckedIn(event: ConnectionCheckedInEvent): void;
 } & Omit<ConnectionEvents, 'close' | 'message'>;
 
+/* Excluded from this release type: ConnectionPoolMetrics */
+
 /**
  * The base export class for all monitoring events published from the connection pool
  * @public
@@ -2099,6 +2155,8 @@ export declare interface ConnectionPoolOptions extends Omit<ConnectionOptions, '
     maxIdleTimeMS: number;
     /** The maximum amount of time operation execution should wait for a connection to become available. The default is 0 which means there is no limit. */
     waitQueueTimeoutMS: number;
+    /** If we are in load balancer mode. */
+    loadBalanced: boolean;
 }
 
 /**
@@ -2187,9 +2245,12 @@ export declare interface CreateIndexesOptions extends CommandOperationOptions {
     sparse?: boolean;
     /** Allows you to expire data on indexes applied to a data (MongoDB 2.2 or higher) */
     expireAfterSeconds?: number;
+    /** Allows users to configure the storage engine on a per-index basis when creating an index. (MongoDB 3.0 or higher) */
     storageEngine?: Document;
     /** (MongoDB 4.4. or higher) Specifies how many data-bearing members of a replica set, including the primary, must complete the index builds successfully before the primary marks the indexes as ready. This option accepts the same values for the "w" field in a write concern plus "votingMembers", which indicates all voting data-bearing nodes. */
     commitQuorum?: number | string;
+    /** Specifies the index version number, either 0 or 1. */
+    version?: number;
     weights?: Document;
     default_language?: string;
     language_override?: string;
@@ -2202,14 +2263,18 @@ export declare interface CreateIndexesOptions extends CommandOperationOptions {
     max?: number;
     bucketSize?: number;
     wildcardProjection?: Document;
+    /** Specifies that the index should exist on the target collection but should not be used by the query planner when executing operations. (MongoDB 4.4 or higher) */
+    hidden?: boolean;
 }
 
 /** @public */
 export declare const CURSOR_FLAGS: readonly ["tailable", "oplogReplay", "noCursorTimeout", "awaitData", "exhaust", "partial"];
 
-/** @public */
+/** @public
+ * @deprecated This interface is deprecated */
 export declare interface CursorCloseOptions {
     /** Bypass calling killCursors when closing the cursor. */
+    /** @deprecated  the skipKillCursors option is deprecated */
     skipKillCursors?: boolean;
 }
 
@@ -2301,7 +2366,7 @@ export declare class Db {
      * @param pipeline - An array of aggregation stages to be executed
      * @param options - Optional settings for the command
      */
-    aggregate(pipeline?: Document[], options?: AggregateOptions): AggregationCursor;
+    aggregate<T = Document>(pipeline?: Document[], options?: AggregateOptions): AggregationCursor<T>;
     /** Return the Admin db instance */
     admin(): Admin;
     /**
@@ -2310,7 +2375,7 @@ export declare class Db {
      * @param name - the collection name we wish to access.
      * @returns return the new Collection instance
      */
-    collection<TSchema extends Document = Document>(name: string): Collection<TSchema>;
+    collection<TSchema extends Document = Document>(name: string, options?: CollectionOptions): Collection<TSchema>;
     /**
      * Get all the db statistics.
      *
@@ -2451,7 +2516,10 @@ export declare class Db {
     indexInformation(name: string, callback: Callback<Document>): void;
     indexInformation(name: string, options: IndexInformationOptions): Promise<Document>;
     indexInformation(name: string, options: IndexInformationOptions, callback: Callback<Document>): void;
-    /** Unref all sockets */
+    /**
+     * Unref all sockets
+     * @deprecated This function is deprecated and will be removed in the next major version.
+     */
     unref(): void;
     /**
      * Create a new Change Stream, watching for new changes (insertions, updates,
@@ -2493,6 +2561,7 @@ export declare interface DbStatsOptions extends CommandOperationOptions {
     /** Divide the returned sizes by scale value. */
     scale?: number;
 }
+
 export { Decimal128 }
 
 /** @public */
@@ -2563,7 +2632,9 @@ export declare interface DestroyOptions {
 
 /** @public */
 export declare type DistinctOptions = CommandOperationOptions;
+
 export { Document }
+
 export { Double }
 
 /** @public */
@@ -2586,16 +2657,23 @@ export declare type DropIndexesOptions = CommandOperationOptions;
 
 /* Excluded from this release type: EncrypterOptions */
 
+/** @public */
+export declare interface EndSessionOptions {
+    /* Excluded from this release type: error */
+    force?: boolean;
+    forceClear?: boolean;
+}
+
 /** TypeScript Omit (Exclude to be specific) does not work for objects with an "any" indexed type, and breaks discriminated unions @public */
 export declare type EnhancedOmit<TRecordOrUnion, KeyUnion> = string extends keyof TRecordOrUnion ? TRecordOrUnion : TRecordOrUnion extends any ? Pick<TRecordOrUnion, Exclude<keyof TRecordOrUnion, KeyUnion>> : never;
 
 /** @public */
-export declare interface ErrorDescription {
+export declare interface ErrorDescription extends Document {
     message?: string;
     errmsg?: string;
     $err?: string;
     errorLabels?: string[];
-    [key: string]: any;
+    errInfo?: Document;
 }
 
 /** @public */
@@ -2668,11 +2746,11 @@ export declare interface FilterOperators<TValue> extends Document {
     $eq?: TValue;
     $gt?: TValue;
     $gte?: TValue;
-    $in?: TValue[];
+    $in?: ReadonlyArray<TValue>;
     $lt?: TValue;
     $lte?: TValue;
     $ne?: TValue;
-    $nin?: TValue[];
+    $nin?: ReadonlyArray<TValue>;
     $not?: TValue extends string ? FilterOperators<TValue> | RegExp : FilterOperators<TValue>;
     /**
      * When `true`, `$exists` matches the documents that contain the field,
@@ -2692,8 +2770,8 @@ export declare interface FilterOperators<TValue> extends Document {
     $near?: Document;
     $nearSphere?: Document;
     $maxDistance?: number;
-    $all?: TValue extends ReadonlyArray<any> ? any[] : never;
-    $elemMatch?: TValue extends ReadonlyArray<any> ? Document : never;
+    $all?: ReadonlyArray<any>;
+    $elemMatch?: Document;
     $size?: TValue extends ReadonlyArray<any> ? number : never;
     $bitsAllClear?: BitwiseFilter;
     $bitsAllSet?: BitwiseFilter;
@@ -2790,18 +2868,40 @@ export declare class FindCursor<TSchema = Document> extends AbstractCursor<TSche
      * In order to strictly type this function you must provide an interface
      * that represents the effect of your projection on the result documents.
      *
-     * **NOTE:** adding a projection changes the return type of the iteration of this cursor,
+     * By default chaining a projection to your cursor changes the returned type to the generic
+     * {@link Document} type.
+     * You should specify a parameterized type to have assertions on your final results.
+     *
+     * @example
+     * ```typescript
+     * // Best way
+     * const docs: FindCursor<{ a: number }> = cursor.project<{ a: number }>({ _id: 0, a: true });
+     * // Flexible way
+     * const docs: FindCursor<Document> = cursor.project({ _id: 0, a: true });
+     * ```
+     *
+     * @remarks
+     *
+     * **Note for Typescript Users:** adding a transform changes the return type of the iteration of this cursor,
      * it **does not** return a new instance of a cursor. This means when calling project,
-     * you should always assign the result to a new variable. Take note of the following example:
+     * you should always assign the result to a new variable in order to get a correctly typed cursor variable.
+     * Take note of the following example:
      *
      * @example
      * ```typescript
      * const cursor: FindCursor<{ a: number; b: string }> = coll.find();
-     * const projectCursor = cursor.project<{ a: number }>({ a: true });
+     * const projectCursor = cursor.project<{ a: number }>({ _id: 0, a: true });
      * const aPropOnlyArray: {a: number}[] = await projectCursor.toArray();
+     *
+     * // or always use chaining and save the final cursor
+     *
+     * const cursor = coll.find().project<{ a: string }>({
+     *   _id: 0,
+     *   a: { $convert: { input: '$a', to: 'string' }
+     * }});
      * ```
      */
-    project<T = TSchema>(value: Projection<T>): FindCursor<T>;
+    project<T extends Document = Document>(value: Document): FindCursor<T>;
     /**
      * Sets the sort order of the cursor query.
      *
@@ -2913,14 +3013,17 @@ export declare class FindOperators {
     arrayFilters(arrayFilters: Document[]): this;
 }
 
-/** @public */
-export declare interface FindOptions<TSchema = Document> extends CommandOperationOptions {
+/**
+ * @public
+ * @typeParam TSchema - Unused schema definition, deprecated usage, only specify `FindOptions` with no generic
+ */
+export declare interface FindOptions<TSchema extends Document = Document> extends CommandOperationOptions {
     /** 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. */
     sort?: Sort;
     /** The fields to return in the query. Object of fields to either include or exclude (one of, not both), `{'a':1, 'b': 1}` **or** `{'a': 0, 'b': 0}` */
-    projection?: Projection<TSchema>;
+    projection?: Document;
     /** Set to skip N documents ahead in your query (useful for pagination). */
     skip?: number;
     /** Tell the query to use specific indexes in the query. Object of indexes to use, `{'_id':1}` */
@@ -3059,7 +3162,7 @@ export declare interface GridFSBucketOptions extends WriteConcernOptions {
  * Do not instantiate this class directly. Use `openDownloadStream()` instead.
  * @public
  */
-export declare class GridFSBucketReadStream extends Readable {
+export declare class GridFSBucketReadStream extends Readable implements NodeJS.ReadableStream {
     /* Excluded from this release type: s */
     /**
      * An error occurred
@@ -3140,7 +3243,7 @@ export declare interface GridFSBucketReadStreamOptionsWithRevision extends GridF
  * Do not instantiate this class directly. Use `openUploadStream()` instead.
  * @public
  */
-export declare class GridFSBucketWriteStream extends Writable {
+export declare class GridFSBucketWriteStream extends Writable implements NodeJS.WritableStream {
     bucket: GridFSBucket;
     chunks: Collection<GridFSChunk>;
     filename: string;
@@ -3178,10 +3281,10 @@ export declare class GridFSBucketWriteStream extends Writable {
      * @param callback - Function to call when the chunk was added to the buffer, or if the entire chunk was persisted to MongoDB if this chunk caused a flush.
      * @returns False if this write required flushing a chunk to MongoDB. True otherwise.
      */
-    write(chunk: Buffer): boolean;
-    write(chunk: Buffer, callback: Callback<void>): boolean;
-    write(chunk: Buffer, encoding: BufferEncoding | undefined): boolean;
-    write(chunk: Buffer, encoding: BufferEncoding | undefined, callback: Callback<void>): boolean;
+    write(chunk: Buffer | string): boolean;
+    write(chunk: Buffer | string, callback: Callback<void>): boolean;
+    write(chunk: Buffer | string, encoding: BufferEncoding | undefined): boolean;
+    write(chunk: Buffer | string, encoding: BufferEncoding | undefined, callback: Callback<void>): boolean;
     /**
      * Places this write stream into an aborted state (all future writes fail)
      * and deletes all chunks that have already been written.
@@ -3265,7 +3368,7 @@ export declare class HostAddress {
 }
 
 /** @public */
-export declare interface IndexDescription {
+export declare interface IndexDescription extends Pick<CreateIndexesOptions, 'background' | 'unique' | 'partialFilterExpression' | 'sparse' | 'hidden' | 'expireAfterSeconds' | 'storageEngine' | 'version' | 'weights' | 'default_language' | 'language_override' | 'textIndexVersion' | '2dsphereIndexVersion' | 'bits' | 'min' | 'max' | 'bucketSize' | 'wildcardProjection'> {
     collation?: CollationOptions;
     name?: string;
     key: Document;
@@ -3326,6 +3429,7 @@ export declare interface InsertOneResult<TSchema = Document> {
     /** The identifier that was inserted. If the server generated the identifier, this value will be null as the driver does not have access to that data */
     insertedId: InferIdType<TSchema>;
 }
+
 export { Int32 }
 
 /** @public */
@@ -3354,6 +3458,8 @@ export declare type IsAny<Type, ResultIfAny, ResultIfNotAny> = true extends fals
 
 /* Excluded from this release type: kCancelled_2 */
 
+/* Excluded from this release type: kCheckedOut */
+
 /* Excluded from this release type: kClosed */
 
 /* Excluded from this release type: kClosed_2 */
@@ -3386,6 +3492,8 @@ export declare type KeysOfOtherType<TSchema, Type> = {
 
 /* Excluded from this release type: kFilter */
 
+/* Excluded from this release type: kFullResult */
+
 /* Excluded from this release type: kGeneration */
 
 /* Excluded from this release type: kGeneration_2 */
@@ -3410,6 +3518,8 @@ export declare type KeysOfOtherType<TSchema, Type> = {
 
 /* Excluded from this release type: kMessageStream */
 
+/* Excluded from this release type: kMetrics */
+
 /* Excluded from this release type: kMinPoolSizeTimer */
 
 /* Excluded from this release type: kMode */
@@ -3428,12 +3538,14 @@ export declare type KeysOfOtherType<TSchema, Type> = {
 
 /* Excluded from this release type: kOptions_3 */
 
-/* Excluded from this release type: kParent */
-
 /* Excluded from this release type: kPermits */
 
+/* Excluded from this release type: kPinnedConnection */
+
 /* Excluded from this release type: kPipeline */
 
+/* Excluded from this release type: kProcessingWaitQueue */
+
 /* Excluded from this release type: kQueue */
 
 /* Excluded from this release type: kResumeQueue */
@@ -3446,8 +3558,12 @@ export declare type KeysOfOtherType<TSchema, Type> = {
 
 /* Excluded from this release type: kServer_2 */
 
+/* Excluded from this release type: kServerError */
+
 /* Excluded from this release type: kServerSession */
 
+/* Excluded from this release type: kServiceGenerations */
+
 /* Excluded from this release type: kSession */
 
 /* Excluded from this release type: kSession_2 */
@@ -3473,7 +3589,7 @@ export declare const LEGAL_TCP_SOCKET_OPTIONS: readonly ["family", "hints", "loc
 export declare const LEGAL_TLS_SOCKET_OPTIONS: readonly ["ALPNProtocols", "ca", "cert", "checkServerIdentity", "ciphers", "crl", "ecdhCurve", "key", "minDHSize", "passphrase", "pfx", "rejectUnauthorized", "secureContext", "secureProtocol", "servername", "session"];
 
 /** @public */
-export declare class ListCollectionsCursor<T extends Pick<CollectionInfo, 'name' | 'type'> | CollectionInfo = CollectionInfo> extends AbstractCursor<T> {
+export declare class ListCollectionsCursor<T extends Pick<CollectionInfo, 'name' | 'type'> | CollectionInfo = Pick<CollectionInfo, 'name' | 'type'> | CollectionInfo> extends AbstractCursor<T> {
     parent: Db;
     filter: Document;
     options?: ListCollectionsOptions;
@@ -3614,7 +3730,9 @@ export declare interface LoggerOptions {
     logger?: LoggerFunction;
     loggerLevel?: LoggerLevel;
 }
+
 export { Long }
+
 export { Map_2 as Map }
 
 /** @public */
@@ -3654,6 +3772,7 @@ export declare interface MapReduceOptions<TKey = ObjectId, TValue = Document> ex
 
 /** @public */
 export declare type MatchKeysAndValues<TSchema> = Readonly<Partial<TSchema>> & Record<string, any>;
+
 export { MaxKey }
 
 /* Excluded from this release type: MessageStream */
@@ -3663,7 +3782,7 @@ export { MinKey }
 
 /** @public */
 export declare interface ModifyResult<TSchema = Document> {
-    value?: TSchema;
+    value: TSchema | null;
     lastErrorObject?: Document;
     ok: 0 | 1;
 }
@@ -3671,6 +3790,32 @@ export declare interface ModifyResult<TSchema = Document> {
 /** @public */
 export declare const MONGO_CLIENT_EVENTS: readonly ["connectionPoolCreated", "connectionPoolClosed", "connectionCreated", "connectionReady", "connectionClosed", "connectionCheckOutStarted", "connectionCheckOutFailed", "connectionCheckedOut", "connectionCheckedIn", "connectionPoolCleared", ...("error" | "close" | "commandStarted" | "commandSucceeded" | "commandFailed" | "serverHeartbeatStarted" | "serverHeartbeatSucceeded" | "serverHeartbeatFailed" | "timeout" | "serverOpening" | "serverClosed" | "serverDescriptionChanged" | "topologyOpening" | "topologyClosed" | "topologyDescriptionChanged")[]];
 
+/**
+ * An error generated when the driver API is used incorrectly
+ *
+ * @privateRemarks
+ * Should **never** be directly instantiated
+ *
+ * @public
+ * @category Error
+ */
+export declare class MongoAPIError extends MongoDriverError {
+    constructor(message: string);
+    get name(): string;
+}
+
+/**
+ * An error generated when a batch command is reexecuted after one of the commands in the batch
+ * has failed
+ *
+ * @public
+ * @category Error
+ */
+export declare class MongoBatchReExecutionError extends MongoAPIError {
+    constructor(message?: string);
+    get name(): string;
+}
+
 /**
  * An error indicating an unsuccessful Bulk Write
  * @public
@@ -3678,8 +3823,14 @@ export declare const MONGO_CLIENT_EVENTS: readonly ["connectionPoolCreated", "co
  */
 export declare class MongoBulkWriteError extends MongoServerError {
     result: BulkWriteResult;
+    writeErrors: OneOrMore<WriteError>;
+    err?: WriteConcernError;
     /** Creates a new MongoBulkWriteError */
-    constructor(error: AnyError, result: BulkWriteResult);
+    constructor(error: {
+        message: string;
+        code: number;
+        writeErrors?: WriteError[];
+    } | WriteConcernError | AnyError, result: BulkWriteResult);
     get name(): string;
     /** Number of documents inserted. */
     get insertedCount(): number;
@@ -3701,6 +3852,17 @@ export declare class MongoBulkWriteError extends MongoServerError {
     };
 }
 
+/**
+ * An error generated when a ChangeStream operation fails to execute.
+ *
+ * @public
+ * @category Error
+ */
+export declare class MongoChangeStreamError extends MongoRuntimeError {
+    constructor(message: string);
+    get name(): string;
+}
+
 /**
  * The **MongoClient** class is a class that allows for making Connections to MongoDB.
  * @public
@@ -3838,7 +4000,7 @@ export declare interface MongoClientOptions extends BSONSerializeOptions, Suppor
     ssl?: boolean;
     /** Specifies the location of a local TLS Certificate */
     tlsCertificateFile?: string;
-    /** Specifies the location of a local .pem file that contains either the client’s TLS/SSL certificate or the client’s TLS/SSL certificate and key. */
+    /** Specifies the location of a local .pem file that contains either the client's TLS/SSL certificate and key or only the client's TLS/SSL key when tlsCertificateFile is used to provide the certificate. */
     tlsCertificateKeyFile?: string;
     /** Specifies the password to de-crypt the tlsCertificateKeyFile. */
     tlsCertificateKeyFilePassword?: string;
@@ -3854,8 +4016,8 @@ export declare interface MongoClientOptions extends BSONSerializeOptions, Suppor
     connectTimeoutMS?: number;
     /** The time in milliseconds to attempt a send or receive on a socket before the attempt times out. */
     socketTimeoutMS?: number;
-    /** Comma-delimited string of compressors to enable network compression for communication between this client and a mongod/mongos instance. */
-    compressors?: CompressorName[];
+    /** An array or comma-delimited string of compressors to enable network compression for communication between this client and a mongod/mongos instance. */
+    compressors?: CompressorName[] | string;
     /** An integer that specifies the compression level if using zlib for network compression. */
     zlibCompressionLevel?: 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | undefined;
     /** The maximum number of connections in the connection pool. */
@@ -3883,12 +4045,7 @@ export declare interface MongoClientOptions extends BSONSerializeOptions, Suppor
     /** Specify the authentication mechanism that MongoDB will use to authenticate the connection. */
     authMechanism?: AuthMechanism;
     /** Specify properties for the specified authMechanism as a comma-separated list of colon-separated key-value pairs. */
-    authMechanismProperties?: {
-        SERVICE_NAME?: string;
-        CANONICALIZE_HOST_NAME?: boolean;
-        SERVICE_REALM?: string;
-        [key: string]: any;
-    };
+    authMechanismProperties?: AuthMechanismProperties;
     /** The size (in milliseconds) of the latency window for selecting among multiple suitable MongoDB instances. */
     localThresholdMS?: number;
     /** Specifies how long (in milliseconds) to block for server selection before throwing an exception.  */
@@ -3905,6 +4062,8 @@ export declare interface MongoClientOptions extends BSONSerializeOptions, Suppor
     retryWrites?: boolean;
     /** Allow a driver to force a Single topology type with a connection string containing one host */
     directConnection?: boolean;
+    /** Instruct the driver it is connecting to a load balancer fronting a mongos like service */
+    loadBalanced?: boolean;
     /** The write concern w value */
     w?: W;
     /** The write concern timeout */
@@ -3969,6 +4128,19 @@ export declare interface MongoClientOptions extends BSONSerializeOptions, Suppor
 
 /* Excluded from this release type: MongoClientPrivate */
 
+/**
+ * An error generated when a feature that is not enabled or allowed for the current server
+ * configuration is used
+ *
+ *
+ * @public
+ * @category Error
+ */
+export declare class MongoCompatibilityError extends MongoAPIError {
+    constructor(message: string);
+    get name(): string;
+}
+
 /**
  * A representation of the credentials used by MongoDB
  * @public
@@ -3983,7 +4155,7 @@ export declare class MongoCredentials {
     /** The method used to authenticate */
     readonly mechanism: AuthMechanism;
     /** Special properties used by some types of auth mechanisms */
-    readonly mechanismProperties: Document;
+    readonly mechanismProperties: AuthMechanismProperties;
     constructor(options: MongoCredentialsOptions);
     /** Determines if two MongoCredentials objects are equivalent */
     equals(other: MongoCredentials): boolean;
@@ -4005,7 +4177,30 @@ export declare interface MongoCredentialsOptions {
     source: string;
     db?: string;
     mechanism?: AuthMechanism;
-    mechanismProperties: Document;
+    mechanismProperties: AuthMechanismProperties;
+}
+
+/**
+ * An error thrown when an attempt is made to read from a cursor that has been exhausted
+ *
+ * @public
+ * @category Error
+ */
+export declare class MongoCursorExhaustedError extends MongoAPIError {
+    constructor(message?: string);
+    get name(): string;
+}
+
+/**
+ * An error thrown when the user attempts to add options to a cursor that has already been
+ * initialized
+ *
+ * @public
+ * @category Error
+ */
+export declare class MongoCursorInUseError extends MongoAPIError {
+    constructor(message?: string);
+    get name(): string;
 }
 
 /** @public */
@@ -4024,6 +4219,18 @@ export declare class MongoDBNamespace {
     static fromString(namespace?: string): MongoDBNamespace;
 }
 
+/**
+ * An error generated when the driver fails to decompress
+ * data received from the server.
+ *
+ * @public
+ * @category Error
+ */
+export declare class MongoDecompressionError extends MongoRuntimeError {
+    constructor(message: string);
+    get name(): string;
+}
+
 /**
  * An error generated by the driver
  *
@@ -4031,7 +4238,6 @@ export declare class MongoDBNamespace {
  * @category Error
  */
 export declare class MongoDriverError extends MongoError {
-    code?: string;
     constructor(message: string);
     get name(): string;
 }
@@ -4045,6 +4251,11 @@ export declare class MongoDriverError extends MongoError {
  */
 export declare class MongoError extends Error {
     /* Excluded from this release type: [kErrorLabels] */
+    /**
+     * This is a number in MongoServerError and a string in MongoDriverError
+     * @privateRemarks
+     * Define the type override on the subclasses when we can use the override keyword
+     */
     code?: number | string;
     topologyVersion?: TopologyVersion;
     constructor(message: string | Error);
@@ -4062,6 +4273,89 @@ export declare class MongoError extends Error {
     get errorLabels(): string[];
 }
 
+/**
+ * An error generated when the user attempts to operate
+ * on a session that has expired or has been closed.
+ *
+ * @public
+ * @category Error
+ */
+export declare class MongoExpiredSessionError extends MongoAPIError {
+    constructor(message?: string);
+    get name(): string;
+}
+
+/**
+ * An error generated when a malformed or invalid chunk is
+ * encountered when reading from a GridFSStream.
+ *
+ * @public
+ * @category Error
+ */
+export declare class MongoGridFSChunkError extends MongoRuntimeError {
+    constructor(message: string);
+    get name(): string;
+}
+
+/** An error generated when a GridFSStream operation fails to execute.
+ *
+ * @public
+ * @category Error
+ */
+export declare class MongoGridFSStreamError extends MongoRuntimeError {
+    constructor(message: string);
+    get name(): string;
+}
+
+/**
+ * An error generated when the user supplies malformed or unexpected arguments
+ * or when a required argument or field is not provided.
+ *
+ *
+ * @public
+ * @category Error
+ */
+export declare class MongoInvalidArgumentError extends MongoAPIError {
+    constructor(message: string);
+    get name(): string;
+}
+
+/**
+ * A error generated when the user attempts to authenticate
+ * via Kerberos, but fails to connect to the Kerberos client.
+ *
+ * @public
+ * @category Error
+ */
+export declare class MongoKerberosError extends MongoRuntimeError {
+    constructor(message: string);
+    get name(): string;
+}
+
+/**
+ * An error generated when the user fails to provide authentication credentials before attempting
+ * to connect to a mongo server instance.
+ *
+ *
+ * @public
+ * @category Error
+ */
+export declare class MongoMissingCredentialsError extends MongoAPIError {
+    constructor(message: string);
+    get name(): string;
+}
+
+/**
+ * An error generated when a required module or dependency is not present in the local environment
+ *
+ * @public
+ * @category Error
+ */
+export declare class MongoMissingDependencyError extends MongoAPIError {
+    constructor(message: string);
+    get name(): string;
+}
+
 /**
  * An error indicating an issue with the network, including TCP errors and timeouts.
  * @public
@@ -4069,12 +4363,16 @@ export declare class MongoError extends Error {
  */
 export declare class MongoNetworkError extends MongoError {
     /* Excluded from this release type: [kBeforeHandshake] */
-    constructor(message: string | Error, options?: {
-        beforeHandshake?: boolean;
-    });
+    constructor(message: string | Error, options?: MongoNetworkErrorOptions);
     get name(): string;
 }
 
+/** @public */
+export declare interface MongoNetworkErrorOptions {
+    /** Indicates the timeout happened before a connection handshake completed */
+    beforeHandshake: boolean;
+}
+
 /**
  * An error indicating a network timeout occurred
  * @public
@@ -4084,27 +4382,35 @@ export declare class MongoNetworkError extends MongoError {
  * CSFLE has a dependency on this error with an instanceof check
  */
 export declare class MongoNetworkTimeoutError extends MongoNetworkError {
-    constructor(message: string, options?: MongoNetworkTimeoutErrorOptions);
+    constructor(message: string, options?: MongoNetworkErrorOptions);
     get name(): string;
 }
 
-/** @public */
-export declare interface MongoNetworkTimeoutErrorOptions {
-    /** Indicates the timeout happened before a connection handshake completed */
-    beforeHandshake: boolean;
+/**
+ * An error thrown when the user attempts to operate on a database or collection through a MongoClient
+ * that has not yet successfully called the "connect" method
+ *
+ * @public
+ * @category Error
+ */
+export declare class MongoNotConnectedError extends MongoAPIError {
+    constructor(message: string);
+    get name(): string;
 }
 
 /**
  * Mongo Client Options
  * @public
  */
-export declare interface MongoOptions extends Required<Pick<MongoClientOptions, 'autoEncryption' | 'compressors' | 'connectTimeoutMS' | 'directConnection' | 'driverInfo' | 'forceServerObjectId' | 'minHeartbeatFrequencyMS' | 'heartbeatFrequencyMS' | 'keepAlive' | 'keepAliveInitialDelay' | 'localThresholdMS' | 'logger' | 'maxIdleTimeMS' | 'maxPoolSize' | 'minPoolSize' | 'monitorCommands' | 'noDelay' | 'pkFactory' | 'promiseLibrary' | 'raw' | 'replicaSet' | 'retryReads' | 'retryWrites' | 'serverSelectionTimeoutMS' | 'socketTimeoutMS' | 'tlsAllowInvalidCertificates' | 'tlsAllowInvalidHostnames' | 'tlsInsecure' | 'waitQueueTimeoutMS' | 'zlibCompressionLevel'>>, SupportedNodeConnectionOptions {
+export declare interface MongoOptions extends Required<Pick<MongoClientOptions, 'autoEncryption' | 'connectTimeoutMS' | 'directConnection' | 'driverInfo' | 'forceServerObjectId' | 'minHeartbeatFrequencyMS' | 'heartbeatFrequencyMS' | 'keepAlive' | 'keepAliveInitialDelay' | 'localThresholdMS' | 'logger' | 'maxIdleTimeMS' | 'maxPoolSize' | 'minPoolSize' | 'monitorCommands' | 'noDelay' | 'pkFactory' | 'promiseLibrary' | 'raw' | 'replicaSet' | 'retryReads' | 'retryWrites' | 'serverSelectionTimeoutMS' | 'socketTimeoutMS' | 'tlsAllowInvalidCertificates' | 'tlsAllowInvalidHostnames' | 'tlsInsecure' | 'waitQueueTimeoutMS' | 'zlibCompressionLevel'>>, SupportedNodeConnectionOptions {
     hosts: HostAddress[];
     srvHost?: string;
     credentials?: MongoCredentials;
     readPreference: ReadPreference;
     readConcern: ReadConcern;
+    loadBalanced: boolean;
     serverApi: ServerApi;
+    compressors: CompressorName[];
     writeConcern: WriteConcern;
     dbName: string;
     metadata: ClientMetadata;
@@ -4147,6 +4453,33 @@ export declare class MongoParseError extends MongoDriverError {
     get name(): string;
 }
 
+/**
+ * An error generated when the driver encounters unexpected input
+ * or reaches an unexpected/invalid internal state
+ *
+ * @privateRemarks
+ * Should **never** be directly instantiated.
+ *
+ * @public
+ * @category Error
+ */
+export declare class MongoRuntimeError extends MongoDriverError {
+    constructor(message: string);
+    get name(): string;
+}
+
+/**
+ * An error generated when an attempt is made to operate
+ * on a closed/closing server.
+ *
+ * @public
+ * @category Error
+ */
+export declare class MongoServerClosedError extends MongoAPIError {
+    constructor(message?: string);
+    get name(): string;
+}
+
 /**
  * An error coming from the mongo server
  *
@@ -4154,10 +4487,12 @@ export declare class MongoParseError extends MongoDriverError {
  * @category Error
  */
 export declare class MongoServerError extends MongoError {
-    code?: number;
     codeName?: string;
     writeConcernError?: Document;
-    constructor(message: Error | ErrorDescription);
+    errInfo?: Document;
+    ok?: number;
+    [key: string]: any;
+    constructor(message: ErrorDescription);
     get name(): string;
 }
 
@@ -4183,6 +4518,30 @@ export declare class MongoSystemError extends MongoError {
     get name(): string;
 }
 
+/**
+ * An error generated when an attempt is made to operate on a
+ * dropped, or otherwise unavailable, database.
+ *
+ * @public
+ * @category Error
+ */
+export declare class MongoTopologyClosedError extends MongoAPIError {
+    constructor(message?: string);
+    get name(): string;
+}
+
+/**
+ * An error generated when the user makes a mistake in the usage of transactions.
+ * (e.g. attempting to commit a transaction with a readPreference other than primary)
+ *
+ * @public
+ * @category Error
+ */
+export declare class MongoTransactionError extends MongoAPIError {
+    constructor(message: string);
+    get name(): string;
+}
+
 /**
  * An error thrown when the server reports a writeConcernError
  * @public
@@ -4191,7 +4550,8 @@ export declare class MongoSystemError extends MongoError {
 export declare class MongoWriteConcernError extends MongoServerError {
     /** The result document (provided if ok: 1) */
     result?: Document;
-    constructor(message: ErrorDescription, result: Document);
+    errInfo?: Document;
+    constructor(message: ErrorDescription, result?: Document);
     get name(): string;
 }
 
@@ -4225,10 +4585,17 @@ export declare type NotAcceptedFields<TSchema, FieldType> = {
 
 /** @public */
 export declare type NumericType = IntegerType | Decimal128 | Double;
+
+/**
+ * @public
+ * @deprecated Please use `ObjectId`
+ */
+export declare const ObjectID: typeof ObjectId;
+
 export { ObjectId }
 
 /** @public */
-export declare type OneOrMore<T> = T | T[];
+export declare type OneOrMore<T> = T | ReadonlyArray<T>;
 
 /** @public */
 export declare type OnlyFieldsOfType<TSchema, FieldType = any, AssignableType = FieldType> = IsAny<TSchema[keyof TSchema], Record<string, FieldType>, AcceptedFields<TSchema, FieldType, AssignableType> & NotAcceptedFields<TSchema, FieldType> & Record<string, AssignableType>>;
@@ -4242,6 +4609,7 @@ export declare interface OperationOptions extends BSONSerializeOptions {
     willRetryWrites?: boolean;
     /** The preferred read preference (ReadPreference.primary, ReadPreference.primary_preferred, ReadPreference.secondary, ReadPreference.secondary_preferred, ReadPreference.nearest). */
     readPreference?: ReadPreferenceLike;
+    /* Excluded from this release type: bypassPinningCheck */
 }
 
 /* Excluded from this release type: OperationParent */
@@ -4302,19 +4670,18 @@ export declare type ProfilingLevel = typeof ProfilingLevel[keyof typeof Profilin
 /** @public */
 export declare type ProfilingLevelOptions = CommandOperationOptions;
 
-/** @public */
-export declare type Projection<TSchema> = {
-    [Key in keyof TSchema]?: ProjectionOperators | 0 | 1 | boolean;
-} & Partial<Record<string, ProjectionOperators | 0 | 1 | boolean>>;
+/**
+ * @public
+ * Projection is flexible to permit the wide array of aggregation operators
+ * @deprecated since v4.1.0: Since projections support all aggregation operations we have no plans to narrow this type further
+ */
+export declare type Projection<TSchema extends Document = Document> = Document;
 
-/** @public */
-export declare interface ProjectionOperators extends Document {
-    $elemMatch?: Document;
-    $slice?: number | [number, number];
-    $meta?: string;
-    /** @deprecated Since MongoDB 3.2, Use FindCursor#max */
-    $max?: any;
-}
+/**
+ * @public
+ * @deprecated since v4.1.0: Since projections support all aggregation operations we have no plans to narrow this type further
+ */
+export declare type ProjectionOperators = Document;
 
 /**
  * Global promise store allowing user-provided promises
@@ -4334,7 +4701,7 @@ export { Promise_2 as Promise }
 export declare type PullAllOperator<TSchema> = ({
     readonly [key in KeysOfAType<TSchema, ReadonlyArray<any>>]?: TSchema[key];
 } & NotAcceptedFields<TSchema, ReadonlyArray<any>>) & {
-    readonly [key: string]: any[];
+    readonly [key: string]: ReadonlyArray<any>;
 };
 
 /** @public */
@@ -4855,6 +5222,7 @@ export declare const ServerType: Readonly<{
     readonly RSOther: "RSOther";
     readonly RSGhost: "RSGhost";
     readonly Unknown: "Unknown";
+    readonly LoadBalancer: "LoadBalancer";
 }>;
 
 /** @public */
@@ -4909,6 +5277,7 @@ export declare class StreamDescription {
     compressors: CompressorName[];
     compressor?: CompressorName;
     logicalSessionTimeoutMinutes?: number;
+    loadBalanced: boolean;
     __nodejs_mock_server__?: boolean;
     zlibCompressionLevel?: number;
     constructor(address: string, options?: StreamDescriptionOptions);
@@ -4918,6 +5287,8 @@ export declare class StreamDescription {
 /** @public */
 export declare interface StreamDescriptionOptions {
     compressors?: CompressorName[];
+    logicalSessionTimeoutMinutes?: number;
+    loadBalanced: boolean;
 }
 
 /** @public */
@@ -4948,6 +5319,7 @@ export declare interface TimeSeriesCollectionOptions extends Document {
     metaField?: string;
     granularity?: string;
 }
+
 export { Timestamp }
 
 /* Excluded from this release type: Topology */
@@ -5058,6 +5430,7 @@ export declare interface TopologyOptions extends BSONSerializeOptions, ServerOpt
     /* Excluded from this release type: srvPoller */
     /** Indicates that a client should directly connect to a node without attempting to discover its topology type */
     directConnection: boolean;
+    loadBalanced: boolean;
     metadata: ClientMetadata;
     /** MongoDB server API version */
     serverApi?: ServerApi;
@@ -5075,6 +5448,7 @@ export declare const TopologyType: Readonly<{
     readonly ReplicaSetWithPrimary: "ReplicaSetWithPrimary";
     readonly Sharded: "Sharded";
     readonly Unknown: "Unknown";
+    readonly LoadBalanced: "LoadBalanced";
 }>;
 
 /** @public */
@@ -5105,6 +5479,7 @@ export declare class Transaction {
      * @returns Whether this session is presently in a transaction
      */
     get isActive(): boolean;
+    get isCommitted(): boolean;
     /* Excluded from this release type: transition */
     /* Excluded from this release type: pinServer */
     /* Excluded from this release type: unpinServer */
@@ -5494,19 +5869,27 @@ export declare class WriteConcern {
  * @category Error
  */
 export declare class WriteConcernError {
-    err: MongoServerError;
-    constructor(err: MongoServerError);
+    /* Excluded from this release type: [kServerError] */
+    constructor(error: WriteConcernErrorData);
     /** Write concern error code. */
     get code(): number | undefined;
     /** Write concern error message. */
-    get errmsg(): string;
-    toJSON(): {
-        code?: number;
-        errmsg: string;
-    };
+    get errmsg(): string | undefined;
+    /** Write concern error info. */
+    get errInfo(): Document | undefined;
+    /** @deprecated The `err` prop that contained a MongoServerError has been deprecated. */
+    get err(): WriteConcernErrorData;
+    toJSON(): WriteConcernErrorData;
     toString(): string;
 }
 
+/** @public */
+export declare interface WriteConcernErrorData {
+    code: number;
+    errmsg: string;
+    errInfo?: Document;
+}
+
 /** @public */
 export declare interface WriteConcernOptions {
     /** Write Concern as an object */
@@ -5543,6 +5926,8 @@ export declare class WriteError {
     get index(): number;
     /** WriteError message. */
     get errmsg(): string | undefined;
+    /** WriteError details. */
+    get errInfo(): Document | undefined;
     /** Returns the underlying operation that caused the error */
     getOperation(): Document;
     toJSON(): {