diff --git a/.evergreen/run-tests.sh b/.evergreen/run-tests.sh
index 0b7ddc9513..4cb7328245 100755
--- a/.evergreen/run-tests.sh
+++ b/.evergreen/run-tests.sh
@@ -52,7 +52,7 @@ else
   source "$DRIVERS_TOOLS"/.evergreen/csfle/set-temp-creds.sh
 fi
 
-npm install mongodb-client-encryption@">=2.3.0"
+npm install mongodb-client-encryption@">=2.4.0-alpha.0"
 npm install @mongodb-js/zstd
 npm install snappy
 
diff --git a/etc/notes/CHANGES_5.0.0.md b/etc/notes/CHANGES_5.0.0.md
index 7c48ea8e48..b19d447283 100644
--- a/etc/notes/CHANGES_5.0.0.md
+++ b/etc/notes/CHANGES_5.0.0.md
@@ -16,9 +16,56 @@ The following is a detailed collection of the changes in the major v5 release of
 
 ## Changes
 
+### Optional callback support migrated to `mongodb-legacy`
+
+If you are a callback user and you are not ready to use promises, support for your workflow has **not** been removed.
+We have migrated it to a new package:
+
+- [`mongodb-legacy` Github](https://github.com/mongodb-js/nodejs-mongodb-legacy#readme)
+- [`mongodb-legacy` npm](https://www.npmjs.com/package/mongodb-legacy)
+
+The package wraps all of the driver's asynchronous operations that previously supported both promises and callbacks. All the wrapped APIs offer callback support via an optional callback argument alongside a Promise return value so projects with mixed usage will continue to work.
+
+#### Example usage of equivalent callback and promise usage
+
+After installing the package and modifying imports the following example demonstrates equivalent usages of either `async`/`await` syntax, `.then`/`.catch` chaining, or callbacks:
+
+```ts
+// Just add '-legacy' to my mongodb import
+import { MongoClient } from 'mongodb-legacy';
+const client = new MongoClient();
+const db = client.db();
+const collection = db.collection('pets');
+
+// Legacy projects may have intermixed API usage:
+app.get('/endpoint_async_await', async (req, res) => {
+  try {
+    const result = await collection.findOne({})
+    res.end(JSON.stringify(result));
+  } catch (error) {
+    res.errorHandling(error)
+  }
+});
+
+app.get('/endpoint_promises', (req, res) => {
+  collection
+    .findOne({})
+    .then(result => res.end(JSON.stringify(result)))
+    .catch(error => res.errorHandling(error));
+});
+
+app.get('/endpoint_callbacks', (req, res) => {
+  collection.findOne({}, (error, result) => {
+    if (error) return res.errorHandling(error);
+    res.end(JSON.stringify(result));
+  });
+});
+```
+
+
 ### Dot Notation Typescript Support Removed By Default
 
-**NOTE** This is a **Typescript compile-time only** change. Dot notation in filters sent to MongoDB will still work the same.
+**NOTE:** This is a **Typescript compile-time only** change. Dot notation in filters sent to MongoDB will still work the same.
 
 Version 4.3.0 introduced Typescript support for dot notation in filter predicates.  For example:
 
diff --git a/src/admin.ts b/src/admin.ts
index 977de4e885..9e9a64e082 100644
--- a/src/admin.ts
+++ b/src/admin.ts
@@ -14,7 +14,6 @@ import {
   ValidateCollectionOperation,
   ValidateCollectionOptions
 } from './operations/validate_collection';
-import type { Callback } from './utils';
 
 /** @internal */
 export interface AdminPrivate {
@@ -57,26 +56,11 @@ export class Admin {
    *
    * @param command - The command to execute
    * @param options - Optional settings for the command
-   * @param callback - An optional callback, a Promise will be returned if none is provided
    */
-  command(command: Document): Promise<Document>;
-  command(command: Document, options: RunCommandOptions): Promise<Document>;
-  /** @deprecated Callbacks are deprecated and will be removed in the next major version. See [mongodb-legacy](https://github.com/mongodb-js/nodejs-mongodb-legacy) for migration assistance */
-  command(command: Document, callback: Callback<Document>): void;
-  /** @deprecated Callbacks are deprecated and will be removed in the next major version. See [mongodb-legacy](https://github.com/mongodb-js/nodejs-mongodb-legacy) for migration assistance */
-  command(command: Document, options: RunCommandOptions, callback: Callback<Document>): void;
-  command(
-    command: Document,
-    options?: RunCommandOptions | Callback<Document>,
-    callback?: Callback<Document>
-  ): Promise<Document> | void {
-    if (typeof options === 'function') (callback = options), (options = {});
-    options = Object.assign({ dbName: 'admin' }, options);
-
+  async command(command: Document, options?: RunCommandOptions): Promise<Document> {
     return executeOperation(
       this.s.db.s.client,
-      new RunCommandOperation(this.s.db, command, options),
-      callback
+      new RunCommandOperation(this.s.db, command, { dbName: 'admin', ...options })
     );
   }
 
@@ -84,135 +68,60 @@ export class Admin {
    * Retrieve the server build information
    *
    * @param options - Optional settings for the command
-   * @param callback - An optional callback, a Promise will be returned if none is provided
    */
-  buildInfo(): Promise<Document>;
-  buildInfo(options: CommandOperationOptions): Promise<Document>;
-  /** @deprecated Callbacks are deprecated and will be removed in the next major version. See [mongodb-legacy](https://github.com/mongodb-js/nodejs-mongodb-legacy) for migration assistance */
-  buildInfo(callback: Callback<Document>): void;
-  /** @deprecated Callbacks are deprecated and will be removed in the next major version. See [mongodb-legacy](https://github.com/mongodb-js/nodejs-mongodb-legacy) for migration assistance */
-  buildInfo(options: CommandOperationOptions, callback: Callback<Document>): void;
-  buildInfo(
-    options?: CommandOperationOptions | Callback<Document>,
-    callback?: Callback<Document>
-  ): Promise<Document> | void {
-    if (typeof options === 'function') (callback = options), (options = {});
-    options = options ?? {};
-    return this.command({ buildinfo: 1 }, options, callback as Callback<Document>);
+  async buildInfo(options?: CommandOperationOptions): Promise<Document> {
+    return this.command({ buildinfo: 1 }, options);
   }
 
   /**
    * Retrieve the server build information
    *
    * @param options - Optional settings for the command
-   * @param callback - An optional callback, a Promise will be returned if none is provided
    */
-  serverInfo(): Promise<Document>;
-  serverInfo(options: CommandOperationOptions): Promise<Document>;
-  /** @deprecated Callbacks are deprecated and will be removed in the next major version. See [mongodb-legacy](https://github.com/mongodb-js/nodejs-mongodb-legacy) for migration assistance */
-  serverInfo(callback: Callback<Document>): void;
-  /** @deprecated Callbacks are deprecated and will be removed in the next major version. See [mongodb-legacy](https://github.com/mongodb-js/nodejs-mongodb-legacy) for migration assistance */
-  serverInfo(options: CommandOperationOptions, callback: Callback<Document>): void;
-  serverInfo(
-    options?: CommandOperationOptions | Callback<Document>,
-    callback?: Callback<Document>
-  ): Promise<Document> | void {
-    if (typeof options === 'function') (callback = options), (options = {});
-    options = options ?? {};
-    return this.command({ buildinfo: 1 }, options, callback as Callback<Document>);
+  async serverInfo(options?: CommandOperationOptions): Promise<Document> {
+    return this.command({ buildinfo: 1 }, options);
   }
 
   /**
    * Retrieve this db's server status.
    *
    * @param options - Optional settings for the command
-   * @param callback - An optional callback, a Promise will be returned if none is provided
    */
-  serverStatus(): Promise<Document>;
-  serverStatus(options: CommandOperationOptions): Promise<Document>;
-  /** @deprecated Callbacks are deprecated and will be removed in the next major version. See [mongodb-legacy](https://github.com/mongodb-js/nodejs-mongodb-legacy) for migration assistance */
-  serverStatus(callback: Callback<Document>): void;
-  /** @deprecated Callbacks are deprecated and will be removed in the next major version. See [mongodb-legacy](https://github.com/mongodb-js/nodejs-mongodb-legacy) for migration assistance */
-  serverStatus(options: CommandOperationOptions, callback: Callback<Document>): void;
-  serverStatus(
-    options?: CommandOperationOptions | Callback<Document>,
-    callback?: Callback<Document>
-  ): Promise<Document> | void {
-    if (typeof options === 'function') (callback = options), (options = {});
-    options = options ?? {};
-    return this.command({ serverStatus: 1 }, options, callback as Callback<Document>);
+  async serverStatus(options?: CommandOperationOptions): Promise<Document> {
+    return this.command({ serverStatus: 1 }, options);
   }
 
   /**
    * Ping the MongoDB server and retrieve results
    *
    * @param options - Optional settings for the command
-   * @param callback - An optional callback, a Promise will be returned if none is provided
    */
-  ping(): Promise<Document>;
-  ping(options: CommandOperationOptions): Promise<Document>;
-  /** @deprecated Callbacks are deprecated and will be removed in the next major version. See [mongodb-legacy](https://github.com/mongodb-js/nodejs-mongodb-legacy) for migration assistance */
-  ping(callback: Callback<Document>): void;
-  /** @deprecated Callbacks are deprecated and will be removed in the next major version. See [mongodb-legacy](https://github.com/mongodb-js/nodejs-mongodb-legacy) for migration assistance */
-  ping(options: CommandOperationOptions, callback: Callback<Document>): void;
-  ping(
-    options?: CommandOperationOptions | Callback<Document>,
-    callback?: Callback<Document>
-  ): Promise<Document> | void {
-    if (typeof options === 'function') (callback = options), (options = {});
-    options = options ?? {};
-    return this.command({ ping: 1 }, options, callback as Callback<Document>);
+  async ping(options?: CommandOperationOptions): Promise<Document> {
+    return this.command({ ping: 1 }, options);
   }
 
   /**
    * Add a user to the database
    *
    * @param username - The username for the new user
-   * @param password - An optional password for the new user
+   * @param passwordOrOptions - An optional password for the new user, or the options for the command
    * @param options - Optional settings for the command
-   * @param callback - An optional callback, a Promise will be returned if none is provided
    */
-  addUser(username: string): Promise<Document>;
-  addUser(username: string, password: string): Promise<Document>;
-  addUser(username: string, options: AddUserOptions): Promise<Document>;
-  addUser(username: string, password: string, options: AddUserOptions): Promise<Document>;
-  /** @deprecated Callbacks are deprecated and will be removed in the next major version. See [mongodb-legacy](https://github.com/mongodb-js/nodejs-mongodb-legacy) for migration assistance */
-  addUser(username: string, callback: Callback<Document>): void;
-  /** @deprecated Callbacks are deprecated and will be removed in the next major version. See [mongodb-legacy](https://github.com/mongodb-js/nodejs-mongodb-legacy) for migration assistance */
-  addUser(username: string, password: string, callback: Callback<Document>): void;
-  /** @deprecated Callbacks are deprecated and will be removed in the next major version. See [mongodb-legacy](https://github.com/mongodb-js/nodejs-mongodb-legacy) for migration assistance */
-  addUser(username: string, options: AddUserOptions, callback: Callback<Document>): void;
-  /** @deprecated Callbacks are deprecated and will be removed in the next major version. See [mongodb-legacy](https://github.com/mongodb-js/nodejs-mongodb-legacy) for migration assistance */
-  addUser(
-    username: string,
-    password: string,
-    options: AddUserOptions,
-    callback: Callback<Document>
-  ): void;
-  addUser(
+  async addUser(
     username: string,
-    password?: string | AddUserOptions | Callback<Document>,
-    options?: AddUserOptions | Callback<Document>,
-    callback?: Callback<Document>
-  ): Promise<Document> | void {
-    if (typeof password === 'function') {
-      (callback = password), (password = undefined), (options = {});
-    } else if (typeof password !== 'string') {
-      if (typeof options === 'function') {
-        (callback = options), (options = password), (password = undefined);
-      } else {
-        (options = password), (callback = undefined), (password = undefined);
-      }
-    } else {
-      if (typeof options === 'function') (callback = options), (options = {});
-    }
-
-    options = Object.assign({ dbName: 'admin' }, options);
-
+    passwordOrOptions?: string | AddUserOptions,
+    options?: AddUserOptions
+  ): Promise<Document> {
+    options =
+      options != null && typeof options === 'object'
+        ? options
+        : passwordOrOptions != null && typeof passwordOrOptions === 'object'
+        ? passwordOrOptions
+        : undefined;
+    const password = typeof passwordOrOptions === 'string' ? passwordOrOptions : undefined;
     return executeOperation(
       this.s.db.s.client,
-      new AddUserOperation(this.s.db, username, password, options),
-      callback
+      new AddUserOperation(this.s.db, username, password, { dbName: 'admin', ...options })
     );
   }
 
@@ -221,26 +130,11 @@ export class Admin {
    *
    * @param username - The username to remove
    * @param options - Optional settings for the command
-   * @param callback - An optional callback, a Promise will be returned if none is provided
    */
-  removeUser(username: string): Promise<boolean>;
-  removeUser(username: string, options: RemoveUserOptions): Promise<boolean>;
-  /** @deprecated Callbacks are deprecated and will be removed in the next major version. See [mongodb-legacy](https://github.com/mongodb-js/nodejs-mongodb-legacy) for migration assistance */
-  removeUser(username: string, callback: Callback<boolean>): void;
-  /** @deprecated Callbacks are deprecated and will be removed in the next major version. See [mongodb-legacy](https://github.com/mongodb-js/nodejs-mongodb-legacy) for migration assistance */
-  removeUser(username: string, options: RemoveUserOptions, callback: Callback<boolean>): void;
-  removeUser(
-    username: string,
-    options?: RemoveUserOptions | Callback<boolean>,
-    callback?: Callback<boolean>
-  ): Promise<boolean> | void {
-    if (typeof options === 'function') (callback = options), (options = {});
-    options = Object.assign({ dbName: 'admin' }, options);
-
+  async removeUser(username: string, options?: RemoveUserOptions): Promise<boolean> {
     return executeOperation(
       this.s.db.s.client,
-      new RemoveUserOperation(this.s.db, username, options),
-      callback
+      new RemoveUserOperation(this.s.db, username, { dbName: 'admin', ...options })
     );
   }
 
@@ -249,30 +143,14 @@ export class Admin {
    *
    * @param collectionName - The name of the collection to validate.
    * @param options - Optional settings for the command
-   * @param callback - An optional callback, a Promise will be returned if none is provided
    */
-  validateCollection(collectionName: string): Promise<Document>;
-  validateCollection(collectionName: string, options: ValidateCollectionOptions): Promise<Document>;
-  /** @deprecated Callbacks are deprecated and will be removed in the next major version. See [mongodb-legacy](https://github.com/mongodb-js/nodejs-mongodb-legacy) for migration assistance */
-  validateCollection(collectionName: string, callback: Callback<Document>): void;
-  /** @deprecated Callbacks are deprecated and will be removed in the next major version. See [mongodb-legacy](https://github.com/mongodb-js/nodejs-mongodb-legacy) for migration assistance */
-  validateCollection(
+  async validateCollection(
     collectionName: string,
-    options: ValidateCollectionOptions,
-    callback: Callback<Document>
-  ): void;
-  validateCollection(
-    collectionName: string,
-    options?: ValidateCollectionOptions | Callback<Document>,
-    callback?: Callback<Document>
-  ): Promise<Document> | void {
-    if (typeof options === 'function') (callback = options), (options = {});
-    options = options ?? {};
-
+    options: ValidateCollectionOptions = {}
+  ): Promise<Document> {
     return executeOperation(
       this.s.db.s.client,
-      new ValidateCollectionOperation(this, collectionName, options),
-      callback
+      new ValidateCollectionOperation(this, collectionName, options)
     );
   }
 
@@ -280,46 +158,17 @@ export class Admin {
    * List the available databases
    *
    * @param options - Optional settings for the command
-   * @param callback - An optional callback, a Promise will be returned if none is provided
    */
-  listDatabases(): Promise<ListDatabasesResult>;
-  listDatabases(options: ListDatabasesOptions): Promise<ListDatabasesResult>;
-  /** @deprecated Callbacks are deprecated and will be removed in the next major version. See [mongodb-legacy](https://github.com/mongodb-js/nodejs-mongodb-legacy) for migration assistance */
-  listDatabases(callback: Callback<ListDatabasesResult>): void;
-  /** @deprecated Callbacks are deprecated and will be removed in the next major version. See [mongodb-legacy](https://github.com/mongodb-js/nodejs-mongodb-legacy) for migration assistance */
-  listDatabases(options: ListDatabasesOptions, callback: Callback<ListDatabasesResult>): void;
-  listDatabases(
-    options?: ListDatabasesOptions | Callback<ListDatabasesResult>,
-    callback?: Callback<ListDatabasesResult>
-  ): Promise<ListDatabasesResult> | void {
-    if (typeof options === 'function') (callback = options), (options = {});
-    options = options ?? {};
-
-    return executeOperation(
-      this.s.db.s.client,
-      new ListDatabasesOperation(this.s.db, options),
-      callback
-    );
+  async listDatabases(options?: ListDatabasesOptions): Promise<ListDatabasesResult> {
+    return executeOperation(this.s.db.s.client, new ListDatabasesOperation(this.s.db, options));
   }
 
   /**
    * Get ReplicaSet status
    *
    * @param options - Optional settings for the command
-   * @param callback - An optional callback, a Promise will be returned if none is provided
    */
-  replSetGetStatus(): Promise<Document>;
-  replSetGetStatus(options: CommandOperationOptions): Promise<Document>;
-  /** @deprecated Callbacks are deprecated and will be removed in the next major version. See [mongodb-legacy](https://github.com/mongodb-js/nodejs-mongodb-legacy) for migration assistance */
-  replSetGetStatus(callback: Callback<Document>): void;
-  /** @deprecated Callbacks are deprecated and will be removed in the next major version. See [mongodb-legacy](https://github.com/mongodb-js/nodejs-mongodb-legacy) for migration assistance */
-  replSetGetStatus(options: CommandOperationOptions, callback: Callback<Document>): void;
-  replSetGetStatus(
-    options?: CommandOperationOptions | Callback<Document>,
-    callback?: Callback<Document>
-  ): Promise<Document> | void {
-    if (typeof options === 'function') (callback = options), (options = {});
-    options = options ?? {};
-    return this.command({ replSetGetStatus: 1 }, options, callback as Callback<Document>);
+  async replSetGetStatus(options?: CommandOperationOptions): Promise<Document> {
+    return this.command({ replSetGetStatus: 1 }, options);
   }
 }
diff --git a/src/bulk/common.ts b/src/bulk/common.ts
index 1d1ade6e50..566c2464b9 100644
--- a/src/bulk/common.ts
+++ b/src/bulk/common.ts
@@ -23,7 +23,6 @@ import {
   Callback,
   getTopology,
   hasAtomicOperators,
-  maybeCallback,
   MongoDBNamespace,
   resolveOptions
 } from '../utils';
@@ -1175,56 +1174,34 @@ export abstract class BulkOperationBase {
     return batches;
   }
 
-  execute(options?: BulkWriteOptions): Promise<BulkWriteResult>;
-  /** @deprecated Callbacks are deprecated and will be removed in the next major version. See [mongodb-legacy](https://github.com/mongodb-js/nodejs-mongodb-legacy) for migration assistance */
-  execute(callback: Callback<BulkWriteResult>): void;
-  /** @deprecated Callbacks are deprecated and will be removed in the next major version. See [mongodb-legacy](https://github.com/mongodb-js/nodejs-mongodb-legacy) for migration assistance */
-  execute(options: BulkWriteOptions | undefined, callback: Callback<BulkWriteResult>): void;
-  /** @deprecated Callbacks are deprecated and will be removed in the next major version. See [mongodb-legacy](https://github.com/mongodb-js/nodejs-mongodb-legacy) for migration assistance */
-  execute(
-    options?: BulkWriteOptions | Callback<BulkWriteResult>,
-    callback?: Callback<BulkWriteResult>
-  ): Promise<BulkWriteResult> | void;
-  execute(
-    options?: BulkWriteOptions | Callback<BulkWriteResult>,
-    callback?: Callback<BulkWriteResult>
-  ): Promise<BulkWriteResult> | void {
-    callback =
-      typeof callback === 'function'
-        ? callback
-        : typeof options === 'function'
-        ? options
-        : undefined;
-    return maybeCallback(async () => {
-      options = options != null && typeof options !== 'function' ? options : {};
-
-      if (this.s.executed) {
-        throw new MongoBatchReExecutionError();
-      }
+  async execute(options: BulkWriteOptions = {}): Promise<BulkWriteResult> {
+    if (this.s.executed) {
+      throw new MongoBatchReExecutionError();
+    }
 
-      const writeConcern = WriteConcern.fromOptions(options);
-      if (writeConcern) {
-        this.s.writeConcern = writeConcern;
-      }
+    const writeConcern = WriteConcern.fromOptions(options);
+    if (writeConcern) {
+      this.s.writeConcern = writeConcern;
+    }
 
-      // If we have current batch
-      if (this.isOrdered) {
-        if (this.s.currentBatch) this.s.batches.push(this.s.currentBatch);
-      } else {
-        if (this.s.currentInsertBatch) this.s.batches.push(this.s.currentInsertBatch);
-        if (this.s.currentUpdateBatch) this.s.batches.push(this.s.currentUpdateBatch);
-        if (this.s.currentRemoveBatch) this.s.batches.push(this.s.currentRemoveBatch);
-      }
-      // If we have no operations in the bulk raise an error
-      if (this.s.batches.length === 0) {
-        throw new MongoInvalidArgumentError('Invalid BulkOperation, Batch cannot be empty');
-      }
+    // If we have current batch
+    if (this.isOrdered) {
+      if (this.s.currentBatch) this.s.batches.push(this.s.currentBatch);
+    } else {
+      if (this.s.currentInsertBatch) this.s.batches.push(this.s.currentInsertBatch);
+      if (this.s.currentUpdateBatch) this.s.batches.push(this.s.currentUpdateBatch);
+      if (this.s.currentRemoveBatch) this.s.batches.push(this.s.currentRemoveBatch);
+    }
+    // If we have no operations in the bulk raise an error
+    if (this.s.batches.length === 0) {
+      throw new MongoInvalidArgumentError('Invalid BulkOperation, Batch cannot be empty');
+    }
+
+    this.s.executed = true;
+    const finalOptions = { ...this.s.options, ...options };
+    const operation = new BulkWriteShimOperation(this, finalOptions);
 
-      this.s.executed = true;
-      const finalOptions = { ...this.s.options, ...options };
-      const operation = new BulkWriteShimOperation(this, finalOptions);
-      return executeOperation(this.s.collection.s.db.s.client, operation);
-    }, callback);
+    return executeOperation(this.s.collection.s.db.s.client, operation);
   }
 
   /**
diff --git a/src/change_stream.ts b/src/change_stream.ts
index e346609e09..ee6876acc1 100644
--- a/src/change_stream.ts
+++ b/src/change_stream.ts
@@ -19,7 +19,7 @@ import type { AggregateOptions } from './operations/aggregate';
 import type { CollationOptions, OperationParent } from './operations/command';
 import type { ReadPreference } from './read_preference';
 import type { ServerSessionId } from './sessions';
-import { Callback, filterOptions, getTopology, maybeCallback, MongoDBNamespace } from './utils';
+import { filterOptions, getTopology, MongoDBNamespace } from './utils';
 
 /** @internal */
 const kCursorStream = Symbol('cursorStream');
@@ -637,99 +637,84 @@ export class ChangeStream<
   }
 
   /** Check if there is any document still available in the Change Stream */
-  hasNext(): Promise<boolean>;
-  /** @deprecated Callbacks are deprecated and will be removed in the next major version. See [mongodb-legacy](https://github.com/mongodb-js/nodejs-mongodb-legacy) for migration assistance */
-  hasNext(callback: Callback<boolean>): void;
-  hasNext(callback?: Callback): Promise<boolean> | void {
+  async hasNext(): Promise<boolean> {
     this._setIsIterator();
-    return maybeCallback(async () => {
-      // Change streams must resume indefinitely while each resume event succeeds.
-      // This loop continues until either a change event is received or until a resume attempt
-      // fails.
-      // eslint-disable-next-line no-constant-condition
-      while (true) {
+    // Change streams must resume indefinitely while each resume event succeeds.
+    // This loop continues until either a change event is received or until a resume attempt
+    // fails.
+    // eslint-disable-next-line no-constant-condition
+    while (true) {
+      try {
+        const hasNext = await this.cursor.hasNext();
+        return hasNext;
+      } catch (error) {
         try {
-          const hasNext = await this.cursor.hasNext();
-          return hasNext;
+          await this._processErrorIteratorMode(error);
         } catch (error) {
           try {
-            await this._processErrorIteratorMode(error);
-          } catch (error) {
-            try {
-              await this.close();
-            } catch {
-              // We are not concerned with errors from close()
-            }
-            throw error;
+            await this.close();
+          } catch {
+            // We are not concerned with errors from close()
           }
+          throw error;
         }
       }
-    }, callback);
+    }
   }
 
   /** Get the next available document from the Change Stream. */
-  next(): Promise<TChange>;
-  /** @deprecated Callbacks are deprecated and will be removed in the next major version. See [mongodb-legacy](https://github.com/mongodb-js/nodejs-mongodb-legacy) for migration assistance */
-  next(callback: Callback<TChange>): void;
-  next(callback?: Callback<TChange>): Promise<TChange> | void {
+  async next(): Promise<TChange> {
     this._setIsIterator();
-    return maybeCallback(async () => {
-      // Change streams must resume indefinitely while each resume event succeeds.
-      // This loop continues until either a change event is received or until a resume attempt
-      // fails.
-      // eslint-disable-next-line no-constant-condition
-      while (true) {
+    // Change streams must resume indefinitely while each resume event succeeds.
+    // This loop continues until either a change event is received or until a resume attempt
+    // fails.
+    // eslint-disable-next-line no-constant-condition
+    while (true) {
+      try {
+        const change = await this.cursor.next();
+        const processedChange = this._processChange(change ?? null);
+        return processedChange;
+      } catch (error) {
         try {
-          const change = await this.cursor.next();
-          const processedChange = this._processChange(change ?? null);
-          return processedChange;
+          await this._processErrorIteratorMode(error);
         } catch (error) {
           try {
-            await this._processErrorIteratorMode(error);
-          } catch (error) {
-            try {
-              await this.close();
-            } catch {
-              // We are not concerned with errors from close()
-            }
-            throw error;
+            await this.close();
+          } catch {
+            // We are not concerned with errors from close()
           }
+          throw error;
         }
       }
-    }, callback);
+    }
   }
 
   /**
    * Try to get the next available document from the Change Stream's cursor or `null` if an empty batch is returned
    */
-  tryNext(): Promise<Document | null>;
-  /** @deprecated Callbacks are deprecated and will be removed in the next major version. See [mongodb-legacy](https://github.com/mongodb-js/nodejs-mongodb-legacy) for migration assistance */
-  tryNext(callback: Callback<Document | null>): void;
-  tryNext(callback?: Callback<Document | null>): Promise<Document | null> | void {
+  async tryNext(): Promise<Document | null> {
     this._setIsIterator();
-    return maybeCallback(async () => {
-      // Change streams must resume indefinitely while each resume event succeeds.
-      // This loop continues until either a change event is received or until a resume attempt
-      // fails.
-      // eslint-disable-next-line no-constant-condition
-      while (true) {
+    // Change streams must resume indefinitely while each resume event succeeds.
+    // This loop continues until either a change event is received or until a resume attempt
+    // fails.
+    // eslint-disable-next-line no-constant-condition
+    while (true) {
+      try {
+        const change = await this.cursor.tryNext();
+        return change ?? null;
+      } catch (error) {
         try {
-          const change = await this.cursor.tryNext();
-          return change ?? null;
+          await this._processErrorIteratorMode(error);
         } catch (error) {
           try {
-            await this._processErrorIteratorMode(error);
-          } catch (error) {
-            try {
-              await this.close();
-            } catch {
-              // We are not concerned with errors from close()
-            }
-            throw error;
+            await this.close();
+          } catch {
+            // We are not concerned with errors from close()
           }
+          throw error;
         }
       }
-    }, callback);
+    }
   }
 
   async *[Symbol.asyncIterator](): AsyncGenerator<TChange, void, void> {
@@ -758,20 +743,15 @@ export class ChangeStream<
   }
 
   /** Close the Change Stream */
-  close(): Promise<void>;
-  /** @deprecated Callbacks are deprecated and will be removed in the next major version. See [mongodb-legacy](https://github.com/mongodb-js/nodejs-mongodb-legacy) for migration assistance */
-  close(callback: Callback): void;
-  close(callback?: Callback): Promise<void> | void {
+  async close(): Promise<void> {
     this[kClosed] = true;
 
-    return maybeCallback(async () => {
-      const cursor = this.cursor;
-      try {
-        await cursor.close();
-      } finally {
-        this._endStream();
-      }
-    }, callback);
+    const cursor = this.cursor;
+    try {
+      await cursor.close();
+    } finally {
+      this._endStream();
+    }
   }
 
   /**
@@ -864,9 +844,7 @@ export class ChangeStream<
   private _closeEmitterModeWithError(error: AnyError): void {
     this.emit(ChangeStream.ERROR, error);
 
-    this.close(() => {
-      // nothing to do
-    });
+    this.close().catch(() => null);
   }
 
   /** @internal */
diff --git a/src/collection.ts b/src/collection.ts
index 23031d8900..afd15e5a60 100644
--- a/src/collection.ts
+++ b/src/collection.ts
@@ -82,7 +82,6 @@ import {
 import { ReadConcern, ReadConcernLike } from './read_concern';
 import { ReadPreference, ReadPreferenceLike } from './read_preference';
 import {
-  Callback,
   checkCollectionName,
   DEFAULT_PK_FACTORY,
   MongoDBNamespace,
@@ -250,42 +249,18 @@ export class Collection<TSchema extends Document = Document> {
    *
    * @param doc - The document to insert
    * @param options - Optional settings for the command
-   * @param callback - An optional callback, a Promise will be returned if none is provided
    */
-  insertOne(doc: OptionalUnlessRequiredId<TSchema>): Promise<InsertOneResult<TSchema>>;
-  insertOne(
+  async insertOne(
     doc: OptionalUnlessRequiredId<TSchema>,
-    options: InsertOneOptions
-  ): Promise<InsertOneResult<TSchema>>;
-  /** @deprecated Callbacks are deprecated and will be removed in the next major version. See [mongodb-legacy](https://github.com/mongodb-js/nodejs-mongodb-legacy) for migration assistance */
-  insertOne(
-    doc: OptionalUnlessRequiredId<TSchema>,
-    callback: Callback<InsertOneResult<TSchema>>
-  ): void;
-  /** @deprecated Callbacks are deprecated and will be removed in the next major version. See [mongodb-legacy](https://github.com/mongodb-js/nodejs-mongodb-legacy) for migration assistance */
-  insertOne(
-    doc: OptionalUnlessRequiredId<TSchema>,
-    options: InsertOneOptions,
-    callback: Callback<InsertOneResult<TSchema>>
-  ): void;
-  insertOne(
-    doc: OptionalUnlessRequiredId<TSchema>,
-    options?: InsertOneOptions | Callback<InsertOneResult<TSchema>>,
-    callback?: Callback<InsertOneResult<TSchema>>
-  ): Promise<InsertOneResult<TSchema>> | void {
-    if (typeof options === 'function') {
-      callback = options;
-      options = {};
-    }
-
+    options?: InsertOneOptions
+  ): Promise<InsertOneResult<TSchema>> {
     return executeOperation(
       this.s.db.s.client,
       new InsertOneOperation(
         this as TODO_NODE_3286,
         doc,
         resolveOptions(this, options)
-      ) as TODO_NODE_3286,
-      callback
+      ) as TODO_NODE_3286
     );
   }
 
@@ -296,40 +271,18 @@ export class Collection<TSchema extends Document = Document> {
    *
    * @param docs - The documents to insert
    * @param options - Optional settings for the command
-   * @param callback - An optional callback, a Promise will be returned if none is provided
    */
-  insertMany(docs: OptionalUnlessRequiredId<TSchema>[]): Promise<InsertManyResult<TSchema>>;
-  insertMany(
-    docs: OptionalUnlessRequiredId<TSchema>[],
-    options: BulkWriteOptions
-  ): Promise<InsertManyResult<TSchema>>;
-  /** @deprecated Callbacks are deprecated and will be removed in the next major version. See [mongodb-legacy](https://github.com/mongodb-js/nodejs-mongodb-legacy) for migration assistance */
-  insertMany(
-    docs: OptionalUnlessRequiredId<TSchema>[],
-    callback: Callback<InsertManyResult<TSchema>>
-  ): void;
-  /** @deprecated Callbacks are deprecated and will be removed in the next major version. See [mongodb-legacy](https://github.com/mongodb-js/nodejs-mongodb-legacy) for migration assistance */
-  insertMany(
-    docs: OptionalUnlessRequiredId<TSchema>[],
-    options: BulkWriteOptions,
-    callback: Callback<InsertManyResult<TSchema>>
-  ): void;
-  insertMany(
+  async insertMany(
     docs: OptionalUnlessRequiredId<TSchema>[],
-    options?: BulkWriteOptions | Callback<InsertManyResult<TSchema>>,
-    callback?: Callback<InsertManyResult<TSchema>>
-  ): Promise<InsertManyResult<TSchema>> | void {
-    if (typeof options === 'function') (callback = options), (options = {});
-    options = options ? Object.assign({}, options) : { ordered: true };
-
+    options?: BulkWriteOptions
+  ): Promise<InsertManyResult<TSchema>> {
     return executeOperation(
       this.s.db.s.client,
       new InsertManyOperation(
         this as TODO_NODE_3286,
         docs,
-        resolveOptions(this, options)
-      ) as TODO_NODE_3286,
-      callback
+        resolveOptions(this, options ?? { ordered: true })
+      ) as TODO_NODE_3286
     );
   }
 
@@ -344,41 +297,18 @@ export class Collection<TSchema extends Document = Document> {
    * - `deleteOne`
    * - `deleteMany`
    *
-   * Please note that raw operations are no longer accepted as of driver version 4.0.
-   *
    * 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
    * can be overridden by setting the **forceServerObjectId** flag.
    *
    * @param operations - Bulk operations to perform
    * @param options - Optional settings for the command
-   * @param callback - An optional callback, a Promise will be returned if none is provided
    * @throws MongoDriverError if operations is not an array
    */
-  bulkWrite(operations: AnyBulkWriteOperation<TSchema>[]): Promise<BulkWriteResult>;
-  bulkWrite(
-    operations: AnyBulkWriteOperation<TSchema>[],
-    options: BulkWriteOptions
-  ): Promise<BulkWriteResult>;
-  /** @deprecated Callbacks are deprecated and will be removed in the next major version. See [mongodb-legacy](https://github.com/mongodb-js/nodejs-mongodb-legacy) for migration assistance */
-  bulkWrite(
+  async bulkWrite(
     operations: AnyBulkWriteOperation<TSchema>[],
-    callback: Callback<BulkWriteResult>
-  ): void;
-  /** @deprecated Callbacks are deprecated and will be removed in the next major version. See [mongodb-legacy](https://github.com/mongodb-js/nodejs-mongodb-legacy) for migration assistance */
-  bulkWrite(
-    operations: AnyBulkWriteOperation<TSchema>[],
-    options: BulkWriteOptions,
-    callback: Callback<BulkWriteResult>
-  ): void;
-  bulkWrite(
-    operations: AnyBulkWriteOperation<TSchema>[],
-    options?: BulkWriteOptions | Callback<BulkWriteResult>,
-    callback?: Callback<BulkWriteResult>
-  ): Promise<BulkWriteResult> | void {
-    if (typeof options === 'function') (callback = options), (options = {});
-    options = options || { ordered: true };
-
+    options?: BulkWriteOptions
+  ): Promise<BulkWriteResult> {
     if (!Array.isArray(operations)) {
       throw new MongoInvalidArgumentError('Argument "operations" must be an array of documents');
     }
@@ -388,9 +318,8 @@ export class Collection<TSchema extends Document = Document> {
       new BulkWriteOperation(
         this as TODO_NODE_3286,
         operations as TODO_NODE_3286,
-        resolveOptions(this, options)
-      ),
-      callback
+        resolveOptions(this, options ?? { ordered: true })
+      )
     );
   }
 
@@ -400,38 +329,12 @@ export class Collection<TSchema extends Document = Document> {
    * @param filter - The filter used to select the document to update
    * @param update - The update operations to be applied to the 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>;
-  updateOne(
-    filter: Filter<TSchema>,
-    update: UpdateFilter<TSchema> | Partial<TSchema>,
-    options: UpdateOptions
-  ): Promise<UpdateResult>;
-  /** @deprecated Callbacks are deprecated and will be removed in the next major version. See [mongodb-legacy](https://github.com/mongodb-js/nodejs-mongodb-legacy) for migration assistance */
-  updateOne(
-    filter: Filter<TSchema>,
-    update: UpdateFilter<TSchema> | Partial<TSchema>,
-    callback: Callback<UpdateResult>
-  ): void;
-  /** @deprecated Callbacks are deprecated and will be removed in the next major version. See [mongodb-legacy](https://github.com/mongodb-js/nodejs-mongodb-legacy) for migration assistance */
-  updateOne(
-    filter: Filter<TSchema>,
-    update: UpdateFilter<TSchema> | Partial<TSchema>,
-    options: UpdateOptions,
-    callback: Callback<UpdateResult>
-  ): void;
-  updateOne(
+  async updateOne(
     filter: Filter<TSchema>,
     update: UpdateFilter<TSchema> | Partial<TSchema>,
-    options?: UpdateOptions | Callback<UpdateResult>,
-    callback?: Callback<UpdateResult>
-  ): Promise<UpdateResult> | void {
-    if (typeof options === 'function') (callback = options), (options = {});
-
+    options?: UpdateOptions
+  ): Promise<UpdateResult> {
     return executeOperation(
       this.s.db.s.client,
       new UpdateOneOperation(
@@ -439,8 +342,7 @@ export class Collection<TSchema extends Document = Document> {
         filter,
         update,
         resolveOptions(this, options)
-      ) as TODO_NODE_3286,
-      callback
+      ) as TODO_NODE_3286
     );
   }
 
@@ -450,38 +352,12 @@ export class Collection<TSchema extends Document = Document> {
    * @param filter - The filter used to select the document to replace
    * @param replacement - The Document that replaces the matching document
    * @param options - Optional settings for the command
-   * @param callback - An optional callback, a Promise will be returned if none is provided
    */
-  replaceOne(
-    filter: Filter<TSchema>,
-    replacement: WithoutId<TSchema>
-  ): Promise<UpdateResult | Document>;
-  replaceOne(
-    filter: Filter<TSchema>,
-    replacement: WithoutId<TSchema>,
-    options: ReplaceOptions
-  ): Promise<UpdateResult | Document>;
-  /** @deprecated Callbacks are deprecated and will be removed in the next major version. See [mongodb-legacy](https://github.com/mongodb-js/nodejs-mongodb-legacy) for migration assistance */
-  replaceOne(
-    filter: Filter<TSchema>,
-    replacement: WithoutId<TSchema>,
-    callback: Callback<UpdateResult | Document>
-  ): void;
-  /** @deprecated Callbacks are deprecated and will be removed in the next major version. See [mongodb-legacy](https://github.com/mongodb-js/nodejs-mongodb-legacy) for migration assistance */
-  replaceOne(
-    filter: Filter<TSchema>,
-    replacement: WithoutId<TSchema>,
-    options: ReplaceOptions,
-    callback: Callback<UpdateResult | Document>
-  ): void;
-  replaceOne(
+  async replaceOne(
     filter: Filter<TSchema>,
     replacement: WithoutId<TSchema>,
-    options?: ReplaceOptions | Callback<UpdateResult | Document>,
-    callback?: Callback<UpdateResult | Document>
-  ): Promise<UpdateResult | Document> | void {
-    if (typeof options === 'function') (callback = options), (options = {});
-
+    options?: ReplaceOptions
+  ): Promise<UpdateResult | Document> {
     return executeOperation(
       this.s.db.s.client,
       new ReplaceOneOperation(
@@ -489,8 +365,7 @@ export class Collection<TSchema extends Document = Document> {
         filter,
         replacement,
         resolveOptions(this, options)
-      ),
-      callback
+      )
     );
   }
 
@@ -500,38 +375,12 @@ export class Collection<TSchema extends Document = Document> {
    * @param filter - The filter used to select the documents to update
    * @param update - The update operations to be applied to the documents
    * @param options - Optional settings for the command
-   * @param callback - An optional callback, a Promise will be returned if none is provided
    */
-  updateMany(
-    filter: Filter<TSchema>,
-    update: UpdateFilter<TSchema>
-  ): Promise<UpdateResult | Document>;
-  updateMany(
-    filter: Filter<TSchema>,
-    update: UpdateFilter<TSchema>,
-    options: UpdateOptions
-  ): Promise<UpdateResult | Document>;
-  /** @deprecated Callbacks are deprecated and will be removed in the next major version. See [mongodb-legacy](https://github.com/mongodb-js/nodejs-mongodb-legacy) for migration assistance */
-  updateMany(
-    filter: Filter<TSchema>,
-    update: UpdateFilter<TSchema>,
-    callback: Callback<UpdateResult | Document>
-  ): void;
-  /** @deprecated Callbacks are deprecated and will be removed in the next major version. See [mongodb-legacy](https://github.com/mongodb-js/nodejs-mongodb-legacy) for migration assistance */
-  updateMany(
-    filter: Filter<TSchema>,
-    update: UpdateFilter<TSchema>,
-    options: UpdateOptions,
-    callback: Callback<UpdateResult | Document>
-  ): void;
-  updateMany(
+  async updateMany(
     filter: Filter<TSchema>,
     update: UpdateFilter<TSchema>,
-    options?: UpdateOptions | Callback<UpdateResult | Document>,
-    callback?: Callback<UpdateResult | Document>
-  ): Promise<UpdateResult | Document> | void {
-    if (typeof options === 'function') (callback = options), (options = {});
-
+    options?: UpdateOptions
+  ): Promise<UpdateResult> {
     return executeOperation(
       this.s.db.s.client,
       new UpdateManyOperation(
@@ -539,8 +388,7 @@ export class Collection<TSchema extends Document = Document> {
         filter,
         update,
         resolveOptions(this, options)
-      ),
-      callback
+      ) as TODO_NODE_3286
     );
   }
 
@@ -549,29 +397,14 @@ export class Collection<TSchema extends Document = Document> {
    *
    * @param filter - The filter used to select the document to remove
    * @param options - Optional settings for the command
-   * @param callback - An optional callback, a Promise will be returned if none is provided
    */
-  deleteOne(filter: Filter<TSchema>): Promise<DeleteResult>;
-  deleteOne(filter: Filter<TSchema>, options: DeleteOptions): Promise<DeleteResult>;
-  /** @deprecated Callbacks are deprecated and will be removed in the next major version. See [mongodb-legacy](https://github.com/mongodb-js/nodejs-mongodb-legacy) for migration assistance */
-  deleteOne(filter: Filter<TSchema>, callback: Callback<DeleteResult>): void;
-  /** @deprecated Callbacks are deprecated and will be removed in the next major version. See [mongodb-legacy](https://github.com/mongodb-js/nodejs-mongodb-legacy) for migration assistance */
-  deleteOne(
-    filter: Filter<TSchema>,
-    options: DeleteOptions,
-    callback?: Callback<DeleteResult>
-  ): void;
-  deleteOne(
-    filter: Filter<TSchema>,
-    options?: DeleteOptions | Callback<DeleteResult>,
-    callback?: Callback<DeleteResult>
-  ): Promise<DeleteResult> | void {
-    if (typeof options === 'function') (callback = options), (options = {});
-
+  async deleteOne(
+    filter: Filter<TSchema> = {},
+    options: DeleteOptions = {}
+  ): Promise<DeleteResult> {
     return executeOperation(
       this.s.db.s.client,
-      new DeleteOneOperation(this as TODO_NODE_3286, filter, resolveOptions(this, options)),
-      callback
+      new DeleteOneOperation(this as TODO_NODE_3286, filter, resolveOptions(this, options))
     );
   }
 
@@ -580,40 +413,14 @@ export class Collection<TSchema extends Document = Document> {
    *
    * @param filter - The filter used to select the documents to remove
    * @param options - Optional settings for the command
-   * @param callback - An optional callback, a Promise will be returned if none is provided
    */
-  deleteMany(filter: Filter<TSchema>): Promise<DeleteResult>;
-  deleteMany(filter: Filter<TSchema>, options: DeleteOptions): Promise<DeleteResult>;
-  /** @deprecated Callbacks are deprecated and will be removed in the next major version. See [mongodb-legacy](https://github.com/mongodb-js/nodejs-mongodb-legacy) for migration assistance */
-  deleteMany(filter: Filter<TSchema>, callback: Callback<DeleteResult>): void;
-  /** @deprecated Callbacks are deprecated and will be removed in the next major version. See [mongodb-legacy](https://github.com/mongodb-js/nodejs-mongodb-legacy) for migration assistance */
-  deleteMany(
-    filter: Filter<TSchema>,
-    options: DeleteOptions,
-    callback: Callback<DeleteResult>
-  ): void;
-  deleteMany(
-    filter: Filter<TSchema>,
-    options?: DeleteOptions | Callback<DeleteResult>,
-    callback?: Callback<DeleteResult>
-  ): Promise<DeleteResult> | void {
-    if (filter == null) {
-      filter = {};
-      options = {};
-      callback = undefined;
-    } else if (typeof filter === 'function') {
-      callback = filter as Callback<DeleteResult>;
-      filter = {};
-      options = {};
-    } else if (typeof options === 'function') {
-      callback = options;
-      options = {};
-    }
-
+  async deleteMany(
+    filter: Filter<TSchema> = {},
+    options: DeleteOptions = {}
+  ): Promise<DeleteResult> {
     return executeOperation(
       this.s.db.s.client,
-      new DeleteManyOperation(this as TODO_NODE_3286, filter, resolveOptions(this, options)),
-      callback
+      new DeleteManyOperation(this as TODO_NODE_3286, filter, resolveOptions(this, options))
     );
   }
 
@@ -625,29 +432,15 @@ export class Collection<TSchema extends Document = Document> {
    *
    * @param newName - New name of of the collection.
    * @param options - Optional settings for the command
-   * @param callback - An optional callback, a Promise will be returned if none is provided
    */
-  rename(newName: string): Promise<Collection>;
-  rename(newName: string, options: RenameOptions): Promise<Collection>;
-  /** @deprecated Callbacks are deprecated and will be removed in the next major version. See [mongodb-legacy](https://github.com/mongodb-js/nodejs-mongodb-legacy) for migration assistance */
-  rename(newName: string, callback: Callback<Collection>): void;
-  /** @deprecated Callbacks are deprecated and will be removed in the next major version. See [mongodb-legacy](https://github.com/mongodb-js/nodejs-mongodb-legacy) for migration assistance */
-  rename(newName: string, options: RenameOptions, callback: Callback<Collection>): void;
-  rename(
-    newName: string,
-    options?: RenameOptions | Callback<Collection>,
-    callback?: Callback<Collection>
-  ): Promise<Collection> | void {
-    if (typeof options === 'function') (callback = options), (options = {});
-
+  async rename(newName: string, options?: RenameOptions): Promise<Collection> {
     // Intentionally, we do not inherit options from parent for this operation.
     return executeOperation(
       this.s.db.s.client,
       new RenameOperation(this as TODO_NODE_3286, newName, {
         ...options,
         readPreference: ReadPreference.PRIMARY
-      }) as TODO_NODE_3286,
-      callback
+      }) as TODO_NODE_3286
     );
   }
 
@@ -655,25 +448,11 @@ export class Collection<TSchema extends Document = Document> {
    * Drop the collection from the database, removing it permanently. New accesses will create a new collection.
    *
    * @param options - Optional settings for the command
-   * @param callback - An optional callback, a Promise will be returned if none is provided
    */
-  drop(): Promise<boolean>;
-  drop(options: DropCollectionOptions): Promise<boolean>;
-  /** @deprecated Callbacks are deprecated and will be removed in the next major version. See [mongodb-legacy](https://github.com/mongodb-js/nodejs-mongodb-legacy) for migration assistance */
-  drop(callback: Callback<boolean>): void;
-  /** @deprecated Callbacks are deprecated and will be removed in the next major version. See [mongodb-legacy](https://github.com/mongodb-js/nodejs-mongodb-legacy) for migration assistance */
-  drop(options: DropCollectionOptions, callback: Callback<boolean>): void;
-  drop(
-    options?: DropCollectionOptions | Callback<boolean>,
-    callback?: Callback<boolean>
-  ): Promise<boolean> | void {
-    if (typeof options === 'function') (callback = options), (options = {});
-    options = options ?? {};
-
+  async drop(options?: DropCollectionOptions): Promise<boolean> {
     return executeOperation(
       this.s.db.s.client,
-      new DropCollectionOperation(this.s.db, this.collectionName, options),
-      callback
+      new DropCollectionOperation(this.s.db, this.collectionName, options)
     );
   }
 
@@ -682,59 +461,21 @@ export class Collection<TSchema extends Document = Document> {
    *
    * @param filter - Query for find Operation
    * @param options - Optional settings for the command
-   * @param callback - An optional callback, a Promise will be returned if none is provided
    */
-  findOne(): Promise<WithId<TSchema> | null>;
-  findOne(filter: Filter<TSchema>): Promise<WithId<TSchema> | null>;
-  findOne(filter: Filter<TSchema>, options: FindOptions): Promise<WithId<TSchema> | null>;
-  /** @deprecated Callbacks are deprecated and will be removed in the next major version. See [mongodb-legacy](https://github.com/mongodb-js/nodejs-mongodb-legacy) for migration assistance */
-  findOne(callback: Callback<WithId<TSchema> | null>): void;
-  /** @deprecated Callbacks are deprecated and will be removed in the next major version. See [mongodb-legacy](https://github.com/mongodb-js/nodejs-mongodb-legacy) for migration assistance */
-  findOne(filter: Filter<TSchema>, callback: Callback<WithId<TSchema> | null>): void;
-  /** @deprecated Callbacks are deprecated and will be removed in the next major version. See [mongodb-legacy](https://github.com/mongodb-js/nodejs-mongodb-legacy) for migration assistance */
-  findOne(
-    filter: Filter<TSchema>,
-    options: FindOptions,
-    callback: Callback<WithId<TSchema> | null>
-  ): void;
+  async findOne(): Promise<WithId<TSchema> | null>;
+  async findOne(filter: Filter<TSchema>): Promise<WithId<TSchema> | null>;
+  async findOne(filter: Filter<TSchema>, options: FindOptions): Promise<WithId<TSchema> | null>;
 
   // allow an override of the schema.
-  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>;
-  /** @deprecated Callbacks are deprecated and will be removed in the next major version. See [mongodb-legacy](https://github.com/mongodb-js/nodejs-mongodb-legacy) for migration assistance */
-  findOne<T = TSchema>(callback: Callback<T | null>): void;
-  /** @deprecated Callbacks are deprecated and will be removed in the next major version. See [mongodb-legacy](https://github.com/mongodb-js/nodejs-mongodb-legacy) for migration assistance */
-  findOne<T = TSchema>(
-    filter: Filter<TSchema>,
-    options?: FindOptions,
-    callback?: Callback<T | null>
-  ): void;
-
-  findOne(
-    filter?: Filter<TSchema> | Callback<WithId<TSchema> | null>,
-    options?: FindOptions | Callback<WithId<TSchema> | null>,
-    callback?: Callback<WithId<TSchema> | null>
-  ): Promise<WithId<TSchema> | null> | void {
-    if (callback != null && typeof callback !== 'function') {
-      throw new MongoInvalidArgumentError(
-        'Third parameter to `findOne()` must be a callback or undefined'
-      );
-    }
+  async findOne<T = TSchema>(): Promise<T | null>;
+  async findOne<T = TSchema>(filter: Filter<TSchema>): Promise<T | null>;
+  async findOne<T = TSchema>(filter: Filter<TSchema>, options?: FindOptions): Promise<T | null>;
 
-    if (typeof filter === 'function') {
-      callback = filter;
-      filter = {};
-      options = {};
-    }
-    if (typeof options === 'function') {
-      callback = options;
-      options = {};
-    }
-
-    const finalFilter = filter ?? {};
-    const finalOptions = options ?? {};
-    return this.find(finalFilter, finalOptions).limit(-1).batchSize(1).next(callback);
+  async findOne(
+    filter: Filter<TSchema> = {},
+    options: FindOptions = {}
+  ): Promise<WithId<TSchema> | null> {
+    return this.find(filter, options).limit(-1).batchSize(1).next();
   }
 
   /**
@@ -745,16 +486,7 @@ export class Collection<TSchema extends Document = Document> {
   find(): FindCursor<WithId<TSchema>>;
   find(filter: Filter<TSchema>, options?: FindOptions): FindCursor<WithId<TSchema>>;
   find<T extends Document>(filter: Filter<TSchema>, options?: FindOptions): FindCursor<T>;
-  find(filter?: Filter<TSchema>, options?: FindOptions): FindCursor<WithId<TSchema>> {
-    if (arguments.length > 2) {
-      throw new MongoInvalidArgumentError(
-        'Method "collection.find()" accepts at most two arguments'
-      );
-    }
-    if (typeof options === 'function') {
-      throw new MongoInvalidArgumentError('Argument "options" must not be function');
-    }
-
+  find(filter: Filter<TSchema> = {}, options: FindOptions = {}): FindCursor<WithId<TSchema>> {
     return new FindCursor<WithId<TSchema>>(
       this.s.db.s.client,
       this.s.namespace,
@@ -767,24 +499,11 @@ export class Collection<TSchema extends Document = Document> {
    * Returns the options of the collection.
    *
    * @param options - Optional settings for the command
-   * @param callback - An optional callback, a Promise will be returned if none is provided
    */
-  options(): Promise<Document>;
-  options(options: OperationOptions): Promise<Document>;
-  /** @deprecated Callbacks are deprecated and will be removed in the next major version. See [mongodb-legacy](https://github.com/mongodb-js/nodejs-mongodb-legacy) for migration assistance */
-  options(callback: Callback<Document>): void;
-  /** @deprecated Callbacks are deprecated and will be removed in the next major version. See [mongodb-legacy](https://github.com/mongodb-js/nodejs-mongodb-legacy) for migration assistance */
-  options(options: OperationOptions, callback: Callback<Document>): void;
-  options(
-    options?: OperationOptions | Callback<Document>,
-    callback?: Callback<Document>
-  ): Promise<Document> | void {
-    if (typeof options === 'function') (callback = options), (options = {});
-
+  async options(options?: OperationOptions): Promise<Document> {
     return executeOperation(
       this.s.db.s.client,
-      new OptionsOperation(this as TODO_NODE_3286, resolveOptions(this, options)),
-      callback
+      new OptionsOperation(this as TODO_NODE_3286, resolveOptions(this, options))
     );
   }
 
@@ -792,24 +511,11 @@ export class Collection<TSchema extends Document = Document> {
    * Returns if the collection is a capped collection
    *
    * @param options - Optional settings for the command
-   * @param callback - An optional callback, a Promise will be returned if none is provided
    */
-  isCapped(): Promise<boolean>;
-  isCapped(options: OperationOptions): Promise<boolean>;
-  /** @deprecated Callbacks are deprecated and will be removed in the next major version. See [mongodb-legacy](https://github.com/mongodb-js/nodejs-mongodb-legacy) for migration assistance */
-  isCapped(callback: Callback<boolean>): void;
-  /** @deprecated Callbacks are deprecated and will be removed in the next major version. See [mongodb-legacy](https://github.com/mongodb-js/nodejs-mongodb-legacy) for migration assistance */
-  isCapped(options: OperationOptions, callback: Callback<boolean>): void;
-  isCapped(
-    options?: OperationOptions | Callback<boolean>,
-    callback?: Callback<boolean>
-  ): Promise<boolean> | void {
-    if (typeof options === 'function') (callback = options), (options = {});
-
+  async isCapped(options?: OperationOptions): Promise<boolean> {
     return executeOperation(
       this.s.db.s.client,
-      new IsCappedOperation(this as TODO_NODE_3286, resolveOptions(this, options)),
-      callback
+      new IsCappedOperation(this as TODO_NODE_3286, resolveOptions(this, options))
     );
   }
 
@@ -818,7 +524,6 @@ export class Collection<TSchema extends Document = Document> {
    *
    * @param indexSpec - The field name or index specification to create an index for
    * @param options - Optional settings for the command
-   * @param callback - An optional callback, a Promise will be returned if none is provided
    *
    * @example
    * ```ts
@@ -842,23 +547,10 @@ export class Collection<TSchema extends Document = Document> {
    * await collection.createIndex(['j', ['k', -1], { l: '2d' }])
    * ```
    */
-  createIndex(indexSpec: IndexSpecification): Promise<string>;
-  createIndex(indexSpec: IndexSpecification, options: CreateIndexesOptions): Promise<string>;
-  /** @deprecated Callbacks are deprecated and will be removed in the next major version. See [mongodb-legacy](https://github.com/mongodb-js/nodejs-mongodb-legacy) for migration assistance */
-  createIndex(indexSpec: IndexSpecification, callback: Callback<string>): void;
-  /** @deprecated Callbacks are deprecated and will be removed in the next major version. See [mongodb-legacy](https://github.com/mongodb-js/nodejs-mongodb-legacy) for migration assistance */
-  createIndex(
-    indexSpec: IndexSpecification,
-    options: CreateIndexesOptions,
-    callback: Callback<string>
-  ): void;
-  createIndex(
+  async createIndex(
     indexSpec: IndexSpecification,
-    options?: CreateIndexesOptions | Callback<string>,
-    callback?: Callback<string>
-  ): Promise<string> | void {
-    if (typeof options === 'function') (callback = options), (options = {});
-
+    options?: CreateIndexesOptions
+  ): Promise<string> {
     return executeOperation(
       this.s.db.s.client,
       new CreateIndexOperation(
@@ -866,8 +558,7 @@ export class Collection<TSchema extends Document = Document> {
         this.collectionName,
         indexSpec,
         resolveOptions(this, options)
-      ),
-      callback
+      )
     );
   }
 
@@ -881,7 +572,6 @@ export class Collection<TSchema extends Document = Document> {
    *
    * @param indexSpecs - An array of index specifications to be created
    * @param options - Optional settings for the command
-   * @param callback - An optional callback, a Promise will be returned if none is provided
    *
    * @example
    * ```ts
@@ -903,34 +593,18 @@ export class Collection<TSchema extends Document = Document> {
    * ]);
    * ```
    */
-  createIndexes(indexSpecs: IndexDescription[]): Promise<string[]>;
-  createIndexes(indexSpecs: IndexDescription[], options: CreateIndexesOptions): Promise<string[]>;
-  /** @deprecated Callbacks are deprecated and will be removed in the next major version. See [mongodb-legacy](https://github.com/mongodb-js/nodejs-mongodb-legacy) for migration assistance */
-  createIndexes(indexSpecs: IndexDescription[], callback: Callback<string[]>): void;
-  /** @deprecated Callbacks are deprecated and will be removed in the next major version. See [mongodb-legacy](https://github.com/mongodb-js/nodejs-mongodb-legacy) for migration assistance */
-  createIndexes(
-    indexSpecs: IndexDescription[],
-    options: CreateIndexesOptions,
-    callback: Callback<string[]>
-  ): void;
-  createIndexes(
+  async createIndexes(
     indexSpecs: IndexDescription[],
-    options?: CreateIndexesOptions | Callback<string[]>,
-    callback?: Callback<string[]>
-  ): Promise<string[]> | void {
-    if (typeof options === 'function') (callback = options), (options = {});
-    options = options ? Object.assign({}, options) : {};
-    if (typeof options.maxTimeMS !== 'number') delete options.maxTimeMS;
-
+    options?: CreateIndexesOptions
+  ): Promise<string[]> {
     return executeOperation(
       this.s.db.s.client,
       new CreateIndexesOperation(
         this as TODO_NODE_3286,
         this.collectionName,
         indexSpecs,
-        resolveOptions(this, options)
-      ),
-      callback
+        resolveOptions(this, { ...options, maxTimeMS: undefined })
+      )
     );
   }
 
@@ -939,29 +613,14 @@ export class Collection<TSchema extends Document = Document> {
    *
    * @param indexName - Name of the index to drop.
    * @param options - Optional settings for the command
-   * @param callback - An optional callback, a Promise will be returned if none is provided
    */
-  dropIndex(indexName: string): Promise<Document>;
-  dropIndex(indexName: string, options: DropIndexesOptions): Promise<Document>;
-  /** @deprecated Callbacks are deprecated and will be removed in the next major version. See [mongodb-legacy](https://github.com/mongodb-js/nodejs-mongodb-legacy) for migration assistance */
-  dropIndex(indexName: string, callback: Callback<Document>): void;
-  /** @deprecated Callbacks are deprecated and will be removed in the next major version. See [mongodb-legacy](https://github.com/mongodb-js/nodejs-mongodb-legacy) for migration assistance */
-  dropIndex(indexName: string, options: DropIndexesOptions, callback: Callback<Document>): void;
-  dropIndex(
-    indexName: string,
-    options?: DropIndexesOptions | Callback<Document>,
-    callback?: Callback<Document>
-  ): Promise<Document> | void {
-    if (typeof options === 'function') (callback = options), (options = {});
-    options = resolveOptions(this, options);
-
-    // Run only against primary
-    options.readPreference = ReadPreference.primary;
-
+  async dropIndex(indexName: string, options?: DropIndexesOptions): Promise<Document> {
     return executeOperation(
       this.s.db.s.client,
-      new DropIndexOperation(this as TODO_NODE_3286, indexName, options),
-      callback
+      new DropIndexOperation(this as TODO_NODE_3286, indexName, {
+        ...resolveOptions(this, options),
+        readPreference: ReadPreference.primary
+      })
     );
   }
 
@@ -969,24 +628,11 @@ export class Collection<TSchema extends Document = Document> {
    * Drops all indexes from this collection.
    *
    * @param options - Optional settings for the command
-   * @param callback - An optional callback, a Promise will be returned if none is provided
    */
-  dropIndexes(): Promise<Document>;
-  dropIndexes(options: DropIndexesOptions): Promise<Document>;
-  /** @deprecated Callbacks are deprecated and will be removed in the next major version. See [mongodb-legacy](https://github.com/mongodb-js/nodejs-mongodb-legacy) for migration assistance */
-  dropIndexes(callback: Callback<Document>): void;
-  /** @deprecated Callbacks are deprecated and will be removed in the next major version. See [mongodb-legacy](https://github.com/mongodb-js/nodejs-mongodb-legacy) for migration assistance */
-  dropIndexes(options: DropIndexesOptions, callback: Callback<Document>): void;
-  dropIndexes(
-    options?: DropIndexesOptions | Callback<Document>,
-    callback?: Callback<Document>
-  ): Promise<Document> | void {
-    if (typeof options === 'function') (callback = options), (options = {});
-
+  async dropIndexes(options?: DropIndexesOptions): Promise<Document> {
     return executeOperation(
       this.s.db.s.client,
-      new DropIndexesOperation(this as TODO_NODE_3286, resolveOptions(this, options)),
-      callback
+      new DropIndexesOperation(this as TODO_NODE_3286, resolveOptions(this, options))
     );
   }
 
@@ -1004,29 +650,14 @@ export class Collection<TSchema extends Document = Document> {
    *
    * @param indexes - One or more index names to check.
    * @param options - Optional settings for the command
-   * @param callback - An optional callback, a Promise will be returned if none is provided
    */
-  indexExists(indexes: string | string[]): Promise<boolean>;
-  indexExists(indexes: string | string[], options: IndexInformationOptions): Promise<boolean>;
-  /** @deprecated Callbacks are deprecated and will be removed in the next major version. See [mongodb-legacy](https://github.com/mongodb-js/nodejs-mongodb-legacy) for migration assistance */
-  indexExists(indexes: string | string[], callback: Callback<boolean>): void;
-  /** @deprecated Callbacks are deprecated and will be removed in the next major version. See [mongodb-legacy](https://github.com/mongodb-js/nodejs-mongodb-legacy) for migration assistance */
-  indexExists(
-    indexes: string | string[],
-    options: IndexInformationOptions,
-    callback: Callback<boolean>
-  ): void;
-  indexExists(
+  async indexExists(
     indexes: string | string[],
-    options?: IndexInformationOptions | Callback<boolean>,
-    callback?: Callback<boolean>
-  ): Promise<boolean> | void {
-    if (typeof options === 'function') (callback = options), (options = {});
-
+    options?: IndexInformationOptions
+  ): Promise<boolean> {
     return executeOperation(
       this.s.db.s.client,
-      new IndexExistsOperation(this as TODO_NODE_3286, indexes, resolveOptions(this, options)),
-      callback
+      new IndexExistsOperation(this as TODO_NODE_3286, indexes, resolveOptions(this, options))
     );
   }
 
@@ -1034,24 +665,11 @@ export class Collection<TSchema extends Document = Document> {
    * Retrieves this collections index info.
    *
    * @param options - Optional settings for the command
-   * @param callback - An optional callback, a Promise will be returned if none is provided
    */
-  indexInformation(): Promise<Document>;
-  indexInformation(options: IndexInformationOptions): Promise<Document>;
-  /** @deprecated Callbacks are deprecated and will be removed in the next major version. See [mongodb-legacy](https://github.com/mongodb-js/nodejs-mongodb-legacy) for migration assistance */
-  indexInformation(callback: Callback<Document>): void;
-  /** @deprecated Callbacks are deprecated and will be removed in the next major version. See [mongodb-legacy](https://github.com/mongodb-js/nodejs-mongodb-legacy) for migration assistance */
-  indexInformation(options: IndexInformationOptions, callback: Callback<Document>): void;
-  indexInformation(
-    options?: IndexInformationOptions | Callback<Document>,
-    callback?: Callback<Document>
-  ): Promise<Document> | void {
-    if (typeof options === 'function') (callback = options), (options = {});
-
+  async indexInformation(options?: IndexInformationOptions): Promise<Document> {
     return executeOperation(
       this.s.db.s.client,
-      new IndexInformationOperation(this.s.db, this.collectionName, resolveOptions(this, options)),
-      callback
+      new IndexInformationOperation(this.s.db, this.collectionName, resolveOptions(this, options))
     );
   }
 
@@ -1067,23 +685,11 @@ export class Collection<TSchema extends Document = Document> {
    *
    * @see {@link https://www.mongodb.com/docs/manual/reference/command/count/#behavior|Count: Behavior}
    * @param options - Optional settings for the command
-   * @param callback - An optional callback, a Promise will be returned if none is provided
    */
-  estimatedDocumentCount(): Promise<number>;
-  estimatedDocumentCount(options: EstimatedDocumentCountOptions): Promise<number>;
-  /** @deprecated Callbacks are deprecated and will be removed in the next major version. See [mongodb-legacy](https://github.com/mongodb-js/nodejs-mongodb-legacy) for migration assistance */
-  estimatedDocumentCount(callback: Callback<number>): void;
-  /** @deprecated Callbacks are deprecated and will be removed in the next major version. See [mongodb-legacy](https://github.com/mongodb-js/nodejs-mongodb-legacy) for migration assistance */
-  estimatedDocumentCount(options: EstimatedDocumentCountOptions, callback: Callback<number>): void;
-  estimatedDocumentCount(
-    options?: EstimatedDocumentCountOptions | Callback<number>,
-    callback?: Callback<number>
-  ): Promise<number> | void {
-    if (typeof options === 'function') (callback = options), (options = {});
+  async estimatedDocumentCount(options?: EstimatedDocumentCountOptions): Promise<number> {
     return executeOperation(
       this.s.db.s.client,
-      new EstimatedDocumentCountOperation(this as TODO_NODE_3286, resolveOptions(this, options)),
-      callback
+      new EstimatedDocumentCountOperation(this as TODO_NODE_3286, resolveOptions(this, options))
     );
   }
 
@@ -1106,50 +712,19 @@ export class Collection<TSchema extends Document = Document> {
    *
    * @param filter - The filter for the count
    * @param options - Optional settings for the command
-   * @param callback - An optional callback, a Promise will be returned if none is provided
    *
    * @see https://docs.mongodb.com/manual/reference/operator/query/expr/
    * @see https://docs.mongodb.com/manual/reference/operator/query/geoWithin/
    * @see https://docs.mongodb.com/manual/reference/operator/query/center/#op._S_center
    * @see https://docs.mongodb.com/manual/reference/operator/query/centerSphere/#op._S_centerSphere
    */
-  countDocuments(): Promise<number>;
-  countDocuments(filter: Filter<TSchema>): Promise<number>;
-  countDocuments(filter: Filter<TSchema>, options: CountDocumentsOptions): Promise<number>;
-  /** @deprecated Callbacks are deprecated and will be removed in the next major version. See [mongodb-legacy](https://github.com/mongodb-js/nodejs-mongodb-legacy) for migration assistance */
-  countDocuments(callback: Callback<number>): void;
-  /** @deprecated Callbacks are deprecated and will be removed in the next major version. See [mongodb-legacy](https://github.com/mongodb-js/nodejs-mongodb-legacy) for migration assistance */
-  countDocuments(filter: Filter<TSchema>, callback: Callback<number>): void;
-  /** @deprecated Callbacks are deprecated and will be removed in the next major version. See [mongodb-legacy](https://github.com/mongodb-js/nodejs-mongodb-legacy) for migration assistance */
-  countDocuments(
-    filter: Filter<TSchema>,
-    options: CountDocumentsOptions,
-    callback: Callback<number>
-  ): void;
-  countDocuments(
-    filter?: Document | CountDocumentsOptions | Callback<number>,
-    options?: CountDocumentsOptions | Callback<number>,
-    callback?: Callback<number>
-  ): Promise<number> | void {
-    if (filter == null) {
-      (filter = {}), (options = {}), (callback = undefined);
-    } else if (typeof filter === 'function') {
-      (callback = filter as Callback<number>), (filter = {}), (options = {});
-    } else {
-      if (arguments.length === 2) {
-        if (typeof options === 'function') (callback = options), (options = {});
-      }
-    }
-
-    filter ??= {};
+  async countDocuments(
+    filter: Document = {},
+    options: CountDocumentsOptions = {}
+  ): Promise<number> {
     return executeOperation(
       this.s.db.s.client,
-      new CountDocumentsOperation(
-        this as TODO_NODE_3286,
-        filter,
-        resolveOptions(this, options as CountDocumentsOptions)
-      ),
-      callback
+      new CountDocumentsOperation(this as TODO_NODE_3286, filter, resolveOptions(this, options))
     );
   }
 
@@ -1159,7 +734,6 @@ export class Collection<TSchema extends Document = Document> {
    * @param key - Field of the document to find distinct values for
    * @param filter - The filter for filtering the set of documents to which we apply the distinct filter.
    * @param options - Optional settings for the command
-   * @param callback - An optional callback, a Promise will be returned if none is provided
    */
   distinct<Key extends keyof WithId<TSchema>>(
     key: Key
@@ -1173,65 +747,25 @@ export class Collection<TSchema extends Document = Document> {
     filter: Filter<TSchema>,
     options: DistinctOptions
   ): Promise<Array<Flatten<WithId<TSchema>[Key]>>>;
-  /** @deprecated Callbacks are deprecated and will be removed in the next major version. See [mongodb-legacy](https://github.com/mongodb-js/nodejs-mongodb-legacy) for migration assistance */
-  distinct<Key extends keyof WithId<TSchema>>(
-    key: Key,
-    callback: Callback<Array<Flatten<WithId<TSchema>[Key]>>>
-  ): void;
-  /** @deprecated Callbacks are deprecated and will be removed in the next major version. See [mongodb-legacy](https://github.com/mongodb-js/nodejs-mongodb-legacy) for migration assistance */
-  distinct<Key extends keyof WithId<TSchema>>(
-    key: Key,
-    filter: Filter<TSchema>,
-    callback: Callback<Array<Flatten<WithId<TSchema>[Key]>>>
-  ): void;
-  /** @deprecated Callbacks are deprecated and will be removed in the next major version. See [mongodb-legacy](https://github.com/mongodb-js/nodejs-mongodb-legacy) for migration assistance */
-  distinct<Key extends keyof WithId<TSchema>>(
-    key: Key,
-    filter: Filter<TSchema>,
-    options: DistinctOptions,
-    callback: Callback<Array<Flatten<WithId<TSchema>[Key]>>>
-  ): void;
 
   // Embedded documents overload
   distinct(key: string): Promise<any[]>;
   distinct(key: string, filter: Filter<TSchema>): Promise<any[]>;
   distinct(key: string, filter: Filter<TSchema>, options: DistinctOptions): Promise<any[]>;
-  /** @deprecated Callbacks are deprecated and will be removed in the next major version. See [mongodb-legacy](https://github.com/mongodb-js/nodejs-mongodb-legacy) for migration assistance */
-  distinct(key: string, callback: Callback<any[]>): void;
-  /** @deprecated Callbacks are deprecated and will be removed in the next major version. See [mongodb-legacy](https://github.com/mongodb-js/nodejs-mongodb-legacy) for migration assistance */
-  distinct(key: string, filter: Filter<TSchema>, callback: Callback<any[]>): void;
-  /** @deprecated Callbacks are deprecated and will be removed in the next major version. See [mongodb-legacy](https://github.com/mongodb-js/nodejs-mongodb-legacy) for migration assistance */
-  distinct(
-    key: string,
-    filter: Filter<TSchema>,
-    options: DistinctOptions,
-    callback: Callback<any[]>
-  ): void;
-  // Implementation
-  distinct<Key extends keyof WithId<TSchema>>(
-    key: Key,
-    filter?: Filter<TSchema> | DistinctOptions | Callback<any[]>,
-    options?: DistinctOptions | Callback<any[]>,
-    callback?: Callback<any[]>
-  ): Promise<any[]> | void {
-    if (typeof filter === 'function') {
-      (callback = filter), (filter = {}), (options = {});
-    } else {
-      if (arguments.length === 3 && typeof options === 'function') {
-        (callback = options), (options = {});
-      }
-    }
 
-    filter ??= {};
+  async distinct<Key extends keyof WithId<TSchema>>(
+    key: Key,
+    filter: Filter<TSchema> = {},
+    options: DistinctOptions = {}
+  ): Promise<any[]> {
     return executeOperation(
       this.s.db.s.client,
       new DistinctOperation(
         this as TODO_NODE_3286,
         key as TODO_NODE_3286,
         filter,
-        resolveOptions(this, options as DistinctOptions)
-      ),
-      callback
+        resolveOptions(this, options)
+      )
     );
   }
 
@@ -1239,24 +773,11 @@ export class Collection<TSchema extends Document = Document> {
    * Retrieve all the indexes on the collection.
    *
    * @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(options: IndexInformationOptions): Promise<Document[]>;
-  /** @deprecated Callbacks are deprecated and will be removed in the next major version. See [mongodb-legacy](https://github.com/mongodb-js/nodejs-mongodb-legacy) for migration assistance */
-  indexes(callback: Callback<Document[]>): void;
-  /** @deprecated Callbacks are deprecated and will be removed in the next major version. See [mongodb-legacy](https://github.com/mongodb-js/nodejs-mongodb-legacy) for migration assistance */
-  indexes(options: IndexInformationOptions, callback: Callback<Document[]>): void;
-  indexes(
-    options?: IndexInformationOptions | Callback<Document[]>,
-    callback?: Callback<Document[]>
-  ): Promise<Document[]> | void {
-    if (typeof options === 'function') (callback = options), (options = {});
-
+  async indexes(options?: IndexInformationOptions): Promise<Document[]> {
     return executeOperation(
       this.s.db.s.client,
-      new IndexesOperation(this as TODO_NODE_3286, resolveOptions(this, options)),
-      callback
+      new IndexesOperation(this as TODO_NODE_3286, resolveOptions(this, options))
     );
   }
 
@@ -1264,25 +785,11 @@ export class Collection<TSchema extends Document = Document> {
    * Get all the collection statistics.
    *
    * @param options - Optional settings for the command
-   * @param callback - An optional callback, a Promise will be returned if none is provided
    */
-  stats(): Promise<CollStats>;
-  stats(options: CollStatsOptions): Promise<CollStats>;
-  /** @deprecated Callbacks are deprecated and will be removed in the next major version. See [mongodb-legacy](https://github.com/mongodb-js/nodejs-mongodb-legacy) for migration assistance */
-  stats(callback: Callback<CollStats>): void;
-  /** @deprecated Callbacks are deprecated and will be removed in the next major version. See [mongodb-legacy](https://github.com/mongodb-js/nodejs-mongodb-legacy) for migration assistance */
-  stats(options: CollStatsOptions, callback: Callback<CollStats>): void;
-  stats(
-    options?: CollStatsOptions | Callback<CollStats>,
-    callback?: Callback<CollStats>
-  ): Promise<CollStats> | void {
-    if (typeof options === 'function') (callback = options), (options = {});
-    options = options ?? {};
-
+  async stats(options?: CollStatsOptions): Promise<CollStats> {
     return executeOperation(
       this.s.db.s.client,
-      new CollStatsOperation(this as TODO_NODE_3286, options) as TODO_NODE_3286,
-      callback
+      new CollStatsOperation(this as TODO_NODE_3286, options) as TODO_NODE_3286
     );
   }
 
@@ -1291,36 +798,18 @@ export class Collection<TSchema extends Document = Document> {
    *
    * @param filter - The filter used to select the document to remove
    * @param options - Optional settings for the command
-   * @param callback - An optional callback, a Promise will be returned if none is provided
    */
-  findOneAndDelete(filter: Filter<TSchema>): Promise<ModifyResult<TSchema>>;
-  findOneAndDelete(
+  async findOneAndDelete(
     filter: Filter<TSchema>,
-    options: FindOneAndDeleteOptions
-  ): Promise<ModifyResult<TSchema>>;
-  /** @deprecated Callbacks are deprecated and will be removed in the next major version. See [mongodb-legacy](https://github.com/mongodb-js/nodejs-mongodb-legacy) for migration assistance */
-  findOneAndDelete(filter: Filter<TSchema>, callback: Callback<ModifyResult<TSchema>>): void;
-  /** @deprecated Callbacks are deprecated and will be removed in the next major version. See [mongodb-legacy](https://github.com/mongodb-js/nodejs-mongodb-legacy) for migration assistance */
-  findOneAndDelete(
-    filter: Filter<TSchema>,
-    options: FindOneAndDeleteOptions,
-    callback: Callback<ModifyResult<TSchema>>
-  ): void;
-  findOneAndDelete(
-    filter: Filter<TSchema>,
-    options?: FindOneAndDeleteOptions | Callback<ModifyResult<TSchema>>,
-    callback?: Callback<ModifyResult<TSchema>>
-  ): Promise<Document> | void {
-    if (typeof options === 'function') (callback = options), (options = {});
-
+    options?: FindOneAndDeleteOptions
+  ): Promise<ModifyResult<TSchema>> {
     return executeOperation(
       this.s.db.s.client,
       new FindOneAndDeleteOperation(
         this as TODO_NODE_3286,
         filter,
         resolveOptions(this, options)
-      ) as TODO_NODE_3286,
-      callback
+      ) as TODO_NODE_3286
     );
   }
 
@@ -1330,38 +819,12 @@ export class Collection<TSchema extends Document = Document> {
    * @param filter - The filter used to select the document to replace
    * @param replacement - The Document that replaces the matching document
    * @param options - Optional settings for the command
-   * @param callback - An optional callback, a Promise will be returned if none is provided
    */
-  findOneAndReplace(
-    filter: Filter<TSchema>,
-    replacement: WithoutId<TSchema>
-  ): Promise<ModifyResult<TSchema>>;
-  findOneAndReplace(
+  async findOneAndReplace(
     filter: Filter<TSchema>,
     replacement: WithoutId<TSchema>,
-    options: FindOneAndReplaceOptions
-  ): Promise<ModifyResult<TSchema>>;
-  /** @deprecated Callbacks are deprecated and will be removed in the next major version. See [mongodb-legacy](https://github.com/mongodb-js/nodejs-mongodb-legacy) for migration assistance */
-  findOneAndReplace(
-    filter: Filter<TSchema>,
-    replacement: WithoutId<TSchema>,
-    callback: Callback<ModifyResult<TSchema>>
-  ): void;
-  /** @deprecated Callbacks are deprecated and will be removed in the next major version. See [mongodb-legacy](https://github.com/mongodb-js/nodejs-mongodb-legacy) for migration assistance */
-  findOneAndReplace(
-    filter: Filter<TSchema>,
-    replacement: WithoutId<TSchema>,
-    options: FindOneAndReplaceOptions,
-    callback: Callback<ModifyResult<TSchema>>
-  ): void;
-  findOneAndReplace(
-    filter: Filter<TSchema>,
-    replacement: WithoutId<TSchema>,
-    options?: FindOneAndReplaceOptions | Callback<ModifyResult<TSchema>>,
-    callback?: Callback<ModifyResult<TSchema>>
-  ): Promise<ModifyResult<TSchema>> | void {
-    if (typeof options === 'function') (callback = options), (options = {});
-
+    options?: FindOneAndReplaceOptions
+  ): Promise<ModifyResult<TSchema>> {
     return executeOperation(
       this.s.db.s.client,
       new FindOneAndReplaceOperation(
@@ -1369,8 +832,7 @@ export class Collection<TSchema extends Document = Document> {
         filter,
         replacement,
         resolveOptions(this, options)
-      ) as TODO_NODE_3286,
-      callback
+      ) as TODO_NODE_3286
     );
   }
 
@@ -1380,38 +842,12 @@ export class Collection<TSchema extends Document = Document> {
    * @param filter - The filter used to select the document to update
    * @param update - Update operations to be performed on the document
    * @param options - Optional settings for the command
-   * @param callback - An optional callback, a Promise will be returned if none is provided
    */
-  findOneAndUpdate(
-    filter: Filter<TSchema>,
-    update: UpdateFilter<TSchema>
-  ): Promise<ModifyResult<TSchema>>;
-  findOneAndUpdate(
-    filter: Filter<TSchema>,
-    update: UpdateFilter<TSchema>,
-    options: FindOneAndUpdateOptions
-  ): Promise<ModifyResult<TSchema>>;
-  /** @deprecated Callbacks are deprecated and will be removed in the next major version. See [mongodb-legacy](https://github.com/mongodb-js/nodejs-mongodb-legacy) for migration assistance */
-  findOneAndUpdate(
-    filter: Filter<TSchema>,
-    update: UpdateFilter<TSchema>,
-    callback: Callback<ModifyResult<TSchema>>
-  ): void;
-  /** @deprecated Callbacks are deprecated and will be removed in the next major version. See [mongodb-legacy](https://github.com/mongodb-js/nodejs-mongodb-legacy) for migration assistance */
-  findOneAndUpdate(
-    filter: Filter<TSchema>,
-    update: UpdateFilter<TSchema>,
-    options: FindOneAndUpdateOptions,
-    callback: Callback<ModifyResult<TSchema>>
-  ): void;
-  findOneAndUpdate(
+  async findOneAndUpdate(
     filter: Filter<TSchema>,
     update: UpdateFilter<TSchema>,
-    options?: FindOneAndUpdateOptions | Callback<ModifyResult<TSchema>>,
-    callback?: Callback<ModifyResult<TSchema>>
-  ): Promise<ModifyResult<TSchema>> | void {
-    if (typeof options === 'function') (callback = options), (options = {});
-
+    options?: FindOneAndUpdateOptions
+  ): Promise<ModifyResult<TSchema>> {
     return executeOperation(
       this.s.db.s.client,
       new FindOneAndUpdateOperation(
@@ -1419,8 +855,7 @@ export class Collection<TSchema extends Document = Document> {
         filter,
         update,
         resolveOptions(this, options)
-      ) as TODO_NODE_3286,
-      callback
+      ) as TODO_NODE_3286
     );
   }
 
@@ -1434,19 +869,11 @@ export class Collection<TSchema extends Document = Document> {
     pipeline: Document[] = [],
     options?: AggregateOptions
   ): AggregationCursor<T> {
-    if (arguments.length > 2) {
-      throw new MongoInvalidArgumentError(
-        'Method "collection.aggregate()" accepts at most two arguments'
-      );
-    }
     if (!Array.isArray(pipeline)) {
       throw new MongoInvalidArgumentError(
         'Argument "pipeline" must be an array of aggregation stages'
       );
     }
-    if (typeof options === 'function') {
-      throw new MongoInvalidArgumentError('Argument "options" must not be function');
-    }
 
     return new AggregationCursor(
       this.s.db.s.client,
@@ -1542,41 +969,15 @@ export class Collection<TSchema extends Document = Document> {
    *
    * @param filter - The filter for the count.
    * @param options - Optional settings for the command
-   * @param callback - An optional callback, a Promise will be returned if none is provided
    */
-  count(): Promise<number>;
-  count(filter: Filter<TSchema>): Promise<number>;
-  count(filter: Filter<TSchema>, options: CountOptions): Promise<number>;
-  /** @deprecated Callbacks are deprecated and will be removed in the next major version. See [mongodb-legacy](https://github.com/mongodb-js/nodejs-mongodb-legacy) for migration assistance */
-  count(callback: Callback<number>): void;
-  /** @deprecated Callbacks are deprecated and will be removed in the next major version. See [mongodb-legacy](https://github.com/mongodb-js/nodejs-mongodb-legacy) for migration assistance */
-  count(filter: Filter<TSchema>, callback: Callback<number>): void;
-  /** @deprecated Callbacks are deprecated and will be removed in the next major version. See [mongodb-legacy](https://github.com/mongodb-js/nodejs-mongodb-legacy) for migration assistance */
-  count(
-    filter: Filter<TSchema>,
-    options: CountOptions,
-    callback: Callback<number>
-  ): Promise<number> | void;
-  count(
-    filter?: Filter<TSchema> | CountOptions | Callback<number>,
-    options?: CountOptions | Callback<number>,
-    callback?: Callback<number>
-  ): Promise<number> | void {
-    if (typeof filter === 'function') {
-      (callback = filter), (filter = {}), (options = {});
-    } else {
-      if (typeof options === 'function') (callback = options), (options = {});
-    }
-
-    filter ??= {};
+  async count(filter: Filter<TSchema> = {}, options: CountOptions = {}): Promise<number> {
     return executeOperation(
       this.s.db.s.client,
       new CountOperation(
         MongoDBNamespace.fromString(this.namespace),
         filter,
         resolveOptions(this, options)
-      ),
-      callback
+      )
     );
   }
 }
diff --git a/src/cursor/abstract_cursor.ts b/src/cursor/abstract_cursor.ts
index a0662d6c30..2d9ec01a3d 100644
--- a/src/cursor/abstract_cursor.ts
+++ b/src/cursor/abstract_cursor.ts
@@ -21,7 +21,7 @@ import { ReadConcern, ReadConcernLike } from '../read_concern';
 import { ReadPreference, ReadPreferenceLike } from '../read_preference';
 import type { Server } from '../sdam/server';
 import { ClientSession, maybeClearPinnedConnection } from '../sessions';
-import { Callback, List, maybeCallback, MongoDBNamespace, ns } from '../utils';
+import { Callback, List, MongoDBNamespace, ns } from '../utils';
 
 /** @internal */
 const kId = Symbol('id');
@@ -352,60 +352,43 @@ export abstract class AbstractCursor<
     return new ReadableCursorStream(this);
   }
 
-  hasNext(): Promise<boolean>;
-  /** @deprecated Callbacks are deprecated and will be removed in the next major version. See [mongodb-legacy](https://github.com/mongodb-js/nodejs-mongodb-legacy) for migration assistance */
-  hasNext(callback: Callback<boolean>): void;
-  hasNext(callback?: Callback<boolean>): Promise<boolean> | void {
-    return maybeCallback(async () => {
-      if (this[kId] === Long.ZERO) {
-        return false;
-      }
+  async hasNext(): Promise<boolean> {
+    if (this[kId] === Long.ZERO) {
+      return false;
+    }
 
-      if (this[kDocuments].length !== 0) {
-        return true;
-      }
+    if (this[kDocuments].length !== 0) {
+      return true;
+    }
 
-      const doc = await nextAsync<TSchema>(this, true);
+    const doc = await nextAsync<TSchema>(this, true);
 
-      if (doc) {
-        this[kDocuments].unshift(doc);
-        return true;
-      }
+    if (doc) {
+      this[kDocuments].unshift(doc);
+      return true;
+    }
 
-      return false;
-    }, callback);
+    return false;
   }
 
   /** Get the next available document from the cursor, returns null if no more documents are available. */
-  next(): Promise<TSchema | null>;
-  /** @deprecated Callbacks are deprecated and will be removed in the next major version. See [mongodb-legacy](https://github.com/mongodb-js/nodejs-mongodb-legacy) for migration assistance */
-  next(callback: Callback<TSchema | null>): void;
-  /** @deprecated Callbacks are deprecated and will be removed in the next major version. See [mongodb-legacy](https://github.com/mongodb-js/nodejs-mongodb-legacy) for migration assistance */
-  next(callback?: Callback<TSchema | null>): Promise<TSchema | null> | void;
-  next(callback?: Callback<TSchema | null>): Promise<TSchema | null> | void {
-    return maybeCallback(async () => {
-      if (this[kId] === Long.ZERO) {
-        throw new MongoCursorExhaustedError();
-      }
+  async next(): Promise<TSchema | null> {
+    if (this[kId] === Long.ZERO) {
+      throw new MongoCursorExhaustedError();
+    }
 
-      return nextAsync(this, true);
-    }, callback);
+    return nextAsync(this, true);
   }
 
   /**
    * Try to get the next available document from the cursor or `null` if an empty batch is returned
    */
-  tryNext(): Promise<TSchema | null>;
-  /** @deprecated Callbacks are deprecated and will be removed in the next major version. See [mongodb-legacy](https://github.com/mongodb-js/nodejs-mongodb-legacy) for migration assistance */
-  tryNext(callback: Callback<TSchema | null>): void;
-  tryNext(callback?: Callback<TSchema | null>): Promise<TSchema | null> | void {
-    return maybeCallback(async () => {
-      if (this[kId] === Long.ZERO) {
-        throw new MongoCursorExhaustedError();
-      }
+  async tryNext(): Promise<TSchema | null> {
+    if (this[kId] === Long.ZERO) {
+      throw new MongoCursorExhaustedError();
+    }
 
-      return nextAsync(this, false);
-    }, callback);
+    return nextAsync(this, false);
   }
 
   /**
@@ -414,36 +397,23 @@ export abstract class AbstractCursor<
    * If the iterator returns `false`, iteration will stop.
    *
    * @param iterator - The iteration callback.
-   * @param callback - The end callback.
    */
-  forEach(iterator: (doc: TSchema) => boolean | void): Promise<void>;
-  /** @deprecated Callbacks are deprecated and will be removed in the next major version. See [mongodb-legacy](https://github.com/mongodb-js/nodejs-mongodb-legacy) for migration assistance */
-  forEach(iterator: (doc: TSchema) => boolean | void, callback: Callback<void>): void;
-  forEach(
-    iterator: (doc: TSchema) => boolean | void,
-    callback?: Callback<void>
-  ): Promise<void> | void {
+  async forEach(iterator: (doc: TSchema) => boolean | void): Promise<void> {
     if (typeof iterator !== 'function') {
       throw new MongoInvalidArgumentError('Argument "iterator" must be a function');
     }
-    return maybeCallback(async () => {
-      for await (const document of this) {
-        const result = iterator(document);
-        if (result === false) {
-          break;
-        }
+    for await (const document of this) {
+      const result = iterator(document);
+      if (result === false) {
+        break;
       }
-    }, callback);
+    }
   }
 
-  close(): Promise<void>;
-  /** @deprecated Callbacks are deprecated and will be removed in the next major version. See [mongodb-legacy](https://github.com/mongodb-js/nodejs-mongodb-legacy) for migration assistance */
-  close(callback: Callback): void;
-  close(callback?: Callback): Promise<void> | void {
+  async close(): Promise<void> {
     const needsToEmitClosed = !this[kClosed];
     this[kClosed] = true;
-
-    return maybeCallback(async () => cleanupCursorAsync(this, { needsToEmitClosed }), callback);
+    await cleanupCursorAsync(this, { needsToEmitClosed });
   }
 
   /**
@@ -451,20 +421,13 @@ export abstract class AbstractCursor<
    * is enough memory to store the results. Note that the array only contains partial
    * results when this cursor had been previously accessed. In that case,
    * cursor.rewind() can be used to reset the cursor.
-   *
-   * @param callback - The result callback.
    */
-  toArray(): Promise<TSchema[]>;
-  /** @deprecated Callbacks are deprecated and will be removed in the next major version. See [mongodb-legacy](https://github.com/mongodb-js/nodejs-mongodb-legacy) for migration assistance */
-  toArray(callback: Callback<TSchema[]>): void;
-  toArray(callback?: Callback<TSchema[]>): Promise<TSchema[]> | void {
-    return maybeCallback(async () => {
-      const array = [];
-      for await (const document of this) {
-        array.push(document);
-      }
-      return array;
-    }, callback);
+  async toArray(): Promise<TSchema[]> {
+    const array = [];
+    for await (const document of this) {
+      array.push(document);
+    }
+    return array;
   }
 
   /**
@@ -903,7 +866,10 @@ class ReadableCursorStream extends Readable {
   }
 
   override _destroy(error: Error | null, callback: (error?: Error | null) => void): void {
-    this._cursor.close(err => process.nextTick(callback, err || error));
+    this._cursor.close().then(
+      () => callback(error),
+      closeError => callback(closeError)
+    );
   }
 
   private _readNext() {
diff --git a/src/cursor/aggregation_cursor.ts b/src/cursor/aggregation_cursor.ts
index 981989902f..f57969d39b 100644
--- a/src/cursor/aggregation_cursor.ts
+++ b/src/cursor/aggregation_cursor.ts
@@ -77,25 +77,14 @@ export class AggregationCursor<TSchema = any> extends AbstractCursor<TSchema> {
   }
 
   /** Execute the explain for the cursor */
-  explain(): Promise<Document>;
-  explain(verbosity: ExplainVerbosityLike): Promise<Document>;
-  /** @deprecated Callbacks are deprecated and will be removed in the next major version. See [mongodb-legacy](https://github.com/mongodb-js/nodejs-mongodb-legacy) for migration assistance */
-  explain(callback: Callback): void;
-  explain(
-    verbosity?: ExplainVerbosityLike | Callback,
-    callback?: Callback<Document>
-  ): Promise<Document> | void {
-    if (typeof verbosity === 'function') (callback = verbosity), (verbosity = true);
-    if (verbosity == null) verbosity = true;
-
+  async explain(verbosity?: ExplainVerbosityLike): Promise<Document> {
     return executeOperation(
       this.client,
       new AggregateOperation(this.namespace, this[kPipeline], {
         ...this[kOptions], // NOTE: order matters here, we may need to refine this
         ...this.cursorOptions,
-        explain: verbosity
-      }),
-      callback
+        explain: verbosity ?? true
+      })
     );
   }
 
diff --git a/src/cursor/find_cursor.ts b/src/cursor/find_cursor.ts
index 49f4f95cb2..ff4cd6ddf0 100644
--- a/src/cursor/find_cursor.ts
+++ b/src/cursor/find_cursor.ts
@@ -42,12 +42,12 @@ export class FindCursor<TSchema = any> extends AbstractCursor<TSchema> {
   constructor(
     client: MongoClient,
     namespace: MongoDBNamespace,
-    filter: Document | undefined,
+    filter: Document = {},
     options: FindOptions = {}
   ) {
     super(client, namespace, options);
 
-    this[kFilter] = filter || {};
+    this[kFilter] = filter;
     this[kBuiltOptions] = options;
 
     if (options.sort != null) {
@@ -101,7 +101,8 @@ export class FindCursor<TSchema = any> extends AbstractCursor<TSchema> {
         limit && limit > 0 && numReturned + batchSize > limit ? limit - numReturned : batchSize;
 
       if (batchSize <= 0) {
-        return this.close(callback);
+        this.close().finally(() => callback());
+        return;
       }
     }
 
@@ -121,58 +122,32 @@ export class FindCursor<TSchema = any> extends AbstractCursor<TSchema> {
    * Get the count of documents for this cursor
    * @deprecated Use `collection.estimatedDocumentCount` or `collection.countDocuments` instead
    */
-  count(): Promise<number>;
-  /** @deprecated Use `collection.estimatedDocumentCount` or `collection.countDocuments` instead. */
-  count(options: CountOptions): Promise<number>;
-  /** @deprecated Use `collection.estimatedDocumentCount` or `collection.countDocuments` instead. Callbacks are deprecated and will be removed in the next major version. See [mongodb-legacy](https://github.com/mongodb-js/nodejs-mongodb-legacy) for migration assistance */
-  count(callback: Callback<number>): void;
-  /** @deprecated Use `collection.estimatedDocumentCount` or `collection.countDocuments` instead. Callbacks are deprecated and will be removed in the next major version. See [mongodb-legacy](https://github.com/mongodb-js/nodejs-mongodb-legacy) for migration assistance */
-  count(options: CountOptions, callback: Callback<number>): void;
-  count(
-    options?: CountOptions | Callback<number>,
-    callback?: Callback<number>
-  ): Promise<number> | void {
+  async count(options?: CountOptions): Promise<number> {
     emitWarningOnce(
       'cursor.count is deprecated and will be removed in the next major version, please use `collection.estimatedDocumentCount` or `collection.countDocuments` instead '
     );
     if (typeof options === 'boolean') {
       throw new MongoInvalidArgumentError('Invalid first parameter to count');
     }
-
-    if (typeof options === 'function') (callback = options), (options = {});
-    options = options ?? {};
-
     return executeOperation(
       this.client,
       new CountOperation(this.namespace, this[kFilter], {
         ...this[kBuiltOptions], // NOTE: order matters here, we may need to refine this
         ...this.cursorOptions,
         ...options
-      }),
-      callback
+      })
     );
   }
 
   /** Execute the explain for the cursor */
-  explain(): Promise<Document>;
-  explain(verbosity?: ExplainVerbosityLike): Promise<Document>;
-  /** @deprecated Callbacks are deprecated and will be removed in the next major version. See [mongodb-legacy](https://github.com/mongodb-js/nodejs-mongodb-legacy) for migration assistance */
-  explain(callback: Callback): void;
-  explain(
-    verbosity?: ExplainVerbosityLike | Callback,
-    callback?: Callback<Document>
-  ): Promise<Document> | void {
-    if (typeof verbosity === 'function') (callback = verbosity), (verbosity = true);
-    if (verbosity == null) verbosity = true;
-
+  async explain(verbosity?: ExplainVerbosityLike): Promise<Document> {
     return executeOperation(
       this.client,
       new FindOperation(undefined, this.namespace, this[kFilter], {
         ...this[kBuiltOptions], // NOTE: order matters here, we may need to refine this
         ...this.cursorOptions,
-        explain: verbosity
-      }),
-      callback
+        explain: verbosity ?? true
+      })
     );
   }
 
diff --git a/src/db.ts b/src/db.ts
index 4133d491c5..67c49dd96e 100644
--- a/src/db.ts
+++ b/src/db.ts
@@ -39,13 +39,7 @@ import {
 import { DbStatsOperation, DbStatsOptions } from './operations/stats';
 import { ReadConcern } from './read_concern';
 import { ReadPreference, ReadPreferenceLike } from './read_preference';
-import {
-  Callback,
-  DEFAULT_PK_FACTORY,
-  filterOptions,
-  MongoDBNamespace,
-  resolveOptions
-} from './utils';
+import { DEFAULT_PK_FACTORY, filterOptions, MongoDBNamespace, resolveOptions } from './utils';
 import { WriteConcern, WriteConcernOptions } from './write_concern';
 
 // Allowed parameters
@@ -220,35 +214,15 @@ export class Db {
    *
    * @param name - The name of the collection to create
    * @param options - Optional settings for the command
-   * @param callback - An optional callback, a Promise will be returned if none is provided
    */
-  createCollection<TSchema extends Document = Document>(
+  async createCollection<TSchema extends Document = Document>(
     name: string,
     options?: CreateCollectionOptions
-  ): Promise<Collection<TSchema>>;
-  /** @deprecated Callbacks are deprecated and will be removed in the next major version. See [mongodb-legacy](https://github.com/mongodb-js/nodejs-mongodb-legacy) for migration assistance */
-  createCollection<TSchema extends Document = Document>(
-    name: string,
-    callback: Callback<Collection<TSchema>>
-  ): void;
-  /** @deprecated Callbacks are deprecated and will be removed in the next major version. See [mongodb-legacy](https://github.com/mongodb-js/nodejs-mongodb-legacy) for migration assistance */
-  createCollection<TSchema extends Document = Document>(
-    name: string,
-    options: CreateCollectionOptions | undefined,
-    callback: Callback<Collection<TSchema>>
-  ): void;
-  createCollection<TSchema extends Document = Document>(
-    name: string,
-    options?: CreateCollectionOptions | Callback<Collection>,
-    callback?: Callback<Collection>
-  ): Promise<Collection<TSchema>> | void {
-    if (typeof options === 'function') (callback = options), (options = {});
-
+  ): Promise<Collection<TSchema>> {
     return executeOperation(
       this.s.client,
-      new CreateCollectionOperation(this, name, resolveOptions(this, options)) as TODO_NODE_3286,
-      callback
-    ) as TODO_NODE_3286;
+      new CreateCollectionOperation(this, name, resolveOptions(this, options)) as TODO_NODE_3286
+    );
   }
 
   /**
@@ -259,27 +233,10 @@ export class Db {
    *
    * @param command - The command to run
    * @param options - Optional settings for the command
-   * @param callback - An optional callback, a Promise will be returned if none is provided
    */
-  command(command: Document): Promise<Document>;
-  command(command: Document, options: RunCommandOptions): Promise<Document>;
-  /** @deprecated Callbacks are deprecated and will be removed in the next major version. See [mongodb-legacy](https://github.com/mongodb-js/nodejs-mongodb-legacy) for migration assistance */
-  command(command: Document, callback: Callback<Document>): void;
-  /** @deprecated Callbacks are deprecated and will be removed in the next major version. See [mongodb-legacy](https://github.com/mongodb-js/nodejs-mongodb-legacy) for migration assistance */
-  command(command: Document, options: RunCommandOptions, callback: Callback<Document>): void;
-  command(
-    command: Document,
-    options?: RunCommandOptions | Callback<Document>,
-    callback?: Callback<Document>
-  ): Promise<Document> | void {
-    if (typeof options === 'function') (callback = options), (options = {});
-
+  async command(command: Document, options?: RunCommandOptions): Promise<Document> {
     // Intentionally, we do not inherit options from parent for this operation.
-    return executeOperation(
-      this.s.client,
-      new RunCommandOperation(this, command, options ?? {}),
-      callback
-    );
+    return executeOperation(this.s.client, new RunCommandOperation(this, command, options));
   }
 
   /**
@@ -292,16 +249,6 @@ export class Db {
     pipeline: Document[] = [],
     options?: AggregateOptions
   ): AggregationCursor<T> {
-    if (arguments.length > 2) {
-      throw new MongoInvalidArgumentError('Method "db.aggregate()" accepts at most two arguments');
-    }
-    if (typeof pipeline === 'function') {
-      throw new MongoInvalidArgumentError('Argument "pipeline" must not be function');
-    }
-    if (typeof options === 'function') {
-      throw new MongoInvalidArgumentError('Argument "options" must not be function');
-    }
-
     return new AggregationCursor(
       this.s.client,
       this.s.namespace,
@@ -328,31 +275,18 @@ export class Db {
     if (typeof options === 'function') {
       throw new MongoInvalidArgumentError('The callback form of this helper has been removed.');
     }
-    const finalOptions = resolveOptions(this, options);
-    return new Collection<TSchema>(this, name, finalOptions);
+    return new Collection<TSchema>(this, name, resolveOptions(this, options));
   }
 
   /**
    * Get all the db statistics.
    *
    * @param options - Optional settings for the command
-   * @param callback - An optional callback, a Promise will be returned if none is provided
    */
-  stats(): Promise<Document>;
-  stats(options: DbStatsOptions): Promise<Document>;
-  /** @deprecated Callbacks are deprecated and will be removed in the next major version. See [mongodb-legacy](https://github.com/mongodb-js/nodejs-mongodb-legacy) for migration assistance */
-  stats(callback: Callback<Document>): void;
-  /** @deprecated Callbacks are deprecated and will be removed in the next major version. See [mongodb-legacy](https://github.com/mongodb-js/nodejs-mongodb-legacy) for migration assistance */
-  stats(options: DbStatsOptions, callback: Callback<Document>): void;
-  stats(
-    options?: DbStatsOptions | Callback<Document>,
-    callback?: Callback<Document>
-  ): Promise<Document> | void {
-    if (typeof options === 'function') (callback = options), (options = {});
+  async stats(options?: DbStatsOptions): Promise<Document> {
     return executeOperation(
       this.s.client,
-      new DbStatsOperation(this, resolveOptions(this, options)),
-      callback
+      new DbStatsOperation(this, resolveOptions(this, options))
     );
   }
 
@@ -392,52 +326,20 @@ export class Db {
    * @param fromCollection - Name of current collection to rename
    * @param toCollection - New name of of the collection
    * @param options - Optional settings for the command
-   * @param callback - An optional callback, a Promise will be returned if none is provided
    */
-  renameCollection<TSchema extends Document = Document>(
-    fromCollection: string,
-    toCollection: string
-  ): Promise<Collection<TSchema>>;
-  renameCollection<TSchema extends Document = Document>(
-    fromCollection: string,
-    toCollection: string,
-    options: RenameOptions
-  ): Promise<Collection<TSchema>>;
-  /** @deprecated Callbacks are deprecated and will be removed in the next major version. See [mongodb-legacy](https://github.com/mongodb-js/nodejs-mongodb-legacy) for migration assistance */
-  renameCollection<TSchema extends Document = Document>(
+  async renameCollection<TSchema extends Document = Document>(
     fromCollection: string,
     toCollection: string,
-    callback: Callback<Collection<TSchema>>
-  ): void;
-  /** @deprecated Callbacks are deprecated and will be removed in the next major version. See [mongodb-legacy](https://github.com/mongodb-js/nodejs-mongodb-legacy) for migration assistance */
-  renameCollection<TSchema extends Document = Document>(
-    fromCollection: string,
-    toCollection: string,
-    options: RenameOptions,
-    callback: Callback<Collection<TSchema>>
-  ): void;
-  renameCollection<TSchema extends Document = Document>(
-    fromCollection: string,
-    toCollection: string,
-    options?: RenameOptions | Callback<Collection<TSchema>>,
-    callback?: Callback<Collection<TSchema>>
-  ): Promise<Collection<TSchema>> | void {
-    if (typeof options === 'function') (callback = options), (options = {});
-
+    options?: RenameOptions
+  ): Promise<Collection<TSchema>> {
     // Intentionally, we do not inherit options from parent for this operation.
-    options = { ...options, readPreference: ReadPreference.PRIMARY };
-
-    // Add return new collection
-    options.new_collection = true;
-
     return executeOperation(
       this.s.client,
       new RenameOperation(
         this.collection<TSchema>(fromCollection) as TODO_NODE_3286,
         toCollection,
-        options
-      ) as TODO_NODE_3286,
-      callback
+        { ...options, new_collection: true, readPreference: ReadPreference.primary }
+      ) as TODO_NODE_3286
     );
   }
 
@@ -446,25 +348,11 @@ export class Db {
    *
    * @param name - Name of collection to drop
    * @param options - Optional settings for the command
-   * @param callback - An optional callback, a Promise will be returned if none is provided
    */
-  dropCollection(name: string): Promise<boolean>;
-  dropCollection(name: string, options: DropCollectionOptions): Promise<boolean>;
-  /** @deprecated Callbacks are deprecated and will be removed in the next major version. See [mongodb-legacy](https://github.com/mongodb-js/nodejs-mongodb-legacy) for migration assistance */
-  dropCollection(name: string, callback: Callback<boolean>): void;
-  /** @deprecated Callbacks are deprecated and will be removed in the next major version. See [mongodb-legacy](https://github.com/mongodb-js/nodejs-mongodb-legacy) for migration assistance */
-  dropCollection(name: string, options: DropCollectionOptions, callback: Callback<boolean>): void;
-  dropCollection(
-    name: string,
-    options?: DropCollectionOptions | Callback<boolean>,
-    callback?: Callback<boolean>
-  ): Promise<boolean> | void {
-    if (typeof options === 'function') (callback = options), (options = {});
-
+  async dropCollection(name: string, options?: DropCollectionOptions): Promise<boolean> {
     return executeOperation(
       this.s.client,
-      new DropCollectionOperation(this, name, resolveOptions(this, options)),
-      callback
+      new DropCollectionOperation(this, name, resolveOptions(this, options))
     );
   }
 
@@ -472,24 +360,11 @@ export class Db {
    * Drop a database, removing it permanently from the server.
    *
    * @param options - Optional settings for the command
-   * @param callback - An optional callback, a Promise will be returned if none is provided
    */
-  dropDatabase(): Promise<boolean>;
-  dropDatabase(options: DropDatabaseOptions): Promise<boolean>;
-  /** @deprecated Callbacks are deprecated and will be removed in the next major version. See [mongodb-legacy](https://github.com/mongodb-js/nodejs-mongodb-legacy) for migration assistance */
-  dropDatabase(callback: Callback<boolean>): void;
-  /** @deprecated Callbacks are deprecated and will be removed in the next major version. See [mongodb-legacy](https://github.com/mongodb-js/nodejs-mongodb-legacy) for migration assistance */
-  dropDatabase(options: DropDatabaseOptions, callback: Callback<boolean>): void;
-  dropDatabase(
-    options?: DropDatabaseOptions | Callback<boolean>,
-    callback?: Callback<boolean>
-  ): Promise<boolean> | void {
-    if (typeof options === 'function') (callback = options), (options = {});
-
+  async dropDatabase(options?: DropDatabaseOptions): Promise<boolean> {
     return executeOperation(
       this.s.client,
-      new DropDatabaseOperation(this, resolveOptions(this, options)),
-      callback
+      new DropDatabaseOperation(this, resolveOptions(this, options))
     );
   }
 
@@ -497,24 +372,11 @@ export class Db {
    * Fetch all collections for the current db.
    *
    * @param options - Optional settings for the command
-   * @param callback - An optional callback, a Promise will be returned if none is provided
    */
-  collections(): Promise<Collection[]>;
-  collections(options: ListCollectionsOptions): Promise<Collection[]>;
-  /** @deprecated Callbacks are deprecated and will be removed in the next major version. See [mongodb-legacy](https://github.com/mongodb-js/nodejs-mongodb-legacy) for migration assistance */
-  collections(callback: Callback<Collection[]>): void;
-  /** @deprecated Callbacks are deprecated and will be removed in the next major version. See [mongodb-legacy](https://github.com/mongodb-js/nodejs-mongodb-legacy) for migration assistance */
-  collections(options: ListCollectionsOptions, callback: Callback<Collection[]>): void;
-  collections(
-    options?: ListCollectionsOptions | Callback<Collection[]>,
-    callback?: Callback<Collection[]>
-  ): Promise<Collection[]> | void {
-    if (typeof options === 'function') (callback = options), (options = {});
-
+  async collections(options?: ListCollectionsOptions): Promise<Collection[]> {
     return executeOperation(
       this.s.client,
-      new CollectionsOperation(this, resolveOptions(this, options)),
-      callback
+      new CollectionsOperation(this, resolveOptions(this, options))
     );
   }
 
@@ -524,35 +386,15 @@ export class Db {
    * @param name - Name of the collection to create the index on.
    * @param indexSpec - Specify the field to index, or an index specification
    * @param options - Optional settings for the command
-   * @param callback - An optional callback, a Promise will be returned if none is provided
    */
-  createIndex(name: string, indexSpec: IndexSpecification): Promise<string>;
-  createIndex(
+  async createIndex(
     name: string,
     indexSpec: IndexSpecification,
-    options: CreateIndexesOptions
-  ): Promise<string>;
-  /** @deprecated Callbacks are deprecated and will be removed in the next major version. See [mongodb-legacy](https://github.com/mongodb-js/nodejs-mongodb-legacy) for migration assistance */
-  createIndex(name: string, indexSpec: IndexSpecification, callback: Callback<string>): void;
-  /** @deprecated Callbacks are deprecated and will be removed in the next major version. See [mongodb-legacy](https://github.com/mongodb-js/nodejs-mongodb-legacy) for migration assistance */
-  createIndex(
-    name: string,
-    indexSpec: IndexSpecification,
-    options: CreateIndexesOptions,
-    callback: Callback<string>
-  ): void;
-  createIndex(
-    name: string,
-    indexSpec: IndexSpecification,
-    options?: CreateIndexesOptions | Callback<string>,
-    callback?: Callback<string>
-  ): Promise<string> | void {
-    if (typeof options === 'function') (callback = options), (options = {});
-
+    options?: CreateIndexesOptions
+  ): Promise<string> {
     return executeOperation(
       this.s.client,
-      new CreateIndexOperation(this, name, indexSpec, resolveOptions(this, options)),
-      callback
+      new CreateIndexOperation(this, name, indexSpec, resolveOptions(this, options))
     );
   }
 
@@ -560,49 +402,24 @@ export class Db {
    * Add a user to the database
    *
    * @param username - The username for the new user
-   * @param password - An optional password for the new user
+   * @param passwordOrOptions - An optional password for the new user, or the options for the command
    * @param options - Optional settings for the command
-   * @param callback - An optional callback, a Promise will be returned if none is provided
    */
-  addUser(username: string): Promise<Document>;
-  addUser(username: string, password: string): Promise<Document>;
-  addUser(username: string, options: AddUserOptions): Promise<Document>;
-  addUser(username: string, password: string, options: AddUserOptions): Promise<Document>;
-  /** @deprecated Callbacks are deprecated and will be removed in the next major version. See [mongodb-legacy](https://github.com/mongodb-js/nodejs-mongodb-legacy) for migration assistance */
-  addUser(username: string, callback: Callback<Document>): void;
-  /** @deprecated Callbacks are deprecated and will be removed in the next major version. See [mongodb-legacy](https://github.com/mongodb-js/nodejs-mongodb-legacy) for migration assistance */
-  addUser(username: string, password: string, callback: Callback<Document>): void;
-  /** @deprecated Callbacks are deprecated and will be removed in the next major version. See [mongodb-legacy](https://github.com/mongodb-js/nodejs-mongodb-legacy) for migration assistance */
-  addUser(username: string, options: AddUserOptions, callback: Callback<Document>): void;
-  /** @deprecated Callbacks are deprecated and will be removed in the next major version. See [mongodb-legacy](https://github.com/mongodb-js/nodejs-mongodb-legacy) for migration assistance */
-  addUser(
-    username: string,
-    password: string,
-    options: AddUserOptions,
-    callback: Callback<Document>
-  ): void;
-  addUser(
+  async addUser(
     username: string,
-    password?: string | AddUserOptions | Callback<Document>,
-    options?: AddUserOptions | Callback<Document>,
-    callback?: Callback<Document>
-  ): Promise<Document> | void {
-    if (typeof password === 'function') {
-      (callback = password), (password = undefined), (options = {});
-    } else if (typeof password !== 'string') {
-      if (typeof options === 'function') {
-        (callback = options), (options = password), (password = undefined);
-      } else {
-        (options = password), (callback = undefined), (password = undefined);
-      }
-    } else {
-      if (typeof options === 'function') (callback = options), (options = {});
-    }
-
+    passwordOrOptions?: string | AddUserOptions,
+    options?: AddUserOptions
+  ): Promise<Document> {
+    options =
+      options != null && typeof options === 'object'
+        ? options
+        : passwordOrOptions != null && typeof passwordOrOptions === 'object'
+        ? passwordOrOptions
+        : undefined;
+    const password = typeof passwordOrOptions === 'string' ? passwordOrOptions : undefined;
     return executeOperation(
       this.s.client,
-      new AddUserOperation(this, username, password, resolveOptions(this, options)),
-      callback
+      new AddUserOperation(this, username, password, resolveOptions(this, options))
     );
   }
 
@@ -611,25 +428,11 @@ export class Db {
    *
    * @param username - The username to remove
    * @param options - Optional settings for the command
-   * @param callback - An optional callback, a Promise will be returned if none is provided
    */
-  removeUser(username: string): Promise<boolean>;
-  removeUser(username: string, options: RemoveUserOptions): Promise<boolean>;
-  /** @deprecated Callbacks are deprecated and will be removed in the next major version. See [mongodb-legacy](https://github.com/mongodb-js/nodejs-mongodb-legacy) for migration assistance */
-  removeUser(username: string, callback: Callback<boolean>): void;
-  /** @deprecated Callbacks are deprecated and will be removed in the next major version. See [mongodb-legacy](https://github.com/mongodb-js/nodejs-mongodb-legacy) for migration assistance */
-  removeUser(username: string, options: RemoveUserOptions, callback: Callback<boolean>): void;
-  removeUser(
-    username: string,
-    options?: RemoveUserOptions | Callback<boolean>,
-    callback?: Callback<boolean>
-  ): Promise<boolean> | void {
-    if (typeof options === 'function') (callback = options), (options = {});
-
+  async removeUser(username: string, options?: RemoveUserOptions): Promise<boolean> {
     return executeOperation(
       this.s.client,
-      new RemoveUserOperation(this, username, resolveOptions(this, options)),
-      callback
+      new RemoveUserOperation(this, username, resolveOptions(this, options))
     );
   }
 
@@ -638,32 +441,14 @@ export class Db {
    *
    * @param level - The new profiling level (off, slow_only, all).
    * @param options - Optional settings for the command
-   * @param callback - An optional callback, a Promise will be returned if none is provided
    */
-  setProfilingLevel(level: ProfilingLevel): Promise<ProfilingLevel>;
-  setProfilingLevel(
-    level: ProfilingLevel,
-    options: SetProfilingLevelOptions
-  ): Promise<ProfilingLevel>;
-  /** @deprecated Callbacks are deprecated and will be removed in the next major version. See [mongodb-legacy](https://github.com/mongodb-js/nodejs-mongodb-legacy) for migration assistance */
-  setProfilingLevel(level: ProfilingLevel, callback: Callback<ProfilingLevel>): void;
-  /** @deprecated Callbacks are deprecated and will be removed in the next major version. See [mongodb-legacy](https://github.com/mongodb-js/nodejs-mongodb-legacy) for migration assistance */
-  setProfilingLevel(
-    level: ProfilingLevel,
-    options: SetProfilingLevelOptions,
-    callback: Callback<ProfilingLevel>
-  ): void;
-  setProfilingLevel(
+  async setProfilingLevel(
     level: ProfilingLevel,
-    options?: SetProfilingLevelOptions | Callback<ProfilingLevel>,
-    callback?: Callback<ProfilingLevel>
-  ): Promise<ProfilingLevel> | void {
-    if (typeof options === 'function') (callback = options), (options = {});
-
+    options?: SetProfilingLevelOptions
+  ): Promise<ProfilingLevel> {
     return executeOperation(
       this.s.client,
-      new SetProfilingLevelOperation(this, level, resolveOptions(this, options)),
-      callback
+      new SetProfilingLevelOperation(this, level, resolveOptions(this, options))
     );
   }
 
@@ -671,24 +456,11 @@ export class Db {
    * Retrieve the current profiling Level for MongoDB
    *
    * @param options - Optional settings for the command
-   * @param callback - An optional callback, a Promise will be returned if none is provided
    */
-  profilingLevel(): Promise<string>;
-  profilingLevel(options: ProfilingLevelOptions): Promise<string>;
-  /** @deprecated Callbacks are deprecated and will be removed in the next major version. See [mongodb-legacy](https://github.com/mongodb-js/nodejs-mongodb-legacy) for migration assistance */
-  profilingLevel(callback: Callback<string>): void;
-  /** @deprecated Callbacks are deprecated and will be removed in the next major version. See [mongodb-legacy](https://github.com/mongodb-js/nodejs-mongodb-legacy) for migration assistance */
-  profilingLevel(options: ProfilingLevelOptions, callback: Callback<string>): void;
-  profilingLevel(
-    options?: ProfilingLevelOptions | Callback<string>,
-    callback?: Callback<string>
-  ): Promise<string> | void {
-    if (typeof options === 'function') (callback = options), (options = {});
-
+  async profilingLevel(options?: ProfilingLevelOptions): Promise<string> {
     return executeOperation(
       this.s.client,
-      new ProfilingLevelOperation(this, resolveOptions(this, options)),
-      callback
+      new ProfilingLevelOperation(this, resolveOptions(this, options))
     );
   }
 
@@ -697,29 +469,11 @@ export class Db {
    *
    * @param name - The name of the collection.
    * @param options - Optional settings for the command
-   * @param callback - An optional callback, a Promise will be returned if none is provided
    */
-  indexInformation(name: string): Promise<Document>;
-  indexInformation(name: string, options: IndexInformationOptions): Promise<Document>;
-  /** @deprecated Callbacks are deprecated and will be removed in the next major version. See [mongodb-legacy](https://github.com/mongodb-js/nodejs-mongodb-legacy) for migration assistance */
-  indexInformation(name: string, callback: Callback<Document>): void;
-  /** @deprecated Callbacks are deprecated and will be removed in the next major version. See [mongodb-legacy](https://github.com/mongodb-js/nodejs-mongodb-legacy) for migration assistance */
-  indexInformation(
-    name: string,
-    options: IndexInformationOptions,
-    callback: Callback<Document>
-  ): void;
-  indexInformation(
-    name: string,
-    options?: IndexInformationOptions | Callback<Document>,
-    callback?: Callback<Document>
-  ): Promise<Document> | void {
-    if (typeof options === 'function') (callback = options), (options = {});
-
+  async indexInformation(name: string, options?: IndexInformationOptions): Promise<Document> {
     return executeOperation(
       this.s.client,
-      new IndexInformationOperation(this, name, resolveOptions(this, options)),
-      callback
+      new IndexInformationOperation(this, name, resolveOptions(this, options))
     );
   }
 
diff --git a/src/gridfs/download.ts b/src/gridfs/download.ts
index 9e96151478..0053ecc9a0 100644
--- a/src/gridfs/download.ts
+++ b/src/gridfs/download.ts
@@ -182,30 +182,22 @@ export class GridFSBucketReadStream extends Readable implements NodeJS.ReadableS
    * Marks this stream as aborted (will never push another `data` event)
    * and kills the underlying cursor. Will emit the 'end' event, and then
    * the 'close' event once the cursor is successfully killed.
-   *
-   * @param callback - called when the cursor is successfully closed or an error occurred.
    */
-  abort(callback?: Callback<void>): void {
+  async abort(): Promise<void> {
     this.push(null);
     this.destroyed = true;
     if (this.s.cursor) {
-      this.s.cursor.close().then(
-        () => {
-          this.emit(GridFSBucketReadStream.CLOSE);
-          callback?.();
-        },
-        error => {
-          this.emit(GridFSBucketReadStream.CLOSE);
-          callback?.(error);
-        }
-      );
+      try {
+        await this.s.cursor.close();
+      } finally {
+        this.emit(GridFSBucketReadStream.CLOSE);
+      }
     } else {
       if (!this.s.init) {
         // If not initialized, fire close event because we will never
         // get a cursor
         this.emit(GridFSBucketReadStream.CLOSE);
       }
-      callback && callback();
     }
   }
 }
diff --git a/src/gridfs/index.ts b/src/gridfs/index.ts
index 301df170fb..8471859a9e 100644
--- a/src/gridfs/index.ts
+++ b/src/gridfs/index.ts
@@ -6,7 +6,6 @@ import { MongoRuntimeError } from '../error';
 import { Filter, TypedEventEmitter } from '../mongo_types';
 import type { ReadPreference } from '../read_preference';
 import type { Sort } from '../sort';
-import { Callback, maybeCallback } from '../utils';
 import { WriteConcern, WriteConcernOptions } from '../write_concern';
 import type { FindOptions } from './../operations/find';
 import {
@@ -139,28 +138,21 @@ export class GridFSBucket extends TypedEventEmitter<GridFSBucketEvents> {
    *
    * @param id - The id of the file doc
    */
-  delete(id: ObjectId): Promise<void>;
-  /** @deprecated Callbacks are deprecated and will be removed in the next major version. See [mongodb-legacy](https://github.com/mongodb-js/nodejs-mongodb-legacy) for migration assistance */
-  delete(id: ObjectId, callback: Callback<void>): void;
-  delete(id: ObjectId, callback?: Callback<void>): Promise<void> | void {
-    return maybeCallback(async () => {
-      const { deletedCount } = await this.s._filesCollection.deleteOne({ _id: id });
-
-      // Delete orphaned chunks before returning FileNotFound
-      await this.s._chunksCollection.deleteMany({ files_id: id });
-
-      if (deletedCount === 0) {
-        // TODO(NODE-3483): Replace with more appropriate error
-        // Consider creating new error MongoGridFSFileNotFoundError
-        throw new MongoRuntimeError(`File not found for id ${id}`);
-      }
-    }, callback);
+  async delete(id: ObjectId): Promise<void> {
+    const { deletedCount } = await this.s._filesCollection.deleteOne({ _id: id });
+
+    // Delete orphaned chunks before returning FileNotFound
+    await this.s._chunksCollection.deleteMany({ files_id: id });
+
+    if (deletedCount === 0) {
+      // TODO(NODE-3483): Replace with more appropriate error
+      // Consider creating new error MongoGridFSFileNotFoundError
+      throw new MongoRuntimeError(`File not found for id ${id}`);
+    }
   }
 
   /** Convenience wrapper around find on the files collection */
-  find(filter?: Filter<GridFSFile>, options?: FindOptions): FindCursor<GridFSFile> {
-    filter ??= {};
-    options = options ?? {};
+  find(filter: Filter<GridFSFile> = {}, options: FindOptions = {}): FindCursor<GridFSFile> {
     return this.s._filesCollection.find(filter, options);
   }
 
@@ -200,28 +192,18 @@ export 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>;
-  /** @deprecated Callbacks are deprecated and will be removed in the next major version. See [mongodb-legacy](https://github.com/mongodb-js/nodejs-mongodb-legacy) for migration assistance */
-  rename(id: ObjectId, filename: string, callback: Callback<void>): void;
-  rename(id: ObjectId, filename: string, callback?: Callback<void>): Promise<void> | void {
-    return maybeCallback(async () => {
-      const filter = { _id: id };
-      const update = { $set: { filename } };
-      const { matchedCount } = await this.s._filesCollection.updateOne(filter, update);
-      if (matchedCount === 0) {
-        throw new MongoRuntimeError(`File with id ${id} not found`);
-      }
-    }, callback);
+  async rename(id: ObjectId, filename: string): Promise<void> {
+    const filter = { _id: id };
+    const update = { $set: { filename } };
+    const { matchedCount } = await this.s._filesCollection.updateOne(filter, update);
+    if (matchedCount === 0) {
+      throw new MongoRuntimeError(`File with id ${id} not found`);
+    }
   }
 
   /** Removes this bucket's files collection, followed by its chunks collection. */
-  drop(): Promise<void>;
-  /** @deprecated Callbacks are deprecated and will be removed in the next major version. See [mongodb-legacy](https://github.com/mongodb-js/nodejs-mongodb-legacy) for migration assistance */
-  drop(callback: Callback<void>): void;
-  drop(callback?: Callback<void>): Promise<void> | void {
-    return maybeCallback(async () => {
-      await this.s._filesCollection.drop();
-      await this.s._chunksCollection.drop();
-    }, callback);
+  async drop(): Promise<void> {
+    await this.s._filesCollection.drop();
+    await this.s._chunksCollection.drop();
   }
 }
diff --git a/src/gridfs/upload.ts b/src/gridfs/upload.ts
index e36c026d51..a5dabc564d 100644
--- a/src/gridfs/upload.ts
+++ b/src/gridfs/upload.ts
@@ -4,7 +4,7 @@ import type { Document } from '../bson';
 import { ObjectId } from '../bson';
 import type { Collection } from '../collection';
 import { AnyError, MongoAPIError, MONGODB_ERROR_CODES, MongoError } from '../error';
-import { Callback, maybeCallback } from '../utils';
+import type { Callback } from '../utils';
 import type { WriteConcernOptions } from '../write_concern';
 import { WriteConcern } from './../write_concern';
 import type { GridFSFile } from './download';
@@ -144,27 +144,20 @@ export class GridFSBucketWriteStream extends Writable implements NodeJS.Writable
   /**
    * Places this write stream into an aborted state (all future writes fail)
    * and deletes all chunks that have already been written.
-   *
-   * @param callback - called when chunks are successfully removed or error occurred
    */
-  abort(): Promise<void>;
-  /** @deprecated Callbacks are deprecated and will be removed in the next major version. See [mongodb-legacy](https://github.com/mongodb-js/nodejs-mongodb-legacy) for migration assistance */
-  abort(callback: Callback<void>): void;
-  abort(callback?: Callback<void>): Promise<void> | void {
-    return maybeCallback(async () => {
-      if (this.state.streamEnd) {
-        // TODO(NODE-3485): Replace with MongoGridFSStreamClosed
-        throw new MongoAPIError('Cannot abort a stream that has already completed');
-      }
+  async abort(): Promise<void> {
+    if (this.state.streamEnd) {
+      // TODO(NODE-3485): Replace with MongoGridFSStreamClosed
+      throw new MongoAPIError('Cannot abort a stream that has already completed');
+    }
 
-      if (this.state.aborted) {
-        // TODO(NODE-3485): Replace with MongoGridFSStreamClosed
-        throw new MongoAPIError('Cannot call abort() on a stream twice');
-      }
+    if (this.state.aborted) {
+      // TODO(NODE-3485): Replace with MongoGridFSStreamClosed
+      throw new MongoAPIError('Cannot call abort() on a stream twice');
+    }
 
-      this.state.aborted = true;
-      await this.chunks.deleteMany({ files_id: this.id });
-    }, callback);
+    this.state.aborted = true;
+    await this.chunks.deleteMany({ files_id: this.id });
   }
 
   /**
diff --git a/src/mongo_client.ts b/src/mongo_client.ts
index a34767758e..391ab3959c 100644
--- a/src/mongo_client.ts
+++ b/src/mongo_client.ts
@@ -24,15 +24,7 @@ import { readPreferenceServerSelector } from './sdam/server_selection';
 import type { SrvPoller } from './sdam/srv_polling';
 import { Topology, TopologyEvents } from './sdam/topology';
 import { ClientSession, ClientSessionOptions, ServerSessionPool } from './sessions';
-import {
-  Callback,
-  ClientMetadata,
-  HostAddress,
-  maybeCallback,
-  MongoDBNamespace,
-  ns,
-  resolveOptions
-} from './utils';
+import { ClientMetadata, HostAddress, MongoDBNamespace, ns, resolveOptions } from './utils';
 import type { W, WriteConcern, WriteConcernSettings } from './write_concern';
 
 /** @public */
@@ -412,79 +404,60 @@ export class MongoClient extends TypedEventEmitter<MongoClientEvents> {
    *
    * @see docs.mongodb.org/manual/reference/connection-string/
    */
-  connect(): Promise<this>;
-  /** @deprecated Callbacks are deprecated and will be removed in the next major version. See [mongodb-legacy](https://github.com/mongodb-js/nodejs-mongodb-legacy) for migration assistance */
-  connect(callback: Callback<this>): void;
-  connect(callback?: Callback<this>): Promise<this> | void {
-    if (callback && typeof callback !== 'function') {
-      throw new MongoInvalidArgumentError('Method `connect` only accepts a callback');
+  async connect(): Promise<this> {
+    if (this.topology && this.topology.isConnected()) {
+      return this;
     }
 
-    return maybeCallback(async () => {
-      if (this.topology && this.topology.isConnected()) {
-        return this;
-      }
-
-      const options = this[kOptions];
+    const options = this[kOptions];
 
-      if (typeof options.srvHost === 'string') {
-        const hosts = await resolveSRVRecord(options);
+    if (typeof options.srvHost === 'string') {
+      const hosts = await resolveSRVRecord(options);
 
-        for (const [index, host] of hosts.entries()) {
-          options.hosts[index] = host;
-        }
+      for (const [index, host] of hosts.entries()) {
+        options.hosts[index] = host;
       }
+    }
 
-      const topology = new Topology(options.hosts, options);
-      // Events can be emitted before initialization is complete so we have to
-      // save the reference to the topology on the client ASAP if the event handlers need to access it
-      this.topology = topology;
-      topology.client = this;
+    const topology = new Topology(options.hosts, options);
+    // Events can be emitted before initialization is complete so we have to
+    // save the reference to the topology on the client ASAP if the event handlers need to access it
+    this.topology = topology;
+    topology.client = this;
 
-      topology.once(Topology.OPEN, () => this.emit('open', this));
+    topology.once(Topology.OPEN, () => this.emit('open', this));
 
-      for (const event of MONGO_CLIENT_EVENTS) {
-        topology.on(event, (...args: any[]) => this.emit(event, ...(args as any)));
-      }
+    for (const event of MONGO_CLIENT_EVENTS) {
+      topology.on(event, (...args: any[]) => this.emit(event, ...(args as any)));
+    }
 
-      const topologyConnect = async () => {
-        try {
-          await promisify(callback => topology.connect(options, callback))();
-        } catch (error) {
-          topology.close({ force: true });
-          throw error;
-        }
-      };
-
-      if (this.autoEncrypter) {
-        const initAutoEncrypter = promisify(callback => this.autoEncrypter?.init(callback));
-        await initAutoEncrypter();
-        await topologyConnect();
-        await options.encrypter.connectInternalClient();
-      } else {
-        await topologyConnect();
+    const topologyConnect = async () => {
+      try {
+        await promisify(callback => topology.connect(options, callback))();
+      } catch (error) {
+        topology.close({ force: true });
+        throw error;
       }
+    };
 
-      return this;
-    }, callback);
+    if (this.autoEncrypter) {
+      const initAutoEncrypter = promisify(callback => this.autoEncrypter?.init(callback));
+      await initAutoEncrypter();
+      await topologyConnect();
+      await options.encrypter.connectInternalClient();
+    } else {
+      await topologyConnect();
+    }
+
+    return this;
   }
 
   /**
-   * Close the db and its underlying connections
+   * Close the client and its underlying connections
    *
    * @param force - Force close, emitting no events
-   * @param callback - An optional callback, a Promise will be returned if none is provided
    */
-  close(): Promise<void>;
-  close(force: boolean): Promise<void>;
-  /** @deprecated Callbacks are deprecated and will be removed in the next major version. See [mongodb-legacy](https://github.com/mongodb-js/nodejs-mongodb-legacy) for migration assistance */
-  close(callback: Callback<void>): void;
-  /** @deprecated Callbacks are deprecated and will be removed in the next major version. See [mongodb-legacy](https://github.com/mongodb-js/nodejs-mongodb-legacy) for migration assistance */
-  close(force: boolean, callback: Callback<void>): void;
-  close(
-    forceOrCallback?: boolean | Callback<void>,
-    callback?: Callback<void>
-  ): Promise<void> | void {
+  async close(force = false): Promise<void> {
     // There's no way to set hasBeenClosed back to false
     Object.defineProperty(this.s, 'hasBeenClosed', {
       value: true,
@@ -493,58 +466,50 @@ export class MongoClient extends TypedEventEmitter<MongoClientEvents> {
       writable: false
     });
 
-    if (typeof forceOrCallback === 'function') {
-      callback = forceOrCallback;
-    }
-
-    const force = typeof forceOrCallback === 'boolean' ? forceOrCallback : false;
+    const activeSessionEnds = Array.from(this.s.activeSessions, session => session.endSession());
+    this.s.activeSessions.clear();
 
-    return maybeCallback(async () => {
-      const activeSessionEnds = Array.from(this.s.activeSessions, session => session.endSession());
-      this.s.activeSessions.clear();
+    await Promise.all(activeSessionEnds);
 
-      await Promise.all(activeSessionEnds);
+    if (this.topology == null) {
+      return;
+    }
 
-      if (this.topology == null) {
-        return;
+    // If we would attempt to select a server and get nothing back we short circuit
+    // to avoid the server selection timeout.
+    const selector = readPreferenceServerSelector(ReadPreference.primaryPreferred);
+    const topologyDescription = this.topology.description;
+    const serverDescriptions = Array.from(topologyDescription.servers.values());
+    const servers = selector(topologyDescription, serverDescriptions);
+    if (servers.length !== 0) {
+      const endSessions = Array.from(this.s.sessionPool.sessions, ({ id }) => id);
+      if (endSessions.length !== 0) {
+        await this.db('admin')
+          .command(
+            { endSessions },
+            { readPreference: ReadPreference.primaryPreferred, noResponse: true }
+          )
+          .catch(() => null); // outcome does not matter
       }
+    }
 
-      // If we would attempt to select a server and get nothing back we short circuit
-      // to avoid the server selection timeout.
-      const selector = readPreferenceServerSelector(ReadPreference.primaryPreferred);
-      const topologyDescription = this.topology.description;
-      const serverDescriptions = Array.from(topologyDescription.servers.values());
-      const servers = selector(topologyDescription, serverDescriptions);
-      if (servers.length !== 0) {
-        const endSessions = Array.from(this.s.sessionPool.sessions, ({ id }) => id);
-        if (endSessions.length !== 0) {
-          await this.db('admin')
-            .command(
-              { endSessions },
-              { readPreference: ReadPreference.primaryPreferred, noResponse: true }
-            )
-            .catch(() => null); // outcome does not matter
+    // clear out references to old topology
+    const topology = this.topology;
+    this.topology = undefined;
+
+    await new Promise<void>((resolve, reject) => {
+      topology.close({ force }, error => {
+        if (error) return reject(error);
+        const { encrypter } = this[kOptions];
+        if (encrypter) {
+          return encrypter.close(this, force, error => {
+            if (error) return reject(error);
+            resolve();
+          });
         }
-      }
-
-      // clear out references to old topology
-      const topology = this.topology;
-      this.topology = undefined;
-
-      await new Promise<void>((resolve, reject) => {
-        topology.close({ force }, error => {
-          if (error) return reject(error);
-          const { encrypter } = this[kOptions];
-          if (encrypter) {
-            return encrypter.close(this, force, error => {
-              if (error) return reject(error);
-              resolve();
-            });
-          }
-          resolve();
-        });
+        resolve();
       });
-    }, callback);
+    });
   }
 
   /**
@@ -579,34 +544,12 @@ export class MongoClient extends TypedEventEmitter<MongoClientEvents> {
    *
    * @see https://docs.mongodb.org/manual/reference/connection-string/
    */
-  static connect(url: string): Promise<MongoClient>;
-  static connect(url: string, options: MongoClientOptions): Promise<MongoClient>;
-  /** @deprecated Callbacks are deprecated and will be removed in the next major version. See [mongodb-legacy](https://github.com/mongodb-js/nodejs-mongodb-legacy) for migration assistance */
-  static connect(url: string, callback: Callback<MongoClient>): void;
-  /** @deprecated Callbacks are deprecated and will be removed in the next major version. See [mongodb-legacy](https://github.com/mongodb-js/nodejs-mongodb-legacy) for migration assistance */
-  static connect(url: string, options: MongoClientOptions, callback: Callback<MongoClient>): void;
-  static connect(
-    url: string,
-    options?: MongoClientOptions | Callback<MongoClient>,
-    callback?: Callback<MongoClient>
-  ): Promise<MongoClient> | void {
-    callback =
-      typeof callback === 'function'
-        ? callback
-        : typeof options === 'function'
-        ? options
-        : undefined;
-
-    return maybeCallback(async () => {
-      options = typeof options !== 'function' ? options : undefined;
-      const client = new this(url, options);
-      return client.connect();
-    }, callback);
+  static async connect(url: string, options?: MongoClientOptions): Promise<MongoClient> {
+    const client = new this(url, options);
+    return client.connect();
   }
 
   /** Starts a new session on the server */
-  startSession(): ClientSession;
-  startSession(options: ClientSessionOptions): ClientSession;
   startSession(options?: ClientSessionOptions): ClientSession {
     const session = new ClientSession(
       this,
@@ -630,10 +573,10 @@ export class MongoClient extends TypedEventEmitter<MongoClientEvents> {
    * @param options - Optional settings for the command
    * @param callback - An callback to execute with an implicitly created session
    */
-  withSession(callback: WithSessionCallback): Promise<void>;
-  withSession(options: ClientSessionOptions, callback: WithSessionCallback): Promise<void>;
-  withSession(
-    optionsOrOperation?: ClientSessionOptions | WithSessionCallback,
+  async withSession(callback: WithSessionCallback): Promise<void>;
+  async withSession(options: ClientSessionOptions, callback: WithSessionCallback): Promise<void>;
+  async withSession(
+    optionsOrOperation: ClientSessionOptions | WithSessionCallback,
     callback?: WithSessionCallback
   ): Promise<void> {
     const options = {
@@ -652,17 +595,15 @@ export class MongoClient extends TypedEventEmitter<MongoClientEvents> {
 
     const session = this.startSession(options);
 
-    return maybeCallback(async () => {
+    try {
+      await withSessionCallback(session);
+    } finally {
       try {
-        await withSessionCallback(session);
-      } finally {
-        try {
-          await session.endSession();
-        } catch {
-          // We are not concerned with errors from endSession()
-        }
+        await session.endSession();
+      } catch {
+        // We are not concerned with errors from endSession()
       }
-    }, null);
+    }
   }
 
   /**
diff --git a/src/sessions.ts b/src/sessions.ts
index ddc0e53f5a..9e42795229 100644
--- a/src/sessions.ts
+++ b/src/sessions.ts
@@ -37,7 +37,6 @@ import {
   isPromiseLike,
   List,
   maxWireVersion,
-  maybeCallback,
   now,
   uuidV4
 } from './utils';
@@ -247,47 +246,32 @@ export class ClientSession extends TypedEventEmitter<ClientSessionEvents> {
    * Ends this session on the server
    *
    * @param options - Optional settings. Currently reserved for future use
-   * @param callback - Optional callback for completion of this operation
    */
-  endSession(): Promise<void>;
-  endSession(options: EndSessionOptions): Promise<void>;
-  /** @deprecated Callbacks are deprecated and will be removed in the next major version. See [mongodb-legacy](https://github.com/mongodb-js/nodejs-mongodb-legacy) for migration assistance */
-  endSession(callback: Callback<void>): void;
-  /** @deprecated Callbacks are deprecated and will be removed in the next major version. See [mongodb-legacy](https://github.com/mongodb-js/nodejs-mongodb-legacy) for migration assistance */
-  endSession(options: EndSessionOptions, callback: Callback<void>): void;
-  endSession(
-    options?: EndSessionOptions | Callback<void>,
-    callback?: Callback<void>
-  ): void | Promise<void> {
-    if (typeof options === 'function') (callback = options), (options = {});
-    const finalOptions = { force: true, ...options };
-
-    return maybeCallback(async () => {
-      try {
-        if (this.inTransaction()) {
-          await this.abortTransaction();
-        }
-        if (!this.hasEnded) {
-          const serverSession = this[kServerSession];
-          if (serverSession != null) {
-            // release the server session back to the pool
-            this.sessionPool.release(serverSession);
-            // Make sure a new serverSession never makes it onto this ClientSession
-            Object.defineProperty(this, kServerSession, {
-              value: ServerSession.clone(serverSession),
-              writable: false
-            });
-          }
-          // mark the session as ended, and emit a signal
-          this.hasEnded = true;
-          this.emit('ended', this);
+  async endSession(options?: EndSessionOptions): Promise<void> {
+    try {
+      if (this.inTransaction()) {
+        await this.abortTransaction();
+      }
+      if (!this.hasEnded) {
+        const serverSession = this[kServerSession];
+        if (serverSession != null) {
+          // release the server session back to the pool
+          this.sessionPool.release(serverSession);
+          // Make sure a new serverSession never makes it onto this ClientSession
+          Object.defineProperty(this, kServerSession, {
+            value: ServerSession.clone(serverSession),
+            writable: false
+          });
         }
-      } catch {
-        // spec indicates that we should ignore all errors for `endSessions`
-      } finally {
-        maybeClearPinnedConnection(this, finalOptions);
+        // mark the session as ended, and emit a signal
+        this.hasEnded = true;
+        this.emit('ended', this);
       }
-    }, callback);
+    } catch {
+      // spec indicates that we should ignore all errors for `endSessions`
+    } finally {
+      maybeClearPinnedConnection(this, { force: true, ...options });
+    }
   }
 
   /**
@@ -421,26 +405,16 @@ export class ClientSession extends TypedEventEmitter<ClientSessionEvents> {
 
   /**
    * Commits the currently active transaction in this session.
-   *
-   * @param callback - An optional callback, a Promise will be returned if none is provided
    */
-  commitTransaction(): Promise<Document>;
-  /** @deprecated Callbacks are deprecated and will be removed in the next major version. See [mongodb-legacy](https://github.com/mongodb-js/nodejs-mongodb-legacy) for migration assistance */
-  commitTransaction(callback: Callback<Document>): void;
-  commitTransaction(callback?: Callback<Document>): Promise<Document> | void {
-    return maybeCallback(async () => endTransactionAsync(this, 'commitTransaction'), callback);
+  async commitTransaction(): Promise<Document> {
+    return endTransactionAsync(this, 'commitTransaction');
   }
 
   /**
    * Aborts the currently active transaction in this session.
-   *
-   * @param callback - An optional callback, a Promise will be returned if none is provided
    */
-  abortTransaction(): Promise<Document>;
-  /** @deprecated Callbacks are deprecated and will be removed in the next major version. See [mongodb-legacy](https://github.com/mongodb-js/nodejs-mongodb-legacy) for migration assistance */
-  abortTransaction(callback: Callback<Document>): void;
-  abortTransaction(callback?: Callback<Document>): Promise<Document> | void {
-    return maybeCallback(async () => endTransactionAsync(this, 'abortTransaction'), callback);
+  async abortTransaction(): Promise<Document> {
+    return endTransactionAsync(this, 'abortTransaction');
   }
 
   /**
@@ -471,7 +445,7 @@ export class ClientSession extends TypedEventEmitter<ClientSessionEvents> {
    * @param options - optional settings for the transaction
    * @returns A raw command response or undefined
    */
-  withTransaction<T = void>(
+  async withTransaction<T = void>(
     fn: WithTransactionCallback<T>,
     options?: TransactionOptions
   ): Promise<Document | undefined> {
diff --git a/test/integration/change-streams/change_stream.test.ts b/test/integration/change-streams/change_stream.test.ts
index 05074716af..213a5bd628 100644
--- a/test/integration/change-streams/change_stream.test.ts
+++ b/test/integration/change-streams/change_stream.test.ts
@@ -749,16 +749,14 @@ describe('Change Streams', function () {
 
         const errRegex = /ChangeStream cannot be used as an iterator/;
 
-        // These all throw synchronously so it should be safe to not await the results
-        expect(() => {
-          changeStream.next();
-        }).to.throw(errRegex);
-        expect(() => {
-          changeStream.hasNext();
-        }).to.throw(errRegex);
-        expect(() => {
-          changeStream.tryNext();
-        }).to.throw(errRegex);
+        const nextError = await changeStream.next().catch(error => error);
+        expect(nextError.message).to.match(errRegex);
+
+        const hasNextError = await changeStream.hasNext().catch(error => error);
+        expect(hasNextError.message).to.match(errRegex);
+
+        const tryNextError = await changeStream.tryNext().catch(error => error);
+        expect(tryNextError.message).to.match(errRegex);
       }
     });
 
diff --git a/test/integration/change-streams/change_streams.prose.test.ts b/test/integration/change-streams/change_streams.prose.test.ts
index 531776adeb..152b89fbc5 100644
--- a/test/integration/change-streams/change_streams.prose.test.ts
+++ b/test/integration/change-streams/change_streams.prose.test.ts
@@ -37,7 +37,7 @@ function triggerResumableError(
   }
 
   const stub = sinon.stub(changeStream.cursor, 'close');
-  stub.callsFake(function () {
+  stub.callsFake(async function () {
     stub.wrappedMethod.call(this);
     stub.restore();
     onClose();
@@ -50,7 +50,7 @@ function triggerResumableError(
       return;
     }
 
-    const nextStub = sinon.stub(changeStream.cursor, 'next').callsFake(function (callback) {
+    const nextStub = sinon.stub(changeStream.cursor, 'next').callsFake(async function () {
       callback(new MongoNetworkError('error triggered from test'));
       nextStub.restore();
     });
diff --git a/test/integration/collection-management/collection.test.ts b/test/integration/collection-management/collection.test.ts
index d7fba71231..5b4cac76ac 100644
--- a/test/integration/collection-management/collection.test.ts
+++ b/test/integration/collection-management/collection.test.ts
@@ -241,15 +241,14 @@ describe('Collection', function () {
       });
     });
 
-    it('should throw error due to illegal update', function (done) {
-      db.createCollection('shouldThrowErrorDueToIllegalUpdate', {}, (err, coll) => {
-        expect(() => coll.update({}, null)).to.throw(/Document must be a valid JavaScript object/);
-        expect(() => coll.update(null, null)).to.throw(
-          /Selector must be a valid JavaScript object/
-        );
+    it('should throw error due to illegal update', async function () {
+      const coll = await db.createCollection('shouldThrowErrorDueToIllegalUpdate', {});
 
-        done();
-      });
+      const filterError = await coll.updateOne(null, {}).catch(error => error);
+      expect(filterError.message).to.match(/Selector must be a valid JavaScript object/);
+
+      const updateError = await coll.updateOne({}, null).catch(error => error);
+      expect(updateError.message).to.match(/Document must be a valid JavaScript object/);
     });
 
     const selectorTests = [
diff --git a/test/integration/crud/find_and_modify.test.js b/test/integration/crud/find_and_modify.test.js
index c2e3607384..2735d0a95e 100644
--- a/test/integration/crud/find_and_modify.test.js
+++ b/test/integration/crud/find_and_modify.test.js
@@ -308,16 +308,14 @@ describe('Find and Modify', function () {
     }
   });
 
-  it('should not allow atomic operators for findOneAndReplace', {
-    metadata: { requires: { topology: 'single' } },
-    test: async function () {
-      const client = this.configuration.newClient();
-      const db = client.db('fakeDb');
-      const collection = db.collection('test');
-      expect(() => {
-        collection.findOneAndReplace({ a: 1 }, { $set: { a: 14 } });
-      }).to.throw(/must not contain atomic operators/);
-      await client.close();
-    }
+  it('should not allow atomic operators for findOneAndReplace', async function () {
+    const client = this.configuration.newClient();
+    const db = client.db('fakeDb');
+    const collection = db.collection('test');
+    const error = await collection
+      .findOneAndReplace({ a: 1 }, { $set: { a: 14 } })
+      .catch(error => error);
+    expect(error.message).to.match(/must not contain atomic operators/);
+    await client.close();
   });
 });
diff --git a/test/integration/crud/find_cursor_methods.test.js b/test/integration/crud/find_cursor_methods.test.js
index 278ddeca14..9ead78b794 100644
--- a/test/integration/crud/find_cursor_methods.test.js
+++ b/test/integration/crud/find_cursor_methods.test.js
@@ -205,48 +205,32 @@ describe('Find Cursor', function () {
   });
 
   context('#clone', function () {
-    it('should clone a find cursor', function (done) {
+    it('should clone a find cursor', async function () {
       const coll = client.db().collection('abstract_cursor');
       const cursor = coll.find({});
-      this.defer(() => cursor.close());
-
-      cursor.toArray((err, docs) => {
-        expect(err).to.not.exist;
-        expect(docs).to.have.length(6);
-        expect(cursor).property('closed').to.be.true;
 
-        const clonedCursor = cursor.clone();
-        this.defer(() => clonedCursor.close());
+      const docsFromOriginal = await cursor.toArray();
+      expect(docsFromOriginal).to.have.length(6);
+      expect(cursor).property('closed').to.be.true;
 
-        clonedCursor.toArray((err, docs) => {
-          expect(err).to.not.exist;
-          expect(docs).to.have.length(6);
-          expect(clonedCursor).property('closed').to.be.true;
-          done();
-        });
-      });
+      const clonedCursor = cursor.clone();
+      const docsFromCloned = await clonedCursor.toArray();
+      expect(docsFromCloned).to.have.length(6);
+      expect(cursor).property('closed').to.be.true;
     });
 
-    it('should clone an aggregate cursor', function (done) {
+    it('should clone an aggregate cursor', async function () {
       const coll = client.db().collection('abstract_cursor');
       const cursor = coll.aggregate([{ $match: {} }]);
-      this.defer(() => cursor.close());
-
-      cursor.toArray((err, docs) => {
-        expect(err).to.not.exist;
-        expect(docs).to.have.length(6);
-        expect(cursor).property('closed').to.be.true;
 
-        const clonedCursor = cursor.clone();
-        this.defer(() => clonedCursor.close());
+      const docsFromOriginal = await cursor.toArray();
+      expect(docsFromOriginal).to.have.length(6);
+      expect(cursor).property('closed').to.be.true;
 
-        clonedCursor.toArray((err, docs) => {
-          expect(err).to.not.exist;
-          expect(docs).to.have.length(6);
-          expect(clonedCursor).property('closed').to.be.true;
-          done();
-        });
-      });
+      const clonedCursor = cursor.clone();
+      const docsFromCloned = await clonedCursor.toArray();
+      expect(docsFromCloned).to.have.length(6);
+      expect(cursor).property('closed').to.be.true;
     });
   });
 
diff --git a/test/integration/crud/insert.test.js b/test/integration/crud/insert.test.js
index 4602a0af4e..99cc5bb3c9 100644
--- a/test/integration/crud/insert.test.js
+++ b/test/integration/crud/insert.test.js
@@ -17,7 +17,8 @@ const {
   MaxKey,
   Code,
   MongoBulkWriteError,
-  ReturnDocument
+  ReturnDocument,
+  MongoInvalidArgumentError
 } = require('../../mongodb');
 
 /**
@@ -91,25 +92,14 @@ describe('crud - insert', function () {
     });
   });
 
-  it('Should correctly return failing Promise when no document array passed into insertMany', function (done) {
-    const configuration = this.configuration;
-    let url = configuration.url();
-    url =
-      url.indexOf('?') !== -1
-        ? f('%s&%s', url, 'maxPoolSize=100')
-        : f('%s?%s', url, 'maxPoolSize=100');
-
-    const client = configuration.newClient(url);
-    client.connect().then(() => {
-      this.defer(() => client.close());
-
-      const db = client.db(configuration.db);
-      expect(() => {
-        db.collection('insertMany_Promise_error').insertMany({ a: 1 });
-      }).to.throw(/Argument "docs" must be an array of documents/);
-
-      done();
-    });
+  it('rejects when insertMany is passed a non array object', async function () {
+    const db = client.db();
+    const error = await db
+      .collection('insertMany_Promise_error')
+      .insertMany({ a: 1 })
+      .catch(error => error);
+    expect(error).to.be.instanceOf(MongoInvalidArgumentError);
+    expect(error.message).to.match(/must be an array/);
   });
 
   describe('collection.insert()', function () {
diff --git a/test/integration/crud/misc_cursors.test.js b/test/integration/crud/misc_cursors.test.js
index 463be72d11..e0cc7a77d5 100644
--- a/test/integration/crud/misc_cursors.test.js
+++ b/test/integration/crud/misc_cursors.test.js
@@ -1671,64 +1671,26 @@ describe('Cursor', function () {
     }
   });
 
-  it('removes session wheen cloning a find cursor', function (done) {
-    const configuration = this.configuration;
-    client.connect((err, client) => {
-      expect(err).to.not.exist;
-
-      const db = client.db(configuration.db);
-      db.createCollection('clone_find_cursor_session', (err, collection) => {
-        expect(err).to.not.exist;
+  it('removes session when cloning an find cursor', async function () {
+    const collection = await client.db().collection('test');
 
-        collection.insertOne({ a: 1 }, configuration.writeConcernMax(), err => {
-          expect(err).to.not.exist;
+    const cursor = collection.find({});
+    const clonedCursor = cursor.clone();
 
-          const cursor = collection.find();
-          const clonedCursor = cursor.clone();
-          cursor.toArray(err => {
-            expect(err).to.not.exist;
-            clonedCursor.toArray(err => {
-              expect(err).to.not.exist;
-              client.close();
-              done();
-            });
-          });
-        });
-      });
-    });
+    expect(cursor).to.have.property('session');
+    expect(clonedCursor).to.have.property('session');
+    expect(cursor.session).to.not.equal(clonedCursor.session);
   });
 
-  it('removes session wheen cloning an aggregation cursor', {
-    metadata: {
-      requires: { topology: ['single', 'replicaset', 'sharded'] }
-    },
-
-    test: function (done) {
-      const configuration = this.configuration;
-      client.connect((err, client) => {
-        expect(err).to.not.exist;
-
-        const db = client.db(configuration.db);
-        db.createCollection('clone_aggregation_cursor_session', (err, collection) => {
-          expect(err).to.not.exist;
+  it('removes session when cloning an aggregation cursor', async function () {
+    const collection = await client.db().collection('test');
 
-          collection.insertOne({ a: 1 }, configuration.writeConcernMax(), err => {
-            expect(err).to.not.exist;
+    const cursor = collection.aggregate([{ $match: {} }]);
+    const clonedCursor = cursor.clone();
 
-            const cursor = collection.aggregate([{ $match: { a: 1 } }]);
-            const clonedCursor = cursor.clone();
-            cursor.toArray(err => {
-              expect(err).to.not.exist;
-              clonedCursor.toArray(err => {
-                expect(err).to.not.exist;
-                client.close();
-                done();
-              });
-            });
-          });
-        });
-      });
-    }
+    expect(cursor).to.have.property('session');
+    expect(clonedCursor).to.have.property('session');
+    expect(cursor.session).to.not.equal(clonedCursor.session);
   });
 
   it('destroying a stream stops it', {
diff --git a/test/integration/node-specific/operation_examples.test.ts b/test/integration/node-specific/operation_examples.test.ts
index eb092ce853..b0de3fc127 100644
--- a/test/integration/node-specific/operation_examples.test.ts
+++ b/test/integration/node-specific/operation_examples.test.ts
@@ -1,13 +1,13 @@
 import { expect } from 'chai';
 import { format as f } from 'util';
 
-import { Code, enumToString, ProfilingLevel, ReturnDocument } from '../../mongodb';
+import { Code, enumToString, MongoClient, ProfilingLevel, ReturnDocument } from '../../mongodb';
 import { skipBrokenAuthTestBeforeEachHook } from '../../tools/runner/hooks/configuration';
 import { sleep as delay } from '../../tools/utils';
 import { setupDatabase } from '../shared';
 
 describe('Operations', function () {
-  let client;
+  let client: MongoClient;
   beforeEach(async function () {
     client = this.configuration.newClient();
   });
@@ -1572,47 +1572,17 @@ describe('Operations', function () {
    * example-class Collection
    * example-method remove
    */
-  it('shouldRemoveAllDocumentsNoSafeWithPromises', {
-    metadata: { requires: { topology: ['single'] } },
-
-    test: function () {
-      const configuration = this.configuration;
-      const client = configuration.newClient({ maxPoolSize: 1 });
-
-      return client.connect().then(function (client) {
-        const db = client.db(configuration.db);
-        // LINE var MongoClient = require('mongodb').MongoClient,
-        // LINE   test = require('assert');
-        // LINE const client = new MongoClient('mongodb://localhost:27017/test');
-        // LINE client.connect().then(() => {
-        // LINE   var db = client.db('test);
-        // REPLACE configuration.writeConcernMax() WITH {w:1}
-        // REMOVE-LINE done();
-        // BEGIN
-
-        // Fetch a collection to insert document into
-        const collection = db.collection('remove_all_documents_no_safe_with_promise');
-
-        // Insert a bunch of documents
-        return collection
-          .insertMany([{ a: 1 }, { b: 2 }], { writeConcern: { w: 1 } })
-          .then(function (result) {
-            expect(result).to.exist;
-
-            // Remove all the document
-            return collection.deleteMany();
-          })
-          .then(function () {
-            // Fetch all results
-            return collection.find().toArray();
-          })
-          .then(function (items) {
-            expect(items.length).to.equal(0);
-            return client.close();
-          });
-      });
-      // END
-    }
+  it('deleteMany() deletes all documents in collection', async function () {
+    const db = client.db();
+    // Fetch a collection to insert document into
+    const collection = db.collection('remove_all_documents_no_safe_with_promise');
+
+    // Insert a bunch of documents
+    const result = await collection.insertMany([{ a: 1 }, { b: 2 }], { writeConcern: { w: 1 } });
+    expect(result).to.exist;
+    await collection.deleteMany();
+    const items = await collection.find().toArray();
+    expect(items).to.have.lengthOf(0);
   });
 
   /**
diff --git a/test/integration/transactions/transactions.test.ts b/test/integration/transactions/transactions.test.ts
index a10312f1e5..2ee418dec1 100644
--- a/test/integration/transactions/transactions.test.ts
+++ b/test/integration/transactions/transactions.test.ts
@@ -4,6 +4,7 @@ import {
   ClientSession,
   Collection,
   MongoClient,
+  MongoInvalidArgumentError,
   MongoNetworkError,
   ServerSessionPool
 } from '../../mongodb';
@@ -24,23 +25,31 @@ describe('Transactions', function () {
       await client.close();
     });
 
-    it('should provide a useful error if a Promise is not returned', {
-      metadata: {
-        requires: { topology: ['replicaset', 'sharded'], mongodb: '>=4.1.5', serverless: 'forbid' }
+    it(
+      'should provide a useful error if a Promise is not returned',
+      {
+        requires: {
+          topology: ['replicaset', 'sharded'],
+          mongodb: '>=4.1.5',
+          serverless: 'forbid'
+        }
       },
-      test: function (done) {
-        function fnThatDoesntReturnPromise() {
+      async function () {
+        function fnThatDoesNotReturnPromise() {
           return false;
         }
 
-        // @ts-expect-error: Testing that a non promise returning function is handled correctly
-        expect(() => session.withTransaction(fnThatDoesntReturnPromise)).to.throw(
-          /must return a Promise/
-        );
+        const result = await session
+          // @ts-expect-error: testing a function that does not return a promise
+          .withTransaction(fnThatDoesNotReturnPromise)
+          .catch(error => error);
 
-        session.endSession(done);
+        expect(result).to.be.instanceOf(MongoInvalidArgumentError);
+        expect(result.message).to.match(/must return a Promise/);
+
+        await session.endSession();
       }
-    });
+    );
 
     it('should return readable error if promise rejected with no reason', {
       metadata: {
diff --git a/test/types/community/bulk/bulk-operation-base.test-d.ts b/test/types/community/bulk/bulk-operation-base.test-d.ts
index 29564ff393..cc2e5ecb59 100644
--- a/test/types/community/bulk/bulk-operation-base.test-d.ts
+++ b/test/types/community/bulk/bulk-operation-base.test-d.ts
@@ -1,13 +1,11 @@
 import { expectType } from 'tsd';
 
 import {
-  AnyError,
   Batch,
   BatchType,
   BulkOperationBase,
   BulkWriteOptions,
   BulkWriteResult,
-  Callback,
   DeleteStatement,
   Document,
   MongoClient,
@@ -51,32 +49,3 @@ function extendedPromiseBasedBulkExecute(
 }
 
 expectType<Promise<BulkWriteResult>>(extendedPromiseBasedBulkExecute());
-
-expectType<void>(
-  bulkOperation.execute((error, bulkWriteResult) => {
-    expectType<AnyError | undefined>(error);
-    expectType<BulkWriteResult | undefined>(bulkWriteResult);
-  })
-);
-
-expectType<void>(
-  bulkOperation.execute(options, (error, bulkWriteResult) => {
-    expectType<AnyError | undefined>(error);
-    expectType<BulkWriteResult | undefined>(bulkWriteResult);
-  })
-);
-
-// ensure we can use the bulk operation execute in a callback based wrapper function
-function extendedCallbackBasedBulkExecute(
-  callback: Callback<BulkWriteResult>,
-  optionalOptions?: BulkWriteOptions
-): void {
-  bulkOperation.execute(optionalOptions, callback);
-}
-
-expectType<void>(
-  extendedCallbackBasedBulkExecute((error, bulkWriteResult) => {
-    expectType<AnyError | undefined>(error);
-    expectType<BulkWriteResult | undefined>(bulkWriteResult);
-  })
-);
diff --git a/test/types/community/client.test-d.ts b/test/types/community/client.test-d.ts
index 613bf6095d..54aaf0f22c 100644
--- a/test/types/community/client.test-d.ts
+++ b/test/types/community/client.test-d.ts
@@ -4,7 +4,6 @@ import {
   GridFSBucket,
   MongoClient,
   MongoClientOptions,
-  MongoError,
   MongoNetworkError,
   MongoParseError,
   ReadPreference,
@@ -37,25 +36,11 @@ const options: MongoClientOptions = {
   directConnection: false
 };
 
-MongoClient.connect(connectionString, options, (err, client?: MongoClient) => {
-  if (err || !client) throw err;
-  const db = client.db('test');
-  db.collection('test_crud');
-  // Let's close the db
-  client.close();
-});
-
 export async function testFunc(): Promise<MongoClient> {
   const testClient: MongoClient = await MongoClient.connect(connectionString);
   return testClient;
 }
 
-MongoClient.connect(connectionString, err => {
-  if (err instanceof MongoError) {
-    expectType<boolean>(err.hasErrorLabel('label'));
-  }
-});
-
 expectType<Promise<MongoClient>>(MongoClient.connect(connectionString, options));
 
 // TLS
@@ -82,16 +67,6 @@ export function gridTest(bucket: GridFSBucket): void {
   openUploadStream.on('close', () => {});
   openUploadStream.on('end', () => {});
   expectType<Promise<void>>(openUploadStream.abort()); // $ExpectType void
-  expectType<void>(
-    openUploadStream.abort(() => {
-      openUploadStream.removeAllListeners();
-    })
-  );
-  openUploadStream.abort(error => {
-    error; // $ExpectType MongoError
-  });
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  openUploadStream.abort((error, result) => {});
 }
 
 // Client-Side Field Level Encryption
diff --git a/test/types/community/collection/distinct.test-d.ts b/test/types/community/collection/distinct.test-d.ts
index 5bc87e0131..8d0ffac48b 100644
--- a/test/types/community/collection/distinct.test-d.ts
+++ b/test/types/community/collection/distinct.test-d.ts
@@ -18,32 +18,10 @@ expectType<string[]>(await collection.distinct('test'));
 expectType<string[]>(await collection.distinct('test', { foo: 1 }));
 expectType<string[]>(await collection.distinct('test', { foo: 1 }, { maxTimeMS: 400 }));
 
-collection.distinct('_id', (err, fields) => {
-  // callbacks always have the second argument undefined
-  // incase of error
-  expectType<ObjectId[] | undefined>(fields);
-});
-collection.distinct('_id', { foo: 1 }, (err, fields) => {
-  expectType<ObjectId[] | undefined>(fields);
-});
-collection.distinct('_id', { foo: 1 }, { maxTimeMS: 400 }, (err, fields) => {
-  expectType<ObjectId[] | undefined>(fields);
-});
-
 expectType<ObjectId[]>(await collection.distinct('_id'));
 expectType<ObjectId[]>(await collection.distinct('_id', { foo: 1 }));
 expectType<ObjectId[]>(await collection.distinct('_id', { foo: 1 }, { maxTimeMS: 400 }));
 
-collection.distinct('nested.num', (err, fields) => {
-  expectType<any[] | undefined>(fields);
-});
-collection.distinct('nested.num', { foo: 1 }, (err, fields) => {
-  expectType<any[] | undefined>(fields);
-});
-collection.distinct('nested.num', { foo: 1 }, { maxTimeMS: 400 }, (err, fields) => {
-  expectType<any[] | undefined>(fields);
-});
-
 expectType<any[]>(await collection.distinct('nested.num'));
 expectType<any[]>(await collection.distinct('nested.num', { foo: 1 }));
 expectType<any[]>(await collection.distinct('nested.num', { foo: 1 }, { maxTimeMS: 400 }));
diff --git a/test/types/community/collection/findX.test-d.ts b/test/types/community/collection/findX.test-d.ts
index e0ccd4eb92..216239be9f 100644
--- a/test/types/community/collection/findX.test-d.ts
+++ b/test/types/community/collection/findX.test-d.ts
@@ -4,7 +4,6 @@ import type { Filter } from '../../../../src';
 import {
   Collection,
   Db,
-  Document,
   FindCursor,
   FindOptions,
   MongoClient,
@@ -19,13 +18,9 @@ const db = client.db('test');
 const collection = db.collection('test.find');
 
 // Locate all the entries using find
-collection.find({}).toArray((_err, fields) => {
-  expectType<WithId<Document>[] | undefined>(fields);
-  if (fields) {
-    expectType<ObjectId>(fields[0]._id);
-    expectNotType<ObjectId | undefined>(fields[0]._id);
-  }
-});
+const fields = await collection.find({}).toArray();
+expectType<ObjectId>(fields[0]._id);
+expectNotType<ObjectId | undefined>(fields[0]._id);
 
 // test with collection type
 interface TestModel {
@@ -86,21 +81,6 @@ interface Bag {
 
 const collectionBag = db.collection<Bag>('bag');
 
-const cursor: FindCursor<WithId<Bag>> = collectionBag.find({ color: 'black' });
-
-cursor.toArray((_err, bags) => {
-  expectType<WithId<Bag>[] | undefined>(bags);
-});
-
-cursor.forEach(
-  bag => {
-    expectType<WithId<Bag>>(bag);
-  },
-  () => {
-    return null;
-  }
-);
-
 expectType<WithId<Bag> | null>(
   await collectionBag.findOne({ color: 'red' }, { projection: { cost: 1 } })
 );
@@ -253,14 +233,6 @@ const typedDb = client.db('test2') as TypedDb;
 const person = typedDb.collection('people').findOne({});
 expectType<Promise<WithId<Person> | null>>(person);
 
-typedDb.collection('people').findOne({}, function (_err, person) {
-  expectType<WithId<Person> | null | undefined>(person); // null is if nothing is found, undefined is when there is an error defined
-});
-
-typedDb.collection('things').findOne({}, function (_err, thing) {
-  expectType<WithId<Thing> | null | undefined>(thing);
-});
-
 interface SchemaWithTypicalId {
   _id: ObjectId;
   name: string;
diff --git a/test/types/community/db/createCollection.test-d.ts b/test/types/community/db/createCollection.test-d.ts
index 9e932fd5cb..0830804bb9 100644
--- a/test/types/community/db/createCollection.test-d.ts
+++ b/test/types/community/db/createCollection.test-d.ts
@@ -1,13 +1,6 @@
 import { expectType } from 'tsd';
 
-import {
-  AnyError,
-  Callback,
-  Collection,
-  CreateCollectionOptions,
-  MongoClient,
-  ObjectId
-} from '../../../mongodb';
+import { Collection, CreateCollectionOptions, MongoClient, ObjectId } from '../../../mongodb';
 
 const client = new MongoClient('');
 const db = client.db('test');
@@ -50,33 +43,3 @@ function extendedPromiseBasedCreateCollection(
 }
 
 expectType<Promise<Collection<TestSchema>>>(extendedPromiseBasedCreateCollection('test'));
-
-expectType<void>(
-  db.createCollection<TestSchema>('test', (err, collection) => {
-    expectType<AnyError | undefined>(err);
-    expectType<Collection<TestSchema> | undefined>(collection);
-  })
-);
-
-expectType<void>(
-  db.createCollection<TestSchema>('test', options, (err, collection) => {
-    expectType<AnyError | undefined>(err);
-    expectType<Collection<TestSchema> | undefined>(collection);
-  })
-);
-
-// ensure we can use the create collection in a callback based wrapper function
-function extendedCallbackBasedCreateCollection(
-  name: string,
-  callback: Callback<Collection<TestSchema>>,
-  optionalOptions?: CreateCollectionOptions
-): void {
-  db.createCollection<TestSchema>(name, optionalOptions, callback);
-}
-
-expectType<void>(
-  extendedCallbackBasedCreateCollection('test', (err, collection) => {
-    expectType<AnyError | undefined>(err);
-    expectType<Collection<TestSchema> | undefined>(collection);
-  })
-);
diff --git a/test/types/indexes_test-d.ts b/test/types/indexes_test-d.ts
index 430559a5fc..34ae9d4a18 100644
--- a/test/types/indexes_test-d.ts
+++ b/test/types/indexes_test-d.ts
@@ -1,6 +1,6 @@
 import { expectType } from 'tsd';
 
-import { AnyError, Document, MongoClient } from '../../src';
+import { Document, MongoClient } from '../../src';
 
 const client = new MongoClient('');
 const db = client.db('test');
@@ -14,14 +14,3 @@ expectType<Promise<Document[]>>(collection.indexes({}));
 for (const index of await collection.indexes()) {
   expectType<Document>(index);
 }
-
-// Callback variant testing
-collection.indexes((err, indexes) => {
-  expectType<AnyError | undefined>(err);
-  expectType<Document[] | undefined>(indexes);
-});
-
-collection.indexes({}, (err, indexes) => {
-  expectType<AnyError | undefined>(err);
-  expectType<Document[] | undefined>(indexes);
-});