import { KeysOfType, Dict } from '@ts-std/types';
import { Result, Maybe } from '@ts-std/monads';
import { Indexable } from './common';
export declare type MapFunc<T, U> = (element: T, index: number, array: T[]) => U;
export declare type Unzip<L extends any[]> = {
    [K in keyof L]: L[K][];
};
export declare type ValueProducer<T, U> = KeysOfType<T, U> | MapFunc<T, U>;
export declare type SimpleProducer<T, U> = KeysOfType<T, U> | ((value: T) => U);
declare global {
    interface Array<T> {
        sum(this: number[]): number;
        sum(this: T[], key: ValueProducer<T, number>): number;
        push_all(this: T[], ...others: T[][]): void;
        filter_map<U>(this: T[], fn: MapFunc<T, U | undefined>): U[];
        flat_map<U>(this: T[], fn: MapFunc<T, U[]>): U[];
        try_map<U, E>(this: T[], fn: MapFunc<T, Result<U, E>>): Result<U[], E>;
        maybe_map<U>(this: T[], fn: MapFunc<T, Maybe<U>>): Maybe<U[]>;
        index_map<U>(this: T[], fn: MapFunc<T, [Indexable, U]>): Dict<U>;
        unique_index_map<U>(this: T[], fn: MapFunc<T, [Indexable, U]>): Result<Dict<U>, [string, T, T]>;
        maybe_find(this: T[], fn: MapFunc<T, boolean>): Maybe<T>;
        maybe_get(this: T[], index: number): Maybe<T>;
        wrapping_get(this: T[], index: number): Maybe<T>;
        index_by(this: T[], arg: ValueProducer<T, Indexable>): Dict<T>;
        unique_index_by(this: T[], arg: ValueProducer<T, Indexable>): Result<Dict<T>, [string, T, T]>;
        group_by(this: T[], arg: ValueProducer<T, Indexable>): Dict<T[]>;
        group_by_map<U>(this: T[], arg: MapFunc<T, [Indexable, U]>): Dict<U[]>;
        split_by(this: T[], predicate: ValueProducer<T, boolean>): [T[], T[]];
        split_by_map<U>(this: T[], predicate: MapFunc<T, [boolean, U]>): [U[], U[]];
        entries_to_dict<T>(this: [string, T][]): Dict<T>;
        unique_entries_to_dict<T>(this: [string, T][]): Result<Dict<T>, [string, T, T]>;
        unzip<L extends any[]>(this: L[]): Maybe<Unzip<L>>;
        sort_by(this: T[], key: SimpleProducer<T, number | string>, order?: 'asc' | 'desc'): T[];
        mutate_sort_by(this: T[], key: SimpleProducer<T, number | string>, order?: 'asc' | 'desc'): T[];
    }
    interface ArrayConstructor {
        zip_lenient<L extends any[]>(...arrays: Unzip<L>): L[];
        zip_equal<L extends any[]>(...arrays: Unzip<L>): Result<L[], [number, number]>;
    }
}
export declare function make_key_accessor<T, U>(arg: ValueProducer<T, U>): MapFunc<T, U>;