cloudstructs 0.9.27 → 0.9.28

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

@@ -564,6 +564,23 @@ declare module "node:test" {
         /**
          * An object containing assertion methods bound to the test context.
          * The top-level functions from the `node:assert` module are exposed here for the purpose of creating test plans.
+         *
+         * **Note:** Some of the functions from `node:assert` contain type assertions. If these are called via the
+         * TestContext `assert` object, then the context parameter in the test's function signature **must be explicitly typed**
+         * (ie. the parameter must have a type annotation), otherwise an error will be raised by the TypeScript compiler:
+         * ```ts
+         * import { test, type TestContext } from 'node:test';
+         *
+         * // The test function's context parameter must have a type annotation.
+         * test('example', (t: TestContext) => {
+         *   t.assert.deepStrictEqual(actual, expected);
+         * });
+         *
+         * // Omitting the type annotation will result in a compilation error.
+         * test('example', t => {
+         *   t.assert.deepStrictEqual(actual, expected); // Error: 't' needs an explicit type annotation.
+         * });
+         * ```
          * @since v22.2.0, v20.15.0
          */
         readonly assert: TestContextAssert;
@@ -741,139 +758,29 @@ declare module "node:test" {
          */
         readonly mock: MockTracker;
     }
-    interface TestContextAssert {
-        /**
-         * Identical to the `deepEqual` function from the `node:assert` module, but bound to the test context.
-         */
-        deepEqual: typeof import("node:assert").deepEqual;
-        /**
-         * Identical to the `deepStrictEqual` function from the `node:assert` module, but bound to the test context.
-         *
-         * **Note:** as this method returns a type assertion, the context parameter in the callback signature must have a
-         * type annotation, otherwise an error will be raised by the TypeScript compiler:
-         * ```ts
-         * import { test, type TestContext } from 'node:test';
-         *
-         * // The test function's context parameter must have a type annotation.
-         * test('example', (t: TestContext) => {
-         *   t.assert.deepStrictEqual(actual, expected);
-         * });
-         *
-         * // Omitting the type annotation will result in a compilation error.
-         * test('example', t => {
-         *   t.assert.deepStrictEqual(actual, expected); // Error: 't' needs an explicit type annotation.
-         * });
-         * ```
-         */
-        deepStrictEqual: typeof import("node:assert").deepStrictEqual;
-        /**
-         * Identical to the `doesNotMatch` function from the `node:assert` module, but bound to the test context.
-         */
-        doesNotMatch: typeof import("node:assert").doesNotMatch;
-        /**
-         * Identical to the `doesNotReject` function from the `node:assert` module, but bound to the test context.
-         */
-        doesNotReject: typeof import("node:assert").doesNotReject;
-        /**
-         * Identical to the `doesNotThrow` function from the `node:assert` module, but bound to the test context.
-         */
-        doesNotThrow: typeof import("node:assert").doesNotThrow;
-        /**
-         * Identical to the `equal` function from the `node:assert` module, but bound to the test context.
-         */
-        equal: typeof import("node:assert").equal;
-        /**
-         * Identical to the `fail` function from the `node:assert` module, but bound to the test context.
-         */
-        fail: typeof import("node:assert").fail;
-        /**
-         * Identical to the `ifError` function from the `node:assert` module, but bound to the test context.
-         *
-         * **Note:** as this method returns a type assertion, the context parameter in the callback signature must have a
-         * type annotation, otherwise an error will be raised by the TypeScript compiler:
-         * ```ts
-         * import { test, type TestContext } from 'node:test';
-         *
-         * // The test function's context parameter must have a type annotation.
-         * test('example', (t: TestContext) => {
-         *   t.assert.ifError(err);
-         * });
-         *
-         * // Omitting the type annotation will result in a compilation error.
-         * test('example', t => {
-         *   t.assert.ifError(err); // Error: 't' needs an explicit type annotation.
-         * });
-         * ```
-         */
-        ifError: typeof import("node:assert").ifError;
-        /**
-         * Identical to the `match` function from the `node:assert` module, but bound to the test context.
-         */
-        match: typeof import("node:assert").match;
-        /**
-         * Identical to the `notDeepEqual` function from the `node:assert` module, but bound to the test context.
-         */
-        notDeepEqual: typeof import("node:assert").notDeepEqual;
-        /**
-         * Identical to the `notDeepStrictEqual` function from the `node:assert` module, but bound to the test context.
-         */
-        notDeepStrictEqual: typeof import("node:assert").notDeepStrictEqual;
-        /**
-         * Identical to the `notEqual` function from the `node:assert` module, but bound to the test context.
-         */
-        notEqual: typeof import("node:assert").notEqual;
-        /**
-         * Identical to the `notStrictEqual` function from the `node:assert` module, but bound to the test context.
-         */
-        notStrictEqual: typeof import("node:assert").notStrictEqual;
-        /**
-         * Identical to the `ok` function from the `node:assert` module, but bound to the test context.
-         *
-         * **Note:** as this method returns a type assertion, the context parameter in the callback signature must have a
-         * type annotation, otherwise an error will be raised by the TypeScript compiler:
-         * ```ts
-         * import { test, type TestContext } from 'node:test';
-         *
-         * // The test function's context parameter must have a type annotation.
-         * test('example', (t: TestContext) => {
-         *   t.assert.ok(condition);
-         * });
-         *
-         * // Omitting the type annotation will result in a compilation error.
-         * test('example', t => {
-         *   t.assert.ok(condition)); // Error: 't' needs an explicit type annotation.
-         * });
-         * ```
-         */
-        ok: typeof import("node:assert").ok;
-        /**
-         * Identical to the `rejects` function from the `node:assert` module, but bound to the test context.
-         */
-        rejects: typeof import("node:assert").rejects;
-        /**
-         * Identical to the `strictEqual` function from the `node:assert` module, but bound to the test context.
-         *
-         * **Note:** as this method returns a type assertion, the context parameter in the callback signature must have a
-         * type annotation, otherwise an error will be raised by the TypeScript compiler:
-         * ```ts
-         * import { test, type TestContext } from 'node:test';
-         *
-         * // The test function's context parameter must have a type annotation.
-         * test('example', (t: TestContext) => {
-         *   t.assert.strictEqual(actual, expected);
-         * });
-         *
-         * // Omitting the type annotation will result in a compilation error.
-         * test('example', t => {
-         *   t.assert.strictEqual(actual, expected); // Error: 't' needs an explicit type annotation.
-         * });
-         * ```
-         */
-        strictEqual: typeof import("node:assert").strictEqual;
-        /**
-         * Identical to the `throws` function from the `node:assert` module, but bound to the test context.
-         */
-        throws: typeof import("node:assert").throws;
+    interface TestContextAssert extends
+        Pick<
+            typeof import("assert"),
+            | "deepEqual"
+            | "deepStrictEqual"
+            | "doesNotMatch"
+            | "doesNotReject"
+            | "doesNotThrow"
+            | "equal"
+            | "fail"
+            | "ifError"
+            | "match"
+            | "notDeepEqual"
+            | "notDeepStrictEqual"
+            | "notEqual"
+            | "notStrictEqual"
+            | "ok"
+            | "partialDeepStrictEqual"
+            | "rejects"
+            | "strictEqual"
+            | "throws"
+        >
+    {
         /**
          * This function implements assertions for snapshot testing.
          * ```js
@@ -887,10 +794,7 @@ declare module "node:test" {
          *   });
          * });
          * ```
-         *
-         * Only available through the [--experimental-test-snapshots](https://nodejs.org/api/cli.html#--experimental-test-snapshots) flag.
          * @since v22.3.0
-         * @experimental
          */
         snapshot(value: any, options?: AssertSnapshotOptions): void;
     }
@@ -1691,9 +1595,7 @@ declare module "node:test" {
         [Symbol.dispose](): void;
     }
     /**
-     * Only available through the [--experimental-test-snapshots](https://nodejs.org/api/cli.html#--experimental-test-snapshots) flag.
      * @since v22.3.0
-     * @experimental
      */
     namespace snapshot {
         /**

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

@@ -108,14 +108,14 @@ declare module "util" {
     export interface InspectOptionsStylized extends InspectOptions {
         stylize(text: string, styleType: Style): string;
     }
-    export interface StacktraceObject {
+    export interface CallSiteObject {
         /**
-         * Returns the name of the function associated with this stack frame.
+         * Returns the name of the function associated with this call site.
          */
         functionName: string;
         /**
          * Returns the name of the resource that contains the script for the
-         * function for this StackFrame.
+         * function for this call site.
          */
         scriptName: string;
         /**
@@ -185,15 +185,22 @@ declare module "util" {
      * @since v10.0.0
      */
     export function formatWithOptions(inspectOptions: InspectOptions, format?: any, ...param: any[]): string;
+    interface GetCallSitesOptions {
+        /**
+         * Reconstruct the original location in the stacktrace from the source-map.
+         * Enabled by default with the flag `--enable-source-maps`.
+         */
+        sourceMap?: boolean | undefined;
+    }
     /**
-     * Returns an array of stacktrace objects containing the stack of
+     * Returns an array of call site objects containing the stack of
      * the caller function.
      *
      * ```js
      * const util = require('node:util');
      *
      * function exampleFunction() {
-     *   const callSites = util.getCallSite();
+     *   const callSites = util.getCallSites();
      *
      *   console.log('Call Sites:');
      *   callSites.forEach((callSite, index) => {
@@ -225,12 +232,40 @@ declare module "util" {
      *
      * anotherFunction();
      * ```
-     * @param frames Number of frames returned in the stacktrace.
+     *
+     * It is possible to reconstruct the original locations by setting the option `sourceMap` to `true`.
+     * If the source map is not available, the original location will be the same as the current location.
+     * When the `--enable-source-maps` flag is enabled, for example when using `--experimental-transform-types`,
+     * `sourceMap` will be true by default.
+     *
+     * ```ts
+     * import util from 'node:util';
+     *
+     * interface Foo {
+     *   foo: string;
+     * }
+     *
+     * const callSites = util.getCallSites({ sourceMap: true });
+     *
+     * // With sourceMap:
+     * // Function Name: ''
+     * // Script Name: example.js
+     * // Line Number: 7
+     * // Column Number: 26
+     *
+     * // Without sourceMap:
+     * // Function Name: ''
+     * // Script Name: example.js
+     * // Line Number: 2
+     * // Column Number: 26
+     * ```
+     * @param frameCount Number of frames to capture as call site objects.
      * **Default:** `10`. Allowable range is between 1 and 200.
-     * @return An array of stacktrace objects
+     * @return An array of call site objects
      * @since v22.9.0
      */
-    export function getCallSite(frames?: number): StacktraceObject[];
+    export function getCallSites(frameCount?: number, options?: GetCallSitesOptions): CallSiteObject[];
+    export function getCallSites(options: GetCallSitesOptions): CallSiteObject[];
     /**
      * 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.
@@ -260,6 +295,20 @@ declare module "util" {
      * @since v16.0.0, v14.17.0
      */
     export function getSystemErrorMap(): Map<number, [string, string]>;
+    /**
+     * Returns the string message for a numeric error code that comes from a Node.js
+     * API.
+     * The mapping between error codes and string messages is platform-dependent.
+     *
+     * ```js
+     * fs.access('file/that/does/not/exist', (err) => {
+     *   const name = util.getSystemErrorMessage(err.errno);
+     *   console.error(name);  // no such file or directory
+     * });
+     * ```
+     * @since v22.12.0
+     */
+    export function getSystemErrorMessage(err: number): string;
     /**
      * The `util.log()` method prints the given `string` to `stdout` with an included
      * timestamp.
@@ -303,27 +352,36 @@ declare module "util" {
      */
     export function transferableAbortSignal(signal: AbortSignal): AbortSignal;
     /**
-     * Listens to abort event on the provided `signal` and
-     * returns a promise that is fulfilled when the `signal` is
-     * aborted. If the passed `resource` is garbage collected before the `signal` is
-     * aborted, the returned promise shall remain pending indefinitely.
+     * Listens to abort event on the provided `signal` and returns a promise that resolves when the `signal` is aborted.
+     * If `resource` is provided, it weakly references the operation's associated object,
+     * so if `resource` is garbage collected before the `signal` aborts,
+     * then returned promise shall remain pending.
+     * This prevents memory leaks in long-running or non-cancelable operations.
      *
      * ```js
      * import { aborted } from 'node:util';
      *
+     * // Obtain an object with an abortable signal, like a custom resource or operation.
      * const dependent = obtainSomethingAbortable();
      *
+     * // Pass `dependent` as the resource, indicating the promise should only resolve
+     * // if `dependent` is still in memory when the signal is aborted.
      * aborted(dependent.signal, dependent).then(() => {
-     *   // Do something when dependent is aborted.
+     *   // This code runs when `dependent` is aborted.
+     *   console.log('Dependent resource was aborted.');
      * });
      *
+     * // Simulate an event that triggers the abort.
      * dependent.on('event', () => {
-     *   dependent.abort();
+     *   dependent.abort(); // This will cause the `aborted` promise to resolve.
      * });
      * ```
      * @since v19.7.0
      * @experimental
-     * @param resource Any non-null entity, reference to which is held weakly.
+     * @param resource Any non-null object tied to the abortable operation and held weakly.
+     * If `resource` is garbage collected before the `signal` aborts, the promise remains pending,
+     * allowing Node.js to stop tracking it.
+     * This helps prevent memory leaks in long-running or non-cancelable operations.
      */
     export function aborted(signal: AbortSignal, resource: any): Promise<void>;
     /**
@@ -1307,8 +1365,6 @@ declare module "util" {
         | "strikethrough"
         | "underline";
     /**
-     * Stability: 1.1 - Active development
-     *
      * This function returns a formatted text considering the `format` passed.
      *
      * ```js
@@ -1917,6 +1973,18 @@ declare module "util/types" {
      * @since v10.0.0
      */
     function isBigInt64Array(value: unknown): value is BigInt64Array;
+    /**
+     * Returns `true` if the value is a BigInt object, e.g. created
+     * by `Object(BigInt(123))`.
+     *
+     * ```js
+     * util.types.isBigIntObject(Object(BigInt(123)));   // Returns true
+     * util.types.isBigIntObject(BigInt(123));   // Returns false
+     * util.types.isBigIntObject(123);  // Returns false
+     * ```
+     * @since v10.4.0
+     */
+    function isBigIntObject(object: unknown): object is BigInt;
     /**
      * Returns `true` if the value is a `BigUint64Array` instance.
      *

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

@@ -69,7 +69,7 @@ declare module "vm" {
          * [Support of dynamic `import()` in compilation APIs](https://nodejs.org/docs/latest-v22.x/api/vm.html#support-of-dynamic-import-in-compilation-apis).
          */
         importModuleDynamically?:
-            | ((specifier: string, script: Script, importAttributes: ImportAttributes) => Module)
+            | ((specifier: string, script: Script, importAttributes: ImportAttributes) => Module | Promise<Module>)
             | typeof constants.USE_MAIN_CONTEXT_DEFAULT_LOADER
             | undefined;
     }

package/node_modules/@slack/web-api/node_modules/@types/node/README.md

@@ -8,7 +8,7 @@ This package contains type definitions for node (https://nodejs.org/).
 Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/node.
 
 ### Additional Details
- * Last updated: Fri, 03 Jan 2025 06:37:24 GMT
+ * Last updated: Fri, 21 Feb 2025 20:33:17 GMT
  * Dependencies: [undici-types](https://npmjs.com/package/undici-types)
 
 # Credits

package/node_modules/@slack/web-api/node_modules/@types/node/assert.d.ts

@@ -956,6 +956,59 @@ declare module "assert" {
          * @since v13.6.0, v12.16.0
          */
         function doesNotMatch(value: string, regExp: RegExp, message?: string | Error): void;
+        /**
+         * `assert.partialDeepStrictEqual()` Asserts the equivalence between the `actual` and `expected` parameters through a
+         * deep comparison, ensuring that all properties in the `expected` parameter are
+         * present in the `actual` parameter with equivalent values, not allowing type coercion.
+         * The main difference with `assert.deepStrictEqual()` is that `assert.partialDeepStrictEqual()` does not require
+         * all properties in the `actual` parameter to be present in the `expected` parameter.
+         * This method should always pass the same test cases as `assert.deepStrictEqual()`, behaving as a super set of it.
+         *
+         * ```js
+         * import assert from 'node:assert';
+         *
+         * assert.partialDeepStrictEqual({ a: 1, b: 2 }, { a: 1, b: 2 });
+         * // OK
+         *
+         * assert.partialDeepStrictEqual({ a: { b: { c: 1 } } }, { a: { b: { c: 1 } } });
+         * // OK
+         *
+         * assert.partialDeepStrictEqual({ a: 1, b: 2, c: 3 }, { a: 1, b: 2 });
+         * // OK
+         *
+         * assert.partialDeepStrictEqual(new Set(['value1', 'value2']), new Set(['value1', 'value2']));
+         * // OK
+         *
+         * assert.partialDeepStrictEqual(new Map([['key1', 'value1']]), new Map([['key1', 'value1']]));
+         * // OK
+         *
+         * assert.partialDeepStrictEqual(new Uint8Array([1, 2, 3]), new Uint8Array([1, 2, 3]));
+         * // OK
+         *
+         * assert.partialDeepStrictEqual(/abc/, /abc/);
+         * // OK
+         *
+         * assert.partialDeepStrictEqual([{ a: 5 }, { b: 5 }], [{ a: 5 }]);
+         * // OK
+         *
+         * assert.partialDeepStrictEqual(new Set([{ a: 1 }, { b: 1 }]), new Set([{ a: 1 }]));
+         * // OK
+         *
+         * assert.partialDeepStrictEqual(new Date(0), new Date(0));
+         * // OK
+         *
+         * assert.partialDeepStrictEqual({ a: 1 }, { a: 1, b: 2 });
+         * // AssertionError
+         *
+         * assert.partialDeepStrictEqual({ a: 1, b: '2' }, { a: 1, b: 2 });
+         * // AssertionError
+         *
+         * assert.partialDeepStrictEqual({ a: { b: 2 } }, { a: { b: '2' } });
+         * // AssertionError
+         * ```
+         * @since v22.13.0
+         */
+        function partialDeepStrictEqual(actual: unknown, expected: unknown, message?: string | Error): void;
         /**
          * In strict assertion mode, non-strict methods behave like their corresponding strict methods. For example,
          * {@link deepEqual} will behave like {@link deepStrictEqual}.
@@ -1015,6 +1068,7 @@ declare module "assert" {
                 | "deepStrictEqual"
                 | "ifError"
                 | "strict"
+                | "AssertionError"
             >
             & {
                 (value: unknown, message?: string | Error): asserts value;
@@ -1030,6 +1084,7 @@ declare module "assert" {
                 deepStrictEqual: typeof deepStrictEqual;
                 ifError: typeof ifError;
                 strict: typeof strict;
+                AssertionError: typeof AssertionError;
             };
     }
     export = assert;

package/node_modules/@slack/web-api/node_modules/@types/node/buffer.buffer.d.ts

@@ -107,7 +107,8 @@ declare module "buffer" {
              *
              * If `totalLength` is provided, it is coerced to an unsigned integer. If the
              * combined length of the `Buffer`s in `list` exceeds `totalLength`, the result is
-             * truncated to `totalLength`.
+             * truncated to `totalLength`. If the combined length of the `Buffer`s in `list` is
+             * less than `totalLength`, the remaining space is filled with zeros.
              *
              * ```js
              * import { Buffer } from 'node:buffer';

package/node_modules/@slack/web-api/node_modules/@types/node/dgram.d.ts

@@ -26,7 +26,7 @@
  * @see [source](https://github.com/nodejs/node/blob/v22.x/lib/dgram.js)
  */
 declare module "dgram" {
-    import { AddressInfo } from "node:net";
+    import { AddressInfo, BlockList } from "node:net";
     import * as dns from "node:dns";
     import { Abortable, EventEmitter } from "node:events";
     interface RemoteInfo {
@@ -45,6 +45,7 @@ declare module "dgram" {
     interface SocketOptions extends Abortable {
         type: SocketType;
         reuseAddr?: boolean | undefined;
+        reusePort?: boolean | undefined;
         /**
          * @default false
          */
@@ -58,6 +59,8 @@ declare module "dgram" {
                 callback: (err: NodeJS.ErrnoException | null, address: string, family: number) => void,
             ) => void)
             | undefined;
+        receiveBlockList?: BlockList | undefined;
+        sendBlockList?: BlockList | undefined;
     }
     /**
      * Creates a `dgram.Socket` object. Once the socket is created, calling `socket.bind()` will instruct the socket to begin listening for datagram
@@ -352,22 +355,22 @@ declare module "dgram" {
          * @param callback Called when the message has been sent.
          */
         send(
-            msg: string | Uint8Array | readonly any[],
+            msg: string | NodeJS.ArrayBufferView | readonly any[],
             port?: number,
             address?: string,
             callback?: (error: Error | null, bytes: number) => void,
         ): void;
         send(
-            msg: string | Uint8Array | readonly any[],
+            msg: string | NodeJS.ArrayBufferView | readonly any[],
             port?: number,
             callback?: (error: Error | null, bytes: number) => void,
         ): void;
         send(
-            msg: string | Uint8Array | readonly any[],
+            msg: string | NodeJS.ArrayBufferView | readonly any[],
             callback?: (error: Error | null, bytes: number) => void,
         ): void;
         send(
-            msg: string | Uint8Array,
+            msg: string | NodeJS.ArrayBufferView,
             offset: number,
             length: number,
             port?: number,
@@ -375,14 +378,14 @@ declare module "dgram" {
             callback?: (error: Error | null, bytes: number) => void,
         ): void;
         send(
-            msg: string | Uint8Array,
+            msg: string | NodeJS.ArrayBufferView,
             offset: number,
             length: number,
             port?: number,
             callback?: (error: Error | null, bytes: number) => void,
         ): void;
         send(
-            msg: string | Uint8Array,
+            msg: string | NodeJS.ArrayBufferView,
             offset: number,
             length: number,
             callback?: (error: Error | null, bytes: number) => void,

package/node_modules/@slack/web-api/node_modules/@types/node/fs/promises.d.ts

@@ -112,7 +112,7 @@ declare module "fs/promises" {
         appendFile(
             data: string | Uint8Array,
             options?:
-                | (ObjectEncodingOptions & FlagAndOpenMode & { flush?: boolean | undefined })
+                | (ObjectEncodingOptions & Abortable)
                 | BufferEncoding
                 | null,
         ): Promise<void>;
@@ -402,7 +402,7 @@ declare module "fs/promises" {
         writeFile(
             data: string | Uint8Array,
             options?:
-                | (ObjectEncodingOptions & FlagAndOpenMode & Abortable & { flush?: boolean | undefined })
+                | (ObjectEncodingOptions & Abortable)
                 | BufferEncoding
                 | null,
         ): Promise<void>;