import type { AbstractConstructorLike } from "@rickosborne/typical";
export type Optional<T> = {
    value: T;
} | undefined;
export type IteratorTransformerMore<T> = () => Optional<T>;
/**
 * Basic queues and statistic tracking for a dual-queued Iterator transformer.
 */
export declare abstract class IteratorTransformerBase<InputT, OutputT> {
    private _inputCount;
    private _inputDone;
    private _maxInputsLength;
    private _maxOutputsLength;
    private _outputCount;
    private _outputDone;
    private readonly inputQueue;
    private readonly outputQueue;
    get inputCount(): number;
    get inputIsDone(): boolean;
    get inputQueueLength(): number;
    protected get inputs(): InputT[];
    get maxInputsLength(): number;
    get maxOutputsLength(): number;
    get outputCount(): number;
    get outputIsDone(): boolean;
    get outputQueueLength(): number;
    protected pushInput(input: InputT): void;
    protected pushOutputs(items: OutputT[]): void;
    protected setInputDone(): void;
    protected setOutputDone(): void;
    protected takeInputs(count: number): InputT[];
    protected takeOutput(): Optional<OutputT>;
}
export type SyncIteratorTransformerConstructor<InputT, OutputT> = AbstractConstructorLike<[iterator: Iterator<InputT, undefined, undefined>], IteratorTransformer<InputT, OutputT>>;
export interface IteratorTransformerMapResult<OutputT> {
    inputsProcessed: number;
    outputs: OutputT[];
}
export declare abstract class IteratorTransformer<InputT, OutputT> extends IteratorTransformerBase<InputT, OutputT> implements IterableIterator<OutputT, undefined, undefined> {
    private readonly inputIterator;
    constructor(iterator: Iterator<InputT, undefined, undefined>);
    protected abstract map(inputs: readonly InputT[], inputDone: boolean): IteratorTransformerMapResult<OutputT>;
    next(): IteratorResult<OutputT, undefined>;
    private nextInput;
    [Symbol.iterator](): IterableIterator<OutputT, undefined, undefined>;
}
export declare const iteratorTransformer: <InputT, OutputT>(map: (inputs: InputT[], inputIsDone: boolean) => IteratorTransformerMapResult<OutputT>) => (it: Iterator<InputT, undefined, undefined> | Iterable<InputT, undefined, undefined>) => IteratorTransformer<InputT, OutputT>;
export type AsyncIteratorTransformerConstructor<InputT, OutputT> = AbstractConstructorLike<[iterator: AsyncIterator<InputT, undefined, undefined>], AsyncIteratorTransformer<InputT, OutputT>>;
/**
 * Additional configuration for an asynchronous Iterator transformer.
 */
export interface AsyncIteratorTransformerOptions {
    /**
     * If true, will call `next`, without blocking, on the Input Iterator as its
     * own `next` sends out an Output.  In some cases, this could improve latency between
     * input and output calls.  In cases where there are more outputs than inputs,
     * this could chew up memory.
     */
    proactive?: boolean;
}
export declare abstract class AsyncIteratorTransformer<InputT, OutputT> extends IteratorTransformerBase<InputT, OutputT> implements AsyncIterableIterator<OutputT, undefined, undefined> {
    private readonly inputIterator;
    private nextInputPromise;
    private readonly proactive;
    constructor(iterator: AsyncIterator<InputT, undefined, undefined>, options?: AsyncIteratorTransformerOptions);
    protected abstract map(inputs: InputT[], inputDone: boolean): IteratorTransformerMapResult<OutputT> | Promise<IteratorTransformerMapResult<OutputT>>;
    next(): Promise<IteratorResult<OutputT, undefined>>;
    private nextInput;
    [Symbol.asyncIterator](): AsyncIterableIterator<OutputT, undefined, undefined>;
}
export declare const asyncIteratorTransformer: <InputT, OutputT>(map: (inputs: InputT[], inputIsDone: boolean) => IteratorTransformerMapResult<OutputT> | Promise<IteratorTransformerMapResult<OutputT>>, options?: AsyncIteratorTransformerOptions) => (it: AsyncIterator<InputT, undefined, undefined> | AsyncIterable<InputT, undefined, undefined> | Iterable<InputT, undefined, undefined>) => AsyncIteratorTransformer<InputT, OutputT>;
export type IteratorTransformerConstructor<InputT, OutputT> = SyncIteratorTransformerConstructor<InputT, OutputT> | AsyncIteratorTransformerConstructor<InputT, OutputT>;
//# sourceMappingURL=iterator-transformer.d.ts.map