cloudstructs 0.9.19 → 0.9.21

package/node_modules/@slack/logger/node_modules/@types/node/readline.d.ts

@@ -304,7 +304,7 @@ declare module "readline" {
         prependOnceListener(event: "SIGINT", listener: () => void): this;
         prependOnceListener(event: "SIGTSTP", listener: () => void): this;
         prependOnceListener(event: "history", listener: (history: string[]) => void): this;
-        [Symbol.asyncIterator](): AsyncIterableIterator<string>;
+        [Symbol.asyncIterator](): NodeJS.AsyncIterator<string>;
     }
     export type ReadLine = Interface; // type forwarded for backwards compatibility
     export type Completer = (line: string) => CompleterResult;
@@ -314,29 +314,78 @@ declare module "readline" {
     ) => void;
     export type CompleterResult = [string[], string];
     export interface ReadLineOptions {
+        /**
+         * The [`Readable`](https://nodejs.org/docs/latest-v22.x/api/stream.html#readable-streams) stream to listen to
+         */
         input: NodeJS.ReadableStream;
+        /**
+         * The [`Writable`](https://nodejs.org/docs/latest-v22.x/api/stream.html#writable-streams) stream to write readline data to.
+         */
         output?: NodeJS.WritableStream | undefined;
+        /**
+         * An optional function used for Tab autocompletion.
+         */
         completer?: Completer | AsyncCompleter | undefined;
+        /**
+         * `true` if the `input` and `output` streams should be treated like a TTY,
+         * and have ANSI/VT100 escape codes written to it.
+         * Default: checking `isTTY` on the `output` stream upon instantiation.
+         */
         terminal?: boolean | undefined;
         /**
-         *  Initial list of history lines. This option makes sense
-         * only if `terminal` is set to `true` by the user or by an internal `output`
-         * check, otherwise the history caching mechanism is not initialized at all.
+         * Initial list of history lines.
+         * This option makes sense only if `terminal` is set to `true` by the user or by an internal `output` check,
+         * otherwise the history caching mechanism is not initialized at all.
          * @default []
          */
         history?: string[] | undefined;
+        /**
+         * Maximum number of history lines retained.
+         * To disable the history set this value to `0`.
+         * This option makes sense only if `terminal` is set to `true` by the user or by an internal `output` check,
+         * otherwise the history caching mechanism is not initialized at all.
+         * @default 30
+         */
         historySize?: number | undefined;
-        prompt?: string | undefined;
-        crlfDelay?: number | undefined;
         /**
-         * If `true`, when a new input line added
-         * to the history list duplicates an older one, this removes the older line
-         * from the list.
+         * If `true`, when a new input line added to the history list duplicates an older one,
+         * this removes the older line from the list.
          * @default false
          */
         removeHistoryDuplicates?: boolean | undefined;
+        /**
+         * The prompt string to use.
+         * @default "> "
+         */
+        prompt?: string | undefined;
+        /**
+         * If the delay between `\r` and `\n` exceeds `crlfDelay` milliseconds,
+         * both `\r` and `\n` will be treated as separate end-of-line input.
+         * `crlfDelay` will be coerced to a number no less than `100`.
+         * It can be set to `Infinity`, in which case
+         * `\r` followed by `\n` will always be considered a single newline
+         * (which may be reasonable for [reading files](https://nodejs.org/docs/latest-v22.x/api/readline.html#example-read-file-stream-line-by-line) with `\r\n` line delimiter).
+         * @default 100
+         */
+        crlfDelay?: number | undefined;
+        /**
+         * The duration `readline` will wait for a character
+         * (when reading an ambiguous key sequence in milliseconds
+         * one that can both form a complete key sequence using the input read so far
+         * and can take additional input to complete a longer key sequence).
+         * @default 500
+         */
         escapeCodeTimeout?: number | undefined;
+        /**
+         * The number of spaces a tab is equal to (minimum 1).
+         * @default 8
+         */
         tabSize?: number | undefined;
+        /**
+         * Allows closing the interface using an AbortSignal.
+         * Aborting the signal will internally call `close` on the interface.
+         */
+        signal?: AbortSignal | undefined;
     }
     /**
      * The `readline.createInterface()` method creates a new `readline.Interface` instance.

package/node_modules/@slack/logger/node_modules/@types/node/stream/promises.d.ts

@@ -1,12 +1,19 @@
 declare module "stream/promises" {
     import {
-        FinishedOptions,
+        FinishedOptions as _FinishedOptions,
         PipelineDestination,
         PipelineOptions,
         PipelinePromise,
         PipelineSource,
         PipelineTransform,
     } from "node:stream";
+    interface FinishedOptions extends _FinishedOptions {
+        /**
+         * If true, removes the listeners registered by this function before the promise is fulfilled.
+         * @default false
+         */
+        cleanup?: boolean | undefined;
+    }
     function finished(
         stream: NodeJS.ReadableStream | NodeJS.WritableStream | NodeJS.ReadWriteStream,
         options?: FinishedOptions,

package/node_modules/@slack/logger/node_modules/@types/node/stream/web.d.ts

@@ -166,6 +166,9 @@ declare module "stream/web" {
     interface ReadableStreamErrorCallback {
         (reason: any): void | PromiseLike<void>;
     }
+    interface ReadableStreamAsyncIterator<T> extends NodeJS.AsyncIterator<T, NodeJS.BuiltinIteratorReturn, unknown> {
+        [Symbol.asyncIterator](): ReadableStreamAsyncIterator<T>;
+    }
     /** This Streams API interface represents a readable stream of byte data. */
     interface ReadableStream<R = any> {
         readonly locked: boolean;
@@ -176,8 +179,8 @@ declare module "stream/web" {
         pipeThrough<T>(transform: ReadableWritablePair<T, R>, options?: StreamPipeOptions): ReadableStream<T>;
         pipeTo(destination: WritableStream<R>, options?: StreamPipeOptions): Promise<void>;
         tee(): [ReadableStream<R>, ReadableStream<R>];
-        values(options?: { preventCancel?: boolean }): AsyncIterableIterator<R>;
-        [Symbol.asyncIterator](): AsyncIterableIterator<R>;
+        values(options?: { preventCancel?: boolean }): ReadableStreamAsyncIterator<R>;
+        [Symbol.asyncIterator](): ReadableStreamAsyncIterator<R>;
     }
     const ReadableStream: {
         prototype: ReadableStream;

package/node_modules/@slack/logger/node_modules/@types/node/stream.d.ts

@@ -422,7 +422,7 @@ declare module "stream" {
          * or exiting a `for await...of` iteration using a `break`, `return`, or `throw` will not destroy the stream.
          * **Default: `true`**.
          */
-        iterator(options?: { destroyOnReturn?: boolean }): AsyncIterableIterator<any>;
+        iterator(options?: { destroyOnReturn?: boolean }): NodeJS.AsyncIterator<any>;
         /**
          * This method allows mapping over the stream. The *fn* function will be called for every chunk in the stream.
          * If the *fn* function returns a promise - that promise will be `await`ed before being passed to the result stream.
@@ -651,7 +651,7 @@ declare module "stream" {
         removeListener(event: "readable", listener: () => void): this;
         removeListener(event: "resume", listener: () => void): this;
         removeListener(event: string | symbol, listener: (...args: any[]) => void): this;
-        [Symbol.asyncIterator](): AsyncIterableIterator<any>;
+        [Symbol.asyncIterator](): NodeJS.AsyncIterator<any>;
         /**
          * Calls `readable.destroy()` with an `AbortError` and returns a promise that fulfills when the stream is finished.
          * @since v20.4.0

package/node_modules/@slack/logger/node_modules/@types/node/test.d.ts

@@ -340,11 +340,22 @@ declare module "node:test" {
         globPatterns?: readonly string[] | undefined;
         /**
          * Sets inspector port of test child process.
-         * If a nullish value is provided, each process gets its own port,
-         * incremented from the primary's `process.debugPort`.
+         * This can be a number, or a function that takes no arguments and returns a
+         * number. If a nullish value is provided, each process gets its own port,
+         * incremented from the primary's `process.debugPort`. This option is ignored
+         * if the `isolation` option is set to `'none'` as no child processes are
+         * spawned.
          * @default undefined
          */
         inspectPort?: number | (() => number) | undefined;
+        /**
+         * Configures the type of test isolation. If set to
+         * `'process'`, each test file is run in a separate child process. If set to
+         * `'none'`, all test files run in the current process.
+         * @default 'process'
+         * @since v22.8.0
+         */
+        isolation?: "process" | "none" | undefined;
         /**
          * If truthy, the test context will only run tests that have the `only` option set
          */
@@ -1635,9 +1646,10 @@ declare module "node:test" {
          * This function is used to set a custom resolver for the location of the snapshot file used for snapshot testing.
          * By default, the snapshot filename is the same as the entry point filename with `.snapshot` appended.
          * @since v22.3.0
-         * @param fn A function which returns a string specifying the location of the snapshot file.
-         * The function receives the path of the test file as its only argument.
-         * If `process.argv[1]` is not associated with a file (for example in the REPL), the input is undefined.
+         * @param fn A function used to compute the location of the snapshot file.
+         * The function receives the path of the test file as its only argument. If the
+         * test is not associated with a file (for example in the REPL), the input is
+         * undefined. `fn()` must return a string specifying the location of the snapshot file.
          */
         function setResolveSnapshotPath(fn: (path: string | undefined) => string): void;
     }
@@ -1784,6 +1796,25 @@ interface TestCoverage {
                 count: number;
             }>;
         }>;
+        /**
+         * An object containing whether or not the coverage for
+         * each coverage type.
+         * @since v22.9.0
+         */
+        thresholds: {
+            /**
+             * The function coverage threshold.
+             */
+            function: number;
+            /**
+             * The branch coverage threshold.
+             */
+            branch: number;
+            /**
+             * The line coverage threshold.
+             */
+            line: number;
+        };
         /**
          * An object containing a summary of coverage for all files.
          */

package/node_modules/@slack/logger/node_modules/@types/node/timers/promises.d.ts

@@ -80,7 +80,7 @@ declare module "timers/promises" {
          * @experimental
          * @param [delay=1] The number of milliseconds to wait before fulfilling the promise.
          */
-        wait: (delay?: number, options?: Pick<TimerOptions, "signal">) => Promise<void>;
+        wait: (delay?: number, options?: TimerOptions) => 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
          * being developed as a standard Web Platform API.

package/node_modules/@slack/logger/node_modules/@types/node/tls.d.ts

@@ -809,6 +809,12 @@ declare module "tls" {
          * This option cannot be used with the `ALPNProtocols` option, and setting both options will throw an error.
          */
         ALPNCallback?: ((arg: { servername: string; protocols: string[] }) => string | undefined) | undefined;
+        /**
+         * Treat intermediate (non-self-signed)
+         * certificates in the trust CA certificate list as trusted.
+         * @since v22.9.0, v20.18.0
+         */
+        allowPartialTrustChain?: boolean | undefined;
         /**
          * Optionally override the trusted CA certificates. Default is to trust
          * the well-known CAs curated by Mozilla. Mozilla's CAs are completely

package/node_modules/@slack/logger/node_modules/@types/node/ts5.6/index.d.ts

@@ -22,22 +22,22 @@
  * IN THE SOFTWARE.
  */
 
-// NOTE: These definitions support NodeJS and TypeScript 4.9 through 5.6.
+// NOTE: These definitions support Node.js and TypeScript 4.9 through 5.6.
 
-// Reference required types from the default lib:
+// Reference required TypeScript libs:
 /// <reference lib="es2020" />
-/// <reference lib="esnext.asynciterable" />
-/// <reference lib="esnext.intl" />
-/// <reference lib="esnext.bigint" />
 
-// Definitions specific to TypeScript 4.9 through 5.6
+// TypeScript backwards-compatibility definitions:
+/// <reference path="../compatibility/index.d.ts" />
+
+// Definitions specific to TypeScript 4.9 through 5.6:
 /// <reference path="./globals.typedarray.d.ts" />
 /// <reference path="./buffer.buffer.d.ts" />
 
-// Base definitions for all NodeJS modules that are not specific to any version of TypeScript:
+// Definitions for Node.js modules that are not specific to any version of TypeScript:
+/// <reference path="../globals.d.ts" />
 /// <reference path="../assert.d.ts" />
 /// <reference path="../assert/strict.d.ts" />
-/// <reference path="../globals.d.ts" />
 /// <reference path="../async_hooks.d.ts" />
 /// <reference path="../buffer.d.ts" />
 /// <reference path="../child_process.d.ts" />
@@ -90,5 +90,3 @@
 /// <reference path="../wasi.d.ts" />
 /// <reference path="../worker_threads.d.ts" />
 /// <reference path="../zlib.d.ts" />
-
-/// <reference path="../globals.global.d.ts" />

package/node_modules/@slack/logger/node_modules/@types/node/url.d.ts

@@ -757,6 +757,9 @@ declare module "url" {
          */
         toJSON(): string;
     }
+    interface URLSearchParamsIterator<T> extends NodeJS.Iterator<T, NodeJS.BuiltinIteratorReturn, unknown> {
+        [Symbol.iterator](): URLSearchParamsIterator<T>;
+    }
     /**
      * The `URLSearchParams` API provides read and write access to the query of a `URL`. The `URLSearchParams` class can also be used standalone with one of the
      * four following constructors.
@@ -827,7 +830,7 @@ declare module "url" {
          *
          * Alias for `urlSearchParams[@@iterator]()`.
          */
-        entries(): IterableIterator<[string, string]>;
+        entries(): URLSearchParamsIterator<[string, string]>;
         /**
          * Iterates over each name-value pair in the query and invokes the given function.
          *
@@ -881,7 +884,7 @@ declare module "url" {
          * //   foo
          * ```
          */
-        keys(): IterableIterator<string>;
+        keys(): URLSearchParamsIterator<string>;
         /**
          * Sets the value in the `URLSearchParams` object associated with `name` to `value`. If there are any pre-existing name-value pairs whose names are `name`,
          * set the first such pair's value to `value` and remove all others. If not,
@@ -931,8 +934,8 @@ declare module "url" {
         /**
          * Returns an ES6 `Iterator` over the values of each name-value pair.
          */
-        values(): IterableIterator<string>;
-        [Symbol.iterator](): IterableIterator<[string, string]>;
+        values(): URLSearchParamsIterator<string>;
+        [Symbol.iterator](): URLSearchParamsIterator<[string, string]>;
     }
     import { URL as _URL, URLSearchParams as _URLSearchParams } from "url";
     global {

package/node_modules/@slack/logger/node_modules/@types/node/util.d.ts

@@ -108,6 +108,25 @@ declare module "util" {
     export interface InspectOptionsStylized extends InspectOptions {
         stylize(text: string, styleType: Style): string;
     }
+    export interface StacktraceObject {
+        /**
+         * Returns the name of the function associated with this stack frame.
+         */
+        functionName: string;
+        /**
+         * Returns the name of the resource that contains the script for the
+         * function for this StackFrame.
+         */
+        scriptName: string;
+        /**
+         * Returns the number, 1-based, of the line for the associate function call.
+         */
+        lineNumber: number;
+        /**
+         * Returns the 1-based column offset on the line for the associated function call.
+         */
+        column: number;
+    }
     /**
      * The `util.format()` method returns a formatted string using the first argument
      * as a `printf`-like format string which can contain zero or more format
@@ -166,6 +185,52 @@ declare module "util" {
      * @since v10.0.0
      */
     export function formatWithOptions(inspectOptions: InspectOptions, format?: any, ...param: any[]): string;
+    /**
+     * Returns an array of stacktrace objects containing the stack of
+     * the caller function.
+     *
+     * ```js
+     * const util = require('node:util');
+     *
+     * function exampleFunction() {
+     *   const callSites = util.getCallSite();
+     *
+     *   console.log('Call Sites:');
+     *   callSites.forEach((callSite, index) => {
+     *     console.log(`CallSite ${index + 1}:`);
+     *     console.log(`Function Name: ${callSite.functionName}`);
+     *     console.log(`Script Name: ${callSite.scriptName}`);
+     *     console.log(`Line Number: ${callSite.lineNumber}`);
+     *     console.log(`Column Number: ${callSite.column}`);
+     *   });
+     *   // CallSite 1:
+     *   // Function Name: exampleFunction
+     *   // Script Name: /home/example.js
+     *   // Line Number: 5
+     *   // Column Number: 26
+     *
+     *   // CallSite 2:
+     *   // Function Name: anotherFunction
+     *   // Script Name: /home/example.js
+     *   // Line Number: 22
+     *   // Column Number: 3
+     *
+     *   // ...
+     * }
+     *
+     * // A function to simulate another stack layer
+     * function anotherFunction() {
+     *   exampleFunction();
+     * }
+     *
+     * anotherFunction();
+     * ```
+     * @param frames Number of frames returned in the stacktrace.
+     * **Default:** `10`. Allowable range is between 1 and 200.
+     * @return An array of stacktrace objects
+     * @since v22.9.0
+     */
+    export function getCallSite(frames?: number): StacktraceObject[];
     /**
      * Returns the string name for a numeric error code that comes from a Node.js API.
      * The mapping between error codes and error names is platform-dependent.
@@ -1517,18 +1582,23 @@ declare module "util" {
         string | boolean
     >;
 
+    type ApplyOptionalModifiers<O extends ParseArgsOptionsConfig, V extends Record<keyof O, unknown>> = (
+        & { -readonly [LongOption in keyof O]?: V[LongOption] }
+        & { [LongOption in keyof O as O[LongOption]["default"] extends {} ? LongOption : never]: V[LongOption] }
+    ) extends infer P ? { [K in keyof P]: P[K] } : never; // resolve intersection to object
+
     type ParsedValues<T extends ParseArgsConfig> =
         & IfDefaultsTrue<T["strict"], unknown, { [longOption: string]: undefined | string | boolean }>
-        & (T["options"] extends ParseArgsOptionsConfig ? {
-                -readonly [LongOption in keyof T["options"]]:
-                    // when "default" is not undefined, the value will be present
-                    | (T["options"][LongOption]["default"] extends {} ? never : undefined)
-                    | IfDefaultsFalse<
+        & (T["options"] extends ParseArgsOptionsConfig ? ApplyOptionalModifiers<
+                T["options"],
+                {
+                    [LongOption in keyof T["options"]]: IfDefaultsFalse<
                         T["options"][LongOption]["multiple"],
                         Array<ExtractOptionValue<T, T["options"][LongOption]>>,
                         ExtractOptionValue<T, T["options"][LongOption]>
                     >;
-            }
+                }
+            >
             : {});
 
     type ParsedPositionals<T extends ParseArgsConfig> = IfDefaultsTrue<
@@ -1720,7 +1790,7 @@ declare module "util" {
          * Each item of the iterator is a JavaScript `Array`. The first item of the array
          * is the `name`, the second item of the array is the `value`.
          */
-        entries(): IterableIterator<[name: string, value: string]>;
+        entries(): NodeJS.Iterator<[name: string, value: string]>;
         /**
          * Returns the value of the first name-value pair whose name is `name`. If there
          * are no such pairs, `null` is returned.
@@ -1746,7 +1816,7 @@ declare module "util" {
          * //   bar
          * ```
          */
-        keys(): IterableIterator<string>;
+        keys(): NodeJS.Iterator<string>;
         /**
          * Sets the value in the `MIMEParams` object associated with `name` to `value`. If there are any pre-existing name-value pairs whose names are `name`,
          * set the first such pair's value to `value`.
@@ -1765,11 +1835,11 @@ declare module "util" {
         /**
          * Returns an iterator over the values of each name-value pair.
          */
-        values(): IterableIterator<string>;
+        values(): NodeJS.Iterator<string>;
         /**
          * Returns an iterator over each of the name-value pairs in the parameters.
          */
-        [Symbol.iterator]: typeof MIMEParams.prototype.entries;
+        [Symbol.iterator](): NodeJS.Iterator<[name: string, value: string]>;
     }
 }
 declare module "util/types" {