/// <reference types="node" />
import * as nodeStream from 'stream';
import { Writer } from './writer';
export interface ParallelOptions {
    count?: number;
    shuffle?: boolean;
}
export interface CompareOptions<T> {
    compare?: (v1: T, v2: T) => number;
}
export interface Stoppable {
    stop: (arg?: any) => void;
}
export declare class Reader<T> {
    parent?: Stoppable;
    read: (this: Reader<T>) => T | undefined;
    _stop: (this: Reader<T>, arg?: any) => void;
    stopped: boolean;
    headers: {
        [name: string]: string;
    };
    constructor(read: () => T | undefined, stop?: (arg: any) => void, parent?: Stoppable);
    forEach(fn: (value: T, index: number) => void): void;
    map<U>(fn: (value: T, index: number) => U): Reader<U>;
    every(fn: ((value: T) => boolean) | {}): boolean;
    find(fn: ((value: T) => boolean) | {}): T | undefined;
    some(fn: ((value: T) => boolean) | {}): boolean;
    reduce<U>(fn: (prev: U, value: T) => U, v: U): U;
    pipe(writer: Writer<T>): any;
    tee(writer: Writer<T>): Reader<T>;
    dup(): [Reader<T>, Reader<T>];
    concat(...readers: (Reader<T> | Reader<T>[])[]): Reader<T>;
    toArray(): T[];
    readAll(): string | Buffer | T[] | undefined;
    transform<U>(fn: (reader: Reader<T>, writer: Writer<U>) => void): Reader<U>;
    filter(fn: ((value: T, index: number) => boolean) | {}): Reader<T>;
    until(fn: ((value: T, index: number) => boolean) | {}, stopArg?: any): Reader<T>;
    while(fn: ((value: T, index: number) => boolean) | {}, stopArg?: any): Reader<T>;
    limit(n: number, stopArg?: any): Reader<T>;
    skip(n: number): Reader<T>;
    fork(consumers: ((source: any) => Reader<T>)[]): StreamGroup<T>;
    parallel(options: ParallelOptions | number, consumer: (source: any) => Reader<T>): Reader<T>;
    peekable(): PeekableReader<T>;
    buffer(max: number): Reader<T>;
    join(streams: Reader<T>[] | Reader<T>): Reader<T>;
    nodify(): any;
    nodeTransform<U>(duplex: nodeStream.Duplex): Reader<U>;
    compare(other: Reader<T>, options?: CompareOptions<T>): number;
    stop(arg?: any): void;
    [Symbol.iterator](): Iterator<T>;
}
export declare class PeekableReader<T> extends Reader<T> {
    buffered: (T | undefined)[];
    constructor(parent: Reader<T>);
    unread(val: T | undefined): this;
    peek(): T | undefined;
}
export declare function create<T>(read: () => T, stop?: (arg: any) => void): Reader<T>;
export declare class StreamGroup<T> implements Stoppable {
    readers: (Reader<T> | null)[];
    constructor(readers: Reader<T>[]);
    stop(arg?: any): void;
    dequeue(): Reader<T>;
    rr(): Reader<T>;
    join(fn: (values: (T | undefined)[]) => T | undefined): Reader<T>;
}