cdk-common 2.0.1168 → 2.0.1170

package/node_modules/@types/form-data/node_modules/@types/node/process.d.ts

@@ -1938,6 +1938,28 @@ declare module "process" {
                  * @param maybeRefable An object that may be "unref'd".
                  */
                 unref(maybeRefable: any): void;
+                /**
+                 * Replaces the current process with a new process.
+                 *
+                 * This is achieved by using the `execve` POSIX function and therefore no memory or other
+                 * resources from the current process are preserved, except for the standard input,
+                 * standard output and standard error file descriptor.
+                 *
+                 * All other resources are discarded by the system when the processes are swapped, without triggering
+                 * any exit or close events and without running any cleanup handler.
+                 *
+                 * This function will never return, unless an error occurred.
+                 *
+                 * This function is not available on Windows or IBM i.
+                 * @since v22.15.0
+                 * @experimental
+                 * @param file The name or path of the executable file to run.
+                 * @param args List of string arguments. No argument can contain a null-byte (`\u0000`).
+                 * @param env Environment key-value pairs.
+                 * No key or value can contain a null-byte (`\u0000`).
+                 * **Default:** `process.env`.
+                 */
+                execve?(file: string, args?: readonly string[], env?: ProcessEnv): never;
                 /* EventEmitter */
                 addListener(event: "beforeExit", listener: BeforeExitListener): this;
                 addListener(event: "disconnect", listener: DisconnectListener): this;

package/node_modules/@types/form-data/node_modules/@types/node/readline.d.ts

@@ -51,7 +51,7 @@ declare module "readline" {
      * and is read from, the `input` stream.
      * @since v0.1.104
      */
-    export class Interface extends EventEmitter {
+    export class Interface extends EventEmitter implements Disposable {
         readonly terminal: boolean;
         /**
          * The current input data being processed by node.
@@ -208,6 +208,11 @@ declare module "readline" {
          * @since v0.1.98
          */
         close(): void;
+        /**
+         * Alias for `rl.close()`.
+         * @since v22.15.0
+         */
+        [Symbol.dispose](): void;
         /**
          * The `rl.write()` method will write either `data` or a key sequence identified
          * by `key` to the `output`. The `key` argument is supported only if `output` is

package/node_modules/@types/form-data/node_modules/@types/node/sqlite.d.ts

@@ -158,9 +158,10 @@ declare module "node:sqlite" {
          */
         useBigIntArguments?: boolean | undefined;
         /**
-         * If `true`, `function` can accept a variable number of
-         * arguments. If `false`, `function` must be invoked with exactly
-         * `function.length` arguments.
+         * If `true`, `function` may be invoked with any number of
+         * arguments (between zero and
+         * [`SQLITE_MAX_FUNCTION_ARG`](https://www.sqlite.org/limits.html#max_function_arg)). If `false`,
+         * `function` must be invoked with exactly `function.length` arguments.
          * @default false
          */
         varargs?: boolean | undefined;
@@ -170,16 +171,16 @@ declare module "node:sqlite" {
      * exposed by this class execute synchronously.
      * @since v22.5.0
      */
-    class DatabaseSync {
+    class DatabaseSync implements Disposable {
         /**
          * Constructs a new `DatabaseSync` instance.
-         * @param location The location of the database.
+         * @param path The path of the database.
          * A SQLite database can be stored in a file or completely [in memory](https://www.sqlite.org/inmemorydb.html).
-         * To use a file-backed database, the location should be a file path.
-         * To use an in-memory database, the location should be the special name `':memory:'`.
+         * To use a file-backed database, the path should be a file path.
+         * To use an in-memory database, the path should be the special name `':memory:'`.
          * @param options Configuration options for the database connection.
          */
-        constructor(location: string, options?: DatabaseSyncOptions);
+        constructor(path: string | Buffer | URL, options?: DatabaseSyncOptions);
         /**
          * 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).
@@ -217,16 +218,24 @@ declare module "node:sqlite" {
          * @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 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,
-            func: (...args: SupportedValueType[]) => SupportedValueType,
+            func: (...args: SQLOutputValue[]) => SQLInputValue,
         ): void;
-        function(name: string, func: (...args: SupportedValueType[]) => SupportedValueType): void;
+        function(name: string, func: (...args: SQLOutputValue[]) => SQLInputValue): 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
+         * Whether the database is currently open or not.
+         * @since v22.15.0
+         */
+        readonly isOpen: 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.
          * @since v22.5.0
          */
@@ -272,10 +281,17 @@ declare module "node:sqlite" {
          * ```
          * @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.
+         * @returns Whether the changeset was applied successfully without being aborted.
          * @since v22.12.0
          */
         applyChangeset(changeset: Uint8Array, options?: ApplyChangesetOptions): boolean;
+        /**
+         * 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;
     }
     /**
      * @since v22.12.0
@@ -424,6 +440,13 @@ declare module "node:sqlite" {
          * @param enabled Enables or disables support for binding named parameters without the prefix character.
          */
         setAllowBareNamedParameters(enabled: boolean): void;
+        /**
+         * By default, if an unknown name is encountered while binding parameters, an
+         * exception is thrown. This method allows unknown named parameters to be ignored.
+         * @since v22.15.0
+         * @param enabled Enables or disables support for unknown named parameters.
+         */
+        setAllowUnknownNamedParameters(enabled: boolean): void;
         /**
          * When reading from the database, SQLite `INTEGER`s are mapped to JavaScript
          * numbers by default. However, SQLite `INTEGER`s can store values larger than

package/node_modules/@types/form-data/node_modules/@types/node/test.d.ts

@@ -648,11 +648,12 @@ declare module "node:test" {
          */
         readonly name: string;
         /**
-         * Used to set the number of assertions and subtests that are expected to run within the test.
-         * If the number of assertions and subtests that run does not match the expected count, the test will fail.
+         * This function is used to set the number of assertions and subtests that are expected to run
+         * within the test. If the number of assertions and subtests that run does not match the
+         * expected count, the test will fail.
+         *
+         * > Note: To make sure assertions are tracked, `t.assert` must be used instead of `assert` directly.
          *
-         * To make sure assertions are tracked, the assert functions on `context.assert` must be used,
-         * instead of importing from the `node:assert` module.
          * ```js
          * test('top level test', (t) => {
          *   t.plan(2);
@@ -661,7 +662,9 @@ declare module "node:test" {
          * });
          * ```
          *
-         * When working with asynchronous code, the `plan` function can be used to ensure that the correct number of assertions are run:
+         * When working with asynchronous code, the `plan` function can be used to ensure that the
+         * correct number of assertions are run:
+         *
          * ```js
          * test('planning with streams', (t, done) => {
          *   function* generate() {
@@ -675,14 +678,35 @@ declare module "node:test" {
          *   stream.on('data', (chunk) => {
          *     t.assert.strictEqual(chunk, expected.shift());
          *   });
+         *
          *   stream.on('end', () => {
          *     done();
          *   });
          * });
          * ```
+         *
+         * When using the `wait` option, you can control how long the test will wait for the expected assertions.
+         * For example, setting a maximum wait time ensures that the test will wait for asynchronous assertions
+         * to complete within the specified timeframe:
+         *
+         * ```js
+         * test('plan with wait: 2000 waits for async assertions', (t) => {
+         *   t.plan(1, { wait: 2000 }); // Waits for up to 2 seconds for the assertion to complete.
+         *
+         *   const asyncActivity = () => {
+         *     setTimeout(() => {
+         *          *       t.assert.ok(true, 'Async assertion completed within the wait time');
+         *     }, 1000); // Completes after 1 second, within the 2-second wait time.
+         *   };
+         *
+         *   asyncActivity(); // The test will pass because the assertion is completed in time.
+         * });
+         * ```
+         *
+         * Note: If a `wait` timeout is specified, it begins counting down only after the test function finishes executing.
          * @since v22.2.0
          */
-        plan(count: number): void;
+        plan(count: number, options?: TestContextPlanOptions): void;
         /**
          * If `shouldRunOnlyTests` is truthy, the test context will only run tests that
          * have the `only` option set. Otherwise, all tests are run. If Node.js was not
@@ -858,6 +882,20 @@ declare module "node:test" {
          */
         serializers?: ReadonlyArray<(value: any) => any> | undefined;
     }
+    interface TestContextPlanOptions {
+        /**
+         * The wait time for the plan:
+         * * If `true`, the plan waits indefinitely for all assertions and subtests to run.
+         * * If `false`, the plan performs an immediate check after the test function completes,
+         * without waiting for any pending assertions or subtests.
+         * Any assertions or subtests that complete after this check will not be counted towards the plan.
+         * * If a number, it specifies the maximum wait time in milliseconds
+         * before timing out while waiting for expected assertions and subtests to be matched.
+         * If the timeout is reached, the test will fail.
+         * @default false
+         */
+        wait?: boolean | number | undefined;
+    }
     interface TestContextWaitForOptions {
         /**
          * The number of milliseconds to wait after an unsuccessful
@@ -1971,6 +2009,11 @@ interface TestDequeue extends TestLocationInfo {
      * The nesting level of the test.
      */
     nesting: number;
+    /**
+     * The test type. Either `'suite'` or `'test'`.
+     * @since v22.15.0
+     */
+    type: "suite" | "test";
 }
 interface TestEnqueue extends TestLocationInfo {
     /**
@@ -1981,6 +2024,11 @@ interface TestEnqueue extends TestLocationInfo {
      * The nesting level of the test.
      */
     nesting: number;
+    /**
+     * The test type. Either `'suite'` or `'test'`.
+     * @since v22.15.0
+     */
+    type: "suite" | "test";
 }
 interface TestFail extends TestLocationInfo {
     /**

package/node_modules/@types/form-data/node_modules/@types/node/tls.d.ts

@@ -1158,6 +1158,31 @@ declare module "tls" {
      * @since v0.11.13
      */
     function createSecureContext(options?: SecureContextOptions): SecureContext;
+    /**
+     * Returns an array containing the CA certificates from various sources, depending on `type`:
+     *
+     * * `"default"`: return the CA certificates that will be used by the Node.js TLS clients by default.
+     *   * When `--use-bundled-ca` is enabled (default), or `--use-openssl-ca` is not enabled,
+     *     this would include CA certificates from the bundled Mozilla CA store.
+     *   * When `--use-system-ca` is enabled, this would also include certificates from the system's
+     *     trusted store.
+     *   * When `NODE_EXTRA_CA_CERTS` is used, this would also include certificates loaded from the specified
+     *     file.
+     * * `"system"`: return the CA certificates that are loaded from the system's trusted store, according
+     *   to rules set by `--use-system-ca`. This can be used to get the certificates from the system
+     *   when `--use-system-ca` is not enabled.
+     * * `"bundled"`: return the CA certificates from the bundled Mozilla CA store. This would be the same
+     *   as `tls.rootCertificates`.
+     * * `"extra"`: return the CA certificates loaded from `NODE_EXTRA_CA_CERTS`. It's an empty array if
+     *   `NODE_EXTRA_CA_CERTS` is not set.
+     * @since v22.15.0
+     * @param type The type of CA certificates that will be returned. Valid values
+     * are `"default"`, `"system"`, `"bundled"` and `"extra"`.
+     * **Default:** `"default"`.
+     * @returns An array of PEM-encoded certificates. The array may contain duplicates
+     * if the same certificate is repeatedly stored in multiple sources.
+     */
+    function getCACertificates(type?: "default" | "system" | "bundled" | "extra"): string[];
     /**
      * Returns an array with the names of the supported TLS ciphers. The names are
      * lower-case for historical reasons, but must be uppercased to be used in

package/node_modules/@types/form-data/node_modules/@types/node/ts5.6/buffer.buffer.d.ts

@@ -158,6 +158,7 @@ declare module "buffer" {
              * @param encoding The encoding of `string`. **Default:** `'utf8'`.
              */
             from(string: WithImplicitCoercion<string>, encoding?: BufferEncoding): Buffer;
+            from(arrayOrString: WithImplicitCoercion<ArrayLike<number> | string>): Buffer;
             /**
              * Creates a new Buffer using the passed {data}
              * @param values to create a new Buffer