@types/readable-stream

  • Version 4.0.21
  • Published
  • 31.9 kB
  • 1 dependency
  • MIT license

Install

npm i @types/readable-stream
yarn add @types/readable-stream
pnpm add @types/readable-stream

Overview

TypeScript definitions for readable-stream

Index

Variables

Classes

Interfaces

Type Aliases

Namespaces

Variables

variable finished

const finished: any;

    variable NoAsyncDispose

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

      variable pipeline

      const pipeline: any;

        Classes

        class Duplex

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

          constructor

          constructor(options?: DuplexOptions);

            property allowHalfOpen

            allowHalfOpen: boolean;

              property destroyed

              destroyed: boolean;

                property readable

                readable: boolean;

                  property readableAborted

                  readonly readableAborted: boolean;

                    property readableDidRead

                    readonly readableDidRead: boolean;

                      property readableEncoding

                      readonly readableEncoding: any;

                        property readableEnded

                        readonly readableEnded: boolean;

                          property readableFlowing

                          readonly readableFlowing: boolean;

                            property readableHighWaterMark

                            readonly readableHighWaterMark: number;

                              property readableLength

                              readonly readableLength: number;

                                property readableObjectMode

                                readonly readableObjectMode: boolean;

                                  property writableAborted

                                  readonly writableAborted: boolean;

                                    property writableCorked

                                    readonly writableCorked: number;

                                      property writableEnded

                                      readonly writableEnded: boolean;

                                        property writableFinished

                                        readonly writableFinished: boolean;

                                          property writableObjectMode

                                          readonly writableObjectMode: boolean;

                                            method [Symbol.asyncIterator]

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

                                              method addListener

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

                                                method asIndexedPairs

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

                                                  method destroy

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

                                                    method drop

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

                                                      method every

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

                                                        method filter

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

                                                          method find

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

                                                            method flatMap

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

                                                              method forEach

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

                                                                method from

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

                                                                  method isPaused

                                                                  isPaused: () => boolean;

                                                                    method iterator

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

                                                                      method map

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

                                                                        method on

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

                                                                          method pause

                                                                          pause: () => this;

                                                                            method pipe

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

                                                                              method push

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

                                                                                method read

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

                                                                                  method reduce

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

                                                                                    method resume

                                                                                    resume: () => this;

                                                                                      method setEncoding

                                                                                      setEncoding: (enc: BufferEncoding) => this;

                                                                                        method some

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

                                                                                          method take

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

                                                                                            method toArray

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

                                                                                              method unpipe

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

                                                                                                method unshift

                                                                                                unshift: (chunk: any) => boolean;

                                                                                                  method wrap

                                                                                                  wrap: (oldStream: Readable) => this;

                                                                                                    class PassThrough

                                                                                                    class PassThrough extends Transform {}

                                                                                                      constructor

                                                                                                      constructor(options?: TransformOptions);

                                                                                                        class Readable

                                                                                                        class Readable extends _Readable implements NodeJS.ReadableStream {}

                                                                                                          constructor

                                                                                                          constructor(options?: ReadableOptions);

                                                                                                            property readableAborted

                                                                                                            readonly readableAborted: boolean;

                                                                                                              property readableDidRead

                                                                                                              readonly readableDidRead: boolean;

                                                                                                                property readableEncoding

                                                                                                                readonly readableEncoding: any;

                                                                                                                  property readableEnded

                                                                                                                  readonly readableEnded: boolean;

                                                                                                                    property readableObjectMode

                                                                                                                    readonly readableObjectMode: boolean;

                                                                                                                      method compose

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

                                                                                                                        method pipe

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

                                                                                                                          class Stream

                                                                                                                          class Stream extends _Readable {}

                                                                                                                            constructor

                                                                                                                            constructor(options?: ReadableOptions);

                                                                                                                              method compose

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

                                                                                                                                method pipe

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

                                                                                                                                  class Transform

                                                                                                                                  class Transform extends Duplex {}

                                                                                                                                    constructor

                                                                                                                                    constructor(options?: TransformOptions);

                                                                                                                                      class Writable

                                                                                                                                      class Writable extends _Writable {}

                                                                                                                                        constructor

                                                                                                                                        constructor(opts?: WritableOptions);

                                                                                                                                          property writableAborted

                                                                                                                                          readonly writableAborted: boolean;

                                                                                                                                            property writableCorked

                                                                                                                                            readonly writableCorked: number;

                                                                                                                                              property writableEnded

                                                                                                                                              readonly writableEnded: boolean;

                                                                                                                                                property writableFinished

                                                                                                                                                readonly writableFinished: boolean;

                                                                                                                                                  property writableObjectMode

                                                                                                                                                  readonly writableObjectMode: boolean;

                                                                                                                                                    Interfaces

                                                                                                                                                    interface BufferList

                                                                                                                                                    interface BufferList<D extends Buffer = Buffer> {}

                                                                                                                                                      property head

                                                                                                                                                      head: Entry<D>;

                                                                                                                                                        property length

                                                                                                                                                        length: number;

                                                                                                                                                          property tail

                                                                                                                                                          tail: Entry<D>;

                                                                                                                                                            method clear

                                                                                                                                                            clear: () => void;

                                                                                                                                                              method concat

                                                                                                                                                              concat: (n: number) => D;

                                                                                                                                                                method join

                                                                                                                                                                join: (s: any) => string;

                                                                                                                                                                  method push

                                                                                                                                                                  push: (v: D) => void;

                                                                                                                                                                    method shift

                                                                                                                                                                    shift: () => D;

                                                                                                                                                                      method unshift

                                                                                                                                                                      unshift: (v: D) => void;

                                                                                                                                                                        interface BufferRequest

                                                                                                                                                                        interface BufferRequest {}

                                                                                                                                                                          property callback

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

                                                                                                                                                                            property chunk

                                                                                                                                                                            chunk: any;

                                                                                                                                                                              property encoding

                                                                                                                                                                              encoding: BufferEncoding;

                                                                                                                                                                                property isBuf

                                                                                                                                                                                isBuf: boolean;

                                                                                                                                                                                  property next

                                                                                                                                                                                  next: BufferRequest | null;

                                                                                                                                                                                    interface CorkedRequest

                                                                                                                                                                                    interface CorkedRequest {}

                                                                                                                                                                                      property entry

                                                                                                                                                                                      entry: any;

                                                                                                                                                                                        property next

                                                                                                                                                                                        next: any;

                                                                                                                                                                                          method finish

                                                                                                                                                                                          finish: () => void;

                                                                                                                                                                                            interface Destroy

                                                                                                                                                                                            interface Destroy {}

                                                                                                                                                                                              method destroy

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

                                                                                                                                                                                                method undestroy

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

                                                                                                                                                                                                  interface Entry

                                                                                                                                                                                                  interface Entry<D> {}

                                                                                                                                                                                                    property data

                                                                                                                                                                                                    data: D;

                                                                                                                                                                                                      property next

                                                                                                                                                                                                      next: Entry<D> | null;

                                                                                                                                                                                                        interface ReadableState

                                                                                                                                                                                                        interface ReadableState {}

                                                                                                                                                                                                          property awaitDrain

                                                                                                                                                                                                          awaitDrain: number;

                                                                                                                                                                                                            property buffer

                                                                                                                                                                                                            buffer: BufferList<any>;

                                                                                                                                                                                                              property decoder

                                                                                                                                                                                                              decoder: StringDecoder | null;

                                                                                                                                                                                                                property defaultEncoding

                                                                                                                                                                                                                defaultEncoding: BufferEncoding;

                                                                                                                                                                                                                  property destroyed

                                                                                                                                                                                                                  destroyed: boolean;

                                                                                                                                                                                                                    property emittedReadable

                                                                                                                                                                                                                    emittedReadable: boolean;

                                                                                                                                                                                                                      property encoding

                                                                                                                                                                                                                      encoding: BufferEncoding | null;

                                                                                                                                                                                                                        property ended

                                                                                                                                                                                                                        ended: boolean;

                                                                                                                                                                                                                          property endEmitted

                                                                                                                                                                                                                          endEmitted: boolean;

                                                                                                                                                                                                                            property flowing

                                                                                                                                                                                                                            flowing: any;

                                                                                                                                                                                                                              property highWaterMark

                                                                                                                                                                                                                              highWaterMark: number;

                                                                                                                                                                                                                                property length

                                                                                                                                                                                                                                length: number;

                                                                                                                                                                                                                                  property needReadable

                                                                                                                                                                                                                                  needReadable: boolean;

                                                                                                                                                                                                                                    property objectMode

                                                                                                                                                                                                                                    objectMode: boolean;

                                                                                                                                                                                                                                      property pipes

                                                                                                                                                                                                                                      pipes: any;

                                                                                                                                                                                                                                        property pipesCount

                                                                                                                                                                                                                                        pipesCount: number;

                                                                                                                                                                                                                                          property readableListening

                                                                                                                                                                                                                                          readableListening: boolean;

                                                                                                                                                                                                                                            property reading

                                                                                                                                                                                                                                            reading: boolean;

                                                                                                                                                                                                                                              property readingMore

                                                                                                                                                                                                                                              readingMore: boolean;

                                                                                                                                                                                                                                                property resumeScheduled

                                                                                                                                                                                                                                                resumeScheduled: boolean;

                                                                                                                                                                                                                                                  property sync

                                                                                                                                                                                                                                                  sync: boolean;

                                                                                                                                                                                                                                                    interface ReadableStateOptions

                                                                                                                                                                                                                                                    interface ReadableStateOptions {}

                                                                                                                                                                                                                                                      property defaultEncoding

                                                                                                                                                                                                                                                      defaultEncoding?: BufferEncoding | undefined;

                                                                                                                                                                                                                                                        property encoding

                                                                                                                                                                                                                                                        encoding?: BufferEncoding | undefined;

                                                                                                                                                                                                                                                          property highWaterMark

                                                                                                                                                                                                                                                          highWaterMark?: number | undefined;

                                                                                                                                                                                                                                                            property objectMode

                                                                                                                                                                                                                                                            objectMode?: boolean | undefined;

                                                                                                                                                                                                                                                              property readableHighWaterMark

                                                                                                                                                                                                                                                              readableHighWaterMark?: number | undefined;

                                                                                                                                                                                                                                                                property readableObjectMode

                                                                                                                                                                                                                                                                readableObjectMode?: boolean | undefined;

                                                                                                                                                                                                                                                                  interface WritableState

                                                                                                                                                                                                                                                                  interface WritableState {}

                                                                                                                                                                                                                                                                    property buffer

                                                                                                                                                                                                                                                                    buffer: BufferRequest[];

                                                                                                                                                                                                                                                                      property bufferedRequest

                                                                                                                                                                                                                                                                      bufferedRequest: BufferRequest | null;

                                                                                                                                                                                                                                                                        property bufferedRequestCount

                                                                                                                                                                                                                                                                        bufferedRequestCount: number;

                                                                                                                                                                                                                                                                          property bufferProcessing

                                                                                                                                                                                                                                                                          bufferProcessing: boolean;

                                                                                                                                                                                                                                                                            property corked

                                                                                                                                                                                                                                                                            corked: number;

                                                                                                                                                                                                                                                                              property corkedRequestsFree

                                                                                                                                                                                                                                                                              corkedRequestsFree: CorkedRequest;

                                                                                                                                                                                                                                                                                property decodeStrings

                                                                                                                                                                                                                                                                                decodeStrings: boolean;

                                                                                                                                                                                                                                                                                  property defaultEncoding

                                                                                                                                                                                                                                                                                  defaultEncoding: BufferEncoding;

                                                                                                                                                                                                                                                                                    property destroyed

                                                                                                                                                                                                                                                                                    destroyed: boolean;

                                                                                                                                                                                                                                                                                      property ended

                                                                                                                                                                                                                                                                                      ended: boolean;

                                                                                                                                                                                                                                                                                        property ending

                                                                                                                                                                                                                                                                                        ending: boolean;

                                                                                                                                                                                                                                                                                          property errorEmitted

                                                                                                                                                                                                                                                                                          errorEmitted: boolean;

                                                                                                                                                                                                                                                                                            property finalCalled

                                                                                                                                                                                                                                                                                            finalCalled: boolean;

                                                                                                                                                                                                                                                                                              property finished

                                                                                                                                                                                                                                                                                              finished: boolean;

                                                                                                                                                                                                                                                                                                property highWaterMark

                                                                                                                                                                                                                                                                                                highWaterMark: number;

                                                                                                                                                                                                                                                                                                  property lastBufferedRequest

                                                                                                                                                                                                                                                                                                  lastBufferedRequest: BufferRequest | null;

                                                                                                                                                                                                                                                                                                    property length

                                                                                                                                                                                                                                                                                                    length: number;

                                                                                                                                                                                                                                                                                                      property needDrain

                                                                                                                                                                                                                                                                                                      needDrain: boolean;

                                                                                                                                                                                                                                                                                                        property objectMode

                                                                                                                                                                                                                                                                                                        objectMode: boolean;

                                                                                                                                                                                                                                                                                                          property onwrite

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

                                                                                                                                                                                                                                                                                                            property pendingcb

                                                                                                                                                                                                                                                                                                            pendingcb: number;

                                                                                                                                                                                                                                                                                                              property prefinished

                                                                                                                                                                                                                                                                                                              prefinished: boolean;

                                                                                                                                                                                                                                                                                                                property sync

                                                                                                                                                                                                                                                                                                                sync: boolean;

                                                                                                                                                                                                                                                                                                                  property writecb

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

                                                                                                                                                                                                                                                                                                                    property writelen

                                                                                                                                                                                                                                                                                                                    writelen: number;

                                                                                                                                                                                                                                                                                                                      property writing

                                                                                                                                                                                                                                                                                                                      writing: boolean;

                                                                                                                                                                                                                                                                                                                        method getBuffer

                                                                                                                                                                                                                                                                                                                        getBuffer: () => BufferRequest[];

                                                                                                                                                                                                                                                                                                                          interface WritableStateOptions

                                                                                                                                                                                                                                                                                                                          interface WritableStateOptions {}

                                                                                                                                                                                                                                                                                                                            property decodeStrings

                                                                                                                                                                                                                                                                                                                            decodeStrings?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                              property defaultEncoding

                                                                                                                                                                                                                                                                                                                              defaultEncoding?: BufferEncoding | undefined;

                                                                                                                                                                                                                                                                                                                                property highWaterMark

                                                                                                                                                                                                                                                                                                                                highWaterMark?: number | undefined;

                                                                                                                                                                                                                                                                                                                                  property objectMode

                                                                                                                                                                                                                                                                                                                                  objectMode?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                    property writableHighWaterMark

                                                                                                                                                                                                                                                                                                                                    writableHighWaterMark?: number | undefined;

                                                                                                                                                                                                                                                                                                                                      property writableObjectMode

                                                                                                                                                                                                                                                                                                                                      writableObjectMode?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                        Type Aliases

                                                                                                                                                                                                                                                                                                                                        type DuplexOptions

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

                                                                                                                                                                                                                                                                                                                                          type ReadableOptions

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

                                                                                                                                                                                                                                                                                                                                            type TransformOptions

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

                                                                                                                                                                                                                                                                                                                                              type WritableOptions

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

                                                                                                                                                                                                                                                                                                                                                Namespaces

                                                                                                                                                                                                                                                                                                                                                namespace global

                                                                                                                                                                                                                                                                                                                                                namespace global {}

                                                                                                                                                                                                                                                                                                                                                  interface AsyncIteratorObject

                                                                                                                                                                                                                                                                                                                                                  interface AsyncIteratorObject<T, TReturn, TNext> {}

                                                                                                                                                                                                                                                                                                                                                    Package Files (1)

                                                                                                                                                                                                                                                                                                                                                    Dependencies (1)

                                                                                                                                                                                                                                                                                                                                                    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>