import { Voidable } from "./maybe";
import { Option } from "./option";
export declare function flu<T>(iter: AsyncIterable<T>): Flu<T>;
export declare class Flu<T> implements AsyncIterable<T> {
    readonly iter: () => AsyncIterable<T>;
    constructor(iter: () => AsyncIterable<T>);
    [Symbol.asyncIterator](): AsyncIterator<T>;
    static empty<T>(): Flu<T>;
    static by<T>(iter: () => AsyncIterable<T>): Flu<T>;
    static of<T>(...iter: T[]): Flu<T>;
    static from<T>(iter: Iterable<T>): Flu<T>;
    static fromIter<T>(iter: Iterable<T | Promise<T>>): Flu<T>;
    static fromCallback<T>(): CbFlu<[T]>;
    static fromCallback<A extends unknown[], T = A[0], This = never>(map?: (this: This, ...args: A) => T): CbFlu<A, T, This>;
    /** Create a Flu from a range starting from 0 */
    static to(to: number, step?: number): Flu<number>;
    /** Create a Flu from a range */
    static range(from: number, to: number, step?: number): Flu<number>;
    collect(): Promise<T[]>;
    join(separator?: string): Promise<string>;
    count(): Promise<number>;
    isEmpty(): Promise<boolean>;
    first(): Promise<Voidable<T>>;
    firstO(): Promise<Option<T>>;
    last(): Promise<Voidable<T>>;
    lastO(): Promise<Option<T>>;
    nth(n: number): Promise<Voidable<T>>;
    nthO(n: number): Promise<Option<T>>;
    stepBy(step: number): Flu<T>;
    chain(other: AsyncIterable<T> | Iterable<T>, ...more: (AsyncIterable<T> | Iterable<T>)[]): Flu<T>;
    zip<U>(other: AsyncIterable<U>): Flu<[T, U]>;
    unzip(): Promise<[
        (T extends [infer A, any] | readonly [infer A, any] ? A : T extends (infer R)[] ? R : unknown)[],
        (T extends [any, infer B] | readonly [any, infer B] ? B : T extends (infer R)[] ? R : unknown)[]
    ]>;
    map<R>(f: (v: T) => R): Flu<R>;
    mapWait<R>(f: (v: T) => R | PromiseLike<R>): Flu<R>;
    fill<R>(v: R): Flu<R>;
    forEach(f: (v: T) => unknown | PromiseLike<unknown>): Promise<void>;
    run(): Promise<void>;
    filter<S extends T>(f: (v: T) => v is S): Flu<S>;
    filter(f: (v: T) => unknown | PromiseLike<unknown>): Flu<T>;
    enumerate(): Flu<[T, number]>;
    indexed(): Flu<[number, T]>;
    skip(n: number): Flu<T>;
    take(n: number): Flu<T>;
    slice(from: number, to: number): Flu<T>;
    sub(from: number, count: number): Flu<T>;
    scan<R>(init: R, f: (acc: R, val: T) => R): Flu<R>;
    scanWait<R>(init: R | PromiseLike<R>, f: (acc: R, val: T) => R | PromiseLike<R>): Flu<R>;
    flatMap<R>(f: (v: T) => AsyncIterable<R> | Iterable<R>): Flu<R>;
    flatten(): T extends AsyncIterable<infer R> ? Flu<R> : T extends Iterable<infer R> ? Flu<R> : never;
    wait(): T extends infer R | PromiseLike<infer R> ? Flu<R> : never;
    also(f: (v: T) => unknown | PromiseLike<unknown>): Flu<T>;
    fold<R>(init: R, f: (acc: R, val: T) => R): Promise<R>;
    foldWait<R>(init: R | PromiseLike<R>, f: (acc: R, val: T) => R | PromiseLike<R>): Promise<R>;
    reduce(f: (acc: T, val: T) => T): Promise<T>;
    reduceWait(f: (acc: T, val: T) => T | PromiseLike<T>): Promise<T>;
    all(f: (v: T) => unknown | PromiseLike<unknown>): Promise<boolean>;
    any(f: (v: T) => unknown | PromiseLike<unknown>): Promise<boolean>;
    find(f: (v: T) => unknown | PromiseLike<unknown>): Promise<Voidable<T>>;
    position(f: (v: T) => unknown | PromiseLike<unknown>): Promise<number>;
    indexOf(v: T): Promise<number>;
    indexOfWait(v: T | PromiseLike<T>): Promise<number>;
    max(): Promise<Voidable<T>>;
    min(): Promise<Voidable<T>>;
    merge<U>(other: AsyncIterable<U>): Flu<T | U>;
    delay(ms?: Voidable<number>): Flu<T>;
    delay(f: (v: T) => unknown): Flu<T>;
    delay(ms: Voidable<number>, f: (v: T) => unknown): Flu<T>;
    retry(count: number): Flu<T>;
    retry<E = unknown>(f: (err: E, count: number) => unknown): Flu<T>;
    retry<E = unknown>(cond: number | ((err: E, count: number) => unknown)): Flu<T>;
    timestamp(): Flu<[value: T, timestamp: number]>;
    throttle(ms: number): Flu<T>;
    debounce(ms: number): Flu<T>;
    audit(ms: number): Flu<T>;
    buffer(n: number, mode?: 'count' | 'time'): Flu<T[]>;
    break(): Flu<T>;
    breakBy(f: (v: T) => unknown): Flu<T>;
    takeIf(f: (v: T) => unknown): Flu<T>;
    startBy(f: (v: T) => unknown): Flu<T>;
    skipIf(f: (v: T) => unknown): Flu<T>;
    drop(): Flu<void>;
    forEnd(): Flu<any>;
    breakAt(f: (v: T) => unknown): Flu<T>;
    breakAt(single: PromiseLike<unknown>): Flu<T>;
    breakAt(single: AsyncIterable<unknown>): Flu<T>;
    breakAt(single: AsyncIterable<unknown> | PromiseLike<unknown> | ((v: T) => unknown)): Flu<T>;
    takeUntil(single: PromiseLike<unknown>): Flu<T>;
    takeUntil(single: AsyncIterable<unknown>): Flu<T>;
    takeUntil(single: AsyncIterable<unknown> | PromiseLike<unknown>): Flu<T>;
    startAt(f: (v: T) => unknown): Flu<T>;
    startAt(single: PromiseLike<unknown>): Flu<T>;
    startAt(single: AsyncIterable<unknown>): Flu<T>;
    startAt(single: AsyncIterable<unknown> | PromiseLike<unknown> | ((v: T) => unknown)): Flu<T>;
    skipUntil(single: PromiseLike<unknown>): Flu<T>;
    skipUntil(single: AsyncIterable<unknown>): Flu<T>;
    skipUntil(single: AsyncIterable<unknown> | PromiseLike<unknown>): Flu<T>;
    push(...items: T[]): Flu<T>;
    unshift(...items: T[]): Flu<T>;
    as<U>(): Flu<U>;
    groupBy<K>(keyf: (v: T) => K): Flu<[K, T[]]>;
    groupBy<K, V>(keyf: (v: T) => K, valf: (v: T) => V): Flu<[K, V[]]>;
    toArray(): Promise<T[]>;
    toSet(): Promise<Set<T>>;
    toMap(): Promise<T extends [infer K, infer V] ? Map<K, V> : never>;
}
export interface CbFlu<A extends unknown[], T = A[0], This = never> extends Flu<T> {
    cb(this: This, ...arg: A): void;
    end(): void;
    readonly isEnd: boolean;
}
export declare class CbFlu<A extends unknown[], T = A[0], This = never> extends Flu<T> {
    constructor(map?: (this: This, ...args: A) => T);
}
export declare function fromIter<T>(iter: Iterable<T | Promise<T>>): AsyncIterable<T>;
export declare function of<T>(...iter: T[]): AsyncIterable<T>;
export declare function from<T>(iter: Iterable<T>): AsyncIterable<T>;
export declare function collect<T>(iter: AsyncIterable<T>): Promise<T[]>;
export declare function join<T>(iter: AsyncIterable<T>, separator?: string): Promise<string>;
export declare function count<T>(iter: AsyncIterable<T>): Promise<number>;
export declare function isEmpty<T>(iter: AsyncIterable<T>): Promise<boolean>;
export declare function first<T>(iter: AsyncIterable<T>): Promise<Voidable<T>>;
export declare function firstO<T>(iter: AsyncIterable<T>): Promise<Option<T>>;
export declare function last<T>(iter: AsyncIterable<T>): Promise<Voidable<T>>;
export declare function lastO<T>(iter: AsyncIterable<T>): Promise<Option<T>>;
export declare function nth<T>(iter: AsyncIterable<T>, n: number): Promise<Voidable<T>>;
export declare function nthO<T>(iter: AsyncIterable<T>, n: number): Promise<Option<T>>;
export declare function stepBy<T>(iter: AsyncIterable<T>, step: number): AsyncIterable<T>;
export declare function chain<T>(a: AsyncIterable<T> | Iterable<T>, b: AsyncIterable<T> | Iterable<T>, ...more: (AsyncIterable<T> | Iterable<T>)[]): AsyncIterable<T>;
export declare function zip<A, B>(a: AsyncIterable<A>, b: AsyncIterable<B>): AsyncIterable<[A, B]>;
export declare function unzip<A, B>(iter: AsyncIterable<[A, B]>): Promise<[A[], B[]]>;
export declare function map<T, R>(iter: AsyncIterable<T>, f: (v: T) => R): AsyncIterable<R>;
export declare function mapWait<T, R>(iter: AsyncIterable<T>, f: (v: T) => R | PromiseLike<R>): AsyncIterable<R>;
export declare function fill<T, R>(iter: AsyncIterable<T>, v: R): AsyncIterable<R>;
export declare function forEach<T>(iter: AsyncIterable<T>, f: (v: T) => unknown | PromiseLike<unknown>): Promise<void>;
export declare function run<T>(iter: AsyncIterable<T>): Promise<void>;
export declare function filter<T, S extends T>(iter: AsyncIterable<T>, f: (v: T) => v is S): AsyncIterable<S>;
export declare function filter<T>(iter: AsyncIterable<T>, f: (v: T) => unknown): AsyncIterable<T>;
export declare function enumerate<T>(iter: AsyncIterable<T>): AsyncIterable<[T, number]>;
export declare function indexed<T>(iter: AsyncIterable<T>): AsyncIterable<[number, T]>;
export declare function skip<T>(iter: AsyncIterable<T>, n: number): AsyncIterable<T>;
export declare function take<T>(iter: AsyncIterable<T>, n: number): AsyncIterable<T>;
export declare function slice<T>(iter: AsyncIterable<T>, from: number, to: number): AsyncIterable<T>;
export declare function sub<T>(iter: AsyncIterable<T>, from: number, count: number): AsyncIterable<T>;
export declare function scan<T, R>(iter: AsyncIterable<T>, init: R, f: (acc: R, val: T) => R): AsyncIterable<R>;
export declare function scanWait<T, R>(iter: AsyncIterable<T>, init: R | PromiseLike<R>, f: (acc: R, val: T) => R | PromiseLike<R>): AsyncIterable<R>;
export declare function flatMap<T, R>(iter: AsyncIterable<T>, f: (v: T) => AsyncIterable<R> | Iterable<R>): AsyncIterable<R>;
export declare function flatten<T>(iter: AsyncIterable<AsyncIterable<T> | Iterable<T>>): AsyncIterable<T>;
export declare function wait<T>(iter: AsyncIterable<T | PromiseLike<T>>): AsyncIterable<T>;
export declare function also<T>(iter: AsyncIterable<T>, f: (v: T) => unknown | PromiseLike<unknown>): AsyncIterable<T>;
export declare function fold<T, R>(a: AsyncIterable<T>, init: R, f: (acc: R, val: T) => R): Promise<R>;
export declare function foldWait<T, R>(a: AsyncIterable<T>, init: R | PromiseLike<R>, f: (acc: R, val: T) => R | PromiseLike<R>): Promise<R>;
export declare function reduce<T>(a: AsyncIterable<T>, f: (acc: T, val: T) => T): Promise<T>;
export declare function reduceWait<T>(a: AsyncIterable<T>, f: (acc: T, val: T) => T | PromiseLike<T>): Promise<T>;
export declare function all<T>(a: AsyncIterable<T>, f: (v: T) => unknown | PromiseLike<unknown>): Promise<boolean>;
export declare function any<T>(a: AsyncIterable<T>, f: (v: T) => unknown | PromiseLike<unknown>): Promise<boolean>;
export declare function find<T>(a: AsyncIterable<T>, f: (v: T) => unknown | PromiseLike<unknown>): Promise<Voidable<T>>;
export declare function position<T>(a: AsyncIterable<T>, f: (v: T) => unknown | PromiseLike<unknown>): Promise<number>;
export declare function indexOf<T>(a: AsyncIterable<T>, v: T): Promise<number>;
export declare function indexOfWait<T>(a: AsyncIterable<T>, v: T | PromiseLike<T>): Promise<number>;
export declare function max<T>(a: AsyncIterable<T>): Promise<Voidable<T>>;
export declare function min<T>(a: AsyncIterable<T>): Promise<Voidable<T>>;
export declare function merge<A, B>(a: AsyncIterable<A>, b: AsyncIterable<B>): AsyncIterable<A | B>;
export declare function delay<T>(iter: AsyncIterable<T>, ms?: Voidable<number>, f?: (v: T) => unknown): AsyncIterable<T>;
export declare function retry<T, E = unknown>(iterFn: () => AsyncIterable<T>, count?: number | ((err: E, count: number) => unknown)): AsyncIterable<T>;
export declare function timestamp<T>(iter: AsyncIterable<T>): AsyncIterable<[value: T, timestamp: number]>;
export declare function throttle<T>(iter: AsyncIterable<T>, ms?: number): AsyncIterable<T>;
export declare function debounce<T>(iter: AsyncIterable<T>, ms?: number): AsyncIterable<T>;
export declare function audit<T>(iter: AsyncIterable<T>, ms?: number): AsyncIterable<T>;
export declare function buffer<T>(iter: AsyncIterable<T>, n: number, mode?: 'count' | 'time'): AsyncIterable<T[]>;
export declare function breakBy<T>(iter: AsyncIterable<T>, f?: (v: T) => unknown): AsyncIterable<T>;
export declare function takeIf<T>(iter: AsyncIterable<T>, f?: (v: T) => unknown): AsyncIterable<T>;
export declare function skipIf<T>(iter: AsyncIterable<T>, f: (v: T) => unknown): AsyncIterable<T>;
export declare function startBy<T>(iter: AsyncIterable<T>, f: (v: T) => unknown): AsyncIterable<T>;
export declare function drop<T>(iter: AsyncIterable<T>): AsyncIterable<void>;
export declare function forEnd<T>(iter: AsyncIterable<T>): AsyncIterable<any>;
export declare function breakAt<T>(iter: AsyncIterable<T>, single: AsyncIterable<unknown> | PromiseLike<unknown>): AsyncIterable<T>;
export declare function startAt<T>(iter: AsyncIterable<T>, single: AsyncIterable<unknown> | PromiseLike<unknown>): AsyncIterable<T>;
export declare function push<T>(a: AsyncIterable<T>, ...items: T[]): AsyncIterable<T>;
export declare function unshift<T>(a: AsyncIterable<T>, ...items: T[]): AsyncIterable<T>;
export declare function as<T, U>(a: AsyncIterable<T>): AsyncIterable<U>;
export declare function groupBy<T, K>(a: AsyncIterable<T>, keyf: (v: T) => K): AsyncIterable<[K, T[]]>;
export declare function groupBy<T, K, V>(a: AsyncIterable<T>, keyf: (v: T) => K, valf: (v: T) => V): AsyncIterable<[K, V[]]>;
export declare function toArray<T>(a: AsyncIterable<T>): Promise<T[]>;
export declare function toSet<T>(a: AsyncIterable<T>): Promise<Set<T>>;
export declare function toMap<K, V>(a: AsyncIterable<[K, V]>): Promise<Map<K, V>>;