/**
 * `submit_proof` — attach REAL before/after evidence to the receipt.
 *
 * verify_behavior proves the PATTERN against FetchSandbox reference handlers.
 * This proves the FIX against the USER's ACTUAL app: after you apply the fix,
 * run their app against the scenario's probes twice — once on the pre-fix code
 * (bug reproduces) and once on the fixed code (bug gone) — and post the real
 * requests + responses here. The receipt then shows THEIR code's before/after,
 * not a simulation. That's the strongest proof.
 *
 * Typical flow: reproduce the bug locally (capture the buggy responses) →
 * apply the fix → re-run the same probes (capture the fixed responses) →
 * call submit_proof with both, keyed to the run's sandbox_id + flow_run_id.
 */
export interface ProofProbe {
    name: string;
    request: {
        method?: string;
        path?: string;
        body?: unknown;
    };
    before: {
        status?: number;
        body?: unknown;
        error?: string | null;
    };
    after: {
        status?: number;
        body?: unknown;
        error?: string | null;
    };
}
export interface SubmitProofInput {
    sandbox_id: string;
    flow_run_id: string;
    bug_pattern_id: string;
    proofs: ProofProbe[];
    summary?: string;
}
export interface SubmitProofResult {
    ok: boolean;
    confirmed: boolean;
    green_allowed?: boolean;
    proof_grade?: "measured" | "self_reported";
    verdict?: {
        state?: string;
        green_allowed?: boolean;
        reason?: string;
        label?: string;
    };
    probes: number;
    receipt_note?: string;
}
export declare const submitProofTool: {
    name: string;
    description: string;
    inputSchema: {
        type: string;
        properties: {
            sandbox_id: {
                type: string;
                description: string;
            };
            flow_run_id: {
                type: string;
                description: string;
            };
            bug_pattern_id: {
                type: string;
                description: string;
            };
            summary: {
                type: string;
                description: string;
            };
            proofs: {
                type: string;
                description: string;
                items: {
                    type: string;
                    properties: {
                        name: {
                            type: string;
                        };
                        request: {
                            type: string;
                            properties: {
                                method: {
                                    type: string;
                                };
                                path: {
                                    type: string;
                                };
                                body: {};
                            };
                        };
                        before: {
                            type: string;
                            properties: {
                                status: {
                                    type: string;
                                };
                                body: {};
                                error: {
                                    type: string;
                                };
                            };
                        };
                        after: {
                            type: string;
                            properties: {
                                status: {
                                    type: string;
                                };
                                body: {};
                                error: {
                                    type: string;
                                };
                            };
                        };
                    };
                    required: string[];
                };
            };
        };
        required: string[];
    };
};
export declare function runSubmitProof(input: SubmitProofInput): Promise<SubmitProofResult>;