export interface Supplier<T> {
    (): T;
}
export interface Accumulator<A, T> {
    (container: A, item: T): void;
}
export interface Combinator<A> {
    (first: A, second: A): A;
}
export interface Finisher<A, R> {
    (container: A): R;
}
export interface Collector<T, A, R> {
    supply(): A;
    accumulate(container: A, item: T): void;
    combine(container1: A, container2: A): A;
    finish(container: A): R;
    then<U>(transformer: (result: R) => U): Collector<T, A, U>;
    apply(iterable: Iterable<T>): R;
}
export declare class Collector<T, A, R> {
    static of<T, A, R>(supplier: Supplier<A>, accumulator: Accumulator<A, T>, combinator: Combinator<A>, finisher: Finisher<A, R>): Collector<T, A, R>;
    static of<T, A>(supplier: Supplier<A>, accumulator: Accumulator<A, T>, combinator: Combinator<A>): Collector<T, A, A>;
}
export declare abstract class BaseCollector<T, A, R> implements Collector<T, A, R> {
    abstract supply(): A;
    abstract accumulate(container: A, item: T): void;
    abstract combine(container1: A, container2: A): A;
    abstract finish(container: A): R;
    then<U>(transformer: (result: R) => U): Collector<T, A, U>;
    apply(iterable: Iterable<T>): R;
}
export declare class FunctionalCollector<T, A, R> extends BaseCollector<T, A, R> implements Collector<T, A, R> {
    protected supplier: Supplier<A>;
    protected accumulator: Accumulator<A, T>;
    protected combinator: Combinator<A>;
    protected finisher: Finisher<A, R>;
    constructor(supplier: Supplier<A>, accumulator: Accumulator<A, T>, combinator: Combinator<A>, finisher: Finisher<A, R>);
    supply(): A;
    accumulate(container: A, item: T): void;
    combine(container1: A, container2: A): A;
    finish(container: A): R;
}
/**
 * Applies a given collector to the given iterator's items
 *
 * @param iterable
 * @param collector
 */
export declare function collect<T, R>(iterable: Iterable<T>, collector: Collector<T, any, R>): R;