type SafetyClass = "read" | "write" | "destroy" | "network" | "execute";
type Verdict = "pass" | "warn" | "block" | "escalate";
interface FastPathResult {
    verdict: Verdict;
    checks: Array<{
        rule: string;
        passed: boolean;
        severity: "critical" | "warning" | "info";
        message: string;
    }>;
    latencyUs: number;
}
interface SlowPathResult {
    verdict: Verdict;
    reasoning: string;
    invariantChecks: Array<{
        invariant: string;
        satisfied: boolean;
        detail: string;
    }>;
    latencyMs: number;
}
interface DualPathVerdict {
    toolName: string;
    fastPath: FastPathResult;
    slowPath?: SlowPathResult;
    finalVerdict: Verdict;
    reason?: string;
    totalLatencyMs: number;
    pathTaken: "fast" | "fast+slow";
}
interface ToolOperation {
    name: string;
    input: Record<string, unknown>;
    safetyClass: SafetyClass;
    targetsFiles: string[];
}
interface RoutingPolicy {
    alwaysSlowPathFor: SafetyClass[];
    warnEscalatesToSlow: boolean;
    consecutiveFailuresTriggerSlow: number;
    maxConsecutiveFailures: number;
    firstNTurnsFastOnly: number;
    fileNotInGraphTriggersSlow: boolean;
    writeWithoutReadTriggersSlow: boolean;
}
declare const DEFAULT_ROUTING_POLICY: RoutingPolicy;

declare class WorldModel {
    private files;
    private history;
    private consecutiveFailures;
    recordRead(filePath: string, turn: number): void;
    recordWrite(filePath: string, turn: number): void;
    recordDep(from: string, to: string): void;
    recordOperation(turn: number, tool: string, safetyClass: string, files: string[], success: boolean): void;
    hasRead(filePath: string): boolean;
    hasBeenWritten(filePath: string): boolean;
    isKnownFile(filePath: string): boolean;
    getConsecutiveFailures(): number;
    getRecentOperations(count: number): typeof this.history;
    getFileHistory(filePath: string): {
        reads: number[];
        writes: number[];
    } | null;
    getDeps(filePath: string): string[];
    resolveFiles(operation: ToolOperation): string[];
    memoryEstimateBytes(): number;
    reset(): void;
    private normalizePath;
    private getOrCreate;
    private evictIfNeeded;
}

declare class DualPathVerifier {
    private worldModel;
    private policy;
    private previousCalls;
    constructor(worldModel?: WorldModel, policy?: Partial<RoutingPolicy>);
    verify(toolName: string, input: Record<string, unknown>, turnCount: number): DualPathVerdict;
    recordSuccess(toolName: string, input: Record<string, unknown>, turnCount: number): void;
    recordFailure(toolName: string, input: Record<string, unknown>, turnCount: number): void;
    getWorldModel(): WorldModel;
    getPolicy(): RoutingPolicy;
    reset(): void;
    private recordOperation;
}

export { DualPathVerifier as D, type FastPathResult as F, type RoutingPolicy as R, type SafetyClass as S, type ToolOperation as T, type Verdict as V, WorldModel as W, DEFAULT_ROUTING_POLICY as a, type DualPathVerdict as b, type SlowPathResult as c };