export declare class SeededRandom {
    private state0;
    private state1;
    private state2;
    private state3;
    constructor(seed: number | string);
    next(): number;
    private nextUint32;
    private randomIndex;
    shuffle<T>(array: T[]): T[];
    safeCopy<T>(array: T[]): T[];
    static generateSeed(): number;
    /**
     * Get a random integer between min and max (inclusive)
     * @param min - Minimum value
     * @param max - Maximum value
     * @returns Random integer
     */
    randInt(min: number, max: number): number;
    /**
     * Get a random element from an array
     * @param array - Array to pick from
     * @returns Random element
     */
    choice<T>(array: T[]): T;
    /**
     * Get multiple random elements from an array
     * @param array - Array to pick from
     * @param count - Number of elements to pick
     * @param options - Configuration options
     * @param options.unique - Whether to ensure all elements are unique (no duplicates). Default: false
     * @returns Array of random elements
     */
    choices<T>(array: T[], count: number, options?: {
        unique?: boolean;
    }): T[];
    /**
     * Reset the random number generator with a new seed
     * @param seed - New seed value
     */
    reset(seed: number | string): void;
    /**
     * Generate a shuffled index array for a given length
     * @param length - Length of the array
     * @returns Array of shuffled indices
     */
    generateShuffleIndices(length: number): number[];
    /**
     * Apply a shuffle order to an array using indices
     * @param array - Array to shuffle
     * @param indices - Shuffle indices
     * @returns Shuffled array
     */
    applyShuffleByIndices<T>(array: T[], indices: number[]): T[];
    /**
     * Restore original order of an array using shuffle indices
     * @param shuffledArray - Shuffled array
     * @param indices - Shuffle indices used for shuffling
     * @returns Array in original order
     */
    unshuffleByIndices<T>(shuffledArray: T[], indices: number[]): T[];
    /**
     * Restore original order of an array using the same generator state sequence
     * used by shuffle.
     * @param shuffledArray - Previously shuffled array
     * @returns Array restored to original order
     */
    unshuffle<T>(shuffledArray: T[]): T[];
}
/**
 * Shuffle an array using a seeded random number generator
 * @param array - The array to shuffle
 * @param seed - The seed for random number generation (number or string)
 * @returns A new shuffled array
 */
export declare function shuffle<T>(array: T[], seed: number | string): T[];
/**
 * Unshuffle an array using the same seed that was used for shuffling
 * @param shuffledArray - Previously shuffled array
 * @param seed - Same seed used for original shuffling
 * @returns Array restored to original order
 */
export declare function unshuffle<T>(shuffledArray: T[], seed: number | string): T[];