@types/readable-stream

constructor(options?: DuplexOptions);

allowHalfOpen: boolean;

destroyed: boolean;

readable: boolean;

readonly readableAborted: never;

readonly readableDidRead: never;

readonly readableEncoding: any;

readonly readableEnded: boolean;

readonly readableFlowing: boolean;

readonly readableHighWaterMark: number;

readonly readableLength: number;

readonly readableObjectMode: boolean;

readonly writableCorked: never;

readonly writableEnded: never;

readonly writableFinished: never;

readonly writableObjectMode: boolean;

[Symbol.asyncIterator]: () => AsyncIterableIterator<any>;

addListener: (ev: string | symbol, fn: (...args: any[]) => void) => this;

asIndexedPairs: (options?: SignalOption) => Readable;

destroy: (err?: Error, callback?: (error: Error | null) => void) => this;

drop: (limit: number, options?: SignalOption) => Readable;

every: (
    fn: (data: any, options?: SignalOption) => boolean | Promise<boolean>,
    options?: ArrayOptions
) => Promise<boolean>;

filter: (
    fn: (data: any, options?: SignalOption) => boolean | Promise<boolean>,
    options?: ArrayOptions
) => Readable;

find: {
    <T>(
        fn: (data: any, options?: SignalOption) => data is T,
        options?: ArrayOptions
    ): Promise<T | undefined>;
    (
        fn: (data: any, options?: SignalOption) => boolean | Promise<boolean>,
        options?: ArrayOptions
    ): Promise<any>;
};

flatMap: (
    fn: (data: any, options?: SignalOption) => any,
    options?: ArrayOptions
) => Readable;

forEach: (
    fn: (data: any, options?: SignalOption) => void | Promise<void>,
    options?: ArrayOptions
) => Promise<void>;

static from: (source: any) => any;

isPaused: () => boolean;

iterator: (options?: {
    destroyOnReturn?: boolean;
}) => AsyncIterableIterator<any>;

map: (
    fn: (data: any, options?: SignalOption) => any,
    options?: ArrayOptions
) => Readable;

on: (ev: string | symbol, fn: (...args: any[]) => void) => this;

pause: () => this;

pipe: <S extends _IWritable>(
    dest: S,
    pipeOpts?: { end?: boolean | undefined }
) => S;

push: (chunk: any, encoding?: BufferEncoding) => boolean;

read: (size?: number) => any;

reduce: {
    <T = any>(
        fn: (
            previous: any,
            data: any,
            options?: Pick<ArrayOptions, 'signal'>
        ) => T,
        initial?: undefined,
        options?: Pick<ArrayOptions, 'signal'>
    ): Promise<T>;
    <T = any>(
        fn: (
            previous: T,
            data: any,
            options?: Pick<ArrayOptions, 'signal'>
        ) => T,
        initial: T,
        options?: Pick<ArrayOptions, 'signal'>
    ): Promise<T>;
};

resume: () => this;

setEncoding: (enc: BufferEncoding) => this;

some: (
    fn: (data: any, options?: SignalOption) => boolean | Promise<boolean>,
    options?: ArrayOptions
) => Promise<boolean>;

take: (limit: number, options?: SignalOption) => Readable;

toArray: (options?: SignalOption) => Promise<any[]>;

unpipe: (dest?: Writable) => this;

unshift: (chunk: any) => boolean;

wrap: (oldStream: Readable) => this;

constructor(options?: TransformOptions);

constructor(options?: ReadableOptions);

readonly readableAborted: never;

readonly readableDidRead: never;

readonly readableEncoding: never;

readonly readableEnded: never;

readonly readableObjectMode: never;

compose: <T extends NodeJS.ReadableStream>(
    stream: T | ComposeFnParam | Iterable<T> | AsyncIterable<T>,
    options?: { signal: AbortSignal }
) => T;

pipe: <T extends _IWritable>(
    destination: T,
    options?: { end?: boolean | undefined }
) => T;

constructor(options?: ReadableOptions);

compose: <T extends NodeJS.ReadableStream>(
    stream: T | ComposeFnParam | Iterable<T> | AsyncIterable<T>,
    options?: { signal: AbortSignal }
) => T;

pipe: <T extends _IWritable>(
    destination: T,
    options?: { end?: boolean | undefined }
) => T;

constructor(options?: TransformOptions);

constructor(opts?: WritableOptions);

readonly writableCorked: never;

readonly writableEnded: never;

readonly writableFinished: never;

readonly writableObjectMode: never;

head: Entry<D>;

length: number;

tail: Entry<D>;

clear: () => void;

concat: (n: number) => D;

join: (s: any) => string;

push: (v: D) => void;

shift: () => D;

unshift: (v: D) => void;

callback: (error?: Error | null) => void;

chunk: any;

encoding: BufferEncoding;

isBuf: boolean;

next: BufferRequest | null;

entry: any;

next: any;

finish: () => void;

destroy: (
    this: Readable | Writable,
    error: Error | null,
    callback?: (error: Error | null) => void
) => Readable | Writable;

undestroy: (this: Readable | Writable) => void;

data: D;

next: Entry<D> | null;

awaitDrain: number;

buffer: BufferList<any>;

decoder: StringDecoder | null;

defaultEncoding: BufferEncoding;

destroyed: boolean;

emittedReadable: boolean;

encoding: BufferEncoding | null;

ended: boolean;

endEmitted: boolean;

flowing: any;

highWaterMark: number;

length: number;

needReadable: boolean;

objectMode: boolean;

pipes: any;

pipesCount: number;

readableListening: boolean;

reading: boolean;

readingMore: boolean;

resumeScheduled: boolean;

sync: boolean;

defaultEncoding?: BufferEncoding | undefined;

encoding?: BufferEncoding | undefined;

highWaterMark?: number | undefined;

objectMode?: boolean | undefined;

readableHighWaterMark?: number | undefined;

readableObjectMode?: boolean | undefined;

buffer: BufferRequest[];

bufferedRequest: BufferRequest | null;

bufferedRequestCount: number;

bufferProcessing: boolean;

corked: number;

corkedRequestsFree: CorkedRequest;

decodeStrings: boolean;

defaultEncoding: BufferEncoding;

destroyed: boolean;

ended: boolean;

ending: boolean;

errorEmitted: boolean;

finalCalled: boolean;

finished: boolean;

highWaterMark: number;

lastBufferedRequest: BufferRequest | null;

length: number;

needDrain: boolean;

objectMode: boolean;

onwrite: (er?: Error | null) => any;

pendingcb: number;

prefinished: boolean;

sync: boolean;

writecb: ((err?: Error | null) => void) | null;

writelen: number;

writing: boolean;

getBuffer: () => BufferRequest[];

decodeStrings?: boolean | undefined;

defaultEncoding?: BufferEncoding | undefined;

highWaterMark?: number | undefined;

objectMode?: boolean | undefined;

writableHighWaterMark?: number | undefined;

writableObjectMode?: boolean | undefined;