/**
 * Comprehensive Combat RNG system supporting multiple RPG dice mechanics.
 * Deterministic and seeded for reproducibility.
 *
 * Supports:
 * - D&D 5e: Advantage, Disadvantage, Keep/Drop, Reroll, Minimum
 * - Savage Worlds: Exploding dice
 * - Hackmaster: Penetrating dice
 * - Shadowrun/WoD: Dice pool success counting
 * - Pathfinder 2e: Degree-of-success mechanics (in CombatEngine)
 */
export declare class CombatRNG {
    private rng;
    constructor(seed: string);
    /**
     * Roll a single die with N sides
     */
    private rollDie;
    /**
     * Parse and execute standard dice notation (NdS+M or NdS-M)
     * Examples: "1d20", "2d6+3", "1d8-1"
     */
    roll(notation: string): number;
    /**
     * D&D 5e: Roll with Advantage (2d20, keep highest)
     */
    rollWithAdvantage(modifier?: number): number;
    /**
     * D&D 5e: Roll with Disadvantage (2d20, keep lowest)
     */
    rollWithDisadvantage(modifier?: number): number;
    /**
     * General Keep/Drop mechanic
     * Roll N dice of S sides, keep the highest/lowest K dice
     */
    rollKeepDrop(count: number, sides: number, keep: number, type: 'highest' | 'lowest'): number;
    /**
     * D&D 5e: Reroll specific values once (e.g., Great Weapon Fighting)
     * rerollOn: array of values to reroll (e.g., [1, 2])
     */
    rollWithReroll(count: number, sides: number, rerollOn: number[]): number;
    /**
     * D&D 5e: Roll with minimum value (e.g., Reliable Talent)
     * Any roll below min is treated as min
     */
    rollWithMin(count: number, sides: number, min: number): number;
    /**
     * Savage Worlds/L5R: Exploding dice
     * When max value is rolled, roll again and add (can chain indefinitely)
     */
    rollExploding(count: number, sides: number): number;
    /**
     * Hackmaster: Penetrating dice
     * Like exploding, but subtract 1 from each reroll after the first
     */
    rollPenetrating(count: number, sides: number): number;
    /**
     * Shadowrun/World of Darkness: Dice pool success counting
     * Roll poolSize dice of diceSize, count how many meet/exceed threshold
     *
     * @param poolSize Number of dice to roll
     * @param diceSize Size of each die (typically d6 or d10)
     * @param threshold Minimum value to count as success
     * @returns Number of successes
     */
    rollPool(poolSize: number, diceSize: number, threshold: number): number;
    /**
     * Convenience method for d20 checks
     */
    d20(modifier?: number): number;
    /**
     * Make a check against a Difficulty Class
     * Returns true if roll + modifier meets or exceeds DC
     */
    check(modifier: number, dc: number): boolean;
    /**
     * Pathfinder 2e: Determine degree of success
     * Returns: 'critical-failure' | 'failure' | 'success' | 'critical-success'
     */
    checkDegree(modifier: number, dc: number): 'critical-failure' | 'failure' | 'success' | 'critical-success';
    /**
     * Detailed check result with full dice mechanics exposed
     * This is the TRANSPARENT version - shows exactly what was rolled
     */
    checkDegreeDetailed(modifier: number, dc: number): CheckResult;
    /**
     * Roll damage dice with detailed breakdown
     */
    rollDamageDetailed(notation: string): DamageResult;
}
/**
 * Detailed result of a d20 check
 */
export interface CheckResult {
    roll: number;
    modifier: number;
    total: number;
    dc: number;
    margin: number;
    degree: 'critical-failure' | 'failure' | 'success' | 'critical-success';
    isNat20: boolean;
    isNat1: boolean;
    isHit: boolean;
    isCrit: boolean;
}
/**
 * Detailed result of a damage roll
 */
export interface DamageResult {
    notation: string;
    rolls: number[];
    diceTotal: number;
    modifier: number;
    total: number;
}
//# sourceMappingURL=rng.d.ts.map