cloudstructs 0.6.47 → 0.6.49

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

@@ -82,6 +82,11 @@ declare module "node:test" {
     import { Readable } from "node:stream";
     import { AsyncResource } from "node:async_hooks";
     /**
+     * **Note:**`shard` is used to horizontally parallelize test running across
+     * machines or processes, ideal for large-scale executions across varied
+     * environments. It's incompatible with `watch` mode, tailored for rapid
+     * code iteration by automatically rerunning tests on file changes.
+     *
      * ```js
      * import { tap } from 'node:test/reporters';
      * import { run } from 'node:test';
@@ -1007,12 +1012,20 @@ declare module "node:test" {
          */
         restore(): void;
     }
-    type Timer = "setInterval" | "clearInterval" | "setTimeout" | "clearTimeout";
+    type Timer = "setInterval" | "setTimeout" | "setImmediate" | "Date";
+
+    interface MockTimersOptions {
+        apis: Timer[];
+        now?: number | Date;
+    }
     /**
      * Mocking timers is a technique commonly used in software testing to simulate and
      * control the behavior of timers, such as `setInterval` and `setTimeout`,
      * without actually waiting for the specified time intervals.
      *
+     * The MockTimers API also allows for mocking of the `Date` constructor and
+     * `setImmediate`/`clearImmediate` functions.
+     *
      * The `MockTracker` provides a top-level `timers` export
      * which is a `MockTimers` instance.
      * @since v20.4.0
@@ -1025,24 +1038,66 @@ declare module "node:test" {
          * **Note:** When you enable mocking for a specific timer, its associated
          * clear function will also be implicitly mocked.
          *
-         * Example usage:
+         * **Note:** Mocking `Date` will affect the behavior of the mocked timers
+         * as they use the same internal clock.
+         *
+         * Example usage without setting initial time:
+         *
+         * ```js
+         * import { mock } from 'node:test';
+         * mock.timers.enable({ apis: ['setInterval', 'Date'], now: 1234 });
+         * ```
+         *
+         * The above example enables mocking for the `Date` constructor, `setInterval` timer and
+         * implicitly mocks the `clearInterval` function. Only the `Date` constructor from `globalThis`,
+         * `setInterval` and `clearInterval` functions from `node:timers`,`node:timers/promises`, and `globalThis` will be mocked.
+         *
+         * Example usage with initial time set
          *
          * ```js
          * import { mock } from 'node:test';
-         * mock.timers.enable(['setInterval']);
+         * mock.timers.enable({ apis: ['Date'], now: 1000 });
          * ```
          *
-         * The above example enables mocking for the `setInterval` timer and
-         * implicitly mocks the `clearInterval` function. Only the `setInterval`and `clearInterval` functions from `node:timers`,`node:timers/promises`, and`globalThis` will be mocked.
+         * Example usage with initial Date object as time set
+         *
+         * ```js
+         * import { mock } from 'node:test';
+         * mock.timers.enable({ apis: ['Date'], now: new Date() });
+         * ```
          *
          * Alternatively, if you call `mock.timers.enable()` without any parameters:
          *
-         * All timers (`'setInterval'`, `'clearInterval'`, `'setTimeout'`, and `'clearTimeout'`)
-         * will be mocked. The `setInterval`, `clearInterval`, `setTimeout`, and `clearTimeout`functions from `node:timers`, `node:timers/promises`,
+         * All timers (`'setInterval'`, `'clearInterval'`, `'Date'`, `'setImmediate'`, `'clearImmediate'`, `'setTimeout'`, and `'clearTimeout'`)
+         * will be mocked.
+         *
+         * The `setInterval`, `clearInterval`, `setTimeout`, and `clearTimeout` functions from `node:timers`, `node:timers/promises`,
          * and `globalThis` will be mocked.
+         * The `Date` constructor from `globalThis` will be mocked.
+         *
+         * If there is no initial epoch set, the initial date will be based on 0 in the Unix epoch. This is `January 1st, 1970, 00:00:00 UTC`. You can set an initial date by passing a now property to the `.enable()` method. This value will be used as the initial date for the mocked Date object. It can either be a positive integer, or another Date object.
          * @since v20.4.0
          */
-        enable(timers?: Timer[]): void;
+        enable(options?: MockTimersOptions): void;
+        /**
+         * You can use the `.setTime()` method to manually move the mocked date to another time. This method only accepts a positive integer.
+         * Note: This method will execute any mocked timers that are in the past from the new time.
+         * In the below example we are setting a new time for the mocked date.
+         * ```js
+         * import assert from 'node:assert';
+         * import { test } from 'node:test';
+         * test('sets the time of a date object', (context) => {
+         *   // Optionally choose what to mock
+         *   context.mock.timers.enable({ apis: ['Date'], now: 100 });
+         *   assert.strictEqual(Date.now(), 100);
+         *   // Advance in time will also advance the date
+         *   context.mock.timers.setTime(1000);
+         *   context.mock.timers.tick(200);
+         *   assert.strictEqual(Date.now(), 1200);
+         * });
+         * ```
+         */
+        setTime(time: number): void;
         /**
          * This function restores the default behavior of all mocks that were previously
          * created by this `MockTimers` instance and disassociates the mocks
@@ -1076,7 +1131,7 @@ declare module "node:test" {
          * test('mocks setTimeout to be executed synchronously without having to actually wait for it', (context) => {
          *   const fn = context.mock.fn();
          *
-         *   context.mock.timers.enable(['setTimeout']);
+         *   context.mock.timers.enable({ apis: ['setTimeout'] });
          *
          *   setTimeout(fn, 9999);
          *
@@ -1097,7 +1152,7 @@ declare module "node:test" {
          *
          * test('mocks setTimeout to be executed synchronously without having to actually wait for it', (context) => {
          *   const fn = context.mock.fn();
-         *   context.mock.timers.enable(['setTimeout']);
+         *   context.mock.timers.enable({ apis: ['setTimeout'] });
          *   const nineSecs = 9000;
          *   setTimeout(fn, nineSecs);
          *
@@ -1109,11 +1164,35 @@ declare module "node:test" {
          *   assert.strictEqual(fn.mock.callCount(), 1);
          * });
          * ```
+         *
+         * Advancing time using `.tick` will also advance the time for any `Date` object
+         * created after the mock was enabled (if `Date` was also set to be mocked).
+         *
+         * ```js
+         * import assert from 'node:assert';
+         * import { test } from 'node:test';
+         *
+         * test('mocks setTimeout to be executed synchronously without having to actually wait for it', (context) => {
+         *   const fn = context.mock.fn();
+         *
+         *   context.mock.timers.enable({ apis: ['setTimeout', 'Date'] });
+         *   setTimeout(fn, 9999);
+         *
+         *   assert.strictEqual(fn.mock.callCount(), 0);
+         *   assert.strictEqual(Date.now(), 0);
+         *
+         *   // Advance in time
+         *   context.mock.timers.tick(9999);
+         *   assert.strictEqual(fn.mock.callCount(), 1);
+         *   assert.strictEqual(Date.now(), 9999);
+         * });
+         * ```
          * @since v20.4.0
          */
         tick(milliseconds: number): void;
         /**
-         * Triggers all pending mocked timers immediately.
+         * Triggers all pending mocked timers immediately. If the `Date` object is also
+         * mocked, it will also advance the `Date` object to the furthest timer's time.
          *
          * The example below triggers all pending timers immediately,
          * causing them to execute without any delay.
@@ -1123,7 +1202,7 @@ declare module "node:test" {
          * import { test } from 'node:test';
          *
          * test('runAll functions following the given order', (context) => {
-         *   context.mock.timers.enable(['setTimeout']);
+         *   context.mock.timers.enable({ apis: ['setTimeout', 'Date'] });
          *   const results = [];
          *   setTimeout(() => results.push(1), 9999);
          *
@@ -1135,8 +1214,9 @@ declare module "node:test" {
          *   assert.deepStrictEqual(results, []);
          *
          *   context.mock.timers.runAll();
-         *
          *   assert.deepStrictEqual(results, [3, 2, 1]);
+         *   // The Date object is also advanced to the furthest timer's time
+         *   assert.strictEqual(Date.now(), 9999);
          * });
          * ```
          *
@@ -1343,7 +1423,7 @@ interface TestDequeue extends TestLocationInfo {
  * @see [source](https://github.com/nodejs/node/blob/v20.2.0/lib/test/reporters.js)
  */
 declare module "node:test/reporters" {
-    import { Transform } from "node:stream";
+    import { Transform, TransformOptions } from "node:stream";
 
     type TestEvent =
         | { type: "test:diagnostic"; data: DiagnosticData }
@@ -1378,5 +1458,8 @@ declare module "node:test/reporters" {
      * The `junit` reporter outputs test results in a jUnit XML format
      */
     function junit(source: TestEventGenerator): AsyncGenerator<string, void>;
-    export { dot, junit, Spec as spec, tap, TestEvent };
+    class Lcov extends Transform {
+        constructor(opts?: TransformOptions);
+    }
+    export { dot, junit, Lcov as lcov, Spec as spec, tap, TestEvent };
 }

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

@@ -564,7 +564,7 @@ declare module "buffer" {
              *
              * The `Buffer` module pre-allocates an internal `Buffer` instance of
              * size `Buffer.poolSize` that is used as a pool for the fast allocation of new`Buffer` instances created using `Buffer.allocUnsafe()`, `Buffer.from(array)`,
-             * and `Buffer.concat()` only when `size` is less than or equal to`Buffer.poolSize >> 1` (floor of `Buffer.poolSize` divided by two).
+             * and `Buffer.concat()` only when `size` is less than`Buffer.poolSize >>> 1` (floor of `Buffer.poolSize` divided by two).
              *
              * Use of this pre-allocated internal memory pool is a key difference between
              * calling `Buffer.alloc(size, fill)` vs. `Buffer.allocUnsafe(size).fill(fill)`.

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

@@ -100,6 +100,8 @@ declare module "crypto" {
         const OPENSSL_VERSION_NUMBER: number;
         /** Applies multiple bug workarounds within OpenSSL. See https://www.openssl.org/docs/man1.0.2/ssl/SSL_CTX_set_options.html for detail. */
         const SSL_OP_ALL: number;
+        /** Instructs OpenSSL to allow a non-[EC]DHE-based key exchange mode for TLS v1.3 */
+        const SSL_OP_ALLOW_NO_DHE_KEX: number;
         /** Allows legacy insecure renegotiation between OpenSSL and unpatched clients or servers. See https://www.openssl.org/docs/man1.0.2/ssl/SSL_CTX_set_options.html. */
         const SSL_OP_ALLOW_UNSAFE_LEGACY_RENEGOTIATION: number;
         /** Attempts to use the server's preferences instead of the client's when selecting a cipher. See https://www.openssl.org/docs/man1.0.2/ssl/SSL_CTX_set_options.html. */
@@ -116,15 +118,29 @@ declare module "crypto" {
         const SSL_OP_LEGACY_SERVER_CONNECT: number;
         /** Instructs OpenSSL to disable support for SSL/TLS compression. */
         const SSL_OP_NO_COMPRESSION: number;
+        /** Instructs OpenSSL to disable encrypt-then-MAC. */
+        const SSL_OP_NO_ENCRYPT_THEN_MAC: number;
         const SSL_OP_NO_QUERY_MTU: number;
+        /** Instructs OpenSSL to disable renegotiation. */
+        const SSL_OP_NO_RENEGOTIATION: number;
         /** Instructs OpenSSL to always start a new session when performing renegotiation. */
         const SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION: number;
+        /** Instructs OpenSSL to turn off SSL v2 */
         const SSL_OP_NO_SSLv2: number;
+        /** Instructs OpenSSL to turn off SSL v3 */
         const SSL_OP_NO_SSLv3: number;
+        /** Instructs OpenSSL to disable use of RFC4507bis tickets. */
         const SSL_OP_NO_TICKET: number;
+        /** Instructs OpenSSL to turn off TLS v1 */
         const SSL_OP_NO_TLSv1: number;
+        /** Instructs OpenSSL to turn off TLS v1.1 */
         const SSL_OP_NO_TLSv1_1: number;
+        /** Instructs OpenSSL to turn off TLS v1.2 */
         const SSL_OP_NO_TLSv1_2: number;
+        /** Instructs OpenSSL to turn off TLS v1.3 */
+        const SSL_OP_NO_TLSv1_3: number;
+        /** Instructs OpenSSL server to prioritize ChaCha20-Poly1305 when the client does. This option has no effect if `SSL_OP_CIPHER_SERVER_PREFERENCE` is not enabled. */
+        const SSL_OP_PRIORITIZE_CHACHA: number;
         /** Instructs OpenSSL to disable version rollback attack detection. */
         const SSL_OP_TLS_ROLLBACK_BUG: number;
         const ENGINE_METHOD_RSA: number;
@@ -363,7 +379,7 @@ declare module "crypto" {
          * @since v13.1.0
          * @param options `stream.transform` options
          */
-        copy(options?: stream.TransformOptions): Hash;
+        copy(options?: HashOptions): Hash;
         /**
          * Updates the hash content with the given `data`, the encoding of which
          * is given in `inputEncoding`.
@@ -637,6 +653,13 @@ declare module "crypto" {
         export(options: KeyExportOptions<"pem">): string | Buffer;
         export(options?: KeyExportOptions<"der">): Buffer;
         export(options?: JwkKeyExportOptions): JsonWebKey;
+        /**
+         * Returns `true` or `false` depending on whether the keys have exactly the same
+         * type, value, and parameters. This method is not [constant time](https://en.wikipedia.org/wiki/Timing_attack).
+         * @since v17.7.0, v16.15.0
+         * @param otherKeyObject A `KeyObject` with which to compare `keyObject`.
+         */
+        equals(otherKeyObject: KeyObject): boolean;
         /**
          * For secret keys, this property represents the size of the key in bytes. This
          * property is `undefined` for asymmetric keys.
@@ -2475,6 +2498,10 @@ declare module "crypto" {
          * Name of the curve to use
          */
         namedCurve: string;
+        /**
+         * Must be `'named'` or `'explicit'`. Default: `'named'`.
+         */
+        paramEncoding?: "explicit" | "named" | undefined;
     }
     interface RSAKeyPairKeyObjectOptions {
         /**
@@ -2585,11 +2612,7 @@ declare module "crypto" {
             type: "pkcs8";
         };
     }
-    interface ECKeyPairOptions<PubF extends KeyFormat, PrivF extends KeyFormat> {
-        /**
-         * Name of the curve to use.
-         */
-        namedCurve: string;
+    interface ECKeyPairOptions<PubF extends KeyFormat, PrivF extends KeyFormat> extends ECKeyPairKeyObjectOptions {
         publicKeyEncoding: {
             type: "pkcs1" | "spki";
             format: PubF;

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

@@ -227,6 +227,16 @@ declare module "dgram" {
          * @return the `SO_SNDBUF` socket send buffer size in bytes.
          */
         getSendBufferSize(): number;
+        /**
+         * @since v18.8.0, v16.19.0
+         * @return Number of bytes queued for sending.
+         */
+        getSendQueueSize(): number;
+        /**
+         * @since v18.8.0, v16.19.0
+         * @return Number of send requests currently in the queue awaiting to be processed.
+         */
+        getSendQueueCount(): number;
         /**
          * By default, binding a socket will cause it to block the Node.js process from
          * exiting as long as the socket is open. The `socket.unref()` method can be used