/**
 * Runtime permissions simulation pipeline.
 *
 * `PermissionSimulator` wraps two `LayeredPolicyEvaluator` instances —
 * the *actual* (authoritative) evaluator and a *simulated* (candidate)
 * evaluator — and runs both in parallel for every call to `evaluate()`.
 *
 * Divergence tracking:
 *   - Counts by tool class, command prefix, and simulation mode.
 *   - Configurable divergence threshold for enforcement gate.
 *   - `getDivergenceReport()` returns aggregated stats.
 *
 * Simulation modes:
 *   - `simulation-only`    — Actual decision enforced; divergence logged silently.
 *   - `warn-on-divergence` — Actual decision enforced; divergence emits a warning.
 *   - `enforce`            — Simulated decision becomes authoritative; blocked if
 *                           divergence gate fails (rate > threshold).
 *
 * Feature flag: `permissions-simulation` must be enabled to use this module.
 */
import type { DivergenceReport, PermissionSimulatorConfig, PermissionsConfig, SimulationMode, SimulationResult } from './types.js';
import { LayeredPolicyEvaluator } from './evaluator.js';
/**
 * PermissionSimulator — Dual-evaluator simulation pipeline for runtime permissions.
 *
 * Runs two `LayeredPolicyEvaluator` instances (actual + simulated) in parallel
 * and tracks divergence between their decisions.
 *
 * Usage:
 * ```ts
 * const simulator = createPermissionSimulator(
 *   { mode: 'default', rules: currentRules },
 *   { mode: 'default', rules: candidateRules },
 *   'warn-on-divergence',
 * );
 * const result = simulator.evaluate('write', { path: '/tmp/out.txt' });
 * if (result.diverged) {
 *   console.warn('divergence:', result.divergenceType);
 * }
 * ```
 */
export declare class PermissionSimulator {
    private readonly actual;
    private readonly simulated;
    private readonly simulationMode;
    private readonly maxDivergenceRecords;
    private readonly divergenceThreshold;
    private readonly onWarning;
    /** All recorded divergences, capped at `maxDivergenceRecords`. */
    private records;
    /** Per-tool-class evaluation counts (diverged + non-diverged). */
    private evalsByClass;
    /** Per-command-prefix evaluation counts. */
    private evalsByPrefix;
    /** Per-mode evaluation counts. */
    private evalsByMode;
    /** Total evaluations across all calls. */
    private totalEvals;
    private static readonly DEFAULT_MAX_RECORDS;
    private static readonly DEFAULT_THRESHOLD;
    constructor(actualConfig: PermissionsConfig, simulatedConfig: PermissionsConfig, simulationMode: SimulationMode, config?: PermissionSimulatorConfig);
    /**
     * evaluate — Runs both evaluators and returns a `SimulationResult`.
     *
     * In `enforce` mode the call will throw `SimulationEnforcementError` if
     * the divergence rate exceeds the configured threshold.
     *
     * @param toolName — The tool name being evaluated.
     * @param args     — The arguments passed to the tool.
     */
    evaluate(toolName: string, args: Record<string, unknown>): SimulationResult;
    /**
     * getDivergenceReport — Returns aggregated divergence statistics.
     *
     * Queryable by tool class and command prefix. Includes overall summary,
     * per-class, per-prefix, and per-mode breakdowns.
     */
    getDivergenceReport(): DivergenceReport;
    /**
     * getActualEvaluator — Exposes the actual evaluator for direct inspection.
     */
    getActualEvaluator(): LayeredPolicyEvaluator;
    /**
     * getSimulatedEvaluator — Exposes the simulated evaluator for direct inspection.
     */
    getSimulatedEvaluator(): LayeredPolicyEvaluator;
    /**
     * getSimulationMode — Returns the active simulation mode.
     */
    getSimulationMode(): SimulationMode;
    /**
     * isDivergenceGatePassing — Returns whether the divergence rate is within
     * the configured threshold. Always `true` in non-enforce modes.
     */
    isDivergenceGatePassing(): boolean;
    /**
     * assertDivergenceGate — Throws if divergence rate exceeds threshold.
     *
     * Only called in `enforce` mode prior to evaluation.
     */
    private assertDivergenceGate;
}
/**
 * Thrown when `enforce` mode is active and the divergence gate fails.
 */
export declare class SimulationEnforcementError extends Error {
    /** Current divergence rate (0–1). */
    readonly divergenceRate: number;
    /** Configured divergence threshold (0–1). */
    readonly threshold: number;
    constructor(message: string, divergenceRate: number, threshold: number);
}
//# sourceMappingURL=simulation.d.ts.map