/**
 * verify_change — the deterministic verification feedback loop (change: add-verification-feedback-loop).
 *
 * Composes the existing diff-based conclusions into ONE ordered, actionable receipt: what the
 * change breaks, who it affects, and which tests to run — each item with its subject, the check
 * that produced it, a severity, and a single next action. It performs no new analysis and invents
 * no finding codes; it projects the signals its component conclusions already compute.
 *
 * Today it composes `blast_radius` — which itself already composes `select_tests` (tests to run)
 * and the spec/memory/decision drift passes — plus `structural_diff` (removed / re-signed functions
 * and new calls into deprecated code), the generated-file guard (`generated-file-edited`: a
 * generated file or lockfile edited without its source; change: add-generated-file-guard), the
 * phantom-reference check (imports, named exports, and packages the diff adds that resolve to
 * nothing; change: add-phantom-reference-findings), and structural_diff's check-weakening facts (a
 * test removed, skipped, or stripped of assertions, an expected value edited, a suppression or a
 * discarded error added, a check config relaxed; change: add-check-weakening-findings). It is
 * advisory, read-only, offline, and grader-not-author:
 * it names the tests to run and the breaks to fix; it never runs the tests or edits a file.
 *
 * NoRedundantConclusions: each component still answers its own question. verify_change only
 * assembles their answers for one diff into one next-action list.
 */
import { type BlastRadiusBriefing } from './blast-radius.js';
import { type DiffGuardResult } from '../generated-file-guard.js';
import { type PhantomReferenceResult } from '../phantom-references.js';
import { type ClassifiedFinding, type EnforcementPolicy, type GovernanceFinding } from './enforcement-policy.js';
type Severity = 'critical' | 'error' | 'warning' | 'info';
/** One actionable line of the receipt. */
export interface ReceiptItem {
    subject: string;
    /** The component check that produced this item. */
    check: string;
    severity: Severity;
    /** The single next action for the agent or human. */
    nextAction: string;
}
export interface VerifyChangeInput {
    directory: string;
    baseRef?: string;
}
interface StructuralDiffShape {
    summary?: {
        removedFunctions?: number;
        signatureChanges?: number;
        deprecatedCallsAdded?: number;
    };
    removed?: Array<{
        name?: string;
        file?: string;
    }>;
    signatureChanged?: Array<{
        name?: string;
        file?: string;
    }>;
    deprecatedCalls?: {
        added?: Array<{
            callerName?: string;
            calleeName?: string;
            file?: string;
        }>;
    };
    checkWeakening?: {
        baseline?: {
            ref: string;
            commit: string;
        };
        findings?: ClassifiedFinding[];
        notAssessed?: Array<{
            file: string;
            shapes: string[];
            reason: string;
        }>;
        silenced?: Array<{
            code: string;
            subject: string;
        }>;
        boundaries?: string[];
        error?: string;
    };
    error?: string;
}
/**
 * Project a blast-radius briefing and a structural diff into the ordered, severity-ranked receipt.
 * Pure (no I/O) so the projection is tested with synthetic inputs, not only via a real diff.
 */
export declare function projectVerifyReceipt(b: BlastRadiusBriefing, sd: StructuralDiffShape, guard?: DiffGuardResult | {
    error: string;
}, policy?: EnforcementPolicy, references?: PhantomReferenceResult | {
    error: string;
}, payload?: {
    findings: GovernanceFinding[];
    boundaries: string[];
    notAssessed: number;
} | {
    error: string;
}): Record<string, unknown>;
/**
 * Build the ordered verification receipt for a diff. Returns a conclusion-shaped object; a failed
 * blast-radius computation (e.g. an unresolvable base) is returned as an error, not a partial pass.
 */
export declare function handleVerifyChange(input: VerifyChangeInput): Promise<Record<string, unknown>>;
export {};
//# sourceMappingURL=verify-change.d.ts.map