import type { ACBuilder } from "./ac.js";
import type { CritConfig } from "../common/types.js";
import type { DCBuilder } from "./dc.js";
import type { PMF } from "../pmf/pmf.js";
import type { DiceQuery } from "../pmf/query.js";
import { AttackBuilder } from "./attack.js";
import type { ExpressionNode } from "./nodes.js";
import type { RollConfig, RollType } from "./types.js";
/** Clears the plain-roll PMF cache (test/bench seam; mirrors {@link clearAttackCache}). */
export declare function clearRollCache(): void;
export declare const defaultConfig: RollConfig;
export declare class RollBuilder {
    protected readonly subRollConfigs: readonly RollConfig[];
    constructor(countOrConfigs?: number | readonly RollConfig[]);
    protected create(configs: readonly RollConfig[]): RollBuilder;
    protected get lastConfig(): RollConfig;
    hasHiddenState(): boolean;
    getSubRollConfigs(): readonly RollConfig[];
    /**
     * A cheap, stable string that FULLY identifies this builder's PMF — used by {@link AttackBuilder.toPMF}
     * to cache resolved attack PMFs across rebuilds without walking the AST via {@link toExpression}. A plain
     * roll is fully determined by its {@link RollConfig} array (count/sides/modifier/reroll/explode/minimum/
     * bestOf/keep/rollType/isSubtraction), so serializing that is sound. Subclasses whose PMF depends on
     * hidden state NOT captured by `subRollConfigs` (half/scale/max/parsed/pooled/composite transforms) return
     * `null` to opt OUT of caching — a conservative miss is always safe; a wrong key would corrupt DPR.
     */
    cacheKey(): string | null;
    static fromConfig(config: Partial<RollConfig>): RollBuilder;
    static fromConfigs(configs: Partial<RollConfig>[]): RollBuilder;
    static fromArgs(...args: any[]): RollBuilder;
    d(sides: number | undefined): RollBuilder;
    plus(modOrRoll: number | RollBuilder | undefined): RollBuilder;
    plus(count: number, die: RollBuilder): RollBuilder;
    minus(modOrRoll: number | RollBuilder | undefined): RollBuilder;
    minus(count: number, die: RollBuilder): RollBuilder;
    /** Apply one-pass reroll threshold (k): reroll faces 1..k once, must keep. */
    reroll(value: number): RollBuilder;
    /** Set finite explode count for max-face explosions (Infinity allowed). */
    explode(count?: number | undefined): RollBuilder;
    /** Apply per-die minimum value (floors each die roll at `val`, e.g. `minimum(3)` treats a 1 or
     * 2 as a 3 -- the 2024 Great Weapon Fighting style). */
    minimum(val: number | undefined): RollBuilder;
    bestOf(count: number | undefined): RollBuilder;
    keepHighest(total: number, count: number): RollBuilder;
    keepLowest(total: number, count: number): RollBuilder;
    keepHighestAll(total: number, count: number): PooledRollBuilder;
    keepLowestAll(total: number, count: number): PooledRollBuilder;
    withAdvantage(): RollBuilder;
    withDisadvantage(): RollBuilder;
    add(anotherRoll: RollBuilder | undefined): RollBuilder;
    withBonus(anotherRoll: RollBuilder): RollBuilder;
    addRoll(count?: number): RollBuilder;
    scaleDice(scale: number): RollBuilder;
    doubleDice(): RollBuilder;
    alwaysHits(): AlwaysHitBuilder;
    alwaysCrits(): AlwaysCritBuilder;
    copy(): RollBuilder;
    d4: () => RollBuilder;
    d6: () => RollBuilder;
    d8: () => RollBuilder;
    d10: () => RollBuilder;
    d12: () => RollBuilder;
    d20: () => RollBuilder;
    d100: () => RollBuilder;
    withElvenAccuracy(): RollBuilder;
    toExpression(): string;
    toPMF(eps?: number): PMF;
    get pmf(): PMF;
    toQuery(eps?: number): DiceQuery;
    toAST(): ExpressionNode;
    private configToSingleExpressionWithoutModifier;
    getRootDieConfig(): RollConfig | undefined;
    getAllDieConfigs(): readonly RollConfig[];
    getBonusDiceConfigs(): RollConfig[];
    getBonusDicePMFs(check: RollBuilder, eps?: number): PMF[];
    get modifier(): number;
    get rollType(): RollType;
    get baseReroll(): number;
    half(): HalfRollBuilder;
    /**
     * Scale this roll's result by `numerator / denominator`, rounding each outcome.
     * A general, composable form of {@link half} — used to model damage-type resistance
     * (`scaleResult(1, 2)` → `(expr) // 2`) and vulnerability (`scaleResult(2)` → `2 * (expr)`).
     * Compose several of these (and plain rolls) into one payload with {@link sumRolls}.
     */
    scaleResult(numerator: number, denominator?: number, rounding?: "floor" | "round" | "ceil"): ScaleRollBuilder;
    maxOf(count: number): MaxOfRollBuilder;
    ac(_targetAC: number): ACBuilder;
    dc(_saveDC: number): DCBuilder;
}
export declare class HalfRollBuilder extends RollBuilder {
    private readonly innerRoll;
    constructor(innerRoll: RollBuilder);
    hasHiddenState(): boolean;
    cacheKey(): string | null;
    get lastConfig(): RollConfig;
    getSubRollConfigs(): readonly RollConfig[];
    toExpression(): string;
    toAST(): ExpressionNode;
    toPMF(eps?: number): PMF;
    scaleDice(scale: number): RollBuilder;
    copy(): HalfRollBuilder;
}
/**
 * A roll whose result is scaled by `numerator / denominator` and rounded — the composable
 * generalization of {@link HalfRollBuilder}. Renders as `N * (inner)`, `(inner) // D`, or
 * `(inner) * N // D`. Terminal (like `half`): use {@link sumRolls} to combine with other rolls.
 */
export declare class ScaleRollBuilder extends RollBuilder {
    private readonly innerRoll;
    private readonly numerator;
    private readonly denominator;
    private readonly rounding;
    constructor(innerRoll: RollBuilder, numerator: number, denominator?: number, rounding?: "floor" | "round" | "ceil");
    hasHiddenState(): boolean;
    cacheKey(): string | null;
    get lastConfig(): RollConfig;
    getSubRollConfigs(): readonly RollConfig[];
    toExpression(): string;
    toAST(): ExpressionNode;
    toPMF(eps?: number): PMF;
    scaleDice(scale: number): RollBuilder;
    copy(): ScaleRollBuilder;
}
export declare class MaxOfRollBuilder extends RollBuilder {
    private readonly innerRoll;
    private readonly count;
    private readonly diceCount?;
    private readonly diceSides?;
    constructor(innerRoll: RollBuilder, count: number, diceCount?: number | undefined, diceSides?: number | undefined);
    hasHiddenState(): boolean;
    cacheKey(): string | null;
    get lastConfig(): RollConfig;
    getSubRollConfigs(): readonly RollConfig[];
    toExpression(): string;
    toAST(): ExpressionNode;
    toPMF(eps?: number): PMF;
    scaleDice(scale: number): RollBuilder;
    copy(): MaxOfRollBuilder;
}
export declare class AlwaysHitBuilder extends RollBuilder {
    readonly attackConfig: CritConfig;
    constructor(baseRoll: RollBuilder, attackConfig?: CritConfig);
    protected create(configs: readonly RollConfig[]): RollBuilder;
    onHit(val: number): AttackBuilder;
    onHit(val: string): AttackBuilder;
    onHit(val: RollBuilder): AttackBuilder;
    onHit(count: number, die: RollBuilder): AttackBuilder;
    onHit(count: number, sides: number): AttackBuilder;
    onHit(count: number, die: RollBuilder, modifier: number): AttackBuilder;
    onHit(count: number, sides: number, modifier: number): AttackBuilder;
    get critThreshold(): number;
    cacheKey(): string | null;
    critOn(critThreshold: number): AlwaysHitBuilder;
    alwaysCrits(): AlwaysCritBuilder;
    toExpression(): string;
    toPMF(): PMF;
    copy(): AlwaysHitBuilder;
}
export declare class AlwaysCritBuilder extends RollBuilder {
    readonly attackConfig: CritConfig & {
        ac?: number;
    };
    readonly fromAlwaysHit: boolean;
    constructor(baseRoll: RollBuilder, attackConfig?: CritConfig & {
        ac?: number;
    }, fromAlwaysHit?: boolean);
    protected create(configs: readonly RollConfig[]): RollBuilder;
    onHit(val: number): AttackBuilder;
    onHit(val: string): AttackBuilder;
    onHit(val: RollBuilder): AttackBuilder;
    onHit(count: number, die: RollBuilder): AttackBuilder;
    onHit(count: number, sides: number): AttackBuilder;
    onHit(count: number, die: RollBuilder, modifier: number): AttackBuilder;
    onHit(count: number, sides: number, modifier: number): AttackBuilder;
    get critThreshold(): number;
    cacheKey(): string | null;
    critOn(critThreshold: number): AlwaysCritBuilder;
    toExpression(): string;
    toPMF(): PMF;
    copy(): AlwaysCritBuilder;
}
export declare class ParsedRollBuilder extends RollBuilder {
    private readonly cachedPMF;
    private readonly originalExpression;
    constructor(expression: string);
    hasHiddenState(): boolean;
    cacheKey(): string | null;
    protected create(configs: readonly RollConfig[]): RollBuilder;
    toPMF(_eps?: number): PMF;
    toExpression(): string;
    toAST(): ExpressionNode;
    copy(): ParsedRollBuilder;
    doubleDice(): ParsedRollBuilder;
}
export declare class PooledRollBuilder extends RollBuilder {
    private readonly baseAST;
    private readonly baseExpression;
    constructor(baseAST: ExpressionNode, baseExpression: string, configs?: readonly RollConfig[]);
    protected create(configs: readonly RollConfig[]): PooledRollBuilder;
    hasHiddenState(): boolean;
    cacheKey(): string | null;
    d(_sides: number | undefined): RollBuilder;
    reroll(_value: number): RollBuilder;
    explode(_count?: number | undefined): RollBuilder;
    minimum(_val: number | undefined): RollBuilder;
    bestOf(_count: number | undefined): RollBuilder;
    keepHighest(_total: number, _count: number): RollBuilder;
    keepLowest(_total: number, _count: number): RollBuilder;
    withAdvantage(): RollBuilder;
    withDisadvantage(): RollBuilder;
    withElvenAccuracy(): RollBuilder;
    toAST(): ExpressionNode;
    toExpression(): string;
    copy(): PooledRollBuilder;
    scaleDice(scale: number): RollBuilder;
    times(count: number): PooledRollBuilder;
}
/**
 * Combine several rolls into one additive payload whose PMF is their convolution and whose
 * expression is them joined with ` + `. Unlike `a.plus(b)`, this preserves parts that carry
 * hidden state (e.g. `roll.scaleResult(1, 2)` / `roll.half()`), so per-damage-type resistance
 * and vulnerability survive into both the distribution and the rendered expression.
 * Empty parts collapse to `0`; a single part is returned unwrapped.
 */
export declare function sumRolls(parts: readonly RollBuilder[]): RollBuilder;
//# sourceMappingURL=roll.d.ts.map