import './xArrayD';
export declare class ArrayX<T> extends Array<T> implements IArray<T> {
    xAdd(...items: T[]): void;
    get xCount(): number;
    xClone(): T[];
    xSelect<TReturn>(func: (item: T, index?: number, items?: T[]) => TReturn): TReturn[];
    xSelectMany<TReturn>(func: (arg: T) => TReturn[]): TReturn[];
    xWhere(checker: (arg: T, index?: number) => boolean): T[];
    xInsert(index: number, ...items: T[]): void;
    xSort(comparer: (a: T, b: T) => number): T[];
    xSortInPlace(comparer: (a: T, b: T) => number): T[];
    xReverse(): T[];
    xReverseInPlace(): T[];
    xIsAny(checker?: (arg: T) => boolean): boolean;
    xAreAll(checker: (arg: T) => boolean): boolean;
    xIsEmpty(): boolean;
    xFirst(checker?: (i: T) => boolean): T | undefined;
    xFirstIndex(checker: (i: T) => boolean): number;
    xLastIndex(checker: (i: T) => boolean): number;
    xCast<T2>(): T2[];
    xHasTheSameItemsAs(another: T[]): boolean;
    xLast(checker?: (i: T) => boolean): T | undefined;
    xEnsure(item: T): T;
    xUnion(another: T[]): T[];
    xRemoveAt(index: number): {
        removed: T[];
    };
    xExcept(another: T[]): T[];
    xOfType<TResult>(type: new (...args: any[]) => TResult): TResult[];
    xIntersect(another: T[]): T[];
    xIntersects(another: T[]): boolean;
    xReset(): void;
    xToItemIndecesMap(): Map<T, number[]>;
    xReplaceRange(range: {
        start: number;
        end: number;
    } | {
        start: number;
        count: number;
    }, replacement: T[]): {
        removed: T[];
    };
    xRemoveWhere(selector: (item: T) => boolean): {
        removed: T[];
    };
    xToMap<TKey>(keySelector: (item: T) => TKey): Map<TKey, T[]>;
    xContains(item: T): boolean;
    xDistinct(): T[];
}
//# sourceMappingURL=xArray.d.ts.map