import { CompareResult } from './compare';
import { Maybe } from './maybe';
/**
* inplace delete all element from the array
* @return old elements
* */
export declare function clearArray(xs: A[]): A[];
/**
* inplace replace all element in the array
* @return the old elements
* */
export declare function replaceArray(dest: A[], src: A[]): A[];
/**
* only use `===` to compare
* @warning slow
* @return new array
* */
export declare function unique(xs: A[]): A[];
export declare function rightMost(n: number, xs: A[]): A[];
export declare function leftMost(n: number, xs: A[]): A[];
/** inplace update */
export declare function popN(n: number, xs: any[]): void;
/** inplace update */
export declare function popUntilN(n: number, xs: any[]): void;
/** inplace update */
export declare function shiftN(n: number, xs: any[]): void;
/** inplace update */
export declare function shiftUntilN(n: number, xs: any[]): void;
export declare function last(xs: ArrayLike, skipCheck?: boolean): A;
export declare function maybeLast(xs: A[]): Maybe;
export declare function fromFileList(files: FileList): File[];
export declare function array_contains(xs: A[], x: A): boolean;
export declare function insert(xs: A[], index: number, x: A): void;
export type OrderType = 'ascending' | 'descending';
export type Comparator = (a: A, b: A) => CompareResult;
/**
* insert into Ascending sorted array
* */
export declare function insert_sorted(xs: A[], comparator: (a: A, b: A) => CompareResult, x: A, order?: OrderType): void;
export declare const defaultComparator: Comparator;
/**
*
* wrapper of slice, because it's confusing between slice and splice
*
* performance reference: https://jsperf.com/array-clone
* */
export declare function cloneArray(xs: T[]): T[];
/**
* @return in-place sorted, original array
* */
export declare function sort(xs: T[], comparator?: Comparator): T[];
/**
* @remark inplace update
* @return original array
* */
export declare function removeByIdx(xs: A[], i: number): A[];
/**
* @remark inplace update
* @return original array
* */
export declare function remove(xs: A[], x: A): void;
/**
* @remark inplace update
* @return original array
* */
export declare function removeBy(xs: A[], f: (a: A) => boolean): A[];
export declare function nodup(xs: A[]): A[];
/**
* inplace delete all duplicated element from the array (only one copy is kept)
* @return old array
* */
export declare function removeDup(xs: A[]): A[];
/**
* inplace insert elements into the array
* @return old array
* */
export declare function insertNoDup(acc: A[], newXs: A[]): A[];
/**
* inplace insert elements into the array
* @return old array
* */
export declare function insertNoDupWithKey(acc: A[], newXs: A[], key: string): A[];
/**
* inplace operation
* @return old array
* */
export declare function removeDupByKey(xs: A[], key: string | number): A[];
/**
* inplace update
* @return old array
* */
export declare function removeByKey(xs: A[], key: string | number, keys: Array): A[];
/**
* including end
* */
export declare function arrayFromRange(start: number, end: number, step?: number): number[];
/** @deprecated renamed to arrayFromRange */
export declare const range: typeof arrayFromRange;
export declare function repeat(x: T, n: number): T[];
export declare function filterByKey(src: A[], key: string, keys: string[]): A[];
/** @deprecated use Array.from(xs) instead */
export declare function toArray(xs: ArrayLike): A[];
export declare function flatten(xss: A[][]): A[];
/**
* array.push is not monadic, this is a wrapper to make it monadic
* */
export declare function push(res: A[], ...xs: A[]): A[];
export declare function binArray(xs: A[], binSize: number): A[][];
/**
* non-curry version of `groupBy` in functional.ts
* */
export declare function binArrayBy(xs: A[], mapper: (a: A) => K): Map;
export declare function partitionArrayBy(xs: A[], f: (a: A) => boolean): [A[], A[]];
export declare function zipArray(a: A[], b: B[]): Array<[A, B]>;
export declare function countArray(xs: A[], f: (a: A, i: number, xs: A[]) => boolean): number;
export declare function asyncCountArray(xs: A[], f: (x: A, i: number, xs: A[]) => Promise): Promise;
export declare function max(xs: T[]): T | undefined;
export declare function min(xs: T[]): T | undefined;
export declare function sum(xs: number[]): number;
export declare function sumByFunc(xs: T[], mapper: (x: T) => number): number;
export declare function maxByFunc(xs: T[], comparator: (a: T, b: T) => CompareResult): T | undefined;
export declare function minByFunc(xs: T[], comparator: (a: T, b: T) => CompareResult): T | undefined;
export declare function maxByField(xs: T[], key: K): T | undefined;
export declare function minByField(xs: T[], key: K): T | undefined;
export declare function sumByField, K extends keyof T>(xs: T[], key: K): number;
/**
* side-effect: the array will be sorted in-place if instructed
*
* default will sort the array
* */
export declare function median(xs: T[], options?: {
sort?: boolean | typeof defaultComparator;
merger?: (a: T, b: T) => T;
}): T | undefined;
export declare function countElement(xs: T[], x: T): number;
export declare function countAll(xs: T[]): Map;
export declare function mode(xs: T[]): T | undefined;
export declare function shuffle(xs: T[], n?: number): T[];
export declare function shuffledBinArray(xs: T[], binSize: number, nSwap?: number): T[][];
export declare function shuffledIndices(n: number): number[];
/**
* TODO assign a better name
* e.g. f [a,b,c] 1 ~~> [[a],[b],[c]]
* e.g. f [a,b,c] 2 ~~> [ [a,a],[a,b],[a,c],
* [b,a],[b,b],[b,c],
* [c,a],[c,b],[c,c] ]
* */
export declare function genCombination(cs: T[], size: number): T[][];
export type IoList = T[] | T[][] | T[][][] | T[][][][] | T[][][][][] | T[][][][][][] | T[][][][][][][] | any[];
export declare function flattenAll(xs: IoList): T[];
export declare function getMaxArraySize(): number;
export declare function pushForward(xs: T[], x: T): void;
export declare function pushBackward(xs: T[], x: T): void;
export declare function makeArray(n: number, f: (i: number) => T): T[];
export declare function arrayToObject(xs: T[], keyFn: (x: T, i: number, xs: T[]) => string): Record;