@types/readable-stream

Version 2.3.11
Published 1 month ago
20.7 kB
2 dependencies
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

Interfaces

BufferList
BufferRequest
CorkedRequest
Destroy
- destroy()
- undestroy()
Entry
- data
- next
ReadableState
ReadableStateOptions
WritableState
WritableStateOptions

Classes

class Duplex

class Duplex extends Writable implements /*extends*/ _Readable, Duplex {}

constructor

constructor(options?: DuplexOptions);

property allowHalfOpen

allowHalfOpen: boolean;

property destroyed

destroyed: boolean;

property readable

readable: 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 writableObjectMode

readonly writableObjectMode: boolean;

method [Symbol.asyncIterator]

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

method addListener

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

method destroy

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

method from

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

This is a dummy function required to retain type compatibility to node.
Deprecated
DO NOT USE

method isPaused

isPaused: () => boolean;

method on

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

method pause

pause: () => this;

method pipe

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

method push

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

method read

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

method resume

resume: () => this;

method setEncoding

setEncoding: (enc: any) => this;

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

constructor

constructor(options?: ReadableOptions);

class Stream

class Stream extends _Readable {}

constructor

constructor(options?: ReadableOptions);

method pipe

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

class Transform

class Transform extends Duplex {}

constructor

constructor(options?: TransformOptions);

class Writable

class Writable extends Stream {}

constructor

constructor(opts?: WritableOptions);

property destroyed

destroyed: boolean;

property writable

writable: boolean;

property writableHighWaterMark

readonly writableHighWaterMark: number;

property writableLength

readonly writableLength: number;

method addListener

addListener: {
    (event: 'close', listener: () => void): this;
    (event: 'drain', listener: () => void): this;
    (event: 'error', listener: (err: Error) => void): this;
    (event: 'finish', listener: () => void): this;
    (event: 'pipe', listener: (src: Readable) => void): this;
    (event: 'unpipe', listener: (src: Readable) => void): this;
    (event: string | symbol, listener: (...args: any[]) => void): this;
};

Event emitter The defined events on documents including: 1. close 2. drain 3. error 4. finish 5. pipe 6. unpipe

method cork

cork: () => void;

method destroy

destroy: (error?: Error) => void;

method emit

emit: {
    (event: 'close'): boolean;
    (event: 'drain'): boolean;
    (event: 'error', err: Error): boolean;
    (event: 'finish'): boolean;
    (event: 'pipe', src: Readable): boolean;
    (event: 'unpipe', src: Readable): boolean;
    (event: string | symbol, ...args: any[]): boolean;
};

method end

end: {
    (cb?: () => void): void;
    (chunk: any, cb?: () => void): void;
    (chunk: any, encoding?: string, cb?: () => void): void;
};

method on

on: {
    (event: 'close', listener: () => void): this;
    (event: 'drain', listener: () => void): this;
    (event: 'error', listener: (err: Error) => void): this;
    (event: 'finish', listener: () => void): this;
    (event: 'pipe', listener: (src: Readable) => void): this;
    (event: 'unpipe', listener: (src: Readable) => void): this;
    (event: string | symbol, listener: (...args: any[]) => void): this;
};

method once

once: {
    (event: 'close', listener: () => void): this;
    (event: 'drain', listener: () => void): this;
    (event: 'error', listener: (err: Error) => void): this;
    (event: 'finish', listener: () => void): this;
    (event: 'pipe', listener: (src: Readable) => void): this;
    (event: 'unpipe', listener: (src: Readable) => void): this;
    (event: string | symbol, listener: (...args: any[]) => void): this;
};

method prependListener

prependListener: {
    (event: 'close', listener: () => void): this;
    (event: 'drain', listener: () => void): this;
    (event: 'error', listener: (err: Error) => void): this;
    (event: 'finish', listener: () => void): this;
    (event: 'pipe', listener: (src: Readable) => void): this;
    (event: 'unpipe', listener: (src: Readable) => void): this;
    (event: string | symbol, listener: (...args: any[]) => void): this;
};

method prependOnceListener

prependOnceListener: {
    (event: 'close', listener: () => void): this;
    (event: 'drain', listener: () => void): this;
    (event: 'error', listener: (err: Error) => void): this;
    (event: 'finish', listener: () => void): this;
    (event: 'pipe', listener: (src: Readable) => void): this;
    (event: 'unpipe', listener: (src: Readable) => void): this;
    (event: string | symbol, listener: (...args: any[]) => void): this;
};

method removeListener

removeListener: {
    (event: 'close', listener: () => void): this;
    (event: 'drain', listener: () => void): this;
    (event: 'error', listener: (err: Error) => void): this;
    (event: 'finish', listener: () => void): this;
    (event: 'pipe', listener: (src: Readable) => void): this;
    (event: 'unpipe', listener: (src: Readable) => void): this;
    (event: string | symbol, listener: (...args: any[]) => void): this;
};

method setDefaultEncoding

setDefaultEncoding: (encoding: string) => this;

method uncork

uncork: () => void;

method write

write: {
    (chunk: any, cb?: (error: Error | null | undefined) => void): boolean;
    (chunk: any, encoding?: string, cb?: (error: Error) => void): boolean;
};

Interfaces

interface BufferList

interface BufferList<D extends SafeBuffer.Buffer = SafeBuffer.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: _Readable, size: number): void;
    destroy?(
        this: _Readable,
        error: Error | null,
        callback: (error: Error | null) => void
    ): void;
};

type TransformOptions

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

type WritableOptions

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

Package Files (1)

index.d.ts

Dependencies (2)

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 6717 ms.
Missing or incorrect documentation? Open an issue for this package.

@types/readable-stream

Install

Overview

Index

Classes

Interfaces

Type Aliases

Classes

class Duplex

constructor

property allowHalfOpen

property destroyed

property readable

property readableEncoding

property readableEnded

property readableFlowing

property readableHighWaterMark

property readableLength

property readableObjectMode

property writableObjectMode

method [Symbol.asyncIterator]

method addListener

method destroy

method from

Deprecated

method isPaused

method on

method pause

method pipe

method push

method read

method resume

method setEncoding

method unpipe

method unshift

method wrap

class PassThrough

constructor

class Readable

constructor

class Stream

constructor

method pipe

class Transform

constructor

class Writable

constructor

property destroyed

property writable

property writableHighWaterMark

property writableLength

method addListener

method cork

method destroy

method emit

method end

method on

method once

method prependListener

method prependOnceListener

method removeListener

method setDefaultEncoding

method uncork

method write

Interfaces

interface BufferList

property head

property length

property tail

method clear

method concat

method join

method push

method shift

method unshift

interface BufferRequest

property callback

property chunk

property encoding

property isBuf