import { GenericType } from "../Common/Type";
export declare const keyComparer: <T = any>(a: T, b: T) => boolean;
export declare class Enumerable<T = any> implements Iterable<T> {
    static from<T>(source: Iterable<T> | (() => IterableIterator<T>)): Enumerable<T>;
    static range(start: number, end: number, step?: number): Enumerable<number>;
    protected parent: Iterable<any>;
    protected cache: IEnumerableCache<T>;
    enableCache: any;
    constructor(source?: Iterable<any> | (() => IterableIterator<T>));
    [Symbol.iterator](): IterableIterator<T>;
    private cachedGenerator;
    protected generator(): IterableIterator<any>;
    toArray(): T[];
    toMap<K, V = T>(keySelector: (item: T) => K, valueSelector?: (item: T) => V): Map<K, V>;
    all(predicate: (item: T) => boolean): boolean;
    any(predicate?: (item: T) => boolean): boolean;
    first(predicate?: (item: T) => boolean): T | null;
    count(predicate?: (item: T) => boolean): number;
    sum(selector?: (item: T) => number): number;
    avg(selector?: (item: T) => number): number;
    max(selector?: (item: T) => number): number;
    min(selector?: (item: T) => number): number;
    contains(item: T): boolean;
    ofType<T>(type: GenericType<T>): Enumerable<T>;
    each(executor: (item: T, index: number) => void): void;
    reduce<R>(func: (accumulated: R, item: T) => R): R;
    reduce<R>(seed: R, func: (accumulated: R, item: T) => R): R;
}
import "./Enumerable.partial";
import "../Extensions/EnumerableExtension";
import "../Extensions/ArrayExtension";
import { IEnumerableCache } from "./IEnumerableCache";