/**
 * Splits an array into chunks of a given size.
 * @param arr - Array to split into chunks.
 * @param chunkSize - Size of each chunk.
 * @returns Array of chunked arrays.
 *
 * @example
 * ```ts
 * sliceIntoChunks([1,2,3,4], 2); // [[1,2],[3,4]]
 * ```
 */
export declare function sliceIntoChunks<T>(arr: T[], chunkSize: number): T[][];
export type IArrayString = (null | undefined | boolean | string | IArrayString)[];
/**
 * Splits and flattens a list of strings based on a separator.
 * @param {string[]} arrayStrings - Array of strings to split and flatten.
 * @param {string} separator - Separator to use for splitting.
 * @returns {string[]} Flattened and splitted array of strings.
 *
 * @example
 * ```ts
 * splitAndFlat(['tag1 tag2', 'tag2'], ' ');
 * // => ['tag1', 'tag2']
 * ```
 */
export declare function splitAndFlat(arrayStrings: IArrayString, separator?: string): string[];
/**
 * Generates a random set of colors with an optional format.
 * @param count - Number of colors to generate.
 * @param options - Object containing optional parameters.
 * @param options.format - The format of the output colors ('hex', 'rgb', 'nrgb').
 * @param options.bounds - The bounds for color transformation.
 * @param options.distribute - Whether the colors should be evenly distributed.
 * @returns An array of colors in the specified format.
 *
 * @example
 * ```ts
 * generateRandomColors(2, { format: 'rgb' });
 * // => [[r,g,b], [r,g,b]]
 * ```
 */
export declare function generateRandomColors(count: number, { format, bounds, distribute }?: {
    format?: 'hex' | 'rgb' | 'nrgb';
    bounds?: number | number[] | {
        r: number;
        g: number;
        b: number;
    };
    distribute?: boolean;
}): Array<string | [number, number, number] | number[]>;
/**
 * Evaluates the similarity of a set of colors.
 * @param cls - Array of colors in hex format.
 * @returns A similarity score between 0 and 1, where 0 indicates all colors are distinct and 1 indicates all are similar.
 *
 * @example
 * ```ts
 * evaluateColorSimilarity(['#ffffff', '#fffffe']);
 * // => value close to 1
 * ```
 */
export declare function evaluateColorSimilarity(colors: string[]): number;
/**
 * Normalizes a string by converting it to lowercase and removing diacritical marks.
 * @param {string} str - The string to normalize.
 * @returns {string} The normalized string.
 *
 * @example
 * ```ts
 * normalize('Árbol');
 * // => 'arbol'
 * ```
 */
export declare function normalize(str?: string): string;
/**
 * Converts a string to a slug.
 * @param {string} str - The string to slugify.
 * @returns {string} The slugified string.
 *
 * @example
 * ```ts
 * slugify('Hello World!');
 * // => 'hello-world'
 * ```
 */
export declare function slugify(str?: string): string;
/**
 * Generates a random four-character string consisting of hexadecimal digits.
 * @returns {string} The random four-character string.
 *
 * @example
 * ```ts
 * randomS4();
 * // => '9f3b'
 * ```
 */
export declare function randomS4(): string;
/**
 * Generates a random string of the specified length using the provided characters.
 *
 * @param {number} [length=16] - The length of the generated string. Default is 16.
 * @param {string} [characters='ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789'] - A string representing the characters to be used. Default includes uppercase, lowercase letters, and digits.
 * @returns {string} A random string composed of the specified characters.
 *
 * @example
 * ```ts
 * randomString(5);
 * // => e.g., 'aB3dE'
 * ```
 */
export declare function randomString(length?: number, characters?: string): string;
/**
 * Generates an array of time intervals between two dates.
 * @param {Object} options - Options for generating time intervals.
 * @param {string|number} options.from - Start date in string format or as a UNIX timestamp.
 * @param {string|number} options.to - End date in string format or as a UNIX timestamp.
 * @param {number} options.step - The step size in hours for each time interval.
 * @param {string} [options.boundary] - Restrict chunks to 'day', 'month', or 'day,month' boundaries.
 * @returns An array of objects representing each time interval.
 *
 * @example
 * ```ts
 * timeChunks({ from: '2020-01-01', to: '2020-01-02', step: 6 });
 * ```
 */
export declare function timeChunks(options: {
    from: string | number;
    to: string | number;
    step: number;
    boundary?: string;
}): {
    from: string;
    to: string;
    step: number;
}[];
/**
 * Resolves the promise after a given timeout.
 * @param {number} timeout - Milliseconds to wait before resolving.
 * @returns {Promise<void>} The promise that resolves after the timeout.
 *
 * @example
 * ```ts
 * await delay(1000);
 * // waits for one second
 * ```
 */
export declare function delay(timeout: number): Promise<void>;
/**
 * Computes the hash value of a string.
 * @param {string} string - The string to hash.
 * @returns {number} The computed hash value.
 *
 * @example
 * ```ts
 * hash('abc');
 * // => deterministic numeric hash
 * ```
 */
export declare function hash(string: string): number;
/**
 * Linear Congruential Generator (LCG) class for pseudo-random number generation.
 * @class LCG
 *
 * @example
 * ```ts
 * const gen = new LCG(123);
 * gen.random();
 * // => 0.596735... (deterministic)
 * ```
 */
export declare class LCG {
    private a;
    private c;
    private m;
    private seed;
    constructor(seed: number);
    /**
     * Generates a pseudo-random number between 0 and 1.
     * @returns {number} The generated pseudo-random number.
     */
    random(): number;
}