import type { ForEachFn, FoldFn, MapFn, PredicateFn, CompareFn, KeyFn, ScanFn, EqualFn } from './types/functions/mod';
import { Flatten, Pair, Nullable } from './types/mod';
export declare type ToAsyncIterator<T> = T extends number ? IAsyncIterator_number : T extends Pair<infer A, infer B> ? IAsyncIterator_zip<A, B> : IAsyncIterator_<T>;
export interface IAsyncIterator_<T> extends AsyncIterableIterator<T> {
    /**
     * @see https://tc39.es/proposal-iterator-helpers/#sec-asynciteratorprototype-@@tostringtag
     */
    [Symbol.toStringTag]: string;
    /**
     * similar Array.prototype.every
     *
     * @see https://doc.rust-lang.org/stable/std/iter/trait.Iterator.html#method.all
     */
    all(fn: PredicateFn<T>): Promise<boolean>;
    /**
     * similar Array.prototype.some
     *
     * @see https://doc.rust-lang.org/stable/std/iter/trait.Iterator.html#method.any
     */
    any(fn: PredicateFn<T>): Promise<boolean>;
    /**
     * similar concat
     *
     * @see https://doc.rust-lang.org/stable/std/iter/trait.Iterator.html#method.chain
     */
    chain(other: Iterable<T | Promise<T>> | AsyncIterable<T | Promise<T>>): ToAsyncIterator<T>;
    /**
     * @description
     * Convert AsyncIterator_ to Array
     *
     * @see https://doc.rust-lang.org/stable/std/iter/trait.Iterator.html#method.collect
     */
    collect(): Promise<T[]>;
    /**
     * @see https://doc.rust-lang.org/stable/std/iter/trait.Iterator.html#method.count
     */
    count(): Promise<number>;
    /**
     * @see https://doc.rust-lang.org/stable/std/iter/trait.Iterator.html#method.cycle
     */
    cycle(): ToAsyncIterator<T>;
    /**
     * @see https://doc.rust-lang.org/stable/std/iter/trait.Iterator.html#method.enumerate
     */
    enumerate(): ToAsyncIterator<Pair<number, T>>;
    /**
     * @see https://doc.rust-lang.org/stable/std/iter/trait.Iterator.html#method.filter
     */
    filter(predicate: PredicateFn<T>): ToAsyncIterator<T>;
    /**
     * @description
     * do not catch error
     *
     * filter only `null | undefined | NaN`
     *
     * @example
     * ['a', 'b', '1', 'c', '2', '3']
     *   .iter()
     *   .filterMap(e => parseInt(e, 10))
     *   .collect(); // [1, 2, 3]
     *
     * @see https://doc.rust-lang.org/stable/std/iter/trait.Iterator.html#method.filter_map
     */
    filterMap<R>(fn: MapFn<T, Nullable<R>>): ToAsyncIterator<R>;
    /**
     * @see https://doc.rust-lang.org/stable/std/iter/trait.Iterator.html#method.find
     */
    find(predicate: PredicateFn<T>): Promise<T | undefined>;
    /**
     * @description
     * do not catch error
     *
     * filter only `null | undefined | NaN`
     *
     * @example
     * ['a', 'b', '1', 'c', '2']
     *   .iter()
     *   .findMap(e => parseInt(e, 10)); // 1
     *
     * @see https://doc.rust-lang.org/stable/std/iter/trait.Iterator.html#method.find_map
     */
    findMap<R>(fn: MapFn<T, Nullable<R>>): Promise<R | undefined>;
    /**
     * @example
     * [`it's Sunny in`, '', 'California']
     *   .iter()
     *   .flatMap(e => e.split(' '))
     *   .collect(); // [`it's`, 'Sunny', 'in', '', 'California']
     *
     * @see https://doc.rust-lang.org/std/iter/trait.Iterator.html#method.flat_map
     */
    flatMap<R extends Iterable<any> | AsyncIterable<any>>(fn: MapFn<T, R>): ToAsyncIterator<Flatten<R>>;
    /**
     * @example
     * [[1], [Promise.resolve(2), 3], 4, 5]
     *   .iter()
     *   .flatten()
     *   .collect(); // [1, 2, 3, 4, 5]
     *
     * @see https://doc.rust-lang.org/stable/std/iter/trait.Iterator.html#method.flatten
     */
    flatten(): ToAsyncIterator<Flatten<T>>;
    /**
     * @see http://hackage.haskell.org/package/base-4.12.0.0/docs/Data-List.html#v:foldl
     */
    fold<U>(init: U | Promise<U>, fn: FoldFn<T, U>): Promise<U>;
    /**
     * @throws empty iterator
     *
     * @see http://hackage.haskell.org/package/base-4.12.0.0/docs/Data-List.html#v:foldl1
     */
    fold1(fn: FoldFn<T, T>): Promise<T>;
    /**
     * @see https://doc.rust-lang.org/stable/std/iter/trait.Iterator.html#method.for_each
     */
    forEach(fn: ForEachFn<T>): Promise<void>;
    /**
     * @description
     * if empty iterator, return undefined
     *
     * @see https://doc.rust-lang.org/stable/std/iter/trait.Iterator.html#tymethod.next
     */
    head(): Promise<T | undefined>;
    /**
     * @see https://doc.rust-lang.org/stable/std/iter/trait.Iterator.html#method.inspect
     */
    inspect(fn: ForEachFn<T>): ToAsyncIterator<T>;
    /**
     * @description
     * if empty iterator, return undefined
     *
     * @see https://doc.rust-lang.org/stable/std/iter/trait.Iterator.html#method.last
     */
    last(): Promise<T | undefined>;
    /**
     * @see https://doc.rust-lang.org/stable/std/iter/trait.Iterator.html#method.map
     */
    map<R>(fn: MapFn<T, R>): ToAsyncIterator<R>;
    /**
     * @see https://doc.rust-lang.org/stable/std/iter/trait.Iterator.html#method.max
     */
    max(): Promise<T | undefined>;
    /**
     * @see https://doc.rust-lang.org/stable/std/iter/trait.Iterator.html#method.max_by
     */
    maxBy(fn: CompareFn<T>): Promise<T | undefined>;
    /**
     * @see https://doc.rust-lang.org/stable/std/iter/trait.Iterator.html#method.max_by_key
     */
    maxByKey<K>(keyFn: KeyFn<T, K>, cmpFn?: CompareFn<K>): Promise<T | undefined>;
    /**
     * @see https://doc.rust-lang.org/stable/std/iter/trait.Iterator.html#method.min
     */
    min(): Promise<T | undefined>;
    /**
     * @see https://doc.rust-lang.org/stable/std/iter/trait.Iterator.html#method.min_by
     */
    minBy(fn: CompareFn<T>): Promise<T | undefined>;
    /**
     * @see https://doc.rust-lang.org/stable/std/iter/trait.Iterator.html#method.min_by_key
     */
    minByKey<K>(keyFn: KeyFn<T, K>, cmpFn?: CompareFn<K>): Promise<T | undefined>;
    /**
     * @see https://doc.rust-lang.org/stable/std/iter/trait.Iterator.html#method.nth
     */
    nth(n: number): Promise<T | undefined>;
    /**
     * @see https://hackage.haskell.org/package/base-4.12.0.0/docs/Data-List.html#v:nub
     */
    nub(): ToAsyncIterator<T>;
    /**
     * @see https://hackage.haskell.org/package/base-4.12.0.0/docs/Data-List.html#v:nubBy
     */
    nubBy(fn: EqualFn<T>): ToAsyncIterator<T>;
    /**
     * @see https://doc.rust-lang.org/stable/std/iter/trait.Iterator.html#method.partition
     */
    partition(fn: PredicateFn<T>): Promise<Pair<ToAsyncIterator<T>, ToAsyncIterator<T>>>;
    /**
     * @see https://doc.rust-lang.org/stable/std/iter/trait.Iterator.html#method.position
     */
    position(fn: PredicateFn<T>): Promise<number | undefined>;
    /**
     * @see https://doc.rust-lang.org/stable/std/iter/trait.Iterator.html#method.rev
     */
    reverse(): ToAsyncIterator<T>;
    /**
     * @see http://hackage.haskell.org/package/base-4.12.0.0/docs/Data-List.html#v:scanl
     */
    scan<U>(init: U | Promise<U>, fn: ScanFn<T, U>): ToAsyncIterator<U>;
    /**
     * @see http://hackage.haskell.org/package/base-4.12.0.0/docs/Data-List.html#v:scanl1
     */
    scan1(fn: ScanFn<T, T>): ToAsyncIterator<T>;
    /**
     * @see https://doc.rust-lang.org/stable/std/iter/trait.Iterator.html#method.skip
     */
    skip(count_: number): ToAsyncIterator<T>;
    /**
     * @see https://doc.rust-lang.org/stable/std/iter/trait.Iterator.html#method.skip_while
     */
    skipWhile(predicate: PredicateFn<T>): ToAsyncIterator<T>;
    /**
     * @see https://doc.rust-lang.org/stable/std/iter/trait.Iterator.html#method.step_by
     */
    stepBy(step: number): ToAsyncIterator<T>;
    /**
     * @see https://doc.rust-lang.org/stable/std/iter/trait.Iterator.html#method.take
     */
    take(count_: number): ToAsyncIterator<T>;
    /**
     * @see https://doc.rust-lang.org/stable/std/iter/trait.Iterator.html#method.take_while
     */
    takeWhile(predicate: PredicateFn<T>): ToAsyncIterator<T>;
    toString(): string;
    /**
     * @see https://doc.rust-lang.org/stable/std/iter/trait.Iterator.html#method.zip
     */
    zip<U>(other: Iterable<U | Promise<U>> | AsyncIterable<U | Promise<U>>): ToAsyncIterator<Pair<T, U>>;
}
export interface IAsyncIterator_number extends IAsyncIterator_<number> {
    /**
     * @example
     * [1, 2, 3, 4, 5]
     *   .iter()
     *   .average(); // 3
     *
     * ([] as number[])
     *   .iter()
     *   .average(); // 0
     */
    average(): Promise<number>;
    /**
     * @example
     * [1, 2, 3, 4, 5]
     *   .iter()
     *   .product(); // 120
     *
     * ([] as number[])
     *   .iter()
     *   .product(); // 1
     *
     * @see https://doc.rust-lang.org/stable/std/iter/trait.Iterator.html#method.product
     */
    product(): Promise<number>;
    /**
     * @example
     * [1, 2, 3, 4, 5]
     *   .iter()
     *   .sum(); // 15
     *
     * ([] as number[])
     *   .iter()
     *   .sum(); // 0
     *
     * @see https://doc.rust-lang.org/stable/std/iter/trait.Iterator.html#method.sum
     */
    sum(): Promise<number>;
}
export interface IAsyncIterator_zip<T, U> extends IAsyncIterator_<Pair<T, U>> {
    /**
     * @see https://doc.rust-lang.org/stable/std/iter/trait.Iterator.html#method.unzip
     */
    unzip(): Promise<Pair<ToAsyncIterator<T>, ToAsyncIterator<U>>>;
}
export declare class AsyncIterator_<T> implements IAsyncIterator_<T> {
    constructor(iter: AsyncIterable<T | Promise<T>>);
    private readonly _iter;
    readonly [Symbol.toStringTag]: "Async Iterator";
    [Symbol.asyncIterator](): this;
    next(): Promise<{
        done: boolean | undefined;
        value: T;
    }>;
    all(fn: PredicateFn<T>): Promise<boolean>;
    any(fn: PredicateFn<T>): Promise<boolean>;
    average(): Promise<number>;
    chain(other: Iterable<T | Promise<T>> | AsyncIterable<T | Promise<T>>): ToAsyncIterator<T>;
    collect(): Promise<T[]>;
    count(): Promise<number>;
    cycle(): ToAsyncIterator<T>;
    enumerate(): IAsyncIterator_zip<number, T>;
    filter(predicate: PredicateFn<T>): ToAsyncIterator<T>;
    filterMap<R>(fn: MapFn<T, Nullable<R>>): ToAsyncIterator<R>;
    find(predicate: PredicateFn<T>): Promise<T | undefined>;
    findMap<R>(fn: MapFn<T, Nullable<R>>): Promise<R | undefined>;
    flatMap<R extends Iterable<any> | AsyncIterable<any>>(fn: MapFn<T, R>): ToAsyncIterator<Flatten<R>>;
    flatten(): ToAsyncIterator<Flatten<T>>;
    fold<U>(init: U | Promise<U>, fn: FoldFn<T, U>): Promise<U>;
    fold1(fn: FoldFn<T, T>): Promise<T>;
    forEach(fn: ForEachFn<T>): Promise<void>;
    head(): Promise<T | undefined>;
    inspect(fn: ForEachFn<T>): ToAsyncIterator<T>;
    last(): Promise<T | undefined>;
    map<R>(fn: MapFn<T, R>): ToAsyncIterator<R>;
    max(): Promise<T | undefined>;
    maxBy(fn: CompareFn<T>): Promise<T | undefined>;
    maxByKey<K>(keyFn: KeyFn<T, K>, cmpFn?: CompareFn<K>): Promise<T | undefined>;
    min(): Promise<T | undefined>;
    minBy(fn: CompareFn<T>): Promise<T | undefined>;
    minByKey<K>(keyFn: KeyFn<T, K>, cmpFn?: CompareFn<K>): Promise<T | undefined>;
    nth(n: number): Promise<T | undefined>;
    nub(): ToAsyncIterator<T>;
    nubBy(fn: EqualFn<T>): ToAsyncIterator<T>;
    partition(fn: PredicateFn<T>): Promise<Pair<ToAsyncIterator<T>, ToAsyncIterator<T>>>;
    position(fn: PredicateFn<T>): Promise<number | undefined>;
    product(): Promise<number>;
    reverse(): ToAsyncIterator<T>;
    scan<U>(init: U | Promise<U>, fn: ScanFn<T, U>): ToAsyncIterator<U>;
    scan1(fn: ScanFn<T, T>): ToAsyncIterator<T>;
    skip(count_: number): ToAsyncIterator<T>;
    skipWhile(predicate: PredicateFn<T>): ToAsyncIterator<T>;
    stepBy(step: number): ToAsyncIterator<T>;
    sum(): Promise<number>;
    take(count_: number): ToAsyncIterator<T>;
    takeWhile(predicate: PredicateFn<T>): ToAsyncIterator<T>;
    unzip(): Promise<Pair<IAsyncIterator_number | IAsyncIterator_zip<unknown, unknown> | IAsyncIterator_<any>, IAsyncIterator_number | IAsyncIterator_zip<unknown, unknown> | IAsyncIterator_<any>>>;
    zip<U>(other: Iterable<U | Promise<U>> | AsyncIterable<U | Promise<U>>): IAsyncIterator_zip<T, U>;
}
export declare function iterator<T>(iter: Iterable<T | Promise<T>> | AsyncIterable<T | Promise<T>>): ToAsyncIterator<T>;
//# sourceMappingURL=iterator.d.ts.map