@openclaw/slack 2026.10.5-beta.1 → 2026.10.5-beta.2

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

@@ -1,211 +0,0 @@
-declare module "node:stream/promises" {
-    import { Abortable } from "node:events";
-    import {
-        FinishedOptions as _FinishedOptions,
-        PipelineDestination,
-        PipelineSource,
-        PipelineTransform,
-    } from "node:stream";
-    import { ReadableStream, WritableStream } from "node:stream/web";
-    interface FinishedOptions extends _FinishedOptions {
-        /**
-         * If true, removes the listeners registered by this function before the promise is fulfilled.
-         * @default false
-         */
-        cleanup?: boolean | undefined;
-    }
-    /**
-     * ```js
-     * import { finished } from 'node:stream/promises';
-     * import { createReadStream } from 'node:fs';
-     *
-     * const rs = createReadStream('archive.tar');
-     *
-     * async function run() {
-     *   await finished(rs);
-     *   console.log('Stream is done reading.');
-     * }
-     *
-     * run().catch(console.error);
-     * rs.resume(); // Drain the stream.
-     * ```
-     *
-     * The `finished` API also provides a [callback version](https://nodejs.org/docs/latest-v26.x/api/stream.html#streamfinishedstream-options-callback).
-     *
-     * `stream.finished()` leaves dangling event listeners (in particular
-     * `'error'`, `'end'`, `'finish'` and `'close'`) after the returned promise is
-     * resolved or rejected. The reason for this is so that unexpected `'error'`
-     * events (due to incorrect stream implementations) do not cause unexpected
-     * crashes. If this is unwanted behavior then `options.cleanup` should be set to
-     * `true`:
-     *
-     * ```js
-     * await finished(rs, { cleanup: true });
-     * ```
-     * @since v15.0.0
-     * @returns Fulfills when the stream is no longer readable or writable.
-     */
-    function finished(
-        stream: NodeJS.ReadableStream | NodeJS.WritableStream | ReadableStream | WritableStream,
-        options?: FinishedOptions,
-    ): Promise<void>;
-    interface PipelineOptions extends Abortable {
-        end?: boolean | undefined;
-    }
-    type PipelineResult<S extends PipelineDestination<any, any>> = S extends (...args: any[]) => PromiseLike<infer R>
-        ? Promise<R>
-        : Promise<void>;
-    /**
-     * ```js
-     * import { pipeline } from 'node:stream/promises';
-     * import { createReadStream, createWriteStream } from 'node:fs';
-     * import { createGzip } from 'node:zlib';
-     *
-     * await pipeline(
-     *   createReadStream('archive.tar'),
-     *   createGzip(),
-     *   createWriteStream('archive.tar.gz'),
-     * );
-     * console.log('Pipeline succeeded.');
-     * ```
-     *
-     * To use an `AbortSignal`, pass it inside an options object, as the last argument.
-     * When the signal is aborted, `destroy` will be called on the underlying pipeline,
-     * with an `AbortError`.
-     *
-     * ```js
-     * import { pipeline } from 'node:stream/promises';
-     * import { createReadStream, createWriteStream } from 'node:fs';
-     * import { createGzip } from 'node:zlib';
-     *
-     * const ac = new AbortController();
-     * const { signal } = ac;
-     * setImmediate(() => ac.abort());
-     * try {
-     *   await pipeline(
-     *     createReadStream('archive.tar'),
-     *     createGzip(),
-     *     createWriteStream('archive.tar.gz'),
-     *     { signal },
-     *   );
-     * } catch (err) {
-     *   console.error(err); // AbortError
-     * }
-     * ```
-     *
-     * The `pipeline` API also supports async generators:
-     *
-     * ```js
-     * import { pipeline } from 'node:stream/promises';
-     * import { createReadStream, createWriteStream } from 'node:fs';
-     *
-     * await pipeline(
-     *   createReadStream('lowercase.txt'),
-     *   async function* (source, { signal }) {
-     *     source.setEncoding('utf8');  // Work with strings rather than `Buffer`s.
-     *     for await (const chunk of source) {
-     *       yield await processChunk(chunk, { signal });
-     *     }
-     *   },
-     *   createWriteStream('uppercase.txt'),
-     * );
-     * console.log('Pipeline succeeded.');
-     * ```
-     *
-     * Remember to handle the `signal` argument passed into the async generator.
-     * Especially in the case where the async generator is the source for the
-     * pipeline (i.e. first argument) or the pipeline will never complete.
-     *
-     * ```js
-     * import { pipeline } from 'node:stream/promises';
-     * import fs from 'node:fs';
-     * await pipeline(
-     *   async function* ({ signal }) {
-     *     await someLongRunningfn({ signal });
-     *     yield 'asd';
-     *   },
-     *   fs.createWriteStream('uppercase.txt'),
-     * );
-     * console.log('Pipeline succeeded.');
-     * ```
-     *
-     * The `pipeline` API provides [callback version](https://nodejs.org/docs/latest-v26.x/api/stream.html#streampipelinesource-transforms-destination-callback):
-     * @since v15.0.0
-     * @returns Fulfills when the pipeline is complete.
-     */
-    function pipeline<A extends PipelineSource<any>, B extends PipelineDestination<A, any>>(
-        source: A,
-        destination: B,
-        options?: PipelineOptions,
-    ): PipelineResult<B>;
-    function pipeline<
-        A extends PipelineSource<any>,
-        T1 extends PipelineTransform<A, any>,
-        B extends PipelineDestination<T1, any>,
-    >(
-        source: A,
-        transform1: T1,
-        destination: B,
-        options?: PipelineOptions,
-    ): PipelineResult<B>;
-    function pipeline<
-        A extends PipelineSource<any>,
-        T1 extends PipelineTransform<A, any>,
-        T2 extends PipelineTransform<T1, any>,
-        B extends PipelineDestination<T2, any>,
-    >(
-        source: A,
-        transform1: T1,
-        transform2: T2,
-        destination: B,
-        options?: PipelineOptions,
-    ): PipelineResult<B>;
-    function pipeline<
-        A extends PipelineSource<any>,
-        T1 extends PipelineTransform<A, any>,
-        T2 extends PipelineTransform<T1, any>,
-        T3 extends PipelineTransform<T2, any>,
-        B extends PipelineDestination<T3, any>,
-    >(
-        source: A,
-        transform1: T1,
-        transform2: T2,
-        transform3: T3,
-        destination: B,
-        options?: PipelineOptions,
-    ): PipelineResult<B>;
-    function pipeline<
-        A extends PipelineSource<any>,
-        T1 extends PipelineTransform<A, any>,
-        T2 extends PipelineTransform<T1, any>,
-        T3 extends PipelineTransform<T2, any>,
-        T4 extends PipelineTransform<T3, any>,
-        B extends PipelineDestination<T4, any>,
-    >(
-        source: A,
-        transform1: T1,
-        transform2: T2,
-        transform3: T3,
-        transform4: T4,
-        destination: B,
-        options?: PipelineOptions,
-    ): PipelineResult<B>;
-    function pipeline(
-        streams: readonly [PipelineSource<any>, ...PipelineTransform<any, any>[], PipelineDestination<any, any>],
-        options?: PipelineOptions,
-    ): Promise<void>;
-    function pipeline(
-        ...streams: [PipelineSource<any>, ...PipelineTransform<any, any>[], PipelineDestination<any, any>]
-    ): Promise<void>;
-    function pipeline(
-        ...streams: [
-            PipelineSource<any>,
-            ...PipelineTransform<any, any>[],
-            PipelineDestination<any, any>,
-            options: PipelineOptions,
-        ]
-    ): Promise<void>;
-}
-declare module "stream/promises" {
-    export * from "node:stream/promises";
-}

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

@@ -1,320 +0,0 @@
-declare module "node:stream/web" {
-    import { TextDecoderCommon, TextDecoderOptions, TextEncoderCommon } from "node:util";
-    type CompressionFormat = "brotli" | "deflate" | "deflate-raw" | "gzip";
-    type ReadableStreamController<T> = ReadableStreamDefaultController<T> | ReadableByteStreamController;
-    type ReadableStreamReader<T> = ReadableStreamDefaultReader<T> | ReadableStreamBYOBReader;
-    type ReadableStreamReaderMode = "byob";
-    type ReadableStreamReadResult<T> = ReadableStreamReadValueResult<T> | ReadableStreamReadDoneResult<T>;
-    type ReadableStreamType = "bytes";
-    interface GenericTransformStream {
-        readonly readable: ReadableStream;
-        readonly writable: WritableStream;
-    }
-    interface QueuingStrategy<T = any> {
-        highWaterMark?: number;
-        size?: QueuingStrategySize<T>;
-    }
-    interface QueuingStrategyInit {
-        highWaterMark: number;
-    }
-    interface QueuingStrategySize<T = any> {
-        (chunk: T): number;
-    }
-    interface ReadableStreamBYOBReaderReadOptions {
-        min?: number;
-    }
-    interface ReadableStreamGenericReader {
-        readonly closed: Promise<void>;
-        cancel(reason?: any): Promise<void>;
-    }
-    interface ReadableStreamGetReaderOptions {
-        mode?: ReadableStreamReaderMode;
-    }
-    interface ReadableStreamIteratorOptions {
-        preventCancel?: boolean;
-    }
-    interface ReadableStreamReadDoneResult<T> {
-        done: true;
-        value: T | undefined;
-    }
-    interface ReadableStreamReadValueResult<T> {
-        done: false;
-        value: T;
-    }
-    interface ReadableWritablePair<R = any, W = any> {
-        readable: ReadableStream<R>;
-        writable: WritableStream<W>;
-    }
-    interface StreamPipeOptions {
-        preventAbort?: boolean;
-        preventCancel?: boolean;
-        preventClose?: boolean;
-        signal?: AbortSignal;
-    }
-    interface Transformer<I = any, O = any> {
-        cancel?: TransformerCancelCallback;
-        flush?: TransformerFlushCallback<O>;
-        readableType?: undefined;
-        start?: TransformerStartCallback<O>;
-        transform?: TransformerTransformCallback<I, O>;
-        writableType?: undefined;
-    }
-    interface TransformerCancelCallback {
-        (reason: any): void | PromiseLike<void>;
-    }
-    interface TransformerFlushCallback<O> {
-        (controller: TransformStreamDefaultController<O>): void | PromiseLike<void>;
-    }
-    interface TransformerStartCallback<O> {
-        (controller: TransformStreamDefaultController<O>): any;
-    }
-    interface TransformerTransformCallback<I, O> {
-        (chunk: I, controller: TransformStreamDefaultController<O>): void | PromiseLike<void>;
-    }
-    interface UnderlyingByteSource {
-        autoAllocateChunkSize?: number;
-        cancel?: UnderlyingSourceCancelCallback;
-        pull?: (controller: ReadableByteStreamController) => void | PromiseLike<void>;
-        start?: (controller: ReadableByteStreamController) => any;
-        type: "bytes";
-    }
-    interface UnderlyingDefaultSource<R = any> {
-        cancel?: UnderlyingSourceCancelCallback;
-        pull?: (controller: ReadableStreamDefaultController<R>) => void | PromiseLike<void>;
-        start?: (controller: ReadableStreamDefaultController<R>) => any;
-        type?: undefined;
-    }
-    interface UnderlyingSink<W = any> {
-        abort?: UnderlyingSinkAbortCallback;
-        close?: UnderlyingSinkCloseCallback;
-        start?: UnderlyingSinkStartCallback;
-        type?: undefined;
-        write?: UnderlyingSinkWriteCallback<W>;
-    }
-    interface UnderlyingSinkAbortCallback {
-        (reason?: any): void | PromiseLike<void>;
-    }
-    interface UnderlyingSinkCloseCallback {
-        (): void | PromiseLike<void>;
-    }
-    interface UnderlyingSinkStartCallback {
-        (controller: WritableStreamDefaultController): any;
-    }
-    interface UnderlyingSinkWriteCallback<W> {
-        (chunk: W, controller: WritableStreamDefaultController): void | PromiseLike<void>;
-    }
-    interface UnderlyingSource<R = any> {
-        autoAllocateChunkSize?: number;
-        cancel?: UnderlyingSourceCancelCallback;
-        pull?: UnderlyingSourcePullCallback<R>;
-        start?: UnderlyingSourceStartCallback<R>;
-        type?: ReadableStreamType;
-    }
-    interface UnderlyingSourceCancelCallback {
-        (reason?: any): void | PromiseLike<void>;
-    }
-    interface UnderlyingSourcePullCallback<R> {
-        (controller: ReadableStreamController<R>): void | PromiseLike<void>;
-    }
-    interface UnderlyingSourceStartCallback<R> {
-        (controller: ReadableStreamController<R>): any;
-    }
-    interface ByteLengthQueuingStrategy extends QueuingStrategy<NodeJS.ArrayBufferView> {
-        readonly highWaterMark: number;
-        readonly size: QueuingStrategySize<NodeJS.ArrayBufferView>;
-    }
-    var ByteLengthQueuingStrategy: {
-        prototype: ByteLengthQueuingStrategy;
-        new(init: QueuingStrategyInit): ByteLengthQueuingStrategy;
-    };
-    interface CompressionStream extends GenericTransformStream {
-        readonly readable: ReadableStream<NodeJS.NonSharedUint8Array>;
-        readonly writable: WritableStream<NodeJS.BufferSource>;
-    }
-    var CompressionStream: {
-        prototype: CompressionStream;
-        new(format: CompressionFormat): CompressionStream;
-    };
-    interface CountQueuingStrategy extends QueuingStrategy {
-        readonly highWaterMark: number;
-        readonly size: QueuingStrategySize;
-    }
-    var CountQueuingStrategy: {
-        prototype: CountQueuingStrategy;
-        new(init: QueuingStrategyInit): CountQueuingStrategy;
-    };
-    interface DecompressionStream extends GenericTransformStream {
-        readonly readable: ReadableStream<NodeJS.NonSharedUint8Array>;
-        readonly writable: WritableStream<NodeJS.BufferSource>;
-    }
-    var DecompressionStream: {
-        prototype: DecompressionStream;
-        new(format: CompressionFormat): DecompressionStream;
-    };
-    interface ReadableByteStreamController {
-        readonly byobRequest: ReadableStreamBYOBRequest | null;
-        readonly desiredSize: number | null;
-        close(): void;
-        enqueue(chunk: NodeJS.NonSharedArrayBufferView): void;
-        error(e?: any): void;
-    }
-    var ReadableByteStreamController: {
-        prototype: ReadableByteStreamController;
-        new(): ReadableByteStreamController;
-    };
-    interface ReadableStream<R = any> {
-        readonly locked: boolean;
-        cancel(reason?: any): Promise<void>;
-        getReader(options: { mode: "byob" }): ReadableStreamBYOBReader;
-        getReader(): ReadableStreamDefaultReader<R>;
-        getReader(options?: ReadableStreamGetReaderOptions): ReadableStreamReader<R>;
-        pipeThrough<T>(transform: ReadableWritablePair<T, R>, options?: StreamPipeOptions): ReadableStream<T>;
-        pipeTo(destination: WritableStream<R>, options?: StreamPipeOptions): Promise<void>;
-        tee(): [ReadableStream<R>, ReadableStream<R>];
-        [Symbol.asyncIterator](options?: ReadableStreamIteratorOptions): ReadableStreamAsyncIterator<R>;
-        values(options?: ReadableStreamIteratorOptions): ReadableStreamAsyncIterator<R>;
-    }
-    var ReadableStream: {
-        prototype: ReadableStream;
-        new(
-            underlyingSource: UnderlyingByteSource,
-            strategy?: { highWaterMark?: number },
-        ): ReadableStream<NodeJS.NonSharedUint8Array>;
-        new<R = any>(underlyingSource: UnderlyingDefaultSource<R>, strategy?: QueuingStrategy<R>): ReadableStream<R>;
-        new<R = any>(underlyingSource?: UnderlyingSource<R>, strategy?: QueuingStrategy<R>): ReadableStream<R>;
-        from<R = any>(iterable: Iterable<R> | AsyncIterable<R>): ReadableStream<R>;
-    };
-    interface ReadableStreamAsyncIterator<T> extends NodeJS.AsyncIterator<T, BuiltinIteratorReturn, unknown> {
-        [Symbol.asyncIterator](): ReadableStreamAsyncIterator<T>;
-    }
-    interface ReadableStreamBYOBReader extends ReadableStreamGenericReader {
-        read<T extends NodeJS.NonSharedArrayBufferView>(
-            view: T,
-            options?: ReadableStreamBYOBReaderReadOptions,
-        ): Promise<ReadableStreamReadResult<T>>;
-        releaseLock(): void;
-    }
-    var ReadableStreamBYOBReader: {
-        prototype: ReadableStreamBYOBReader;
-        new(stream: ReadableStream<NodeJS.NonSharedUint8Array>): ReadableStreamBYOBReader;
-    };
-    interface ReadableStreamBYOBRequest {
-        readonly view: NodeJS.NonSharedArrayBufferView | null;
-        respond(bytesWritten: number): void;
-        respondWithNewView(view: NodeJS.NonSharedArrayBufferView): void;
-    }
-    var ReadableStreamBYOBRequest: {
-        prototype: ReadableStreamBYOBRequest;
-        new(): ReadableStreamBYOBRequest;
-    };
-    interface ReadableStreamDefaultController<R = any> {
-        readonly desiredSize: number | null;
-        close(): void;
-        enqueue(chunk: R): void;
-        error(e?: any): void;
-    }
-    var ReadableStreamDefaultController: {
-        prototype: ReadableStreamDefaultController;
-        new(): ReadableStreamDefaultController;
-    };
-    interface ReadableStreamDefaultReader<R = any> extends ReadableStreamGenericReader {
-        read(): Promise<ReadableStreamReadResult<R>>;
-        releaseLock(): void;
-    }
-    var ReadableStreamDefaultReader: {
-        prototype: ReadableStreamDefaultReader;
-        new<R = any>(stream: ReadableStream<R>): ReadableStreamDefaultReader<R>;
-    };
-    interface TextDecoderStream extends GenericTransformStream, TextDecoderCommon {
-        readonly readable: ReadableStream<string>;
-        readonly writable: WritableStream<NodeJS.BufferSource>;
-    }
-    var TextDecoderStream: {
-        prototype: TextDecoderStream;
-        new(label?: string, options?: TextDecoderOptions): TextDecoderStream;
-    };
-    interface TextEncoderStream extends GenericTransformStream, TextEncoderCommon {
-        readonly readable: ReadableStream<NodeJS.NonSharedUint8Array>;
-        readonly writable: WritableStream<string>;
-    }
-    var TextEncoderStream: {
-        prototype: TextEncoderStream;
-        new(): TextEncoderStream;
-    };
-    interface TransformStream<I = any, O = any> {
-        readonly readable: ReadableStream<O>;
-        readonly writable: WritableStream<I>;
-    }
-    var TransformStream: {
-        prototype: TransformStream;
-        new<I = any, O = any>(
-            transformer?: Transformer<I, O>,
-            writableStrategy?: QueuingStrategy<I>,
-            readableStrategy?: QueuingStrategy<O>,
-        ): TransformStream<I, O>;
-    };
-    interface TransformStreamDefaultController<O = any> {
-        readonly desiredSize: number | null;
-        enqueue(chunk: O): void;
-        error(reason?: any): void;
-        terminate(): void;
-    }
-    var TransformStreamDefaultController: {
-        prototype: TransformStreamDefaultController;
-        new(): TransformStreamDefaultController;
-    };
-    interface WritableStream<W = any> {
-        readonly locked: boolean;
-        abort(reason?: any): Promise<void>;
-        close(): Promise<void>;
-        getWriter(): WritableStreamDefaultWriter<W>;
-    }
-    var WritableStream: {
-        prototype: WritableStream;
-        new<W = any>(underlyingSink?: UnderlyingSink<W>, strategy?: QueuingStrategy<W>): WritableStream<W>;
-    };
-    interface WritableStreamDefaultController {
-        readonly signal: AbortSignal;
-        error(e?: any): void;
-    }
-    var WritableStreamDefaultController: {
-        prototype: WritableStreamDefaultController;
-        new(): WritableStreamDefaultController;
-    };
-    interface WritableStreamDefaultWriter<W = any> {
-        readonly closed: Promise<void>;
-        readonly desiredSize: number | null;
-        readonly ready: Promise<void>;
-        abort(reason?: any): Promise<void>;
-        close(): Promise<void>;
-        releaseLock(): void;
-        write(chunk: W): Promise<void>;
-    }
-    var WritableStreamDefaultWriter: {
-        prototype: WritableStreamDefaultWriter;
-        new<W = any>(stream: WritableStream<W>): WritableStreamDefaultWriter<W>;
-    };
-    // Node.js extensions
-    /**
-     * Runs the WHATWG `ReadableStreamTee` abstract operation on `stream`.
-     *
-     * This differs from `readableStream.tee()` only when `cloneForBranch2` is
-     * `true`. The `tee()` method always passes `false`, while other web platform
-     * specifications, such as Fetch body cloning, pass `true` so that the second
-     * branch receives cloned chunks and consumption of one branch cannot mutate chunks
-     * seen by the other.
-     * @since v26.5.0
-     * @experimental
-     * @param cloneForBranch2 When `true`, chunks enqueued into the second
-     * branch are cloned from chunks enqueued into the first branch. **Default:**
-     * `false`.
-     * @returns Two `ReadableStream` branches.
-     */
-    function ReadableStreamTee<R>(
-        stream: ReadableStream<R>,
-        cloneForBranch2?: boolean,
-    ): [ReadableStream<R>, ReadableStream<R>];
-}
-declare module "stream/web" {
-    export * from "node:stream/web";
-}