export declare enum RecoverabilityTier {
    REVERSIBLE = 1,// Can be undone with another API call
    RECOVERABLE_WITH_EFFORT = 2,// Can be recreated but requires work
    RECOVERABLE_FROM_BACKUP = 3,// Requires backup/snapshot to restore
    UNRECOVERABLE = 4,// Data is gone forever
    NEEDS_REVIEW = 5
}
export declare const RecoverabilityLabels: Record<RecoverabilityTier, string>;
export type VerdictSource = 'rules' | 'classifier' | 'default';
import type { VerificationSuggestion } from '../core/mutation.js';
export interface RecoverabilityResult {
    tier: RecoverabilityTier;
    label: string;
    reasoning: string;
    source?: VerdictSource;
    confidence?: number;
    classifierAgreement?: boolean;
    verificationSuggestions?: VerificationSuggestion[];
}
export type TerraformAction = 'create' | 'read' | 'update' | 'delete' | 'no-op';
export interface ResourceChange {
    address: string;
    type: string;
    name: string;
    providerName: string;
    actions: TerraformAction[];
    before: Record<string, unknown> | null;
    after: Record<string, unknown> | null;
    afterUnknown: Record<string, unknown>;
}
export interface StateResource {
    address: string;
    type: string;
    name: string;
    providerName: string;
    values: Record<string, unknown>;
    dependsOn: string[];
}
export interface TerraformPlan {
    formatVersion: string;
    terraformVersion: string;
    resourceChanges: ResourceChange[];
    priorState?: TerraformState;
}
export interface TerraformState {
    formatVersion: string;
    terraformVersion: string;
    resources: StateResource[];
}
export interface ResourceDependency {
    address: string;
    dependencyType: 'explicit' | 'implicit';
    referenceAttribute?: string;
}
export interface BlastRadiusChange {
    resource: ResourceChange;
    recoverability: RecoverabilityResult;
    cascadeImpact: CascadeImpact[];
}
export interface CascadeImpact {
    affectedResource: string;
    resourceType: string;
    reason: string;
    depth: number;
    dependencyType: 'explicit' | 'implicit';
}
export interface BlastRadiusReport {
    changes: BlastRadiusChange[];
    summary: BlastRadiusSummary;
}
export interface BlastRadiusSummary {
    totalChanges: number;
    byTier: Record<RecoverabilityTier, number>;
    cascadeImpactCount: number;
    hasUnrecoverable: boolean;
    cascadeByType?: Record<string, number>;
    maxCascadeDepth?: number;
    cascadeSummary?: string;
}
import type { ClassificationContext, ClassificationTrace } from '../analyzer/trace.js';
import type { EvidenceRequirement } from '../core/state-schema.js';
/**
 * Evidence requirements per action type.
 */
export interface ActionEvidenceRequirements {
    create?: EvidenceRequirement[];
    update?: EvidenceRequirement[];
    delete?: EvidenceRequirement[];
}
/**
 * Evidence requirements can be:
 * - Simple: same requirements for all resource types the handler covers
 * - Per-type: different requirements for each resource type (keyed by resource type)
 */
export type HandlerEvidenceRequirements = ActionEvidenceRequirements | Record<string, ActionEvidenceRequirements>;
export interface ResourceHandler {
    resourceTypes: string[];
    /**
     * Evidence requirements for this handler.
     *
     * Simple form (same for all resource types):
     *   evidenceRequirements: { delete: [...] }
     *
     * Per-type form (different per resource type):
     *   evidenceRequirements: {
     *     'aws_iam_role': { delete: [...] },
     *     'aws_iam_user': { delete: [...] },
     *   }
     */
    evidenceRequirements?: HandlerEvidenceRequirements;
    getRecoverability(change: ResourceChange, state: TerraformState | null): RecoverabilityResult;
    getRecoverabilityTraced?(change: ResourceChange, state: TerraformState | null, ctx: ClassificationContext): ClassificationTrace;
    getDependencies(resource: StateResource, allResources: StateResource[]): ResourceDependency[];
}
export type { ClassificationContext, ClassificationTrace };
//# sourceMappingURL=types.d.ts.map