mongodb 6.18.0 → 6.19.0-dev.20250828.sha.41034f16

package/src/client-side-encryption/client_encryption.ts

@@ -749,7 +749,8 @@ export class ClientEncryption {
     expressionMode: boolean,
     options: ClientEncryptionEncryptOptions
   ): Promise<Binary> {
-    const { algorithm, keyId, keyAltName, contentionFactor, queryType, rangeOptions } = options;
+    const { algorithm, keyId, keyAltName, contentionFactor, queryType, rangeOptions, textOptions } =
+      options;
     const contextOptions: ExplicitEncryptionContextOptions = {
       expressionMode,
       algorithm
@@ -782,6 +783,10 @@ export class ClientEncryption {
       contextOptions.rangeOptions = serialize(rangeOptions);
     }
 
+    if (typeof textOptions === 'object') {
+      contextOptions.textOptions = serialize(textOptions);
+    }
+
     const valueBuffer = serialize({ v: value });
     const stateMachine = new StateMachine({
       proxyOptions: this._proxyOptions,
@@ -812,7 +817,8 @@ export interface ClientEncryptionEncryptOptions {
     | 'AEAD_AES_256_CBC_HMAC_SHA_512-Random'
     | 'Indexed'
     | 'Unindexed'
-    | 'Range';
+    | 'Range'
+    | 'TextPreview';
 
   /**
    * The id of the Binary dataKey to use for encryption
@@ -830,10 +836,53 @@ export interface ClientEncryptionEncryptOptions {
   /**
    * The query type.
    */
-  queryType?: 'equality' | 'range';
+  queryType?: 'equality' | 'range' | 'prefixPreview' | 'suffixPreview' | 'substringPreview';
 
   /** The index options for a Queryable Encryption field supporting "range" queries.*/
   rangeOptions?: RangeOptions;
+
+  /**
+   * Options for a Queryable Encryption field supporting text queries.  Only valid when `algorithm` is `TextPreview`.
+   *
+   * @experimental Public Technical Preview: `textPreview` is an experimental feature and may break at any time.
+   */
+  textOptions?: TextQueryOptions;
+}
+
+/**
+ * Options for a Queryable Encryption field supporting text queries.
+ *
+ * @public
+ * @experimental Public Technical Preview: `textPreview` is an experimental feature and may break at any time.
+ */
+export interface TextQueryOptions {
+  /** Indicates that text indexes for this field are case sensitive */
+  caseSensitive: boolean;
+  /** Indicates that text indexes for this field are diacritic sensitive. */
+  diacriticSensitive: boolean;
+
+  prefix?: {
+    /** The maximum allowed query length. */
+    strMaxQueryLength: Int32 | number;
+    /** The minimum allowed query length. */
+    strMinQueryLength: Int32 | number;
+  };
+
+  suffix?: {
+    /** The maximum allowed query length. */
+    strMaxQueryLength: Int32 | number;
+    /** The minimum allowed query length. */
+    strMinQueryLength: Int32 | number;
+  };
+
+  substring?: {
+    /** The maximum allowed length to insert. */
+    strMaxLength: Int32 | number;
+    /** The maximum allowed query length. */
+    strMaxQueryLength: Int32 | number;
+    /** The minimum allowed query length. */
+    strMinQueryLength: Int32 | number;
+  };
 }
 
 /**

package/src/client-side-encryption/state_machine.ts

@@ -106,7 +106,7 @@ declare module 'mongodb-client-encryption' {
  */
 export type ClientEncryptionTlsOptions = Pick<
   MongoClientOptions,
-  'tlsCAFile' | 'tlsCertificateKeyFile' | 'tlsCertificateKeyFilePassword'
+  'tlsCAFile' | 'tlsCertificateKeyFile' | 'tlsCertificateKeyFilePassword' | 'secureContext'
 >;
 
 /** @public */
@@ -521,6 +521,10 @@ export class StateMachine {
     tlsOptions: ClientEncryptionTlsOptions,
     options: tls.ConnectionOptions
   ): Promise<void> {
+    // If a secureContext is provided, ensure it is set.
+    if (tlsOptions.secureContext) {
+      options.secureContext = tlsOptions.secureContext;
+    }
     if (tlsOptions.tlsCertificateKeyFile) {
       const cert = await fs.readFile(tlsOptions.tlsCertificateKeyFile);
       options.cert = options.key = cert;

package/src/cmap/connection.ts

@@ -92,7 +92,6 @@ export interface CommandOptions extends BSONSerializeOptions {
   session?: ClientSession;
   documentsReturnedIn?: string;
   noResponse?: boolean;
-  omitReadPreference?: boolean;
   omitMaxTimeMS?: boolean;
 
   // TODO(NODE-2802): Currently the CommandOptions take a property willRetryWrite which is a hint

package/src/collection.ts

@@ -1,5 +1,10 @@
 import { type BSONSerializeOptions, type Document, resolveBSONOptions } from './bson';
-import type { AnyBulkWriteOperation, BulkWriteOptions, BulkWriteResult } from './bulk/common';
+import type {
+  AnyBulkWriteOperation,
+  BulkOperationBase,
+  BulkWriteOptions,
+  BulkWriteResult
+} from './bulk/common';
 import { OrderedBulkOperation } from './bulk/ordered';
 import { UnorderedBulkOperation } from './bulk/unordered';
 import { ChangeStream, type ChangeStreamDocument, type ChangeStreamOptions } from './change_stream';
@@ -11,7 +16,8 @@ import {
   type ListSearchIndexesOptions
 } from './cursor/list_search_indexes_cursor';
 import type { Db } from './db';
-import { MongoInvalidArgumentError, MongoOperationTimeoutError } from './error';
+import { MongoAPIError, MongoInvalidArgumentError, MongoOperationTimeoutError } from './error';
+import { type ExplainCommandOptions, type ExplainVerbosityLike } from './explain';
 import type { MongoClient, PkFactory } from './mongo_client';
 import type {
   Abortable,
@@ -24,7 +30,6 @@ import type {
   WithoutId
 } from './mongo_types';
 import type { AggregateOptions } from './operations/aggregate';
-import { BulkWriteOperation } from './operations/bulk_write';
 import { CountOperation, type CountOptions } from './operations/count';
 import {
   DeleteManyOperation,
@@ -33,13 +38,13 @@ import {
   type DeleteResult
 } from './operations/delete';
 import { DistinctOperation, type DistinctOptions } from './operations/distinct';
-import { DropCollectionOperation, type DropCollectionOptions } from './operations/drop';
+import { type DropCollectionOptions } from './operations/drop';
 import {
   EstimatedDocumentCountOperation,
   type EstimatedDocumentCountOptions
 } from './operations/estimated_document_count';
-import { executeOperation } from './operations/execute_operation';
-import type { FindOptions } from './operations/find';
+import { autoConnect, executeOperation } from './operations/execute_operation';
+import { type FindOneOptions, type FindOptions } from './operations/find';
 import {
   FindOneAndDeleteOperation,
   type FindOneAndDeleteOptions,
@@ -61,15 +66,12 @@ import {
   type ListIndexesOptions
 } from './operations/indexes';
 import {
-  InsertManyOperation,
   type InsertManyResult,
   InsertOneOperation,
   type InsertOneOptions,
   type InsertOneResult
 } from './operations/insert';
-import { IsCappedOperation } from './operations/is_capped';
 import type { Hint, OperationOptions } from './operations/operation';
-import { OptionsOperation } from './operations/options_operation';
 import { RenameOperation, type RenameOptions } from './operations/rename';
 import {
   CreateSearchIndexesOperation,
@@ -305,14 +307,31 @@ export class Collection<TSchema extends Document = Document> {
     docs: ReadonlyArray<OptionalUnlessRequiredId<TSchema>>,
     options?: BulkWriteOptions
   ): Promise<InsertManyResult<TSchema>> {
-    return await executeOperation(
-      this.client,
-      new InsertManyOperation(
-        this as TODO_NODE_3286,
-        docs,
-        resolveOptions(this, options ?? { ordered: true })
-      ) as TODO_NODE_3286
-    );
+    if (!Array.isArray(docs)) {
+      throw new MongoInvalidArgumentError('Argument "docs" must be an array of documents');
+    }
+    options = resolveOptions(this, options ?? {});
+
+    const acknowledged = WriteConcern.fromOptions(options)?.w !== 0;
+
+    try {
+      const res = await this.bulkWrite(
+        docs.map(doc => ({ insertOne: { document: doc } })),
+        options
+      );
+      return {
+        acknowledged,
+        insertedCount: res.insertedCount,
+        insertedIds: res.insertedIds
+      };
+    } catch (err) {
+      if (err && err.message === 'Operation must be an object with an operation key') {
+        throw new MongoInvalidArgumentError(
+          'Collection.insertMany() cannot be called with an array that has null/undefined values'
+        );
+      }
+      throw err;
+    }
   }
 
   /**
@@ -342,14 +361,28 @@ export class Collection<TSchema extends Document = Document> {
       throw new MongoInvalidArgumentError('Argument "operations" must be an array of documents');
     }
 
-    return await executeOperation(
-      this.client,
-      new BulkWriteOperation(
-        this as TODO_NODE_3286,
-        operations,
-        resolveOptions(this, options ?? { ordered: true })
-      )
-    );
+    options = resolveOptions(this, options ?? {});
+
+    // TODO(NODE-7071): remove once the client doesn't need to be connected to construct
+    // bulk operations
+    const isConnected = this.client.topology != null;
+    if (!isConnected) {
+      await autoConnect(this.client);
+    }
+
+    // Create the bulk operation
+    const bulk: BulkOperationBase =
+      options.ordered === false
+        ? this.initializeUnorderedBulkOp(options)
+        : this.initializeOrderedBulkOp(options);
+
+    // for each op go through and add to the bulk
+    for (const operation of operations) {
+      bulk.raw(operation);
+    }
+
+    // Execute the bulk
+    return await bulk.execute({ ...options });
   }
 
   /**
@@ -370,12 +403,7 @@ export class Collection<TSchema extends Document = Document> {
   ): Promise<UpdateResult<TSchema>> {
     return await executeOperation(
       this.client,
-      new UpdateOneOperation(
-        this as TODO_NODE_3286,
-        filter,
-        update,
-        resolveOptions(this, options)
-      ) as TODO_NODE_3286
+      new UpdateOneOperation(this.s.namespace, filter, update, resolveOptions(this, options))
     );
   }
 
@@ -393,12 +421,7 @@ export class Collection<TSchema extends Document = Document> {
   ): Promise<UpdateResult<TSchema>> {
     return await executeOperation(
       this.client,
-      new ReplaceOneOperation(
-        this as TODO_NODE_3286,
-        filter,
-        replacement,
-        resolveOptions(this, options)
-      )
+      new ReplaceOneOperation(this.s.namespace, filter, replacement, resolveOptions(this, options))
     );
   }
 
@@ -420,12 +443,7 @@ export class Collection<TSchema extends Document = Document> {
   ): Promise<UpdateResult<TSchema>> {
     return await executeOperation(
       this.client,
-      new UpdateManyOperation(
-        this as TODO_NODE_3286,
-        filter,
-        update,
-        resolveOptions(this, options)
-      ) as TODO_NODE_3286
+      new UpdateManyOperation(this.s.namespace, filter, update, resolveOptions(this, options))
     );
   }
 
@@ -441,7 +459,7 @@ export class Collection<TSchema extends Document = Document> {
   ): Promise<DeleteResult> {
     return await executeOperation(
       this.client,
-      new DeleteOneOperation(this as TODO_NODE_3286, filter, resolveOptions(this, options))
+      new DeleteOneOperation(this.s.namespace, filter, resolveOptions(this, options))
     );
   }
 
@@ -457,7 +475,7 @@ export class Collection<TSchema extends Document = Document> {
   ): Promise<DeleteResult> {
     return await executeOperation(
       this.client,
-      new DeleteManyOperation(this as TODO_NODE_3286, filter, resolveOptions(this, options))
+      new DeleteManyOperation(this.s.namespace, filter, resolveOptions(this, options))
     );
   }
 
@@ -481,7 +499,7 @@ export class Collection<TSchema extends Document = Document> {
           ...options,
           readPreference: ReadPreference.PRIMARY
         })
-      ) as TODO_NODE_3286
+      )
     );
   }
 
@@ -491,10 +509,7 @@ export class Collection<TSchema extends Document = Document> {
    * @param options - Optional settings for the command
    */
   async drop(options?: DropCollectionOptions): Promise<boolean> {
-    return await executeOperation(
-      this.client,
-      new DropCollectionOperation(this.s.db, this.collectionName, options)
-    );
+    return await this.s.db.dropCollection(this.collectionName, options);
   }
 
   /**
@@ -507,7 +522,7 @@ export class Collection<TSchema extends Document = Document> {
   async findOne(filter: Filter<TSchema>): Promise<WithId<TSchema> | null>;
   async findOne(
     filter: Filter<TSchema>,
-    options: Omit<FindOptions, 'timeoutMode'> & Abortable
+    options: Omit<FindOneOptions, 'timeoutMode'> & Abortable
   ): Promise<WithId<TSchema> | null>;
 
   // allow an override of the schema.
@@ -515,17 +530,22 @@ export class Collection<TSchema extends Document = Document> {
   async findOne<T = TSchema>(filter: Filter<TSchema>): Promise<T | null>;
   async findOne<T = TSchema>(
     filter: Filter<TSchema>,
-    options?: Omit<FindOptions, 'timeoutMode'> & Abortable
+    options?: Omit<FindOneOptions, 'timeoutMode'> & Abortable
   ): Promise<T | null>;
 
   async findOne(
     filter: Filter<TSchema> = {},
-    options: FindOptions & Abortable = {}
+    options: Omit<FindOneOptions, 'timeoutMode'> & Abortable = {}
   ): Promise<WithId<TSchema> | null> {
-    const cursor = this.find(filter, options).limit(-1).batchSize(1);
-    const res = await cursor.next();
+    // Explicitly set the limit to 1 and singleBatch to true for all commands, per the spec.
+    // noCursorTimeout must be unset as well as batchSize.
+    // See: https://github.com/mongodb/specifications/blob/master/source/crud/crud.md#findone-api-details
+    const { batchSize: _batchSize, noCursorTimeout: _noCursorTimeout, ...opts } = options;
+    opts.singleBatch = true;
+    const cursor = this.find(filter, opts).limit(1);
+    const result = await cursor.next();
     await cursor.close();
-    return res;
+    return result;
   }
 
   /**
@@ -547,7 +567,7 @@ export class Collection<TSchema extends Document = Document> {
       this.client,
       this.s.namespace,
       filter,
-      resolveOptions(this as TODO_NODE_3286, options)
+      resolveOptions(this, options)
     );
   }
 
@@ -557,10 +577,16 @@ export class Collection<TSchema extends Document = Document> {
    * @param options - Optional settings for the command
    */
   async options(options?: OperationOptions): Promise<Document> {
-    return await executeOperation(
-      this.client,
-      new OptionsOperation(this as TODO_NODE_3286, resolveOptions(this, options))
-    );
+    options = resolveOptions(this, options);
+    const [collection] = await this.s.db
+      .listCollections({ name: this.collectionName }, { ...options, nameOnly: false })
+      .toArray();
+
+    if (collection == null || collection.options == null) {
+      throw new MongoAPIError(`collection ${this.namespace} not found`);
+    }
+
+    return collection.options;
   }
 
   /**
@@ -569,10 +595,8 @@ export class Collection<TSchema extends Document = Document> {
    * @param options - Optional settings for the command
    */
   async isCapped(options?: OperationOptions): Promise<boolean> {
-    return await executeOperation(
-      this.client,
-      new IsCappedOperation(this as TODO_NODE_3286, resolveOptions(this, options))
-    );
+    const { capped } = await this.options(options);
+    return Boolean(capped);
   }
 
   /**
@@ -840,6 +864,11 @@ export class Collection<TSchema extends Document = Document> {
     filter: Filter<TSchema>,
     options: DistinctOptions
   ): Promise<Array<Flatten<WithId<TSchema>[Key]>>>;
+  distinct<Key extends keyof WithId<TSchema>>(
+    key: Key,
+    filter: Filter<TSchema>,
+    options: DistinctOptions & { explain: ExplainVerbosityLike | ExplainCommandOptions }
+  ): Promise<Document>;
 
   // Embedded documents overload
   distinct(key: string): Promise<any[]>;

package/src/cursor/aggregation_cursor.ts

@@ -2,7 +2,6 @@ import type { Document } from '../bson';
 import { MongoAPIError } from '../error';
 import {
   Explain,
-  ExplainableCursor,
   type ExplainCommandOptions,
   type ExplainVerbosityLike,
   validateExplainTimeoutOptions
@@ -19,6 +18,7 @@ import {
   CursorTimeoutMode,
   type InitialCursorResponse
 } from './abstract_cursor';
+import { ExplainableCursor } from './explainable_cursor';
 
 /** @public */
 export interface AggregationCursorOptions extends AbstractCursorOptions, AggregateOptions {}

package/src/cursor/explainable_cursor.ts

@@ -0,0 +1,51 @@
+import { type Document } from '../bson';
+import { type ExplainCommandOptions, type ExplainVerbosityLike } from '../explain';
+import { AbstractCursor } from './abstract_cursor';
+
+/**
+ * @public
+ *
+ * A base class for any cursors that have `explain()` methods.
+ */
+export 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 } {
+    let explain: ExplainVerbosityLike | ExplainCommandOptions | undefined;
+    let timeout: { timeoutMS?: number } | undefined;
+
+    if (verbosity == null && options == null) {
+      explain = undefined;
+      timeout = undefined;
+    } else if (verbosity != null && options == null) {
+      explain =
+        typeof verbosity !== 'object'
+          ? verbosity
+          : 'verbosity' in verbosity
+            ? verbosity
+            : undefined;
+
+      timeout = typeof verbosity === 'object' && 'timeoutMS' in verbosity ? verbosity : undefined;
+    } else {
+      // @ts-expect-error TS isn't smart enough to determine that if both options are provided, the first is explain options
+      explain = verbosity;
+      timeout = options;
+    }
+
+    return { timeout, explain };
+  }
+}

package/src/cursor/find_cursor.ts

@@ -3,7 +3,6 @@ import { CursorResponse } from '../cmap/wire_protocol/responses';
 import { MongoAPIError, MongoInvalidArgumentError, MongoTailableCursorError } from '../error';
 import {
   Explain,
-  ExplainableCursor,
   type ExplainCommandOptions,
   type ExplainVerbosityLike,
   validateExplainTimeoutOptions
@@ -19,6 +18,7 @@ import type { ClientSession } from '../sessions';
 import { formatSort, type Sort, type SortDirection } from '../sort';
 import { emitWarningOnce, mergeOptions, type MongoDBNamespace, squashError } from '../utils';
 import { type InitialCursorResponse } from './abstract_cursor';
+import { ExplainableCursor } from './explainable_cursor';
 
 /** @public Flags allowed for cursor */
 export const FLAGS = [

package/src/cursor/run_command_cursor.ts

@@ -1,10 +1,10 @@
 import type { BSONSerializeOptions, Document } from '../bson';
-import { CursorResponse } from '../cmap/wire_protocol/responses';
+import { type CursorResponse } from '../cmap/wire_protocol/responses';
 import type { Db } from '../db';
 import { MongoAPIError, MongoRuntimeError } from '../error';
 import { executeOperation } from '../operations/execute_operation';
 import { GetMoreOperation } from '../operations/get_more';
-import { RunCommandOperation } from '../operations/run_command';
+import { RunCursorCommandOperation } from '../operations/run_command';
 import type { ReadConcernLike } from '../read_concern';
 import type { ReadPreferenceLike } from '../read_preference';
 import type { ClientSession } from '../sessions';
@@ -143,11 +143,10 @@ export class RunCommandCursor extends AbstractCursor {
 
   /** @internal */
   protected async _initialize(session: ClientSession): Promise<InitialCursorResponse> {
-    const operation = new RunCommandOperation<CursorResponse>(this.db, this.command, {
+    const operation = new RunCursorCommandOperation(this.db.s.namespace, this.command, {
       ...this.cursorOptions,
       session: session,
-      readPreference: this.cursorOptions.readPreference,
-      responseType: CursorResponse
+      readPreference: this.cursorOptions.readPreference
     });
 
     const response = await executeOperation(this.client, operation, this.timeoutContext);

package/src/db.ts

@@ -10,14 +10,10 @@ import { MongoInvalidArgumentError } from './error';
 import type { MongoClient, PkFactory } from './mongo_client';
 import type { Abortable, TODO_NODE_3286 } from './mongo_types';
 import type { AggregateOptions } from './operations/aggregate';
-import { CollectionsOperation } from './operations/collections';
+import { type CreateCollectionOptions, createCollections } from './operations/create_collection';
 import {
-  CreateCollectionOperation,
-  type CreateCollectionOptions
-} from './operations/create_collection';
-import {
-  DropCollectionOperation,
   type DropCollectionOptions,
+  dropCollections,
   DropDatabaseOperation,
   type DropDatabaseOptions
 } from './operations/drop';
@@ -242,10 +238,8 @@ export class Db {
     name: string,
     options?: CreateCollectionOptions
   ): Promise<Collection<TSchema>> {
-    return await executeOperation(
-      this.client,
-      new CreateCollectionOperation(this, name, resolveOptions(this, options)) as TODO_NODE_3286
-    );
+    options = resolveOptions(this, options);
+    return await createCollections<TSchema>(this, name, options);
   }
 
   /**
@@ -278,7 +272,7 @@ export class Db {
     return await executeOperation(
       this.client,
       new RunCommandOperation(
-        this,
+        this.s.namespace,
         command,
         resolveOptions(undefined, {
           ...resolveBSONOptions(options),
@@ -411,10 +405,8 @@ export class Db {
    * @param options - Optional settings for the command
    */
   async dropCollection(name: string, options?: DropCollectionOptions): Promise<boolean> {
-    return await executeOperation(
-      this.client,
-      new DropCollectionOperation(this, name, resolveOptions(this, options))
-    );
+    options = resolveOptions(this, options);
+    return await dropCollections(this, name, options);
   }
 
   /**
@@ -435,10 +427,15 @@ export class Db {
    * @param options - Optional settings for the command
    */
   async collections(options?: ListCollectionsOptions): Promise<Collection[]> {
-    return await executeOperation(
-      this.client,
-      new CollectionsOperation(this, resolveOptions(this, options))
-    );
+    options = resolveOptions(this, options);
+    const collections = await this.listCollections({}, { ...options, nameOnly: true }).toArray();
+
+    return collections
+      .filter(
+        // Filter collections removing any illegal ones
+        ({ name }) => !name.includes('$')
+      )
+      .map(({ name }) => new Collection(this, name, this.s.options));
   }
 
   /**

package/src/explain.ts

@@ -1,5 +1,4 @@
 import { type Document } from './bson';
-import { AbstractCursor } from './cursor/abstract_cursor';
 import { MongoAPIError } from './error';
 
 /** @public */
@@ -123,51 +122,3 @@ export function decorateWithExplain(
 
   return baseCommand;
 }
-
-/**
- * @public
- *
- * A base class for any cursors that have `explain()` methods.
- */
-export 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 } {
-    let explain: ExplainVerbosityLike | ExplainCommandOptions | undefined;
-    let timeout: { timeoutMS?: number } | undefined;
-
-    if (verbosity == null && options == null) {
-      explain = undefined;
-      timeout = undefined;
-    } else if (verbosity != null && options == null) {
-      explain =
-        typeof verbosity !== 'object'
-          ? verbosity
-          : 'verbosity' in verbosity
-            ? verbosity
-            : undefined;
-
-      timeout = typeof verbosity === 'object' && 'timeoutMS' in verbosity ? verbosity : undefined;
-    } else {
-      // @ts-expect-error TS isn't smart enough to determine that if both options are provided, the first is explain options
-      explain = verbosity;
-      timeout = options;
-    }
-
-    return { timeout, explain };
-  }
-}