import './object';
import { MapDelegate, SimpleMapDelegate, IArrayOrderByConfig, IArrayDiff, IMergeWithOptions, GroupingDelegate } from '../models';
import { SortDirections } from '../models/sort';
import { DeepPartial, Record, TypeOf, Upsertable, Updatable } from './global';
import './reflect';
declare type FilterDelegate<T> = (item: T, index: number) => boolean;
declare type UpdateDelegate<T> = MapDelegate<T, DeepPartial<T>>;
declare type CalculationDelegate<T> = (item: T, index: number, prevItem: T, nextItem: T) => number;
declare type DiffMatcherDelegate<T, P> = (sourceItem: T, targetItem: P, sourceIndex: number, targetIndex: number) => boolean;
declare type RemoveNull<T> = Exclude<T, null | undefined>;
declare type FlattenedArray<Arr> = Arr extends unknown[] ? (Arr extends unknown[][] ? FlattenedArray<Arr[number]> : Arr) : Arr[];
export declare class ArrayExtensions<T> {
    mapMany<V>(map: MapDelegate<T, V[]>): V[];
    flatten(): FlattenedArray<T>;
    groupBy<K>(groupingDelegate: GroupingDelegate<T, K>): Map<K, T[]>;
    ofType<V>(type: TypeOf<V>): V[];
    ofType(type: 'string'): string[];
    ofType(type: 'number'): number[];
    cast<V>(): V[];
    single(): T | undefined;
    single(filter: FilterDelegate<T>): T | undefined;
    first(): T | undefined;
    first(filter: FilterDelegate<T>): T | undefined;
    last(): T | undefined;
    last(filter: FilterDelegate<T>): T | undefined;
    clone(): T[];
    remove(item: T): T[];
    removeMany(items: T[]): T[];
    removeAt(index: number): T[];
    removeByFilter(filter: FilterDelegate<T>): T[];
    removeById(id: string): T[];
    indexOfId(id: string): number;
    findById(id: string): T | undefined;
    upsert(item: Upsertable<T>): T[];
    upsert(item: Upsertable<T>, index: number): T[];
    upsertMany(this: T[], items: Upsertable<T>[], newIndex?: number): T[];
    upsertWhere(filter: FilterDelegate<T>, update: UpdateDelegate<T | undefined>): T[];
    replace(item: T): T[];
    replace(item: T, index: number): T[];
    replaceMany(items: T[]): T[];
    replaceMany(items: T[], index: number): T[];
    update(item: Updatable<T & Record>): T[];
    update(filter: FilterDelegate<T>, update: UpdateDelegate<T>): T[];
    insert(item: T): T[];
    insert(item: T, index: number): T[];
    chunk(size: number): T[][];
    clear(): void;
    move(from: number, to: number): T[];
    orderBy<R>(sorterDelegate: SimpleMapDelegate<T, R>): T[];
    orderBy<R>(sorterDelegate: SimpleMapDelegate<T, R>, direction: SortDirections): T[];
    orderBy(config: IArrayOrderByConfig<T>[]): T[];
    removeNull(): RemoveNull<T>[];
    except(array: T[]): T[];
    except<U extends Record>(array: U[]): T[];
    distinct(): T[];
    distinct<V>(delegate: MapDelegate<T, V>): T[];
    equals(array: T[]): boolean;
    equals(array: T[], ignoreOrder: boolean): boolean;
    sum(): number;
    sum(delegate: CalculationDelegate<T>): number;
    min(): number;
    min(delegate: CalculationDelegate<T>): number;
    max(): number;
    max(delegate: CalculationDelegate<T>): number;
    average(): number;
    average(delegate: CalculationDelegate<T>): number;
    aggregate(method: 'sum' | 'max' | 'min' | 'average'): number;
    aggregate(method: 'sum' | 'max' | 'min' | 'average', delegate: CalculationDelegate<T>): number;
    absorb(array: T[]): T[];
    any(): T;
    takeUntil(this: T[], delegate: FilterDelegate<T>): T[];
    takeUntil(this: T[], delegate: FilterDelegate<T>, andIncluding: boolean): T[];
    diff<P extends Record>(items: P[]): IArrayDiff<T, P>;
    diff<P>(items: P[], matcher: DiffMatcherDelegate<T, P>): IArrayDiff<T, P>;
    ids(): string[];
    mergeWith<P>(items: P[]): T[];
    mergeWith<P>(items: P[], options: IMergeWithOptions<T, P>): T[];
    syncWith<P>(items: P[]): T[];
    syncWith<P>(items: P[], options: IMergeWithOptions<T, P>): T[];
    take(count: number): T[];
    takeLast(count: number): T[];
    skip(count: number): T[];
    toMap(): Map<string, T>;
    toMap<K>(createKey: (item: T, index: number, array: T[]) => K): Map<K, T>;
    toSet(): Set<T>;
}
export declare class ArrayConstructorExtensions {
    ofSize<T = any>(length: number): T[];
    empty(): Readonly<any[]>;
}
export {};