export declare namespace Sink {
    type Finalizator = () => void | Promise<void>;
    interface Options {
        readonly cancelOnPipeError?: boolean | undefined;
    }
    interface WaitOptions {
        readonly timeout?: number | undefined;
        readonly errorOnTimeout?: boolean | undefined;
    }
}
export declare class Sink<A> {
    private readonly promise;
    private readonly cancelOnError;
    private pending;
    private waitTimeoutHandler;
    private cancelling;
    private resolve;
    private reject;
    private finalizator;
    private pipeHandler;
    constructor(executor: (pipe: (value: A) => void, cancel: Sink<A>['cancel']) => Sink.Finalizator | void, { cancelOnPipeError }?: Sink.Options);
    get isPending(): boolean;
    /** Wait until Sink is finished/cancelled. */
    wait({ timeout, errorOnTimeout }?: Sink.WaitOptions): Promise<void>;
    /** Stop pipes and free resources. */
    cancel(reason?: unknown): Promise<void>;
    /** Execute action on every pipe and use prev action result. */
    pipe<B>(action: (value: A) => PromiseLike<B> | B): Sink<B>;
    /** Execute action on pipe once and then cancel. */
    once<B>(action: (value: A) => PromiseLike<B> | B): Sink<B>;
    catch<B = never>(action: (reason: unknown) => PromiseLike<B> | B): Sink<B>;
}