fast-extract/dist/esm/streams/transforms/IteratorTransform.d.ts

Extract contents from various archive types (tar, tar.bz2, tar.gz, tar.xz, tgz, zip)

import type { TransformCallback, TransformOptions, Transform as TransformT } from 'stream';
import type { OptionsInternal } from '../../types.js';
interface Iterator {
    forEach(fn: (entry: unknown) => void, options: {
        concurrency: number;
    }, callback: (err?: Error | null) => void): void;
    destroy(error?: Error | null): void;
}
type IteratorConstructor = new (stream: NodeJS.ReadWriteStream) => Iterator;
export default function createIteratorTransform(IteratorClass: IteratorConstructor): {
    new (options?: OptionsInternal | TransformOptions<TransformT>): {
        _iterator: Iterator | null;
        _callback: ((error?: Error | null) => void) | null;
        _stream: NodeJS.ReadWriteStream | null;
        _concurrency: number;
        _transform(chunk: unknown, encoding: BufferEncoding, callback: TransformCallback): void;
        _flush(callback: TransformCallback): void;
        destroy(error?: Error | null): /*elided*/ any;
        allowHalfOpen: boolean;
        addListener<E extends keyof import("node:stream").DuplexEventMap>(eventName: E, listener: (...args: import("node:stream").DuplexEventMap[E]) => void): /*elided*/ any;
        addListener(eventName: string | symbol, listener: (...args: any[]) => void): /*elided*/ any;
        emit<E extends keyof import("node:stream").DuplexEventMap>(eventName: E, ...args: import("node:stream").DuplexEventMap[E]): boolean;
        emit(eventName: string | symbol, ...args: any[]): boolean;
        listenerCount<E extends keyof import("node:stream").DuplexEventMap>(eventName: E, listener?: ((...args: import("node:stream").DuplexEventMap[E]) => void) | undefined): number;
        listenerCount(eventName: string | symbol, listener?: ((...args: any[]) => void) | undefined): number;
        listeners<E extends keyof import("node:stream").DuplexEventMap>(eventName: E): ((...args: import("node:stream").DuplexEventMap[E]) => void)[];
        listeners(eventName: string | symbol): ((...args: any[]) => void)[];
        off<E extends keyof import("node:stream").DuplexEventMap>(eventName: E, listener: (...args: import("node:stream").DuplexEventMap[E]) => void): /*elided*/ any;
        off(eventName: string | symbol, listener: (...args: any[]) => void): /*elided*/ any;
        on<E extends keyof import("node:stream").DuplexEventMap>(eventName: E, listener: (...args: import("node:stream").DuplexEventMap[E]) => void): /*elided*/ any;
        on(eventName: string | symbol, listener: (...args: any[]) => void): /*elided*/ any;
        once<E extends keyof import("node:stream").DuplexEventMap>(eventName: E, listener: (...args: import("node:stream").DuplexEventMap[E]) => void): /*elided*/ any;
        once(eventName: string | symbol, listener: (...args: any[]) => void): /*elided*/ any;
        prependListener<E extends keyof import("node:stream").DuplexEventMap>(eventName: E, listener: (...args: import("node:stream").DuplexEventMap[E]) => void): /*elided*/ any;
        prependListener(eventName: string | symbol, listener: (...args: any[]) => void): /*elided*/ any;
        prependOnceListener<E extends keyof import("node:stream").DuplexEventMap>(eventName: E, listener: (...args: import("node:stream").DuplexEventMap[E]) => void): /*elided*/ any;
        prependOnceListener(eventName: string | symbol, listener: (...args: any[]) => void): /*elided*/ any;
        rawListeners<E extends keyof import("node:stream").DuplexEventMap>(eventName: E): ((...args: import("node:stream").DuplexEventMap[E]) => void)[];
        rawListeners(eventName: string | symbol): ((...args: any[]) => void)[];
        removeAllListeners<E extends keyof import("node:stream").DuplexEventMap>(eventName?: E | undefined): /*elided*/ any;
        removeAllListeners(eventName?: string | symbol): /*elided*/ any;
        removeListener<E extends keyof import("node:stream").DuplexEventMap>(eventName: E, listener: (...args: import("node:stream").DuplexEventMap[E]) => void): /*elided*/ any;
        removeListener(eventName: string | symbol, listener: (...args: any[]) => void): /*elided*/ any;
        pipe<T extends NodeJS.WritableStream>(destination: T, options?: import("node:stream").PipeOptions): T;
        eventNames(): (string | symbol)[];
        getMaxListeners(): number;
        setMaxListeners(n: number): /*elided*/ any;
        [EventEmitter.captureRejectionSymbol]?(error: Error, event: string | symbol, ...args: any[]): void;
        readonly readableAborted: boolean;
        readable: boolean;
        readonly readableDidRead: boolean;
        readonly readableEncoding: BufferEncoding | null;
        readonly readableEnded: boolean;
        readableFlowing: boolean | null;
        readonly readableHighWaterMark: number;
        readonly readableLength: number;
        readonly readableObjectMode: boolean;
        destroyed: boolean;
        readonly closed: boolean;
        readonly errored: Error | null;
        _construct?(callback: (error?: Error | null) => void): void;
        _read(size: number): void;
        read(size?: number): any;
        setEncoding(encoding: BufferEncoding): /*elided*/ any;
        pause(): /*elided*/ any;
        resume(): /*elided*/ any;
        isPaused(): boolean;
        unpipe(destination?: NodeJS.WritableStream): /*elided*/ any;
        unshift(chunk: any, encoding?: BufferEncoding): void;
        wrap(stream: NodeJS.ReadableStream): /*elided*/ any;
        push(chunk: any, encoding?: BufferEncoding): boolean;
        compose(stream: NodeJS.WritableStream | import("node:stream/web").WritableStream | import("node:stream/web").TransformStream | ((source: any) => void), options?: import("node:events").Abortable): import("node:stream").Duplex;
        iterator(options?: import("node:stream").ReadableIteratorOptions): NodeJS.AsyncIterator<any>;
        map(fn: (data: any, options?: import("node:events").Abortable) => any, options?: import("node:stream").ReadableOperatorOptions): import("node:stream").Readable;
        filter(fn: (data: any, options?: import("node:events").Abortable) => boolean | Promise<boolean>, options?: import("node:stream").ReadableOperatorOptions): import("node:stream").Readable;
        forEach(fn: (data: any, options?: import("node:events").Abortable) => void | Promise<void>, options?: Pick<import("node:stream").ReadableOperatorOptions, "concurrency" | "signal">): Promise<void>;
        toArray(options?: import("node:events").Abortable): Promise<any[]>;
        some(fn: (data: any, options?: import("node:events").Abortable) => boolean | Promise<boolean>, options?: Pick<import("node:stream").ReadableOperatorOptions, "concurrency" | "signal">): Promise<boolean>;
        find<T>(fn: (data: any, options?: import("node:events").Abortable) => data is T, options?: Pick<import("node:stream").ReadableOperatorOptions, "concurrency" | "signal">): Promise<T | undefined>;
        find(fn: (data: any, options?: import("node:events").Abortable) => boolean | Promise<boolean>, options?: Pick<import("node:stream").ReadableOperatorOptions, "concurrency" | "signal">): Promise<any>;
        every(fn: (data: any, options?: import("node:events").Abortable) => boolean | Promise<boolean>, options?: Pick<import("node:stream").ReadableOperatorOptions, "concurrency" | "signal">): Promise<boolean>;
        flatMap(fn: (data: any, options?: import("node:events").Abortable) => any, options?: Pick<import("node:stream").ReadableOperatorOptions, "concurrency" | "signal">): import("node:stream").Readable;
        drop(limit: number, options?: import("node:events").Abortable): import("node:stream").Readable;
        take(limit: number, options?: import("node:events").Abortable): import("node:stream").Readable;
        reduce<T>(fn: (previous: any, data: any, options?: import("node:events").Abortable) => T): Promise<T>;
        reduce<T>(fn: (previous: T, data: any, options?: import("node:events").Abortable) => T, initial: T, options?: import("node:events").Abortable): Promise<T>;
        _destroy(error: Error | null, callback: (error?: Error | null) => void): void;
        [Symbol.asyncIterator](): NodeJS.AsyncIterator<any>;
        [Symbol.asyncDispose](): Promise<void>;
        writable: boolean;
        readonly writableAborted: boolean;
        readonly writableEnded: boolean;
        readonly writableFinished: boolean;
        readonly writableHighWaterMark: number;
        readonly writableLength: number;
        readonly writableObjectMode: boolean;
        readonly writableCorked: number;
        readonly writableNeedDrain: boolean;
        _write(chunk: any, encoding: BufferEncoding, callback: (error?: Error | null) => void): void;
        _writev?(chunks: {
            chunk: any;
            encoding: BufferEncoding;
        }[], callback: (error?: Error | null) => void): void;
        _final(callback: (error?: Error | null) => void): void;
        write(chunk: any, callback?: (error: Error | null | undefined) => void): boolean;
        write(chunk: any, encoding: BufferEncoding, callback?: (error: Error | null | undefined) => void): boolean;
        setDefaultEncoding(encoding: BufferEncoding): /*elided*/ any;
        end(cb?: () => void): /*elided*/ any;
        end(chunk: any, cb?: () => void): /*elided*/ any;
        end(chunk: any, encoding: BufferEncoding, cb?: () => void): /*elided*/ any;
        cork(): void;
        uncork(): void;
    };
    from(src: NodeJS.ReadableStream | NodeJS.WritableStream | import("node:buffer").Blob | string | Iterable<any> | AsyncIterable<any> | ((source: AsyncIterable<any>) => AsyncIterable<any>) | ((source: AsyncIterable<any>) => Promise<void>) | Promise<any> | import("node:stream/web").ReadableWritablePair | import("node:stream/web").ReadableStream | import("node:stream/web").WritableStream): import("node:stream").Duplex;
    toWeb(streamDuplex: NodeJS.ReadWriteStream, options?: import("node:stream").DuplexToWebOptions): import("node:stream/web").ReadableWritablePair;
    fromWeb(duplexStream: import("node:stream/web").ReadableWritablePair, options?: Pick<import("node:stream").DuplexOptions, "allowHalfOpen" | "decodeStrings" | "encoding" | "highWaterMark" | "objectMode" | "signal">): import("node:stream").Duplex;
    promises: typeof import("node:stream/promises");
    Stream: typeof import("node:stream");
    duplexPair(options?: import("node:stream").DuplexOptions): [import("node:stream").Duplex, import("node:stream").Duplex];
    addAbortSignal<T extends NodeJS.ReadableStream | NodeJS.WritableStream | import("node:stream/web").ReadableStream | import("node:stream/web").WritableStream>(signal: AbortSignal, stream: T): T;
    getDefaultHighWaterMark(objectMode: boolean): number;
    setDefaultHighWaterMark(objectMode: boolean, value: number): void;
    finished: typeof import("node:stream").finished;
    pipeline: typeof import("node:stream").pipeline;
    compose(stream: import("node:stream").ComposeSource<any> | import("node:stream").ComposeDestination<any>): import("node:stream").Duplex;
    compose<S extends import("node:stream").ComposeSource<any> | import("node:stream").ComposeTransform<any, any>, D extends import("node:stream").ComposeTransform<S, any> | import("node:stream").ComposeDestination<S>>(source: S, destination: D): import("node:stream").Duplex;
    compose<S extends import("node:stream").ComposeSource<any> | import("node:stream").ComposeTransform<any, any>, T extends import("node:stream").ComposeTransform<S, any>, D extends import("node:stream").ComposeTransform<T, any> | import("node:stream").ComposeDestination<T>>(source: S, transform: T, destination: D): import("node:stream").Duplex;
    compose<S extends import("node:stream").ComposeSource<any> | import("node:stream").ComposeTransform<any, any>, T1 extends import("node:stream").ComposeTransform<S, any>, T2 extends import("node:stream").ComposeTransform<T1, any>, D extends import("node:stream").ComposeTransform<T2, any> | import("node:stream").ComposeDestination<T2>>(source: S, transform1: T1, transform2: T2, destination: D): import("node:stream").Duplex;
    compose<S extends import("node:stream").ComposeSource<any> | import("node:stream").ComposeTransform<any, any>, T1 extends import("node:stream").ComposeTransform<S, any>, T2 extends import("node:stream").ComposeTransform<T1, any>, T3 extends import("node:stream").ComposeTransform<T2, any>, D extends import("node:stream").ComposeTransform<T3, any> | import("node:stream").ComposeDestination<T3>>(source: S, transform1: T1, transform2: T2, transform3: T3, destination: D): import("node:stream").Duplex;
    compose<S extends import("node:stream").ComposeSource<any> | import("node:stream").ComposeTransform<any, any>, T1 extends import("node:stream").ComposeTransform<S, any>, T2 extends import("node:stream").ComposeTransform<T1, any>, T3 extends import("node:stream").ComposeTransform<T2, any>, T4 extends import("node:stream").ComposeTransform<T3, any>, D extends import("node:stream").ComposeTransform<T4, any> | import("node:stream").ComposeDestination<T4>>(source: S, transform1: T1, transform2: T2, transform3: T3, transform4: T4, destination: D): import("node:stream").Duplex;
    compose(...streams: [import("node:stream").ComposeSource<any>, ...import("node:stream").ComposeTransform<any, any>[], import("node:stream").ComposeDestination<any>]): import("node:stream").Duplex;
    isErrored(stream: NodeJS.ReadableStream | NodeJS.WritableStream | import("node:stream/web").ReadableStream | import("node:stream/web").WritableStream): boolean;
    isReadable(stream: NodeJS.ReadableStream | import("node:stream/web").ReadableStream): boolean | null;
    isWritable(stream: NodeJS.WritableStream | import("node:stream/web").WritableStream): boolean | null;
    Readable: typeof import("node:stream").Readable;
    Writable: typeof import("node:stream").Writable;
    Duplex: typeof import("node:stream").Duplex;
    Transform: typeof TransformT;
    PassThrough: typeof import("node:stream").PassThrough;
    EventEmitter: typeof import("node:events");
    addAbortListener(signal: AbortSignal, resource: (event: Event) => void): Disposable;
    getEventListeners(emitter: import("node:events"), name: string | symbol): ((...args: any[]) => void)[];
    getEventListeners(emitter: EventTarget, name: string): ((...args: any[]) => void)[];
    getMaxListeners(emitter: import("node:events") | EventTarget): number;
    listenerCount(emitter: import("node:events"), eventName: string | symbol): number;
    listenerCount(emitter: EventTarget, eventName: string): number;
    on(emitter: import("node:events"), eventName: string | symbol, options?: import("node:events").OnOptions): NodeJS.AsyncIterator<any[]>;
    on(emitter: EventTarget, eventName: string, options?: import("node:events").OnOptions): NodeJS.AsyncIterator<any[]>;
    once(emitter: import("node:events"), eventName: string | symbol, options?: import("node:events").OnceOptions): Promise<any[]>;
    once(emitter: EventTarget, eventName: string, options?: import("node:events").OnceOptions): Promise<any[]>;
    setMaxListeners(n: number, ...eventTargets: ReadonlyArray<import("node:events") | EventTarget>): void;
    readonly captureRejectionSymbol: typeof import("node:events").captureRejectionSymbol;
    captureRejections: boolean;
    defaultMaxListeners: number;
    readonly errorMonitor: typeof import("node:events").errorMonitor;
    EventEmitterAsyncResource: typeof import("node:events").EventEmitterAsyncResource;
};
export {};