@types/readable-stream

  • Version 2.3.11
  • Published
  • 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

Classes

Interfaces

Type Aliases

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)

                                                                                                                                                                                                                                                                                                        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>