aws-delivlib 14.15.64 → 14.15.66

package/lib/publishing/github/node_modules/@types/jsonwebtoken/node_modules/@types/node/module.d.ts

@@ -128,12 +128,54 @@ declare module "module" {
          */
         function getCompileCacheDir(): string | undefined;
         /**
-         * @since v23.2.0, v22.14.0
+         * ```text
+         * /path/to/project
+         *   ├ packages/
+         *     ├ bar/
+         *       ├ bar.js
+         *       └ package.json // name = '@foo/bar'
+         *     └ qux/
+         *       ├ node_modules/
+         *         └ some-package/
+         *           └ package.json // name = 'some-package'
+         *       ├ qux.js
+         *       └ package.json // name = '@foo/qux'
+         *   ├ main.js
+         *   └ package.json // name = '@foo'
+         * ```
+         * ```js
+         * // /path/to/project/packages/bar/bar.js
+         * import { findPackageJSON } from 'node:module';
+         *
+         * findPackageJSON('..', import.meta.url);
+         * // '/path/to/project/package.json'
+         * // Same result when passing an absolute specifier instead:
+         * findPackageJSON(new URL('../', import.meta.url));
+         * findPackageJSON(import.meta.resolve('../'));
+         *
+         * findPackageJSON('some-package', import.meta.url);
+         * // '/path/to/project/packages/bar/node_modules/some-package/package.json'
+         * // When passing an absolute specifier, you might get a different result if the
+         * // resolved module is inside a subfolder that has nested `package.json`.
+         * findPackageJSON(import.meta.resolve('some-package'));
+         * // '/path/to/project/packages/bar/node_modules/some-package/some-subfolder/package.json'
+         *
+         * findPackageJSON('@foo/qux', import.meta.url);
+         * // '/path/to/project/packages/qux/package.json'
+         * ```
+         * @since v22.14.0
+         * @param specifier The specifier for the module whose `package.json` to
+         * retrieve. When passing a _bare specifier_, the `package.json` at the root of
+         * the package is returned. When passing a _relative specifier_ or an _absolute specifier_,
+         * the closest parent `package.json` is returned.
+         * @param base The absolute location (`file:` URL string or FS path) of the
+         * containing  module. For CJS, use `__filename` (not `__dirname`!); for ESM, use
+         * `import.meta.url`. You do not need to pass it if `specifier` is an _absolute specifier_.
+         * @returns A path if the `package.json` is found. When `startLocation`
+         * is a package, the package's root `package.json`; when a relative or unresolved, the closest
+         * `package.json` to the `startLocation`.
          */
-        function findPackageJSON(
-            specifier: string | URL,
-            base?: string | URL,
-        ): undefined | string;
+        function findPackageJSON(specifier: string | URL, base?: string | URL): string | undefined;
         /**
          * @since v18.6.0, v16.17.0
          */
@@ -162,6 +204,9 @@ declare module "module" {
          * Register a module that exports hooks that customize Node.js module
          * resolution and loading behavior. See
          * [Customization hooks](https://nodejs.org/docs/latest-v22.x/api/module.html#customization-hooks).
+         *
+         * This feature requires `--allow-worker` if used with the
+         * [Permission Model](https://nodejs.org/docs/latest-v22.x/api/permissions.html#permission-model).
          * @since v20.6.0, v18.19.0
          * @param specifier Customization hooks to be registered; this should be
          * the same string that would be passed to `import()`, except that if it is

package/lib/publishing/github/node_modules/@types/jsonwebtoken/node_modules/@types/node/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@types/node",
-    "version": "22.13.14",
+    "version": "22.14.0",
     "description": "TypeScript definitions for node",
     "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/node",
     "license": "MIT",
@@ -212,9 +212,9 @@
     },
     "scripts": {},
     "dependencies": {
-        "undici-types": "~6.20.0"
+        "undici-types": "~6.21.0"
     },
     "peerDependencies": {},
-    "typesPublisherContentHash": "af64bfc0a656bf0a8361fdb57a05eaae0728c100c8458bc316201b2b7e34e55c",
-    "typeScriptVersion": "5.0"
+    "typesPublisherContentHash": "85380e858018285cbe47b1f83eb49c9bd791be4b6f059c2ae75b99b5b202ea93",
+    "typeScriptVersion": "5.1"
 }

package/lib/publishing/github/node_modules/@types/jsonwebtoken/node_modules/@types/node/process.d.ts

@@ -1910,6 +1910,34 @@ declare module "process" {
                  * @since v0.8.0
                  */
                 traceDeprecation: boolean;
+                /**
+                 * An object is "refable" if it implements the Node.js "Refable protocol".
+                 * Specifically, this means that the object implements the `Symbol.for('nodejs.ref')`
+                 * and `Symbol.for('nodejs.unref')` methods. "Ref'd" objects will keep the Node.js
+                 * event loop alive, while "unref'd" objects will not. Historically, this was
+                 * implemented by using `ref()` and `unref()` methods directly on the objects.
+                 * This pattern, however, is being deprecated in favor of the "Refable protocol"
+                 * in order to better support Web Platform API types whose APIs cannot be modified
+                 * to add `ref()` and `unref()` methods but still need to support that behavior.
+                 * @since v22.14.0
+                 * @experimental
+                 * @param maybeRefable An object that may be "refable".
+                 */
+                ref(maybeRefable: any): void;
+                /**
+                 * An object is "unrefable" if it implements the Node.js "Refable protocol".
+                 * Specifically, this means that the object implements the `Symbol.for('nodejs.ref')`
+                 * and `Symbol.for('nodejs.unref')` methods. "Ref'd" objects will keep the Node.js
+                 * event loop alive, while "unref'd" objects will not. Historically, this was
+                 * implemented by using `ref()` and `unref()` methods directly on the objects.
+                 * This pattern, however, is being deprecated in favor of the "Refable protocol"
+                 * in order to better support Web Platform API types whose APIs cannot be modified
+                 * to add `ref()` and `unref()` methods but still need to support that behavior.
+                 * @since v22.14.0
+                 * @experimental
+                 * @param maybeRefable An object that may be "unref'd".
+                 */
+                unref(maybeRefable: any): void;
                 /* EventEmitter */
                 addListener(event: "beforeExit", listener: BeforeExitListener): this;
                 addListener(event: "disconnect", listener: DisconnectListener): this;

package/lib/publishing/github/node_modules/@types/jsonwebtoken/node_modules/@types/node/sqlite.d.ts

@@ -43,7 +43,10 @@
  * @see [source](https://github.com/nodejs/node/blob/v22.x/lib/sqlite.js)
  */
 declare module "node:sqlite" {
-    type SupportedValueType = null | number | bigint | string | Uint8Array;
+    type SQLInputValue = null | number | bigint | string | NodeJS.ArrayBufferView;
+    type SQLOutputValue = null | number | bigint | string | Uint8Array;
+    /** @deprecated Use `SQLInputValue` or `SQLOutputValue` instead. */
+    type SupportedValueType = SQLOutputValue;
     interface DatabaseSyncOptions {
         /**
          * If `true`, the database is opened by the constructor. When
@@ -109,10 +112,30 @@ declare module "node:sqlite" {
          */
         filter?: ((tableName: string) => boolean) | undefined;
         /**
-         * Determines how conflicts are handled. **Default**: `SQLITE_CHANGESET_ABORT`.
+         * A function that determines how to handle conflicts. The function receives one argument,
+         * which can be one of the following values:
+         *
+         * * `SQLITE_CHANGESET_DATA`: A `DELETE` or `UPDATE` change does not contain the expected "before" values.
+         * * `SQLITE_CHANGESET_NOTFOUND`: A row matching the primary key of the `DELETE` or `UPDATE` change does not exist.
+         * * `SQLITE_CHANGESET_CONFLICT`: An `INSERT` change results in a duplicate primary key.
+         * * `SQLITE_CHANGESET_FOREIGN_KEY`: Applying a change would result in a foreign key violation.
+         * * `SQLITE_CHANGESET_CONSTRAINT`: Applying a change results in a `UNIQUE`, `CHECK`, or `NOT NULL` constraint
+         * violation.
+         *
+         * The function should return one of the following values:
+         *
+         * * `SQLITE_CHANGESET_OMIT`: Omit conflicting changes.
+         * * `SQLITE_CHANGESET_REPLACE`: Replace existing values with conflicting changes (only valid with
+             `SQLITE_CHANGESET_DATA` or `SQLITE_CHANGESET_CONFLICT` conflicts).
+         * * `SQLITE_CHANGESET_ABORT`: Abort on conflict and roll back the database.
+         *
+         * When an error is thrown in the conflict handler or when any other value is returned from the handler,
+         * applying the changeset is aborted and the database is rolled back.
+         *
+         * **Default**: A function that returns `SQLITE_CHANGESET_ABORT`.
          * @since v22.12.0
          */
-        onConflict?: number | undefined;
+        onConflict?: ((conflictType: number) => number) | undefined;
     }
     interface FunctionOptions {
         /**
@@ -322,11 +345,11 @@ declare module "node:sqlite" {
          * @return An array 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.
          */
-        all(...anonymousParameters: SupportedValueType[]): unknown[];
+        all(...anonymousParameters: SQLInputValue[]): Record<string, SQLOutputValue>[];
         all(
-            namedParameters: Record<string, SupportedValueType>,
-            ...anonymousParameters: SupportedValueType[]
-        ): unknown[];
+            namedParameters: Record<string, SQLInputValue>,
+            ...anonymousParameters: SQLInputValue[]
+        ): Record<string, SQLOutputValue>[];
         /**
          * The source SQL text of the prepared statement with parameter
          * placeholders replaced by the values that were used during the most recent
@@ -346,8 +369,11 @@ declare module "node:sqlite" {
          * @return An object corresponding to the first row returned by executing the prepared statement. The keys and values of the object correspond to the column names and values of the row. If no
          * rows were returned from the database then this method returns `undefined`.
          */
-        get(...anonymousParameters: SupportedValueType[]): unknown;
-        get(namedParameters: Record<string, SupportedValueType>, ...anonymousParameters: SupportedValueType[]): unknown;
+        get(...anonymousParameters: SQLInputValue[]): Record<string, SQLOutputValue> | undefined;
+        get(
+            namedParameters: Record<string, SQLInputValue>,
+            ...anonymousParameters: SQLInputValue[]
+        ): Record<string, SQLOutputValue> | undefined;
         /**
          * This method executes a prepared statement and returns an iterator of
          * objects. If the prepared statement does not return any results, this method
@@ -361,11 +387,11 @@ declare module "node:sqlite" {
          * 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(...anonymousParameters: SQLInputValue[]): NodeJS.Iterator<Record<string, SQLOutputValue>>;
         iterate(
-            namedParameters: Record<string, SupportedValueType>,
-            ...anonymousParameters: SupportedValueType[]
-        ): NodeJS.Iterator<unknown>;
+            namedParameters: Record<string, SQLInputValue>,
+            ...anonymousParameters: SQLInputValue[]
+        ): NodeJS.Iterator<Record<string, SQLOutputValue>>;
         /**
          * 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
@@ -374,10 +400,10 @@ declare module "node:sqlite" {
          * @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.
          */
-        run(...anonymousParameters: SupportedValueType[]): StatementResultingChanges;
+        run(...anonymousParameters: SQLInputValue[]): StatementResultingChanges;
         run(
-            namedParameters: Record<string, SupportedValueType>,
-            ...anonymousParameters: SupportedValueType[]
+            namedParameters: Record<string, SQLInputValue>,
+            ...anonymousParameters: SQLInputValue[]
         ): StatementResultingChanges;
         /**
          * The names of SQLite parameters begin with a prefix character. By default,`node:sqlite` requires that this prefix character is present when binding
@@ -420,13 +446,33 @@ declare module "node:sqlite" {
      * @since v22.13.0
      */
     namespace constants {
+        /**
+         * The conflict handler is invoked with this constant when processing a DELETE or UPDATE change if a row with the required PRIMARY KEY fields is present in the database, but one or more other (non primary-key) fields modified by the update do not contain the expected "before" values.
+         * @since v22.14.0
+         */
+        const SQLITE_CHANGESET_DATA: number;
+        /**
+         * The conflict handler is invoked with this constant when processing a DELETE or UPDATE change if a row with the required PRIMARY KEY fields is not present in the database.
+         * @since v22.14.0
+         */
+        const SQLITE_CHANGESET_NOTFOUND: number;
+        /**
+         * This constant is passed to the conflict handler while processing an INSERT change if the operation would result in duplicate primary key values.
+         * @since v22.14.0
+         */
+        const SQLITE_CHANGESET_CONFLICT: number;
+        /**
+         * If foreign key handling is enabled, and applying a changeset leaves the database in a state containing foreign key violations, the conflict handler is invoked with this constant exactly once before the changeset is committed. If the conflict handler returns `SQLITE_CHANGESET_OMIT`, the changes, including those that caused the foreign key constraint violation, are committed. Or, if it returns `SQLITE_CHANGESET_ABORT`, the changeset is rolled back.
+         * @since v22.14.0
+         */
+        const SQLITE_CHANGESET_FOREIGN_KEY: number;
         /**
          * Conflicting changes are omitted.
          * @since v22.12.0
          */
         const SQLITE_CHANGESET_OMIT: number;
         /**
-         * Conflicting changes replace existing values.
+         * Conflicting changes replace existing values. Note that this value can only be returned when the type of conflict is either `SQLITE_CHANGESET_DATA` or `SQLITE_CHANGESET_CONFLICT`.
          * @since v22.12.0
          */
         const SQLITE_CHANGESET_REPLACE: number;

package/lib/publishing/github/node_modules/@types/jsonwebtoken/node_modules/@types/node/test.d.ts

@@ -147,6 +147,7 @@ declare module "node:test" {
         export {
             after,
             afterEach,
+            assert,
             before,
             beforeEach,
             describe,
@@ -753,6 +754,18 @@ declare module "node:test" {
          * @returns A {@link Promise} resolved with `undefined` once the test completes.
          */
         test: typeof test;
+        /**
+         * This method polls a `condition` function until that function either returns
+         * successfully or the operation times out.
+         * @since v22.14.0
+         * @param condition An assertion function that is invoked
+         * periodically until it completes successfully or the defined polling timeout
+         * elapses. Successful completion is defined as not throwing or rejecting. This
+         * function does not accept any arguments, and is allowed to return any value.
+         * @param options An optional configuration object for the polling operation.
+         * @returns Fulfilled with the value returned by `condition`.
+         */
+        waitFor<T>(condition: () => T, options?: TestContextWaitForOptions): Promise<Awaited<T>>;
         /**
          * Each test provides its own MockTracker instance.
          */
@@ -781,6 +794,33 @@ declare module "node:test" {
             | "throws"
         >
     {
+        /**
+         * This function serializes `value` and writes it to the file specified by `path`.
+         *
+         * ```js
+         * test('snapshot test with default serialization', (t) => {
+         *   t.assert.fileSnapshot({ value1: 1, value2: 2 }, './snapshots/snapshot.json');
+         * });
+         * ```
+         *
+         * This function differs from `context.assert.snapshot()` in the following ways:
+         *
+         * * The snapshot file path is explicitly provided by the user.
+         * * Each snapshot file is limited to a single snapshot value.
+         * * No additional escaping is performed by the test runner.
+         *
+         * These differences allow snapshot files to better support features such as syntax
+         * highlighting.
+         * @since v22.14.0
+         * @param value A value to serialize to a string. If Node.js was started with
+         * the [`--test-update-snapshots`](https://nodejs.org/docs/latest-v22.x/api/cli.html#--test-update-snapshots)
+         * flag, the serialized value is written to
+         * `path`. Otherwise, the serialized value is compared to the contents of the
+         * existing snapshot file.
+         * @param path The file where the serialized `value` is written.
+         * @param options Optional configuration options.
+         */
+        fileSnapshot(value: any, path: string, options?: AssertSnapshotOptions): void;
         /**
          * This function implements assertions for snapshot testing.
          * ```js
@@ -795,8 +835,17 @@ declare module "node:test" {
          * });
          * ```
          * @since v22.3.0
+         * @param value A value to serialize to a string. If Node.js was started with
+         * the [`--test-update-snapshots`](https://nodejs.org/docs/latest-v22.x/api/cli.html#--test-update-snapshots)
+         * flag, the serialized value is written to
+         * the snapshot file. Otherwise, the serialized value is compared to the
+         * corresponding value in the existing snapshot file.
          */
         snapshot(value: any, options?: AssertSnapshotOptions): void;
+        /**
+         * A custom assertion function registered with `assert.register()`.
+         */
+        [name: string]: (...args: any[]) => void;
     }
     interface AssertSnapshotOptions {
         /**
@@ -809,6 +858,20 @@ declare module "node:test" {
          */
         serializers?: ReadonlyArray<(value: any) => any> | undefined;
     }
+    interface TestContextWaitForOptions {
+        /**
+         * The number of milliseconds to wait after an unsuccessful
+         * invocation of `condition` before trying again.
+         * @default 50
+         */
+        interval?: number | undefined;
+        /**
+         * The poll timeout in milliseconds. If `condition` has not
+         * succeeded by the time this elapses, an error occurs.
+         * @default 1000
+         */
+        timeout?: number | undefined;
+    }
 
     /**
      * An instance of `SuiteContext` is passed to each suite function in order to
@@ -1594,6 +1657,24 @@ declare module "node:test" {
          */
         [Symbol.dispose](): void;
     }
+    /**
+     * An object whose methods are used to configure available assertions on the
+     * `TestContext` objects in the current process. The methods from `node:assert`
+     * and snapshot testing functions are available by default.
+     *
+     * It is possible to apply the same configuration to all files by placing common
+     * configuration code in a module
+     * preloaded with `--require` or `--import`.
+     * @since v22.14.0
+     */
+    namespace assert {
+        /**
+         * Defines a new assertion function with the provided name and function. If an
+         * assertion already exists with the same name, it is overwritten.
+         * @since v22.14.0
+         */
+        function register(name: string, fn: (this: TestContext, ...args: any[]) => void): void;
+    }
     /**
      * @since v22.3.0
      */
@@ -1625,6 +1706,7 @@ declare module "node:test" {
     export {
         after,
         afterEach,
+        assert,
         before,
         beforeEach,
         describe,

package/lib/publishing/github/node_modules/@types/jsonwebtoken/node_modules/@types/node/timers/promises.d.ts

@@ -1,6 +1,7 @@
 /**
  * The `timers/promises` API provides an alternative set of timer functions
- * that return `Promise` objects. The API is accessible via `import timersPromises from 'node:timers/promises'`.
+ * that return `Promise` objects. The API is accessible via
+ * `require('node:timers/promises')`.
  *
  * ```js
  * import {
@@ -10,6 +11,7 @@
  * } from 'node:timers/promises';
  * ```
  * @since v15.0.0
+ * @see [source](https://github.com/nodejs/node/blob/v22.x/lib/timers/promises.js)
  */
 declare module "timers/promises" {
     import { TimerOptions } from "node:timers";
@@ -24,7 +26,8 @@ declare module "timers/promises" {
      * console.log(res);  // Prints 'result'
      * ```
      * @since v15.0.0
-     * @param [delay=1] The number of milliseconds to wait before fulfilling the promise.
+     * @param delay The number of milliseconds to wait before fulfilling the
+     * promise. **Default:** `1`.
      * @param value A value with which the promise is fulfilled.
      */
     function setTimeout<T = void>(delay?: number, value?: T, options?: TimerOptions): Promise<T>;
@@ -62,33 +65,41 @@ declare module "timers/promises" {
      * console.log(Date.now());
      * ```
      * @since v15.9.0
+     * @param delay The number of milliseconds to wait between iterations.
+     * **Default:** `1`.
+     * @param value A value with which the iterator returns.
      */
-    function setInterval<T = void>(delay?: number, value?: T, options?: TimerOptions): AsyncIterable<T>;
+    function setInterval<T = void>(delay?: number, value?: T, options?: TimerOptions): NodeJS.AsyncIterator<T>;
     interface Scheduler {
         /**
-         * An experimental API defined by the [Scheduling APIs](https://github.com/WICG/scheduling-apis) draft specification being developed as a standard Web Platform API.
+         * An experimental API defined by the [Scheduling APIs](https://github.com/WICG/scheduling-apis) draft specification
+         * being developed as a standard Web Platform API.
          *
-         * Calling `timersPromises.scheduler.wait(delay, options)` is roughly equivalent to calling `timersPromises.setTimeout(delay, undefined, options)` except that the `ref`
-         * option is not supported.
+         * Calling `timersPromises.scheduler.wait(delay, options)` is roughly equivalent
+         * to calling `timersPromises.setTimeout(delay, undefined, options)` except that
+         * the `ref` option is not supported.
          *
          * ```js
          * import { scheduler } from 'node:timers/promises';
          *
          * await scheduler.wait(1000); // Wait one second before continuing
          * ```
-         * @since v16.14.0
+         * @since v17.3.0, v16.14.0
          * @experimental
-         * @param [delay=1] The number of milliseconds to wait before fulfilling the promise.
+         * @param delay The number of milliseconds to wait before resolving the
+         * promise.
          */
-        wait: (delay?: number, options?: TimerOptions) => Promise<void>;
+        wait(delay: number, options?: { signal?: AbortSignal }): Promise<void>;
         /**
-         * An experimental API defined by the [Scheduling APIs](https://nodejs.org/docs/latest-v20.x/api/async_hooks.html#promise-execution-tracking) draft specification
+         * An experimental API defined by the [Scheduling APIs](https://github.com/WICG/scheduling-apis) draft specification
          * being developed as a standard Web Platform API.
-         * Calling `timersPromises.scheduler.yield()` is equivalent to calling `timersPromises.setImmediate()` with no arguments.
-         * @since v16.14.0
+         *
+         * Calling `timersPromises.scheduler.yield()` is equivalent to calling
+         * `timersPromises.setImmediate()` with no arguments.
+         * @since v17.3.0, v16.14.0
          * @experimental
          */
-        yield: () => Promise<void>;
+        yield(): Promise<void>;
     }
     const scheduler: Scheduler;
 }