@openclaw/slack 2026.7.2-beta.7 → 2026.7.33

package/node_modules/@slack/socket-mode/node_modules/@types/node/trace_events.d.ts

@@ -1,103 +0,0 @@
-declare module "node:trace_events" {
-    /**
-     * The `Tracing` object is used to enable or disable tracing for sets of
-     * categories. Instances are created using the
-     * `trace_events.createTracing()` method.
-     *
-     * When created, the `Tracing` object is disabled. Calling the
-     * `tracing.enable()` method adds the categories to the set of enabled trace
-     * event categories. Calling `tracing.disable()` will remove the categories
-     * from the set of enabled trace event categories.
-     */
-    interface Tracing {
-        /**
-         * A comma-separated list of the trace event categories covered by this
-         * `Tracing` object.
-         * @since v10.0.0
-         */
-        readonly categories: string;
-        /**
-         * Disables this `Tracing` object.
-         *
-         * Only trace event categories _not_ covered by other enabled `Tracing`
-         * objects and _not_ specified by the `--trace-event-categories` flag
-         * will be disabled.
-         *
-         * ```js
-         * import trace_events from 'node:trace_events';
-         * const t1 = trace_events.createTracing({ categories: ['node', 'v8'] });
-         * const t2 = trace_events.createTracing({ categories: ['node.perf', 'node'] });
-         * t1.enable();
-         * t2.enable();
-         *
-         * // Prints 'node,node.perf,v8'
-         * console.log(trace_events.getEnabledCategories());
-         *
-         * t2.disable(); // Will only disable emission of the 'node.perf' category
-         *
-         * // Prints 'node,v8'
-         * console.log(trace_events.getEnabledCategories());
-         * ```
-         * @since v10.0.0
-         */
-        disable(): void;
-        /**
-         * Enables this `Tracing` object for the set of categories covered by
-         * the `Tracing` object.
-         * @since v10.0.0
-         */
-        enable(): void;
-        /**
-         * `true` only if the `Tracing` object has been enabled.
-         * @since v10.0.0
-         */
-        readonly enabled: boolean;
-    }
-    interface CreateTracingOptions {
-        /**
-         * An array of trace category names. Values included in the array are
-         * coerced to a string when possible. An error will be thrown if the
-         * value cannot be coerced.
-         */
-        categories: string[];
-    }
-    /**
-     * Creates and returns a `Tracing` object for the given set of `categories`.
-     *
-     * ```js
-     * import trace_events from 'node:trace_events';
-     * const categories = ['node.perf', 'node.async_hooks'];
-     * const tracing = trace_events.createTracing({ categories });
-     * tracing.enable();
-     * // do stuff
-     * tracing.disable();
-     * ```
-     * @since v10.0.0
-     */
-    function createTracing(options: CreateTracingOptions): Tracing;
-    /**
-     * Returns a comma-separated list of all currently-enabled trace event
-     * categories. The current set of enabled trace event categories is determined
-     * by the _union_ of all currently-enabled `Tracing` objects and any categories
-     * enabled using the `--trace-event-categories` flag.
-     *
-     * Given the file `test.js` below, the command `node --trace-event-categories node.perf test.js` will print `'node.async_hooks,node.perf'` to the console.
-     *
-     * ```js
-     * import trace_events from 'node:trace_events';
-     * const t1 = trace_events.createTracing({ categories: ['node.async_hooks'] });
-     * const t2 = trace_events.createTracing({ categories: ['node.perf'] });
-     * const t3 = trace_events.createTracing({ categories: ['v8'] });
-     *
-     * t1.enable();
-     * t2.enable();
-     *
-     * console.log(trace_events.getEnabledCategories());
-     * ```
-     * @since v10.0.0
-     */
-    function getEnabledCategories(): string | undefined;
-}
-declare module "trace_events" {
-    export * from "node:trace_events";
-}

package/node_modules/@slack/socket-mode/node_modules/@types/node/ts5.6/buffer.buffer.d.ts

@@ -1,462 +0,0 @@
-declare module "node:buffer" {
-    global {
-        interface BufferConstructor {
-            // see ../buffer.d.ts for implementation shared with all TypeScript versions
-
-            /**
-             * Allocates a new buffer containing the given {str}.
-             *
-             * @param str String to store in buffer.
-             * @param encoding encoding to use, optional.  Default is 'utf8'
-             * @deprecated since v10.0.0 - Use `Buffer.from(string[, encoding])` instead.
-             */
-            new(str: string, encoding?: BufferEncoding): Buffer;
-            /**
-             * Allocates a new buffer of {size} octets.
-             *
-             * @param size count of octets to allocate.
-             * @deprecated since v10.0.0 - Use `Buffer.alloc()` instead (also see `Buffer.allocUnsafe()`).
-             */
-            new(size: number): Buffer;
-            /**
-             * Allocates a new buffer containing the given {array} of octets.
-             *
-             * @param array The octets to store.
-             * @deprecated since v10.0.0 - Use `Buffer.from(array)` instead.
-             */
-            new(array: ArrayLike<number>): Buffer;
-            /**
-             * Produces a Buffer backed by the same allocated memory as
-             * the given {ArrayBuffer}/{SharedArrayBuffer}.
-             *
-             * @param arrayBuffer The ArrayBuffer with which to share memory.
-             * @deprecated since v10.0.0 - Use `Buffer.from(arrayBuffer[, byteOffset[, length]])` instead.
-             */
-            new(arrayBuffer: ArrayBufferLike): Buffer;
-            /**
-             * Allocates a new `Buffer` using an `array` of bytes in the range `0` – `255`.
-             * Array entries outside that range will be truncated to fit into it.
-             *
-             * ```js
-             * import { Buffer } from 'node:buffer';
-             *
-             * // Creates a new Buffer containing the UTF-8 bytes of the string 'buffer'.
-             * const buf = Buffer.from([0x62, 0x75, 0x66, 0x66, 0x65, 0x72]);
-             * ```
-             *
-             * If `array` is an `Array`-like object (that is, one with a `length` property of
-             * type `number`), it is treated as if it is an array, unless it is a `Buffer` or
-             * a `Uint8Array`. This means all other `TypedArray` variants get treated as an
-             * `Array`. To create a `Buffer` from the bytes backing a `TypedArray`, use
-             * `Buffer.copyBytesFrom()`.
-             *
-             * A `TypeError` will be thrown if `array` is not an `Array` or another type
-             * appropriate for `Buffer.from()` variants.
-             *
-             * `Buffer.from(array)` and `Buffer.from(string)` may also use the internal
-             * `Buffer` pool like `Buffer.allocUnsafe()` does.
-             * @since v5.10.0
-             */
-            from(array: WithImplicitCoercion<ArrayLike<number>>): Buffer;
-            /**
-             * This creates a view of the `ArrayBuffer` without copying the underlying
-             * memory. For example, when passed a reference to the `.buffer` property of a
-             * `TypedArray` instance, the newly created `Buffer` will share the same
-             * allocated memory as the `TypedArray`'s underlying `ArrayBuffer`.
-             *
-             * ```js
-             * import { Buffer } from 'node:buffer';
-             *
-             * const arr = new Uint16Array(2);
-             *
-             * arr[0] = 5000;
-             * arr[1] = 4000;
-             *
-             * // Shares memory with `arr`.
-             * const buf = Buffer.from(arr.buffer);
-             *
-             * console.log(buf);
-             * // Prints: <Buffer 88 13 a0 0f>
-             *
-             * // Changing the original Uint16Array changes the Buffer also.
-             * arr[1] = 6000;
-             *
-             * console.log(buf);
-             * // Prints: <Buffer 88 13 70 17>
-             * ```
-             *
-             * The optional `byteOffset` and `length` arguments specify a memory range within
-             * the `arrayBuffer` that will be shared by the `Buffer`.
-             *
-             * ```js
-             * import { Buffer } from 'node:buffer';
-             *
-             * const ab = new ArrayBuffer(10);
-             * const buf = Buffer.from(ab, 0, 2);
-             *
-             * console.log(buf.length);
-             * // Prints: 2
-             * ```
-             *
-             * A `TypeError` will be thrown if `arrayBuffer` is not an `ArrayBuffer` or a
-             * `SharedArrayBuffer` or another type appropriate for `Buffer.from()`
-             * variants.
-             *
-             * It is important to remember that a backing `ArrayBuffer` can cover a range
-             * of memory that extends beyond the bounds of a `TypedArray` view. A new
-             * `Buffer` created using the `buffer` property of a `TypedArray` may extend
-             * beyond the range of the `TypedArray`:
-             *
-             * ```js
-             * import { Buffer } from 'node:buffer';
-             *
-             * const arrA = Uint8Array.from([0x63, 0x64, 0x65, 0x66]); // 4 elements
-             * const arrB = new Uint8Array(arrA.buffer, 1, 2); // 2 elements
-             * console.log(arrA.buffer === arrB.buffer); // true
-             *
-             * const buf = Buffer.from(arrB.buffer);
-             * console.log(buf);
-             * // Prints: <Buffer 63 64 65 66>
-             * ```
-             * @since v5.10.0
-             * @param arrayBuffer An `ArrayBuffer`, `SharedArrayBuffer`, for example the
-             * `.buffer` property of a `TypedArray`.
-             * @param byteOffset Index of first byte to expose. **Default:** `0`.
-             * @param length Number of bytes to expose. **Default:**
-             * `arrayBuffer.byteLength - byteOffset`.
-             */
-            from(
-                arrayBuffer: WithImplicitCoercion<ArrayBufferLike>,
-                byteOffset?: number,
-                length?: number,
-            ): Buffer;
-            /**
-             * Creates a new `Buffer` containing `string`. The `encoding` parameter identifies
-             * the character encoding to be used when converting `string` into bytes.
-             *
-             * ```js
-             * import { Buffer } from 'node:buffer';
-             *
-             * const buf1 = Buffer.from('this is a tést');
-             * const buf2 = Buffer.from('7468697320697320612074c3a97374', 'hex');
-             *
-             * console.log(buf1.toString());
-             * // Prints: this is a tést
-             * console.log(buf2.toString());
-             * // Prints: this is a tést
-             * console.log(buf1.toString('latin1'));
-             * // Prints: this is a tést
-             * ```
-             *
-             * A `TypeError` will be thrown if `string` is not a string or another type
-             * appropriate for `Buffer.from()` variants.
-             *
-             * `Buffer.from(string)` may also use the internal `Buffer` pool like
-             * `Buffer.allocUnsafe()` does.
-             * @since v5.10.0
-             * @param string A string to encode.
-             * @param encoding The encoding of `string`. **Default:** `'utf8'`.
-             */
-            from(string: WithImplicitCoercion<string>, encoding?: BufferEncoding): Buffer;
-            from(arrayOrString: WithImplicitCoercion<ArrayLike<number> | string>): Buffer;
-            /**
-             * Creates a new Buffer using the passed {data}
-             * @param values to create a new Buffer
-             */
-            of(...items: number[]): Buffer;
-            /**
-             * Returns a new `Buffer` which is the result of concatenating all the `Buffer` instances in the `list` together.
-             *
-             * If the list has no items, or if the `totalLength` is 0, then a new zero-length `Buffer` is returned.
-             *
-             * If `totalLength` is not provided, it is calculated from the `Buffer` instances
-             * in `list` by adding their lengths.
-             *
-             * If `totalLength` is provided, it must be an unsigned integer. If the
-             * combined length of the `Buffer`s in `list` exceeds `totalLength`, the result is
-             * truncated to `totalLength`.
-             *
-             * ```js
-             * import { Buffer } from 'node:buffer';
-             *
-             * // Create a single `Buffer` from a list of three `Buffer` instances.
-             *
-             * const buf1 = Buffer.alloc(10);
-             * const buf2 = Buffer.alloc(14);
-             * const buf3 = Buffer.alloc(18);
-             * const totalLength = buf1.length + buf2.length + buf3.length;
-             *
-             * console.log(totalLength);
-             * // Prints: 42
-             *
-             * const bufA = Buffer.concat([buf1, buf2, buf3], totalLength);
-             *
-             * console.log(bufA);
-             * // Prints: <Buffer 00 00 00 00 ...>
-             * console.log(bufA.length);
-             * // Prints: 42
-             * ```
-             *
-             * `Buffer.concat()` may also use the internal `Buffer` pool like `Buffer.allocUnsafe()` does.
-             * @since v0.7.11
-             * @param list List of `Buffer` or {@link Uint8Array} instances to concatenate.
-             * @param totalLength Total length of the `Buffer` instances in `list` when concatenated.
-             */
-            concat(list: readonly Uint8Array[], totalLength?: number): Buffer;
-            /**
-             * Copies the underlying memory of `view` into a new `Buffer`.
-             *
-             * ```js
-             * const u16 = new Uint16Array([0, 0xffff]);
-             * const buf = Buffer.copyBytesFrom(u16, 1, 1);
-             * u16[1] = 0;
-             * console.log(buf.length); // 2
-             * console.log(buf[0]); // 255
-             * console.log(buf[1]); // 255
-             * ```
-             * @since v19.8.0
-             * @param view The {TypedArray} to copy.
-             * @param [offset=0] The starting offset within `view`.
-             * @param [length=view.length - offset] The number of elements from `view` to copy.
-             */
-            copyBytesFrom(view: NodeJS.TypedArray, offset?: number, length?: number): Buffer;
-            /**
-             * Allocates a new `Buffer` of `size` bytes. If `fill` is `undefined`, the`Buffer` will be zero-filled.
-             *
-             * ```js
-             * import { Buffer } from 'node:buffer';
-             *
-             * const buf = Buffer.alloc(5);
-             *
-             * console.log(buf);
-             * // Prints: <Buffer 00 00 00 00 00>
-             * ```
-             *
-             * If `size` is larger than {@link constants.MAX_LENGTH} or smaller than 0, `ERR_OUT_OF_RANGE` is thrown.
-             *
-             * If `fill` is specified, the allocated `Buffer` will be initialized by calling `buf.fill(fill)`.
-             *
-             * ```js
-             * import { Buffer } from 'node:buffer';
-             *
-             * const buf = Buffer.alloc(5, 'a');
-             *
-             * console.log(buf);
-             * // Prints: <Buffer 61 61 61 61 61>
-             * ```
-             *
-             * If both `fill` and `encoding` are specified, the allocated `Buffer` will be
-             * initialized by calling `buf.fill(fill, encoding)`.
-             *
-             * ```js
-             * import { Buffer } from 'node:buffer';
-             *
-             * const buf = Buffer.alloc(11, 'aGVsbG8gd29ybGQ=', 'base64');
-             *
-             * console.log(buf);
-             * // Prints: <Buffer 68 65 6c 6c 6f 20 77 6f 72 6c 64>
-             * ```
-             *
-             * Calling `Buffer.alloc()` can be measurably slower than the alternative `Buffer.allocUnsafe()` but ensures that the newly created `Buffer` instance
-             * contents will never contain sensitive data from previous allocations, including
-             * data that might not have been allocated for `Buffer`s.
-             *
-             * A `TypeError` will be thrown if `size` is not a number.
-             * @since v5.10.0
-             * @param size The desired length of the new `Buffer`.
-             * @param [fill=0] A value to pre-fill the new `Buffer` with.
-             * @param [encoding='utf8'] If `fill` is a string, this is its encoding.
-             */
-            alloc(size: number, fill?: string | Uint8Array | number, encoding?: BufferEncoding): Buffer;
-            /**
-             * Allocates a new `Buffer` of `size` bytes. If `size` is larger than {@link constants.MAX_LENGTH} or smaller than 0, `ERR_OUT_OF_RANGE` is thrown.
-             *
-             * The underlying memory for `Buffer` instances created in this way is _not_
-             * _initialized_. The contents of the newly created `Buffer` are unknown and _may contain sensitive data_. Use `Buffer.alloc()` instead to initialize`Buffer` instances with zeroes.
-             *
-             * ```js
-             * import { Buffer } from 'node:buffer';
-             *
-             * const buf = Buffer.allocUnsafe(10);
-             *
-             * console.log(buf);
-             * // Prints (contents may vary): <Buffer a0 8b 28 3f 01 00 00 00 50 32>
-             *
-             * buf.fill(0);
-             *
-             * console.log(buf);
-             * // Prints: <Buffer 00 00 00 00 00 00 00 00 00 00>
-             * ```
-             *
-             * A `TypeError` will be thrown if `size` is not a number.
-             *
-             * 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 `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)`.
-             * Specifically, `Buffer.alloc(size, fill)` will _never_ use the internal `Buffer`pool, while `Buffer.allocUnsafe(size).fill(fill)`_will_ use the internal`Buffer` pool if `size` is less
-             * than or equal to half `Buffer.poolSize`. The
-             * difference is subtle but can be important when an application requires the
-             * additional performance that `Buffer.allocUnsafe()` provides.
-             * @since v5.10.0
-             * @param size The desired length of the new `Buffer`.
-             */
-            allocUnsafe(size: number): Buffer;
-            /**
-             * Allocates a new `Buffer` of `size` bytes. If `size` is larger than {@link constants.MAX_LENGTH} or smaller than 0, `ERR_OUT_OF_RANGE` is thrown. A zero-length `Buffer` is created if
-             * `size` is 0.
-             *
-             * The underlying memory for `Buffer` instances created in this way is _not_
-             * _initialized_. The contents of the newly created `Buffer` are unknown and _may contain sensitive data_. Use `buf.fill(0)` to initialize
-             * such `Buffer` instances with zeroes.
-             *
-             * When using `Buffer.allocUnsafe()` to allocate new `Buffer` instances,
-             * allocations under 4 KiB are sliced from a single pre-allocated `Buffer`. This
-             * allows applications to avoid the garbage collection overhead of creating many
-             * individually allocated `Buffer` instances. This approach improves both
-             * performance and memory usage by eliminating the need to track and clean up as
-             * many individual `ArrayBuffer` objects.
-             *
-             * However, in the case where a developer may need to retain a small chunk of
-             * memory from a pool for an indeterminate amount of time, it may be appropriate
-             * to create an un-pooled `Buffer` instance using `Buffer.allocUnsafeSlow()` and
-             * then copying out the relevant bits.
-             *
-             * ```js
-             * import { Buffer } from 'node:buffer';
-             *
-             * // Need to keep around a few small chunks of memory.
-             * const store = [];
-             *
-             * socket.on('readable', () => {
-             *   let data;
-             *   while (null !== (data = readable.read())) {
-             *     // Allocate for retained data.
-             *     const sb = Buffer.allocUnsafeSlow(10);
-             *
-             *     // Copy the data into the new allocation.
-             *     data.copy(sb, 0, 0, 10);
-             *
-             *     store.push(sb);
-             *   }
-             * });
-             * ```
-             *
-             * A `TypeError` will be thrown if `size` is not a number.
-             * @since v5.12.0
-             * @param size The desired length of the new `Buffer`.
-             */
-            allocUnsafeSlow(size: number): Buffer;
-        }
-        interface Buffer extends Uint8Array {
-            // see ../buffer.d.ts for implementation shared with all TypeScript versions
-
-            /**
-             * Returns a new `Buffer` that references the same memory as the original, but
-             * offset and cropped by the `start` and `end` indices.
-             *
-             * This method is not compatible with the `Uint8Array.prototype.slice()`,
-             * which is a superclass of `Buffer`. To copy the slice, use`Uint8Array.prototype.slice()`.
-             *
-             * ```js
-             * import { Buffer } from 'node:buffer';
-             *
-             * const buf = Buffer.from('buffer');
-             *
-             * const copiedBuf = Uint8Array.prototype.slice.call(buf);
-             * copiedBuf[0]++;
-             * console.log(copiedBuf.toString());
-             * // Prints: cuffer
-             *
-             * console.log(buf.toString());
-             * // Prints: buffer
-             *
-             * // With buf.slice(), the original buffer is modified.
-             * const notReallyCopiedBuf = buf.slice();
-             * notReallyCopiedBuf[0]++;
-             * console.log(notReallyCopiedBuf.toString());
-             * // Prints: cuffer
-             * console.log(buf.toString());
-             * // Also prints: cuffer (!)
-             * ```
-             * @since v0.3.0
-             * @deprecated Use `subarray` instead.
-             * @param [start=0] Where the new `Buffer` will start.
-             * @param [end=buf.length] Where the new `Buffer` will end (not inclusive).
-             */
-            slice(start?: number, end?: number): Buffer;
-            /**
-             * Returns a new `Buffer` that references the same memory as the original, but
-             * offset and cropped by the `start` and `end` indices.
-             *
-             * Specifying `end` greater than `buf.length` will return the same result as
-             * that of `end` equal to `buf.length`.
-             *
-             * This method is inherited from [`TypedArray.prototype.subarray()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/subarray).
-             *
-             * Modifying the new `Buffer` slice will modify the memory in the original `Buffer`because the allocated memory of the two objects overlap.
-             *
-             * ```js
-             * import { Buffer } from 'node:buffer';
-             *
-             * // Create a `Buffer` with the ASCII alphabet, take a slice, and modify one byte
-             * // from the original `Buffer`.
-             *
-             * const buf1 = Buffer.allocUnsafe(26);
-             *
-             * for (let i = 0; i < 26; i++) {
-             *   // 97 is the decimal ASCII value for 'a'.
-             *   buf1[i] = i + 97;
-             * }
-             *
-             * const buf2 = buf1.subarray(0, 3);
-             *
-             * console.log(buf2.toString('ascii', 0, buf2.length));
-             * // Prints: abc
-             *
-             * buf1[0] = 33;
-             *
-             * console.log(buf2.toString('ascii', 0, buf2.length));
-             * // Prints: !bc
-             * ```
-             *
-             * Specifying negative indexes causes the slice to be generated relative to the
-             * end of `buf` rather than the beginning.
-             *
-             * ```js
-             * import { Buffer } from 'node:buffer';
-             *
-             * const buf = Buffer.from('buffer');
-             *
-             * console.log(buf.subarray(-6, -1).toString());
-             * // Prints: buffe
-             * // (Equivalent to buf.subarray(0, 5).)
-             *
-             * console.log(buf.subarray(-6, -2).toString());
-             * // Prints: buff
-             * // (Equivalent to buf.subarray(0, 4).)
-             *
-             * console.log(buf.subarray(-5, -2).toString());
-             * // Prints: uff
-             * // (Equivalent to buf.subarray(1, 4).)
-             * ```
-             * @since v3.0.0
-             * @param [start=0] Where the new `Buffer` will start.
-             * @param [end=buf.length] Where the new `Buffer` will end (not inclusive).
-             */
-            subarray(start?: number, end?: number): Buffer;
-        }
-        /**
-         * @deprecated This is intended for internal use, and will be removed once `@types/node` no longer supports
-         * TypeScript versions earlier than 5.7.
-         */
-        type NonSharedBuffer = Buffer;
-        /**
-         * @deprecated This is intended for internal use, and will be removed once `@types/node` no longer supports
-         * TypeScript versions earlier than 5.7.
-         */
-        type AllowSharedBuffer = Buffer;
-    }
-}

package/node_modules/@slack/socket-mode/node_modules/@types/node/ts5.6/compatibility/float16array.d.ts

@@ -1,71 +0,0 @@
-// Interface declaration for Float16Array, required in @types/node v24+.
-// These definitions are specific to TS <=5.6.
-
-// This needs all of the "common" properties/methods of the TypedArrays,
-// otherwise the type unions `TypedArray` and `ArrayBufferView` will be
-// empty objects.
-interface Float16Array extends Pick<Float32Array, typeof Symbol.iterator | "entries" | "keys" | "values"> {
-    readonly BYTES_PER_ELEMENT: number;
-    readonly buffer: ArrayBufferLike;
-    readonly byteLength: number;
-    readonly byteOffset: number;
-    readonly length: number;
-    readonly [Symbol.toStringTag]: "Float16Array";
-    at(index: number): number | undefined;
-    copyWithin(target: number, start: number, end?: number): this;
-    every(predicate: (value: number, index: number, array: Float16Array) => unknown, thisArg?: any): boolean;
-    fill(value: number, start?: number, end?: number): this;
-    filter(predicate: (value: number, index: number, array: Float16Array) => any, thisArg?: any): Float16Array;
-    find(predicate: (value: number, index: number, obj: Float16Array) => boolean, thisArg?: any): number | undefined;
-    findIndex(predicate: (value: number, index: number, obj: Float16Array) => boolean, thisArg?: any): number;
-    findLast<S extends number>(
-        predicate: (value: number, index: number, array: Float16Array) => value is S,
-        thisArg?: any,
-    ): S | undefined;
-    findLast(
-        predicate: (value: number, index: number, array: Float16Array) => unknown,
-        thisArg?: any,
-    ): number | undefined;
-    findLastIndex(predicate: (value: number, index: number, array: Float16Array) => unknown, thisArg?: any): number;
-    forEach(callbackfn: (value: number, index: number, array: Float16Array) => void, thisArg?: any): void;
-    includes(searchElement: number, fromIndex?: number): boolean;
-    indexOf(searchElement: number, fromIndex?: number): number;
-    join(separator?: string): string;
-    lastIndexOf(searchElement: number, fromIndex?: number): number;
-    map(callbackfn: (value: number, index: number, array: Float16Array) => number, thisArg?: any): Float16Array;
-    reduce(
-        callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Float16Array) => number,
-    ): number;
-    reduce(
-        callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Float16Array) => number,
-        initialValue: number,
-    ): number;
-    reduce<U>(
-        callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: Float16Array) => U,
-        initialValue: U,
-    ): U;
-    reduceRight(
-        callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Float16Array) => number,
-    ): number;
-    reduceRight(
-        callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Float16Array) => number,
-        initialValue: number,
-    ): number;
-    reduceRight<U>(
-        callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: Float16Array) => U,
-        initialValue: U,
-    ): U;
-    reverse(): Float16Array;
-    set(array: ArrayLike<number>, offset?: number): void;
-    slice(start?: number, end?: number): Float16Array;
-    some(predicate: (value: number, index: number, array: Float16Array) => unknown, thisArg?: any): boolean;
-    sort(compareFn?: (a: number, b: number) => number): this;
-    subarray(begin?: number, end?: number): Float16Array;
-    toLocaleString(locales: string | string[], options?: Intl.NumberFormatOptions): string;
-    toReversed(): Float16Array;
-    toSorted(compareFn?: (a: number, b: number) => number): Float16Array;
-    toString(): string;
-    valueOf(): Float16Array;
-    with(index: number, value: number): Float16Array;
-    [index: number]: number;
-}

package/node_modules/@slack/socket-mode/node_modules/@types/node/ts5.6/globals.typedarray.d.ts

@@ -1,36 +0,0 @@
-export {}; // Make this a module
-
-declare global {
-    namespace NodeJS {
-        type TypedArray =
-            | Uint8Array
-            | Uint8ClampedArray
-            | Uint16Array
-            | Uint32Array
-            | Int8Array
-            | Int16Array
-            | Int32Array
-            | BigUint64Array
-            | BigInt64Array
-            | Float16Array
-            | Float32Array
-            | Float64Array;
-        type ArrayBufferView = TypedArray | DataView;
-
-        type NonSharedUint8Array = Uint8Array;
-        type NonSharedUint8ClampedArray = Uint8ClampedArray;
-        type NonSharedUint16Array = Uint16Array;
-        type NonSharedUint32Array = Uint32Array;
-        type NonSharedInt8Array = Int8Array;
-        type NonSharedInt16Array = Int16Array;
-        type NonSharedInt32Array = Int32Array;
-        type NonSharedBigUint64Array = BigUint64Array;
-        type NonSharedBigInt64Array = BigInt64Array;
-        type NonSharedFloat16Array = Float16Array;
-        type NonSharedFloat32Array = Float32Array;
-        type NonSharedFloat64Array = Float64Array;
-        type NonSharedDataView = DataView;
-        type NonSharedTypedArray = TypedArray;
-        type NonSharedArrayBufferView = ArrayBufferView;
-    }
-}