export declare abstract class Chainable<FROM, TO, IMPLEMENTERCLASS extends Chainable<FROM, TO, IMPLEMENTERCLASS>> {
    protected abstract take(error: Error | undefined, item: FROM): boolean;
    protected abstract me(): IMPLEMENTERCLASS;
    private downstreamChainables;
    chain<N extends Chainable<TO, any, any>>(chainable: N): N;
    branch(branchFn: (me: IMPLEMENTERCLASS) => void): IMPLEMENTERCLASS;
    protected shouldLoadNewItems(): boolean;
    protected give(error: Error | undefined, item: TO | undefined): boolean;
    protected doTake(error: Error | undefined, item: FROM | undefined): boolean;
}
/**
 * Generic filter that can be chained.
 */
export declare abstract class ChainableFilter<TYPE, IMPLEMENTERCLASS extends ChainableFilter<TYPE, IMPLEMENTERCLASS>> extends Chainable<TYPE, TYPE, IMPLEMENTERCLASS> {
}
/**
 * Generic transformer that can be chained.
 */
export declare abstract class ChainableTransformer<FROM, TO, IMPLEMENTERCLASS extends ChainableTransformer<FROM, TO, IMPLEMENTERCLASS>> extends Chainable<FROM, TO, IMPLEMENTERCLASS> {
}
/**
 * Supplier that does not accept take.
 */
export declare abstract class ChainableSupplier<TO, IMPLEMENTERCLASS extends ChainableSupplier<TO, IMPLEMENTERCLASS>> extends Chainable<undefined, TO, IMPLEMENTERCLASS> {
    take(error: Error | undefined, item: undefined | undefined): boolean;
    abstract start(callback?: () => void): void;
}
/**
 * Taker that cannot be branched or chained.
 */
export declare abstract class ChainableTaker<FROM, IMPLEMENTERCLASS extends ChainableTaker<FROM, IMPLEMENTERCLASS>> extends Chainable<FROM, undefined, IMPLEMENTERCLASS> {
    chain<N extends Chainable<undefined, any, any>>(chainable: N): N;
    branch(branchFn: (me: IMPLEMENTERCLASS) => void): IMPLEMENTERCLASS;
    protected give(error: Error | undefined, item: undefined | undefined): boolean;
}
export declare class SimpleTaker<T> extends ChainableTaker<T, SimpleTaker<T>> {
    private callback;
    private onErrorCallback;
    constructor(callback: (item: T) => boolean);
    catch(fn: (error: Error) => boolean): void;
    protected me(): SimpleTaker<T>;
    protected onErrorCought(error: Error): void;
    protected take(error: Error | undefined, item: T): boolean;
    protected doTake(error: Error | undefined, item: T): boolean;
}
