cloudstructs 0.9.26 → 0.9.28

package/node_modules/@types/cacheable-request/node_modules/@types/node/net.d.ts

@@ -65,6 +65,7 @@ declare module "net" {
          * @since v18.13.0
          */
         autoSelectFamilyAttemptTimeout?: number | undefined;
+        blockList?: BlockList | undefined;
     }
     interface IpcSocketConnectOpts {
         path: string;
@@ -486,17 +487,18 @@ declare module "net" {
         prependOnceListener(event: "timeout", listener: () => void): this;
     }
     interface ListenOptions extends Abortable {
-        port?: number | undefined;
-        host?: string | undefined;
         backlog?: number | undefined;
-        path?: string | undefined;
         exclusive?: boolean | undefined;
-        readableAll?: boolean | undefined;
-        writableAll?: boolean | undefined;
+        host?: string | undefined;
         /**
          * @default false
          */
         ipv6Only?: boolean | undefined;
+        reusePort?: boolean | undefined;
+        path?: string | undefined;
+        port?: number | undefined;
+        readableAll?: boolean | undefined;
+        writableAll?: boolean | undefined;
     }
     interface ServerOpts {
         /**
@@ -534,6 +536,15 @@ declare module "net" {
          * @since v18.17.0, v20.1.0
          */
         highWaterMark?: number | undefined;
+        /**
+         * `blockList` can be used for disabling inbound
+         * access to specific IP addresses, IP ranges, or IP subnets. This does not
+         * work if the server is behind a reverse proxy, NAT, etc. because the address
+         * checked against the block list is the address of the proxy, or the one
+         * specified by the NAT.
+         * @since v22.13.0
+         */
+        blockList?: BlockList | undefined;
     }
     interface DropArgument {
         localAddress?: string;
@@ -785,6 +796,12 @@ declare module "net" {
          * @since v15.0.0, v14.18.0
          */
         rules: readonly string[];
+        /**
+         * Returns `true` if the `value` is a `net.BlockList`.
+         * @since v22.13.0
+         * @param value Any JS value
+         */
+        static isBlockList(value: unknown): value is BlockList;
     }
     interface TcpNetConnectOpts extends TcpSocketConnectOpts, SocketConstructorOpts {
         timeout?: number | undefined;
@@ -997,6 +1014,14 @@ declare module "net" {
          * @since v15.14.0, v14.18.0
          */
         readonly flowlabel: number;
+        /**
+         * @since v22.13.0
+         * @param input An input string containing an IP address and optional port,
+         * e.g. `123.1.2.3:1234` or `[1::1]:1234`.
+         * @returns Returns a `SocketAddress` if parsing was successful.
+         * Otherwise returns `undefined`.
+         */
+        static parse(input: string): SocketAddress | undefined;
     }
 }
 declare module "node:net" {

package/node_modules/@types/cacheable-request/node_modules/@types/node/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@types/node",
-    "version": "22.10.5",
+    "version": "22.13.5",
     "description": "TypeScript definitions for node",
     "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/node",
     "license": "MIT",
@@ -215,6 +215,6 @@
         "undici-types": "~6.20.0"
     },
     "peerDependencies": {},
-    "typesPublisherContentHash": "5204c15eb02bc9a74afae771b0dc25867021c6aa886a7aad0f8c75fe7571881e",
+    "typesPublisherContentHash": "f50d94abf6b192ce8d4087c8e3714bfeea42915f01b0f6338f726e5286a67f3a",
     "typeScriptVersion": "5.0"
 }

package/node_modules/@types/cacheable-request/node_modules/@types/node/perf_hooks.d.ts

@@ -594,6 +594,11 @@ declare module "perf_hooks" {
                     buffered?: boolean | undefined;
                 },
         ): void;
+        /**
+         * @since v16.0.0
+         * @returns Current list of entries stored in the performance observer, emptying it out.
+         */
+        takeRecords(): PerformanceEntry[];
     }
     /**
      * Provides detailed network timing data regarding the loading of an application's resources.

package/node_modules/@types/cacheable-request/node_modules/@types/node/process.d.ts

@@ -186,7 +186,10 @@ declare module "process" {
                 readonly inspector: boolean;
                 /**
                  * A boolean value that is `true` if the current Node.js build includes support for IPv6.
+                 *
+                 * Since all Node.js builds have IPv6 support, this value is always `true`.
                  * @since v0.5.3
+                 * @deprecated This property is always true, and any checks based on it are redundant.
                  */
                 readonly ipv6: boolean;
                 /**
@@ -202,17 +205,29 @@ declare module "process" {
                 readonly tls: boolean;
                 /**
                  * A boolean value that is `true` if the current Node.js build includes support for ALPN in TLS.
+                 *
+                 * In Node.js 11.0.0 and later versions, the OpenSSL dependencies feature unconditional ALPN support.
+                 * This value is therefore identical to that of `process.features.tls`.
                  * @since v4.8.0
+                 * @deprecated Use `process.features.tls` instead.
                  */
                 readonly tls_alpn: boolean;
                 /**
                  * A boolean value that is `true` if the current Node.js build includes support for OCSP in TLS.
+                 *
+                 * In Node.js 11.0.0 and later versions, the OpenSSL dependencies feature unconditional OCSP support.
+                 * This value is therefore identical to that of `process.features.tls`.
                  * @since v0.11.13
+                 * @deprecated Use `process.features.tls` instead.
                  */
                 readonly tls_ocsp: boolean;
                 /**
                  * A boolean value that is `true` if the current Node.js build includes support for SNI in TLS.
+                 *
+                 * In Node.js 11.0.0 and later versions, the OpenSSL dependencies feature unconditional SNI support.
+                 * This value is therefore identical to that of `process.features.tls`.
                  * @since v0.5.3
+                 * @deprecated Use `process.features.tls` instead.
                  */
                 readonly tls_sni: boolean;
                 /**
@@ -223,8 +238,10 @@ declare module "process" {
                 readonly typescript: "strip" | "transform" | false;
                 /**
                  * A boolean value that is `true` if the current Node.js build includes support for libuv.
-                 * Since it's currently not possible to build Node.js without libuv, this value is always `true`.
+                 *
+                 * Since it's not possible to build Node.js without libuv, this value is always `true`.
                  * @since v0.5.3
+                 * @deprecated This property is always true, and any checks based on it are redundant.
                  */
                 readonly uv: boolean;
             }
@@ -333,11 +350,43 @@ declare module "process" {
                 TZ?: string;
             }
             interface HRTime {
+                /**
+                 * This is the legacy version of {@link process.hrtime.bigint()}
+                 * before bigint was introduced in JavaScript.
+                 *
+                 * The `process.hrtime()` method returns the current high-resolution real time in a `[seconds, nanoseconds]` tuple `Array`,
+                 * where `nanoseconds` is the remaining part of the real time that can't be represented in second precision.
+                 *
+                 * `time` is an optional parameter that must be the result of a previous `process.hrtime()` call to diff with the current time.
+                 * If the parameter passed in is not a tuple `Array`, a TypeError will be thrown.
+                 * Passing in a user-defined array instead of the result of a previous call to `process.hrtime()` will lead to undefined behavior.
+                 *
+                 * These times are relative to an arbitrary time in the past,
+                 * and not related to the time of day and therefore not subject to clock drift.
+                 * The primary use is for measuring performance between intervals:
+                 * ```js
+                 * const { hrtime } = require('node:process');
+                 * const NS_PER_SEC = 1e9;
+                 * const time = hrtime();
+                 * // [ 1800216, 25 ]
+                 *
+                 * setTimeout(() => {
+                 *   const diff = hrtime(time);
+                 *   // [ 1, 552 ]
+                 *
+                 *   console.log(`Benchmark took ${diff[0] * NS_PER_SEC + diff[1]} nanoseconds`);
+                 *   // Benchmark took 1000000552 nanoseconds
+                 * }, 1000);
+                 * ```
+                 * @since 0.7.6
+                 * @legacy Use {@link process.hrtime.bigint()} instead.
+                 * @param time The result of a previous call to `process.hrtime()`
+                 */
                 (time?: [number, number]): [number, number];
                 /**
-                 * The `bigint` version of the `{@link hrtime()}` method returning the current high-resolution real time in nanoseconds as a `bigint`.
+                 * The `bigint` version of the {@link process.hrtime()} method returning the current high-resolution real time in nanoseconds as a `bigint`.
                  *
-                 * Unlike `{@link hrtime()}`, it does not support an additional time argument since the difference can just be computed directly by subtraction of the two `bigint`s.
+                 * Unlike {@link process.hrtime()}, it does not support an additional time argument since the difference can just be computed directly by subtraction of the two `bigint`s.
                  * ```js
                  * import { hrtime } from 'node:process';
                  *
@@ -352,6 +401,7 @@ declare module "process" {
                  *   // Benchmark took 1154389282 nanoseconds
                  * }, 1000);
                  * ```
+                 * @since v10.7.0
                  */
                 bigint(): bigint;
             }
@@ -1643,7 +1693,7 @@ declare module "process" {
                  */
                 nextTick(callback: Function, ...args: any[]): void;
                 /**
-                 * This API is available through the [--experimental-permission](https://nodejs.org/api/cli.html#--experimental-permission) flag.
+                 * This API is available through the [--permission](https://nodejs.org/api/cli.html#--permission) flag.
                  *
                  * `process.permission` is an object whose methods are used to manage permissions for the current process.
                  * Additional documentation is available in the [Permission Model](https://nodejs.org/api/permissions.html#permission-model).

package/node_modules/@types/cacheable-request/node_modules/@types/node/sea.d.ts

@@ -149,5 +149,5 @@ declare module "node:sea" {
      * writes to the returned array buffer is likely to result in a crash.
      * @since v20.12.0
      */
-    function getRawAsset(key: AssetKey): string | ArrayBuffer;
+    function getRawAsset(key: AssetKey): ArrayBuffer;
 }

package/node_modules/@types/cacheable-request/node_modules/@types/node/sqlite.d.ts

@@ -10,7 +10,7 @@
  * work:
  *
  * ```js
- * import sqlite from 'node:sqlite';
+ * import sqlite from 'sqlite';
  * ```
  *
  * The following example shows the basic usage of the `node:sqlite` module to open
@@ -43,6 +43,7 @@
  * @see [source](https://github.com/nodejs/node/blob/v22.x/lib/sqlite.js)
  */
 declare module "node:sqlite" {
+    type SupportedValueType = null | number | bigint | string | Uint8Array;
     interface DatabaseSyncOptions {
         /**
          * If `true`, the database is opened by the constructor. When
@@ -70,6 +71,76 @@ declare module "node:sqlite" {
          * @default false
          */
         enableDoubleQuotedStringLiterals?: boolean | undefined;
+        /**
+         * If `true`, the database is opened in read-only mode.
+         * If the database does not exist, opening it will fail.
+         * @since v22.12.0
+         * @default false
+         */
+        readOnly?: boolean | undefined;
+        /**
+         * If `true`, the `loadExtension` SQL function
+         * and the `loadExtension()` method are enabled.
+         * You can call `enableLoadExtension(false)` later to disable this feature.
+         * @since v22.13.0
+         * @default false
+         */
+        allowExtension?: boolean | undefined;
+    }
+    interface CreateSessionOptions {
+        /**
+         * A specific table to track changes for. By default, changes to all tables are tracked.
+         * @since v22.12.0
+         */
+        table?: string | undefined;
+        /**
+         * Name of the database to track. This is useful when multiple databases have been added using
+         * [`ATTACH DATABASE`](https://www.sqlite.org/lang_attach.html).
+         * @since v22.12.0
+         * @default 'main'
+         */
+        db?: string | undefined;
+    }
+    interface ApplyChangesetOptions {
+        /**
+         * 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;
+        /**
+         * Determines how conflicts are handled. **Default**: `SQLITE_CHANGESET_ABORT`.
+         * @since v22.12.0
+         */
+        onConflict?: number | undefined;
+    }
+    interface FunctionOptions {
+        /**
+         * If `true`, the [`SQLITE_DETERMINISTIC`](https://www.sqlite.org/c3ref/c_deterministic.html) flag is
+         * set on the created function.
+         * @default false
+         */
+        deterministic?: boolean | undefined;
+        /**
+         * If `true`, the [`SQLITE_DIRECTONLY`](https://www.sqlite.org/c3ref/c_directonly.html) flag is set on
+         * the created function.
+         * @default false
+         */
+        directOnly?: boolean | undefined;
+        /**
+         * If `true`, integer arguments to `function`
+         * are converted to `BigInt`s. If `false`, integer arguments are passed as
+         * JavaScript numbers.
+         * @default false
+         */
+        useBigIntArguments?: boolean | undefined;
+        /**
+         * If `true`, `function` can accept a variable number of
+         * arguments. If `false`, `function` must be invoked with exactly
+         * `function.length` arguments.
+         * @default false
+         */
+        varargs?: boolean | undefined;
     }
     /**
      * This class represents a single [connection](https://www.sqlite.org/c3ref/sqlite3.html) to a SQLite database. All APIs
@@ -92,6 +163,22 @@ declare module "node:sqlite" {
          * @since v22.5.0
          */
         close(): void;
+        /**
+         * 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.
+         * @since v22.13.0
+         * @param path The path to the shared library to load.
+         */
+        loadExtension(path: string): void;
+        /**
+         * Enables or disables the `loadExtension` SQL function, and the `loadExtension()`
+         * method. When `allowExtension` is `false` when constructing, you cannot enable
+         * loading extensions for security reasons.
+         * @since v22.13.0
+         * @param allow Whether to allow loading extensions.
+         */
+        enableLoadExtension(allow: boolean): void;
         /**
          * 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
@@ -100,6 +187,21 @@ declare module "node:sqlite" {
          * @param sql A SQL string to execute.
          */
         exec(sql: string): void;
+        /**
+         * This method is used to create SQLite user-defined functions. This method is a
+         * wrapper around [`sqlite3_create_function_v2()`](https://www.sqlite.org/c3ref/create_function.html).
+         * @since v22.13.0
+         * @param name The name of the SQLite function to create.
+         * @param options Optional configuration settings for the function.
+         * @param func The JavaScript function to call when the SQLite
+         * function is invoked.
+         */
+        function(
+            name: string,
+            options: FunctionOptions,
+            func: (...args: SupportedValueType[]) => SupportedValueType,
+        ): void;
+        function(name: string, func: (...args: SupportedValueType[]) => SupportedValueType): void;
         /**
          * Opens the database specified in the `location` 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.
@@ -114,8 +216,73 @@ declare module "node:sqlite" {
          * @return The prepared statement.
          */
         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
+         * [`sqlite3session_attach()`](https://www.sqlite.org/session/sqlite3session_attach.html).
+         * @param options The configuration options for the session.
+         * @returns A session handle.
+         * @since v22.12.0
+         */
+        createSession(options?: CreateSessionOptions): Session;
+        /**
+         * An exception is thrown if the database is not
+         * open. This method is a wrapper around
+         * [`sqlite3changeset_apply()`](https://www.sqlite.org/session/sqlite3changeset_apply.html).
+         *
+         * ```js
+         * const sourceDb = new DatabaseSync(':memory:');
+         * const targetDb = new DatabaseSync(':memory:');
+         *
+         * sourceDb.exec('CREATE TABLE data(key INTEGER PRIMARY KEY, value TEXT)');
+         * targetDb.exec('CREATE TABLE data(key INTEGER PRIMARY KEY, value TEXT)');
+         *
+         * const session = sourceDb.createSession();
+         *
+         * const insert = sourceDb.prepare('INSERT INTO data (key, value) VALUES (?, ?)');
+         * insert.run(1, 'hello');
+         * insert.run(2, 'world');
+         *
+         * const changeset = session.changeset();
+         * targetDb.applyChangeset(changeset);
+         * // Now that the changeset has been applied, targetDb contains the same data as sourceDb.
+         * ```
+         * @param changeset A binary changeset or patchset.
+         * @param options The configuration options for how the changes will be applied.
+         * @returns Whether the changeset was applied succesfully without being aborted.
+         * @since v22.12.0
+         */
+        applyChangeset(changeset: Uint8Array, options?: ApplyChangesetOptions): boolean;
+    }
+    /**
+     * @since v22.12.0
+     */
+    interface Session {
+        /**
+         * Retrieves a changeset containing all changes since the changeset was created. Can be called multiple times.
+         * An exception is thrown if the database or the session is not open. This method is a wrapper around
+         * [`sqlite3session_changeset()`](https://www.sqlite.org/session/sqlite3session_changeset.html).
+         * @returns Binary changeset that can be applied to other databases.
+         * @since v22.12.0
+         */
+        changeset(): Uint8Array;
+        /**
+         * Similar to the method above, but generates a more compact patchset. See
+         * [Changesets and Patchsets](https://www.sqlite.org/sessionintro.html#changesets_and_patchsets)
+         * in the documentation of SQLite. An exception is thrown if the database or the session is not open. This method is a
+         * wrapper around
+         * [`sqlite3session_patchset()`](https://www.sqlite.org/session/sqlite3session_patchset.html).
+         * @returns Binary patchset that can be applied to other databases.
+         * @since v22.12.0
+         */
+        patchset(): Uint8Array;
+        /**
+         * Closes the session. An exception is thrown if the database or the session is not open. This method is a
+         * wrapper around
+         * [`sqlite3session_delete()`](https://www.sqlite.org/session/sqlite3session_delete.html).
+         */
+        close(): void;
     }
-    type SupportedValueType = null | number | bigint | string | Uint8Array;
     interface StatementResultingChanges {
         /**
          * The number of rows modified, inserted, or deleted by the most recently completed `INSERT`, `UPDATE`, or `DELETE` statement.
@@ -181,6 +348,24 @@ declare module "node:sqlite" {
          */
         get(...anonymousParameters: SupportedValueType[]): unknown;
         get(namedParameters: Record<string, SupportedValueType>, ...anonymousParameters: SupportedValueType[]): unknown;
+        /**
+         * This method executes a prepared statement and returns an iterator of
+         * objects. If the prepared statement does not return any results, this method
+         * returns an empty iterator. The prepared statement [parameters are bound](https://www.sqlite.org/c3ref/bind_blob.html) using
+         * the values in `namedParameters` and `anonymousParameters`.
+         * @since v22.13.0
+         * @param namedParameters An optional object used to bind named parameters.
+         * The keys of this object are used to configure the mapping.
+         * @param anonymousParameters Zero or more values to bind to anonymous parameters.
+         * @returns An iterable iterator of objects. Each object corresponds to a row
+         * returned by executing the prepared statement. The keys and values of each
+         * object correspond to the column names and values of the row.
+         */
+        iterate(...anonymousParameters: SupportedValueType[]): NodeJS.Iterator<unknown>;
+        iterate(
+            namedParameters: Record<string, SupportedValueType>,
+            ...anonymousParameters: SupportedValueType[]
+        ): NodeJS.Iterator<unknown>;
         /**
          * This method executes a prepared statement and returns an object summarizing the
          * resulting changes. The prepared statement [parameters are bound](https://www.sqlite.org/c3ref/bind_blob.html) using the
@@ -231,4 +416,24 @@ declare module "node:sqlite" {
          */
         readonly sourceSQL: string;
     }
+    /**
+     * @since v22.13.0
+     */
+    namespace constants {
+        /**
+         * Conflicting changes are omitted.
+         * @since v22.12.0
+         */
+        const SQLITE_CHANGESET_OMIT: number;
+        /**
+         * Conflicting changes replace existing values.
+         * @since v22.12.0
+         */
+        const SQLITE_CHANGESET_REPLACE: number;
+        /**
+         * Abort when a change encounters a conflict and roll back database.
+         * @since v22.12.0
+         */
+        const SQLITE_CHANGESET_ABORT: number;
+    }
 }

package/node_modules/@types/cacheable-request/node_modules/@types/node/stream.d.ts

@@ -981,7 +981,12 @@ declare module "stream" {
              * @since v17.0.0
              * @experimental
              */
-            static toWeb(streamReadable: Readable): streamWeb.ReadableStream;
+            static toWeb(
+                streamReadable: Readable,
+                options?: {
+                    strategy?: streamWeb.QueuingStrategy | undefined;
+                },
+            ): streamWeb.ReadableStream;
         }
         interface WritableOptions extends StreamOptions<Writable> {
             decodeStrings?: boolean | undefined;