import { Flu } from '../flu';
import { Voidable } from '../maybe';
import { Seq } from '.';
export { filter as where, all, any, includes as contains, map as select, flatMap as selectMany, zip, skip, take, relateMap as join, relate as joinPair, groupBy, nth as elementAt, first, last, find as single, as as cast, toArray, toMap, toSet, chain as concat, fold as aggregate, avg as average, count, min, max, sum } from './ops';
export declare class SeqLinq<T> implements Iterable<T> {
    readonly iter: () => Iterable<T>;
    constructor(iter: () => Iterable<T>);
    [Symbol.iterator](): Iterator<T>;
    static empty<T>(): SeqLinq<T>;
    /** Create a SeqLinq from a range starting from 0 */
    static to(to: number, step?: number): SeqLinq<number>;
    /** Create a SeqLinq from a range */
    static range(from: number, to: number, step?: number): SeqLinq<number>;
    static repeat<T>(v: T, n: number): SeqLinq<T>;
    seq(): Seq<T>;
    flu(): Flu<T>;
    toFlu(): T extends infer R | Promise<infer R> ? Flu<R> : never;
    where(f: (v: T) => unknown): Iterable<T>;
    all<S extends T>(f: (v: T) => v is S): this is SeqLinq<S>;
    all(f: (v: T) => unknown): boolean;
    any(f: (v: T) => unknown): boolean;
    contains(v: T): boolean;
    select<R>(f: (v: T) => R): SeqLinq<R>;
    selectMany<R>(f: (v: T) => Iterable<R>): SeqLinq<R>;
    zip<U>(other: Iterable<U>): SeqLinq<[T, U]>;
    skip(n: number): SeqLinq<T>;
    take(n: number): SeqLinq<T>;
    join<I, K, R>(inner: Iterable<I>, outerKey: (a: T) => K, innerKey: (b: I) => K, selector: (a: T, b: I) => R): SeqLinq<R>;
    joinPair<I, K>(inner: Iterable<I>, outerKey: (a: T) => K, innerKey: (b: I) => K): SeqLinq<[T, I]>;
    groupBy<K>(keyf: (v: T) => K): SeqLinq<[K, T[]]>;
    groupBy<K, V>(keyf: (v: T) => K, valf: (v: T) => V): SeqLinq<[K, V[]]>;
    elementAt(n: number): Voidable<T>;
    first(): Voidable<T>;
    last(): Voidable<T>;
    find(f: (v: T) => unknown): Voidable<T>;
    cast<U>(): SeqLinq<U>;
    toArray(): T[];
    toSet(): Set<T>;
    toMap(): T extends [infer K, infer V] ? Map<K, V> : never;
    concat(other: Iterable<T>, ...more: Iterable<T>[]): SeqLinq<T>;
    aggregate<R>(init: R, f: (acc: R, val: T) => R): R;
    average(defv: T): T extends number | bigint ? T : never;
    average(): T extends number | bigint ? Voidable<T> : never;
    count(): number;
    min(): Voidable<T>;
    max(): Voidable<T>;
    sum(defv: T): T extends number | bigint | string ? T : never;
    sum(): T extends number | bigint | string ? Voidable<T> : never;
}