/**
 * Unknown-State Schema
 *
 * Formalizes how RecourseOS handles incomplete, stale, or missing state
 * when classifying mutation consequences.
 *
 * Key concepts:
 * - StateCompleteness: How much required evidence is present
 * - EvidenceFreshness: Whether evidence is current enough to trust
 * - EvidenceRequirement: What evidence is needed per resource type
 * - StateAssessment: Combined evaluation of state quality
 */
import type { EvidenceItem, MissingEvidence } from './mutation.js';
/**
 * State completeness levels determine how confident we can be in classification.
 *
 * complete:    All required evidence present; high-confidence verdict possible
 * partial:     Some required evidence missing; conservative verdict with lower confidence
 * minimal:     Only basic evidence present; NEEDS_REVIEW likely
 * none:        No state available; must use defaults or refuse classification
 */
export type StateCompletenessLevel = 'complete' | 'partial' | 'minimal' | 'none';
export interface StateCompleteness {
    level: StateCompletenessLevel;
    /** Percentage of required evidence present (0-100) */
    percentage: number;
    /** Evidence keys that are present */
    presentKeys: string[];
    /** Evidence keys that are required but missing */
    missingKeys: string[];
    /** Evidence keys that are optional and missing (informational) */
    optionalMissingKeys: string[];
}
/**
 * Freshness levels indicate whether evidence can be trusted.
 *
 * fresh:    Gathered within acceptable window; safe to use
 * aging:    Approaching staleness; acceptable but note in reasoning
 * stale:    Outside acceptable window; treat as missing
 * unknown:  No timestamp available; treat as potentially stale
 */
export type EvidenceFreshnessLevel = 'fresh' | 'aging' | 'stale' | 'unknown';
export interface EvidenceFreshness {
    level: EvidenceFreshnessLevel;
    /** When the evidence was gathered (ISO 8601) */
    gatheredAt?: string;
    /** Maximum acceptable age in seconds */
    maxAgeSeconds: number;
    /** Current age in seconds (if known) */
    ageSeconds?: number;
}
/**
 * Requirement levels determine how missing evidence affects classification.
 *
 * required:     Must be present for any verdict above NEEDS_REVIEW
 * recommended:  Should be present; lowers confidence if missing
 * optional:     Nice to have; no confidence penalty if missing
 */
export type EvidenceRequirementLevel = 'required' | 'recommended' | 'optional';
export interface EvidenceRequirement {
    key: string;
    level: EvidenceRequirementLevel;
    description: string;
    /** If true, absence of this evidence blocks any safe (tier < 4) verdict */
    blocksSafeVerdict: boolean;
    /** Default value to assume if evidence is missing (conservative default) */
    defaultAssumption?: unknown;
    /** Freshness requirement in seconds (default: 3600 = 1 hour) */
    maxFreshnessSeconds?: number;
}
export interface ResourceEvidenceRequirements {
    resourceType: string;
    /** Action this requirement set applies to (usually 'delete') */
    action: 'create' | 'update' | 'delete' | 'any';
    requirements: EvidenceRequirement[];
}
/**
 * Where evidence originated from.
 *
 * terraform_state:  From Terraform state file (prior_state or .tfstate)
 * terraform_plan:   From Terraform plan (before/after values)
 * live_api:         From live API call to cloud provider
 * agent_provided:   Agent submitted via verification protocol
 * cached:           From RecourseOS evidence cache
 * default:          Assumed default (no actual evidence)
 */
export type EvidenceSource = 'terraform_state' | 'terraform_plan' | 'live_api' | 'agent_provided' | 'cached' | 'default';
export interface TrackedEvidence extends EvidenceItem {
    source: EvidenceSource;
    gatheredAt?: string;
    freshnessLevel?: EvidenceFreshnessLevel;
}
/**
 * Combined assessment of state quality for a mutation.
 */
export interface StateAssessment {
    completeness: StateCompleteness;
    freshness: EvidenceFreshness;
    /** Whether any conflicts exist between evidence sources */
    hasConflicts: boolean;
    conflicts?: EvidenceConflict[];
    /** Overall state quality score (0-1) */
    qualityScore: number;
    /** Whether state is sufficient for confident classification */
    sufficientForClassification: boolean;
    /** Evidence sufficiency assessment - a fact about evidence state */
    sufficiency: EvidenceSufficiency;
}
export interface EvidenceConflict {
    key: string;
    sources: Array<{
        source: EvidenceSource;
        value: unknown;
        gatheredAt?: string;
    }>;
    resolution: 'use_freshest' | 'use_most_conservative' | 'requires_review';
}
/**
 * Evidence sufficiency assessment - a fact about evidence state, not a directive.
 * Callers interpret this in their own context to decide what action to take.
 */
export type EvidenceSufficiency = 'sufficient' | 'partial' | 'insufficient' | 'blocking_gaps';
/** @deprecated Use EvidenceSufficiency instead */
export type StateRecommendation = EvidenceSufficiency;
/**
 * Assess state completeness against requirements.
 */
export declare function assessCompleteness(evidence: EvidenceItem[], requirements: EvidenceRequirement[]): StateCompleteness;
/**
 * Assess evidence freshness.
 */
export declare function assessFreshness(gatheredAt: string | undefined, maxAgeSeconds?: number): EvidenceFreshness;
/**
 * Full state assessment combining completeness, freshness, and conflicts.
 */
export declare function assessState(evidence: TrackedEvidence[], requirements: EvidenceRequirement[], maxFreshnessSeconds?: number): StateAssessment;
/**
 * Convert assessment to MissingEvidence array for ConsequenceReport.
 */
export declare function assessmentToMissingEvidence(assessment: StateAssessment, requirements: EvidenceRequirement[]): MissingEvidence[];
/**
 * Calculate confidence modifier based on state assessment.
 * Returns a multiplier (0-1) to apply to base confidence.
 */
export declare function confidenceModifier(assessment: StateAssessment): number;
import type { RequiredEvidence } from './consequence.js';
/**
 * Build RequiredEvidence object for a ConsequenceReport.
 *
 * This is the interface between the state schema and the consequence report.
 * It tells agents exactly what evidence is needed and what's present.
 */
export declare function buildRequiredEvidence(resourceType: string, action: 'create' | 'update' | 'delete', evidence: EvidenceItem[], requirements: EvidenceRequirement[]): RequiredEvidence;
//# sourceMappingURL=state-schema.d.ts.map