export type PlainObject = {
    [key: string]: AnyValue;
};
export type AnyValue = unknown;
export type Constructor<T> = {
    new (...args: ReadonlyArray<any>): T;
};
export declare function flatMap<TOut, TIn>(arr: ReadonlyArray<TIn>, f: (t: TIn) => ReadonlyArray<TOut>): ReadonlyArray<TOut>;
/**
 * Maps an array and returns the first defined result. Undefined elements in array will be ignored.
 * @param {ReadonlyArray<TIn>} array.
 * @param {(t: TIn) => TOut} fn
 * @returns TOut|undefined
 */
export declare function mapFirstDefined<TIn, TOut>(array: ReadonlyArray<TIn | undefined>, fn: (t: TIn) => TOut): NonNullable<TOut> | undefined;
export declare function flatten<T>(arr: ReadonlyArray<ReadonlyArray<T>>): ReadonlyArray<T>;
/**
 * Check if {array} starts with {start}
 * @param {ReadonlyArray<T>} array
 * @param {ReadonlyArray<T>} start
 * @returns {boolean}
 */
export declare function arrayStartsWith<T>(array: ReadonlyArray<T>, start: ReadonlyArray<T>): boolean;
export declare function capitalize(string: string): string;
export declare function decapitalize(string: string): string;
/**
 * Groups items in an array by common keys
 * @param items the input items
 * @param keyFn a function that computes the key value of an item
 * @returns {Map<TKey, ReadonlyArray<TItem>>} a map from key values to the list of items that have that key
 */
export declare function groupArray<TItem, TKey>(items: ReadonlyArray<TItem>, keyFn: (item: TItem) => TKey): Map<TKey, ReadonlyArray<TItem>>;
export declare const INDENTATION = "  ";
/**
 * Indents each line of a string with a given indentation
 * @param input the string to indent
 * @param indentation the prefix to put in front of each line
 * @returns the indented string
 */
export declare function indent(input: string, indentation?: string | number): string;
/**
 * Creates an array of the form [0, 1, 2, ..., count-1]
 *
 * @param count the number of items for the array
 * @returns the array
 */
export declare function range(count: number): ReadonlyArray<number>;
/**
 * Takes a random sample of an array
 * @param arr the source population
 * @returns the sampled item, or undefined if the input array is empty
 */
export declare function takeRandomSample<T>(arr: ReadonlyArray<T>): T | undefined;
export declare function arrayToObject<TValue>(array: ReadonlyArray<TValue>, keyFn: (item: TValue, index: number) => string): {
    [name: string]: TValue;
};
export declare function compact<T>(arr: ReadonlyArray<T | undefined | null>): ReadonlyArray<T>;
export declare function objectValues<T>(obj: {
    [name: string]: T;
}): ReadonlyArray<T>;
export declare function objectEntries<T>(obj: {
    [name: string]: T;
}): [string, T][];
export declare function mapValues<TIn, TOut>(obj: {
    [key: string]: TIn;
}, fn: (value: TIn, key: string) => TOut): {
    [key: string]: TOut;
};
export declare function mapValues<TIn, TOut, TKey>(map: Map<TKey, TIn>, fn: (value: TIn, key: TKey) => TOut): Map<TKey, TOut>;
export declare function sleep(ms: number): Promise<unknown>;
/**
 * Gets a promise that resolves with `true` after a specified time, except when a cancellation promise fires first, then
 * it resolves with `false`.
 *
 * If the cancellation token is rejected, the sleep continues as normal.
 *
 * @param ms the sleep time in milliseconds
 * @param cancellationToken a promise that should be resolved to cancel the timeout
 */
export declare function sleepInterruptible(ms: number, cancellationToken: Promise<void> | undefined): Promise<boolean>;
export declare let escapeRegExp: (input: string) => string;
export declare function isPromise<T>(value: any): value is Promise<T>;
export declare function joinWithAnd(items: ReadonlyArray<string>): string;
/**
 * Checks if a value is an array using Array.isArray()
 *
 * The runtime behavior is identical to Array.is.Array(), but it fixes a shortcoming of TypeScript if the
 * passed value is a union of a readonly array and something else. Array.isArray() would narrow the value
 * to Array<any> instead of ReadonlyArray<T> (see https://github.com/microsoft/TypeScript/issues/17002).
 */
export declare function isReadonlyArray<T>(obj: unknown | ReadonlyArray<T>): obj is ReadonlyArray<T>;