import { Flu } from "../flu";
import { Voidable } from "../maybe";
import { Option } from "../option";
import { AnyPair, Pair, PairKey, PairValue } from "../types";
import { SeqLinq } from "./linq";
export * from './ops';
export declare function seq<T>(iter: Iterable<T>): Seq<T>;
export declare class Seq<T> implements Iterable<T> {
    readonly iter: () => Iterable<T>;
    constructor(iter: () => Iterable<T>);
    [Symbol.iterator](): Iterator<T>;
    /** Create empty seq */
    static empty<T>(): Seq<T>;
    static by<T>(iter: () => Iterable<T>): Seq<T>;
    static of<T>(...iter: T[]): Seq<T>;
    /** Create a Seq from a range starting from 0 */
    static to(to: number, step?: number): Seq<number>;
    /** Create a Seq from a range */
    static range(from: number, to: number, step?: number): Seq<number>;
    static repeat<T>(v: T, n: number): Seq<T>;
    linq(): SeqLinq<T>;
    flu(): Flu<T>;
    toFlu(): T extends infer R | Promise<infer R> ? Flu<R> : never;
    collect(): T[];
    join(separator?: string): string;
    count(): number;
    isEmpty(): boolean;
    first(): Voidable<T>;
    firstO(): Option<T>;
    last(): Voidable<T>;
    lastO(): Option<T>;
    nth(n: number): Voidable<T>;
    nthO(n: number): Option<T>;
    stepBy(step: number): Seq<T>;
    chain(other: Iterable<T>, ...more: Iterable<T>[]): Seq<T>;
    zip<U>(other: Iterable<U>): Seq<[T, U]>;
    unzip(): [
        (T extends [infer A, any] | readonly [infer A, any] | (infer A)[] ? A : unknown)[],
        (T extends [any, infer B] | readonly [any, infer B] | (infer B)[] ? B : unknown)[]
    ];
    map<R>(f: (v: T) => R): Seq<R>;
    fill<R>(v: R): Seq<R>;
    forEach(f: (v: T) => unknown): void;
    run(): void;
    filter<S extends T>(f: (v: T) => v is S): Seq<S>;
    filter(f: (v: T) => unknown): Seq<T>;
    enumerate(): Seq<[T, number]>;
    indexed(): Seq<[number, T]>;
    skip(n: number): Seq<T>;
    take(n: number): Seq<T>;
    slice(from: number, to: number): Seq<T>;
    sub(from: number, count: number): Seq<T>;
    scan<R>(init: R, f: (acc: R, val: T) => R): Seq<R>;
    flatMap<R>(f: (v: T) => Iterable<R>): Seq<R>;
    flatten(): T extends Iterable<infer R> ? Seq<R> : never;
    also(f: (v: T) => void): Seq<T>;
    fold<R>(init: R, f: (acc: R, val: T) => R): R;
    reduce(f: (acc: T, val: T) => T): T;
    all<S extends T>(f: (v: T) => v is S): this is Seq<S>;
    all(f: (v: T) => unknown): boolean;
    any(f: (v: T) => unknown): boolean;
    find(f: (v: T) => unknown): Voidable<T>;
    findO(f: (v: T) => unknown): Option<T>;
    position(f: (v: T) => unknown): number;
    indexOf(v: T): number;
    includes(v: T): boolean;
    max(): Voidable<T>;
    maxO(): Option<T>;
    min(): Voidable<T>;
    minO(): Option<T>;
    sum(defv: T): T extends number | bigint | string ? T : never;
    sum(): T extends number | bigint | string ? Voidable<T> : never;
    avg(defv: T): T extends number | bigint ? T : never;
    avg(): T extends number | bigint ? Voidable<T> : never;
    push(...items: T[]): Seq<T>;
    unshift(...items: T[]): Seq<T>;
    as<U>(): Seq<U>;
    toArray(): T[];
    toSet(): Set<T>;
    toMap(): T extends AnyPair<infer K, infer V> ? Map<K, V> : never;
    groupBy<K>(keyf: (v: T) => K): Seq<[K, T[]]>;
    groupBy<K, V>(keyf: (v: T) => K, valf: (v: T) => V): Seq<[K, V[]]>;
    relate<I, K>(inner: Iterable<I>, outerKey: (a: T) => K, innerKey: (b: I) => K): Seq<[T, I]>;
    relateMap<I, K, R>(inner: Iterable<I>, outerKey: (a: T) => K, innerKey: (b: I) => K, selector: (a: T, b: I) => R): Seq<R>;
    get arr(): T[];
    mapKey<R>(f: (key: PairKey<T>) => R): T extends AnyPair<any, infer V> ? Seq<Pair<R, V>> : never;
    mapValue<R>(f: (key: PairValue<T>) => R): T extends AnyPair<infer K, any> ? Seq<Pair<K, R>> : never;
}