import type { IntegerTypedArray } from "./_types.js";
declare abstract class Prng32 {
    /** Generates a pseudo-random 32-bit unsigned integer. */
    abstract nextUint32(): number;
    /**
     * Mutates the provided typed array with pseudo-random values.
     * @returns The same typed array, now populated with random values.
     */
    getRandomValues<T extends IntegerTypedArray>(arr: T): T;
}
/**
 * Internal PCG32 implementation, used by both the public seeded random
 * function and the seed generation algorithm.
 *
 * Modified from https://github.com/rust-random/rand/blob/f7bbcca/rand_pcg/src/pcg64.rs#L140-L153
 */
export declare class Pcg32 extends Prng32 {
    #private;
    /** Multiplier for the PCG32 algorithm. */
    static readonly MULTIPLIER = 6364136223846793005n;
    static readonly ROTATE = 59n;
    static readonly XSHIFT = 18n;
    static readonly SPARE = 27n;
    get state(): bigint;
    protected set state(val: bigint);
    get increment(): bigint;
    protected set increment(val: bigint);
    /**
     * Creates a new `Pcg32` instance with entropy generated from the seed.
     * @param seed A 64-bit unsigned integer used to seed the generator.
     */
    constructor(seed: bigint);
    /**
     * Creates a new `Pcg32` instance with the given `state` and `increment` values.
     * @param state The current state of the generator.
     * @param increment The increment value used in the generator.
     *
     * > [!NOTE]
     * > It is typically better to use the constructor that takes a single `seed` value.
     * > However, this constructor can be useful for resuming from a saved state.
     */
    constructor({ state, increment }: {
        state: bigint;
        increment: bigint;
    });
    /** @returns The next pseudo-random 32-bit integer. */
    nextUint32(): number;
    /** Mutates `pcg` by advancing `pcg.state`. */
    step(): this;
}
export {};
//# sourceMappingURL=_pcg32.d.ts.map