cloudstructs 0.12.10 → 0.12.11

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

@@ -1,8 +1,3 @@
-/**
- * HTTPS is the HTTP protocol over TLS/SSL. In Node.js this is implemented as a
- * separate module.
- * @see [source](https://github.com/nodejs/node/blob/v25.x/lib/https.js)
- */
 declare module "node:https" {
     import * as http from "node:http";
     import { Duplex } from "node:stream";

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

@@ -1,9 +1,3 @@
-/**
- * The `node:inspector/promises` module provides an API for interacting with the V8
- * inspector.
- * @see [source](https://github.com/nodejs/node/blob/v25.x/lib/inspector/promises.js)
- * @since v19.0.0
- */
 declare module "node:inspector/promises" {
     import { EventEmitter } from "node:events";
     export { close, console, NetworkResources, open, url, waitForDebugger } from "node:inspector";

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

@@ -1,8 +1,3 @@
-/**
- * The `node:inspector` module provides an API for interacting with the V8
- * inspector.
- * @see [source](https://github.com/nodejs/node/blob/v25.x/lib/inspector.js)
- */
 declare module "node:inspector" {
     import { EventEmitter } from "node:events";
     /**

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

@@ -1,6 +1,3 @@
-/**
- * @since v0.3.7
- */
 declare module "node:module" {
     import { URL } from "node:url";
     class Module {

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

@@ -1,17 +1,3 @@
-/**
- * > Stability: 2 - Stable
- *
- * The `node:net` module provides an asynchronous network API for creating stream-based
- * TCP or `IPC` servers ({@link createServer}) and clients
- * ({@link createConnection}).
- *
- * It can be accessed using:
- *
- * ```js
- * import net from 'node:net';
- * ```
- * @see [source](https://github.com/nodejs/node/blob/v25.x/lib/net.js)
- */
 declare module "node:net" {
     import { NonSharedBuffer } from "node:buffer";
     import * as dns from "node:dns";
@@ -38,6 +24,7 @@ declare module "node:net" {
         keepAlive?: boolean | undefined;
         keepAliveInitialDelay?: number | undefined;
         blockList?: BlockList | undefined;
+        typeOfService?: number | undefined;
     }
     interface OnReadOpts {
         buffer: Uint8Array | (() => Uint8Array);
@@ -116,9 +103,14 @@ declare module "node:net" {
          * See `Writable` stream `write()` method for more
          * information.
          * @since v0.1.90
-         * @param [encoding='utf8'] Only used when data is `string`.
          */
         write(buffer: Uint8Array | string, cb?: (err?: Error | null) => void): boolean;
+        /**
+         * Sends data on the socket, with an explicit encoding for string data.
+         * @see {@link Socket.write} for full details.
+         * @since v0.1.90
+         * @param [encoding='utf8'] Only used when data is `string`.
+         */
         write(str: Uint8Array | string, encoding?: BufferEncoding, cb?: (err?: Error | null) => void): boolean;
         /**
          * Initiate a connection on a given socket.
@@ -226,6 +218,37 @@ declare module "node:net" {
          * @return The socket itself.
          */
         setKeepAlive(enable?: boolean, initialDelay?: number): this;
+        /**
+         * Returns the current Type of Service (TOS) field for IPv4 packets or Traffic
+         * Class for IPv6 packets for this socket.
+         *
+         * `setTypeOfService()` may be called before the socket is connected; the value
+         * will be cached and applied when the socket establishes a connection.
+         * `getTypeOfService()` will return the currently set value even before connection.
+         *
+         * On some platforms (e.g., Linux), certain TOS/ECN bits may be masked or ignored,
+         * and behavior can differ between IPv4 and IPv6 or dual-stack sockets. Callers
+         * should verify platform-specific semantics.
+         * @since v25.6.0
+         * @returns The current TOS value.
+         */
+        getTypeOfService(): number;
+        /**
+         * Sets the Type of Service (TOS) field for IPv4 packets or Traffic Class for IPv6
+         * Packets sent from this socket. This can be used to prioritize network traffic.
+         *
+         * `setTypeOfService()` may be called before the socket is connected; the value
+         * will be cached and applied when the socket establishes a connection.
+         * `getTypeOfService()` will return the currently set value even before connection.
+         *
+         * On some platforms (e.g., Linux), certain TOS/ECN bits may be masked or ignored,
+         * and behavior can differ between IPv4 and IPv6 or dual-stack sockets. Callers
+         * should verify platform-specific semantics.
+         * @since v25.6.0
+         * @param tos The TOS value to set (0-255).
+         * @returns The socket itself.
+         */
+        setTypeOfService(tos: number): this;
         /**
          * Returns the bound `address`, the address `family` name and `port` of the
          * socket as reported by the operating system:`{ port: 12346, family: 'IPv4', address: '127.0.0.1' }`
@@ -358,12 +381,26 @@ declare module "node:net" {
          *
          * See `writable.end()` for further details.
          * @since v0.1.90
-         * @param [encoding='utf8'] Only used when data is `string`.
          * @param callback Optional callback for when the socket is finished.
          * @return The socket itself.
          */
         end(callback?: () => void): this;
+        /**
+         * Half-closes the socket, with one final chunk of data.
+         * @see {@link Socket.end} for full details.
+         * @since v0.1.90
+         * @param callback Optional callback for when the socket is finished.
+         * @return The socket itself.
+         */
         end(buffer: Uint8Array | string, callback?: () => void): this;
+        /**
+         * Half-closes the socket, with one final chunk of data.
+         * @see {@link Socket.end} for full details.
+         * @since v0.1.90
+         * @param [encoding='utf8'] Only used when data is `string`.
+         * @param callback Optional callback for when the socket is finished.
+         * @return The socket itself.
+         */
         end(str: Uint8Array | string, encoding?: BufferEncoding, callback?: () => void): this;
         // #region InternalEventEmitter
         addListener<E extends keyof SocketEventMap>(eventName: E, listener: (...args: SocketEventMap[E]) => void): this;

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

@@ -1,12 +1,3 @@
-/**
- * The `node:os` module provides operating system-related utility methods and
- * properties. It can be accessed using:
- *
- * ```js
- * import os from 'node:os';
- * ```
- * @see [source](https://github.com/nodejs/node/blob/v25.x/lib/os.js)
- */
 declare module "node:os" {
     import { NonSharedBuffer } from "buffer";
     interface CpuInfo {

package/node_modules/@slack/web-api/node_modules/@types/node/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@types/node",
-    "version": "25.5.0",
+    "version": "25.6.0",
     "description": "TypeScript definitions for node",
     "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/node",
     "license": "MIT",
@@ -147,9 +147,9 @@
     },
     "scripts": {},
     "dependencies": {
-        "undici-types": "~7.18.0"
+        "undici-types": "~7.19.0"
     },
     "peerDependencies": {},
-    "typesPublisherContentHash": "4b6968335abe1dc64bd6086fd546d6e9c50f986c37d49de8073f4ed1c900057c",
-    "typeScriptVersion": "5.2"
+    "typesPublisherContentHash": "753bd9272f1c86686cc2d1bb435a7f033157f700201f64f0319742347e1ca060",
+    "typeScriptVersion": "5.3"
 }

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

@@ -1,12 +1,3 @@
-/**
- * The `node:path` module provides utilities for working with file and directory
- * paths. It can be accessed using:
- *
- * ```js
- * import path from 'node:path';
- * ```
- * @see [source](https://github.com/nodejs/node/blob/v25.x/lib/path.js)
- */
 declare module "node:path" {
     namespace path {
         /**

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

@@ -1,34 +1,3 @@
-/**
- * This module provides an implementation of a subset of the W3C [Web Performance APIs](https://w3c.github.io/perf-timing-primer/) as well as additional APIs for
- * Node.js-specific performance measurements.
- *
- * Node.js supports the following [Web Performance APIs](https://w3c.github.io/perf-timing-primer/):
- *
- * * [High Resolution Time](https://www.w3.org/TR/hr-time-2)
- * * [Performance Timeline](https://w3c.github.io/performance-timeline/)
- * * [User Timing](https://www.w3.org/TR/user-timing/)
- * * [Resource Timing](https://www.w3.org/TR/resource-timing-2/)
- *
- * ```js
- * import { PerformanceObserver, performance } from 'node:perf_hooks';
- *
- * const obs = new PerformanceObserver((items) => {
- *   console.log(items.getEntries()[0].duration);
- *   performance.clearMarks();
- * });
- * obs.observe({ type: 'measure' });
- * performance.measure('Start to Now');
- *
- * performance.mark('A');
- * doSomeLongRunningProcess(() => {
- *   performance.measure('A to Now', 'A');
- *
- *   performance.mark('B');
- *   performance.measure('A to B', 'A', 'B');
- * });
- * ```
- * @see [source](https://github.com/nodejs/node/blob/v25.x/lib/perf_hooks.js)
- */
 declare module "node:perf_hooks" {
     import { InternalEventTargetEventProperties } from "node:events";
     // #region web types

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

@@ -1,31 +1,3 @@
-/**
- * **The version of the punycode module bundled in Node.js is being deprecated. **In a future major version of Node.js this module will be removed. Users
- * currently depending on the `punycode` module should switch to using the
- * userland-provided [Punycode.js](https://github.com/bestiejs/punycode.js) module instead. For punycode-based URL
- * encoding, see `url.domainToASCII` or, more generally, the `WHATWG URL API`.
- *
- * The `punycode` module is a bundled version of the [Punycode.js](https://github.com/bestiejs/punycode.js) module. It
- * can be accessed using:
- *
- * ```js
- * import punycode from 'node:punycode';
- * ```
- *
- * [Punycode](https://tools.ietf.org/html/rfc3492) is a character encoding scheme defined by RFC 3492 that is
- * primarily intended for use in Internationalized Domain Names. Because host
- * names in URLs are limited to ASCII characters only, Domain Names that contain
- * non-ASCII characters must be converted into ASCII using the Punycode scheme.
- * For instance, the Japanese character that translates into the English word, `'example'` is `'例'`. The Internationalized Domain Name, `'例.com'` (equivalent
- * to `'example.com'`) is represented by Punycode as the ASCII string `'xn--fsq.com'`.
- *
- * The `punycode` module provides a simple implementation of the Punycode standard.
- *
- * The `punycode` module is a third-party dependency used by Node.js and
- * made available to developers as a convenience. Fixes or other modifications to
- * the module must be directed to the [Punycode.js](https://github.com/bestiejs/punycode.js) project.
- * @deprecated
- * @see [source](https://github.com/nodejs/node/blob/v25.x/lib/punycode.js)
- */
 declare module "node:punycode" {
     /**
      * The `punycode.decode()` method converts a [Punycode](https://tools.ietf.org/html/rfc3492) string of ASCII-only

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

@@ -1,16 +1,3 @@
-/**
- * The `node:querystring` module provides utilities for parsing and formatting URL
- * query strings. It can be accessed using:
- *
- * ```js
- * import querystring from 'node:querystring';
- * ```
- *
- * `querystring` is more performant than `URLSearchParams` but is not a
- * standardized API. Use `URLSearchParams` when performance is not critical or
- * when compatibility with browser code is desirable.
- * @see [source](https://github.com/nodejs/node/blob/v25.x/lib/querystring.js)
- */
 declare module "node:querystring" {
     interface StringifyOptions {
         /**

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

@@ -1,16 +1,3 @@
-/**
- * The 'node:quic' module provides an implementation of the QUIC protocol.
- * To access it, start Node.js with the `--experimental-quic` option and:
- *
- * ```js
- * import quic from 'node:quic';
- * ```
- *
- * The module is only available under the `node:` scheme.
- * @since v23.8.0
- * @experimental
- * @see [source](https://github.com/nodejs/node/blob/v25.x/lib/quic.js)
- */
 declare module "node:quic" {
     import { KeyObject, webcrypto } from "node:crypto";
     import { SocketAddress } from "node:net";

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

@@ -1,6 +1,3 @@
-/**
- * @since v17.0.0
- */
 declare module "node:readline/promises" {
     import { Abortable } from "node:events";
     import {

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

@@ -1,38 +1,3 @@
-/**
- * The `node:readline` module provides an interface for reading data from a [Readable](https://nodejs.org/docs/latest-v25.x/api/stream.html#readable-streams) stream
- * (such as [`process.stdin`](https://nodejs.org/docs/latest-v25.x/api/process.html#processstdin)) one line at a time.
- *
- * To use the promise-based APIs:
- *
- * ```js
- * import * as readline from 'node:readline/promises';
- * ```
- *
- * To use the callback and sync APIs:
- *
- * ```js
- * import * as readline from 'node:readline';
- * ```
- *
- * The following simple example illustrates the basic use of the `node:readline` module.
- *
- * ```js
- * import * as readline from 'node:readline/promises';
- * import { stdin as input, stdout as output } from 'node:process';
- *
- * const rl = readline.createInterface({ input, output });
- *
- * const answer = await rl.question('What do you think of Node.js? ');
- *
- * console.log(`Thank you for your valuable feedback: ${answer}`);
- *
- * rl.close();
- * ```
- *
- * Once this code is invoked, the Node.js application will not terminate until the `readline.Interface` is closed because the interface waits for data to be
- * received on the `input` stream.
- * @see [source](https://github.com/nodejs/node/blob/v25.x/lib/readline.js)
- */
 declare module "node:readline" {
     import { Abortable, EventEmitter, InternalEventEmitter } from "node:events";
     interface Key {

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

@@ -1,13 +1,3 @@
-/**
- * The `node:repl` module provides a Read-Eval-Print-Loop (REPL) implementation
- * that is available both as a standalone program or includible in other
- * applications. It can be accessed using:
- *
- * ```js
- * import repl from 'node:repl';
- * ```
- * @see [source](https://github.com/nodejs/node/blob/v25.x/lib/repl.js)
- */
 declare module "node:repl" {
     import { AsyncCompleter, Completer, Interface, InterfaceEventMap } from "node:readline";
     import { InspectOptions } from "node:util";

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

@@ -1,118 +1,3 @@
-/**
- * This feature allows the distribution of a Node.js application conveniently to a
- * system that does not have Node.js installed.
- *
- * Node.js supports the creation of [single executable applications](https://github.com/nodejs/single-executable) by allowing
- * the injection of a blob prepared by Node.js, which can contain a bundled script,
- * into the `node` binary. During start up, the program checks if anything has been
- * injected. If the blob is found, it executes the script in the blob. Otherwise
- * Node.js operates as it normally does.
- *
- * The single executable application feature currently only supports running a
- * single embedded script using the `CommonJS` module system.
- *
- * Users can create a single executable application from their bundled script
- * with the `node` binary itself and any tool which can inject resources into the
- * binary.
- *
- * Here are the steps for creating a single executable application using one such
- * tool, [postject](https://github.com/nodejs/postject):
- *
- * 1. Create a JavaScript file:
- * ```bash
- * echo 'console.log(`Hello, ${process.argv[2]}!`);' > hello.js
- * ```
- * 2. Create a configuration file building a blob that can be injected into the
- * single executable application (see `Generating single executable preparation blobs` for details):
- * ```bash
- * echo '{ "main": "hello.js", "output": "sea-prep.blob" }' > sea-config.json
- * ```
- * 3. Generate the blob to be injected:
- * ```bash
- * node --experimental-sea-config sea-config.json
- * ```
- * 4. Create a copy of the `node` executable and name it according to your needs:
- *    * On systems other than Windows:
- * ```bash
- * cp $(command -v node) hello
- * ```
- *    * On Windows:
- * ```text
- * node -e "require('fs').copyFileSync(process.execPath, 'hello.exe')"
- * ```
- * The `.exe` extension is necessary.
- * 5. Remove the signature of the binary (macOS and Windows only):
- *    * On macOS:
- * ```bash
- * codesign --remove-signature hello
- * ```
- *    * On Windows (optional):
- * [signtool](https://learn.microsoft.com/en-us/windows/win32/seccrypto/signtool) can be used from the installed [Windows SDK](https://developer.microsoft.com/en-us/windows/downloads/windows-sdk/).
- * If this step is
- * skipped, ignore any signature-related warning from postject.
- * ```powershell
- * signtool remove /s hello.exe
- * ```
- * 6. Inject the blob into the copied binary by running `postject` with
- * the following options:
- *    * `hello` / `hello.exe` \- The name of the copy of the `node` executable
- *    created in step 4.
- *    * `NODE_SEA_BLOB` \- The name of the resource / note / section in the binary
- *    where the contents of the blob will be stored.
- *    * `sea-prep.blob` \- The name of the blob created in step 1.
- *    * `--sentinel-fuse NODE_SEA_FUSE_fce680ab2cc467b6e072b8b5df1996b2` \- The [fuse](https://www.electronjs.org/docs/latest/tutorial/fuses) used by the Node.js project to detect if a file has been
- * injected.
- *    * `--macho-segment-name NODE_SEA` (only needed on macOS) - The name of the
- *    segment in the binary where the contents of the blob will be
- *    stored.
- * To summarize, here is the required command for each platform:
- *    * On Linux:
- *    ```bash
- *    npx postject hello NODE_SEA_BLOB sea-prep.blob \
- *        --sentinel-fuse NODE_SEA_FUSE_fce680ab2cc467b6e072b8b5df1996b2
- *    ```
- *    * On Windows - PowerShell:
- *    ```powershell
- *    npx postject hello.exe NODE_SEA_BLOB sea-prep.blob `
- *        --sentinel-fuse NODE_SEA_FUSE_fce680ab2cc467b6e072b8b5df1996b2
- *    ```
- *    * On Windows - Command Prompt:
- *    ```text
- *    npx postject hello.exe NODE_SEA_BLOB sea-prep.blob ^
- *        --sentinel-fuse NODE_SEA_FUSE_fce680ab2cc467b6e072b8b5df1996b2
- *    ```
- *    * On macOS:
- *    ```bash
- *    npx postject hello NODE_SEA_BLOB sea-prep.blob \
- *        --sentinel-fuse NODE_SEA_FUSE_fce680ab2cc467b6e072b8b5df1996b2 \
- *        --macho-segment-name NODE_SEA
- *    ```
- * 7. Sign the binary (macOS and Windows only):
- *    * On macOS:
- * ```bash
- * codesign --sign - hello
- * ```
- *    * On Windows (optional):
- * A certificate needs to be present for this to work. However, the unsigned
- * binary would still be runnable.
- * ```powershell
- * signtool sign /fd SHA256 hello.exe
- * ```
- * 8. Run the binary:
- *    * On systems other than Windows
- * ```console
- * $ ./hello world
- * Hello, world!
- * ```
- *    * On Windows
- * ```console
- * $ .\hello.exe world
- * Hello, world!
- * ```
- * @since v19.7.0, v18.16.0
- * @experimental
- * @see [source](https://github.com/nodejs/node/blob/v25.x/src/node_sea.cc)
- */
 declare module "node:sea" {
     type AssetKey = string;
     /**

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

@@ -1,47 +1,3 @@
-/**
- * The `node:sqlite` module facilitates working with SQLite databases.
- * To access it:
- *
- * ```js
- * import sqlite from 'node:sqlite';
- * ```
- *
- * This module is only available under the `node:` scheme. The following will not
- * work:
- *
- * ```js
- * import sqlite from 'sqlite';
- * ```
- *
- * The following example shows the basic usage of the `node:sqlite` module to open
- * an in-memory database, write data to the database, and then read the data back.
- *
- * ```js
- * import { DatabaseSync } from 'node:sqlite';
- * const database = new DatabaseSync(':memory:');
- *
- * // Execute SQL statements from strings.
- * database.exec(`
- *   CREATE TABLE data(
- *     key INTEGER PRIMARY KEY,
- *     value TEXT
- *   ) STRICT
- * `);
- * // Create a prepared statement to insert data into the database.
- * const insert = database.prepare('INSERT INTO data (key, value) VALUES (?, ?)');
- * // Execute the prepared statement with bound values.
- * insert.run(1, 'hello');
- * insert.run(2, 'world');
- * // Create a prepared statement to read data from the database.
- * const query = database.prepare('SELECT * FROM data ORDER BY key');
- * // Execute the prepared statement and log the result set.
- * console.log(query.all());
- * // Prints: [ { key: 1, value: 'hello' }, { key: 2, value: 'world' } ]
- * ```
- * @since v22.5.0
- * @experimental
- * @see [source](https://github.com/nodejs/node/blob/v25.x/lib/sqlite.js)
- */
 declare module "node:sqlite" {
     import { PathLike } from "node:fs";
     type SQLInputValue = null | number | bigint | string | NodeJS.ArrayBufferView;

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

@@ -1,33 +1,109 @@
-/**
- * The utility consumer functions provide common options for consuming
- * streams.
- * @since v16.7.0
- */
 declare module "node:stream/consumers" {
     import { Blob, NonSharedBuffer } from "node:buffer";
     import { ReadableStream } from "node:stream/web";
     /**
+     * ```js
+     * import { arrayBuffer } from 'node:stream/consumers';
+     * import { Readable } from 'node:stream';
+     * import { TextEncoder } from 'node:util';
+     *
+     * const encoder = new TextEncoder();
+     * const dataArray = encoder.encode('hello world from consumers!');
+     *
+     * const readable = Readable.from(dataArray);
+     * const data = await arrayBuffer(readable);
+     * console.log(`from readable: ${data.byteLength}`);
+     * // Prints: from readable: 76
+     * ```
      * @since v16.7.0
      * @returns Fulfills with an `ArrayBuffer` containing the full contents of the stream.
      */
     function arrayBuffer(stream: ReadableStream | NodeJS.ReadableStream | AsyncIterable<any>): Promise<ArrayBuffer>;
     /**
+     * ```js
+     * import { blob } from 'node:stream/consumers';
+     *
+     * const dataBlob = new Blob(['hello world from consumers!']);
+     *
+     * const readable = dataBlob.stream();
+     * const data = await blob(readable);
+     * console.log(`from readable: ${data.size}`);
+     * // Prints: from readable: 27
+     * ```
      * @since v16.7.0
      * @returns Fulfills with a `Blob` containing the full contents of the stream.
      */
     function blob(stream: ReadableStream | NodeJS.ReadableStream | AsyncIterable<any>): Promise<Blob>;
     /**
+     * ```js
+     * import { buffer } from 'node:stream/consumers';
+     * import { Readable } from 'node:stream';
+     * import { Buffer } from 'node:buffer';
+     *
+     * const dataBuffer = Buffer.from('hello world from consumers!');
+     *
+     * const readable = Readable.from(dataBuffer);
+     * const data = await buffer(readable);
+     * console.log(`from readable: ${data.length}`);
+     * // Prints: from readable: 27
+     * ```
      * @since v16.7.0
      * @returns Fulfills with a `Buffer` containing the full contents of the stream.
      */
     function buffer(stream: ReadableStream | NodeJS.ReadableStream | AsyncIterable<any>): Promise<NonSharedBuffer>;
     /**
+     * ```js
+     * import { bytes } from 'node:stream/consumers';
+     * import { Readable } from 'node:stream';
+     * import { Buffer } from 'node:buffer';
+     *
+     * const dataBuffer = Buffer.from('hello world from consumers!');
+     *
+     * const readable = Readable.from(dataBuffer);
+     * const data = await bytes(readable);
+     * console.log(`from readable: ${data.length}`);
+     * // Prints: from readable: 27
+     * ```
+     * @since v25.6.0
+     * @returns Fulfills with a `Uint8Array` containing the full contents of the stream.
+     */
+    function bytes(
+        stream: ReadableStream | NodeJS.ReadableStream | AsyncIterable<any>,
+    ): Promise<NodeJS.NonSharedUint8Array>;
+    /**
+     * ```js
+     * import { json } from 'node:stream/consumers';
+     * import { Readable } from 'node:stream';
+     *
+     * const items = Array.from(
+     *   {
+     *     length: 100,
+     *   },
+     *   () => ({
+     *     message: 'hello world from consumers!',
+     *   }),
+     * );
+     *
+     * const readable = Readable.from(JSON.stringify(items));
+     * const data = await json(readable);
+     * console.log(`from readable: ${data.length}`);
+     * // Prints: from readable: 100
+     * ```
      * @since v16.7.0
      * @returns Fulfills with the contents of the stream parsed as a
      * UTF-8 encoded string that is then passed through `JSON.parse()`.
      */
     function json(stream: ReadableStream | NodeJS.ReadableStream | AsyncIterable<any>): Promise<unknown>;
     /**
+     * ```js
+     * import { text } from 'node:stream/consumers';
+     * import { Readable } from 'node:stream';
+     *
+     * const readable = Readable.from('Hello world from consumers!');
+     * const data = await text(readable);
+     * console.log(`from readable: ${data.length}`);
+     * // Prints: from readable: 27
+     * ```
      * @since v16.7.0
      * @returns Fulfills with the contents of the stream parsed as a UTF-8 encoded string.
      */

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

@@ -206,7 +206,7 @@ declare module "node:stream/web" {
     interface ReadableStreamDefaultController<R = any> {
         readonly desiredSize: number | null;
         close(): void;
-        enqueue(chunk?: R): void;
+        enqueue(chunk: R): void;
         error(e?: any): void;
     }
     var ReadableStreamDefaultController: {
@@ -251,7 +251,7 @@ declare module "node:stream/web" {
     };
     interface TransformStreamDefaultController<O = any> {
         readonly desiredSize: number | null;
-        enqueue(chunk?: O): void;
+        enqueue(chunk: O): void;
         error(reason?: any): void;
         terminate(): void;
     }
@@ -284,7 +284,7 @@ declare module "node:stream/web" {
         abort(reason?: any): Promise<void>;
         close(): Promise<void>;
         releaseLock(): void;
-        write(chunk?: W): Promise<void>;
+        write(chunk: W): Promise<void>;
     }
     var WritableStreamDefaultWriter: {
         prototype: WritableStreamDefaultWriter;