cloudstructs 0.6.21 → 0.6.23

package/node_modules/@types/cacheable-request/node_modules/@types/node/test.d.ts

@@ -342,6 +342,10 @@ declare module 'node:test' {
          * @returns A {@link Promise} resolved with `undefined` once the test completes.
          */
         test: typeof test;
+        /**
+         * Each test provides its own MockTracker instance.
+         */
+        readonly mock: MockTracker;
     }
 
     interface TestOptions {
@@ -451,5 +455,238 @@ declare module 'node:test' {
         timeout?: number | undefined;
     }
 
-    export { test as default, run, test, describe, it, before, after, beforeEach, afterEach };
+    interface MockFunctionOptions {
+        /**
+         * The number of times that the mock will use the behavior of `implementation`.
+         * Once the mock function has been called `times` times,
+         * it will automatically restore the behavior of `original`.
+         * This value must be an integer greater than zero.
+         * @default Infinity
+         */
+        times?: number | undefined;
+    }
+
+    interface MockMethodOptions extends MockFunctionOptions {
+        /**
+         * If `true`, `object[methodName]` is treated as a getter.
+         * This option cannot be used with the `setter` option.
+         */
+        getter?: boolean | undefined;
+
+        /**
+         * If `true`, `object[methodName]` is treated as a setter.
+         * This option cannot be used with the `getter` option.
+         */
+        setter?: boolean | undefined;
+    }
+
+    type Mock<F extends Function> = F & {
+        mock: MockFunctionContext<F>;
+    };
+
+    type NoOpFunction = (...args: any[]) => undefined;
+
+    type FunctionPropertyNames<T> = {
+        [K in keyof T]: T[K] extends Function ? K : never;
+    }[keyof T];
+
+    interface MockTracker {
+        /**
+         * This function is used to create a mock function.
+         * @param original An optional function to create a mock on.
+         * @param implementation An optional function used as the mock implementation for `original`.
+         *  This is useful for creating mocks that exhibit one behavior for a specified number of calls and then restore the behavior of `original`.
+         * @param options Optional configuration options for the mock function.
+         */
+        fn<F extends Function = NoOpFunction>(original?: F, options?: MockFunctionOptions): Mock<F>;
+        fn<F extends Function = NoOpFunction, Implementation extends Function = F>(original?: F, implementation?: Implementation, options?: MockFunctionOptions): Mock<F | Implementation>;
+
+        /**
+         * This function is used to create a mock on an existing object method.
+         * @param object The object whose method is being mocked.
+         * @param methodName The identifier of the method on `object` to mock. If `object[methodName]` is not a function, an error is thrown.
+         * @param implementation An optional function used as the mock implementation for `object[methodName]`.
+         * @param options Optional configuration options for the mock method.
+         */
+        method<
+            MockedObject extends object,
+            MethodName extends FunctionPropertyNames<MockedObject>,
+        >(
+            object: MockedObject,
+            methodName: MethodName,
+            options?: MockFunctionOptions,
+        ): MockedObject[MethodName] extends Function
+            ? Mock<MockedObject[MethodName]>
+            : never;
+        method<
+            MockedObject extends object,
+            MethodName extends FunctionPropertyNames<MockedObject>,
+            Implementation extends Function,
+        >(
+            object: MockedObject,
+            methodName: MethodName,
+            implementation: Implementation,
+            options?: MockFunctionOptions,
+        ): MockedObject[MethodName] extends Function
+            ? Mock<MockedObject[MethodName] | Implementation>
+            : never;
+        method<MockedObject extends object>(
+            object: MockedObject,
+            methodName: keyof MockedObject,
+            options: MockMethodOptions,
+        ): Mock<Function>;
+        method<MockedObject extends object>(
+            object: MockedObject,
+            methodName: keyof MockedObject,
+            implementation: Function,
+            options: MockMethodOptions,
+        ): Mock<Function>;
+
+        /**
+         * This function is syntax sugar for {@link MockTracker.method} with `options.getter` set to `true`.
+         */
+        getter<
+            MockedObject extends object,
+            MethodName extends keyof MockedObject,
+        >(
+            object: MockedObject,
+            methodName: MethodName,
+            options?: MockFunctionOptions,
+        ): Mock<() => MockedObject[MethodName]>;
+        getter<
+            MockedObject extends object,
+            MethodName extends keyof MockedObject,
+            Implementation extends Function,
+        >(
+            object: MockedObject,
+            methodName: MethodName,
+            implementation?: Implementation,
+            options?: MockFunctionOptions,
+        ): Mock<(() => MockedObject[MethodName]) | Implementation>;
+
+        /**
+         * This function is syntax sugar for {@link MockTracker.method} with `options.setter` set to `true`.
+         */
+        setter<
+            MockedObject extends object,
+            MethodName extends keyof MockedObject,
+        >(
+            object: MockedObject,
+            methodName: MethodName,
+            options?: MockFunctionOptions,
+        ): Mock<(value: MockedObject[MethodName]) => void>;
+        setter<
+            MockedObject extends object,
+            MethodName extends keyof MockedObject,
+            Implementation extends Function,
+        >(
+            object: MockedObject,
+            methodName: MethodName,
+            implementation?: Implementation,
+            options?: MockFunctionOptions,
+        ): Mock<((value: MockedObject[MethodName]) => void) | Implementation>;
+
+        /**
+         * This function restores the default behavior of all mocks that were previously created by this `MockTracker`
+         * and disassociates the mocks from the `MockTracker` instance. Once disassociated, the mocks can still be used,
+         * but the `MockTracker` instance can no longer be used to reset their behavior or otherwise interact with them.
+         *
+         * After each test completes, this function is called on the test context's `MockTracker`.
+         * If the global `MockTracker` is used extensively, calling this function manually is recommended.
+         */
+        reset(): void;
+
+        /**
+         * This function restores the default behavior of all mocks that were previously created by this `MockTracker`.
+         * Unlike `mock.reset()`, `mock.restoreAll()` does not disassociate the mocks from the `MockTracker` instance.
+         */
+        restoreAll(): void;
+    }
+
+    const mock: MockTracker;
+
+    interface MockFunctionCall<
+        F extends Function,
+        ReturnType = F extends (...args: any) => infer T
+            ? T
+            : F extends abstract new (...args: any) => infer T
+                ? T
+                : unknown,
+        Args = F extends (...args: infer Y) => any
+            ? Y
+            : F extends abstract new (...args: infer Y) => any
+                ? Y
+                : unknown[],
+    > {
+        /**
+         * An array of the arguments passed to the mock function.
+         */
+        arguments: Args;
+        /**
+         * If the mocked function threw then this property contains the thrown value.
+         */
+        error: unknown | undefined;
+        /**
+         * The value returned by the mocked function.
+         *
+         * If the mocked function threw, it will be `undefined`.
+         */
+        result: ReturnType | undefined;
+        /**
+         * An `Error` object whose stack can be used to determine the callsite of the mocked function invocation.
+         */
+        stack: Error;
+        /**
+         * If the mocked function is a constructor, this field contains the class being constructed.
+         * Otherwise this will be `undefined`.
+         */
+        target: F extends abstract new (...args: any) => any ? F : undefined;
+        /**
+         * The mocked function's `this` value.
+         */
+        this: unknown;
+    }
+
+    interface MockFunctionContext<F extends Function> {
+        /**
+         * A getter that returns a copy of the internal array used to track calls to the mock.
+         */
+        readonly calls: Array<MockFunctionCall<F>>;
+
+        /**
+         * This function returns the number of times that this mock has been invoked.
+         * This function is more efficient than checking `ctx.calls.length`
+         * because `ctx.calls` is a getter that creates a copy of the internal call tracking array.
+         */
+        callCount(): number;
+
+        /**
+         * This function is used to change the behavior of an existing mock.
+         * @param implementation The function to be used as the mock's new implementation.
+         */
+        mockImplementation(implementation: Function): void;
+
+        /**
+         * This function is used to change the behavior of an existing mock for a single invocation.
+         * Once invocation `onCall` has occurred, the mock will revert to whatever behavior
+         * it would have used had `mockImplementationOnce()` not been called.
+         * @param implementation The function to be used as the mock's implementation for the invocation number specified by `onCall`.
+         * @param onCall The invocation number that will use `implementation`.
+         *  If the specified invocation has already occurred then an exception is thrown.
+         */
+        mockImplementationOnce(implementation: Function, onCall?: number): void;
+
+        /**
+         * Resets the call history of the mock function.
+         */
+        resetCalls(): void;
+
+        /**
+         * Resets the implementation of the mock function to its original behavior.
+         * The mock can still be used after calling this function.
+         */
+        restore(): void;
+    }
+
+    export { test as default, run, test, describe, it, before, after, beforeEach, afterEach, mock };
 }

package/node_modules/@types/cacheable-request/node_modules/@types/node/timers.d.ts

@@ -62,6 +62,13 @@ declare module 'timers' {
                 [Symbol.toPrimitive](): number;
             }
         }
+        /**
+         * Schedules execution of a one-time `callback` after `delay` milliseconds. The `callback` will likely not be invoked in precisely `delay` milliseconds.
+         * Node.js makes no guarantees about the exact timing of when callbacks will fire, nor of their ordering. The callback will be called as close as possible to the time specified.
+         * When `delay` is larger than `2147483647` or less than `1`, the `delay` will be set to `1`. Non-integer delays are truncated to an integer.
+         * If `callback` is not a function, a [TypeError](https://nodejs.org/api/errors.html#class-typeerror) will be thrown.
+         * @since v0.0.1
+         */
         function setTimeout<TArgs extends any[]>(callback: (...args: TArgs) => void, ms?: number, ...args: TArgs): NodeJS.Timeout;
         // util.promisify no rest args compability
         // tslint:disable-next-line void-return

package/node_modules/@types/cacheable-request/node_modules/@types/node/ts4.8/buffer.d.ts

@@ -46,6 +46,8 @@
 declare module 'buffer' {
     import { BinaryLike } from 'node:crypto';
     import { ReadableStream as WebReadableStream } from 'node:stream/web';
+    export function isUtf8(input: Buffer | ArrayBuffer | NodeJS.TypedArray): boolean;
+    export function isAscii(input: Buffer | ArrayBuffer | NodeJS.TypedArray): boolean;
     export const INSPECT_MAX_BYTES: number;
     export const kMaxLength: number;
     export const kStringMaxLength: number;
@@ -163,18 +165,57 @@ declare module 'buffer' {
          */
         stream(): WebReadableStream;
     }
+    export interface FileOptions {
+        /**
+         * One of either `'transparent'` or `'native'`. When set to `'native'`, line endings in string source parts will be
+         * converted to the platform native line-ending as specified by `require('node:os').EOL`.
+         */
+        endings?: 'native' | 'transparent';
+        /** The File content-type. */
+        type?: string;
+        /** The last modified date of the file. `Default`: Date.now(). */
+        lastModified?: number;
+    }
+    /**
+     * A [`File`](https://developer.mozilla.org/en-US/docs/Web/API/File) provides information about files.
+     * @experimental
+     * @since v18.13.0
+     */
+    export class File extends Blob {
+        constructor(sources: Array<BinaryLike | Blob>, fileName: string, options?: FileOptions);
+        /**
+         * The name of the `File`.
+         * @since v18.13.0
+         */
+        readonly name: string;
+        /**
+         * The last modified date of the `File`.
+         * @since v18.13.0
+         */
+        readonly lastModified: number;
+    }
     export import atob = globalThis.atob;
     export import btoa = globalThis.btoa;
 
     import { Blob as NodeBlob } from 'buffer';
     // This conditional type will be the existing global Blob in a browser, or
     // the copy below in a Node environment.
-    type __Blob = typeof globalThis extends { onmessage: any, Blob: any }
-        ? {} : NodeBlob;
+    type __Blob = typeof globalThis extends { onmessage: any; Blob: any } ? {} : NodeBlob;
 
     global {
         // Buffer class
-        type BufferEncoding = 'ascii' | 'utf8' | 'utf-8' | 'utf16le' | 'ucs2' | 'ucs-2' | 'base64' | 'base64url' | 'latin1' | 'binary' | 'hex';
+        type BufferEncoding =
+            | 'ascii'
+            | 'utf8'
+            | 'utf-8'
+            | 'utf16le'
+            | 'ucs2'
+            | 'ucs-2'
+            | 'base64'
+            | 'base64url'
+            | 'latin1'
+            | 'binary'
+            | 'hex';
         type WithImplicitCoercion<T> =
             | T
             | {
@@ -248,7 +289,11 @@ declare module 'buffer' {
              * `Buffer.from(array)` and `Buffer.from(string)` may also use the internal`Buffer` pool like `Buffer.allocUnsafe()` does.
              * @since v5.10.0
              */
-            from(arrayBuffer: WithImplicitCoercion<ArrayBuffer | SharedArrayBuffer>, byteOffset?: number, length?: number): Buffer;
+            from(
+                arrayBuffer: WithImplicitCoercion<ArrayBuffer | SharedArrayBuffer>,
+                byteOffset?: number,
+                length?: number,
+            ): Buffer;
             /**
              * Creates a new Buffer using the passed {data}
              * @param data data to create a new Buffer
@@ -266,7 +311,7 @@ declare module 'buffer' {
                     | {
                           [Symbol.toPrimitive](hint: 'string'): string;
                       },
-                encoding?: BufferEncoding
+                encoding?: BufferEncoding,
             ): Buffer;
             /**
              * Creates a new Buffer using the passed {data}
@@ -340,7 +385,10 @@ declare module 'buffer' {
              * @param [encoding='utf8'] If `string` is a string, this is its encoding.
              * @return The number of bytes contained within `string`.
              */
-            byteLength(string: string | NodeJS.ArrayBufferView | ArrayBuffer | SharedArrayBuffer, encoding?: BufferEncoding): number;
+            byteLength(
+                string: string | NodeJS.ArrayBufferView | ArrayBuffer | SharedArrayBuffer,
+                encoding?: BufferEncoding,
+            ): number;
             /**
              * Returns a new `Buffer` which is the result of concatenating all the `Buffer`instances in the `list` together.
              *
@@ -711,7 +759,13 @@ declare module 'buffer' {
              * @param [sourceStart=0] The offset within `buf` at which to begin comparison.
              * @param [sourceEnd=buf.length] The offset within `buf` at which to end comparison (not inclusive).
              */
-            compare(target: Uint8Array, targetStart?: number, targetEnd?: number, sourceStart?: number, sourceEnd?: number): -1 | 0 | 1;
+            compare(
+                target: Uint8Array,
+                targetStart?: number,
+                targetEnd?: number,
+                sourceStart?: number,
+                sourceEnd?: number,
+            ): -1 | 0 | 1;
             /**
              * Copies data from a region of `buf` to a region in `target`, even if the `target`memory region overlaps with `buf`.
              *

package/node_modules/@types/cacheable-request/node_modules/@types/node/ts4.8/crypto.d.ts

@@ -1190,11 +1190,13 @@ declare module 'crypto' {
         format?: KeyFormat | undefined;
         type?: 'pkcs1' | 'pkcs8' | 'sec1' | undefined;
         passphrase?: string | Buffer | undefined;
+        encoding?: string | undefined;
     }
     interface PublicKeyInput {
         key: string | Buffer;
         format?: KeyFormat | undefined;
         type?: 'pkcs1' | 'spki' | undefined;
+        encoding?: string | undefined;
     }
     /**
      * Asynchronously generates a new random secret key of the given `length`. The`type` will determine which validations will be performed on the `length`.
@@ -1305,6 +1307,7 @@ declare module 'crypto' {
     interface VerifyKeyObjectInput extends SigningOptions {
         key: KeyObject;
     }
+    interface VerifyJsonWebKeyInput extends JsonWebKeyInput, SigningOptions {}
     type KeyLike = string | Buffer | KeyObject;
     /**
      * The `Sign` class is a utility for generating signatures. It can be used in one
@@ -1459,8 +1462,8 @@ declare module 'crypto' {
          * be passed instead of a public key.
          * @since v0.1.92
          */
-        verify(object: KeyLike | VerifyKeyObjectInput | VerifyPublicKeyInput, signature: NodeJS.ArrayBufferView): boolean;
-        verify(object: KeyLike | VerifyKeyObjectInput | VerifyPublicKeyInput, signature: string, signature_format?: BinaryToTextEncoding): boolean;
+        verify(object: KeyLike | VerifyKeyObjectInput | VerifyPublicKeyInput | VerifyJsonWebKeyInput, signature: NodeJS.ArrayBufferView): boolean;
+        verify(object: KeyLike | VerifyKeyObjectInput | VerifyPublicKeyInput | VerifyJsonWebKeyInput, signature: string, signature_format?: BinaryToTextEncoding): boolean;
     }
     /**
      * Creates a `DiffieHellman` key exchange object using the supplied `prime` and an
@@ -2968,11 +2971,16 @@ declare module 'crypto' {
      * If the `callback` function is provided this function uses libuv's threadpool.
      * @since v12.0.0
      */
-    function verify(algorithm: string | null | undefined, data: NodeJS.ArrayBufferView, key: KeyLike | VerifyKeyObjectInput | VerifyPublicKeyInput, signature: NodeJS.ArrayBufferView): boolean;
     function verify(
         algorithm: string | null | undefined,
         data: NodeJS.ArrayBufferView,
-        key: KeyLike | VerifyKeyObjectInput | VerifyPublicKeyInput,
+        key: KeyLike | VerifyKeyObjectInput | VerifyPublicKeyInput | VerifyJsonWebKeyInput,
+        signature: NodeJS.ArrayBufferView
+    ): boolean;
+    function verify(
+        algorithm: string | null | undefined,
+        data: NodeJS.ArrayBufferView,
+        key: KeyLike | VerifyKeyObjectInput | VerifyPublicKeyInput | VerifyJsonWebKeyInput,
         signature: NodeJS.ArrayBufferView,
         callback: (error: Error | null, result: boolean) => void
     ): void;

package/node_modules/@types/cacheable-request/node_modules/@types/node/ts4.8/globals.d.ts

@@ -53,7 +53,7 @@ interface AbortController {
     /**
      * Invoking this method will set this object's AbortSignal's aborted flag and signal to any observers that the associated activity is to be aborted.
      */
-    abort(): void;
+    abort(reason?: any): void;
 }
 
 /** A signal object that allows you to communicate with a DOM request (such as a Fetch) and abort it if required via an AbortController object. */

package/node_modules/@types/cacheable-request/node_modules/@types/node/ts4.8/net.d.ts

@@ -290,6 +290,12 @@ declare module 'net' {
          * @since v18.8.0
          */
         readonly localFamily?: string;
+        /**
+         * This is `true` if the socket is not connected yet, either because `.connect()`
+         * has not yet been called or because it is still in the process of connecting (see `socket.connecting`).
+         * @since v10.16.0
+         */
+        readonly pending: boolean;
         /**
          * This property represents the state of the connection as a string.
          * @see {https://nodejs.org/api/net.html#socketreadystate}

package/node_modules/@types/cacheable-request/node_modules/@types/node/ts4.8/os.d.ts

@@ -132,6 +132,13 @@ declare module 'os' {
      * @since v0.3.3
      */
     function cpus(): CpuInfo[];
+    /**
+     * Returns an estimate of the default amount of parallelism a program should use. Always returns a value greater than zero.
+     *
+     * This function is a small wrapper about libuv's [`uv_available_parallelism()`](https://docs.libuv.org/en/v1.x/misc.html#c.uv_available_parallelism).
+     * @since 18.4.0
+     */
+    function availableParallelism(): number;
     /**
      * Returns the operating system name as returned by [`uname(3)`](https://linux.die.net/man/3/uname). For example, it
      * returns `'Linux'` on Linux, `'Darwin'` on macOS, and `'Windows_NT'` on Windows.