@chainlink/external-adapter-framework 2.6.0 → 2.7.0

package/generator-adapter/node_modules/@types/node/http2.d.ts

@@ -1223,14 +1223,66 @@ declare module "http2" {
     }
     // Http2Server
     export interface SessionOptions {
+        /**
+         * Sets the maximum dynamic table size for deflating header fields.
+         * @default 4Kib
+         */
         maxDeflateDynamicTableSize?: number | undefined;
+        /**
+         * Sets the maximum number of settings entries per `SETTINGS` frame.
+         * The minimum value allowed is `1`.
+         * @default 32
+         */
+        maxSettings?: number | undefined;
+        /**
+         * Sets the maximum memory that the `Http2Session` is permitted to use.
+         * The value is expressed in terms of number of megabytes, e.g. `1` equal 1 megabyte.
+         * The minimum value allowed is `1`.
+         * This is a credit based limit, existing `Http2Stream`s may cause this limit to be exceeded,
+         * but new `Http2Stream` instances will be rejected while this limit is exceeded.
+         * The current number of `Http2Stream` sessions, the current memory use of the header compression tables,
+         * current data queued to be sent, and unacknowledged `PING` and `SETTINGS` frames are all counted towards the current limit.
+         * @default 10
+         */
         maxSessionMemory?: number | undefined;
+        /**
+         * Sets the maximum number of header entries.
+         * This is similar to `server.maxHeadersCount` or `request.maxHeadersCount` in the `node:http` module.
+         * The minimum value is `1`.
+         * @default 128
+         */
         maxHeaderListPairs?: number | undefined;
+        /**
+         * Sets the maximum number of outstanding, unacknowledged pings.
+         * @default 10
+         */
         maxOutstandingPings?: number | undefined;
+        /**
+         * Sets the maximum allowed size for a serialized, compressed block of headers.
+         * Attempts to send headers that exceed this limit will result in
+         * a `'frameError'` event being emitted and the stream being closed and destroyed.
+         */
         maxSendHeaderBlockLength?: number | undefined;
+        /**
+         * Strategy used for determining the amount of padding to use for `HEADERS` and `DATA` frames.
+         * @default http2.constants.PADDING_STRATEGY_NONE
+         */
         paddingStrategy?: number | undefined;
+        /**
+         * Sets the maximum number of concurrent streams for the remote peer as if a `SETTINGS` frame had been received.
+         * Will be overridden if the remote peer sets its own value for `maxConcurrentStreams`.
+         * @default 100
+         */
         peerMaxConcurrentStreams?: number | undefined;
+        /**
+         * The initial settings to send to the remote peer upon connection.
+         */
         settings?: Settings | undefined;
+        /**
+         * The array of integer values determines the settings types,
+         * which are included in the `CustomSettings`-property of the received remoteSettings.
+         * Please see the `CustomSettings`-property of the `Http2Settings` object for more information, on the allowed setting types.
+         */
         remoteCustomSettings?: number[] | undefined;
         /**
          * Specifies a timeout in milliseconds that
@@ -1239,11 +1291,27 @@ declare module "http2" {
          * @default 100000
          */
         unknownProtocolTimeout?: number | undefined;
-        selectPadding?(frameLen: number, maxFrameLen: number): number;
     }
     export interface ClientSessionOptions extends SessionOptions {
+        /**
+         * Sets the maximum number of reserved push streams the client will accept at any given time.
+         * Once the current number of currently reserved push streams exceeds reaches this limit,
+         * new push streams sent by the server will be automatically rejected.
+         * The minimum allowed value is 0. The maximum allowed value is 2<sup>32</sup>-1.
+         * A negative value sets this option to the maximum allowed value.
+         * @default 200
+         */
         maxReservedRemoteStreams?: number | undefined;
+        /**
+         * An optional callback that receives the `URL` instance passed to `connect` and the `options` object,
+         * and returns any `Duplex` stream that is to be used as the connection for this session.
+         */
         createConnection?: ((authority: url.URL, option: SessionOptions) => stream.Duplex) | undefined;
+        /**
+         * The protocol to connect with, if not set in the `authority`.
+         * Value may be either `'http:'` or `'https:'`.
+         * @default 'https:'
+         */
         protocol?: "http:" | "https:" | undefined;
     }
     export interface ServerSessionOptions<

package/generator-adapter/node_modules/@types/node/module.d.ts

@@ -225,12 +225,12 @@ declare module "module" {
              * See [load hook](https://nodejs.org/docs/latest-v22.x/api/module.html#loadurl-context-nextload).
              * @default undefined
              */
-            load?: LoadHook | undefined;
+            load?: LoadHookSync | undefined;
             /**
              * See [resolve hook](https://nodejs.org/docs/latest-v22.x/api/module.html#resolvespecifier-context-nextresolve).
              * @default undefined
              */
-            resolve?: ResolveHook | undefined;
+            resolve?: ResolveHookSync | undefined;
         }
         interface ModuleHooks {
             /**
@@ -429,6 +429,14 @@ declare module "module" {
                 context?: Partial<ResolveHookContext>,
             ) => ResolveFnOutput | Promise<ResolveFnOutput>,
         ) => ResolveFnOutput | Promise<ResolveFnOutput>;
+        type ResolveHookSync = (
+            specifier: string,
+            context: ResolveHookContext,
+            nextResolve: (
+                specifier: string,
+                context?: Partial<ResolveHookContext>,
+            ) => ResolveFnOutput,
+        ) => ResolveFnOutput;
         interface LoadHookContext {
             /**
              * Export conditions of the relevant `package.json`
@@ -444,7 +452,7 @@ declare module "module" {
             importAttributes: ImportAttributes;
         }
         interface LoadFnOutput {
-            format: ModuleFormat;
+            format: string | null | undefined;
             /**
              * A signal that this hook intends to terminate the chain of `resolve` hooks.
              * @default false
@@ -468,6 +476,34 @@ declare module "module" {
                 context?: Partial<LoadHookContext>,
             ) => LoadFnOutput | Promise<LoadFnOutput>,
         ) => LoadFnOutput | Promise<LoadFnOutput>;
+        type LoadHookSync = (
+            url: string,
+            context: LoadHookContext,
+            nextLoad: (
+                url: string,
+                context?: Partial<LoadHookContext>,
+            ) => LoadFnOutput,
+        ) => LoadFnOutput;
+        interface SourceMapsSupport {
+            /**
+             * If the source maps support is enabled
+             */
+            enabled: boolean;
+            /**
+             * If the support is enabled for files in `node_modules`.
+             */
+            nodeModules: boolean;
+            /**
+             * If the support is enabled for generated code from `eval` or `new Function`.
+             */
+            generatedCode: boolean;
+        }
+        /**
+         * This method returns whether the [Source Map v3](https://tc39.es/ecma426/) support for stack
+         * traces is enabled.
+         * @since v22.14.0
+         */
+        function getSourceMapsSupport(): SourceMapsSupport;
         /**
          * `path` is the resolved path for the file for which a corresponding source map
          * should be fetched.
@@ -475,6 +511,33 @@ declare module "module" {
          * @return Returns `module.SourceMap` if a source map is found, `undefined` otherwise.
          */
         function findSourceMap(path: string): SourceMap | undefined;
+        interface SetSourceMapsSupportOptions {
+            /**
+             * If enabling the support for files in `node_modules`.
+             * @default false
+             */
+            nodeModules?: boolean | undefined;
+            /**
+             * If enabling the support for generated code from `eval` or `new Function`.
+             * @default false
+             */
+            generatedCode?: boolean | undefined;
+        }
+        /**
+         * This function enables or disables the [Source Map v3](https://tc39.es/ecma426/) support for
+         * stack traces.
+         *
+         * It provides same features as launching Node.js process with commandline options
+         * `--enable-source-maps`, with additional options to alter the support for files
+         * in `node_modules` or generated codes.
+         *
+         * Only source maps in JavaScript files that are loaded after source maps has been
+         * enabled will be parsed and loaded. Preferably, use the commandline options
+         * `--enable-source-maps` to avoid losing track of source maps of modules loaded
+         * before this API call.
+         * @since v22.14.0
+         */
+        function setSourceMapsSupport(enabled: boolean, options?: SetSourceMapsSupportOptions): void;
         interface SourceMapConstructorOptions {
             /**
              * @since v21.0.0, v20.5.0
@@ -560,34 +623,67 @@ declare module "module" {
     global {
         interface ImportMeta {
             /**
-             * The directory name of the current module. This is the same as the `path.dirname()` of the `import.meta.filename`.
-             * **Caveat:** only present on `file:` modules.
+             * The directory name of the current module.
+             *
+             * This is the same as the `path.dirname()` of the `import.meta.filename`.
+             *
+             * > **Caveat**: only present on `file:` modules.
+             * @since v21.2.0, v20.11.0
              */
             dirname: string;
             /**
-             * The full absolute path and filename of the current module, with symlinks resolved.
+             * The full absolute path and filename of the current module, with
+             * symlinks resolved.
+             *
              * This is the same as the `url.fileURLToPath()` of the `import.meta.url`.
-             * **Caveat:** only local modules support this property. Modules not using the `file:` protocol will not provide it.
+             *
+             * > **Caveat** only local modules support this property. Modules not using the
+             * > `file:` protocol will not provide it.
+             * @since v21.2.0, v20.11.0
              */
             filename: string;
             /**
              * The absolute `file:` URL of the module.
+             *
+             * This is defined exactly the same as it is in browsers providing the URL of the
+             * current module file.
+             *
+             * This enables useful patterns such as relative file loading:
+             *
+             * ```js
+             * import { readFileSync } from 'node:fs';
+             * const buffer = readFileSync(new URL('./data.proto', import.meta.url));
+             * ```
              */
             url: string;
             /**
-             * Provides a module-relative resolution function scoped to each module, returning
-             * the URL string.
+             * `import.meta.resolve` is a module-relative resolution function scoped to
+             * each module, returning the URL string.
              *
-             * Second `parent` parameter is only used when the `--experimental-import-meta-resolve`
-             * command flag enabled.
+             * ```js
+             * const dependencyAsset = import.meta.resolve('component-lib/asset.css');
+             * // file:///app/node_modules/component-lib/asset.css
+             * import.meta.resolve('./dep.js');
+             * // file:///app/dep.js
+             * ```
              *
-             * @since v20.6.0
+             * All features of the Node.js module resolution are supported. Dependency
+             * resolutions are subject to the permitted exports resolutions within the package.
              *
-             * @param specifier The module specifier to resolve relative to `parent`.
-             * @param parent The absolute parent module URL to resolve from.
-             * @returns The absolute (`file:`) URL string for the resolved module.
-             */
-            resolve(specifier: string, parent?: string | URL | undefined): string;
+             * **Caveats**:
+             *
+             * * This can result in synchronous file-system operations, which
+             *   can impact performance similarly to `require.resolve`.
+             * * This feature is not available within custom loaders (it would
+             *   create a deadlock).
+             * @since v13.9.0, v12.16.0
+             * @param specifier The module specifier to resolve relative to the
+             * current module.
+             * @param parent An optional absolute parent module URL to resolve from.
+             * **Default:** `import.meta.url`
+             * @returns The absolute URL string that the specifier would resolve to.
+             */
+            resolve(specifier: string, parent?: string | URL): string;
         }
         namespace NodeJS {
             interface Module {
@@ -756,7 +852,6 @@ declare module "module" {
          */
         var require: NodeJS.Require;
         // Global-scope aliases for backwards compatibility with @types/node <13.0.x
-        // TODO: consider removing in a future major version update
         /** @deprecated Use `NodeJS.Module` instead. */
         interface NodeModule extends NodeJS.Module {}
         /** @deprecated Use `NodeJS.Require` instead. */

package/generator-adapter/node_modules/@types/node/net.d.ts

@@ -109,8 +109,8 @@ declare module "net" {
          * @since v0.1.90
          * @param [encoding='utf8'] Only used when data is `string`.
          */
-        write(buffer: Uint8Array | string, cb?: (err?: Error) => void): boolean;
-        write(str: Uint8Array | string, encoding?: BufferEncoding, cb?: (err?: Error) => void): boolean;
+        write(buffer: Uint8Array | string, cb?: (err?: Error | null) => void): boolean;
+        write(str: Uint8Array | string, encoding?: BufferEncoding, cb?: (err?: Error | null) => void): boolean;
         /**
          * Initiate a connection on a given socket.
          *
@@ -377,7 +377,7 @@ declare module "net" {
         addListener(event: "connectionAttempt", listener: (ip: string, port: number, family: number) => void): this;
         addListener(
             event: "connectionAttemptFailed",
-            listener: (ip: string, port: number, family: number) => void,
+            listener: (ip: string, port: number, family: number, error: Error) => void,
         ): this;
         addListener(
             event: "connectionAttemptTimeout",
@@ -397,7 +397,7 @@ declare module "net" {
         emit(event: "close", hadError: boolean): boolean;
         emit(event: "connect"): boolean;
         emit(event: "connectionAttempt", ip: string, port: number, family: number): boolean;
-        emit(event: "connectionAttemptFailed", ip: string, port: number, family: number): boolean;
+        emit(event: "connectionAttemptFailed", ip: string, port: number, family: number, error: Error): boolean;
         emit(event: "connectionAttemptTimeout", ip: string, port: number, family: number): boolean;
         emit(event: "data", data: Buffer): boolean;
         emit(event: "drain"): boolean;
@@ -410,7 +410,10 @@ declare module "net" {
         on(event: "close", listener: (hadError: boolean) => void): this;
         on(event: "connect", listener: () => void): this;
         on(event: "connectionAttempt", listener: (ip: string, port: number, family: number) => void): this;
-        on(event: "connectionAttemptFailed", listener: (ip: string, port: number, family: number) => void): this;
+        on(
+            event: "connectionAttemptFailed",
+            listener: (ip: string, port: number, family: number, error: Error) => void,
+        ): this;
         on(event: "connectionAttemptTimeout", listener: (ip: string, port: number, family: number) => void): this;
         on(event: "data", listener: (data: Buffer) => void): this;
         on(event: "drain", listener: () => void): this;
@@ -425,7 +428,10 @@ declare module "net" {
         once(event: string, listener: (...args: any[]) => void): this;
         once(event: "close", listener: (hadError: boolean) => void): this;
         once(event: "connectionAttempt", listener: (ip: string, port: number, family: number) => void): this;
-        once(event: "connectionAttemptFailed", listener: (ip: string, port: number, family: number) => void): this;
+        once(
+            event: "connectionAttemptFailed",
+            listener: (ip: string, port: number, family: number, error: Error) => void,
+        ): this;
         once(event: "connectionAttemptTimeout", listener: (ip: string, port: number, family: number) => void): this;
         once(event: "connect", listener: () => void): this;
         once(event: "data", listener: (data: Buffer) => void): this;
@@ -444,7 +450,7 @@ declare module "net" {
         prependListener(event: "connectionAttempt", listener: (ip: string, port: number, family: number) => void): this;
         prependListener(
             event: "connectionAttemptFailed",
-            listener: (ip: string, port: number, family: number) => void,
+            listener: (ip: string, port: number, family: number, error: Error) => void,
         ): this;
         prependListener(
             event: "connectionAttemptTimeout",
@@ -469,7 +475,7 @@ declare module "net" {
         ): this;
         prependOnceListener(
             event: "connectionAttemptFailed",
-            listener: (ip: string, port: number, family: number) => void,
+            listener: (ip: string, port: number, family: number, error: Error) => void,
         ): this;
         prependOnceListener(
             event: "connectionAttemptTimeout",
@@ -656,7 +662,7 @@ declare module "net" {
          * Callback should take two arguments `err` and `count`.
          * @since v0.9.7
          */
-        getConnections(cb: (error: Error | null, count: number) => void): void;
+        getConnections(cb: (error: Error | null, count: number) => void): this;
         /**
          * Opposite of `unref()`, calling `ref()` on a previously `unref`ed server will _not_ let the program exit if it's the only server left (the default behavior).
          * If the server is `ref`ed calling `ref()` again will have no effect.

package/generator-adapter/node_modules/@types/node/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@types/node",
-    "version": "22.15.3",
+    "version": "22.16.3",
     "description": "TypeScript definitions for node",
     "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/node",
     "license": "MIT",
@@ -220,6 +220,6 @@
         "undici-types": "~6.21.0"
     },
     "peerDependencies": {},
-    "typesPublisherContentHash": "2aecc93ec4fa0fcbf62f8df1fe665ab3615d3005c7b01703781b7e8c26655911",
+    "typesPublisherContentHash": "7159d16cfd01c052bbb85f0987775b21301e2769ae8b3305f8b90e868d05deea",
     "typeScriptVersion": "5.1"
 }

package/generator-adapter/node_modules/@types/node/perf_hooks.d.ts

@@ -866,12 +866,12 @@ declare module "perf_hooks" {
          * The minimum recordable value. Must be an integer value greater than 0.
          * @default 1
          */
-        min?: number | bigint | undefined;
+        lowest?: number | bigint | undefined;
         /**
          * The maximum recordable value. Must be an integer value greater than min.
          * @default Number.MAX_SAFE_INTEGER
          */
-        max?: number | bigint | undefined;
+        highest?: number | bigint | undefined;
         /**
          * The number of accuracy digits. Must be a number between 1 and 5.
          * @default 3

package/generator-adapter/node_modules/@types/node/process.d.ts

@@ -1566,13 +1566,11 @@ declare module "process" {
                  * See [`uv_get_constrained_memory`](https://docs.libuv.org/en/v1.x/misc.html#c.uv_get_constrained_memory) for more
                  * information.
                  * @since v19.6.0, v18.15.0
-                 * @experimental
                  */
                 constrainedMemory(): number;
                 /**
                  * Gets the amount of free memory that is still available to the process (in bytes).
                  * See [`uv_get_available_memory`](https://nodejs.org/docs/latest-v22.x/api/process.html#processavailablememory) for more information.
-                 * @experimental
                  * @since v20.13.0
                  */
                 availableMemory(): number;

package/generator-adapter/node_modules/@types/node/querystring.d.ts

@@ -37,9 +37,8 @@ declare module "querystring" {
             | string
             | number
             | boolean
-            | readonly string[]
-            | readonly number[]
-            | readonly boolean[]
+            | bigint
+            | ReadonlyArray<string | number | boolean | bigint>
             | null
         >
     {}

package/generator-adapter/node_modules/@types/node/repl.d.ts

@@ -37,12 +37,10 @@ declare module "repl" {
         terminal?: boolean | undefined;
         /**
          * The function to be used when evaluating each given line of input.
-         * Default: an async wrapper for the JavaScript `eval()` function. An `eval` function can
+         * **Default:** an async wrapper for the JavaScript `eval()` function. An `eval` function can
          * error with `repl.Recoverable` to indicate the input was incomplete and prompt for
-         * additional lines.
-         *
-         * @see https://nodejs.org/dist/latest-v22.x/docs/api/repl.html#repl_default_evaluation
-         * @see https://nodejs.org/dist/latest-v22.x/docs/api/repl.html#repl_custom_evaluation_functions
+         * additional lines. See the [custom evaluation functions](https://nodejs.org/dist/latest-v22.x/docs/api/repl.html#custom-evaluation-functions)
+         * section for more details.
          */
         eval?: REPLEval | undefined;
         /**

package/generator-adapter/node_modules/@types/node/sqlite.d.ts

@@ -166,6 +166,31 @@ declare module "node:sqlite" {
          */
         varargs?: boolean | undefined;
     }
+    interface AggregateOptions<T extends SQLInputValue = SQLInputValue> extends FunctionOptions {
+        /**
+         * The identity value for the aggregation function. This value is used when the aggregation
+         * function is initialized. When a `Function` is passed the identity will be its return value.
+         */
+        start: T | (() => T);
+        /**
+         * The function to call for each row in the aggregation. The
+         * function receives the current state and the row value. The return value of
+         * this function should be the new state.
+         */
+        step: (accumulator: T, ...args: SQLOutputValue[]) => T;
+        /**
+         * The function to call to get the result of the
+         * aggregation. The function receives the final state and should return the
+         * result of the aggregation.
+         */
+        result?: ((accumulator: T) => SQLInputValue) | undefined;
+        /**
+         * When this function is provided, the `aggregate` method will work as a window function.
+         * The function receives the current state and the dropped row value. The return value of this function should be the
+         * new state.
+         */
+        inverse?: ((accumulator: T, ...args: SQLOutputValue[]) => T) | 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.
@@ -181,6 +206,38 @@ declare module "node:sqlite" {
          * @param options Configuration options for the database connection.
          */
         constructor(path: string | Buffer | URL, options?: DatabaseSyncOptions);
+        /**
+         * Registers a new aggregate function with the SQLite database. This method is a wrapper around
+         * [`sqlite3_create_window_function()`](https://www.sqlite.org/c3ref/create_function.html).
+         *
+         * When used as a window function, the `result` function will be called multiple times.
+         *
+         * ```js
+         * import { DatabaseSync } from 'node:sqlite';
+         *
+         * const db = new DatabaseSync(':memory:');
+         * db.exec(`
+         *   CREATE TABLE t3(x, y);
+         *   INSERT INTO t3 VALUES ('a', 4),
+         *                         ('b', 5),
+         *                         ('c', 3),
+         *                         ('d', 8),
+         *                         ('e', 1);
+         * `);
+         *
+         * db.aggregate('sumint', {
+         *   start: 0,
+         *   step: (acc, value) => acc + value,
+         * });
+         *
+         * db.prepare('SELECT sumint(y) as total FROM t3').get(); // { total: 21 }
+         * ```
+         * @since v22.16.0
+         * @param name The name of the SQLite function to create.
+         * @param options Function configuration settings.
+         */
+        aggregate(name: string, options: AggregateOptions): void;
+        aggregate<T extends SQLInputValue>(name: string, options: AggregateOptions<T>): void;
         /**
          * Closes the database connection. An exception is thrown if the database is not
          * open. This method is a wrapper around [`sqlite3_close_v2()`](https://www.sqlite.org/c3ref/close.html).
@@ -203,6 +260,15 @@ declare module "node:sqlite" {
          * @param allow Whether to allow loading extensions.
          */
         enableLoadExtension(allow: boolean): void;
+        /**
+         * This method is a wrapper around [`sqlite3_db_filename()`](https://sqlite.org/c3ref/db_filename.html)
+         * @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,
+         * this method returns null.
+         */
+        location(dbName?: string): string | null;
         /**
          * This method allows one or more SQL statements to be executed without returning
          * any results. This method is useful when executing SQL statements read from a
@@ -234,6 +300,12 @@ declare module "node:sqlite" {
          * @since v22.15.0
          */
         readonly isOpen: boolean;
+        /**
+         * 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 v22.16.0
+         */
+        readonly isTransaction: boolean;
         /**
          * 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.
@@ -322,6 +394,38 @@ declare module "node:sqlite" {
          */
         close(): void;
     }
+    interface StatementColumnMetadata {
+        /**
+         * The unaliased name of the column in the origin
+         * table, or `null` if the column is the result of an expression or subquery.
+         * This property is the result of [`sqlite3_column_origin_name()`](https://www.sqlite.org/c3ref/column_database_name.html).
+         */
+        column: string | null;
+        /**
+         * The unaliased name of the origin database, or
+         * `null` if the column is the result of an expression or subquery. This
+         * property is the result of [`sqlite3_column_database_name()`](https://www.sqlite.org/c3ref/column_database_name.html).
+         */
+        database: string | null;
+        /**
+         * The name assigned to the column in the result set of a
+         * `SELECT` statement. This property is the result of
+         * [`sqlite3_column_name()`](https://www.sqlite.org/c3ref/column_name.html).
+         */
+        name: string;
+        /**
+         * The unaliased name of the origin table, or `null` if
+         * the column is the result of an expression or subquery. This property is the
+         * result of [`sqlite3_column_table_name()`](https://www.sqlite.org/c3ref/column_database_name.html).
+         */
+        table: string | null;
+        /**
+         * The declared data type of the column, or `null` if the
+         * column is the result of an expression or subquery. This property is the
+         * result of [`sqlite3_column_decltype()`](https://www.sqlite.org/c3ref/column_decltype.html).
+         */
+        type: string | null;
+    }
     interface StatementResultingChanges {
         /**
          * The number of rows modified, inserted, or deleted by the most recently completed `INSERT`, `UPDATE`, or `DELETE` statement.
@@ -366,6 +470,14 @@ declare module "node:sqlite" {
             namedParameters: Record<string, SQLInputValue>,
             ...anonymousParameters: SQLInputValue[]
         ): Record<string, SQLOutputValue>[];
+        /**
+         * This method is used to retrieve information about the columns returned by the
+         * prepared statement.
+         * @since v22.16.0
+         * @returns An array of objects. Each object corresponds to a column
+         * in the prepared statement, and contains the following properties:
+         */
+        columns(): StatementColumnMetadata[];
         /**
          * The source SQL text of the prepared statement with parameter
          * placeholders replaced by the values that were used during the most recent
@@ -465,6 +577,66 @@ declare module "node:sqlite" {
          */
         readonly sourceSQL: string;
     }
+    interface BackupOptions {
+        /**
+         * Name of the source database. This can be `'main'` (the default primary database) or any other
+         * database that have been added with [`ATTACH DATABASE`](https://www.sqlite.org/lang_attach.html)
+         * @default 'main'
+         */
+        source?: string | undefined;
+        /**
+         * Name of the target database. This can be `'main'` (the default primary database) or any other
+         * database that have been added with [`ATTACH DATABASE`](https://www.sqlite.org/lang_attach.html)
+         * @default 'main'
+         */
+        target?: string | undefined;
+        /**
+         * Number of pages to be transmitted in each batch of the backup.
+         * @default 100
+         */
+        rate?: number | undefined;
+        /**
+         * Callback function that will be called with the number of pages copied and the total number of
+         * pages.
+         */
+        progress?: ((progressInfo: BackupProgressInfo) => void) | undefined;
+    }
+    interface BackupProgressInfo {
+        totalPages: number;
+        remainingPages: number;
+    }
+    /**
+     * This method makes a database backup. This method abstracts the
+     * [`sqlite3_backup_init()`](https://www.sqlite.org/c3ref/backup_finish.html#sqlite3backupinit),
+     * [`sqlite3_backup_step()`](https://www.sqlite.org/c3ref/backup_finish.html#sqlite3backupstep)
+     * and [`sqlite3_backup_finish()`](https://www.sqlite.org/c3ref/backup_finish.html#sqlite3backupfinish) functions.
+     *
+     * The backed-up database can be used normally during the backup process. Mutations coming from the same connection - same
+     * `DatabaseSync` - object will be reflected in the backup right away. However, mutations from other connections will cause
+     * the backup process to restart.
+     *
+     * ```js
+     * import { backup, DatabaseSync } from 'node:sqlite';
+     *
+     * const sourceDb = new DatabaseSync('source.db');
+     * const totalPagesTransferred = await backup(sourceDb, 'backup.db', {
+     *   rate: 1, // Copy one page at a time.
+     *   progress: ({ totalPages, remainingPages }) => {
+     *     console.log('Backup in progress', { totalPages, remainingPages });
+     *   },
+     * });
+     *
+     * console.log('Backup completed', totalPagesTransferred);
+     * ```
+     * @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 resolves when the backup is completed and rejects if an error occurs.
+     */
+    function backup(sourceDb: DatabaseSync, path: string | Buffer | URL, options?: BackupOptions): Promise<void>;
     /**
      * @since v22.13.0
      */