export * from './_types';
import { ConstructorFor, KeyValuePair, Predicate, Selector, Undefinable } from "../Types";
import { IComparer } from '../Comparers/_types';
import { IEnumerable, IEnumerableGroup, IDictionary, IList, ICollection, ISet, IEnumerableOrArray } from './_types';
import { IEnumerator } from '../Enumerators/_types';
export declare class Enumerable {
    static range(start: number, count: number): IEnumerable<number>;
    static empty<TElement>(): IEnumerable<TElement>;
    static asArray<T>(enumerableOrArray: IEnumerableOrArray<T>): T[];
    static asEnumerable<T>(enumerableOrArray: IEnumerableOrArray<T>): IEnumerable<T>;
}
export declare abstract class EnumerableBase<T> implements IEnumerable<T> {
    [Symbol.iterator](): Iterator<T>;
    abstract getEnumerator(): IEnumerator<T>;
    append(item: T): IEnumerable<T>;
    concat(next: IEnumerable<T>): IEnumerable<T>;
    prepend(item: T): IEnumerable<T>;
    contains(item: T): boolean;
    forEach(callback: (value: T, index: number) => boolean | void): void;
    item(index: number): Undefinable<T>;
    all(predicate: Predicate<T>): boolean;
    any(predicate?: Predicate<T>): boolean;
    average(selector: Selector<T, number>): number;
    count(): number;
    distinct<R>(selector: (a: T) => R): IEnumerable<T>;
    first(predicate?: Predicate<T>): T;
    firstOrDefault(predicate?: Predicate<T>): T | null;
    groupBy<TKey>(selector: Selector<T, TKey>, comparer?: IComparer<TKey>): IEnumerable<IEnumerableGroup<T, TKey>>;
    last(predicate?: Predicate<T>): T;
    lastOrDefault(predicate?: Predicate<T>): T | null;
    max(selector: Selector<T, number>): number;
    min(selector: Selector<T, number>): number;
    ofType<N extends T>(ctor: ConstructorFor<N>): IEnumerable<N>;
    orderBy<R>(selector: (a: T) => R, comparer?: IComparer<R>): IEnumerable<T>;
    orderByDescending<R>(selector: (a: T) => R, comparer?: IComparer<R>): IEnumerable<T>;
    select<TOut>(selector: Selector<T, TOut>): IEnumerable<TOut>;
    selectMany<TOut>(selector: Selector<T, IEnumerable<TOut>>): IEnumerable<TOut>;
    single(predicate?: Predicate<T>): T;
    singleOrDefault(predicate?: Predicate<T>): T | null;
    skip(count: number): IEnumerable<T>;
    split(predicate: Predicate<T>): {
        pTrue: IEnumerable<T>;
        pFalse: IEnumerable<T>;
    };
    sum(selector: Selector<T, number>): number;
    take(count: number): IEnumerable<T>;
    where(predicate: Predicate<T>): IEnumerable<T>;
    toArray(): T[];
    toDictionary<TKey, TValue>(keySelector: (a: T) => TKey, valueSelector: (a: T) => TValue): IDictionary<TKey, TValue>;
    toList(): IList<T>;
    private internalOrderBy;
}
export declare class ArrayEnumerable<T> implements IEnumerable<T> {
    [Symbol.iterator](): Iterator<T, unknown, undefined>;
    protected _array: T[];
    constructor(array: T[]);
    /**@inheritDoc */
    all(predicate: Predicate<T>): boolean;
    /**@inheritDoc */
    append(item: T): IEnumerable<T>;
    /**@inheritDoc */
    any(predicate?: Predicate<T> | undefined): boolean;
    /**@inheritDoc */
    average(selector: Selector<T, number>): number;
    /**@inheritDoc */
    concat(next: IEnumerable<T>): IEnumerable<T>;
    /**@inheritDoc */
    contains(item: T): boolean;
    /**@inheritDoc */
    count(): number;
    /**@inheritDoc */
    distinct<R>(selector: Selector<T, R>): IEnumerable<T>;
    /**@inheritDoc */
    first(predicate?: Predicate<T>): T;
    /**@inheritDoc */
    firstOrDefault(predicate?: Predicate<T>): T | null;
    /**@inheritDoc */
    forEach(callback: (value: T, index: number) => boolean | void): void;
    /**@inheritDoc */
    getEnumerator(): IEnumerator<T>;
    /**@inheritDoc */
    groupBy<TKey>(keySelector: Selector<T, TKey>, comparer?: IComparer<TKey>): IEnumerable<IEnumerableGroup<T, TKey>>;
    /**@inheritDoc */
    item(index: number): Undefinable<T>;
    /**@inheritDoc */
    last(predicate?: Predicate<T>): T;
    /**@inheritDoc */
    lastOrDefault(predicate?: Predicate<T>): T | null;
    /**@inheritDoc */
    max(selector: Selector<T, number>): number;
    /**@inheritDoc */
    min(selector: Selector<T, number>): number;
    /**@inheritDoc */
    ofType<N extends T>(ctor: ConstructorFor<N>): IEnumerable<N>;
    /**@inheritDoc */
    orderBy<R>(selector: Selector<T, R>, comparer?: IComparer<R> | undefined): IEnumerable<T>;
    /**@inheritDoc */
    orderByDescending<R>(selector: Selector<T, R>, comparer?: IComparer<R> | undefined): IEnumerable<T>;
    private internalOrderBy;
    /**@inheritDoc */
    prepend(item: T): IEnumerable<T>;
    /**@inheritDoc */
    select<TOut>(selector: Selector<T, TOut>): IEnumerable<TOut>;
    /**@inheritDoc */
    selectMany<TOut>(selector: Selector<T, IEnumerable<TOut>>): IEnumerable<TOut>;
    /**@inheritDoc */
    single(predicate?: Predicate<T>): T;
    /**@inheritDoc */
    singleOrDefault(predicate?: Predicate<T>): T | null;
    /**@inheritDoc */
    skip(count: number): IEnumerable<T>;
    /**@inheritDoc */
    split(predicate: Predicate<T>): {
        pTrue: IEnumerable<T>;
        pFalse: IEnumerable<T>;
    };
    /**@inheritDoc */
    sum(selector: Selector<T, number>): number;
    /**@inheritDoc */
    take(count: number): IEnumerable<T>;
    /**@inheritDoc */
    toArray(): T[];
    /**@inheritDoc */
    toDictionary<TKey, TValue>(keySelector: (a: T) => TKey, valueSelector: (a: T) => TValue): IDictionary<TKey, TValue>;
    /**@inheritDoc */
    toList(): IList<T>;
    /**@inheritDoc */
    where(predicate: Predicate<T>): IEnumerable<T>;
}
export declare class Collection<T> extends ArrayEnumerable<T> implements ICollection<T>, IEnumerable<T> {
    constructor(enumerableOrArray?: IEnumerableOrArray<T>);
    get isReadOnly(): boolean;
    add(obj: T): void;
    get length(): number;
    clear(): void;
    copyTo(array: T[], arrayIndex: number): void;
    remove(item: T): boolean;
}
export declare class Dictionary<TKey, TValue> extends EnumerableBase<KeyValuePair<TKey, TValue>> implements IDictionary<TKey, TValue>, ICollection<KeyValuePair<TKey, TValue>>, IEnumerable<KeyValuePair<TKey, TValue>> {
    #private;
    readonly isReadOnly: boolean;
    constructor(enumerableOrArray?: IEnumerableOrArray<KeyValuePair<TKey, TValue>>);
    get length(): number;
    get keys(): TKey[];
    get values(): TValue[];
    add(keyValuePair: KeyValuePair<TKey, TValue>): void;
    addKeyValue(key: TKey, value: TValue): void;
    itemByKey(key: TKey): TValue;
    containsKey(key: TKey): boolean;
    removeByKey(key: TKey): boolean;
    tryGetValue(key: TKey): {
        value?: TValue;
        success: boolean;
    };
    clear(): void;
    remove(item: KeyValuePair<TKey, TValue>): boolean;
    contains(item: KeyValuePair<TKey, TValue>): boolean;
    copyTo(array: KeyValuePair<TKey, TValue>[], arrayIndex: number): void;
    getEnumerator(): IEnumerator<KeyValuePair<TKey, TValue>>;
}
export declare class EnumeratorEnumerable<T> extends EnumerableBase<T> {
    #private;
    constructor(enumerator: IEnumerator<T>);
    getEnumerator(): IEnumerator<T>;
}
export declare class LinkedList<T> extends EnumerableBase<T> implements ICollection<T>, IEnumerable<T> {
    #private;
    constructor(enumerableOrArray?: IEnumerableOrArray<T>);
    append(item: T): IEnumerable<T>;
    concat(next: IEnumerable<T>): IEnumerable<T>;
    prepend(item: T): IEnumerable<T>;
    get length(): number;
    get isReadOnly(): boolean;
    add(item: T): void;
    clear(): void;
    contains(item: T): boolean;
    copyTo(array: T[], arrayIndex: number): void;
    remove(item: T): boolean;
    forEach(callback: (value: T, index: number) => boolean | void): void;
    getEnumerator(): IEnumerator<T>;
    item(index: number): Undefinable<T>;
    ofType<N extends T>(ctor: new (...args: unknown[]) => N): IEnumerable<N>;
    toArray(): T[];
    toDictionary<TKey, TValue>(keySelector: (a: T) => TKey, valueSelector: (a: T) => TValue): IDictionary<TKey, TValue>;
    toList(): IList<T>;
    /**
     * Traverse the collection, return false in the callback to break. return true or undefined to continue.
     * @param node
     * @param callback
     */
    private traverse;
}
export declare class List<T> extends Collection<T> implements IList<T>, ICollection<T>, IEnumerable<T> {
    addRange(enumerableOrArray: IEnumerableOrArray<T>): void;
    find(obj: T, isEquivilent?: boolean): T | undefined;
    indexOf(value: T, isEquivilent?: boolean): number | undefined;
    insert(obj: T, index: number): void;
    prepend(obj: T): IEnumerable<T>;
    prependRange(enumerableOrArray: IEnumerableOrArray<T>): void;
    removeAt(index: number): void;
    sort(comparer?: IComparer<T>): void;
}
export default class Set<T> extends Collection<T> implements ISet<T>, ICollection<T>, IEnumerable<T> {
    constructor(enumerable?: IEnumerable<T>);
    get length(): number;
    get isReadOnly(): boolean;
    append(item: T): IEnumerable<T>;
    concat(next: IEnumerable<T>): IEnumerable<T>;
    prepend(item: T): IEnumerable<T>;
    exceptWith(enumerable: IEnumerable<T>): void;
    intersectWith(enumerable: IEnumerable<T>): void;
    isSubsetOf(enumerable: IEnumerable<T>): boolean;
    isSupersetOf(enumerable: IEnumerable<T>): boolean;
    overlaps(enumerable: IEnumerable<T>): boolean;
    setEquals(enumerable: IEnumerable<T>): boolean;
    symmetricExceptWith(enumerable: IEnumerable<T>): void;
    unionWith(enumerable: IEnumerable<T>): void;
    /**
     * Adds an item to the ICollection<T>.
     * @param item The object to add to the ICollection<T>.
     * @throws {ArgumentException} When the item is already in the collection.
     */
    add(item: T): void;
    clear(): void;
    contains(item: T): boolean;
    copyTo(array: T[], arrayIndex: number): void;
    remove(item: T): boolean;
    forEach(callback: (value: T, index: number) => boolean | void): void;
    getEnumerator(): IEnumerator<T>;
    item(index: number): Undefinable<T>;
    ofType<N extends T>(ctor: new (...args: unknown[]) => N): IEnumerable<N>;
    toArray(): T[];
    toDictionary<TKey, TValue>(keySelector: (a: T) => TKey, valueSelector: (a: T) => TValue): IDictionary<TKey, TValue>;
    toList(): IList<T>;
}