cloudstructs 0.1.41 → 0.2.2

package/node_modules/@types/keyv/node_modules/@types/node/console.d.ts

@@ -394,6 +394,11 @@ declare module 'node:console' {
                 ignoreErrors?: boolean | undefined;
                 colorMode?: boolean | 'auto' | undefined;
                 inspectOptions?: InspectOptions | undefined;
+                /**
+                 * Set group indentation
+                 * @default 2
+                 */
+                groupIndentation?: number | undefined;
             }
             interface ConsoleConstructor {
                 prototype: Console;

package/node_modules/@types/keyv/node_modules/@types/node/crypto.d.ts

@@ -250,7 +250,7 @@ declare module 'crypto' {
      */
     function createHmac(algorithm: string, key: BinaryLike | KeyObject, options?: stream.TransformOptions): Hmac;
     // https://nodejs.org/api/buffer.html#buffer_buffers_and_character_encodings
-    type BinaryToTextEncoding = 'base64' | 'hex';
+    type BinaryToTextEncoding = 'base64' | 'base64url' | 'hex';
     type CharacterEncoding = 'utf8' | 'utf-8' | 'utf16le' | 'latin1';
     type LegacyCharacterEncoding = 'ascii' | 'binary' | 'ucs2' | 'ucs-2';
     type Encoding = BinaryToTextEncoding | CharacterEncoding | LegacyCharacterEncoding;
@@ -1167,6 +1167,26 @@ declare module 'crypto' {
         },
         callback: (err: Error | null, key: KeyObject) => void
     ): void;
+    /**
+     * Synchronously generates a new random secret key of the given `length`. The`type` will determine which validations will be performed on the `length`.
+     *
+     * ```js
+     * const {
+     *   generateKeySync
+     * } = await import('crypto');
+     *
+     * const key = generateKeySync('hmac', { length: 64 });
+     * console.log(key.export().toString('hex'));  // e89..........41e
+     * ```
+     * @since v15.0.0
+     * @param type The intended use of the generated secret key. Currently accepted values are `'hmac'` and `'aes'`.
+     */
+    function generateKeySync(
+        type: 'hmac' | 'aes',
+        options: {
+            length: number;
+        }
+    ): KeyObject;
     interface JsonWebKeyInput {
         key: JsonWebKey;
         format: 'jwk';
@@ -2140,7 +2160,7 @@ declare module 'crypto' {
             key: BinaryLike,
             curve: string,
             inputEncoding?: BinaryToTextEncoding,
-            outputEncoding?: 'latin1' | 'hex' | 'base64',
+            outputEncoding?: 'latin1' | 'hex' | 'base64' | 'base64url',
             format?: 'uncompressed' | 'compressed' | 'hybrid'
         ): Buffer | string;
         /**
@@ -2259,7 +2279,7 @@ declare module 'crypto' {
     interface X448KeyPairKeyObjectOptions {}
     interface ECKeyPairKeyObjectOptions {
         /**
-         * Name of the curve to use.
+         * Name of the curve to use
          */
         namedCurve: string;
     }
@@ -2269,6 +2289,7 @@ declare module 'crypto' {
          */
         modulusLength: number;
         /**
+         * Public exponent
          * @default 0x10001
          */
         publicExponent?: number | undefined;
@@ -2279,9 +2300,22 @@ declare module 'crypto' {
          */
         modulusLength: number;
         /**
+         * Public exponent
          * @default 0x10001
          */
         publicExponent?: number | undefined;
+        /**
+         * Name of the message digest
+         */
+        hashAlgorithm?: string;
+        /**
+         * Name of the message digest used by MGF1
+         */
+        mgf1HashAlgorithm?: string;
+        /**
+         * Minimal salt length in bytes
+         */
+        saltLength?: string;
     }
     interface DSAKeyPairKeyObjectOptions {
         /**
@@ -2299,6 +2333,7 @@ declare module 'crypto' {
          */
         modulusLength: number;
         /**
+         * Public exponent
          * @default 0x10001
          */
         publicExponent?: number | undefined;
@@ -2316,9 +2351,22 @@ declare module 'crypto' {
          */
         modulusLength: number;
         /**
+         * Public exponent
          * @default 0x10001
          */
         publicExponent?: number | undefined;
+        /**
+         * Name of the message digest
+         */
+        hashAlgorithm?: string;
+        /**
+         * Name of the message digest used by MGF1
+         */
+        mgf1HashAlgorithm?: string;
+        /**
+         * Minimal salt length in bytes
+         */
+        saltLength?: string;
         publicKeyEncoding: {
             type: 'spki';
             format: PubF;

package/node_modules/@types/keyv/node_modules/@types/node/dgram.d.ts

@@ -166,17 +166,17 @@ declare module 'dgram' {
          * @since v0.1.99
          * @param callback with no parameters. Called when binding is complete.
          */
-        bind(port?: number, address?: string, callback?: () => void): void;
-        bind(port?: number, callback?: () => void): void;
-        bind(callback?: () => void): void;
-        bind(options: BindOptions, callback?: () => void): void;
+        bind(port?: number, address?: string, callback?: () => void): this;
+        bind(port?: number, callback?: () => void): this;
+        bind(callback?: () => void): this;
+        bind(options: BindOptions, callback?: () => void): this;
         /**
          * Close the underlying socket and stop listening for data on it. If a callback is
          * provided, it is added as a listener for the `'close'` event.
          * @since v0.1.99
          * @param callback Called when the socket has been closed.
          */
-        close(callback?: () => void): void;
+        close(callback?: () => void): this;
         /**
          * Associates the `dgram.Socket` to a remote address and port. Every
          * message sent by this handle is automatically sent to that destination. Also,
@@ -414,7 +414,7 @@ declare module 'dgram' {
          * This method throws `EBADF` if called on an unbound socket.
          * @since v0.3.8
          */
-        setMulticastLoopback(flag: boolean): void;
+        setMulticastLoopback(flag: boolean): boolean;
         /**
          * Sets the `IP_MULTICAST_TTL` socket option. While TTL generally stands for
          * "Time to Live", in this context it specifies the number of IP hops that a
@@ -427,7 +427,7 @@ declare module 'dgram' {
          * This method throws `EBADF` if called on an unbound socket.
          * @since v0.3.8
          */
-        setMulticastTTL(ttl: number): void;
+        setMulticastTTL(ttl: number): number;
         /**
          * Sets the `SO_RCVBUF` socket option. Sets the maximum socket receive buffer
          * in bytes.
@@ -457,7 +457,7 @@ declare module 'dgram' {
          * This method throws `EBADF` if called on an unbound socket.
          * @since v0.1.101
          */
-        setTTL(ttl: number): void;
+        setTTL(ttl: number): 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

package/node_modules/@types/keyv/node_modules/@types/node/diagnostics_channel.d.ts

@@ -37,6 +37,7 @@ declare module 'diagnostics_channel' {
      *   // There are subscribers, prepare and publish message
      * }
      * ```
+     * @since v15.1.0, v14.17.0
      * @param name The channel name
      * @return If there are active subscribers
      */
@@ -51,6 +52,7 @@ declare module 'diagnostics_channel' {
      *
      * const channel = diagnostics_channel.channel('my-channel');
      * ```
+     * @since v15.1.0, v14.17.0
      * @param name The channel name
      * @return The named channel object
      */
@@ -63,6 +65,7 @@ declare module 'diagnostics_channel' {
      * lookups at publish time, enabling very fast publish speeds and allowing
      * for heavy use while incurring very minimal cost. Channels are created with {@link channel}, constructing a channel directly
      * with `new Channel(name)` is not supported.
+     * @since v15.1.0, v14.17.0
      */
     class Channel {
         readonly name: string;
@@ -82,6 +85,7 @@ declare module 'diagnostics_channel' {
          *   // There are subscribers, prepare and publish message
          * }
          * ```
+         * @since v15.1.0, v14.17.0
          */
         readonly hasSubscribers: boolean;
         private constructor(name: string);
@@ -99,6 +103,7 @@ declare module 'diagnostics_channel' {
          *   // Received data
          * });
          * ```
+         * @since v15.1.0, v14.17.0
          * @param onMessage The handler to receive channel messages
          */
         subscribe(onMessage: ChannelListener): void;
@@ -118,6 +123,7 @@ declare module 'diagnostics_channel' {
          *
          * channel.unsubscribe(onMessage);
          * ```
+         * @since v15.1.0, v14.17.0
          * @param onMessage The previous subscribed handler to remove
          */
         unsubscribe(onMessage: ChannelListener): void;

package/node_modules/@types/keyv/node_modules/@types/node/dns/promises.d.ts

@@ -331,6 +331,17 @@ declare module 'dns/promises' {
      * @param servers array of `RFC 5952` formatted addresses
      */
     function setServers(servers: ReadonlyArray<string>): void;
+    /**
+     * Set the default value of `verbatim` in {@link lookup}. The value could be:
+     * - `ipv4first`: sets default `verbatim` `false`.
+     * - `verbatim`: sets default `verbatim` `true`.
+     *
+     * The default is `ipv4first` and {@link setDefaultResultOrder} have higher priority than `--dns-result-order`.
+     * When using worker threads, {@link setDefaultResultOrder} from the main thread won't affect the default dns orders in workers.
+     * @since v14.18.0
+     * @param order must be 'ipv4first' or 'verbatim'.
+     */
+    function setDefaultResultOrder(order: 'ipv4first' | 'verbatim'): void;
     class Resolver {
         constructor(options?: ResolverOptions);
         cancel(): void;

package/node_modules/@types/keyv/node_modules/@types/node/dns.d.ts

@@ -526,6 +526,17 @@ declare module 'dns' {
      * @since v0.11.3
      */
     export function getServers(): string[];
+    /**
+     * Set the default value of `verbatim` in {@link lookup}. The value could be:
+     * - `ipv4first`: sets default `verbatim` `false`.
+     * - `verbatim`: sets default `verbatim` `true`.
+     *
+     * The default is `ipv4first` and {@link setDefaultResultOrder} have higher priority than `--dns-result-order`.
+     * When using worker threads, {@link setDefaultResultOrder} from the main thread won't affect the default dns orders in workers.
+     * @since v14.18.0
+     * @param order must be 'ipv4first' or 'verbatim'.
+     */
+    export function setDefaultResultOrder(order: 'ipv4first' | 'verbatim'): void;
     // Error codes
     export const NODATA: string;
     export const FORMERR: string;

package/node_modules/@types/keyv/node_modules/@types/node/fs/promises.d.ts

@@ -31,6 +31,8 @@ declare module 'fs/promises' {
         WatchOptions,
         WatchEventType,
         CopyOptions,
+        ReadStream,
+        WriteStream,
     } from 'node:fs';
     interface FileChangeInfo<T extends string | Buffer> {
         eventType: WatchEventType;
@@ -59,6 +61,20 @@ declare module 'fs/promises' {
         length?: number | null;
         position?: number | null;
     }
+    interface CreateReadStreamOptions {
+        encoding?: BufferEncoding | null | undefined;
+        autoClose?: boolean | undefined;
+        emitClose?: boolean | undefined;
+        start?: number | undefined;
+        end?: number | undefined;
+        highWaterMark?: number | undefined;
+    }
+    interface CreateWriteStreamOptions {
+        encoding?: BufferEncoding | null | undefined;
+        autoClose?: boolean | undefined;
+        emitClose?: boolean | undefined;
+        start?: number | undefined;
+    }
     // TODO: Add `EventEmitter` close
     interface FileHandle {
         /**
@@ -90,6 +106,77 @@ declare module 'fs/promises' {
          * @return Fulfills with `undefined` upon success.
          */
         chmod(mode: Mode): Promise<void>;
+        /**
+         * Unlike the 16 kb default `highWaterMark` for a `stream.Readable`, the stream
+         * returned by this method has a default `highWaterMark` of 64 kb.
+         *
+         * `options` can include `start` and `end` values to read a range of bytes from
+         * the file instead of the entire file. Both `start` and `end` are inclusive and
+         * start counting at 0, allowed values are in the
+         * \[0, [`Number.MAX_SAFE_INTEGER`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/MAX_SAFE_INTEGER)\] range. If `start` is
+         * omitted or `undefined`, `filehandle.createReadStream()` reads sequentially from
+         * the current file position. The `encoding` can be any one of those accepted by `Buffer`.
+         *
+         * If the `FileHandle` points to a character device that only supports blocking
+         * reads (such as keyboard or sound card), read operations do not finish until data
+         * is available. This can prevent the process from exiting and the stream from
+         * closing naturally.
+         *
+         * By default, the stream will emit a `'close'` event after it has been
+         * destroyed.  Set the `emitClose` option to `false` to change this behavior.
+         *
+         * ```js
+         * import { open } from 'fs/promises';
+         *
+         * const fd = await open('/dev/input/event0');
+         * // Create a stream from some character device.
+         * const stream = fd.createReadStream();
+         * setTimeout(() => {
+         *   stream.close(); // This may not close the stream.
+         *   // Artificially marking end-of-stream, as if the underlying resource had
+         *   // indicated end-of-file by itself, allows the stream to close.
+         *   // This does not cancel pending read operations, and if there is such an
+         *   // operation, the process may still not be able to exit successfully
+         *   // until it finishes.
+         *   stream.push(null);
+         *   stream.read(0);
+         * }, 100);
+         * ```
+         *
+         * If `autoClose` is false, then the file descriptor won't be closed, even if
+         * there's an error. It is the application's responsibility to close it and make
+         * sure there's no file descriptor leak. If `autoClose` is set to true (default
+         * behavior), on `'error'` or `'end'` the file descriptor will be closed
+         * automatically.
+         *
+         * An example to read the last 10 bytes of a file which is 100 bytes long:
+         *
+         * ```js
+         * import { open } from 'fs/promises';
+         *
+         * const fd = await open('sample.txt');
+         * fd.createReadStream({ start: 90, end: 99 });
+         * ```
+         * @since v16.11.0
+         */
+        createReadStream(options?: CreateReadStreamOptions): ReadStream;
+        /**
+         * `options` may also include a `start` option to allow writing data at some
+         * position past the beginning of the file, allowed values are in the
+         * \[0, [`Number.MAX_SAFE_INTEGER`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/MAX_SAFE_INTEGER)\] range. Modifying a file rather than replacing
+         * it may require the `flags` `open` option to be set to `r+` rather than the
+         * default `r`. The `encoding` can be any one of those accepted by `Buffer`.
+         *
+         * If `autoClose` is set to true (default behavior) on `'error'` or `'finish'`the file descriptor will be closed automatically. If `autoClose` is false,
+         * then the file descriptor won't be closed, even if there's an error.
+         * It is the application's responsibility to close it and make sure there's no
+         * file descriptor leak.
+         *
+         * By default, the stream will emit a `'close'` event after it has been
+         * destroyed.  Set the `emitClose` option to `false` to change this behavior.
+         * @since v16.11.0
+         */
+        createWriteStream(options?: CreateWriteStreamOptions): WriteStream;
         /**
          * Forces all currently queued I/O operations associated with the file to the
          * operating system's synchronized I/O completion state. Refer to the POSIX [`fdatasync(2)`](http://man7.org/linux/man-pages/man2/fdatasync.2.html) documentation for details.
@@ -114,8 +201,8 @@ declare module 'fs/promises' {
          * number of bytes read is zero.
          * @since v10.0.0
          * @param buffer A buffer that will be filled with the file data read.
-         * @param [offset=0] The location in the buffer at which to start filling.
-         * @param [length=buffer.byteLength] The number of bytes to read.
+         * @param offset The location in the buffer at which to start filling.
+         * @param length The number of bytes to read.
          * @param position The location where to begin reading data from the file. If `null`, data will be read from the current file position, and the position will be updated. If `position` is an
          * integer, the current file position will remain unchanged.
          * @return Fulfills upon success with an object with two properties:
@@ -928,7 +1015,7 @@ declare module 'fs/promises' {
      * @since v12.12.0
      * @return Fulfills with an {fs.Dir}.
      */
-    function opendir(path: string, options?: OpenDirOptions): Promise<Dir>;
+    function opendir(path: PathLike, options?: OpenDirOptions): Promise<Dir>;
     /**
      * Returns an async iterator that watches for changes on `filename`, where `filename`is either a file or a directory.
      *