/**
 * Time-Travel Simulator
 *
 * Simulates rule evaluation at arbitrary historical or future timestamps,
 * comparing current vs proposed rules (Enhancement #5).
 */
import type { ArkaRule, ArkaEvent, ArkaEntity, ArkaDecision, TimeTravelSimulationRequest, TimeTravelSimulationResult } from '@arka-protocol/types';
/**
 * Snapshot of rules and entities at a point in time
 */
export interface TimeSnapshot {
    /** Timestamp of the snapshot */
    timestamp: string;
    /** Rules active at this time */
    rules: ArkaRule[];
    /** Entity state at this time */
    entities: Map<string, ArkaEntity>;
    /** Events that occurred before this time */
    events: ArkaEvent[];
}
/**
 * Result of evaluating an event at a specific time
 */
export interface TimePointEvaluation {
    /** Timestamp evaluated */
    timestamp: string;
    /** Decisions made */
    decisions: ArkaDecision[];
    /** Rules that were applicable */
    applicableRules: string[];
    /** Rules that matched */
    matchedRules: string[];
}
/**
 * Comparison between two time points or rule sets
 */
export interface SimulationComparison {
    /** Events with different outcomes */
    divergentEvents: Array<{
        eventId: string;
        baselineDecision: ArkaDecision;
        simulatedDecision: ArkaDecision;
        difference: string;
    }>;
    /** Rules that produced different results */
    divergentRules: Array<{
        ruleId: string;
        ruleName: string;
        baselineMatches: number;
        simulatedMatches: number;
        changePercent: number;
    }>;
    /** Summary statistics */
    summary: {
        totalEvents: number;
        divergentCount: number;
        divergenceRate: number;
        riskImpact: 'NONE' | 'LOW' | 'MEDIUM' | 'HIGH' | 'CRITICAL';
    };
}
/**
 * Extended simulation request with additional properties for the simulator
 */
export interface ExtendedSimulationRequest extends TimeTravelSimulationRequest {
    /** Optional proposed rule set to compare against */
    proposedRules?: ArkaRule[];
    /** Optional specific event IDs to simulate */
    eventIds?: string[];
}
/**
 * Time-Travel Simulator options
 */
export interface SimulatorOptions {
    /** Function to get rules effective at a timestamp */
    getRulesAtTime: (timestamp: string) => Promise<ArkaRule[]>;
    /** Function to get entity state at a timestamp */
    getEntityAtTime: (entityId: string, timestamp: string) => Promise<ArkaEntity | null>;
    /** Function to get events in a time range */
    getEventsInRange: (start: string, end: string) => Promise<ArkaEvent[]>;
    /** Function to evaluate a rule against an event */
    evaluateRule: (rule: ArkaRule, event: ArkaEvent, entity: ArkaEntity | null) => Promise<ArkaDecision | null>;
}
/**
 * Time-Travel Simulator class
 */
export declare class TimeTravelSimulator {
    private options;
    constructor(options: SimulatorOptions);
    /**
     * Run a time-travel simulation
     */
    simulate(request: ExtendedSimulationRequest): Promise<TimeTravelSimulationResult>;
    /**
     * Compare rule sets without events (dry run)
     */
    compareRuleSets(baselineRules: ArkaRule[], proposedRules: ArkaRule[]): Promise<{
        added: ArkaRule[];
        removed: ArkaRule[];
        modified: Array<{
            baseline: ArkaRule;
            proposed: ArkaRule;
            changes: string[];
        }>;
        unchanged: ArkaRule[];
    }>;
    /**
     * Replay historical events with new rules
     */
    replayHistory(startTime: string, endTime: string, newRules: ArkaRule[]): Promise<{
        originalDecisions: Map<string, ArkaDecision[]>;
        replayedDecisions: Map<string, ArkaDecision[]>;
        changes: Array<{
            eventId: string;
            original: ArkaDecision;
            replayed: ArkaDecision;
            wouldChange: boolean;
        }>;
    }>;
    /**
     * Forecast impact of rule changes
     */
    forecastImpact(proposedRules: ArkaRule[], sampleSize?: number): Promise<{
        estimatedImpact: {
            allowToFlag: number;
            allowToDeny: number;
            flagToAllow: number;
            flagToDeny: number;
            denyToAllow: number;
            denyToFlag: number;
        };
        confidenceLevel: number;
        riskAssessment: string;
    }>;
    /**
     * Evaluate event at a specific time point
     */
    private evaluateAtTime;
    /**
     * Check if a rule is effective at a given timestamp
     */
    private isRuleEffective;
    /**
     * Compare evaluations and find divergences
     */
    private compareEvaluations;
    /**
     * Aggregate multiple decisions into a single decision type
     */
    private aggregateDecisions;
    /**
     * Create a default decision record
     */
    private createDefaultDecision;
    /**
     * Detect changes between two rule versions
     */
    private detectRuleChanges;
    /**
     * Sample events for forecasting
     */
    private sampleEvents;
    /**
     * Get events by IDs
     */
    private getEventsByIds;
    private capitalize;
}
/**
 * Create a time-travel simulator
 */
export declare function createTimeTravelSimulator(options: SimulatorOptions): TimeTravelSimulator;
//# sourceMappingURL=simulator.d.ts.map