interface Mapper<T, U> {
    (x: T): U;
}
interface FlatMapper<T, U> {
    (x: T): Iterable<U>;
}
interface Predicate<T> {
    (x: T): boolean;
}
interface Guard<T, U extends T> {
    (a: T): a is U;
}
interface Reducer<T, U> {
    (acc: U, x: T): U;
}
interface Collector<T, U> {
    from: (i: Iterable<T>) => U;
}
/**
 * Useful operators for Iterables.
 *
 * The module exports the class `Seq` which creates a wrapper that exposes
 * a fluent interface for traversing and manipulating the underlying iterable
 * object using operators.
 *
 * The module also exports each operator as a function for use in isolation.
 *
 * All methods and functions return a new Iterable object. Iteration is lazy
 * and will only execute when a value is requested (toArray, reduce, etc).
 * The iteration will terminate as early as possible.
 *
 * For example, the following `Seq` code will only iterate 3 times:
 *
 *    let array = [];
 *    for (let i = 1; i <= 1000; i++) {
 *      array.push(i);
 *    }
 *
 *    // 3 iterations
 *    Seq.from(array)
 *      .map(n => n * n)
 *      .filter(n => n % 2 === 1)
 *      .takeUntil(n => n > 30)
 *      .toArray() // [ 1, 9, 25 ]
 *
 */
/**
 * Wraps `iterable` in an object with collection operations.
 */
export declare class Seq<T> {
    private _iterable;
    private static readonly EMPTY;
    static empty<T>(): Seq<T>;
    static of<T>(...values: T[]): Seq<T>;
    static from<T>(iterable: Iterable<T>): Seq<T>;
    static concat<T>(...iterables: Iterable<T>[]): Seq<T>;
    private _iterator?;
    private readonly _cache;
    private constructor();
    [Symbol.iterator](): Generator<any, void, undefined>;
    concat(...iterables: Iterable<T>[]): Seq<any>;
    map<U>(fn: Mapper<T, U>): Seq<U>;
    flatMap<U>(fn: FlatMapper<T, U>): Seq<U>;
    uniq(): Seq<any>;
    uniqBy<U>(fn: Mapper<T, U>): Seq<any>;
    orderBy<U>(fn: Mapper<T, U>, reverse?: boolean): Seq<T>;
    filter<U extends T>(fn: Guard<T, U>): Seq<U>;
    filter(fn: Predicate<T>): Seq<T>;
    take(n: number): Seq<any>;
    takeLast(n: number): Seq<any>;
    takeWhile<U extends T>(fn: Guard<T, U>): Seq<U>;
    takeWhile(fn: Predicate<T>): Seq<T>;
    drop(n: number): Seq<any>;
    dropLast(n: number): Seq<any>;
    dropWhile<U extends T>(fn: Guard<T, U>): Seq<U>;
    dropWhile(fn: Predicate<T>): Seq<T>;
    find<U extends T>(fn: Guard<T, U>): U;
    find(fn: Predicate<T>): T;
    findLast<U extends T>(fn: Guard<T, U>): U;
    findLast(fn: Predicate<T>): T;
    every(fn: Predicate<T>): boolean;
    some(fn: Predicate<T>): boolean;
    includes(item: T): boolean;
    reduce<U>(fn: Reducer<T, U>, value: U): U;
    join(separator: string): string;
    toArray(): T[];
    into<U>(Collector: Collector<T, U>): U;
    first(): any;
    last(): any;
    rest(): Generator<any, void, unknown>;
    isEmpty(): boolean;
    forEach(fn: (t: T) => void): this;
    groupBy<S>(fn: (t: T) => S): Seq<[S, T[]]>;
}
export declare function concat<T>(...iterables: Iterable<T>[]): Generator<T, void, undefined>;
export declare function map<T, U>(fn: Mapper<T, U>, iterable: Iterable<T>): Generator<U, void, unknown>;
export declare function flatMap<T, U>(fn: FlatMapper<T, U>, iterable: Iterable<T>): Generator<U, void, undefined>;
export declare function uniq<T>(iterable: Iterable<T>): Generator<any, void, unknown>;
export declare function uniqBy<T, U>(fn: Mapper<T, U>, iterable: Iterable<T>): Generator<any, void, unknown>;
export declare function filter<T, U extends T>(fn: Guard<T, U>, iterable: Iterable<T>): Iterable<U>;
export declare function filter<T>(fn: Predicate<T>, iterable: Iterable<T>): Iterable<T>;
export declare function take<T>(n: number, iterable: Iterable<T>): Generator<any, void, unknown>;
/**
 * Take the last `n` elements of `iterable`
 */
export declare function takeLast<T>(n: number, iterable: Iterable<T>): Generator<T, void, undefined>;
/**
 * Keep items until test returns false.
 */
export declare function takeWhile<T, U extends T>(fn: Guard<T, U>, iterable: Iterable<T>): Iterable<U>;
export declare function takeWhile<T>(fn: Predicate<T>, iterable: Iterable<T>): Iterable<T>;
export declare function drop<T>(n: number, iterable: Iterable<T>): Generator<any, void, unknown>;
export declare function dropLast<T>(n: number, iterable: Iterable<T>): Generator<T, void, undefined>;
/**
 * Ignore items until test returns false.
 */
export declare function dropWhile<T, U extends T>(fn: Guard<T, U>, iterable: Iterable<T>): Iterable<U>;
export declare function dropWhile<T>(fn: Predicate<T>, iterable: Iterable<T>): Iterable<T>;
/**
 * Find the first item that test returns true for.
 */
export declare function find<T, U extends T>(test: Guard<T, U>, iterable: Iterable<T>): U;
export declare function find<T>(test: Predicate<T>, iterable: Iterable<T>): T;
/**
 * Find the last item that the test returns true for.
 */
export declare function findLast<T, U extends T>(test: Guard<T, U>, iterable: Iterable<T>): U;
export declare function findLast<T>(test: Predicate<T>, iterable: Iterable<T>): T;
export declare function first<T>(iterable: Iterable<T>): any;
export declare function last<T>(iterable: Iterable<T>): void | T;
export declare function rest<T>(iterable: Iterable<T>): Generator<any, void, unknown>;
export declare function includes<T>(item: T, iterable: Iterable<T>): boolean;
export declare function every<T>(test: Predicate<T>, iterable: Iterable<T>): boolean;
export declare function some<T>(test: Predicate<T>, iterable: Iterable<T>): boolean;
/**
 * Reduce collection to a single value.
 */
export declare function reduce<T, U>(fn: Reducer<T, U>, seedValue: U, iterable: Iterable<T>): U;
export declare function join<T>(separator: string, iterable: Iterable<T>): string;
export {};
//# sourceMappingURL=IterableUtils.d.ts.map