import { type TicketMaterializer } from "../tickets/materializer.js";
import { type SyncTicketResult } from "../tickets/store.js";
import { type ProtectedVerificationRun } from "../verification/protected-runner.js";
import { type ProtectedGradeSource } from "../verification/grade-source.js";
import { type ProtectedAdvisorProvenance } from "../dispatch/advice-source.js";
export type EvidenceKind = "verification-plan" | "executor-result" | "goal-executor-result" | "lease-expiry" | "deterministic-check" | "advisor-output" | "grader-output" | "live-disclosure" | "live-outcome" | "trust-run" | "reflection" | "trust-report";
export type Slice3EvidenceKind = EvidenceKind;
export type EvidenceRecord = {
    schema_version: 1;
    evidence_id: string;
    evidence_kind: EvidenceKind;
    ticket_id: string | null;
    producer_role: string;
    created_at: string;
    payload: Record<string, unknown>;
};
export interface EvidenceReference {
    evidence_id: string;
    sha256: string;
    file_name: string;
}
export interface EvidenceReader {
    read(ref: EvidenceReference): EvidenceRecord;
    references(kind?: EvidenceKind): EvidenceReference[];
    absolutePath(ref: EvidenceReference): string;
}
export interface EvidenceStore extends EvidenceReader {
    write(record: EvidenceRecord): EvidenceWriteResult;
}
export type EvidenceWriteResult = {
    status: "created" | "replayed";
    ref: EvidenceReference;
    record: EvidenceRecord;
};
declare const PROTECTED_RESULT_GATE_WRITER: unique symbol;
declare const PROTECTED_ADVISOR_WRITER: unique symbol;
export declare function assertEvidenceStore(value: unknown): asserts value is EvidenceStore;
export declare function registeredEvidenceKinds(): EvidenceKind[];
export declare function createEvidenceStore(options: {
    evidenceRoot: string;
    packageRoot?: string;
}): EvidenceStore;
export interface ProtectedResultGateEvidenceWriter {
    readonly [PROTECTED_RESULT_GATE_WRITER]: true;
    writeDeterministic(options: {
        evidenceId: string;
        createdAt: string;
        run: ProtectedVerificationRun;
    }): EvidenceWriteResult;
    writeGrade(record: EvidenceRecord, source: ProtectedGradeSource): EvidenceWriteResult;
}
/** Branded writer used only by the protected verification/result-gate authority. */
export declare function createProtectedResultGateEvidenceWriter(evidenceStore: EvidenceStore): ProtectedResultGateEvidenceWriter;
export declare function assertProtectedResultGateEvidenceWriter(value: unknown): asserts value is ProtectedResultGateEvidenceWriter;
export interface ProtectedAdvisorEvidenceWriter {
    readonly [PROTECTED_ADVISOR_WRITER]: true;
    writeAdvice(options: {
        readonly createdAt: string;
    }, provenance: ProtectedAdvisorProvenance): EvidenceWriteResult;
}
/** Branded writer used only by the protected pre-dispatch advisor authority. */
export declare function createProtectedAdvisorEvidenceWriter(evidenceStore: EvidenceStore): ProtectedAdvisorEvidenceWriter;
export declare function assertProtectedAdvisorEvidenceWriter(value: unknown): asserts value is ProtectedAdvisorEvidenceWriter;
export declare function writeTicketBoundEvidence(options: {
    evidenceStore: EvidenceStore;
    ticketMaterializer: TicketMaterializer;
    record: EvidenceRecord;
}): EvidenceWriteResult;
export type GithubProbeCertification = "live" | "non-certifying";
export interface GithubQueueDisclosure {
    schema_version: 1;
    certification: GithubProbeCertification;
    run_id: string;
    contact_surface: "github-api-via-gh";
    expected_spend: "none";
    operation: "read-ready-issues";
    repository: string;
    ready_label: string;
    issue_limit: number;
}
export interface GithubSyncedTicket {
    ticket_id: string;
    content_sha256: string;
    content_file: string;
    record_version: number;
    sync_status: "created" | "refreshed" | "unchanged";
}
export interface GithubQueueProbeResult {
    contacted: boolean;
    disclosure: GithubQueueDisclosure;
    disclosureEvidence?: EvidenceReference;
    outcomeEvidence?: EvidenceReference;
    syncResults: readonly SyncTicketResult[];
}
export declare class GithubQueueProbeError extends Error {
    readonly phase: "contact" | "sync" | "evidence";
    readonly contacted: boolean;
    readonly outcomeEvidence?: EvidenceReference;
    constructor(options: {
        phase: "contact" | "sync" | "evidence";
        contacted: boolean;
        outcomeEvidence?: EvidenceReference;
        cause: unknown;
    });
}
export interface GithubQueueProbeOptions {
    runId: string;
    repository: string;
    readyLabel?: string;
    limit?: number;
    confirmLive: boolean;
    cwd: string;
    evidenceStore: EvidenceStore;
    materializer: TicketMaterializer;
    emitDisclosure: (disclosure: Readonly<GithubQueueDisclosure>, evidence: Readonly<EvidenceReference>) => void;
}
export interface NonCertifyingGithubQueueProbeFixtureOptions extends GithubQueueProbeOptions {
    env: NodeJS.ProcessEnv;
}
/** Certifying path: owns the canonical process, clock, materializer, and evidence writes. */
export declare function runGithubQueueProbe(options: GithubQueueProbeOptions): GithubQueueProbeResult;
/** Offline fixture path: still uses runProcess, but every record is permanently non-certifying. */
export declare function runNonCertifyingGithubQueueProbeFixture(options: NonCertifyingGithubQueueProbeFixtureOptions): GithubQueueProbeResult;
export declare function sanitizeLiveOutcomeError(value: string): string;
export {};