import "./Map.ext";
import { Type } from "../types/type/Type";
import { WrappedType } from "../types/wrap/WrappedType";
import { DateOnly } from "../types/date-time/DateOnly";
import { DateTime } from "../types/date-time/DateTime";
import { Time } from "../types/date-time/Time";
interface IReadonlyArrayExt<T> {
    single(predicate?: (item: T, index: number) => boolean): T | undefined;
    first(predicate?: (item: T, index: number) => boolean): T | undefined;
    filterAsync(predicate: (item: T, index: number) => Promise<boolean>): Promise<T[]>;
    last(predicate?: (item: T, index: number) => boolean): T | undefined;
    filterExists(): NonNullable<T>[];
    ofType<N extends T>(type: Type<WrappedType<N>>): N[];
    mapAsync<R>(selector: (item: T, index: number) => Promise<R>): Promise<R[]>;
    mapMany(): T;
    mapMany<R>(selector: (item: T, index: number) => R[]): R[];
    mapManyAsync<R>(selector: (item: T, index: number) => Promise<R[]>): Promise<R[]>;
    parallelAsync<R>(fn: (item: T, index: number) => Promise<R>): Promise<R[]>;
    groupBy<K>(keySelector: (item: T, index: number) => K): {
        key: K;
        values: T[];
    }[];
    groupBy<K, V>(keySelector: (item: T, index: number) => K, valueSelector: (item: T, index: number) => V): {
        key: K;
        values: V[];
    }[];
    toMap<K>(keySelector: (item: T, index: number) => K): Map<K, T>;
    toMap<K, V>(keySelector: (item: T, index: number) => K, valueSelector: (item: T, index: number) => V): Map<K, V>;
    toMapAsync<K>(keySelector: (item: T, index: number) => Promise<K>): Promise<Map<K, T>>;
    toMapAsync<K, V>(keySelector: (item: T, index: number) => Promise<K> | K, valueSelector: (item: T, index: number) => Promise<V> | V): Promise<Map<K, V>>;
    toArrayMap<K>(keySelector: (item: T, index: number) => K): Map<K, T[]>;
    toArrayMap<K, V>(keySelector: (item: T, index: number) => K, valueSelector: (item: T, index: number) => V): Map<K, V[]>;
    toSetMap<K>(keySelector: (item: T, index: number) => K): Map<K, Set<T>>;
    toSetMap<K, V>(keySelector: (item: T, index: number) => K, valueSelector: (item: T, index: number) => V): Map<K, Set<V>>;
    toMapValues<K, V>(keySelector: (item: T, index: number) => K, valueSelector: (items: T[]) => V): Map<K, V>;
    toObject(keySelector: (item: T, index: number) => string): Record<string, T>;
    toObject<V>(keySelector: (item: T, index: number) => string, valueSelector: (item: T, index: number) => V): Record<string, V>;
    toTree<K extends keyof T, P extends keyof T>(keyProp: K, parentKey: P): ITreeArray<T>[];
    distinct(matchAddress?: boolean): T[];
    orderBy(selector?: (item: T) => string | number | DateOnly | DateTime | Time | undefined): T[];
    orderByDesc(selector?: (item: T) => string | number | DateOnly | DateTime | Time | undefined): T[];
    diffs<P>(target: P[], options?: {
        keys?: string[];
        excludes?: string[];
    }): TArrayDiffsResult<T, P>[];
    oneWayDiffs<K extends keyof T>(orgItems: T[] | Map<T[K], T>, keyPropNameOrFn: K | ((item: T) => K), options?: {
        includeSame?: boolean;
        excludes?: string[];
        includes?: string[];
    }): TArrayDiffs2Result<T>[];
    merge<P>(target: P[], options?: {
        keys?: string[];
        excludes?: string[];
    }): (T | P | (T & P))[];
    sum(selector?: (item: T, index: number) => number): number;
    min(): T extends number | string ? T | undefined : never;
    min<P extends number | string>(selector?: (item: T, index: number) => P): P | undefined;
    max(): T extends number | string ? T | undefined : never;
    max<P extends number | string>(selector?: (item: T, index: number) => P): P | undefined;
    shuffle(): T[];
}
interface IMutableArrayExt<T> {
    distinctThis(matchAddress?: boolean): T[];
    orderByThis(selector?: (item: T) => string | number | DateOnly | DateTime | Time | undefined): T[];
    orderByDescThis(selector?: (item: T) => string | number | DateOnly | DateTime | Time | undefined): T[];
    insert(index: number, ...items: T[]): this;
    remove(item: T): this;
    remove(selector: (item: T, index: number) => boolean): this;
    toggle(item: T): this;
    clear(): this;
}
declare global {
    interface ReadonlyArray<T> extends IReadonlyArrayExt<T> {
    }
    interface Array<T> extends IReadonlyArrayExt<T>, IMutableArrayExt<T> {
    }
}
export type TArrayDiffsResult<T, P> = {
    source: undefined;
    target: P;
} | {
    source: T;
    target: undefined;
} | {
    source: T;
    target: P;
};
export type TArrayDiffs2Result<T> = {
    type: "create";
    item: T;
    orgItem: undefined;
} | {
    type: "update";
    item: T;
    orgItem: T;
} | {
    type: "same";
    item: T;
    orgItem: T;
};
export type ITreeArray<T> = T & {
    children: ITreeArray<T>[];
};
export {};