/**
 * Returns a random signed int32, from the crypto lib via a pool.
 *
 * This is on par with {@link Math.random} rather than being significantly faster.
 * It has a 'startup cost' which makes benchmarking hard, and seems to get faster the more numbers you request.
 */
export declare const randInt32: () => number;
/**
 * Returns a basic hash of the string or {@link ArrayLike}.
 */
export declare function hashCode(s: string | ArrayLike<number>): number;
/**
 * Returns a basic hash of the given string based on its UTF-16 parts only. Empty string is zero.
 */
export declare function hashCodeString(s: string): number;
/**
 * Returns a basic hash of the given array-like. Empty is zero.
 */
export declare function hashCodeArray(s: ArrayLike<number>): number;
/**
 * Choose a random item from the {@link ArrayLike}.
 */
export declare function randomArrayChoice<X>(arr: ArrayLike<X>): X | undefined;
/**
 * Pick a random item from the passed {@link Iterable}. Consumes the entire iterable.
 */
export declare function randomPick<X>(iter: Iterable<X>): X | undefined;
/**
 * Picks a random N items from the passed {@link Iterable}. Consumes the entire iterable.
 */
export declare function randomPickN<X>(iter: Iterable<X>, count: number): X[];
/**
 * Lerp between low/high at the given position.
 */
export declare function lerp(low: number, high: number, at: number): number;
/**
 * Finds the position (normally 0-1) between low-high.
 *
 * Will return `Infinity` if low and high are the same.
 */
export declare function inverseLerp(low: number, high: number, value: number): number;
/**
 * Returns a random number in the given range.
 * This is the same semantics as {@link Math.random()}.
 */
export declare function randomRange(a: number, b?: number): number;
/**
 * Returns a random integer number in the given range.
 * If only a single number is given, treated as `[0,n)`.
 * If two numbers are given, treated as `[a,b)`, regardless of relative order.
 *
 * For example:
 *  - `(10)` can give values 0 through 9.
 *  - `(1, 6)` can give values 1 through 5.
 *  - `(0, -4)` can give values 0 through -3.
 *  - `(-4, 0)` can give values -4 through -1.
 *
 * Same values always return that value.
 *
 */
export declare function randomRangeInt(a: number, b?: number): number;
/**
 * Clamps a number between low and high.
 */
export declare const clamp: (low: number, high: number, number: number) => number;
/**
 * Skews a value from a prior range to a new range.
 */
export declare const skew: (from: {
    low: number;
    high: number;
}, to: {
    low: number;
    high: number;
}, value: number) => number;
/**
 * Generates seeded, random 32-bit numbers between `[-2147483648,2147483647]` (i.e., `[-2^31,(2^31)-1]`).
 *
 * The seed must be an integer, if a float is passed, only the integer part is used (e.g., `0.5`
 * becomes `0`).
 *
 * The best use is to clip these numbers with a mask, e.g., `gen() & 0xffff` for 16-bit.
 */
export declare function seeded32(s: number): () => number;
/**
 * Generates seeded `Math.random()` behavior (i.e., >=0 and <1). Requires integer seed, just like
 * {@link seeded32}.
 */
export declare function seededRand(s: number): () => number;
/**
 * Returns a random 36-alphabet string (0-9, a-z) for use as a random identifier.
 *
 * By default, generates a 6-character long ID, which is ~31 bits. The bits are linear with length;
 * each character is ~5.15 bits worth.
 */
export declare function randomId(length?: number): string;