@psnext/slingcli 3.1.20260904-1 → 3.3.20260911-1

package/node_modules/@types/node/sqlite.d.ts

@@ -1,3 +1,47 @@
+/**
+ * The `node:sqlite` module facilitates working with SQLite databases.
+ * To access it:
+ *
+ * ```js
+ * import sqlite from 'node:sqlite';
+ * ```
+ *
+ * This module is only available under the `node:` scheme. The following will not
+ * work:
+ *
+ * ```js
+ * import sqlite from 'sqlite';
+ * ```
+ *
+ * The following example shows the basic usage of the `node:sqlite` module to open
+ * an in-memory database, write data to the database, and then read the data back.
+ *
+ * ```js
+ * import { DatabaseSync } from 'node:sqlite';
+ * const database = new DatabaseSync(':memory:');
+ *
+ * // Execute SQL statements from strings.
+ * database.exec(`
+ *   CREATE TABLE data(
+ *     key INTEGER PRIMARY KEY,
+ *     value TEXT
+ *   ) STRICT
+ * `);
+ * // Create a prepared statement to insert data into the database.
+ * const insert = database.prepare('INSERT INTO data (key, value) VALUES (?, ?)');
+ * // Execute the prepared statement with bound values.
+ * insert.run(1, 'hello');
+ * insert.run(2, 'world');
+ * // Create a prepared statement to read data from the database.
+ * const query = database.prepare('SELECT * FROM data ORDER BY key');
+ * // Execute the prepared statement and log the result set.
+ * console.log(query.all());
+ * // Prints: [ { key: 1, value: 'hello' }, { key: 2, value: 'world' } ]
+ * ```
+ * @since v22.5.0
+ * @experimental
+ * @see [source](https://github.com/nodejs/node/blob/v22.x/lib/sqlite.js)
+ */
 declare module "node:sqlite" {
     import { PathLike } from "node:fs";
     type SQLInputValue = null | number | bigint | string | NodeJS.ArrayBufferView;
@@ -48,68 +92,37 @@ declare module "node:sqlite" {
          * The [busy timeout](https://sqlite.org/c3ref/busy_timeout.html) in milliseconds. This is the maximum amount of
          * time that SQLite will wait for a database lock to be released before
          * returning an error.
-         * @since v24.0.0
+         * @since v22.16.0
          * @default 0
          */
         timeout?: number | undefined;
         /**
          * If `true`, integer fields are read as JavaScript `BigInt` values. If `false`,
          * integer fields are read as JavaScript numbers.
-         * @since v24.4.0
+         * @since v22.18.0
          * @default false
          */
         readBigInts?: boolean | undefined;
         /**
          * If `true`, query results are returned as arrays instead of objects.
-         * @since v24.4.0
+         * @since v22.18.0
          * @default false
          */
         returnArrays?: boolean | undefined;
         /**
          * If `true`, allows binding named parameters without the prefix
          * character (e.g., `foo` instead of `:foo`).
-         * @since v24.4.40
+         * @since v22.18.0
          * @default true
          */
         allowBareNamedParameters?: boolean | undefined;
         /**
          * If `true`, unknown named parameters are ignored when binding.
          * If `false`, an exception is thrown for unknown named parameters.
-         * @since v24.4.40
+         * @since v22.18.0
          * @default false
          */
         allowUnknownNamedParameters?: boolean | undefined;
-        /**
-         * If `true`, enables the defensive flag. When the defensive flag is enabled,
-         * language features that allow ordinary SQL to deliberately corrupt the database file are disabled.
-         * The defensive flag can also be set using `enableDefensive()`.
-         * @since v25.1.0
-         * @default true
-         */
-        defensive?: boolean | undefined;
-        /**
-         * Configuration for various SQLite limits. These limits
-         * can be used to prevent excessive resource consumption when handling
-         * potentially malicious input. See [Run-Time Limits](https://www.sqlite.org/c3ref/c_limit_attached.html) and [Limit Constants](https://www.sqlite.org/c3ref/limit.html)
-         * in the SQLite documentation for details. Default values are determined by
-         * SQLite's compile-time defaults and may vary depending on how SQLite was
-         * built. The following properties are supported:
-         * @since v25.8.0
-         */
-        limits?: NodeJS.PartialOptions<DatabaseLimits> | undefined;
-    }
-    interface DatabaseLimits {
-        length: number;
-        sqlLength: number;
-        column: number;
-        exprDepth: number;
-        compoundSelect: number;
-        vdbeOp: number;
-        functionArg: number;
-        attach: number;
-        likePatternLength: number;
-        variableNumber: number;
-        triggerDepth: number;
     }
     interface CreateSessionOptions {
         /**
@@ -127,12 +140,8 @@ declare module "node:sqlite" {
     }
     interface ApplyChangesetOptions {
         /**
-         * for each table affected by at least
-         * one change in the changeset, the `filter` callback is invoked with the
-         * table name as the first argument. If the return value is falsy, then no
-         * attempt is made to apply any changes to the table.
-         * Otherwise, if the return value is truthy or no `filter` callback is provided,
-         * all changes related to the table are attempted.
+         * Skip changes that, when targeted table name is supplied to this function, return a truthy value.
+         * By default, all changes are attempted.
          * @since v22.12.0
          */
         filter?: ((tableName: string) => boolean) | undefined;
@@ -162,13 +171,6 @@ declare module "node:sqlite" {
          */
         onConflict?: ((conflictType: number) => number) | undefined;
     }
-    interface DeserializeOptions {
-        /**
-         * Name of the database to deserialize into.
-         * @default 'main'
-         */
-        dbName?: string | undefined;
-    }
     interface FunctionOptions {
         /**
          * If `true`, the [`SQLITE_DETERMINISTIC`](https://www.sqlite.org/c3ref/c_deterministic.html) flag is
@@ -223,28 +225,6 @@ declare module "node:sqlite" {
          */
         inverse?: ((accumulator: T, ...args: SQLOutputValue[]) => T) | undefined;
     }
-    interface PrepareOptions {
-        /**
-         * If `true`, integer fields are read as `BigInt`s.
-         * @since v25.5.0
-         */
-        readBigInts?: boolean | undefined;
-        /**
-         * If `true`, results are returned as arrays.
-         * @since v25.5.0
-         */
-        returnArrays?: boolean | undefined;
-        /**
-         * If `true`, allows binding named parameters without the prefix character.
-         * @since v25.5.0
-         */
-        allowBareNamedParameters?: boolean | undefined;
-        /**
-         * If `true`, unknown named parameters are ignored.
-         * @since v25.5.0
-         */
-        allowUnknownNamedParameters?: boolean | undefined;
-    }
     /**
      * This class represents a single [connection](https://www.sqlite.org/c3ref/sqlite3.html) to a SQLite database. All APIs
      * exposed by this class execute synchronously.
@@ -286,7 +266,7 @@ declare module "node:sqlite" {
          *
          * db.prepare('SELECT sumint(y) as total FROM t3').get(); // { total: 21 }
          * ```
-         * @since v24.0.0
+         * @since v22.16.0
          * @param name The name of the SQLite function to create.
          * @param options Function configuration settings.
          */
@@ -302,23 +282,10 @@ declare module "node:sqlite" {
          * Loads a shared library into the database connection. This method is a wrapper
          * around [`sqlite3_load_extension()`](https://www.sqlite.org/c3ref/load_extension.html). It is required to enable the
          * `allowExtension` option when constructing the `DatabaseSync` instance.
-         *
-         * ```js
-         * import { DatabaseSync } from 'node:sqlite';
-         * const database = new DatabaseSync(':memory:', { allowExtension: true });
-         *
-         * // Load using the entry point derived from the filename.
-         * database.loadExtension('./decimal.dylib');
-         *
-         * // Override the entry point when the derived name does not match.
-         * database.loadExtension('./base64.dylib', 'sqlite3_base64_init');
          * @since v22.13.0
          * @param path The path to the shared library to load.
-         * @param entryPoint The name of the extension's entry-point function. When
-         * omitted, SQLite derives the entry point from the shared library's filename;
-         * pass this argument explicitly when the derived name does not match.
          */
-        loadExtension(path: string, entryPoint?: string): void;
+        loadExtension(path: string): void;
         /**
          * Enables or disables the `loadExtension` SQL function, and the `loadExtension()`
          * method. When `allowExtension` is `false` when constructing, you cannot enable
@@ -327,17 +294,9 @@ declare module "node:sqlite" {
          * @param allow Whether to allow loading extensions.
          */
         enableLoadExtension(allow: boolean): void;
-        /**
-         * Enables or disables the defensive flag. When the defensive flag is active,
-         * language features that allow ordinary SQL to deliberately corrupt the database file are disabled.
-         * See [`SQLITE_DBCONFIG_DEFENSIVE`](https://www.sqlite.org/c3ref/c_dbconfig_defensive.html#sqlitedbconfigdefensive) in the SQLite documentation for details.
-         * @since v25.1.0
-         * @param active Whether to set the defensive flag.
-         */
-        enableDefensive(active: boolean): void;
         /**
          * This method is a wrapper around [`sqlite3_db_filename()`](https://sqlite.org/c3ref/db_filename.html)
-         * @since v24.0.0
+         * @since v22.16.0
          * @param dbName Name of the database. This can be `'main'` (the default primary database) or any other
          * database that has been added with [`ATTACH DATABASE`](https://www.sqlite.org/lang_attach.html) **Default:** `'main'`.
          * @returns The location of the database file. When using an in-memory database,
@@ -358,75 +317,18 @@ declare module "node:sqlite" {
          * @since v22.13.0
          * @param name The name of the SQLite function to create.
          * @param options Optional configuration settings for the function.
-         * @param fn The JavaScript function to call when the SQLite function is
-         * invoked. The return value of this function should be a valid SQLite data type:
-         * see [Type conversion between JavaScript and SQLite](https://nodejs.org/docs/latest-v26.x/api/sqlite.html#type-conversion-between-javascript-and-sqlite). The result defaults to
-         * `NULL` if the return value is `undefined`.
+         * @param func The JavaScript function to call when the SQLite
+         * function is invoked. The return value of this function should be a valid
+         * SQLite data type: see
+         * [Type conversion between JavaScript and SQLite](https://nodejs.org/docs/latest-v22.x/api/sqlite.html#type-conversion-between-javascript-and-sqlite).
+         * The result defaults to `NULL` if the return value is `undefined`.
          */
         function(
             name: string,
             options: FunctionOptions,
-            fn: (...args: SQLOutputValue[]) => SQLInputValue,
-        ): void;
-        function(name: string, fn: (...args: SQLOutputValue[]) => SQLInputValue): void;
-        /**
-         * Sets an authorizer callback that SQLite will invoke whenever it attempts to
-         * access data or modify the database schema through prepared statements.
-         * This can be used to implement security policies, audit access, or restrict certain operations.
-         * This method is a wrapper around [`sqlite3_set_authorizer()`](https://sqlite.org/c3ref/set_authorizer.html).
-         *
-         * When invoked, the callback receives five arguments:
-         *
-         * * `actionCode` {number} The type of operation being performed (e.g.,
-         *   `SQLITE_INSERT`, `SQLITE_UPDATE`, `SQLITE_SELECT`).
-         * * `arg1` {string|null} The first argument (context-dependent, often a table name).
-         * * `arg2` {string|null} The second argument (context-dependent, often a column name).
-         * * `dbName` {string|null} The name of the database.
-         * * `triggerOrView` {string|null} The name of the trigger or view causing the access.
-         *
-         * The callback must return one of the following constants:
-         *
-         * * `SQLITE_OK` - Allow the operation.
-         * * `SQLITE_DENY` - Deny the operation (causes an error).
-         * * `SQLITE_IGNORE` - Ignore the operation (silently skip).
-         *
-         * ```js
-         * import { DatabaseSync, constants } from 'node:sqlite';
-         * const db = new DatabaseSync(':memory:');
-         *
-         * // Set up an authorizer that denies all table creation
-         * db.setAuthorizer((actionCode) => {
-         *   if (actionCode === constants.SQLITE_CREATE_TABLE) {
-         *     return constants.SQLITE_DENY;
-         *   }
-         *   return constants.SQLITE_OK;
-         * });
-         *
-         * // This will work
-         * db.prepare('SELECT 1').get();
-         *
-         * // This will throw an error due to authorization denial
-         * try {
-         *   db.exec('CREATE TABLE blocked (id INTEGER)');
-         * } catch (err) {
-         *   console.log('Operation blocked:', err.message);
-         * }
-         * ```
-         * @since v24.10.0
-         * @param callback The authorizer function to set, or `null` to
-         * clear the current authorizer.
-         */
-        setAuthorizer(
-            callback:
-                | ((
-                    actionCode: number,
-                    arg1: string | null,
-                    arg2: string | null,
-                    dbName: string | null,
-                    triggerOrView: string | null,
-                ) => number)
-                | null,
+            func: (...args: SQLOutputValue[]) => SQLInputValue,
         ): void;
+        function(name: string, func: (...args: SQLOutputValue[]) => SQLInputValue): void;
         /**
          * Whether the database is currently open or not.
          * @since v22.15.0
@@ -435,191 +337,23 @@ declare module "node:sqlite" {
         /**
          * Whether the database is currently within a transaction. This method
          * is a wrapper around [`sqlite3_get_autocommit()`](https://sqlite.org/c3ref/get_autocommit.html).
-         * @since v24.0.0
+         * @since v22.16.0
          */
         readonly isTransaction: boolean;
-        /**
-         * An object for getting and setting SQLite database limits at runtime.
-         * Each property corresponds to an SQLite limit and can be read or written.
-         *
-         * ```js
-         * const db = new DatabaseSync(':memory:');
-         *
-         * // Read current limit
-         * console.log(db.limits.length);
-         *
-         * // Set a new limit
-         * db.limits.sqlLength = 100000;
-         *
-         * // Reset a limit to its compile-time maximum
-         * db.limits.sqlLength = Infinity;
-         * ```
-         *
-         * Available properties: `length`, `sqlLength`, `column`, `exprDepth`,
-         * `compoundSelect`, `vdbeOp`, `functionArg`, `attach`, `likePatternLength`,
-         * `variableNumber`, `triggerDepth`.
-         *
-         * Setting a property to `Infinity` resets the limit to its compile-time maximum value.
-         * @since v25.8.0
-         */
-        readonly limits: DatabaseLimits;
         /**
          * Opens the database specified in the `path` argument of the `DatabaseSync`constructor. This method should only be used when the database is not opened via
          * the constructor. An exception is thrown if the database is already open.
          * @since v22.5.0
          */
         open(): void;
-        /**
-         * Serializes the database into a binary representation, returned as a
-         * `Uint8Array`. This is useful for saving, cloning, or transferring an in-memory
-         * database. This method is a wrapper around [`sqlite3_serialize()`](https://sqlite.org/c3ref/serialize.html).
-         *
-         * ```js
-         * import { DatabaseSync } from 'node:sqlite';
-         *
-         * const db = new DatabaseSync(':memory:');
-         * db.exec('CREATE TABLE t(key INTEGER PRIMARY KEY, value TEXT)');
-         * db.exec("INSERT INTO t VALUES (1, 'hello')");
-         * const buffer = db.serialize();
-         * console.log(buffer.length); // Prints the byte length of the database
-         * ```
-         * @since v26.1.0
-         * @param dbName Name of the database to serialize. This can be `'main'`
-         * (the default primary database) or any other database that has been added with
-         * [`ATTACH DATABASE`](https://www.sqlite.org/lang_attach.html). **Default:** `'main'`.
-         * @returns A binary representation of the database.
-         */
-        serialize(dbName?: string): NodeJS.NonSharedUint8Array;
-        /**
-         * Loads a serialized database into this connection, replacing the current
-         * database. The deserialized database is writable. Existing prepared statements
-         * are finalized before deserialization is attempted, even if the operation
-         * subsequently fails. This method is a wrapper around
-         * [`sqlite3_deserialize()`](https://sqlite.org/c3ref/deserialize.html).
-         *
-         * ```js
-         * import { DatabaseSync } from 'node:sqlite';
-         *
-         * const original = new DatabaseSync(':memory:');
-         * original.exec('CREATE TABLE t(key INTEGER PRIMARY KEY, value TEXT)');
-         * original.exec("INSERT INTO t VALUES (1, 'hello')");
-         * const buffer = original.serialize();
-         * original.close();
-         *
-         * const clone = new DatabaseSync(':memory:');
-         * clone.deserialize(buffer);
-         * console.log(clone.prepare('SELECT value FROM t').get());
-         * // Prints: { value: 'hello' }
-         * ```
-         * @since v26.1.0
-         * @param buffer A binary representation of a database, such as the
-         * output of `database.serialize()`.
-         * @param options Optional configuration for the deserialization.
-         */
-        deserialize(buffer: Uint8Array, options?: DeserializeOptions): void;
         /**
          * Compiles a SQL statement into a [prepared statement](https://www.sqlite.org/c3ref/stmt.html). This method is a wrapper
          * around [`sqlite3_prepare_v2()`](https://www.sqlite.org/c3ref/prepare.html).
          * @since v22.5.0
          * @param sql A SQL string to compile to a prepared statement.
-         * @param options Optional configuration for the prepared statement.
          * @return The prepared statement.
          */
-        prepare(sql: string, options?: PrepareOptions): StatementSync;
-        /**
-         * Creates a new {@link SQLTagStore}, which is a Least Recently Used (LRU) cache
-         * for storing prepared statements. This allows for the efficient reuse of
-         * prepared statements by tagging them with a unique identifier.
-         *
-         * When a tagged SQL literal is executed, the `SQLTagStore` checks if a prepared
-         * statement for the corresponding SQL query string already exists in the cache.
-         * If it does, the cached statement is used. If not, a new prepared statement is
-         * created, executed, and then stored in the cache for future use. This mechanism
-         * helps to avoid the overhead of repeatedly parsing and preparing the same SQL
-         * statements.
-         *
-         * Tagged statements bind the placeholder values from the template literal as
-         * parameters to the underlying prepared statement. For example:
-         *
-         * ```js
-         * sqlTagStore.get`SELECT ${value}`;
-         * ```
-         *
-         * is equivalent to:
-         *
-         * ```js
-         * db.prepare('SELECT ?').get(value);
-         * ```
-         *
-         * However, in the first example, the tag store will cache the underlying prepared
-         * statement for future use.
-         *
-         * > **Note:** The `${value}` syntax in tagged statements _binds_ a parameter to
-         * > the prepared statement. This differs from its behavior in _untagged_ template
-         * > literals, where it performs string interpolation.
-         * >
-         * > ```js
-         * > // This a safe example of binding a parameter to a tagged statement.
-         * > sqlTagStore.run`INSERT INTO t1 (id) VALUES (${id})`;
-         * >
-         * > // This is an *unsafe* example of an untagged template string.
-         * > // `id` is interpolated into the query text as a string.
-         * > // This can lead to SQL injection and data corruption.
-         * > db.run(`INSERT INTO t1 (id) VALUES (${id})`);
-         * > ```
-         *
-         * The tag store will match a statement from the cache if the query strings
-         * (including the positions of any bound placeholders) are identical.
-         *
-         * ```js
-         * // The following statements will match in the cache:
-         * sqlTagStore.get`SELECT * FROM t1 WHERE id = ${id} AND active = 1`;
-         * sqlTagStore.get`SELECT * FROM t1 WHERE id = ${12345} AND active = 1`;
-         *
-         * // The following statements will not match, as the query strings
-         * // and bound placeholders differ:
-         * sqlTagStore.get`SELECT * FROM t1 WHERE id = ${id} AND active = 1`;
-         * sqlTagStore.get`SELECT * FROM t1 WHERE id = 12345 AND active = 1`;
-         *
-         * // The following statements will not match, as matches are case-sensitive:
-         * sqlTagStore.get`SELECT * FROM t1 WHERE id = ${id} AND active = 1`;
-         * sqlTagStore.get`select * from t1 where id = ${id} and active = 1`;
-         * ```
-         *
-         * The only way of binding parameters in tagged statements is with the `${value}`
-         * syntax. Do not add parameter binding placeholders (`?` etc.) to the SQL query
-         * string itself.
-         *
-         * ```js
-         * import { DatabaseSync } from 'node:sqlite';
-         *
-         * const db = new DatabaseSync(':memory:');
-         * const sql = db.createSQLTagStore();
-         *
-         * db.exec('CREATE TABLE users (id INT, name TEXT)');
-         *
-         * // Using the 'run' method to insert data.
-         * // The tagged literal is used to identify the prepared statement.
-         * sql.run`INSERT INTO users VALUES (1, 'Alice')`;
-         * sql.run`INSERT INTO users VALUES (2, 'Bob')`;
-         *
-         * // Using the 'get' method to retrieve a single row.
-         * const name = 'Alice';
-         * const user = sql.get`SELECT * FROM users WHERE name = ${name}`;
-         * console.log(user); // { id: 1, name: 'Alice' }
-         *
-         * // Using the 'all' method to retrieve all rows.
-         * const allUsers = sql.all`SELECT * FROM users ORDER BY id`;
-         * console.log(allUsers);
-         * // [
-         * //   { id: 1, name: 'Alice' },
-         * //   { id: 2, name: 'Bob' }
-         * // ]
-         * ```
-         * @since v24.9.0
-         * @returns A new SQL tag store for caching prepared statements.
-         */
-        createTagStore(maxSize?: number): SQLTagStore;
+        prepare(sql: string): StatementSync;
         /**
          * Creates and attaches a session to the database. This method is a wrapper around
          * [`sqlite3session_create()`](https://www.sqlite.org/session/sqlite3session_create.html) and
@@ -635,8 +369,6 @@ declare module "node:sqlite" {
          * [`sqlite3changeset_apply()`](https://www.sqlite.org/session/sqlite3changeset_apply.html).
          *
          * ```js
-         * import { DatabaseSync } from 'node:sqlite';
-         *
          * const sourceDb = new DatabaseSync(':memory:');
          * const targetDb = new DatabaseSync(':memory:');
          *
@@ -663,6 +395,7 @@ declare module "node:sqlite" {
          * Closes the database connection. If the database connection is already closed
          * then this is a no-op.
          * @since v22.15.0
+         * @experimental
          */
         [Symbol.dispose](): void;
     }
@@ -694,107 +427,6 @@ declare module "node:sqlite" {
          * [`sqlite3session_delete()`](https://www.sqlite.org/session/sqlite3session_delete.html).
          */
         close(): void;
-        /**
-         * Closes the session. If the session is already closed, does nothing.
-         * @since v24.9.0
-         */
-        [Symbol.dispose](): void;
-    }
-    /**
-     * This class represents a single LRU (Least Recently Used) cache for storing
-     * prepared statements.
-     *
-     * Instances of this class are created via the `database.createTagStore()`
-     * method, not by using a constructor. The store caches prepared statements based
-     * on the provided SQL query string. When the same query is seen again, the store
-     * retrieves the cached statement and safely applies the new values through
-     * parameter binding, thereby preventing attacks like SQL injection.
-     *
-     * The cache has a maxSize that defaults to 1000 statements, but a custom size can
-     * be provided (e.g., `database.createTagStore(100)`). All APIs exposed by this
-     * class execute synchronously.
-     * @since v24.9.0
-     */
-    interface SQLTagStore {
-        /**
-         * Executes the given SQL query and returns all resulting rows as an array of
-         * objects.
-         *
-         * This function is intended to be used as a template literal tag, not to be
-         * called directly.
-         * @since v24.9.0
-         * @param stringElements Template literal elements containing the SQL
-         * query.
-         * @param boundParameters Parameter values to be bound to placeholders in the template string.
-         * @returns An array of objects representing the rows returned by the query.
-         */
-        all(
-            stringElements: TemplateStringsArray,
-            ...boundParameters: SQLInputValue[]
-        ): Record<string, SQLOutputValue>[];
-        /**
-         * Executes the given SQL query and returns the first resulting row as an object.
-         *
-         * This function is intended to be used as a template literal tag, not to be
-         * called directly.
-         * @since v24.9.0
-         * @param stringElements Template literal elements containing the SQL
-         * query.
-         * @param boundParameters Parameter values to be bound to placeholders in the template string.
-         * @returns An object representing the first row returned by
-         * the query, or `undefined` if no rows are returned.
-         */
-        get(
-            stringElements: TemplateStringsArray,
-            ...boundParameters: SQLInputValue[]
-        ): Record<string, SQLOutputValue> | undefined;
-        /**
-         * Executes the given SQL query and returns an iterator over the resulting rows.
-         *
-         * This function is intended to be used as a template literal tag, not to be
-         * called directly.
-         * @since v24.9.0
-         * @param stringElements Template literal elements containing the SQL
-         * query.
-         * @param boundParameters Parameter values to be bound to placeholders in the template string.
-         * @returns An iterator that yields objects representing the rows returned by the query.
-         */
-        iterate(
-            stringElements: TemplateStringsArray,
-            ...boundParameters: SQLInputValue[]
-        ): NodeJS.Iterator<Record<string, SQLOutputValue>>;
-        /**
-         * Executes the given SQL query, which is expected to not return any rows (e.g., INSERT, UPDATE, DELETE).
-         *
-         * This function is intended to be used as a template literal tag, not to be
-         * called directly.
-         * @since v24.9.0
-         * @param stringElements Template literal elements containing the SQL
-         * query.
-         * @param boundParameters Parameter values to be bound to placeholders in the template string.
-         * @returns An object containing information about the execution, including `changes` and `lastInsertRowid`.
-         */
-        run(stringElements: TemplateStringsArray, ...boundParameters: SQLInputValue[]): StatementResultingChanges;
-        /**
-         * A read-only property that returns the number of prepared statements currently in the cache.
-         * @since v24.9.0
-         */
-        readonly size: number;
-        /**
-         * A read-only property that returns the maximum number of prepared statements the cache can hold.
-         * @since v24.9.0
-         */
-        readonly capacity: number;
-        /**
-         * A read-only property that returns the `DatabaseSync` object associated with this `SQLTagStore`.
-         * @since v24.9.0
-         */
-        readonly db: DatabaseSync;
-        /**
-         * Resets the LRU cache, clearing all stored prepared statements.
-         * @since v24.9.0
-         */
-        clear(): void;
     }
     interface StatementColumnMetadata {
         /**
@@ -875,7 +507,7 @@ declare module "node:sqlite" {
         /**
          * This method is used to retrieve information about the columns returned by the
          * prepared statement.
-         * @since v23.11.0
+         * @since v22.16.0
          * @returns An array of objects. Each object corresponds to a column
          * in the prepared statement, and contains the following properties:
          */
@@ -964,7 +596,7 @@ declare module "node:sqlite" {
         /**
          * When enabled, query results returned by the `all()`, `get()`, and `iterate()` methods will be returned as arrays instead
          * of objects.
-         * @since v24.0.0
+         * @since v22.16.0
          * @param enabled Enables or disables the return of query results as arrays.
          */
         setReturnArrays(enabled: boolean): void;
@@ -1038,14 +670,13 @@ declare module "node:sqlite" {
      *
      * console.log('Backup completed', totalPagesTransferred);
      * ```
-     * @since v23.8.0
+     * @since v22.16.0
      * @param sourceDb The database to backup. The source database must be open.
      * @param path The path where the backup will be created. If the file already exists,
      * the contents will be overwritten.
      * @param options Optional configuration for the backup. The
      * following properties are supported:
-     * @returns A promise that fulfills with the total number of backed-up pages upon completion, or rejects if an
-     * error occurs.
+     * @returns A promise that fulfills with the total number of backed-up pages upon completion, or rejects if an error occurs.
      */
     function backup(sourceDb: DatabaseSync, path: PathLike, options?: BackupOptions): Promise<number>;
     /**
@@ -1087,54 +718,5 @@ declare module "node:sqlite" {
          * @since v22.12.0
          */
         const SQLITE_CHANGESET_ABORT: number;
-        /**
-         * Deny the operation and cause an error to be returned.
-         * @since v24.10.0
-         */
-        const SQLITE_DENY: number;
-        /**
-         * Ignore the operation and continue as if it had never been requested.
-         * @since 24.10.0
-         */
-        const SQLITE_IGNORE: number;
-        /**
-         * Allow the operation to proceed normally.
-         * @since v24.10.0
-         */
-        const SQLITE_OK: number;
-        const SQLITE_CREATE_INDEX: number;
-        const SQLITE_CREATE_TABLE: number;
-        const SQLITE_CREATE_TEMP_INDEX: number;
-        const SQLITE_CREATE_TEMP_TABLE: number;
-        const SQLITE_CREATE_TEMP_TRIGGER: number;
-        const SQLITE_CREATE_TEMP_VIEW: number;
-        const SQLITE_CREATE_TRIGGER: number;
-        const SQLITE_CREATE_VIEW: number;
-        const SQLITE_DELETE: number;
-        const SQLITE_DROP_INDEX: number;
-        const SQLITE_DROP_TABLE: number;
-        const SQLITE_DROP_TEMP_INDEX: number;
-        const SQLITE_DROP_TEMP_TABLE: number;
-        const SQLITE_DROP_TEMP_TRIGGER: number;
-        const SQLITE_DROP_TEMP_VIEW: number;
-        const SQLITE_DROP_TRIGGER: number;
-        const SQLITE_DROP_VIEW: number;
-        const SQLITE_INSERT: number;
-        const SQLITE_PRAGMA: number;
-        const SQLITE_READ: number;
-        const SQLITE_SELECT: number;
-        const SQLITE_TRANSACTION: number;
-        const SQLITE_UPDATE: number;
-        const SQLITE_ATTACH: number;
-        const SQLITE_DETACH: number;
-        const SQLITE_ALTER_TABLE: number;
-        const SQLITE_REINDEX: number;
-        const SQLITE_ANALYZE: number;
-        const SQLITE_CREATE_VTABLE: number;
-        const SQLITE_DROP_VTABLE: number;
-        const SQLITE_FUNCTION: number;
-        const SQLITE_SAVEPOINT: number;
-        const SQLITE_COPY: number;
-        const SQLITE_RECURSIVE: number;
     }
 }