import type { RoutingStage, TaskFeatures } from "./modelRouting.js";
export type EvidenceNumber = number | "unknown";
export type RoutingEvidenceOutcomeType = "stage-started" | "stage-ended" | "routing-fallback" | "human-override" | "final-status";
export type RoutingEvidenceVerdict = "approve" | "reject" | "unknown";
export type RoutingEvidenceFinalStatus = "done" | "failed" | "cancelled" | "unknown";
export interface EvidenceModelIdentity {
    provider: string;
    model: string;
    family?: string;
}
export interface RoutingEvidenceEvent {
    version: 1;
    eventId: string;
    runId: string;
    decisionId: string;
    stage: RoutingStage;
    recordedAt: string;
    policyVersion: string;
    profileVersion: string;
    task: Pick<TaskFeatures, "workKind" | "risk" | "languages" | "fileCount">;
    selected: EvidenceModelIdentity;
    durationMs?: EvidenceNumber;
    fallbackCount?: number;
    rejectionCategory?: string;
    fallback?: {
        from: EvidenceModelIdentity;
        reason: "unavailable" | "unconfigured" | "selection-failed" | "policy-mismatch";
    };
    usage: {
        inputTokens: EvidenceNumber;
        outputTokens: EvidenceNumber;
        cacheReadTokens: EvidenceNumber;
        cacheWriteTokens: EvidenceNumber;
    };
    cost: {
        estimatedUsd: EvidenceNumber;
        observedUsd: EvidenceNumber;
    };
    outcome: {
        type: RoutingEvidenceOutcomeType;
        structuredToolCompliance?: boolean | "unknown";
        verdict?: RoutingEvidenceVerdict;
        laterReversal?: boolean;
        buildIteration: number;
        humanOverride?: boolean;
        finalRunStatus?: RoutingEvidenceFinalStatus;
    };
}
export interface RoutingEvidenceValidation {
    ok: boolean;
    event?: RoutingEvidenceEvent;
    error?: string;
}
export interface StageEvidenceAggregate {
    events: number;
    approvals: number;
    rejections: number;
    reversals: number;
    humanOverrides: number;
    estimatedCostUsd: number;
    observedCostUsd: number;
    unknownEstimatedCostCount: number;
    unknownObservedCostCount: number;
}
export interface RoutingEvidenceAggregate {
    totalEvents: number;
    byStage: Partial<Record<RoutingStage, StageEvidenceAggregate>>;
    byModel: Record<string, StageEvidenceAggregate>;
}
export interface RoutingPolicyRecommendation {
    stage: RoutingStage;
    taskCategory: string;
    sampleCount: number;
    uncertainty: string;
    downstreamEvidence: string;
    expectedTradeoff: string;
    recommendedChange: {
        kind: "prefer-model";
        provider: string;
        model: string;
    } | {
        kind: "adjust-weight";
        capability: string;
        deltaBasisPoints: number;
    } | {
        kind: "cost-mode";
        mode: "quality" | "balanced" | "economy";
    };
    rollback: string;
}
export interface ShadowPolicyComparisonInput {
    stage: RoutingStage;
    selected: EvidenceModelIdentity;
    alternate?: EvidenceModelIdentity;
    selectedEstimatedCostUsd?: EvidenceNumber;
    alternateEstimatedCostUsd?: EvidenceNumber;
    observedOutcome?: {
        verdict?: RoutingEvidenceVerdict;
        finalRunStatus?: RoutingEvidenceFinalStatus;
    };
}
export interface ShadowPolicyComparison {
    stage: RoutingStage;
    sameChoice: boolean;
    selected: string;
    alternate?: string;
    expectedCostDeltaUsd?: number;
    observedOutcome?: ShadowPolicyComparisonInput["observedOutcome"];
    qualityClaim: "not-counterfactual";
}
export declare function validateRoutingEvidenceEvent(value: unknown): RoutingEvidenceValidation;
export declare function aggregateRoutingEvidence(events: readonly RoutingEvidenceEvent[]): RoutingEvidenceAggregate;
export declare function recommendRoutingPolicyChanges(events: readonly RoutingEvidenceEvent[], options?: {
    minimumSamples?: number;
}): RoutingPolicyRecommendation[];
export declare function compareRoutingPolicies(input: ShadowPolicyComparisonInput): ShadowPolicyComparison;