export declare type Mapper<A, B> = (a: A) => B;
export declare type Comparator<A> = (a: A, b: A) => number;
export declare function ascending<T>(a: T, b: T): 1 | -1 | 0;
export declare function descending<T>(a: T, b: T): number;
export declare function comparators<T>(...comparators: Comparator<T>[]): Comparator<T>;
export interface Key<A, K extends keyof A> extends Mapper<A, A[K]> {
    name: K;
}
export declare function key<A, K extends keyof A>(name: K): Key<A, K>;
export declare function value<A, K extends keyof A>(name: K): Mapper<A, A[K]>;
export declare type Reducer<A, B> = (accumulator: B, value: A) => B;
export declare function isIterable(instance: any): instance is Iterable<any>;
export declare function isAsyncIterable(instance: any): instance is AsyncIterable<any>;
export declare function isPromiseLike(instance: any): instance is PromiseLike<any>;
export declare function toIterable<T>(...t: T[]): Iterable<T>;
export declare function iterable<T>(values: ArrayLike<T>): Iterable<T>;
export declare function asyncIterable<T>(values: Array<Promise<T> | T> | Iterable<Promise<T> | T>): AsyncIterable<T>;
export declare function isArrayLike(value: any): value is ArrayLike<any>;
export declare type IterableLike<T> = Iterable<T> | ArrayLike<T>;
export declare function toAsyncIterable<A>(promise: PromiseLike<A>): AsyncIterable<A>;
export declare function by<A, K extends keyof A>(key: K, comparator?: Comparator<A[K]>): Comparator<A>;
export declare function by<A, K>(mapper: Mapper<A, K>, comparator?: Comparator<K>): Comparator<A>;
export interface AsyncIterableWithReturn<T, R = any> extends AsyncIterator<T, R> {
    [Symbol.asyncIterator](): AsyncIterableWithReturn<T, R>;
}
export declare class AsyncIteratorHandler<T, R = any> implements AsyncIterableWithReturn<T, R> {
    private handlers;
    private state;
    value(value: T): void;
    error(value: Error): void;
    close(value?: R): void;
    [Symbol.asyncIterator](): AsyncIterableIterator<T>;
    next(): Promise<IteratorResult<T>>;
    private newState;
    private newHandler;
    private consume;
}
export declare type Yielded<T> = {
    yielded: T;
};
export declare type Returned<R> = {
    returned: R;
};
export declare type ReturnedResult<T, R> = Yielded<T> | Returned<R>;
export declare function isYielded<T>(value: any): value is Yielded<T>;
export declare function isReturned<R>(value: any): value is Returned<R>;
export declare function asyncReturned<T, R>(iterator: AsyncIterator<T, R>): AsyncIterableIterator<ReturnedResult<T, R>>;
export declare function syncReturned<T, R>(iterator: Iterator<T, R>): IterableIterator<ReturnedResult<T, R>>;