export type ResolveIOAIManagerAction = 'continue' | 'retry_infra' | 'reset_loop_budget' | 'park_repeated_failure' | 'park_ping_pong' | 'manual_handoff';
export interface ResolveIOAIManagerFailureRecord {
    outcome?: string;
    lane?: string;
    stepType?: string;
    failureClass?: string;
    blocker?: string;
    blockerFingerprint?: string;
    evidenceHash?: string;
    changedFiles?: string[];
    artifactPaths?: string[];
    summary?: string;
    recordedAt?: Date | string;
}
export type ResolveIOAIManagerEvidenceStrength = 'none' | 'weak' | 'material' | 'proof';
export interface ResolveIOAIManagerEvidenceAssessment {
    changed: boolean;
    material: boolean;
    strength: ResolveIOAIManagerEvidenceStrength;
    signals: string[];
    evidenceHash: string;
    blockerFingerprint: string;
}
export type ResolveIOAIManagerRecoveryClass = 'advance_after_proof' | 'diagnosis_only' | 'diagnosis_revision' | 'infra_repair' | 'compile_repair' | 'journey_contract_repair' | 'business_proof_repair' | 'release_repair' | 'product_code_repair' | 'blocked_until_new_evidence' | 'manual_handoff' | 'continue';
export interface ResolveIOAIManagerRecoveryPlan {
    recoveryClass: ResolveIOAIManagerRecoveryClass;
    lane: string;
    stepType: string;
    nextActionLabel: string;
    objective: string;
    allowedAction: string;
    productRepairAllowed: boolean;
    expensiveModelAllowed: boolean;
    maxAttemptsBeforePark: number;
    finiteSteps: string[];
    requiredEvidence: string[];
    loopResetEvidence: string[];
    forbiddenActions: string[];
    notes: string[];
}
export type ResolveIOAIManagerRecoveryCheckpointStatus = 'active' | 'parked' | 'manual_handoff' | 'complete';
export interface ResolveIOAIManagerRecoveryCheckpoint {
    checkpointId: string;
    recoveryClass: ResolveIOAIManagerRecoveryClass;
    status: ResolveIOAIManagerRecoveryCheckpointStatus;
    lane: string;
    stepType: string;
    allowedAction: string;
    productRepairAllowed: boolean;
    expensiveModelAllowed: boolean;
    attempts: number;
    maxAttemptsBeforePark: number;
    blockerFingerprint: string;
    evidenceHash: string;
    changedFiles: string[];
    artifactPaths: string[];
    requiredEvidence: string[];
    loopResetEvidence: string[];
    forbiddenActions: string[];
    objective: string;
    nextActionLabel: string;
    createdAt: string;
    updatedAt: string;
}
export type ResolveIOAIManagerRecoveryEvidenceProbeStepKind = 'read_only_diagnosis' | 'rerun_same_gate' | 'infra_preflight' | 'compile_check' | 'route_probe' | 'business_assertion' | 'journey_validation' | 'release_status' | 'diff_scope_check' | 'operator_review';
export interface ResolveIOAIManagerRecoveryEvidenceProbeStep {
    id: string;
    kind: ResolveIOAIManagerRecoveryEvidenceProbeStepKind;
    label: string;
    objective: string;
    required: boolean;
    commandHint?: string;
    artifactExpectation: string;
    successSignal: string;
}
export interface ResolveIOAIManagerRecoveryEvidenceProbe {
    probeId: string;
    checkpointId: string;
    recoveryClass: ResolveIOAIManagerRecoveryClass;
    lane: string;
    stepType: string;
    objective: string;
    evidenceOnly: boolean;
    productRepairAllowed: boolean;
    expensiveModelAllowed: boolean;
    evidenceHashBefore: string;
    blockerFingerprint: string;
    steps: ResolveIOAIManagerRecoveryEvidenceProbeStep[];
    requiredArtifacts: string[];
    acceptanceEvidence: string[];
    stopConditions: string[];
    loopResetEvidence: string[];
    createdAt: string;
}
export type ResolveIOAIManagerRecoveryAutomationMode = 'advance' | 'collect_evidence' | 'read_only_diagnosis' | 'repair_infra' | 'repair_compile' | 'repair_journey_contract' | 'repair_business_assertion' | 'repair_release' | 'targeted_product_repair' | 'manual_review' | 'continue_gate';
export interface ResolveIOAIManagerRecoveryActionRetryPolicy {
    allowImmediateRetry: boolean;
    requireNewEvidence: boolean;
    resetLoopWhen: string[];
    stopWhen: string[];
}
export type ResolveIOAIManagerHotfixFirstReleaseAction = 'wait_for_active_deploy' | 'block_duplicate_deploy' | 'block_duplicate_publish' | 'review_force_deploy' | 'hotfix_release_artifact' | 'deploy_new_artifact_after_release_gate' | 'build_artifact_first';
export type ResolveIOAIManagerHotfixChannel = 'static_ui' | 'backend_js' | 'config' | 'seed_data' | 'cache_invalidation' | 'service_restart' | 'release_artifact' | 'force_deploy_review' | 'new_artifact_deploy' | 'artifact_build';
export interface ResolveIOAIManagerHotfixPlanStep {
    id: string;
    label: string;
    channel: ResolveIOAIManagerHotfixChannel;
    safeToAutoRun: boolean;
    requiresFullDeploy: boolean;
    requiredEvidence: string[];
    successEvidence: string[];
    blockedBy: string[];
}
export interface ResolveIOAIManagerHotfixPlan {
    planId: string;
    label: string;
    recommendedChannel: ResolveIOAIManagerHotfixChannel;
    reason: string;
    fullDeployAvoided: boolean;
    steps: ResolveIOAIManagerHotfixPlanStep[];
    acceptanceEvidence: string[];
    escalationTriggers: string[];
}
export interface ResolveIOAIManagerHotfixFirstReleasePolicyInput {
    surface?: string;
    activeDeploy?: boolean;
    deployFingerprint?: string;
    lastDeployFingerprint?: string;
    publishFingerprint?: string;
    lastPublishFingerprint?: string;
    deployStatus?: string;
    publishStatus?: string;
    sampleDataStatus?: string;
    forceDeploy?: boolean;
    forcePublish?: boolean;
    hasNewArtifact?: boolean;
}
export interface ResolveIOAIManagerHotfixFirstReleasePolicy {
    policy: 'hotfix_first';
    surface: string;
    recommendedAction: ResolveIOAIManagerHotfixFirstReleaseAction;
    label: string;
    reason: string;
    hotfixPreferred: boolean;
    fullDeployAllowed: boolean;
    duplicateDeployBlocked: boolean;
    duplicatePublishBlocked: boolean;
    forceDeployRequiredToRepeat: boolean;
    forcePublishRequiredToRepeat: boolean;
    statuses: {
        deploy: string;
        publish: string;
        sampleData: string;
    };
    fingerprints: {
        current: string;
        last: string;
        matchesLast: boolean;
        publishCurrent: string;
        publishLast: string;
        publishMatchesLast: boolean;
    };
    hotfixPlan: ResolveIOAIManagerHotfixPlan;
    allowedActions: string[];
    forbiddenActions: string[];
    requiredEvidence: string[];
}
export type ResolveIOAIManagerHotfixEvidenceStatus = 'missing' | 'incomplete' | 'passed' | 'blocked';
export interface ResolveIOAIManagerHotfixEvidenceTarget {
    surface?: string;
    host?: string;
    path?: string;
    artifactPath?: string;
    bucket?: string;
    distributionId?: string;
    processName?: string;
    configKey?: string;
    cacheKey?: string;
    seedKey?: string;
}
export interface ResolveIOAIManagerHotfixRemoteChecksumProof {
    host?: string;
    path?: string;
    checksumBefore?: string;
    checksumAfter?: string;
    checksum?: string;
    status?: string;
}
export interface ResolveIOAIManagerHotfixHostStatusProof {
    host?: string;
    status?: string;
    evidence?: string;
    checkCount?: number;
    failedCount?: number;
}
export interface ResolveIOAIManagerHotfixEvidence {
    channel: ResolveIOAIManagerHotfixChannel;
    status?: ResolveIOAIManagerHotfixEvidenceStatus | string;
    target: ResolveIOAIManagerHotfixEvidenceTarget;
    targets?: ResolveIOAIManagerHotfixEvidenceTarget[];
    compiledArtifactPath?: string;
    builtDistPath?: string;
    remoteChecksumBefore?: string;
    remoteChecksumAfter?: string;
    remoteChecksum?: string;
    remoteChecksums?: ResolveIOAIManagerHotfixRemoteChecksumProof[];
    restartEvidence?: string;
    restartResults?: ResolveIOAIManagerHotfixHostStatusProof[];
    healthCheckStatus?: string;
    healthChecks?: ResolveIOAIManagerHotfixHostStatusProof[];
    selfTestStatus?: string;
    selfTests?: ResolveIOAIManagerHotfixHostStatusProof[];
    releaseGateStatus?: string;
    s3UploadResult?: string;
    cloudfrontInvalidationId?: string;
    publicProof?: string;
    configChangeEvidence?: string;
    seedDataEvidence?: string;
    cacheInvalidationEvidence?: string;
    serviceRestartEvidence?: string;
    releaseArtifactFingerprint?: string;
    lastReleaseArtifactFingerprint?: string;
    sourceCommitSha?: string;
    githubCommitUrl?: string;
    gitCommitStatus?: string;
    gitPushStatus?: string;
    committedAt?: Date | string;
    forceDeployReason?: string;
    hotfixCannotResolveReason?: string;
    fullDeployRequested?: boolean;
    recordedAt?: Date | string;
}
export interface ResolveIOAIManagerHotfixEvidenceValidation {
    valid: boolean;
    status: ResolveIOAIManagerHotfixEvidenceStatus;
    channel: ResolveIOAIManagerHotfixChannel | '';
    blockers: string[];
    warnings: string[];
    fullDeployAllowed: boolean;
    fullDeployBlocked: boolean;
    hotfixSatisfied: boolean;
    requiredEvidence: string[];
    successEvidence: string[];
    normalized?: ResolveIOAIManagerHotfixEvidence;
    githubCommitGuard: ResolveIOAIManagerHotfixGitProof;
    policy?: ResolveIOAIManagerHotfixFirstReleasePolicy;
    nextAction: 'record_hotfix_evidence' | 'rerun_release_gate' | 'request_force_deploy_reason' | 'allow_one_full_deploy' | 'park_manual';
}
export type ResolveIOAIManagerHotfixGitProofStatus = 'not_required' | 'missing' | 'invalid' | 'passed';
export interface ResolveIOAIManagerHotfixGitProof {
    required: boolean;
    status: ResolveIOAIManagerHotfixGitProofStatus;
    passed: boolean;
    managerMustCommitBeforeHotfix: boolean;
    channel: ResolveIOAIManagerHotfixChannel | '';
    sourceCommitSha: string;
    githubCommitUrl: string;
    githubCommitSha: string;
    gitCommitStatus: string;
    gitPushStatus: string;
    blockers: string[];
    nextCommands: string[];
    requiredEvidence: string[];
}
export type ResolveIOAIManagerHotfixContinuationAction = 'record_hotfix_evidence' | 'rerun_release_gate' | 'continue_runner' | 'request_force_deploy_reason' | 'allow_one_full_deploy' | 'park_manual';
export interface ResolveIOAIManagerHotfixContinuationInput {
    evidence?: any;
    policy?: ResolveIOAIManagerHotfixFirstReleasePolicy;
    releaseGatePassed?: boolean;
    repeatedFailure?: boolean;
    failureClass?: string;
    blocker?: string;
    now?: Date | string;
}
export interface ResolveIOAIManagerHotfixContinuationDecision {
    action: ResolveIOAIManagerHotfixContinuationAction;
    canContinueRun: boolean;
    canRunFullDeploy: boolean;
    shouldRerunReleaseGate: boolean;
    shouldPark: boolean;
    reason: string;
    blockers: string[];
    warnings: string[];
    requiredEvidence: string[];
    successEvidence: string[];
    nextCommands: string[];
    failureClass: string;
    blockerFingerprint: string;
    githubCommitGuard: ResolveIOAIManagerHotfixGitProof;
    validation: ResolveIOAIManagerHotfixEvidenceValidation;
    recordedAt: string;
}
export interface ResolveIOAIManagerHotfixCommitGuardDecision {
    active: boolean;
    blocked: boolean;
    reason: string;
    nextAction: 'record_hotfix_evidence' | 'continue';
    channel: ResolveIOAIManagerHotfixChannel | '';
    blockers: string[];
    nextCommands: string[];
    requiredEvidence: string[];
    githubCommitGuard: ResolveIOAIManagerHotfixGitProof;
    validation: ResolveIOAIManagerHotfixEvidenceValidation;
}
export type ResolveIOAIManagerHotfixEvidenceRecordSource = 'manual' | 'manager' | 'runner_console' | 'hotfix_script' | 'deploy_script' | 'unknown';
export interface ResolveIOAIManagerHotfixEvidenceRecordInput extends Partial<ResolveIOAIManagerHotfixEvidence> {
    evidence?: any;
    policy?: ResolveIOAIManagerHotfixFirstReleasePolicy;
    recordId?: string;
    reason?: string;
    recordedBy?: string;
    source?: ResolveIOAIManagerHotfixEvidenceRecordSource | string;
    now?: Date | string;
}
export interface ResolveIOAIManagerHotfixEvidenceRecord {
    recordId: string;
    recordedAt: string;
    recordedBy: string;
    source: ResolveIOAIManagerHotfixEvidenceRecordSource | string;
    reason: string;
    channel: ResolveIOAIManagerHotfixChannel | '';
    status: ResolveIOAIManagerHotfixEvidenceStatus;
    nextAction: ResolveIOAIManagerHotfixEvidenceValidation['nextAction'];
    valid: boolean;
    hotfixSatisfied: boolean;
    fullDeployAllowed: boolean;
    fullDeployBlocked: boolean;
    requiredFields: string[];
    missingFields: string[];
    evidence: ResolveIOAIManagerHotfixEvidence | undefined;
    validation: ResolveIOAIManagerHotfixEvidenceValidation;
    sourceCommitSha: string;
    githubCommitUrl: string;
    gitCommitStatus: string;
    gitPushStatus: string;
    githubCommitRequired: boolean;
    githubCommitProofPassed: boolean;
    commitProofStatus: 'not_required' | 'missing' | 'invalid' | 'passed';
    commitFirstProtocol: 'not_required' | 'commit_first_hotfix';
    commit_first_protocol: 'not_required' | 'commit_first_hotfix';
    commitFirstProtocolSatisfied: boolean;
    commit_first_protocol_satisfied: boolean;
    liveHotfixBlockedUntilCommit: boolean;
    live_hotfix_blocked_until_commit: boolean;
    liveHotfixAllowed: boolean;
    live_hotfix_allowed: boolean;
    managerMustCommitBeforeHotfix: boolean;
    githubCommitGuard: ResolveIOAIManagerHotfixGitProof;
    readyForReleaseGate: boolean;
    readyForContinuation: boolean;
    managerContinuationAllowed: boolean;
    manager_continuation_allowed: boolean;
}
export type ResolveIOAIManagerHotfixDurabilityStatus = 'not_required' | 'waiting_for_commit_proof' | 'ready_for_live_hotfix' | 'ready_for_release_gate' | 'ready_for_continuation';
export interface ResolveIOAIManagerHotfixDurabilityContractInput {
    action?: string;
    reason?: string;
    evidence?: any;
    policy?: ResolveIOAIManagerHotfixFirstReleasePolicy;
    continuation?: Partial<ResolveIOAIManagerHotfixContinuationDecision> | null;
    existing?: any;
    source?: string;
    releaseGatePassed?: boolean;
    now?: Date | string;
}
export interface ResolveIOAIManagerHotfixDurabilityContract {
    contractId: string;
    contract_id: string;
    createdAt: string;
    created_at: string;
    updatedAt: string;
    updated_at: string;
    source: string;
    required: boolean;
    action: string;
    status: ResolveIOAIManagerHotfixDurabilityStatus;
    reason: string;
    canPrepareHotfixPatch: boolean;
    can_prepare_hotfix_patch: boolean;
    canHotfixBackend: boolean;
    can_hotfix_backend: boolean;
    liveHotfixBlockedUntilCommit: boolean;
    live_hotfix_blocked_until_commit: boolean;
    durabilityProtocol: 'not_required' | 'commit_first_hotfix';
    durability_protocol: 'not_required' | 'commit_first_hotfix';
    commitFirstProtocolRequired: boolean;
    commit_first_protocol_required: boolean;
    commitFirstProtocolSatisfied: boolean;
    commit_first_protocol_satisfied: boolean;
    liveHotfixAllowed: boolean;
    live_hotfix_allowed: boolean;
    managerContinuationAllowed: boolean;
    manager_continuation_allowed: boolean;
    commitProofPassed: boolean;
    commit_proof_passed: boolean;
    commitProofStatus: ResolveIOAIManagerHotfixGitProofStatus | 'missing';
    commit_proof_status: ResolveIOAIManagerHotfixGitProofStatus | 'missing';
    sourceCommitSha: string;
    source_commit_sha: string;
    githubCommitUrl: string;
    github_commit_url: string;
    gitCommitStatus: string;
    git_commit_status: string;
    gitPushStatus: string;
    git_push_status: string;
    missingCommitProofFields: string[];
    missing_commit_proof_fields: string[];
    nextSafeAction: string;
    next_safe_action: string;
    phaseOrder: string[];
    phase_order: string[];
    requiredFields: string[];
    required_fields: string[];
    requiredEvidence: string[];
    required_evidence: string[];
    successCriteria: string[];
    success_criteria: string[];
    forbiddenActions: string[];
    forbidden_actions: string[];
    hotfixCommitGuard: Record<string, any>;
    hotfix_commit_guard: Record<string, any>;
    githubCommitGuard: ResolveIOAIManagerHotfixGitProof;
    github_commit_guard: ResolveIOAIManagerHotfixGitProof;
    validation: ResolveIOAIManagerHotfixEvidenceValidation;
    continuation?: Partial<ResolveIOAIManagerHotfixContinuationDecision> | null;
    extraRequest: string;
    extra_request: string;
}
export interface ResolveIOAIManagerRecoveryActionPacket {
    actionId: string;
    checkpointId: string;
    probeId: string;
    recoveryClass: ResolveIOAIManagerRecoveryClass;
    mode: ResolveIOAIManagerRecoveryAutomationMode;
    singleActionOnly: boolean;
    allowedDispatchAction: ResolveIOAIManagerRecoveryActionDispatchAction;
    label: string;
    lane: string;
    stepType: string;
    primaryStepKind: ResolveIOAIManagerRecoveryEvidenceProbeStepKind | 'none';
    objective: string;
    evidenceOnly: boolean;
    autoRunnable: boolean;
    productRepairAllowed: boolean;
    expensiveModelAllowed: boolean;
    costCeilingUsd: number;
    requiredStateTransition: string;
    proofRequiredBeforeContinuation: boolean;
    canResetLoopAfterEvidence: boolean;
    maxAttemptsBeforePark: number;
    requiredArtifacts: string[];
    nextCommands: string[];
    successCriteria: string[];
    exitCriteria: string[];
    retryPolicy: ResolveIOAIManagerRecoveryActionRetryPolicy;
    releasePolicy?: ResolveIOAIManagerHotfixFirstReleasePolicy;
    blockedReason?: string;
    createdAt: string;
}
export type ResolveIOAIManagerRecoveryActionDispatchAction = 'run_evidence_probe' | 'run_read_only_diagnosis' | 'run_infra_repair' | 'run_compile_repair' | 'run_journey_contract_repair' | 'run_business_assertion_repair' | 'run_release_repair' | 'run_targeted_product_repair' | 'advance' | 'continue_gate' | 'park_manual';
export interface ResolveIOAIManagerAutoDispatchPolicyInput {
    dispatchAction?: ResolveIOAIManagerRecoveryActionDispatchAction | string;
    directive?: Partial<ResolveIOAIManagerRecoveryExecutionDirective>;
    action?: Partial<ResolveIOAIManagerRecoveryActionPacket>;
    includeJourneyContractRepair?: boolean;
    includeReleaseRepair?: boolean;
    includeBusinessProofRepair?: boolean;
    includeProductRepair?: boolean;
}
export type ResolveIOAIManagerRecoveryActionDispatchStatus = 'queued' | 'started' | 'completed' | 'failed' | 'parked';
export interface ResolveIOAIManagerRecoveryActionDispatchRecord {
    dispatchId: string;
    actionId: string;
    checkpointId: string;
    probeId: string;
    mode: ResolveIOAIManagerRecoveryAutomationMode;
    dispatchAction: ResolveIOAIManagerRecoveryActionDispatchAction;
    status: ResolveIOAIManagerRecoveryActionDispatchStatus;
    evidenceHash: string;
    blockerFingerprint: string;
    productRepairAllowed: boolean;
    expensiveModelAllowed: boolean;
    reason: string;
    artifactPaths: string[];
    startedAt?: string;
    completedAt?: string;
    createdAt: string;
}
export interface ResolveIOAIManagerRecoveryActionDispatchInput {
    action?: ResolveIOAIManagerRecoveryActionPacket;
    history?: ResolveIOAIManagerRecoveryActionDispatchRecord[];
    current?: ResolveIOAIManagerFailureRecord;
    autonomyPolicy?: ResolveIOAIManagerAutonomyPolicyInput;
    operatorApproved?: boolean;
    now?: Date | string;
}
export interface ResolveIOAIManagerRecoveryActionDispatchDecision {
    dispatchAction: ResolveIOAIManagerRecoveryActionDispatchAction;
    allowed: boolean;
    reason: string;
    status: ResolveIOAIManagerRecoveryActionDispatchStatus;
    canRunProductRepair: boolean;
    canRunExpensiveModel: boolean;
    shouldRecordDispatch: boolean;
    requiresNewEvidence: boolean;
    newEvidence: boolean;
    autonomyPolicy?: ResolveIOAIManagerAutonomyPolicyDecision;
    dispatchRecord?: ResolveIOAIManagerRecoveryActionDispatchRecord;
}
export type ResolveIOAIManagerAutonomyMode = 'manual_only' | 'monitor_only' | 'auto_retry_within_budget';
export interface ResolveIOAIManagerAutonomyPolicyInput {
    mode?: ResolveIOAIManagerAutonomyMode | string;
    currentSpendUsd?: number;
    budgetSoftUsd?: number;
    budgetHardUsd?: number;
    projectedActionCostUsd?: number;
    dispatchAction?: ResolveIOAIManagerRecoveryActionDispatchAction | string;
    expectedValueScore?: number;
    minExpectedValueScore?: number;
    evidenceStrength?: ResolveIOAIManagerEvidenceStrength | string;
    materialEvidence?: boolean;
    newEvidence?: boolean;
    evidenceSignals?: string[];
    sameEvidenceAlreadyAttempted?: boolean;
    allowEvidenceProbeWithoutExpectedValue?: boolean;
    operatorApproved?: boolean;
}
export interface ResolveIOAIManagerRetryExpectedValueInput {
    dispatchAction?: ResolveIOAIManagerRecoveryActionDispatchAction | string;
    projectedActionCostUsd?: number;
    currentSpendUsd?: number;
    budgetHardUsd?: number;
    failureClass?: string;
    recoveryClass?: ResolveIOAIManagerRecoveryClass | string;
    evidenceStrength?: ResolveIOAIManagerEvidenceStrength | string;
    materialEvidence?: boolean;
    newEvidence?: boolean;
    evidenceSignals?: string[];
    sameEvidenceAlreadyAttempted?: boolean;
}
export interface ResolveIOAIManagerRetryExpectedValueEstimate {
    score: number;
    minScore: number;
    positive: boolean;
    source: 'estimated';
    confidence: 'low' | 'medium' | 'high';
    reason: string;
    signals: string[];
}
export interface ResolveIOAIManagerAutonomyPolicyDecision {
    mode: ResolveIOAIManagerAutonomyMode;
    canAutoDispatch: boolean;
    canManualDispatch: boolean;
    blocked: boolean;
    requiresHumanApproval: boolean;
    reason: string;
    currentSpendUsd: number;
    projectedActionCostUsd: number;
    projectedSpendUsd: number;
    budgetSoftUsd: number;
    budgetHardUsd: number;
    softBudgetExceeded: boolean;
    hardBudgetExceeded: boolean;
    dispatchAction: string;
    expectedValueScore: number;
    minExpectedValueScore: number;
    expectedValueKnown: boolean;
    expectedValueSource: 'provided' | 'estimated';
    expectedValuePositive: boolean;
    evidenceStrength: ResolveIOAIManagerEvidenceStrength;
    materialEvidence: boolean;
    newEvidence: boolean;
    evidenceBacked: boolean;
    evidenceSignals: string[];
    recommendedControl: 'manual_only' | 'monitor_only' | 'auto_retry_within_budget' | 'increase_budget_or_manual';
    forbiddenActions: string[];
    requiredEvidence: string[];
}
export type ResolveIOAIManagerRecoveryExecutionPhase = 'evidence' | 'diagnosis' | 'infra' | 'compile' | 'journey' | 'business_proof' | 'release' | 'product_repair' | 'advance' | 'manual';
export interface ResolveIOAIManagerRecoveryExecutionDirectiveInput {
    action?: ResolveIOAIManagerRecoveryActionPacket;
    dispatchDecision?: ResolveIOAIManagerRecoveryActionDispatchDecision;
    current?: ResolveIOAIManagerFailureRecord;
    autonomyPolicy?: ResolveIOAIManagerAutonomyPolicyInput;
    surface?: string;
    now?: Date | string;
}
export interface ResolveIOAIManagerRecoveryExecutionDirective {
    directiveId: string;
    surface: string;
    dispatchAction: ResolveIOAIManagerRecoveryActionDispatchAction;
    phase: ResolveIOAIManagerRecoveryExecutionPhase;
    allowed: boolean;
    status: ResolveIOAIManagerRecoveryActionDispatchStatus;
    reason: string;
    singleActionOnly: boolean;
    allowedDispatchAction: ResolveIOAIManagerRecoveryActionDispatchAction;
    lane: string;
    stepType: string;
    nextActionLabel: string;
    rerunReason: string;
    evidenceOnly: boolean;
    autoRunnable: boolean;
    productRepairAllowed: boolean;
    expensiveModelAllowed: boolean;
    costCeilingUsd: number;
    requiredStateTransition: string;
    proofRequiredBeforeContinuation: boolean;
    canRunProductRepair: boolean;
    canRunExpensiveModel: boolean;
    canResetLoopAfterEvidence: boolean;
    requiresNewEvidence: boolean;
    newEvidence: boolean;
    autonomyPolicy?: ResolveIOAIManagerAutonomyPolicyDecision;
    maxAttemptsBeforePark: number;
    requiredArtifacts: string[];
    nextCommands: string[];
    successCriteria: string[];
    exitCriteria: string[];
    forbiddenActions: string[];
    dispatchRecord?: ResolveIOAIManagerRecoveryActionDispatchRecord;
    releasePolicy?: ResolveIOAIManagerHotfixFirstReleasePolicy;
    createdAt: string;
}
export type ResolveIOAIManagerRecoveryExecutionProofStatus = 'proof_ready' | 'waiting_for_execution' | 'waiting_for_new_evidence' | 'blocked_same_evidence' | 'manual_handoff';
export interface ResolveIOAIManagerRecoveryExecutionProofContractInput {
    directive?: ResolveIOAIManagerRecoveryExecutionDirective;
    previous?: ResolveIOAIManagerFailureRecord;
    current?: ResolveIOAIManagerFailureRecord;
    requiredEvidence?: any;
    now?: Date | string;
}
export interface ResolveIOAIManagerRecoveryExecutionProofContract {
    contractId: string;
    directiveId: string;
    surface: string;
    dispatchAction: ResolveIOAIManagerRecoveryActionDispatchAction;
    phase: ResolveIOAIManagerRecoveryExecutionPhase;
    status: ResolveIOAIManagerRecoveryExecutionProofStatus;
    canContinueRun: boolean;
    canRunProductRepair: boolean;
    canRunExpensiveModel: boolean;
    canResetLoopBudget: boolean;
    proofRequiredBeforeContinuation: boolean;
    requiresNewEvidence: boolean;
    newEvidence: boolean;
    materialEvidence: boolean;
    evidenceStrength: ResolveIOAIManagerEvidenceStrength;
    evidenceSignals: string[];
    startingFailureClass: string;
    startingBlockerFingerprint: string;
    startingEvidenceHash: string;
    latestFailureClass: string;
    latestBlockerFingerprint: string;
    latestEvidenceHash: string;
    requiredEvidence: string[];
    missingEvidence: string[];
    artifactPaths: string[];
    changedFiles: string[];
    blockers: string[];
    nextAllowedAction: string;
    forbiddenActions: string[];
    createdAt: string;
}
export interface ResolveIOAIManagerRecoveryCheckpointInput {
    plan: ResolveIOAIManagerRecoveryPlan;
    current?: ResolveIOAIManagerFailureRecord;
    previousCheckpoint?: ResolveIOAIManagerRecoveryCheckpoint;
    now?: Date | string;
}
export type ResolveIOAIManagerRecoveryGateAction = 'allow' | 'collect_new_evidence' | 'reject_action' | 'manual_handoff' | 'complete';
export interface ResolveIOAIManagerRecoveryGateInput {
    checkpoint: ResolveIOAIManagerRecoveryCheckpoint;
    current?: ResolveIOAIManagerFailureRecord;
    proposedAction?: string;
    operatorApproved?: boolean;
    now?: Date | string;
}
export interface ResolveIOAIManagerRecoveryGateDecision {
    action: ResolveIOAIManagerRecoveryGateAction;
    reason: string;
    canRunProductRepair: boolean;
    canRunExpensiveModel: boolean;
    shouldResetLoopBudget: boolean;
    shouldIncrementAttempt: boolean;
    newEvidence: boolean;
    materialEvidence: boolean;
    evidenceStrength: ResolveIOAIManagerEvidenceStrength;
    evidenceSignals: string[];
    blockerFingerprint: string;
    evidenceHash: string;
    missingEvidence: string[];
    checkpoint: ResolveIOAIManagerRecoveryCheckpoint;
}
export interface ResolveIOAIManagerRecoveryEvidenceProbeInput {
    checkpoint: ResolveIOAIManagerRecoveryCheckpoint;
    current?: ResolveIOAIManagerFailureRecord;
    now?: Date | string;
}
export interface ResolveIOAIManagerRecoveryActionPacketInput {
    plan?: ResolveIOAIManagerRecoveryPlan;
    checkpoint: ResolveIOAIManagerRecoveryCheckpoint;
    probe?: ResolveIOAIManagerRecoveryEvidenceProbe;
    current?: ResolveIOAIManagerFailureRecord;
    now?: Date | string;
}
export interface ResolveIOAIManagerRecoveryPlanInput {
    action?: ResolveIOAIManagerAction | string;
    reason?: string;
    failureClass?: string;
    lane?: string;
    stepType?: string;
    blocker?: string;
    sameFailureCount?: number;
    pingPongCount?: number;
    newEvidence?: boolean;
    productRepairFailure?: boolean;
    changedFiles?: string[];
    artifactPaths?: string[];
    maxSameFailureRepeats?: number;
}
export interface ResolveIOAIManagerPolicyInput {
    history?: ResolveIOAIManagerFailureRecord[];
    current?: ResolveIOAIManagerFailureRecord;
    maxSameFailureRepeats?: number;
    maxPingPongTransitions?: number;
    infraFailureClasses?: string[];
    ignoredFailureClasses?: string[];
}
export interface ResolveIOAIManagerPolicyDecision {
    action: ResolveIOAIManagerAction;
    reason: string;
    failureClass: string;
    blockerFingerprint: string;
    evidenceHash: string;
    sameFailureCount: number;
    pingPongCount: number;
    newEvidence: boolean;
    materialEvidence: boolean;
    evidenceStrength: ResolveIOAIManagerEvidenceStrength;
    evidenceSignals: string[];
    loopBudgetShouldReset: boolean;
    productRepairFailure: boolean;
    recoveryPlan: ResolveIOAIManagerRecoveryPlan;
    recoveryCheckpoint: ResolveIOAIManagerRecoveryCheckpoint;
    recoveryEvidenceProbe: ResolveIOAIManagerRecoveryEvidenceProbe;
    recoveryAction: ResolveIOAIManagerRecoveryActionPacket;
}
export interface ResolveIOAIManagerRecoveryReplayMatrixInput {
    surface?: string;
    includeJourneyContractRepair?: boolean;
    includeReleaseRepair?: boolean;
    includeProductRepair?: boolean;
    maxSameFailureRepeats?: number;
}
export interface ResolveIOAIManagerRecoveryReplayCase {
    caseId: string;
    surface: string;
    pass: boolean;
    action: string;
    reason: string;
    recoveryClass: string;
    dispatchAction: string;
    safeAutoDispatch: boolean;
    expectedSafeAutoDispatch: boolean;
    productRepairAllowed: boolean;
    loopBudgetShouldReset: boolean;
    materialEvidence: boolean;
    evidenceStrength: ResolveIOAIManagerEvidenceStrength;
    hotfixFirst?: boolean;
    fullDeployAllowed?: boolean;
    details?: Record<string, any>;
}
export declare function estimateResolveIOAIManagerRetryExpectedValue(input?: ResolveIOAIManagerRetryExpectedValueInput): ResolveIOAIManagerRetryExpectedValueEstimate;
export declare function decideResolveIOAIManagerAutonomyPolicy(input?: ResolveIOAIManagerAutonomyPolicyInput): ResolveIOAIManagerAutonomyPolicyDecision;
export declare function normalizeResolveIOAIManagerHotfixEvidence(value: any, policy?: ResolveIOAIManagerHotfixFirstReleasePolicy): ResolveIOAIManagerHotfixEvidence | undefined;
export declare function evaluateResolveIOAIManagerHotfixGitProof(value: any, channelHint?: ResolveIOAIManagerHotfixChannel | ''): ResolveIOAIManagerHotfixGitProof;
export declare function validateResolveIOAIManagerHotfixEvidence(value: any, options?: {
    policy?: ResolveIOAIManagerHotfixFirstReleasePolicy;
}): ResolveIOAIManagerHotfixEvidenceValidation;
export declare function buildResolveIOAIManagerHotfixEvidenceRecord(input?: ResolveIOAIManagerHotfixEvidenceRecordInput): ResolveIOAIManagerHotfixEvidenceRecord;
export declare function buildResolveIOAIManagerHotfixDurabilityContract(input?: ResolveIOAIManagerHotfixDurabilityContractInput): ResolveIOAIManagerHotfixDurabilityContract;
export declare function decideResolveIOAIManagerHotfixContinuation(input?: ResolveIOAIManagerHotfixContinuationInput): ResolveIOAIManagerHotfixContinuationDecision;
export declare function decideResolveIOAIManagerHotfixCommitGuard(input?: ResolveIOAIManagerHotfixContinuationInput): ResolveIOAIManagerHotfixCommitGuardDecision;
export declare function buildResolveIOAIManagerHotfixFirstReleasePolicy(input?: ResolveIOAIManagerHotfixFirstReleasePolicyInput): ResolveIOAIManagerHotfixFirstReleasePolicy;
export declare function isResolveIOAIManagerSafeAutoDispatch(input: ResolveIOAIManagerAutoDispatchPolicyInput | ResolveIOAIManagerRecoveryActionDispatchAction | string | undefined): boolean;
export declare function normalizeResolveIOAIManagerFailureClass(value: any): string;
export declare function fingerprintResolveIOAIManagerBlocker(value: any): string;
export declare function hashResolveIOAIManagerEvidence(record: ResolveIOAIManagerFailureRecord | undefined): string;
export declare function buildResolveIOAIManagerRecoveryCheckpoint(input: ResolveIOAIManagerRecoveryCheckpointInput): ResolveIOAIManagerRecoveryCheckpoint;
export declare function buildResolveIOAIManagerRecoveryEvidenceProbe(input: ResolveIOAIManagerRecoveryEvidenceProbeInput): ResolveIOAIManagerRecoveryEvidenceProbe;
export declare function buildResolveIOAIManagerRecoveryActionPacket(input: ResolveIOAIManagerRecoveryActionPacketInput): ResolveIOAIManagerRecoveryActionPacket;
export declare function decideResolveIOAIManagerRecoveryActionDispatch(input: ResolveIOAIManagerRecoveryActionDispatchInput): ResolveIOAIManagerRecoveryActionDispatchDecision;
export declare function appendResolveIOAIManagerRecoveryActionDispatch(history: ResolveIOAIManagerRecoveryActionDispatchRecord[] | undefined, record: ResolveIOAIManagerRecoveryActionDispatchRecord | undefined, limit?: number): ResolveIOAIManagerRecoveryActionDispatchRecord[];
export declare function buildResolveIOAIManagerRecoveryExecutionDirective(input: ResolveIOAIManagerRecoveryExecutionDirectiveInput): ResolveIOAIManagerRecoveryExecutionDirective;
export declare function buildResolveIOAIManagerRecoveryExecutionProofContract(input?: ResolveIOAIManagerRecoveryExecutionProofContractInput): ResolveIOAIManagerRecoveryExecutionProofContract;
export declare function validateResolveIOAIManagerRecoveryExecutionProofContract(value: any): {
    valid: boolean;
    status: ResolveIOAIManagerRecoveryExecutionProofStatus | 'blocked';
    blockers: string[];
    normalized: ResolveIOAIManagerRecoveryExecutionProofContract;
};
export declare function assessResolveIOAIManagerEvidenceChange(previous: (ResolveIOAIManagerFailureRecord | ResolveIOAIManagerRecoveryCheckpoint | undefined), current: ResolveIOAIManagerFailureRecord | undefined, fallbackObjective?: string): ResolveIOAIManagerEvidenceAssessment;
export declare function decideResolveIOAIManagerRecoveryGate(input: ResolveIOAIManagerRecoveryGateInput): ResolveIOAIManagerRecoveryGateDecision;
export declare function buildResolveIOAIManagerRecoveryPlan(input?: ResolveIOAIManagerRecoveryPlanInput): ResolveIOAIManagerRecoveryPlan;
export declare function decideResolveIOAIManagerPolicy(input: ResolveIOAIManagerPolicyInput): ResolveIOAIManagerPolicyDecision;
export declare function buildResolveIOAIManagerRecoveryReplayMatrix(input?: ResolveIOAIManagerRecoveryReplayMatrixInput): ResolveIOAIManagerRecoveryReplayCase[];
