@types/readable-stream

  • Version 2.3.13
  • Published
  • 24.4 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

Classes

Interfaces

Type Aliases

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: never;

              property readableDidRead

              readonly readableDidRead: never;

                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 writableCorked

                            readonly writableCorked: never;

                              property writableEnded

                              readonly writableEnded: never;

                                property writableFinished

                                readonly writableFinished: never;

                                  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 _IWritable>(
                                                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);

                                                                        property readableAborted

                                                                        readonly readableAborted: never;

                                                                          property readableDidRead

                                                                          readonly readableDidRead: never;

                                                                            property readableEncoding

                                                                            readonly readableEncoding: never;

                                                                              property readableEnded

                                                                              readonly readableEnded: never;

                                                                                property readableObjectMode

                                                                                readonly readableObjectMode: never;

                                                                                  method pipe

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

                                                                                    class Stream

                                                                                    class Stream extends _Readable {}

                                                                                      constructor

                                                                                      constructor(options?: ReadableOptions);

                                                                                        method pipe

                                                                                        pipe: <T extends _IWritable>(
                                                                                        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 writableCorked

                                                                                                  readonly writableCorked: never;

                                                                                                    property writableEnded

                                                                                                    readonly writableEnded: never;

                                                                                                      property writableFinished

                                                                                                      readonly writableFinished: never;

                                                                                                        property writableObjectMode

                                                                                                        readonly writableObjectMode: never;

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

                                                                                                                                                                                                                                                                                                      Package Files (1)

                                                                                                                                                                                                                                                                                                      Dependencies (2)

                                                                                                                                                                                                                                                                                                      Dev Dependencies (0)

                                                                                                                                                                                                                                                                                                      No dev dependencies.

                                                                                                                                                                                                                                                                                                      Peer Dependencies (0)

                                                                                                                                                                                                                                                                                                      No peer dependencies.

                                                                                                                                                                                                                                                                                                      Badge

                                                                                                                                                                                                                                                                                                      To add a badge like this onejsDocs.io badgeto 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>