export declare type PrimitiveArray = ReadonlyArray<string | number | boolean>;
export declare type ToArrayLike<T> = ReadonlyArray<T> | {
    [key: string]: T;
} | {
    [key: number]: T;
} | undefined | null;
interface IArrayLike<T> {
    [key: number]: T;
    readonly length: number;
}
interface GroupedDict<V> {
    [key: string]: ReadonlyArray<V>;
}
export interface IndexedValue<V> {
    readonly index: number;
    readonly value: V;
}
export declare namespace Arrays {
    function toIndexed<V>(values: ReadonlyArray<V>): ReadonlyArray<IndexedValue<V>>;
    function groupBy<V>(values: ReadonlyArray<V>, toKey: (value: V) => string): GroupedDict<V>;
    function toArray<T>(value: ToArrayLike<T>): ReadonlyArray<T>;
    function onlyDefined<T>(values: ReadonlyArray<T | undefined>): ReadonlyArray<T>;
    function first<T>(values: ReadonlyArray<T>): T | undefined;
    function last<T>(values: ReadonlyArray<T>): T | undefined;
    function sample<T>(values: T[], count: number): T[];
    function toDict(val: {} | any[]): {
        [key: string]: any;
    };
    function createBatches<T>(input: ReadonlyArray<T>, batchSize: number): T[][];
    function asyncForEach<T>(items: T[], callback: AsyncCallback<T>): Promise<void>;
    function shuffle<T>(...input: T[]): T[];
    function head<T>(input: ReadonlyArray<T>, limit: number): T[];
    function hasAny<T>(list: ReadonlyArray<T>, items: ReadonlyArray<T>): boolean;
    function equal(a: PrimitiveArray, b: PrimitiveArray): boolean;
    function prevSibling<T>(arr: IArrayLike<T>, index: number): T | undefined;
    function nextSibling<T>(arr: IArrayLike<T>, index: number): T | undefined;
}
export declare type AsyncCallback<T> = (current: T) => Promise<void>;
export declare type SparseArray<T> = ReadonlyArray<T | undefined | null>;
export declare namespace SparseArrays {
    function presentOnly<T>(values: SparseArray<T>): ReadonlyArray<T>;
}
export declare function asArray<T>(arr: ReadonlyArray<T> | undefined | null): ReadonlyArray<T>;
export {};