cloudstructs 0.6.26 → 0.6.28

package/node_modules/@types/responselike/node_modules/@types/node/test.d.ts

@@ -7,16 +7,16 @@ declare module 'node:test' {
      * Programmatically start the test runner.
      * @since v18.9.0
      * @param options Configuration options for running tests.
-     * @returns A {@link TapStream} that emits events about the test execution.
+     * @returns A {@link TestsStream} that emits events about the test execution.
      */
-    function run(options?: RunOptions): TapStream;
+    function run(options?: RunOptions): TestsStream;
 
     /**
      * The `test()` function is the value imported from the test module. Each invocation of this
-     * function results in the creation of a test point in the TAP output.
+     * function results in reporting the test to the {@link TestsStream}.
      *
      * The {@link TestContext} object passed to the fn argument can be used to perform actions
-     * related to the current test. Examples include skipping the test, adding additional TAP
+     * related to the current test. Examples include skipping the test, adding additional
      * diagnostic information, or creating subtests.
      *
      * `test()` returns a {@link Promise} that resolves once the test completes. The return value
@@ -158,54 +158,88 @@ declare module 'node:test' {
     }
 
     /**
-     * A successful call of the `run()` method will return a new `TapStream` object,
-     * streaming a [TAP](https://testanything.org/) output.
-     * `TapStream` will emit events in the order of the tests' definitions.
+     * A successful call of the `run()` method will return a new `TestsStream` object,
+     * streaming a series of events representing the execution of the tests.
+     * `TestsStream` will emit events in the order of the tests' definitions.
      * @since v18.9.0
      */
-    interface TapStream extends NodeJS.ReadableStream {
-        addListener(event: 'test:diagnostic', listener: (message: string) => void): this;
+    interface TestsStream extends NodeJS.ReadableStream {
+        addListener(event: 'test:diagnostic', listener: (data: DiagnosticData) => void): this;
         addListener(event: 'test:fail', listener: (data: TestFail) => void): this;
         addListener(event: 'test:pass', listener: (data: TestPass) => void): this;
+        addListener(event: 'test:plan', listener: (data: TestPlan) => void): this;
+        addListener(event: 'test:start', listener: (data: TestStart) => void): this;
         addListener(event: string, listener: (...args: any[]) => void): this;
-        emit(event: 'test:diagnostic', message: string): boolean;
+        emit(event: 'test:diagnostic', data: DiagnosticData): boolean;
         emit(event: 'test:fail', data: TestFail): boolean;
         emit(event: 'test:pass', data: TestPass): boolean;
+        emit(event: 'test:plan', data: TestPlan): boolean;
+        emit(event: 'test:start', data: TestStart): boolean;
         emit(event: string | symbol, ...args: any[]): boolean;
-        on(event: 'test:diagnostic', listener: (message: string) => void): this;
+        on(event: 'test:diagnostic', listener: (data: DiagnosticData) => void): this;
         on(event: 'test:fail', listener: (data: TestFail) => void): this;
         on(event: 'test:pass', listener: (data: TestPass) => void): this;
+        on(event: 'test:plan', listener: (data: TestPlan) => void): this;
+        on(event: 'test:start', listener: (data: TestStart) => void): this;
         on(event: string, listener: (...args: any[]) => void): this;
-        once(event: 'test:diagnostic', listener: (message: string) => void): this;
+        once(event: 'test:diagnostic', listener: (data: DiagnosticData) => void): this;
         once(event: 'test:fail', listener: (data: TestFail) => void): this;
         once(event: 'test:pass', listener: (data: TestPass) => void): this;
+        once(event: 'test:plan', listener: (data: TestPlan) => void): this;
+        once(event: 'test:start', listener: (data: TestStart) => void): this;
         once(event: string, listener: (...args: any[]) => void): this;
-        prependListener(event: 'test:diagnostic', listener: (message: string) => void): this;
+        prependListener(event: 'test:diagnostic', listener: (data: DiagnosticData) => void): this;
         prependListener(event: 'test:fail', listener: (data: TestFail) => void): this;
         prependListener(event: 'test:pass', listener: (data: TestPass) => void): this;
+        prependListener(event: 'test:plan', listener: (data: TestPlan) => void): this;
+        prependListener(event: 'test:start', listener: (data: TestStart) => void): this;
         prependListener(event: string, listener: (...args: any[]) => void): this;
-        prependOnceListener(event: 'test:diagnostic', listener: (message: string) => void): this;
+        prependOnceListener(event: 'test:diagnostic', listener: (data: DiagnosticData) => void): this;
         prependOnceListener(event: 'test:fail', listener: (data: TestFail) => void): this;
         prependOnceListener(event: 'test:pass', listener: (data: TestPass) => void): this;
+        prependOnceListener(event: 'test:plan', listener: (data: TestPlan) => void): this;
+        prependOnceListener(event: 'test:start', listener: (data: TestStart) => void): this;
         prependOnceListener(event: string, listener: (...args: any[]) => void): this;
     }
 
-    interface TestFail {
+    interface DiagnosticData {
+        /**
+         * The diagnostic message.
+         */
+        message: string;
+
         /**
-         * The test duration.
+         * The nesting level of the test.
          */
-        duration: number;
+        nesting: number;
+    }
 
+    interface TestFail {
         /**
-         * The failure casing test to fail.
+         * Additional execution metadata.
          */
-        error: Error;
+        details: {
+            /**
+             * The duration of the test in milliseconds.
+             */
+            duration: number;
+
+            /**
+             * The error thrown by the test.
+             */
+            error: Error;
+        };
 
         /**
          * The test name.
          */
         name: string;
 
+        /**
+         * The nesting level of the test.
+         */
+        nesting: number;
+
         /**
          * The ordinal number of the test.
          */
@@ -214,25 +248,35 @@ declare module 'node:test' {
         /**
          * Present if `context.todo` is called.
          */
-        todo?: string;
+        todo?: string | boolean;
 
         /**
          * Present if `context.skip` is called.
          */
-        skip?: string;
+        skip?: string | boolean;
     }
 
     interface TestPass {
         /**
-         * The test duration.
+         * Additional execution metadata.
          */
-        duration: number;
+        details: {
+            /**
+             * The duration of the test in milliseconds.
+             */
+            duration: number;
+        };
 
         /**
          * The test name.
          */
         name: string;
 
+        /**
+         * The nesting level of the test.
+         */
+        nesting: number;
+
         /**
          * The ordinal number of the test.
          */
@@ -241,12 +285,36 @@ declare module 'node:test' {
         /**
          * Present if `context.todo` is called.
          */
-        todo?: string;
+        todo?: string | boolean;
 
         /**
          * Present if `context.skip` is called.
          */
-        skip?: string;
+        skip?: string | boolean;
+    }
+
+    interface TestPlan {
+        /**
+         * The nesting level of the test.
+         */
+        nesting: number;
+
+        /**
+         * The number of subtests that have ran.
+         */
+        count: number;
+    }
+
+    interface TestStart {
+        /**
+         * The test name.
+         */
+        name: string;
+
+        /**
+         * The nesting level of the test.
+         */
+        nesting: number;
     }
 
     /**
@@ -283,9 +351,9 @@ declare module 'node:test' {
         afterEach: typeof afterEach;
 
         /**
-         * This function is used to write TAP diagnostics to the output. Any diagnostic information is
+         * This function is used to write diagnostics to the output. Any diagnostic information is
          * included at the end of the test's results. This function does not return a value.
-         * @param message Message to be displayed as a TAP diagnostic.
+         * @param message Message to be reported.
          * @since v18.0.0
          */
         diagnostic(message: string): void;
@@ -313,18 +381,18 @@ declare module 'node:test' {
 
         /**
          * This function causes the test's output to indicate the test as skipped. If `message` is
-         * provided, it is included in the TAP output. Calling `skip()` does not terminate execution of
+         * provided, it is included in the output. Calling `skip()` does not terminate execution of
          * the test function. This function does not return a value.
-         * @param message Optional skip message to be displayed in TAP output.
+         * @param message Optional skip message.
          * @since v18.0.0
          */
         skip(message?: string): void;
 
         /**
          * This function adds a `TODO` directive to the test's output. If `message` is provided, it is
-         * included in the TAP output. Calling `todo()` does not terminate execution of the test
+         * included in the output. Calling `todo()` does not terminate execution of the test
          * function. This function does not return a value.
-         * @param message Optional `TODO` message to be displayed in TAP output.
+         * @param message Optional `TODO` message.
          * @since v18.0.0
          */
         todo(message?: string): void;

package/node_modules/@types/responselike/node_modules/@types/node/ts4.8/diagnostics_channel.d.ts

@@ -20,7 +20,7 @@
  * should generally include the module name to avoid collisions with data from
  * other modules.
  * @experimental
- * @see [source](https://github.com/nodejs/node/blob/v18.0.0/lib/diagnostics_channel.js)
+ * @see [source](https://github.com/nodejs/node/blob/v18.7.0/lib/diagnostics_channel.js)
  */
 declare module 'diagnostics_channel' {
     /**
@@ -58,6 +58,45 @@ declare module 'diagnostics_channel' {
      */
     function channel(name: string | symbol): Channel;
     type ChannelListener = (message: unknown, name: string | symbol) => void;
+    /**
+     * Register a message handler to subscribe to this channel. This message handler will be run synchronously
+     * whenever a message is published to the channel. Any errors thrown in the message handler will
+     * trigger an 'uncaughtException'.
+     *
+     * ```js
+     * import diagnostics_channel from 'diagnostics_channel';
+     *
+     * diagnostics_channel.subscribe('my-channel', (message, name) => {
+     *   // Received data
+     * });
+     * ```
+     *
+     * @since v18.7.0, v16.17.0
+     * @param name The channel name
+     * @param onMessage The handler to receive channel messages
+     */
+    function subscribe(name: string | symbol, onMessage: ChannelListener): void;
+    /**
+     * Remove a message handler previously registered to this channel with diagnostics_channel.subscribe(name, onMessage).
+     *
+     * ```js
+     * import diagnostics_channel from 'diagnostics_channel';
+     *
+     * function onMessage(message, name) {
+     *  // Received data
+     * }
+     *
+     * diagnostics_channel.subscribe('my-channel', onMessage);
+     *
+     * diagnostics_channel.unsubscribe('my-channel', onMessage);
+     * ```
+     *
+     * @since v18.7.0, v16.17.0
+     * @param name The channel name
+     * @param onMessage The previous subscribed handler to remove
+     * @returns `true` if the handler was found, `false` otherwise
+     */
+    function unsubscribe(name: string | symbol, onMessage: ChannelListener): boolean;
     /**
      * The class `Channel` represents an individual named channel within the data
      * pipeline. It is use to track subscribers and to publish messages when there

package/node_modules/@types/responselike/node_modules/@types/node/ts4.8/dns.d.ts

@@ -174,7 +174,7 @@ declare module 'dns' {
         type: 'AAAA';
     }
     export interface CaaRecord {
-        critial: number;
+        critical: number;
         issue?: string | undefined;
         issuewild?: string | undefined;
         iodef?: string | undefined;

package/node_modules/@types/responselike/node_modules/@types/node/ts4.8/http2.d.ts

@@ -1053,7 +1053,6 @@ declare module 'http2' {
          */
         unknownProtocolTimeout?: number | undefined;
         selectPadding?(frameLen: number, maxFrameLen: number): number;
-        createConnection?(authority: url.URL, option: SessionOptions): stream.Duplex;
     }
     export interface ClientSessionOptions extends SessionOptions {
         maxReservedRemoteStreams?: number | undefined;

package/node_modules/@types/responselike/node_modules/@types/node/ts4.8/process.d.ts

@@ -1089,6 +1089,12 @@ 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.
+                 */
+                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

package/node_modules/@types/responselike/node_modules/@types/node/ts4.8/stream.d.ts

@@ -912,6 +912,105 @@ declare module 'stream' {
             end(chunk: any, encoding?: BufferEncoding, cb?: () => void): this;
             cork(): void;
             uncork(): void;
+            /**
+             * Event emitter
+             * The defined events on documents including:
+             * 1.  close
+             * 2.  data
+             * 3.  drain
+             * 4.  end
+             * 5.  error
+             * 6.  finish
+             * 7.  pause
+             * 8.  pipe
+             * 9.  readable
+             * 10. resume
+             * 11. unpipe
+             */
+            addListener(event: 'close', listener: () => void): this;
+            addListener(event: 'data', listener: (chunk: any) => void): this;
+            addListener(event: 'drain', listener: () => void): this;
+            addListener(event: 'end', listener: () => void): this;
+            addListener(event: 'error', listener: (err: Error) => void): this;
+            addListener(event: 'finish', listener: () => void): this;
+            addListener(event: 'pause', listener: () => void): this;
+            addListener(event: 'pipe', listener: (src: Readable) => void): this;
+            addListener(event: 'readable', listener: () => void): this;
+            addListener(event: 'resume', listener: () => void): this;
+            addListener(event: 'unpipe', listener: (src: Readable) => void): this;
+            addListener(event: string | symbol, listener: (...args: any[]) => void): this;
+            emit(event: 'close'): boolean;
+            emit(event: 'data', chunk: any): boolean;
+            emit(event: 'drain'): boolean;
+            emit(event: 'end'): boolean;
+            emit(event: 'error', err: Error): boolean;
+            emit(event: 'finish'): boolean;
+            emit(event: 'pause'): boolean;
+            emit(event: 'pipe', src: Readable): boolean;
+            emit(event: 'readable'): boolean;
+            emit(event: 'resume'): boolean;
+            emit(event: 'unpipe', src: Readable): boolean;
+            emit(event: string | symbol, ...args: any[]): boolean;
+            on(event: 'close', listener: () => void): this;
+            on(event: 'data', listener: (chunk: any) => void): this;
+            on(event: 'drain', listener: () => void): this;
+            on(event: 'end', listener: () => void): this;
+            on(event: 'error', listener: (err: Error) => void): this;
+            on(event: 'finish', listener: () => void): this;
+            on(event: 'pause', listener: () => void): this;
+            on(event: 'pipe', listener: (src: Readable) => void): this;
+            on(event: 'readable', listener: () => void): this;
+            on(event: 'resume', listener: () => void): this;
+            on(event: 'unpipe', listener: (src: Readable) => void): this;
+            on(event: string | symbol, listener: (...args: any[]) => void): this;
+            once(event: 'close', listener: () => void): this;
+            once(event: 'data', listener: (chunk: any) => void): this;
+            once(event: 'drain', listener: () => void): this;
+            once(event: 'end', listener: () => void): this;
+            once(event: 'error', listener: (err: Error) => void): this;
+            once(event: 'finish', listener: () => void): this;
+            once(event: 'pause', listener: () => void): this;
+            once(event: 'pipe', listener: (src: Readable) => void): this;
+            once(event: 'readable', listener: () => void): this;
+            once(event: 'resume', listener: () => void): this;
+            once(event: 'unpipe', listener: (src: Readable) => void): this;
+            once(event: string | symbol, listener: (...args: any[]) => void): this;
+            prependListener(event: 'close', listener: () => void): this;
+            prependListener(event: 'data', listener: (chunk: any) => void): this;
+            prependListener(event: 'drain', listener: () => void): this;
+            prependListener(event: 'end', listener: () => void): this;
+            prependListener(event: 'error', listener: (err: Error) => void): this;
+            prependListener(event: 'finish', listener: () => void): this;
+            prependListener(event: 'pause', listener: () => void): this;
+            prependListener(event: 'pipe', listener: (src: Readable) => void): this;
+            prependListener(event: 'readable', listener: () => void): this;
+            prependListener(event: 'resume', listener: () => void): this;
+            prependListener(event: 'unpipe', listener: (src: Readable) => void): this;
+            prependListener(event: string | symbol, listener: (...args: any[]) => void): this;
+            prependOnceListener(event: 'close', listener: () => void): this;
+            prependOnceListener(event: 'data', listener: (chunk: any) => void): this;
+            prependOnceListener(event: 'drain', listener: () => void): this;
+            prependOnceListener(event: 'end', listener: () => void): this;
+            prependOnceListener(event: 'error', listener: (err: Error) => void): this;
+            prependOnceListener(event: 'finish', listener: () => void): this;
+            prependOnceListener(event: 'pause', listener: () => void): this;
+            prependOnceListener(event: 'pipe', listener: (src: Readable) => void): this;
+            prependOnceListener(event: 'readable', listener: () => void): this;
+            prependOnceListener(event: 'resume', listener: () => void): this;
+            prependOnceListener(event: 'unpipe', listener: (src: Readable) => void): this;
+            prependOnceListener(event: string | symbol, listener: (...args: any[]) => void): this;
+            removeListener(event: 'close', listener: () => void): this;
+            removeListener(event: 'data', listener: (chunk: any) => void): this;
+            removeListener(event: 'drain', listener: () => void): this;
+            removeListener(event: 'end', listener: () => void): this;
+            removeListener(event: 'error', listener: (err: Error) => void): this;
+            removeListener(event: 'finish', listener: () => void): this;
+            removeListener(event: 'pause', listener: () => void): this;
+            removeListener(event: 'pipe', listener: (src: Readable) => void): this;
+            removeListener(event: 'readable', listener: () => void): this;
+            removeListener(event: 'resume', listener: () => void): this;
+            removeListener(event: 'unpipe', listener: (src: Readable) => void): this;
+            removeListener(event: string | symbol, listener: (...args: any[]) => void): this;
         }
         type TransformCallback = (error?: Error | null, data?: any) => void;
         interface TransformOptions extends DuplexOptions {