import { type DiceFilter, type DiceFunctor, type DiceReducer, type Sides } from './dice-expression';
import type { BinaryOper } from './program';
/** Operators a Roller-evaluated arithmetic expression supports. */
export type ArithmeticBinaryOp = Extract<BinaryOper, 'add' | 'subtract' | 'multiply' | 'divide'>;
export interface CustomDieResult {
    type: 'custom-die-result';
    result: number;
    faces: number[];
}
export declare function customDieResult(result: number, faces: number[]): CustomDieResult;
export interface OneResult {
    type: 'one-result';
    die: DieResult | CustomDieResult;
    /** Mirror of `die.result`. Lets consumers narrow `RollResult.result`
     *  uniformly across the union without a discriminator dance. */
    result: number;
}
export declare function oneResult(die: DieResult | CustomDieResult): OneResult;
export interface NumberLiteralResult {
    type: 'number-literal-result';
    value: number;
    result: number;
}
export declare function numberLiteralResult(value: number, result: number): NumberLiteralResult;
export interface DiceReduceResult {
    type: 'dice-reduce-result';
    reduceables: DiceReduceableResult;
    reducer: DiceReducer;
    result: number;
}
export declare function diceReduceResult(reduceables: DiceReduceableResult, reducer: DiceReducer, result: number): DiceReduceResult;
export interface BinaryExprResult {
    type: 'binary-expr-result';
    op: ArithmeticBinaryOp;
    left: RollResult;
    right: RollResult;
    result: number;
}
export declare function binaryExprResult(op: ArithmeticBinaryOp, left: RollResult, right: RollResult, result: number): BinaryExprResult;
export interface UnaryExprResult {
    type: 'unary-expr-result';
    op: 'negate';
    expr: RollResult;
    result: number;
}
export declare function unaryExprResult(op: 'negate', expr: RollResult, result: number): UnaryExprResult;
export type RollResult = OneResult | NumberLiteralResult | DiceReduceResult | BinaryExprResult | UnaryExprResult;
export interface DiceExpressionsResult {
    type: 'dice-expressions-result';
    rolls: RollResult[];
}
export declare function diceExpressionsResult(rolls: RollResult[]): DiceExpressionsResult;
export interface DiceFilterableResult {
    type: 'dice-filterable-result';
    rolls: DieResultFilter[];
    filters: DiceFilter[];
}
export declare function diceFilterableResult(rolls: DieResultFilter[], filters: DiceFilter[]): DiceFilterableResult;
export interface DiceMapeableResult {
    type: 'dice-mapeable-result';
    rolls: DiceResultMapped[];
    functor: DiceFunctor;
}
export declare function diceMapeableResult(rolls: DiceResultMapped[], functor: DiceFunctor): DiceMapeableResult;
/**
 * Trace shape for a chained `functor → filter → reducer` expression
 * (e.g. `4d6 explode on 6 keep 3`). Carries both the per-die mapping
 * detail from the functor pass and the survivor/discard markers from
 * the filter pass, so trace consumers can render either layer.
 */
export interface DiceFilterableMapeableResult {
    type: 'dice-filterable-mapeable-result';
    mapeable: DiceResultMapped[];
    functor: DiceFunctor;
    filterRolls: DieResultFilter[];
    filters: DiceFilter[];
}
export declare function diceFilterableMapeableResult(mapeable: DiceResultMapped[], functor: DiceFunctor, filterRolls: DieResultFilter[], filters: DiceFilter[]): DiceFilterableMapeableResult;
export type DiceReduceableResult = DiceExpressionsResult | DiceFilterableResult | DiceMapeableResult | DiceFilterableMapeableResult;
export interface Rerolled {
    type: 'rerolled';
    rerolls: DieResult[];
}
export declare function rerolled(rerolls: DieResult[]): Rerolled;
export interface Exploded {
    type: 'exploded';
    explosions: DieResult[];
}
export declare function exploded(explosions: DieResult[]): Exploded;
export interface Normal {
    type: 'normal';
    roll: DieResult;
}
export declare function normal(roll: DieResult): Normal;
export interface Compounded {
    type: 'compounded';
    rolls: DieResult[];
    total: number;
}
export declare function compounded(rolls: DieResult[], total: number): Compounded;
export type DiceResultMapped = Rerolled | Exploded | Normal | Compounded;
export interface DieResult {
    type: 'die-result';
    result: number;
    sides: Sides;
}
export declare function dieResult(result: number, sides: Sides): DieResult;
export interface KeepResult {
    type: 'keep-result';
    roll: RollResult;
}
export declare function keepResult(roll: RollResult): KeepResult;
export interface DiscardResult {
    type: 'discard-result';
    roll: RollResult;
}
export declare function discardResult(roll: RollResult): DiscardResult;
export type DieResultFilter = KeepResult | DiscardResult;
export interface StructuredFaceRoll {
    type: 'structured-face-roll';
    faceIndex: number;
    face: number | Record<string, number>;
}
export declare function structuredFaceRoll(faceIndex: number, face: number | Record<string, number>): StructuredFaceRoll;
export interface StructuredDiceRollResult {
    type: 'structured-dice-roll-result';
    name: string;
    draws: StructuredFaceRoll[];
    result: number | Record<string, number>;
}
export declare function structuredDiceRollResult(name: string, draws: StructuredFaceRoll[], result: number | Record<string, number>): StructuredDiceRollResult;
/**
 * One die-face draw from a `StructuredDiceRollResult`, with the
 * declaration name and pool position attached. Convenience shape for
 * consumers that render each die individually.
 */
export interface StructuredFaceDraw {
    /** Dice declaration name (`"Genesys"`, `"Descent"`, …). */
    name: string;
    /** Zero-based index into the declaration's `faces` array. */
    faceIdx: number;
    /** The face value — a record for symbol dice (`{ success: 1 }`) or
     *  a number for numeric custom dice. */
    face: number | Record<string, number>;
    /** Position in the rolled pool (0 .. N-1). */
    drawIdx: number;
}
/**
 * Unfold a `StructuredDiceRollResult` into one entry per die in the
 * pool. Mirrors the arithmetic-side walkers; lets UI consumers render
 * each die as an independent chip without re-implementing the unfold.
 */
export declare function flatStructuredFaces(result: StructuredDiceRollResult): StructuredFaceDraw[];