@types/readable-stream

Version 4.0.23
Published 1 month ago
32 kB
1 dependency
MIT license

Install

npm i @types/readable-stream

yarn add @types/readable-stream

pnpm add @types/readable-stream

Overview

TypeScript definitions for readable-stream

Index

Variables

variable finished

const finished: any;

variable NoAsyncDispose

var NoAsyncDispose: new (...arguments: any[]) => {};

variable pipeline

const pipeline: any;

Classes

class Duplex

class Duplex extends _Writable implements _IDuplex, /*extends*/ _Readable, Duplex {}

constructor

constructor(options?: DuplexOptions);

property allowHalfOpen

allowHalfOpen: boolean;

property destroyed

destroyed: boolean;

property readable

readable: boolean;

property readableAborted

readonly readableAborted: boolean;

property readableDidRead

readonly readableDidRead: boolean;

property readableEncoding

readonly readableEncoding: any;

property readableEnded

readonly readableEnded: boolean;

property readableFlowing

readonly readableFlowing: boolean;

property readableHighWaterMark

readonly readableHighWaterMark: number;

property readableLength

readonly readableLength: number;

property readableObjectMode

readonly readableObjectMode: boolean;

property writableAborted

readonly writableAborted: boolean;

property writableCorked

readonly writableCorked: number;

property writableEnded

readonly writableEnded: boolean;

property writableFinished

readonly writableFinished: boolean;

property writableObjectMode

readonly writableObjectMode: boolean;

method [Symbol.asyncIterator]

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

method addListener

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

method asIndexedPairs

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

method destroy

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

method drop

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

method every

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

method filter

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

method find

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>;
};

method flatMap

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

method forEach

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

method from

static from: (
    src:
        | string
        | Stream
        | Blob
        | ArrayBuffer
        | Iterable<any>
        | AsyncIterable<any>
        | AsyncGeneratorFunction
        | Promise<any>
        | { writable?: Writable; readable?: _Readable }
) => Duplex;

method isPaused

isPaused: () => boolean;

method iterator

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

method map

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

method on

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

method pause

pause: () => this;

method pipe

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

method push

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

method read

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

method reduce

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>;
};

method resume

resume: () => this;

method setEncoding

setEncoding: (enc: BufferEncoding) => this;

method some

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

method take

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

method toArray

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

method unpipe

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

method unshift

unshift: (chunk: any) => boolean;

method wrap

wrap: (oldStream: Readable) => this;

class PassThrough

class PassThrough extends Transform {}

constructor

constructor(options?: TransformOptions);

class Readable

class Readable extends _Readable implements NodeJS.ReadableStream {}

constructor

constructor(options?: ReadableOptions);

property readableAborted

readonly readableAborted: boolean;

property readableDidRead

readonly readableDidRead: boolean;

property readableEncoding

readonly readableEncoding: any;

property readableEnded

readonly readableEnded: boolean;

property readableObjectMode

readonly readableObjectMode: boolean;

method pipe

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

class Stream

class Stream extends _Readable {}

constructor

constructor(options?: ReadableOptions);

method pipe

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

class Transform

class Transform extends Duplex {}

constructor

constructor(options?: TransformOptions);

class Writable

class Writable extends _Writable {}

constructor

constructor(opts?: WritableOptions);

property writableAborted

readonly writableAborted: boolean;

property writableCorked

readonly writableCorked: number;

property writableEnded

readonly writableEnded: boolean;

property writableFinished

readonly writableFinished: boolean;

property writableObjectMode

readonly writableObjectMode: boolean;

Interfaces

interface BufferList

interface BufferList<D extends Buffer = Buffer> {}

property head

head: Entry<D>;

property length

length: number;

property tail

tail: Entry<D>;

method clear

clear: () => void;

method concat

concat: (n: number) => D;

method join

join: (s: any) => string;

method push

push: (v: D) => void;

method shift

shift: () => D;

method unshift

unshift: (v: D) => void;

interface BufferRequest

interface BufferRequest {}

property callback

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

property chunk

chunk: any;

property encoding

encoding: BufferEncoding;

property isBuf

isBuf: boolean;

property next

next: BufferRequest | null;

interface CorkedRequest

interface CorkedRequest {}

property entry

entry: any;

property next

next: any;

method finish

finish: () => void;

interface Destroy

interface Destroy {}

method destroy

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

method undestroy

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

interface Entry

interface Entry<D> {}

property data

data: D;

property next

next: Entry<D> | null;

interface ReadableState

interface ReadableState {}

property awaitDrain

awaitDrain: number;

property buffer

buffer: BufferList<any>;

property decoder

decoder: StringDecoder | null;

property defaultEncoding

defaultEncoding: BufferEncoding;

property destroyed

destroyed: boolean;

property emittedReadable

emittedReadable: boolean;

property encoding

encoding: BufferEncoding | null;

property ended

ended: boolean;

property endEmitted

endEmitted: boolean;

property flowing

flowing: any;

property highWaterMark

highWaterMark: number;

property length

length: number;

property needReadable

needReadable: boolean;

property objectMode

objectMode: boolean;

property pipes

pipes: any;

property pipesCount

pipesCount: number;

property readableListening

readableListening: boolean;

property reading

reading: boolean;

property readingMore

readingMore: boolean;

property resumeScheduled

resumeScheduled: boolean;

property sync

sync: boolean;

interface ReadableStateOptions

interface ReadableStateOptions {}

property defaultEncoding

defaultEncoding?: BufferEncoding | undefined;

property encoding

encoding?: BufferEncoding | undefined;

property highWaterMark

highWaterMark?: number | undefined;

property objectMode

objectMode?: boolean | undefined;

property readableHighWaterMark

readableHighWaterMark?: number | undefined;

property readableObjectMode

readableObjectMode?: boolean | undefined;

interface WritableState

interface WritableState {}

property buffer

buffer: BufferRequest[];

property bufferedRequest

bufferedRequest: BufferRequest | null;

property bufferedRequestCount

bufferedRequestCount: number;

property bufferProcessing

bufferProcessing: boolean;

property corked

corked: number;

property corkedRequestsFree

corkedRequestsFree: CorkedRequest;

property decodeStrings

decodeStrings: boolean;

property defaultEncoding

defaultEncoding: BufferEncoding;

property destroyed

destroyed: boolean;

property ended

ended: boolean;

property ending

ending: boolean;

property errorEmitted

errorEmitted: boolean;

property finalCalled

finalCalled: boolean;

property finished

finished: boolean;

property highWaterMark

highWaterMark: number;

property lastBufferedRequest

lastBufferedRequest: BufferRequest | null;

property length

length: number;

property needDrain

needDrain: boolean;

property objectMode

objectMode: boolean;

property onwrite

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

property pendingcb

pendingcb: number;

property prefinished

prefinished: boolean;

property sync

sync: boolean;

property writecb

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

property writelen

writelen: number;

property writing

writing: boolean;

method getBuffer

getBuffer: () => BufferRequest[];

interface WritableStateOptions

interface WritableStateOptions {}

property decodeStrings

decodeStrings?: boolean | undefined;

property defaultEncoding

defaultEncoding?: BufferEncoding | undefined;

property highWaterMark

highWaterMark?: number | undefined;

property objectMode

objectMode?: boolean | undefined;

property writableHighWaterMark

writableHighWaterMark?: number | undefined;

property writableObjectMode

writableObjectMode?: boolean | undefined;

Type Aliases

type DuplexOptions

type DuplexOptions = ReadableOptions &
    WritableOptions & {
        allowHalfOpen?: boolean | undefined;
        readable?: boolean | undefined;
        writable?: boolean | undefined;
        read?(this: Duplex, size: number): void;
        write?(
            this: Duplex,
            chunk: any,
            encoding: BufferEncoding,
            callback: (error?: Error | null) => void
        ): void;
        writev?(
            this: Duplex,
            chunks: Array<{ chunk: any; encoding: BufferEncoding }>,
            callback: (error?: Error | null) => void
        ): void;
        final?(this: Duplex, callback: (error?: Error | null) => void): void;
        destroy?(
            this: Duplex,
            error: Error | null,
            callback: (error: Error | null) => void
        ): void;
    };

type ReadableOptions

type ReadableOptions = ReadableStateOptions & {
    read?(this: _IReadable, size: number): void;
    destroy?(
        this: _IReadable,
        error: Error | null,
        callback: (error: Error | null) => void
    ): void;
};

type TransformOptions

type TransformOptions = ReadableOptions &
    WritableOptions & {
        read?(this: _ITransform, size: number): void;
        write?(
            this: _ITransform,
            chunk: any,
            encoding: BufferEncoding,
            callback: (error?: Error | null) => void
        ): void;
        writev?(
            this: _ITransform,
            chunks: Array<{ chunk: any; encoding: BufferEncoding }>,
            callback: (error?: Error | null) => void
        ): void;
        final?(this: _ITransform, callback: (error?: Error | null) => void): void;
        destroy?(
            this: _ITransform,
            error: Error | null,
            callback: (error: Error | null) => void
        ): void;
        transform?(
            this: _ITransform,
            chunk: any,
            encoding: BufferEncoding,
            callback: (error?: Error | null, data?: any) => void
        ): void;
        flush?(callback: (error?: Error | null, data?: any) => void): void;
    };

type WritableOptions

type WritableOptions = WritableStateOptions & {
    write?(
        this: _IWritable,
        chunk: any,
        encoding: BufferEncoding | string,
        callback: (error?: Error | null) => void
    ): void;
    writev?(
        this: _IWritable,
        chunk: ArrayLike<{ chunk: any; encoding: BufferEncoding | string }>,
        callback: (error?: Error | null) => void
    ): void;
    destroy?(
        this: _IWritable,
        error: Error | null,
        callback: (error?: Error | null) => void
    ): void;
    final?(this: _IWritable, callback: (error?: Error | null) => void): void;
};

Namespaces

namespace global

namespace global {}

interface AsyncIteratorObject

interface AsyncIteratorObject<T, TReturn, TNext> {}

Package Files (1)

index.d.ts

Dependencies (1)

@types/node

Dev Dependencies (0)

No dev dependencies.

Peer Dependencies (0)

No peer dependencies.

Badge

To add a badge like this oneto your package's README, use the codes available below.

You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/@types/readable-stream.

Markdown

[![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/@types/readable-stream)

HTML

<a href="https://www.jsdocs.io/package/@types/readable-stream"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>

Updated 1 month ago.
Package analyzed in 6153 ms.
Missing or incorrect documentation? Open an issue for this package.