camote-utils/dist/random/index.d.ts

A comprehensive TypeScript utility library featuring advanced string and number formatting, data structures, and algorithms

/**
 * Generates a random integer between min (inclusive) and max (inclusive)
 * @param min - The minimum value (inclusive)
 * @param max - The maximum value (inclusive)
 * @returns A random integer between min and max
 * @throws {Error} If min is greater than max
 * @throws {Error} If min or max is not a finite number
 * @example
 * generateRandomInteger(1, 10);    // Returns a number between 1 and 10
 * generateRandomInteger(0, 1);     // Returns either 0 or 1
 * generateRandomInteger(-5, 5);    // Returns a number between -5 and 5
 */
export declare const generateRandomInteger: (min: number, max: number) => number;
/**
 * Generates a random integer between min (inclusive) and max (inclusive)
 * @param min - The minimum value (inclusive)
 * @param max - The maximum value (inclusive)
 * @returns A random integer between min and max
 * @throws {Error} If min is greater than max
 * @throws {Error} If min or max is not a finite number
 * @example
 * generateRandomIntegerInRange(5, 10);    // Returns a number between 5 and 10
 * generateRandomIntegerInRange(-10, 10);   // Returns a number between -10 and 10
 */
export declare const generateRandomIntegerInRange: (min: number, max: number) => number;
/**
 * Generates an array of random integers
 * @param length - The length of the array to generate
 * @param min - The minimum value (inclusive)
 * @param max - The maximum value (inclusive)
 * @returns An array of random integers
 * @throws {Error} If length is less than 0
 * @example
 * generateRandomIntegerArray(3, 1, 10);    // Returns e.g. [4, 7, 2]
 * generateRandomIntegerArray(5, 0, 1);     // Returns e.g. [1, 0, 1, 0, 1]
 */
export declare const generateRandomIntegerArray: (length: number, min: number, max: number) => number[];
/**
 * Generates a random integer excluding certain values
 * @param min - The minimum value (inclusive)
 * @param max - The maximum value (inclusive)
 * @param exclude - Array of numbers to exclude
 * @returns A random integer between min and max, excluding specified values
 * @throws {Error} If no valid numbers are available in the range
 * @example
 * generateRandomIntegerExcluding(1, 10, [5, 6]);    // Returns a number between 1-4 or 7-10
 * generateRandomIntegerExcluding(1, 3, [2]);        // Returns either 1 or 3
 */
export declare const generateRandomIntegerExcluding: (min: number, max: number, exclude: number[]) => number;
/**
 * Options for random string generation
 */
export interface GenerateRandomStringOptions {
    lowercase?: boolean;
    uppercase?: boolean;
    numbers?: boolean;
    special?: boolean;
    custom?: string;
    exclude?: string;
}
/**
 * Generates a random string based on specified options.
 *
 * @param length - The length of the string to generate.
 * @param options - Configuration options for string generation, which may include:
 *    - custom: A string of custom characters to use for generation.
 *    - lowercase: A boolean indicating whether to include lowercase letters.
 *    - uppercase: A boolean indicating whether to include uppercase letters.
 *    - numbers: A boolean indicating whether to include numeric characters.
 *    - special: A boolean indicating whether to include special characters.
 *    - exclude: A string of characters to exclude from the generated string.
 *
 * @returns A random string that matches the specified criteria.
 *
 * @throws {Error} If length is less than 0.
 * @throws {Error} If no character set is selected (i.e., all options are false or empty).
 *
 * @example
 * generateRandomString(8); // Might return "aB3$kL9p"
 * generateRandomString(10, { lowercase: true, numbers: true }); // Might return "a7b2n9k4m5"
 * generateRandomString(5, { custom: "ABC123" }); // Might return "B1CA3"
 */
export declare const generateRandomString: (length: number, options?: GenerateRandomStringOptions) => string;
export declare const generateRandomPassword: (length: number, options?: Omit<GenerateRandomStringOptions, "lowercase" | "uppercase" | "numbers" | "special">) => string;
export declare const generateStrongPassword: (length?: number) => string;
export declare const generateRandomHexColor: (includeHash?: boolean) => string;
export declare const generateRandomRGB: (includeArray?: boolean) => string | number[];
export declare const generateRandomHSL: (includeArray?: boolean) => string | number[];
export declare const generateColorPalette: (numColors: number, format?: "hex" | "rgb" | "hsl") => string[];
export declare const generateRandomColor: (format?: "hex" | "rgb" | "hsl") => string;
export declare const generateUUID: () => string;
export declare const generateUUIDv4: () => string;
export type GenerateRandomType = 'integer' | 'float' | 'boolean' | 'string' | 'hexColor' | 'rgbColor' | 'hslColor' | 'uuid' | 'colorPalette';
export interface GenerateRandomOptions {
    type: GenerateRandomType;
    min?: number;
    max?: number;
    length?: number;
    stringOptions?: GenerateRandomStringOptions;
    includeHash?: boolean;
    numColors?: number;
    format?: 'hex' | 'rgb' | 'hsl';
}
export declare const generateRandom: (options: GenerateRandomOptions) => number | string | boolean | string[];