bun-types 1.2.6 → 1.2.8-canary.20250327T140605

package/sqlite.d.ts

@@ -24,1220 +24,1191 @@
  * | `null` | `NULL` |
  */
 declare module "bun:sqlite" {
-	export class Database implements Disposable {
-		/**
-		 * Open or create a SQLite3 database
-		 *
-		 * @param filename The filename of the database to open. Pass an empty string (`""`) or `":memory:"` or undefined for an in-memory database.
-		 * @param options defaults to `{readwrite: true, create: true}`. If a number, then it's treated as `SQLITE_OPEN_*` constant flags.
-		 *
-		 * @example
-		 *
-		 * ```ts
-		 * const db = new Database("mydb.sqlite");
-		 * db.run("CREATE TABLE foo (bar TEXT)");
-		 * db.run("INSERT INTO foo VALUES (?)", ["baz"]);
-		 * console.log(db.query("SELECT * FROM foo").all());
-		 * ```
-		 *
-		 * @example
-		 *
-		 * Open an in-memory database
-		 *
-		 * ```ts
-		 * const db = new Database(":memory:");
-		 * db.run("CREATE TABLE foo (bar TEXT)");
-		 * db.run("INSERT INTO foo VALUES (?)", ["hiiiiii"]);
-		 * console.log(db.query("SELECT * FROM foo").all());
-		 * ```
-		 *
-		 * @example
-		 *
-		 * Open read-only
-		 *
-		 * ```ts
-		 * const db = new Database("mydb.sqlite", {readonly: true});
-		 * ```
-		 */
-		constructor(
-			filename?: string,
-			options?:
-				| number
-				| {
-						/**
-						 * Open the database as read-only (no write operations, no create).
-						 *
-						 * Equivalent to {@link constants.SQLITE_OPEN_READONLY}
-						 */
-						readonly?: boolean;
-						/**
-						 * Allow creating a new database
-						 *
-						 * Equivalent to {@link constants.SQLITE_OPEN_CREATE}
-						 */
-						create?: boolean;
-						/**
-						 * Open the database as read-write
-						 *
-						 * Equivalent to {@link constants.SQLITE_OPEN_READWRITE}
-						 */
-						readwrite?: boolean;
+  export class Database implements Disposable {
+    /**
+     * Open or create a SQLite3 database
+     *
+     * @param filename The filename of the database to open. Pass an empty string (`""`) or `":memory:"` or undefined for an in-memory database.
+     * @param options defaults to `{readwrite: true, create: true}`. If a number, then it's treated as `SQLITE_OPEN_*` constant flags.
+     *
+     * @example
+     *
+     * ```ts
+     * const db = new Database("mydb.sqlite");
+     * db.run("CREATE TABLE foo (bar TEXT)");
+     * db.run("INSERT INTO foo VALUES (?)", ["baz"]);
+     * console.log(db.query("SELECT * FROM foo").all());
+     * ```
+     *
+     * @example
+     *
+     * Open an in-memory database
+     *
+     * ```ts
+     * const db = new Database(":memory:");
+     * db.run("CREATE TABLE foo (bar TEXT)");
+     * db.run("INSERT INTO foo VALUES (?)", ["hiiiiii"]);
+     * console.log(db.query("SELECT * FROM foo").all());
+     * ```
+     *
+     * @example
+     *
+     * Open read-only
+     *
+     * ```ts
+     * const db = new Database("mydb.sqlite", {readonly: true});
+     * ```
+     */
+    constructor(
+      filename?: string,
+      options?:
+        | number
+        | {
+            /**
+             * Open the database as read-only (no write operations, no create).
+             *
+             * Equivalent to {@link constants.SQLITE_OPEN_READONLY}
+             */
+            readonly?: boolean;
+            /**
+             * Allow creating a new database
+             *
+             * Equivalent to {@link constants.SQLITE_OPEN_CREATE}
+             */
+            create?: boolean;
+            /**
+             * Open the database as read-write
+             *
+             * Equivalent to {@link constants.SQLITE_OPEN_READWRITE}
+             */
+            readwrite?: boolean;
 
-						/**
-						 * When set to `true`, integers are returned as `bigint` types.
-						 *
-						 * When set to `false`, integers are returned as `number` types and truncated to 52 bits.
-						 *
-						 * @default false
-						 * @since v1.1.14
-						 */
-						safeIntegers?: boolean;
+            /**
+             * When set to `true`, integers are returned as `bigint` types.
+             *
+             * When set to `false`, integers are returned as `number` types and truncated to 52 bits.
+             *
+             * @default false
+             * @since v1.1.14
+             */
+            safeIntegers?: boolean;
 
-						/**
-						 * When set to `false` or `undefined`:
-						 * - Queries missing bound parameters will NOT throw an error
-						 * - Bound named parameters in JavaScript need to exactly match the SQL query.
-						 *
-						 * @example
-						 * ```ts
-						 * const db = new Database(":memory:", { strict: false });
-						 * db.run("INSERT INTO foo (name) VALUES ($name)", { $name: "foo" });
-						 * ```
-						 *
-						 * When set to `true`:
-						 * - Queries missing bound parameters will throw an error
-						 * - Bound named parameters in JavaScript no longer need to be `$`, `:`, or `@`. The SQL query will remain prefixed.
-						 *
-						 * @example
-						 * ```ts
-						 * const db = new Database(":memory:", { strict: true });
-						 * db.run("INSERT INTO foo (name) VALUES ($name)", { name: "foo" });
-						 * ```
-						 * @since v1.1.14
-						 */
-						strict?: boolean;
-				  },
-		);
+            /**
+             * When set to `false` or `undefined`:
+             * - Queries missing bound parameters will NOT throw an error
+             * - Bound named parameters in JavaScript need to exactly match the SQL query.
+             *
+             * @example
+             * ```ts
+             * const db = new Database(":memory:", { strict: false });
+             * db.run("INSERT INTO foo (name) VALUES ($name)", { $name: "foo" });
+             * ```
+             *
+             * When set to `true`:
+             * - Queries missing bound parameters will throw an error
+             * - Bound named parameters in JavaScript no longer need to be `$`, `:`, or `@`. The SQL query will remain prefixed.
+             *
+             * @example
+             * ```ts
+             * const db = new Database(":memory:", { strict: true });
+             * db.run("INSERT INTO foo (name) VALUES ($name)", { name: "foo" });
+             * ```
+             * @since v1.1.14
+             */
+            strict?: boolean;
+          },
+    );
 
-		/**
-		 * This is an alias of `new Database()`
-		 *
-		 * See {@link Database}
-		 */
-		static open(
-			filename: string,
-			options?:
-				| number
-				| {
-						/**
-						 * Open the database as read-only (no write operations, no create).
-						 *
-						 * Equivalent to {@link constants.SQLITE_OPEN_READONLY}
-						 */
-						readonly?: boolean;
-						/**
-						 * Allow creating a new database
-						 *
-						 * Equivalent to {@link constants.SQLITE_OPEN_CREATE}
-						 */
-						create?: boolean;
-						/**
-						 * Open the database as read-write
-						 *
-						 * Equivalent to {@link constants.SQLITE_OPEN_READWRITE}
-						 */
-						readwrite?: boolean;
-				  },
-		): Database;
+    /**
+     * This is an alias of `new Database()`
+     *
+     * See {@link Database}
+     */
+    static open(
+      filename: string,
+      options?:
+        | number
+        | {
+            /**
+             * Open the database as read-only (no write operations, no create).
+             *
+             * Equivalent to {@link constants.SQLITE_OPEN_READONLY}
+             */
+            readonly?: boolean;
+            /**
+             * Allow creating a new database
+             *
+             * Equivalent to {@link constants.SQLITE_OPEN_CREATE}
+             */
+            create?: boolean;
+            /**
+             * Open the database as read-write
+             *
+             * Equivalent to {@link constants.SQLITE_OPEN_READWRITE}
+             */
+            readwrite?: boolean;
+          },
+    ): Database;
 
-		/**
-		 * Execute a SQL query **without returning any results**.
-		 *
-		 * This does not cache the query, so if you want to run a query multiple times, you should use {@link prepare} instead.
-		 *
-		 * @example
-		 * ```ts
-		 * db.run("CREATE TABLE foo (bar TEXT)");
-		 * db.run("INSERT INTO foo VALUES (?)", ["baz"]);
-		 * ```
-		 *
-		 * Useful for queries like:
-		 * - `CREATE TABLE`
-		 * - `INSERT INTO`
-		 * - `UPDATE`
-		 * - `DELETE FROM`
-		 * - `DROP TABLE`
-		 * - `PRAGMA`
-		 * - `ATTACH DATABASE`
-		 * - `DETACH DATABASE`
-		 * - `REINDEX`
-		 * - `VACUUM`
-		 * - `EXPLAIN ANALYZE`
-		 * - `CREATE INDEX`
-		 * - `CREATE TRIGGER`
-		 * - `CREATE VIEW`
-		 * - `CREATE VIRTUAL TABLE`
-		 * - `CREATE TEMPORARY TABLE`
-		 *
-		 * @param sql The SQL query to run
-		 *
-		 * @param bindings Optional bindings for the query
-		 *
-		 * @returns `Database` instance
-		 *
-		 * Under the hood, this calls `sqlite3_prepare_v3` followed by `sqlite3_step` and `sqlite3_finalize`.
-		 *
-		 *  * The following types can be used when binding parameters:
-		 *
-		 * | JavaScript type | SQLite type |
-		 * | -------------- | ----------- |
-		 * | `string` | `TEXT` |
-		 * | `number` | `INTEGER` or `DECIMAL` |
-		 * | `boolean` | `INTEGER` (1 or 0) |
-		 * | `Uint8Array` | `BLOB` |
-		 * | `Buffer` | `BLOB` |
-		 * | `bigint` | `INTEGER` |
-		 * | `null` | `NULL` |
-		 */
-		run<ParamsType extends SQLQueryBindings[]>(
-			sqlQuery: string,
-			...bindings: ParamsType[]
-		): Changes;
-		/**
+    /**
+     * Execute a SQL query **without returning any results**.
+     *
+     * This does not cache the query, so if you want to run a query multiple times, you should use {@link prepare} instead.
+     *
+     * @example
+     * ```ts
+     * db.run("CREATE TABLE foo (bar TEXT)");
+     * db.run("INSERT INTO foo VALUES (?)", ["baz"]);
+     * ```
+     *
+     * Useful for queries like:
+     * - `CREATE TABLE`
+     * - `INSERT INTO`
+     * - `UPDATE`
+     * - `DELETE FROM`
+     * - `DROP TABLE`
+     * - `PRAGMA`
+     * - `ATTACH DATABASE`
+     * - `DETACH DATABASE`
+     * - `REINDEX`
+     * - `VACUUM`
+     * - `EXPLAIN ANALYZE`
+     * - `CREATE INDEX`
+     * - `CREATE TRIGGER`
+     * - `CREATE VIEW`
+     * - `CREATE VIRTUAL TABLE`
+     * - `CREATE TEMPORARY TABLE`
+     *
+     * @param sql The SQL query to run
+     *
+     * @param bindings Optional bindings for the query
+     *
+     * @returns `Database` instance
+     *
+     * Under the hood, this calls `sqlite3_prepare_v3` followed by `sqlite3_step` and `sqlite3_finalize`.
+     *
+     *  * The following types can be used when binding parameters:
+     *
+     * | JavaScript type | SQLite type |
+     * | -------------- | ----------- |
+     * | `string` | `TEXT` |
+     * | `number` | `INTEGER` or `DECIMAL` |
+     * | `boolean` | `INTEGER` (1 or 0) |
+     * | `Uint8Array` | `BLOB` |
+     * | `Buffer` | `BLOB` |
+     * | `bigint` | `INTEGER` |
+     * | `null` | `NULL` |
+     */
+    run<ParamsType extends SQLQueryBindings[]>(sqlQuery: string, ...bindings: ParamsType[]): Changes;
+    /**
         This is an alias of {@link Database.prototype.run}
      */
-		exec<ParamsType extends SQLQueryBindings[]>(
-			sqlQuery: string,
-			...bindings: ParamsType[]
-		): Changes;
+    exec<ParamsType extends SQLQueryBindings[]>(sqlQuery: string, ...bindings: ParamsType[]): Changes;
 
-		/**
-		 * Compile a SQL query and return a {@link Statement} object. This is the
-		 * same as {@link prepare} except that it caches the compiled query.
-		 *
-		 * This **does not execute** the query, but instead prepares it for later
-		 * execution and caches the compiled query if possible.
-		 *
-		 * @example
-		 * ```ts
-		 * // compile the query
-		 * const stmt = db.query("SELECT * FROM foo WHERE bar = ?");
-		 * // run the query
-		 * stmt.all("baz");
-		 *
-		 * // run the query again
-		 * stmt.all();
-		 * ```
-		 *
-		 * @param sql The SQL query to compile
-		 *
-		 * @returns `Statment` instance
-		 *
-		 * Under the hood, this calls `sqlite3_prepare_v3`.
-		 */
-		query<ReturnType, ParamsType extends SQLQueryBindings | SQLQueryBindings[]>(
-			sqlQuery: string,
-		): // eslint-disable-next-line @definitelytyped/no-single-element-tuple-type
-		Statement<ReturnType, ParamsType extends any[] ? ParamsType : [ParamsType]>;
+    /**
+     * Compile a SQL query and return a {@link Statement} object. This is the
+     * same as {@link prepare} except that it caches the compiled query.
+     *
+     * This **does not execute** the query, but instead prepares it for later
+     * execution and caches the compiled query if possible.
+     *
+     * @example
+     * ```ts
+     * // compile the query
+     * const stmt = db.query("SELECT * FROM foo WHERE bar = ?");
+     * // run the query
+     * stmt.all("baz");
+     *
+     * // run the query again
+     * stmt.all();
+     * ```
+     *
+     * @param sql The SQL query to compile
+     *
+     * @returns `Statment` instance
+     *
+     * Under the hood, this calls `sqlite3_prepare_v3`.
+     */
+    query<ReturnType, ParamsType extends SQLQueryBindings | SQLQueryBindings[]>(
+      sqlQuery: string,
+    ): // eslint-disable-next-line @definitelytyped/no-single-element-tuple-type
+    Statement<ReturnType, ParamsType extends any[] ? ParamsType : [ParamsType]>;
 
-		/**
-		 * Compile a SQL query and return a {@link Statement} object.
-		 *
-		 * This does not cache the compiled query and does not execute the query.
-		 *
-		 * @example
-		 * ```ts
-		 * // compile the query
-		 * const stmt = db.query("SELECT * FROM foo WHERE bar = ?");
-		 * // run the query
-		 * stmt.all("baz");
-		 * ```
-		 *
-		 * @param sql The SQL query to compile
-		 * @param params Optional bindings for the query
-		 *
-		 * @returns `Statment` instance
-		 *
-		 * Under the hood, this calls `sqlite3_prepare_v3`.
-		 */
-		prepare<
-			ReturnType,
-			ParamsType extends SQLQueryBindings | SQLQueryBindings[],
-		>(
-			sqlQuery: string,
-			params?: ParamsType,
-		): // eslint-disable-next-line @definitelytyped/no-single-element-tuple-type
-		Statement<ReturnType, ParamsType extends any[] ? ParamsType : [ParamsType]>;
+    /**
+     * Compile a SQL query and return a {@link Statement} object.
+     *
+     * This does not cache the compiled query and does not execute the query.
+     *
+     * @example
+     * ```ts
+     * // compile the query
+     * const stmt = db.query("SELECT * FROM foo WHERE bar = ?");
+     * // run the query
+     * stmt.all("baz");
+     * ```
+     *
+     * @param sql The SQL query to compile
+     * @param params Optional bindings for the query
+     *
+     * @returns `Statment` instance
+     *
+     * Under the hood, this calls `sqlite3_prepare_v3`.
+     */
+    prepare<ReturnType, ParamsType extends SQLQueryBindings | SQLQueryBindings[]>(
+      sqlQuery: string,
+      params?: ParamsType,
+    ): // eslint-disable-next-line @definitelytyped/no-single-element-tuple-type
+    Statement<ReturnType, ParamsType extends any[] ? ParamsType : [ParamsType]>;
 
-		/**
-		 * Is the database in a transaction?
-		 *
-		 * @returns `true` if the database is in a transaction, `false` otherwise
-		 *
-		 * @example
-		 * ```ts
-		 * db.run("CREATE TABLE foo (bar TEXT)");
-		 * db.run("INSERT INTO foo VALUES (?)", ["baz"]);
-		 * db.run("BEGIN");
-		 * db.run("INSERT INTO foo VALUES (?)", ["qux"]);
-		 * console.log(db.inTransaction());
-		 * ```
-		 */
-		get inTransaction(): boolean;
+    /**
+     * Is the database in a transaction?
+     *
+     * @returns `true` if the database is in a transaction, `false` otherwise
+     *
+     * @example
+     * ```ts
+     * db.run("CREATE TABLE foo (bar TEXT)");
+     * db.run("INSERT INTO foo VALUES (?)", ["baz"]);
+     * db.run("BEGIN");
+     * db.run("INSERT INTO foo VALUES (?)", ["qux"]);
+     * console.log(db.inTransaction());
+     * ```
+     */
+    get inTransaction(): boolean;
 
-		/**
-		 * Close the database connection.
-		 *
-		 * It is safe to call this method multiple times. If the database is already
-		 * closed, this is a no-op. Running queries after the database has been
-		 * closed will throw an error.
-		 *
-		 * @example
-		 * ```ts
-		 * db.close();
-		 * ```
-		 * This is called automatically when the database instance is garbage collected.
-		 *
-		 * Internally, this calls `sqlite3_close_v2`.
-		 */
-		close(
-			/**
-			 * If `true`, then the database will throw an error if it is in use
-			 * @default false
-			 *
-			 * When true, this calls `sqlite3_close` instead of `sqlite3_close_v2`.
-			 *
-			 * Learn more about this in the [sqlite3 documentation](https://www.sqlite.org/c3ref/close.html).
-			 *
-			 * Bun will automatically call close by default when the database instance is garbage collected.
-			 * In The future, Bun may default `throwOnError` to be true but for backwards compatibility, it is false by default.
-			 */
-			throwOnError?: boolean,
-		): void;
+    /**
+     * Close the database connection.
+     *
+     * It is safe to call this method multiple times. If the database is already
+     * closed, this is a no-op. Running queries after the database has been
+     * closed will throw an error.
+     *
+     * @example
+     * ```ts
+     * db.close();
+     * ```
+     * This is called automatically when the database instance is garbage collected.
+     *
+     * Internally, this calls `sqlite3_close_v2`.
+     */
+    close(
+      /**
+       * If `true`, then the database will throw an error if it is in use
+       * @default false
+       *
+       * When true, this calls `sqlite3_close` instead of `sqlite3_close_v2`.
+       *
+       * Learn more about this in the [sqlite3 documentation](https://www.sqlite.org/c3ref/close.html).
+       *
+       * Bun will automatically call close by default when the database instance is garbage collected.
+       * In The future, Bun may default `throwOnError` to be true but for backwards compatibility, it is false by default.
+       */
+      throwOnError?: boolean,
+    ): void;
 
-		/**
-		 * The filename passed when `new Database()` was called
-		 * @example
-		 * ```ts
-		 * const db = new Database("mydb.sqlite");
-		 * console.log(db.filename);
-		 * // => "mydb.sqlite"
-		 * ```
-		 */
-		readonly filename: string;
+    /**
+     * The filename passed when `new Database()` was called
+     * @example
+     * ```ts
+     * const db = new Database("mydb.sqlite");
+     * console.log(db.filename);
+     * // => "mydb.sqlite"
+     * ```
+     */
+    readonly filename: string;
 
-		/**
-		 * The underlying `sqlite3` database handle
-		 *
-		 * In native code, this is not a file descriptor, but an index into an array of database handles
-		 */
-		readonly handle: number;
+    /**
+     * The underlying `sqlite3` database handle
+     *
+     * In native code, this is not a file descriptor, but an index into an array of database handles
+     */
+    readonly handle: number;
 
-		/**
-		 * Load a SQLite3 extension
-		 *
-		 * macOS requires a custom SQLite3 library to be linked because the Apple build of SQLite for macOS disables loading extensions. See {@link Database.setCustomSQLite}
-		 *
-		 * Bun chooses the Apple build of SQLite on macOS because it brings a ~50% performance improvement.
-		 *
-		 * @param extension name/path of the extension to load
-		 * @param entryPoint optional entry point of the extension
-		 */
-		loadExtension(extension: string, entryPoint?: string): void;
+    /**
+     * Load a SQLite3 extension
+     *
+     * macOS requires a custom SQLite3 library to be linked because the Apple build of SQLite for macOS disables loading extensions. See {@link Database.setCustomSQLite}
+     *
+     * Bun chooses the Apple build of SQLite on macOS because it brings a ~50% performance improvement.
+     *
+     * @param extension name/path of the extension to load
+     * @param entryPoint optional entry point of the extension
+     */
+    loadExtension(extension: string, entryPoint?: string): void;
 
-		/**
-		 * Change the dynamic library path to SQLite
-		 *
-		 * @note macOS-only
-		 *
-		 * This only works before SQLite is loaded, so
-		 * that's before you call `new Database()`.
-		 *
-		 * It can only be run once because this will load
-		 * the SQLite library into the process.
-		 *
-		 * @param path The path to the SQLite library
-		 */
-		static setCustomSQLite(path: string): boolean;
+    /**
+     * Change the dynamic library path to SQLite
+     *
+     * @note macOS-only
+     *
+     * This only works before SQLite is loaded, so
+     * that's before you call `new Database()`.
+     *
+     * It can only be run once because this will load
+     * the SQLite library into the process.
+     *
+     * @param path The path to the SQLite library
+     */
+    static setCustomSQLite(path: string): boolean;
 
-		[Symbol.dispose](): void;
+    [Symbol.dispose](): void;
 
-		/**
-		 * Creates a function that always runs inside a transaction. When the
-		 * function is invoked, it will begin a new transaction. When the function
-		 * returns, the transaction will be committed. If an exception is thrown,
-		 * the transaction will be rolled back (and the exception will propagate as
-		 * usual).
-		 *
-		 * @param insideTransaction The callback which runs inside a transaction
-		 *
-		 * @example
-		 * ```ts
-		 * // setup
-		 * import { Database } from "bun:sqlite";
-		 * const db = Database.open(":memory:");
-		 * db.exec(
-		 *   "CREATE TABLE cats (id INTEGER PRIMARY KEY AUTOINCREMENT, name TEXT UNIQUE, age INTEGER)"
-		 * );
-		 *
-		 * const insert = db.prepare("INSERT INTO cats (name, age) VALUES ($name, $age)");
-		 * const insertMany = db.transaction((cats) => {
-		 *   for (const cat of cats) insert.run(cat);
-		 * });
-		 *
-		 * insertMany([
-		 *   { $name: "Joey", $age: 2 },
-		 *   { $name: "Sally", $age: 4 },
-		 *   { $name: "Junior", $age: 1 },
-		 * ]);
-		 * ```
-		 */
-		transaction(insideTransaction: (...args: any) => void): CallableFunction & {
-			/**
-			 * uses "BEGIN DEFERRED"
-			 */
-			deferred: (...args: any) => void;
-			/**
-			 * uses "BEGIN IMMEDIATE"
-			 */
-			immediate: (...args: any) => void;
-			/**
-			 * uses "BEGIN EXCLUSIVE"
-			 */
-			exclusive: (...args: any) => void;
-		};
+    /**
+     * Creates a function that always runs inside a transaction. When the
+     * function is invoked, it will begin a new transaction. When the function
+     * returns, the transaction will be committed. If an exception is thrown,
+     * the transaction will be rolled back (and the exception will propagate as
+     * usual).
+     *
+     * @param insideTransaction The callback which runs inside a transaction
+     *
+     * @example
+     * ```ts
+     * // setup
+     * import { Database } from "bun:sqlite";
+     * const db = Database.open(":memory:");
+     * db.exec(
+     *   "CREATE TABLE cats (id INTEGER PRIMARY KEY AUTOINCREMENT, name TEXT UNIQUE, age INTEGER)"
+     * );
+     *
+     * const insert = db.prepare("INSERT INTO cats (name, age) VALUES ($name, $age)");
+     * const insertMany = db.transaction((cats) => {
+     *   for (const cat of cats) insert.run(cat);
+     * });
+     *
+     * insertMany([
+     *   { $name: "Joey", $age: 2 },
+     *   { $name: "Sally", $age: 4 },
+     *   { $name: "Junior", $age: 1 },
+     * ]);
+     * ```
+     */
+    transaction(insideTransaction: (...args: any) => void): CallableFunction & {
+      /**
+       * uses "BEGIN DEFERRED"
+       */
+      deferred: (...args: any) => void;
+      /**
+       * uses "BEGIN IMMEDIATE"
+       */
+      immediate: (...args: any) => void;
+      /**
+       * uses "BEGIN EXCLUSIVE"
+       */
+      exclusive: (...args: any) => void;
+    };
 
-		/**
-		 * Save the database to an in-memory {@link Buffer} object.
-		 *
-		 * Internally, this calls `sqlite3_serialize`.
-		 *
-		 * @param name Name to save the database as @default "main"
-		 * @returns Buffer containing the serialized database
-		 */
-		serialize(name?: string): Buffer;
+    /**
+     * Save the database to an in-memory {@link Buffer} object.
+     *
+     * Internally, this calls `sqlite3_serialize`.
+     *
+     * @param name Name to save the database as @default "main"
+     * @returns Buffer containing the serialized database
+     */
+    serialize(name?: string): Buffer;
 
-		/**
-		 * Load a serialized SQLite3 database
-		 *
-		 * Internally, this calls `sqlite3_deserialize`.
-		 *
-		 * @param serialized Data to load
-		 * @returns `Database` instance
-		 *
-		 * @example
-		 * ```ts
-		 * test("supports serialize/deserialize", () => {
-		 *     const db = Database.open(":memory:");
-		 *     db.exec("CREATE TABLE test (id INTEGER PRIMARY KEY, name TEXT)");
-		 *     db.exec('INSERT INTO test (name) VALUES ("Hello")');
-		 *     db.exec('INSERT INTO test (name) VALUES ("World")');
-		 *
-		 *     const input = db.serialize();
-		 *     const db2 = new Database(input);
-		 *
-		 *     const stmt = db2.prepare("SELECT * FROM test");
-		 *     expect(JSON.stringify(stmt.get())).toBe(
-		 *       JSON.stringify({
-		 *         id: 1,
-		 *         name: "Hello",
-		 *       }),
-		 *     );
-		 *
-		 *     expect(JSON.stringify(stmt.all())).toBe(
-		 *       JSON.stringify([
-		 *         {
-		 *           id: 1,
-		 *           name: "Hello",
-		 *         },
-		 *         {
-		 *           id: 2,
-		 *           name: "World",
-		 *         },
-		 *       ]),
-		 *     );
-		 *     db2.exec("insert into test (name) values ('foo')");
-		 *     expect(JSON.stringify(stmt.all())).toBe(
-		 *       JSON.stringify([
-		 *         {
-		 *           id: 1,
-		 *           name: "Hello",
-		 *         },
-		 *         {
-		 *           id: 2,
-		 *           name: "World",
-		 *         },
-		 *         {
-		 *           id: 3,
-		 *           name: "foo",
-		 *         },
-		 *       ]),
-		 *     );
-		 *
-		 *     const db3 = Database.deserialize(input, true);
-		 *     try {
-		 *       db3.exec("insert into test (name) values ('foo')");
-		 *       throw new Error("Expected error");
-		 *     } catch (e) {
-		 *       expect(e.message).toBe("attempt to write a readonly database");
-		 *     }
-		 * });
-		 * ```
-		 */
-		static deserialize(
-			serialized: NodeJS.TypedArray | ArrayBufferLike,
-			isReadOnly?: boolean,
-		): Database;
+    /**
+     * Load a serialized SQLite3 database
+     *
+     * Internally, this calls `sqlite3_deserialize`.
+     *
+     * @param serialized Data to load
+     * @returns `Database` instance
+     *
+     * @example
+     * ```ts
+     * test("supports serialize/deserialize", () => {
+     *     const db = Database.open(":memory:");
+     *     db.exec("CREATE TABLE test (id INTEGER PRIMARY KEY, name TEXT)");
+     *     db.exec('INSERT INTO test (name) VALUES ("Hello")');
+     *     db.exec('INSERT INTO test (name) VALUES ("World")');
+     *
+     *     const input = db.serialize();
+     *     const db2 = new Database(input);
+     *
+     *     const stmt = db2.prepare("SELECT * FROM test");
+     *     expect(JSON.stringify(stmt.get())).toBe(
+     *       JSON.stringify({
+     *         id: 1,
+     *         name: "Hello",
+     *       }),
+     *     );
+     *
+     *     expect(JSON.stringify(stmt.all())).toBe(
+     *       JSON.stringify([
+     *         {
+     *           id: 1,
+     *           name: "Hello",
+     *         },
+     *         {
+     *           id: 2,
+     *           name: "World",
+     *         },
+     *       ]),
+     *     );
+     *     db2.exec("insert into test (name) values ('foo')");
+     *     expect(JSON.stringify(stmt.all())).toBe(
+     *       JSON.stringify([
+     *         {
+     *           id: 1,
+     *           name: "Hello",
+     *         },
+     *         {
+     *           id: 2,
+     *           name: "World",
+     *         },
+     *         {
+     *           id: 3,
+     *           name: "foo",
+     *         },
+     *       ]),
+     *     );
+     *
+     *     const db3 = Database.deserialize(input, true);
+     *     try {
+     *       db3.exec("insert into test (name) values ('foo')");
+     *       throw new Error("Expected error");
+     *     } catch (e) {
+     *       expect(e.message).toBe("attempt to write a readonly database");
+     *     }
+     * });
+     * ```
+     */
+    static deserialize(serialized: NodeJS.TypedArray | ArrayBufferLike, isReadOnly?: boolean): Database;
 
-		/**
-		 * Load a serialized SQLite3 database. This version enables you to specify
-		 * additional options such as `strict` to put the database into strict mode.
-		 *
-		 * Internally, this calls `sqlite3_deserialize`.
-		 *
-		 * @param serialized Data to load
-		 * @returns `Database` instance
-		 *
-		 * @example
-		 * ```ts
-		 * test("supports serialize/deserialize", () => {
-		 *     const db = Database.open(":memory:");
-		 *     db.exec("CREATE TABLE test (id INTEGER PRIMARY KEY, name TEXT)");
-		 *     db.exec('INSERT INTO test (name) VALUES ("Hello")');
-		 *     db.exec('INSERT INTO test (name) VALUES ("World")');
-		 *
-		 *     const input = db.serialize();
-		 *     const db2 = Database.deserialize(input, { strict: true });
-		 *
-		 *     const stmt = db2.prepare("SELECT * FROM test");
-		 *     expect(JSON.stringify(stmt.get())).toBe(
-		 *       JSON.stringify({
-		 *         id: 1,
-		 *         name: "Hello",
-		 *       }),
-		 *     );
-		 *
-		 *     expect(JSON.stringify(stmt.all())).toBe(
-		 *       JSON.stringify([
-		 *         {
-		 *           id: 1,
-		 *           name: "Hello",
-		 *         },
-		 *         {
-		 *           id: 2,
-		 *           name: "World",
-		 *         },
-		 *       ]),
-		 *     );
-		 *     db2.exec("insert into test (name) values ($foo)", { foo: "baz" });
-		 *     expect(JSON.stringify(stmt.all())).toBe(
-		 *       JSON.stringify([
-		 *         {
-		 *           id: 1,
-		 *           name: "Hello",
-		 *         },
-		 *         {
-		 *           id: 2,
-		 *           name: "World",
-		 *         },
-		 *         {
-		 *           id: 3,
-		 *           name: "baz",
-		 *         },
-		 *       ]),
-		 *     );
-		 *
-		 *     const db3 = Database.deserialize(input, { readonly: true, strict: true });
-		 *     try {
-		 *       db3.exec("insert into test (name) values ($foo)", { foo: "baz" });
-		 *       throw new Error("Expected error");
-		 *     } catch (e) {
-		 *       expect(e.message).toBe("attempt to write a readonly database");
-		 *     }
-		 * });
-		 * ```
-		 */
-		static deserialize(
-			serialized: NodeJS.TypedArray | ArrayBufferLike,
-			options?: {
-				readonly?: boolean;
-				strict?: boolean;
-				safeIntegers?: boolean;
-			},
-		): Database;
+    /**
+     * Load a serialized SQLite3 database. This version enables you to specify
+     * additional options such as `strict` to put the database into strict mode.
+     *
+     * Internally, this calls `sqlite3_deserialize`.
+     *
+     * @param serialized Data to load
+     * @returns `Database` instance
+     *
+     * @example
+     * ```ts
+     * test("supports serialize/deserialize", () => {
+     *     const db = Database.open(":memory:");
+     *     db.exec("CREATE TABLE test (id INTEGER PRIMARY KEY, name TEXT)");
+     *     db.exec('INSERT INTO test (name) VALUES ("Hello")');
+     *     db.exec('INSERT INTO test (name) VALUES ("World")');
+     *
+     *     const input = db.serialize();
+     *     const db2 = Database.deserialize(input, { strict: true });
+     *
+     *     const stmt = db2.prepare("SELECT * FROM test");
+     *     expect(JSON.stringify(stmt.get())).toBe(
+     *       JSON.stringify({
+     *         id: 1,
+     *         name: "Hello",
+     *       }),
+     *     );
+     *
+     *     expect(JSON.stringify(stmt.all())).toBe(
+     *       JSON.stringify([
+     *         {
+     *           id: 1,
+     *           name: "Hello",
+     *         },
+     *         {
+     *           id: 2,
+     *           name: "World",
+     *         },
+     *       ]),
+     *     );
+     *     db2.exec("insert into test (name) values ($foo)", { foo: "baz" });
+     *     expect(JSON.stringify(stmt.all())).toBe(
+     *       JSON.stringify([
+     *         {
+     *           id: 1,
+     *           name: "Hello",
+     *         },
+     *         {
+     *           id: 2,
+     *           name: "World",
+     *         },
+     *         {
+     *           id: 3,
+     *           name: "baz",
+     *         },
+     *       ]),
+     *     );
+     *
+     *     const db3 = Database.deserialize(input, { readonly: true, strict: true });
+     *     try {
+     *       db3.exec("insert into test (name) values ($foo)", { foo: "baz" });
+     *       throw new Error("Expected error");
+     *     } catch (e) {
+     *       expect(e.message).toBe("attempt to write a readonly database");
+     *     }
+     * });
+     * ```
+     */
+    static deserialize(
+      serialized: NodeJS.TypedArray | ArrayBufferLike,
+      options?: { readonly?: boolean; strict?: boolean; safeIntegers?: boolean },
+    ): Database;
 
-		/**
-		 * See `sqlite3_file_control` for more information.
-		 * @link https://www.sqlite.org/c3ref/file_control.html
-		 */
-		fileControl(op: number, arg?: ArrayBufferView | number): number;
-		/**
-		 * See `sqlite3_file_control` for more information.
-		 * @link https://www.sqlite.org/c3ref/file_control.html
-		 */
-		fileControl(
-			zDbName: string,
-			op: number,
-			arg?: ArrayBufferView | number,
-		): number;
-	}
+    /**
+     * See `sqlite3_file_control` for more information.
+     * @link https://www.sqlite.org/c3ref/file_control.html
+     */
+    fileControl(op: number, arg?: ArrayBufferView | number): number;
+    /**
+     * See `sqlite3_file_control` for more information.
+     * @link https://www.sqlite.org/c3ref/file_control.html
+     */
+    fileControl(zDbName: string, op: number, arg?: ArrayBufferView | number): number;
+  }
 
-	/**
-	 * A prepared statement.
-	 *
-	 * This is returned by {@link Database.prepare} and {@link Database.query}.
-	 *
-	 * @example
-	 * ```ts
-	 * const stmt = db.prepare("SELECT * FROM foo WHERE bar = ?");
-	 * stmt.all("baz");
-	 * // => [{bar: "baz"}]
-	 * ```
-	 *
-	 * @example
-	 * ```ts
-	 * const stmt = db.prepare("SELECT * FROM foo WHERE bar = ?");
-	 * stmt.get("baz");
-	 * // => {bar: "baz"}
-	 * ```
-	 *
-	 * @example
-	 * ```ts
-	 * const stmt = db.prepare("SELECT * FROM foo WHERE bar = ?");
-	 * stmt.run("baz");
-	 * // => undefined
-	 * ```
-	 */
-	export class Statement<
-		ReturnType = unknown,
-		ParamsType extends SQLQueryBindings[] = any[],
-	> implements Disposable
-	{
-		/**
-		 * Creates a new prepared statement from native code.
-		 *
-		 * This is used internally by the {@link Database} class. Probably you don't need to call this yourself.
-		 */
-		constructor(nativeHandle: any);
+  /**
+   * A prepared statement.
+   *
+   * This is returned by {@link Database.prepare} and {@link Database.query}.
+   *
+   * @example
+   * ```ts
+   * const stmt = db.prepare("SELECT * FROM foo WHERE bar = ?");
+   * stmt.all("baz");
+   * // => [{bar: "baz"}]
+   * ```
+   *
+   * @example
+   * ```ts
+   * const stmt = db.prepare("SELECT * FROM foo WHERE bar = ?");
+   * stmt.get("baz");
+   * // => {bar: "baz"}
+   * ```
+   *
+   * @example
+   * ```ts
+   * const stmt = db.prepare("SELECT * FROM foo WHERE bar = ?");
+   * stmt.run("baz");
+   * // => undefined
+   * ```
+   */
+  export class Statement<ReturnType = unknown, ParamsType extends SQLQueryBindings[] = any[]> implements Disposable {
+    /**
+     * Creates a new prepared statement from native code.
+     *
+     * This is used internally by the {@link Database} class. Probably you don't need to call this yourself.
+     */
+    constructor(nativeHandle: any);
 
-		/**
-		 * Execute the prepared statement and return all results as objects.
-		 *
-		 * @param params optional values to bind to the statement. If omitted, the statement is run with the last bound values or no parameters if there are none.
-		 *
-		 * @example
-		 * ```ts
-		 * const stmt = db.prepare("SELECT * FROM foo WHERE bar = ?");
-		 *
-		 * stmt.all("baz");
-		 * // => [{bar: "baz"}]
-		 *
-		 * stmt.all();
-		 * // => []
-		 *
-		 * stmt.all("foo");
-		 * // => [{bar: "foo"}]
-		 * ```
-		 */
-		all(...params: ParamsType): ReturnType[];
+    /**
+     * Execute the prepared statement and return all results as objects.
+     *
+     * @param params optional values to bind to the statement. If omitted, the statement is run with the last bound values or no parameters if there are none.
+     *
+     * @example
+     * ```ts
+     * const stmt = db.prepare("SELECT * FROM foo WHERE bar = ?");
+     *
+     * stmt.all("baz");
+     * // => [{bar: "baz"}]
+     *
+     * stmt.all();
+     * // => []
+     *
+     * stmt.all("foo");
+     * // => [{bar: "foo"}]
+     * ```
+     */
+    all(...params: ParamsType): ReturnType[];
 
-		/**
-		 * Execute the prepared statement and return **the first** result.
-		 *
-		 * If no result is returned, this returns `null`.
-		 *
-		 * @param params optional values to bind to the statement. If omitted, the statement is run with the last bound values or no parameters if there are none.
-		 *
-		 * @example
-		 * ```ts
-		 * const stmt = db.prepare("SELECT * FROM foo WHERE bar = ?");
-		 *
-		 * stmt.get("baz");
-		 * // => {bar: "baz"}
-		 *
-		 * stmt.get();
-		 * // => null
-		 *
-		 * stmt.get("foo");
-		 * // => {bar: "foo"}
-		 * ```
-		 *
-		 * The following types can be used when binding parameters:
-		 *
-		 * | JavaScript type | SQLite type |
-		 * | -------------- | ----------- |
-		 * | `string` | `TEXT` |
-		 * | `number` | `INTEGER` or `DECIMAL` |
-		 * | `boolean` | `INTEGER` (1 or 0) |
-		 * | `Uint8Array` | `BLOB` |
-		 * | `Buffer` | `BLOB` |
-		 * | `bigint` | `INTEGER` |
-		 * | `null` | `NULL` |
-		 */
-		get(...params: ParamsType): ReturnType | null;
+    /**
+     * Execute the prepared statement and return **the first** result.
+     *
+     * If no result is returned, this returns `null`.
+     *
+     * @param params optional values to bind to the statement. If omitted, the statement is run with the last bound values or no parameters if there are none.
+     *
+     * @example
+     * ```ts
+     * const stmt = db.prepare("SELECT * FROM foo WHERE bar = ?");
+     *
+     * stmt.get("baz");
+     * // => {bar: "baz"}
+     *
+     * stmt.get();
+     * // => null
+     *
+     * stmt.get("foo");
+     * // => {bar: "foo"}
+     * ```
+     *
+     * The following types can be used when binding parameters:
+     *
+     * | JavaScript type | SQLite type |
+     * | -------------- | ----------- |
+     * | `string` | `TEXT` |
+     * | `number` | `INTEGER` or `DECIMAL` |
+     * | `boolean` | `INTEGER` (1 or 0) |
+     * | `Uint8Array` | `BLOB` |
+     * | `Buffer` | `BLOB` |
+     * | `bigint` | `INTEGER` |
+     * | `null` | `NULL` |
+     */
+    get(...params: ParamsType): ReturnType | null;
 
-		/**
-		 * Execute the prepared statement and return an
-		 *
-		 * @param params optional values to bind to the statement. If omitted, the statement is run with the last bound values or no parameters if there are none.
-		 *
-		 */
-		iterate(...params: ParamsType): IterableIterator<ReturnType>;
-		[Symbol.iterator](): IterableIterator<ReturnType>;
+    /**
+     * Execute the prepared statement and return an
+     *
+     * @param params optional values to bind to the statement. If omitted, the statement is run with the last bound values or no parameters if there are none.
+     *
+     */
+    iterate(...params: ParamsType): IterableIterator<ReturnType>;
+    [Symbol.iterator](): IterableIterator<ReturnType>;
 
-		/**
-		 * Execute the prepared statement. This returns `undefined`.
-		 *
-		 * @param params optional values to bind to the statement. If omitted, the statement is run with the last bound values or no parameters if there are none.
-		 *
-		 * @example
-		 * ```ts
-		 * const stmt = db.prepare("UPDATE foo SET bar = ?");
-		 * stmt.run("baz");
-		 * // => undefined
-		 *
-		 * stmt.run();
-		 * // => undefined
-		 *
-		 * stmt.run("foo");
-		 * // => undefined
-		 * ```
-		 *
-		 * The following types can be used when binding parameters:
-		 *
-		 * | JavaScript type | SQLite type |
-		 * | -------------- | ----------- |
-		 * | `string` | `TEXT` |
-		 * | `number` | `INTEGER` or `DECIMAL` |
-		 * | `boolean` | `INTEGER` (1 or 0) |
-		 * | `Uint8Array` | `BLOB` |
-		 * | `Buffer` | `BLOB` |
-		 * | `bigint` | `INTEGER` |
-		 * | `null` | `NULL` |
-		 */
-		run(...params: ParamsType): Changes;
+    /**
+     * Execute the prepared statement. This returns `undefined`.
+     *
+     * @param params optional values to bind to the statement. If omitted, the statement is run with the last bound values or no parameters if there are none.
+     *
+     * @example
+     * ```ts
+     * const stmt = db.prepare("UPDATE foo SET bar = ?");
+     * stmt.run("baz");
+     * // => undefined
+     *
+     * stmt.run();
+     * // => undefined
+     *
+     * stmt.run("foo");
+     * // => undefined
+     * ```
+     *
+     * The following types can be used when binding parameters:
+     *
+     * | JavaScript type | SQLite type |
+     * | -------------- | ----------- |
+     * | `string` | `TEXT` |
+     * | `number` | `INTEGER` or `DECIMAL` |
+     * | `boolean` | `INTEGER` (1 or 0) |
+     * | `Uint8Array` | `BLOB` |
+     * | `Buffer` | `BLOB` |
+     * | `bigint` | `INTEGER` |
+     * | `null` | `NULL` |
+     */
+    run(...params: ParamsType): Changes;
 
-		/**
-		 * Execute the prepared statement and return the results as an array of arrays.
-		 *
-		 * In Bun v0.6.7 and earlier, this method returned `null` if there were no
-		 * results instead of `[]`. This was changed in v0.6.8 to align
-		 * more with what people expect.
-		 *
-		 * @param params optional values to bind to the statement. If omitted, the statement is run with the last bound values or no parameters if there are none.
-		 *
-		 * @example
-		 * ```ts
-		 * const stmt = db.prepare("SELECT * FROM foo WHERE bar = ?");
-		 *
-		 * stmt.values("baz");
-		 * // => [['baz']]
-		 *
-		 * stmt.values();
-		 * // => [['baz']]
-		 *
-		 * stmt.values("foo");
-		 * // => [['foo']]
-		 *
-		 * stmt.values("not-found");
-		 * // => []
-		 * ```
-		 *
-		 * The following types can be used when binding parameters:
-		 *
-		 * | JavaScript type | SQLite type |
-		 * | ---------------|-------------|
-		 * | `string` | `TEXT` |
-		 * | `number` | `INTEGER` or `DECIMAL` |
-		 * | `boolean` | `INTEGER` (1 or 0) |
-		 * | `Uint8Array` | `BLOB` |
-		 * | `Buffer` | `BLOB` |
-		 * | `bigint` | `INTEGER` |
-		 * | `null` | `NULL` |
-		 */
-		values(
-			...params: ParamsType
-		): Array<Array<string | bigint | number | boolean | Uint8Array>>;
+    /**
+     * Execute the prepared statement and return the results as an array of arrays.
+     *
+     * In Bun v0.6.7 and earlier, this method returned `null` if there were no
+     * results instead of `[]`. This was changed in v0.6.8 to align
+     * more with what people expect.
+     *
+     * @param params optional values to bind to the statement. If omitted, the statement is run with the last bound values or no parameters if there are none.
+     *
+     * @example
+     * ```ts
+     * const stmt = db.prepare("SELECT * FROM foo WHERE bar = ?");
+     *
+     * stmt.values("baz");
+     * // => [['baz']]
+     *
+     * stmt.values();
+     * // => [['baz']]
+     *
+     * stmt.values("foo");
+     * // => [['foo']]
+     *
+     * stmt.values("not-found");
+     * // => []
+     * ```
+     *
+     * The following types can be used when binding parameters:
+     *
+     * | JavaScript type | SQLite type |
+     * | ---------------|-------------|
+     * | `string` | `TEXT` |
+     * | `number` | `INTEGER` or `DECIMAL` |
+     * | `boolean` | `INTEGER` (1 or 0) |
+     * | `Uint8Array` | `BLOB` |
+     * | `Buffer` | `BLOB` |
+     * | `bigint` | `INTEGER` |
+     * | `null` | `NULL` |
+     */
+    values(...params: ParamsType): Array<Array<string | bigint | number | boolean | Uint8Array>>;
 
-		/**
-		 * The names of the columns returned by the prepared statement.
-		 * @example
-		 * ```ts
-		 * const stmt = db.prepare("SELECT bar FROM foo WHERE bar = ?");
-		 *
-		 * console.log(stmt.columnNames);
-		 * // => ["bar"]
-		 * ```
-		 */
-		readonly columnNames: string[];
+    /**
+     * The names of the columns returned by the prepared statement.
+     * @example
+     * ```ts
+     * const stmt = db.prepare("SELECT bar FROM foo WHERE bar = ?");
+     *
+     * console.log(stmt.columnNames);
+     * // => ["bar"]
+     * ```
+     */
+    readonly columnNames: string[];
 
-		/**
-		 * The number of parameters expected in the prepared statement.
-		 * @example
-		 * ```ts
-		 * const stmt = db.prepare("SELECT * FROM foo WHERE bar = ?");
-		 * console.log(stmt.paramsCount);
-		 * // => 1
-		 * ```
-		 * @example
-		 * ```ts
-		 * const stmt = db.prepare("SELECT * FROM foo WHERE bar = ? AND baz = ?");
-		 * console.log(stmt.paramsCount);
-		 * // => 2
-		 * ```
-		 */
-		readonly paramsCount: number;
+    /**
+     * The number of parameters expected in the prepared statement.
+     * @example
+     * ```ts
+     * const stmt = db.prepare("SELECT * FROM foo WHERE bar = ?");
+     * console.log(stmt.paramsCount);
+     * // => 1
+     * ```
+     * @example
+     * ```ts
+     * const stmt = db.prepare("SELECT * FROM foo WHERE bar = ? AND baz = ?");
+     * console.log(stmt.paramsCount);
+     * // => 2
+     * ```
+     */
+    readonly paramsCount: number;
 
-		/**
-		 * Finalize the prepared statement, freeing the resources used by the
-		 * statement and preventing it from being executed again.
-		 *
-		 * This is called automatically when the prepared statement is garbage collected.
-		 *
-		 * It is safe to call this multiple times. Calling this on a finalized
-		 * statement has no effect.
-		 *
-		 * Internally, this calls `sqlite3_finalize`.
-		 */
-		finalize(): void;
+    /**
+     * Finalize the prepared statement, freeing the resources used by the
+     * statement and preventing it from being executed again.
+     *
+     * This is called automatically when the prepared statement is garbage collected.
+     *
+     * It is safe to call this multiple times. Calling this on a finalized
+     * statement has no effect.
+     *
+     * Internally, this calls `sqlite3_finalize`.
+     */
+    finalize(): void;
 
-		/**
-		 * Calls {@link finalize} if it wasn't already called.
-		 */
-		[Symbol.dispose](): void;
+    /**
+     * Calls {@link finalize} if it wasn't already called.
+     */
+    [Symbol.dispose](): void;
 
-		/**
-		 * Return the expanded SQL string for the prepared statement.
-		 *
-		 * Internally, this calls `sqlite3_expanded_sql()` on the underlying `sqlite3_stmt`.
-		 *
-		 * @example
-		 * ```ts
-		 * const stmt = db.prepare("SELECT * FROM foo WHERE bar = ?", "baz");
-		 * console.log(stmt.toString());
-		 * // => "SELECT * FROM foo WHERE bar = 'baz'"
-		 * console.log(stmt);
-		 * // => "SELECT * FROM foo WHERE bar = 'baz'"
-		 * ```
-		 */
-		toString(): string;
+    /**
+     * Return the expanded SQL string for the prepared statement.
+     *
+     * Internally, this calls `sqlite3_expanded_sql()` on the underlying `sqlite3_stmt`.
+     *
+     * @example
+     * ```ts
+     * const stmt = db.prepare("SELECT * FROM foo WHERE bar = ?", "baz");
+     * console.log(stmt.toString());
+     * // => "SELECT * FROM foo WHERE bar = 'baz'"
+     * console.log(stmt);
+     * // => "SELECT * FROM foo WHERE bar = 'baz'"
+     * ```
+     */
+    toString(): string;
 
-		/**
-		 *
-		 * Make {@link get} and {@link all} return an instance of the provided
-		 * `Class` instead of the default `Object`.
-		 *
-		 * @param Class A class to use
-		 * @returns The same statement instance, modified to return an instance of `Class`
-		 *
-		 * This lets you attach methods, getters, and setters to the returned
-		 * objects.
-		 *
-		 * For performance reasons, constructors for classes are not called, which means
-		 * initializers will not be called and private fields will not be
-		 * accessible.
-		 *
-		 * @example
-		 *
-		 * ## Custom class
-		 * ```ts
-		 * class User {
-		 *    rawBirthdate: string;
-		 *    get birthdate() {
-		 *      return new Date(this.rawBirthdate);
-		 *    }
-		 * }
-		 *
-		 * const db = new Database(":memory:");
-		 * db.exec("CREATE TABLE users (id INTEGER PRIMARY KEY, rawBirthdate TEXT)");
-		 * db.run("INSERT INTO users (rawBirthdate) VALUES ('1995-12-19')");
-		 * const query = db.query("SELECT * FROM users");
-		 * query.as(User);
-		 * const user = query.get();
-		 * console.log(user.birthdate);
-		 * // => Date(1995, 12, 19)
-		 * ```
-		 */
-		as<T = unknown>(Class: new (...args: any[]) => T): Statement<T, ParamsType>;
+    /**
+     *
+     * Make {@link get} and {@link all} return an instance of the provided
+     * `Class` instead of the default `Object`.
+     *
+     * @param Class A class to use
+     * @returns The same statement instance, modified to return an instance of `Class`
+     *
+     * This lets you attach methods, getters, and setters to the returned
+     * objects.
+     *
+     * For performance reasons, constructors for classes are not called, which means
+     * initializers will not be called and private fields will not be
+     * accessible.
+     *
+     * @example
+     *
+     * ## Custom class
+     * ```ts
+     * class User {
+     *    rawBirthdate: string;
+     *    get birthdate() {
+     *      return new Date(this.rawBirthdate);
+     *    }
+     * }
+     *
+     * const db = new Database(":memory:");
+     * db.exec("CREATE TABLE users (id INTEGER PRIMARY KEY, rawBirthdate TEXT)");
+     * db.run("INSERT INTO users (rawBirthdate) VALUES ('1995-12-19')");
+     * const query = db.query("SELECT * FROM users");
+     * query.as(User);
+     * const user = query.get();
+     * console.log(user.birthdate);
+     * // => Date(1995, 12, 19)
+     * ```
+     */
+    as<T = unknown>(Class: new (...args: any[]) => T): Statement<T, ParamsType>;
 
-		/**
-		 * Native object representing the underlying `sqlite3_stmt`
-		 *
-		 * This is left untyped because the ABI of the native bindings may change at any time.
-		 */
-		readonly native: any;
-	}
+    /**
+     * Native object representing the underlying `sqlite3_stmt`
+     *
+     * This is left untyped because the ABI of the native bindings may change at any time.
+     */
+    readonly native: any;
+  }
 
-	/**
-	 * Constants from `sqlite3.h`
-	 *
-	 * This list isn't exhaustive, but some of the ones which are relevant
-	 */
-	export const constants: {
-		/**
-		 * Open the database as read-only (no write operations, no create).
-		 * @constant 0x00000001
-		 */
-		SQLITE_OPEN_READONLY: number;
-		/**
-		 * Open the database for reading and writing
-		 * @constant 0x00000002
-		 */
-		SQLITE_OPEN_READWRITE: number;
-		/**
-		 * Allow creating a new database
-		 * @constant 0x00000004
-		 */
-		SQLITE_OPEN_CREATE: number;
-		/**
-		 * @constant 0x00000008
-		 */
-		SQLITE_OPEN_DELETEONCLOSE: number;
-		/**
-		 * @constant 0x00000010
-		 */
-		SQLITE_OPEN_EXCLUSIVE: number;
-		/**
-		 * @constant 0x00000020
-		 */
-		SQLITE_OPEN_AUTOPROXY: number;
-		/**
-		 * @constant 0x00000040
-		 */
-		SQLITE_OPEN_URI: number;
-		/**
-		 * @constant 0x00000080
-		 */
-		SQLITE_OPEN_MEMORY: number;
-		/**
-		 * @constant 0x00000100
-		 */
-		SQLITE_OPEN_MAIN_DB: number;
-		/**
-		 * @constant 0x00000200
-		 */
-		SQLITE_OPEN_TEMP_DB: number;
-		/**
-		 * @constant 0x00000400
-		 */
-		SQLITE_OPEN_TRANSIENT_DB: number;
-		/**
-		 * @constant 0x00000800
-		 */
-		SQLITE_OPEN_MAIN_JOURNAL: number;
-		/**
-		 * @constant 0x00001000
-		 */
-		SQLITE_OPEN_TEMP_JOURNAL: number;
-		/**
-		 * @constant 0x00002000
-		 */
-		SQLITE_OPEN_SUBJOURNAL: number;
-		/**
-		 * @constant 0x00004000
-		 */
-		SQLITE_OPEN_SUPER_JOURNAL: number;
-		/**
-		 * @constant 0x00008000
-		 */
-		SQLITE_OPEN_NOMUTEX: number;
-		/**
-		 * @constant 0x00010000
-		 */
-		SQLITE_OPEN_FULLMUTEX: number;
-		/**
-		 * @constant 0x00020000
-		 */
-		SQLITE_OPEN_SHAREDCACHE: number;
-		/**
-		 * @constant 0x00040000
-		 */
-		SQLITE_OPEN_PRIVATECACHE: number;
-		/**
-		 * @constant 0x00080000
-		 */
-		SQLITE_OPEN_WAL: number;
-		/**
-		 * @constant 0x01000000
-		 */
-		SQLITE_OPEN_NOFOLLOW: number;
-		/**
-		 * @constant 0x02000000
-		 */
-		SQLITE_OPEN_EXRESCODE: number;
-		/**
-		 * @constant 0x01
-		 */
-		SQLITE_PREPARE_PERSISTENT: number;
-		/**
-		 * @constant 0x02
-		 */
-		SQLITE_PREPARE_NORMALIZE: number;
-		/**
-		 * @constant 0x04
-		 */
-		SQLITE_PREPARE_NO_VTAB: number;
+  /**
+   * Constants from `sqlite3.h`
+   *
+   * This list isn't exhaustive, but some of the ones which are relevant
+   */
+  export const constants: {
+    /**
+     * Open the database as read-only (no write operations, no create).
+     * @constant 0x00000001
+     */
+    SQLITE_OPEN_READONLY: number;
+    /**
+     * Open the database for reading and writing
+     * @constant 0x00000002
+     */
+    SQLITE_OPEN_READWRITE: number;
+    /**
+     * Allow creating a new database
+     * @constant 0x00000004
+     */
+    SQLITE_OPEN_CREATE: number;
+    /**
+     * @constant 0x00000008
+     */
+    SQLITE_OPEN_DELETEONCLOSE: number;
+    /**
+     * @constant 0x00000010
+     */
+    SQLITE_OPEN_EXCLUSIVE: number;
+    /**
+     * @constant 0x00000020
+     */
+    SQLITE_OPEN_AUTOPROXY: number;
+    /**
+     * @constant 0x00000040
+     */
+    SQLITE_OPEN_URI: number;
+    /**
+     * @constant 0x00000080
+     */
+    SQLITE_OPEN_MEMORY: number;
+    /**
+     * @constant 0x00000100
+     */
+    SQLITE_OPEN_MAIN_DB: number;
+    /**
+     * @constant 0x00000200
+     */
+    SQLITE_OPEN_TEMP_DB: number;
+    /**
+     * @constant 0x00000400
+     */
+    SQLITE_OPEN_TRANSIENT_DB: number;
+    /**
+     * @constant 0x00000800
+     */
+    SQLITE_OPEN_MAIN_JOURNAL: number;
+    /**
+     * @constant 0x00001000
+     */
+    SQLITE_OPEN_TEMP_JOURNAL: number;
+    /**
+     * @constant 0x00002000
+     */
+    SQLITE_OPEN_SUBJOURNAL: number;
+    /**
+     * @constant 0x00004000
+     */
+    SQLITE_OPEN_SUPER_JOURNAL: number;
+    /**
+     * @constant 0x00008000
+     */
+    SQLITE_OPEN_NOMUTEX: number;
+    /**
+     * @constant 0x00010000
+     */
+    SQLITE_OPEN_FULLMUTEX: number;
+    /**
+     * @constant 0x00020000
+     */
+    SQLITE_OPEN_SHAREDCACHE: number;
+    /**
+     * @constant 0x00040000
+     */
+    SQLITE_OPEN_PRIVATECACHE: number;
+    /**
+     * @constant 0x00080000
+     */
+    SQLITE_OPEN_WAL: number;
+    /**
+     * @constant 0x01000000
+     */
+    SQLITE_OPEN_NOFOLLOW: number;
+    /**
+     * @constant 0x02000000
+     */
+    SQLITE_OPEN_EXRESCODE: number;
+    /**
+     * @constant 0x01
+     */
+    SQLITE_PREPARE_PERSISTENT: number;
+    /**
+     * @constant 0x02
+     */
+    SQLITE_PREPARE_NORMALIZE: number;
+    /**
+     * @constant 0x04
+     */
+    SQLITE_PREPARE_NO_VTAB: number;
 
-		/**
-		 * @constant 1
-		 */
-		SQLITE_FCNTL_LOCKSTATE: number;
-		/**
-		 * @constant 2
-		 */
-		SQLITE_FCNTL_GET_LOCKPROXYFILE: number;
-		/**
-		 * @constant 3
-		 */
-		SQLITE_FCNTL_SET_LOCKPROXYFILE: number;
-		/**
-		 * @constant 4
-		 */
-		SQLITE_FCNTL_LAST_ERRNO: number;
-		/**
-		 * @constant 5
-		 */
-		SQLITE_FCNTL_SIZE_HINT: number;
-		/**
-		 * @constant 6
-		 */
-		SQLITE_FCNTL_CHUNK_SIZE: number;
-		/**
-		 * @constant 7
-		 */
-		SQLITE_FCNTL_FILE_POINTER: number;
-		/**
-		 * @constant 8
-		 */
-		SQLITE_FCNTL_SYNC_OMITTED: number;
-		/**
-		 * @constant 9
-		 */
-		SQLITE_FCNTL_WIN32_AV_RETRY: number;
-		/**
-		 * @constant 10
-		 *
-		 * Control whether or not the WAL is persisted
-		 * Some versions of macOS configure WAL to be persistent by default.
-		 *
-		 * You can change this with code like the below:
-		 * ```ts
-		 * import { Database } from "bun:sqlite";
-		 *
-		 * const db = Database.open("mydb.sqlite");
-		 * db.fileControl(constants.SQLITE_FCNTL_PERSIST_WAL, 0);
-		 * // enable WAL
-		 * db.exec("PRAGMA journal_mode = WAL");
-		 * // .. do some work
-		 * db.close();
-		 * ```
-		 *
-		 */
-		SQLITE_FCNTL_PERSIST_WAL: number;
-		/**
-		 * @constant 11
-		 */
-		SQLITE_FCNTL_OVERWRITE: number;
-		/**
-		 * @constant 12
-		 */
-		SQLITE_FCNTL_VFSNAME: number;
-		/**
-		 * @constant 13
-		 */
-		SQLITE_FCNTL_POWERSAFE_OVERWRITE: number;
-		/**
-		 * @constant 14
-		 */
-		SQLITE_FCNTL_PRAGMA: number;
-		/**
-		 * @constant 15
-		 */
-		SQLITE_FCNTL_BUSYHANDLER: number;
-		/**
-		 * @constant 16
-		 */
-		SQLITE_FCNTL_TEMPFILENAME: number;
-		/**
-		 * @constant 18
-		 */
-		SQLITE_FCNTL_MMAP_SIZE: number;
-		/**
-		 * @constant 19
-		 */
-		SQLITE_FCNTL_TRACE: number;
-		/**
-		 * @constant 20
-		 */
-		SQLITE_FCNTL_HAS_MOVED: number;
-		/**
-		 * @constant 21
-		 */
-		SQLITE_FCNTL_SYNC: number;
-		/**
-		 * @constant 22
-		 */
-		SQLITE_FCNTL_COMMIT_PHASETWO: number;
-		/**
-		 * @constant 23
-		 */
-		SQLITE_FCNTL_WIN32_SET_HANDLE: number;
-		/**
-		 * @constant 24
-		 */
-		SQLITE_FCNTL_WAL_BLOCK: number;
-		/**
-		 * @constant 25
-		 */
-		SQLITE_FCNTL_ZIPVFS: number;
-		/**
-		 * @constant 26
-		 */
-		SQLITE_FCNTL_RBU: number;
-		/**
-		 * @constant 27
-		 */
-		SQLITE_FCNTL_VFS_POINTER: number;
-		/**
-		 * @constant 28
-		 */
-		SQLITE_FCNTL_JOURNAL_POINTER: number;
-		/**
-		 * @constant 29
-		 */
-		SQLITE_FCNTL_WIN32_GET_HANDLE: number;
-		/**
-		 * @constant 30
-		 */
-		SQLITE_FCNTL_PDB: number;
-		/**
-		 * @constant 31
-		 */
-		SQLITE_FCNTL_BEGIN_ATOMIC_WRITE: number;
-		/**
-		 * @constant 32
-		 */
-		SQLITE_FCNTL_COMMIT_ATOMIC_WRITE: number;
-		/**
-		 * @constant 33
-		 */
-		SQLITE_FCNTL_ROLLBACK_ATOMIC_WRITE: number;
-		/**
-		 * @constant 34
-		 */
-		SQLITE_FCNTL_LOCK_TIMEOUT: number;
-		/**
-		 * @constant 35
-		 */
-		SQLITE_FCNTL_DATA_VERSION: number;
-		/**
-		 * @constant 36
-		 */
-		SQLITE_FCNTL_SIZE_LIMIT: number;
-		/**
-		 * @constant 37
-		 */
-		SQLITE_FCNTL_CKPT_DONE: number;
-		/**
-		 * @constant 38
-		 */
-		SQLITE_FCNTL_RESERVE_BYTES: number;
-		/**
-		 * @constant 39
-		 */
-		SQLITE_FCNTL_CKPT_START: number;
-		/**
-		 * @constant 40
-		 */
-		SQLITE_FCNTL_EXTERNAL_READER: number;
-		/**
-		 * @constant 41
-		 */
-		SQLITE_FCNTL_CKSM_FILE: number;
-		/**
-		 * @constant 42
-		 */
-		SQLITE_FCNTL_RESET_CACHE: number;
-	};
+    /**
+     * @constant 1
+     */
+    SQLITE_FCNTL_LOCKSTATE: number;
+    /**
+     * @constant 2
+     */
+    SQLITE_FCNTL_GET_LOCKPROXYFILE: number;
+    /**
+     * @constant 3
+     */
+    SQLITE_FCNTL_SET_LOCKPROXYFILE: number;
+    /**
+     * @constant 4
+     */
+    SQLITE_FCNTL_LAST_ERRNO: number;
+    /**
+     * @constant 5
+     */
+    SQLITE_FCNTL_SIZE_HINT: number;
+    /**
+     * @constant 6
+     */
+    SQLITE_FCNTL_CHUNK_SIZE: number;
+    /**
+     * @constant 7
+     */
+    SQLITE_FCNTL_FILE_POINTER: number;
+    /**
+     * @constant 8
+     */
+    SQLITE_FCNTL_SYNC_OMITTED: number;
+    /**
+     * @constant 9
+     */
+    SQLITE_FCNTL_WIN32_AV_RETRY: number;
+    /**
+     * @constant 10
+     *
+     * Control whether or not the WAL is persisted
+     * Some versions of macOS configure WAL to be persistent by default.
+     *
+     * You can change this with code like the below:
+     * ```ts
+     * import { Database } from "bun:sqlite";
+     *
+     * const db = Database.open("mydb.sqlite");
+     * db.fileControl(constants.SQLITE_FCNTL_PERSIST_WAL, 0);
+     * // enable WAL
+     * db.exec("PRAGMA journal_mode = WAL");
+     * // .. do some work
+     * db.close();
+     * ```
+     *
+     */
+    SQLITE_FCNTL_PERSIST_WAL: number;
+    /**
+     * @constant 11
+     */
+    SQLITE_FCNTL_OVERWRITE: number;
+    /**
+     * @constant 12
+     */
+    SQLITE_FCNTL_VFSNAME: number;
+    /**
+     * @constant 13
+     */
+    SQLITE_FCNTL_POWERSAFE_OVERWRITE: number;
+    /**
+     * @constant 14
+     */
+    SQLITE_FCNTL_PRAGMA: number;
+    /**
+     * @constant 15
+     */
+    SQLITE_FCNTL_BUSYHANDLER: number;
+    /**
+     * @constant 16
+     */
+    SQLITE_FCNTL_TEMPFILENAME: number;
+    /**
+     * @constant 18
+     */
+    SQLITE_FCNTL_MMAP_SIZE: number;
+    /**
+     * @constant 19
+     */
+    SQLITE_FCNTL_TRACE: number;
+    /**
+     * @constant 20
+     */
+    SQLITE_FCNTL_HAS_MOVED: number;
+    /**
+     * @constant 21
+     */
+    SQLITE_FCNTL_SYNC: number;
+    /**
+     * @constant 22
+     */
+    SQLITE_FCNTL_COMMIT_PHASETWO: number;
+    /**
+     * @constant 23
+     */
+    SQLITE_FCNTL_WIN32_SET_HANDLE: number;
+    /**
+     * @constant 24
+     */
+    SQLITE_FCNTL_WAL_BLOCK: number;
+    /**
+     * @constant 25
+     */
+    SQLITE_FCNTL_ZIPVFS: number;
+    /**
+     * @constant 26
+     */
+    SQLITE_FCNTL_RBU: number;
+    /**
+     * @constant 27
+     */
+    SQLITE_FCNTL_VFS_POINTER: number;
+    /**
+     * @constant 28
+     */
+    SQLITE_FCNTL_JOURNAL_POINTER: number;
+    /**
+     * @constant 29
+     */
+    SQLITE_FCNTL_WIN32_GET_HANDLE: number;
+    /**
+     * @constant 30
+     */
+    SQLITE_FCNTL_PDB: number;
+    /**
+     * @constant 31
+     */
+    SQLITE_FCNTL_BEGIN_ATOMIC_WRITE: number;
+    /**
+     * @constant 32
+     */
+    SQLITE_FCNTL_COMMIT_ATOMIC_WRITE: number;
+    /**
+     * @constant 33
+     */
+    SQLITE_FCNTL_ROLLBACK_ATOMIC_WRITE: number;
+    /**
+     * @constant 34
+     */
+    SQLITE_FCNTL_LOCK_TIMEOUT: number;
+    /**
+     * @constant 35
+     */
+    SQLITE_FCNTL_DATA_VERSION: number;
+    /**
+     * @constant 36
+     */
+    SQLITE_FCNTL_SIZE_LIMIT: number;
+    /**
+     * @constant 37
+     */
+    SQLITE_FCNTL_CKPT_DONE: number;
+    /**
+     * @constant 38
+     */
+    SQLITE_FCNTL_RESERVE_BYTES: number;
+    /**
+     * @constant 39
+     */
+    SQLITE_FCNTL_CKPT_START: number;
+    /**
+     * @constant 40
+     */
+    SQLITE_FCNTL_EXTERNAL_READER: number;
+    /**
+     * @constant 41
+     */
+    SQLITE_FCNTL_CKSM_FILE: number;
+    /**
+     * @constant 42
+     */
+    SQLITE_FCNTL_RESET_CACHE: number;
+  };
 
-	/**
-	 * The native module implementing the sqlite3 C bindings
-	 *
-	 * It is lazily-initialized, so this will return `undefined` until the first
-	 * call to new Database().
-	 *
-	 * The native module makes no gurantees about ABI stability, so it is left
-	 * untyped
-	 *
-	 * If you need to use it directly for some reason, please let us know because
-	 * that probably points to a deficiency in this API.
-	 */
-	export var native: any;
+  /**
+   * The native module implementing the sqlite3 C bindings
+   *
+   * It is lazily-initialized, so this will return `undefined` until the first
+   * call to new Database().
+   *
+   * The native module makes no gurantees about ABI stability, so it is left
+   * untyped
+   *
+   * If you need to use it directly for some reason, please let us know because
+   * that probably points to a deficiency in this API.
+   */
+  export var native: any;
 
-	export type SQLQueryBindings =
-		| string
-		| bigint
-		| NodeJS.TypedArray
-		| number
-		| boolean
-		| null
-		| Record<
-				string,
-				string | bigint | NodeJS.TypedArray | number | boolean | null
-		  >;
+  export type SQLQueryBindings =
+    | string
+    | bigint
+    | NodeJS.TypedArray
+    | number
+    | boolean
+    | null
+    | Record<string, string | bigint | NodeJS.TypedArray | number | boolean | null>;
 
-	export default Database;
+  export default Database;
 
-	/**
-	 * Errors from SQLite have a name `SQLiteError`.
-	 *
-	 */
-	export class SQLiteError extends Error {
-		readonly name: "SQLiteError";
+  /**
+   * Errors from SQLite have a name `SQLiteError`.
+   *
+   */
+  export class SQLiteError extends Error {
+    readonly name: "SQLiteError";
 
-		/**
-		 * The SQLite3 extended error code
-		 *
-		 * This corresponds to `sqlite3_extended_errcode`.
-		 *
-		 * @since v1.0.21
-		 */
-		errno: number;
+    /**
+     * The SQLite3 extended error code
+     *
+     * This corresponds to `sqlite3_extended_errcode`.
+     *
+     * @since v1.0.21
+     */
+    errno: number;
 
-		/**
-		 * The name of the SQLite3 error code
-		 *
-		 * @example
-		 * "SQLITE_CONSTRAINT_UNIQUE"
-		 *
-		 * @since v1.0.21
-		 */
-		code?: string;
+    /**
+     * The name of the SQLite3 error code
+     *
+     * @example
+     * "SQLITE_CONSTRAINT_UNIQUE"
+     *
+     * @since v1.0.21
+     */
+    code?: string;
 
-		/**
-		 * The UTF-8 byte offset of the sqlite3 query that failed, if known
-		 *
-		 * This corresponds to `sqlite3_error_offset`.
-		 *
-		 * @since v1.0.21
-		 */
-		readonly byteOffset: number;
-	}
+    /**
+     * The UTF-8 byte offset of the sqlite3 query that failed, if known
+     *
+     * This corresponds to `sqlite3_error_offset`.
+     *
+     * @since v1.0.21
+     */
+    readonly byteOffset: number;
+  }
 
-	/**
-	 * An object representing the changes made to the database since the last `run` or `exec` call.
-	 *
-	 * @since Bun v1.1.14
-	 */
-	export interface Changes {
-		/**
-		 * The number of rows changed by the last `run` or `exec` call.
-		 */
-		changes: number;
+  /**
+   * An object representing the changes made to the database since the last `run` or `exec` call.
+   *
+   * @since Bun v1.1.14
+   */
+  export interface Changes {
+    /**
+     * The number of rows changed by the last `run` or `exec` call.
+     */
+    changes: number;
 
-		/**
-		 * If `safeIntegers` is `true`, this is a `bigint`. Otherwise, it is a `number`.
-		 */
-		lastInsertRowid: number | bigint;
-	}
+    /**
+     * If `safeIntegers` is `true`, this is a `bigint`. Otherwise, it is a `number`.
+     */
+    lastInsertRowid: number | bigint;
+  }
 }