aws-delivlib 14.4.2 → 14.4.3

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

@@ -97,7 +97,7 @@ declare module 'process' {
             type UncaughtExceptionListener = (error: Error, origin: UncaughtExceptionOrigin) => void;
             /**
              * Most of the time the unhandledRejection will be an Error, but this should not be relied upon
-             * as *anything* can be thrown/rejected, it is therefore unsafe to assume the the value is an Error.
+             * as *anything* can be thrown/rejected, it is therefore unsafe to assume that the value is an Error.
              */
             type UnhandledRejectionListener = (reason: unknown, promise: Promise<unknown>) => void;
             type WarningListener = (warning: Error) => void;
@@ -250,7 +250,7 @@ declare module 'process' {
                  * For example, to copy `process.stdin` to `process.stdout`:
                  *
                  * ```js
-                 * import { stdin, stdout } from 'process';
+                 * import { stdin, stdout } from 'node:process';
                  *
                  * stdin.pipe(stdout);
                  * ```
@@ -297,7 +297,7 @@ declare module 'process' {
                  * For example, assuming the following script for `process-args.js`:
                  *
                  * ```js
-                 * import { argv } from 'process';
+                 * import { argv } from 'node:process';
                  *
                  * // print process.argv
                  * argv.forEach((val, index) => {
@@ -389,7 +389,7 @@ declare module 'process' {
                  * the specified `directory` does not exist).
                  *
                  * ```js
-                 * import { chdir, cwd } from 'process';
+                 * import { chdir, cwd } from 'node:process';
                  *
                  * console.log(`Starting directory: ${cwd()}`);
                  * try {
@@ -409,7 +409,7 @@ declare module 'process' {
                  * process.
                  *
                  * ```js
-                 * import { cwd } from 'process';
+                 * import { cwd } from 'node:process';
                  *
                  * console.log(`Current directory: ${cwd()}`);
                  * ```
@@ -420,7 +420,7 @@ declare module 'process' {
                  * The port used by the Node.js debugger when enabled.
                  *
                  * ```js
-                 * import process from 'process';
+                 * import process from 'node:process';
                  *
                  * process.debugPort = 5858;
                  * ```
@@ -432,12 +432,12 @@ declare module 'process' {
                  * specific process warnings. These can be listened for by adding a handler to the `'warning'` event.
                  *
                  * ```js
-                 * import { emitWarning } from 'process';
+                 * import { emitWarning } from 'node:process';
                  *
                  * // Emit a warning with a code and additional detail.
                  * emitWarning('Something happened!', {
                  *   code: 'MY_WARNING',
-                 *   detail: 'This is some additional information'
+                 *   detail: 'This is some additional information',
                  * });
                  * // Emits:
                  * // (node:56338) [MY_WARNING] Warning: Something happened!
@@ -447,7 +447,7 @@ declare module 'process' {
                  * In this example, an `Error` object is generated internally by`process.emitWarning()` and passed through to the `'warning'` handler.
                  *
                  * ```js
-                 * import process from 'process';
+                 * import process from 'node:process';
                  *
                  * process.on('warning', (warning) => {
                  *   console.warn(warning.name);    // 'Warning'
@@ -499,7 +499,7 @@ declare module 'process' {
                  * While the following will:
                  *
                  * ```js
-                 * import { env } from 'process';
+                 * import { env } from 'node:process';
                  *
                  * env.foo = 'bar';
                  * console.log(env.foo);
@@ -510,7 +510,7 @@ declare module 'process' {
                  * throw an error when the value is not a string, number, or boolean.
                  *
                  * ```js
-                 * import { env } from 'process';
+                 * import { env } from 'node:process';
                  *
                  * env.test = null;
                  * console.log(env.test);
@@ -523,7 +523,7 @@ declare module 'process' {
                  * Use `delete` to delete a property from `process.env`.
                  *
                  * ```js
-                 * import { env } from 'process';
+                 * import { env } from 'node:process';
                  *
                  * env.TEST = 1;
                  * delete env.TEST;
@@ -534,7 +534,7 @@ declare module 'process' {
                  * On Windows operating systems, environment variables are case-insensitive.
                  *
                  * ```js
-                 * import { env } from 'process';
+                 * import { env } from 'node:process';
                  *
                  * env.TEST = 1;
                  * console.log(env.test);
@@ -543,7 +543,7 @@ declare module 'process' {
                  *
                  * Unless explicitly specified when creating a `Worker` instance,
                  * each `Worker` thread has its own copy of `process.env`, based on its
-                 * parent thread’s `process.env`, or whatever was specified as the `env` option
+                 * parent thread's `process.env`, or whatever was specified as the `env` option
                  * to the `Worker` constructor. Changes to `process.env` will not be visible
                  * across `Worker` threads, and only the main thread can make changes that
                  * are visible to the operating system or to native add-ons.
@@ -560,7 +560,7 @@ declare module 'process' {
                  * To exit with a 'failure' code:
                  *
                  * ```js
-                 * import { exit } from 'process';
+                 * import { exit } from 'node:process';
                  *
                  * exit(1);
                  * ```
@@ -579,7 +579,7 @@ declare module 'process' {
                  * truncated and lost:
                  *
                  * ```js
-                 * import { exit } from 'process';
+                 * import { exit } from 'node:process';
                  *
                  * // This is an example of what *not* to do:
                  * if (someConditionNotMet()) {
@@ -590,13 +590,13 @@ declare module 'process' {
                  *
                  * The reason this is problematic is because writes to `process.stdout` in Node.js
                  * are sometimes _asynchronous_ and may occur over multiple ticks of the Node.js
-                 * event loop. Calling `process.exit()`, however, forces the process to exit_before_ those additional writes to `stdout` can be performed.
+                 * event loop. Calling `process.exit()`, however, forces the process to exit _before_ those additional writes to `stdout` can be performed.
                  *
                  * Rather than calling `process.exit()` directly, the code _should_ set the`process.exitCode` and allow the process to exit naturally by avoiding
                  * scheduling any additional work for the event loop:
                  *
                  * ```js
-                 * import process from 'process';
+                 * import process from 'node:process';
                  *
                  * // How to properly set the exit code while letting
                  * // the process exit gracefully.
@@ -613,7 +613,7 @@ declare module 'process' {
                  * In `Worker` threads, this function stops the current thread rather
                  * than the current process.
                  * @since v0.1.13
-                 * @param [code=0] The exit code.
+                 * @param [code=0] The exit code. For string type, only integer strings (e.g.,'1') are allowed.
                  */
                 exit(code?: number): never;
                 /**
@@ -873,7 +873,7 @@ declare module 'process' {
                  * The `process.version` property contains the Node.js version string.
                  *
                  * ```js
-                 * import { version } from 'process';
+                 * import { version } from 'node:process';
                  *
                  * console.log(`Version: ${version}`);
                  * // Version: v14.8.0
@@ -890,7 +890,7 @@ declare module 'process' {
                  * to load modules that were compiled against a different module ABI version.
                  *
                  * ```js
-                 * import { versions } from 'process';
+                 * import { versions } from 'node:process';
                  *
                  * console.log(versions);
                  * ```
@@ -918,10 +918,10 @@ declare module 'process' {
                  */
                 readonly versions: ProcessVersions;
                 /**
-                 * The `process.config` property returns an `Object` containing the JavaScript
-                 * representation of the configure options used to compile the current Node.js
-                 * executable. This is the same as the `config.gypi` file that was produced when
-                 * running the `./configure` script.
+                 * The `process.config` property returns a frozen `Object` containing the
+                 * JavaScript representation of the configure options used to compile the current
+                 * Node.js executable. This is the same as the `config.gypi` file that was produced
+                 * when running the `./configure` script.
                  *
                  * An example of the possible output looks like:
                  *
@@ -943,7 +943,6 @@ declare module 'process' {
                  *      node_shared_http_parser: 'false',
                  *      node_shared_libuv: 'false',
                  *      node_shared_zlib: 'false',
-                 *      node_use_dtrace: 'false',
                  *      node_use_openssl: 'true',
                  *      node_shared_openssl: 'false',
                  *      strict_aliasing: 'true',
@@ -952,13 +951,6 @@ declare module 'process' {
                  *    }
                  * }
                  * ```
-                 *
-                 * The `process.config` property is **not** read-only and there are existing
-                 * modules in the ecosystem that are known to extend, modify, or entirely replace
-                 * the value of `process.config`.
-                 *
-                 * Modifying the `process.config` property, or any child-property of the`process.config` object has been deprecated. The `process.config` will be made
-                 * read-only in a future release.
                  * @since v0.7.7
                  */
                 readonly config: ProcessConfig;
@@ -977,7 +969,7 @@ declare module 'process' {
                  * other than kill the target process.
                  *
                  * ```js
-                 * import process, { kill } from 'process';
+                 * import process, { kill } from 'node:process';
                  *
                  * process.on('SIGHUP', () => {
                  *   console.log('Got SIGHUP signal.');
@@ -1002,7 +994,7 @@ declare module 'process' {
                  * The `process.pid` property returns the PID of the process.
                  *
                  * ```js
-                 * import { pid } from 'process';
+                 * import { pid } from 'node:process';
                  *
                  * console.log(`This process is pid ${pid}`);
                  * ```
@@ -1014,7 +1006,7 @@ declare module 'process' {
                  * current process.
                  *
                  * ```js
-                 * import { ppid } from 'process';
+                 * import { ppid } from 'node:process';
                  *
                  * console.log(`The parent process is pid ${ppid}`);
                  * ```
@@ -1041,10 +1033,10 @@ declare module 'process' {
                 title: string;
                 /**
                  * The operating system CPU architecture for which the Node.js binary was compiled.
-                 * Possible values are: `'arm'`, `'arm64'`, `'ia32'`, `'mips'`,`'mipsel'`, `'ppc'`,`'ppc64'`, `'s390'`, `'s390x'`, `'x32'`, and `'x64'`.
+                 * Possible values are: `'arm'`, `'arm64'`, `'ia32'`, `'mips'`,`'mipsel'`, `'ppc'`,`'ppc64'`, `'s390'`, `'s390x'`, and `'x64'`.
                  *
                  * ```js
-                 * import { arch } from 'process';
+                 * import { arch } from 'node:process';
                  *
                  * console.log(`This processor architecture is ${arch}`);
                  * ```
@@ -1053,7 +1045,7 @@ declare module 'process' {
                 readonly arch: Architecture;
                 /**
                  * The `process.platform` property returns a string identifying the operating
-                 * system platform on which the Node.js process is running.
+                 * system platform for which the Node.js binary was compiled.
                  *
                  * Currently possible values are:
                  *
@@ -1066,7 +1058,7 @@ declare module 'process' {
                  * * `'win32'`
                  *
                  * ```js
-                 * import { platform } from 'process';
+                 * import { platform } from 'node:process';
                  *
                  * console.log(`This platform is ${platform}`);
                  * ```
@@ -1089,6 +1081,17 @@ declare module 'process' {
                  */
                 mainModule?: Module | undefined;
                 memoryUsage: MemoryUsageFn;
+                /**
+                 * Gets the amount of memory available to the process (in bytes) based on
+                 * limits imposed by the OS. If there is no such constraint, or the constraint
+                 * is unknown, `undefined` is returned.
+                 *
+                 * 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 | undefined;
                 /**
                  * The `process.cpuUsage()` method returns the user and system CPU time usage of
                  * the current process, in an object with properties `user` and `system`, whose
@@ -1100,7 +1103,7 @@ declare module 'process' {
                  * argument to the function, to get a diff reading.
                  *
                  * ```js
-                 * import { cpuUsage } from 'process';
+                 * import { cpuUsage } from 'node:process';
                  *
                  * const startUsage = cpuUsage();
                  * // { user: 38579, system: 6986 }
@@ -1124,7 +1127,7 @@ declare module 'process' {
                  * See the [Event Loop](https://nodejs.org/en/docs/guides/event-loop-timers-and-nexttick/#process-nexttick) guide for more background.
                  *
                  * ```js
-                 * import { nextTick } from 'process';
+                 * import { nextTick } from 'node:process';
                  *
                  * console.log('start');
                  * nextTick(() => {
@@ -1142,7 +1145,7 @@ declare module 'process' {
                  * I/O has occurred:
                  *
                  * ```js
-                 * import { nextTick } from 'process';
+                 * import { nextTick } from 'node:process';
                  *
                  * function MyThing(options) {
                  *   this.setupOptions(options);
@@ -1190,7 +1193,7 @@ declare module 'process' {
                  * The following approach is much better:
                  *
                  * ```js
-                 * import { nextTick } from 'process';
+                 * import { nextTick } from 'node:process';
                  *
                  * function definitelyAsync(arg, cb) {
                  *   if (arg) {
@@ -1215,10 +1218,10 @@ declare module 'process' {
                  * ```js
                  * {
                  *   name: 'node',
-                 *   lts: 'Erbium',
-                 *   sourceUrl: 'https://nodejs.org/download/release/v12.18.1/node-v12.18.1.tar.gz',
-                 *   headersUrl: 'https://nodejs.org/download/release/v12.18.1/node-v12.18.1-headers.tar.gz',
-                 *   libUrl: 'https://nodejs.org/download/release/v12.18.1/win-x64/node.lib'
+                 *   lts: 'Hydrogen',
+                 *   sourceUrl: 'https://nodejs.org/download/release/v18.12.0/node-v18.12.0.tar.gz',
+                 *   headersUrl: 'https://nodejs.org/download/release/v18.12.0/node-v18.12.0-headers.tar.gz',
+                 *   libUrl: 'https://nodejs.org/download/release/v18.12.0/win-x64/node.lib'
                  * }
                  * ```
                  *
@@ -1322,7 +1325,7 @@ declare module 'process' {
                  * dashes:
                  *
                  * ```js
-                 * import { allowedNodeEnvironmentFlags } from 'process';
+                 * import { allowedNodeEnvironmentFlags } from 'node:process';
                  *
                  * allowedNodeEnvironmentFlags.forEach((flag) => {
                  *   // -r
@@ -1348,7 +1351,7 @@ declare module 'process' {
                 report?: ProcessReport | undefined;
                 /**
                  * ```js
-                 * import { resourceUsage } from 'process';
+                 * import { resourceUsage } from 'node:process';
                  *
                  * console.log(resourceUsage());
                  * /*

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

@@ -24,7 +24,7 @@
  * made available to developers as a convenience. Fixes or other modifications to
  * the module must be directed to the [Punycode.js](https://github.com/bestiejs/punycode.js) project.
  * @deprecated Since v7.0.0 - Deprecated
- * @see [source](https://github.com/nodejs/node/blob/v17.0.0/lib/punycode.js)
+ * @see [source](https://github.com/nodejs/node/blob/v20.2.0/lib/punycode.js)
  */
 declare module 'punycode' {
     /**

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

@@ -1,15 +1,15 @@
 /**
- * The `querystring` module provides utilities for parsing and formatting URL
+ * The `node:querystring` module provides utilities for parsing and formatting URL
  * query strings. It can be accessed using:
  *
  * ```js
- * const querystring = require('querystring');
+ * const querystring = require('node:querystring');
  * ```
  *
- * The `querystring` API is considered Legacy. While it is still maintained,
- * new code should use the `URLSearchParams` API instead.
- * @deprecated Legacy
- * @see [source](https://github.com/nodejs/node/blob/v17.0.0/lib/querystring.js)
+ * `querystring` is more performant than `URLSearchParams` but is not a
+ * standardized API. Use `URLSearchParams` when performance is not critical or
+ * when compatibility with browser code is desirable.
+ * @see [source](https://github.com/nodejs/node/blob/v20.2.0/lib/querystring.js)
  */
 declare module 'querystring' {
     interface StringifyOptions {

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

@@ -0,0 +1,145 @@
+/**
+ * @since v17.0.0
+ * @experimental
+ */
+declare module 'readline/promises' {
+    import { Interface as _Interface, ReadLineOptions, Completer, AsyncCompleter, Direction } from 'node:readline';
+    import { Abortable } from 'node:events';
+    /**
+     * Instances of the `readlinePromises.Interface` class are constructed using the`readlinePromises.createInterface()` method. Every instance is associated with a
+     * single `input` `Readable` stream and a single `output` `Writable` stream.
+     * The `output` stream is used to print prompts for user input that arrives on,
+     * and is read from, the `input` stream.
+     * @since v17.0.0
+     */
+    class Interface extends _Interface {
+        /**
+         * The `rl.question()` method displays the `query` by writing it to the `output`,
+         * waits for user input to be provided on `input`, then invokes the `callback`function passing the provided input as the first argument.
+         *
+         * When called, `rl.question()` will resume the `input` stream if it has been
+         * paused.
+         *
+         * If the `Interface` was created with `output` set to `null` or`undefined` the `query` is not written.
+         *
+         * If the question is called after `rl.close()`, it returns a rejected promise.
+         *
+         * Example usage:
+         *
+         * ```js
+         * const answer = await rl.question('What is your favorite food? ');
+         * console.log(`Oh, so your favorite food is ${answer}`);
+         * ```
+         *
+         * Using an `AbortSignal` to cancel a question.
+         *
+         * ```js
+         * const signal = AbortSignal.timeout(10_000);
+         *
+         * signal.addEventListener('abort', () => {
+         *   console.log('The food question timed out');
+         * }, { once: true });
+         *
+         * const answer = await rl.question('What is your favorite food? ', { signal });
+         * console.log(`Oh, so your favorite food is ${answer}`);
+         * ```
+         * @since v17.0.0
+         * @param query A statement or query to write to `output`, prepended to the prompt.
+         * @return A promise that is fulfilled with the user's input in response to the `query`.
+         */
+        question(query: string): Promise<string>;
+        question(query: string, options: Abortable): Promise<string>;
+    }
+    /**
+     * @since v17.0.0
+     */
+    class Readline {
+        /**
+         * @param stream A TTY stream.
+         */
+        constructor(
+            stream: NodeJS.WritableStream,
+            options?: {
+                autoCommit?: boolean;
+            }
+        );
+        /**
+         * The `rl.clearLine()` method adds to the internal list of pending action an
+         * action that clears current line of the associated `stream` in a specified
+         * direction identified by `dir`.
+         * Call `rl.commit()` to see the effect of this method, unless `autoCommit: true`was passed to the constructor.
+         * @since v17.0.0
+         * @return this
+         */
+        clearLine(dir: Direction): this;
+        /**
+         * The `rl.clearScreenDown()` method adds to the internal list of pending action an
+         * action that clears the associated stream from the current position of the
+         * cursor down.
+         * Call `rl.commit()` to see the effect of this method, unless `autoCommit: true`was passed to the constructor.
+         * @since v17.0.0
+         * @return this
+         */
+        clearScreenDown(): this;
+        /**
+         * The `rl.commit()` method sends all the pending actions to the associated`stream` and clears the internal list of pending actions.
+         * @since v17.0.0
+         */
+        commit(): Promise<void>;
+        /**
+         * The `rl.cursorTo()` method adds to the internal list of pending action an action
+         * that moves cursor to the specified position in the associated `stream`.
+         * Call `rl.commit()` to see the effect of this method, unless `autoCommit: true`was passed to the constructor.
+         * @since v17.0.0
+         * @return this
+         */
+        cursorTo(x: number, y?: number): this;
+        /**
+         * The `rl.moveCursor()` method adds to the internal list of pending action an
+         * action that moves the cursor _relative_ to its current position in the
+         * associated `stream`.
+         * Call `rl.commit()` to see the effect of this method, unless `autoCommit: true`was passed to the constructor.
+         * @since v17.0.0
+         * @return this
+         */
+        moveCursor(dx: number, dy: number): this;
+        /**
+         * The `rl.rollback` methods clears the internal list of pending actions without
+         * sending it to the associated `stream`.
+         * @since v17.0.0
+         * @return this
+         */
+        rollback(): this;
+    }
+    /**
+     * The `readlinePromises.createInterface()` method creates a new `readlinePromises.Interface`instance.
+     *
+     * ```js
+     * const readlinePromises = require('node:readline/promises');
+     * const rl = readlinePromises.createInterface({
+     *   input: process.stdin,
+     *   output: process.stdout,
+     * });
+     * ```
+     *
+     * Once the `readlinePromises.Interface` instance is created, the most common case
+     * is to listen for the `'line'` event:
+     *
+     * ```js
+     * rl.on('line', (line) => {
+     *   console.log(`Received: ${line}`);
+     * });
+     * ```
+     *
+     * If `terminal` is `true` for this instance then the `output` stream will get
+     * the best compatibility if it defines an `output.columns` property and emits
+     * a `'resize'` event on the `output` if or when the columns ever change
+     * (`process.stdout` does this automatically when it is a TTY).
+     * @since v17.0.0
+     */
+    function createInterface(input: NodeJS.ReadableStream, output?: NodeJS.WritableStream, completer?: Completer | AsyncCompleter, terminal?: boolean): Interface;
+    function createInterface(options: ReadLineOptions): Interface;
+}
+declare module 'node:readline/promises' {
+    export * from 'readline/promises';
+}