import { z } from 'zod';
/**
 * Task-types (closed-but-append-extensible, #697 axis 5). Only `review-catch` is
 * mined in the first column; the other five are reserved for follow-on columns and
 * carried in the enum so the ledger shape is stable as columns are added.
 */
export declare const TaskTypeSchema: z.ZodEnum<["review-catch", "bug-localization", "diagnostic-harness", "diagnostic-screenshot", "layout-design", "code-impl"]>;
export type TaskType = z.infer<typeof TaskTypeSchema>;
/**
 * Resolution outcome (#697). `partial` is its OWN bucket — never half-credited (a
 * `0.5` is an invented score that smuggles quality-synthesis back in, violating FM-b);
 * `unresolved` is the derived absence of an effective resolution by horizon.
 */
export declare const OutcomeSchema: z.ZodEnum<["correct", "wrong", "partial", "unresolved"]>;
export type Outcome = z.infer<typeof OutcomeSchema>;
/**
 * Closed resolution-source enum (#697 fold 3). There is deliberately NO `llm-judge`
 * member — that makes **FM-b (no LLM-judge in the resolution path) STRUCTURAL**: an
 * LLM-judged resolution is unconstructible at the type/parse boundary, not merely
 * checked. The blind model-diverse head-to-head escape-hatch enters only as a frozen
 * `frozen-label` (a frozen graded result, never a live judge).
 */
export declare const ResolutionSourceSchema: z.ZodEnum<["deterministic-event", "disposition-thread", "frozen-label", "operator-tiebreak"]>;
export type ResolutionSource = z.infer<typeof ResolutionSourceSchema>;
/**
 * Layer-B attribution provenance (#697 `{ ref, commitSha }`) — DISTINCT from the spine
 * miner's `ProvenanceRecord` (which keys on a PR number); a capability claim references
 * a thread/primitive `ref` + the commit it was asserted against.
 */
export declare const CapabilityProvenanceSchema: z.ZodObject<{
    ref: z.ZodEffects<z.ZodString, string, string>;
    commitSha: z.ZodString;
}, "strip", z.ZodTypeAny, {
    commitSha: string;
    ref: string;
}, {
    commitSha: string;
    ref: string;
}>;
export type CapabilityProvenance = z.infer<typeof CapabilityProvenanceSchema>;
/**
 * An append-only output-time claim. `agentSource` is a STABLE Layer-B actor-id (a
 * cohort seat id or a review-backend catalog id); model/backend identity is NEVER
 * folded into it (kept as separate optional `payload` metadata) so the hit-rate
 * aggregates across model swaps (#697 fold 5 left ADR-078 untouched; ADR-078
 * `agent_source` has since converged on the same seat-id space — amended
 * 2026-07-15, strategy#879).
 */
export declare const CapabilityClaimSchema: z.ZodObject<{
    claimId: z.ZodEffects<z.ZodString, string, string>;
    agentSource: z.ZodEffects<z.ZodString, string, string>;
    taskType: z.ZodEnum<["review-catch", "bug-localization", "diagnostic-harness", "diagnostic-screenshot", "layout-design", "code-impl"]>;
    claimKind: z.ZodEffects<z.ZodString, string, string>;
    provenance: z.ZodObject<{
        ref: z.ZodEffects<z.ZodString, string, string>;
        commitSha: z.ZodString;
    }, "strip", z.ZodTypeAny, {
        commitSha: string;
        ref: string;
    }, {
        commitSha: string;
        ref: string;
    }>;
    /** The source primitive's stable native id — the `claimId` discriminator that survives re-enumeration. */
    nativeKey: z.ZodEffects<z.ZodString, string, string>;
    assertedAt: z.ZodString;
    /** Descriptive metadata (incl. model/backend) — NEVER part of `claimId` (identity ≠ content). */
    payload: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
}, "strip", z.ZodTypeAny, {
    provenance: {
        commitSha: string;
        ref: string;
    };
    claimId: string;
    agentSource: string;
    taskType: "review-catch" | "bug-localization" | "diagnostic-harness" | "diagnostic-screenshot" | "layout-design" | "code-impl";
    claimKind: string;
    nativeKey: string;
    assertedAt: string;
    payload?: Record<string, unknown> | undefined;
}, {
    provenance: {
        commitSha: string;
        ref: string;
    };
    claimId: string;
    agentSource: string;
    taskType: "review-catch" | "bug-localization" | "diagnostic-harness" | "diagnostic-screenshot" | "layout-design" | "code-impl";
    claimKind: string;
    nativeKey: string;
    assertedAt: string;
    payload?: Record<string, unknown> | undefined;
}>;
export type CapabilityClaim = z.infer<typeof CapabilityClaimSchema>;
/**
 * An append-only ground-truth-time resolution. The log may carry N resolutions per
 * claim (accept → walked back → operator-adjudicated); the regenerator selects exactly
 * one effective terminal per `resolutionHorizon` (#697 fold 2).
 */
export declare const CapabilityResolutionSchema: z.ZodObject<{
    resolutionId: z.ZodEffects<z.ZodString, string, string>;
    claimId: z.ZodEffects<z.ZodString, string, string>;
    outcome: z.ZodEnum<["correct", "wrong", "partial", "unresolved"]>;
    resolutionSource: z.ZodEnum<["deterministic-event", "disposition-thread", "frozen-label", "operator-tiebreak"]>;
    evidenceRef: z.ZodEffects<z.ZodString, string, string>;
    resolvedAt: z.ZodString;
    /**
     * Explicit supersession chain — preferred over `resolvedAt` ordering when present.
     * `nonEmpty` (not bare `z.string()`): a `""` pointer would be neither `undefined` nor a
     * real resolutionId, silently activating chain logic on a ghost target (CR).
     */
    supersedesResolutionId: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
}, "strip", z.ZodTypeAny, {
    outcome: "partial" | "unresolved" | "correct" | "wrong";
    claimId: string;
    resolutionId: string;
    resolutionSource: "deterministic-event" | "disposition-thread" | "frozen-label" | "operator-tiebreak";
    evidenceRef: string;
    resolvedAt: string;
    supersedesResolutionId?: string | undefined;
}, {
    outcome: "partial" | "unresolved" | "correct" | "wrong";
    claimId: string;
    resolutionId: string;
    resolutionSource: "deterministic-event" | "disposition-thread" | "frozen-label" | "operator-tiebreak";
    evidenceRef: string;
    resolvedAt: string;
    supersedesResolutionId?: string | undefined;
}>;
export type CapabilityResolution = z.infer<typeof CapabilityResolutionSchema>;
/**
 * One derived row of the regenerable cache. `hitRate = correctN / decisiveN` where
 * `decisiveN = correctN + wrongN`; `partial` and `unresolved` are BOTH excluded from
 * the rate (reported as their own counts). `hitRate` is `null` when `decisiveN === 0`
 * (no decisive evidence yet — never `0/0` NaN). The full distribution is always present.
 */
export declare const CapabilityLedgerRowSchema: z.ZodObject<{
    agentSource: z.ZodString;
    taskType: z.ZodEnum<["review-catch", "bug-localization", "diagnostic-harness", "diagnostic-screenshot", "layout-design", "code-impl"]>;
    correctN: z.ZodNumber;
    wrongN: z.ZodNumber;
    partialN: z.ZodNumber;
    unresolvedN: z.ZodNumber;
    decisiveN: z.ZodNumber;
    hitRate: z.ZodNullable<z.ZodNumber>;
    lastResolved: z.ZodNullable<z.ZodString>;
}, "strip", z.ZodTypeAny, {
    agentSource: string;
    taskType: "review-catch" | "bug-localization" | "diagnostic-harness" | "diagnostic-screenshot" | "layout-design" | "code-impl";
    correctN: number;
    wrongN: number;
    partialN: number;
    unresolvedN: number;
    decisiveN: number;
    hitRate: number | null;
    lastResolved: string | null;
}, {
    agentSource: string;
    taskType: "review-catch" | "bug-localization" | "diagnostic-harness" | "diagnostic-screenshot" | "layout-design" | "code-impl";
    correctN: number;
    wrongN: number;
    partialN: number;
    unresolvedN: number;
    decisiveN: number;
    hitRate: number | null;
    lastResolved: string | null;
}>;
export type CapabilityLedgerRow = z.infer<typeof CapabilityLedgerRowSchema>;
export declare const CapabilityLedgerSchema: z.ZodObject<{
    /** The asOf bound for "settled" resolutions — the back-mining analog of the frozen corpus. */
    resolutionHorizon: z.ZodEffects<z.ZodString, string, string>;
    rows: z.ZodArray<z.ZodObject<{
        agentSource: z.ZodString;
        taskType: z.ZodEnum<["review-catch", "bug-localization", "diagnostic-harness", "diagnostic-screenshot", "layout-design", "code-impl"]>;
        correctN: z.ZodNumber;
        wrongN: z.ZodNumber;
        partialN: z.ZodNumber;
        unresolvedN: z.ZodNumber;
        decisiveN: z.ZodNumber;
        hitRate: z.ZodNullable<z.ZodNumber>;
        lastResolved: z.ZodNullable<z.ZodString>;
    }, "strip", z.ZodTypeAny, {
        agentSource: string;
        taskType: "review-catch" | "bug-localization" | "diagnostic-harness" | "diagnostic-screenshot" | "layout-design" | "code-impl";
        correctN: number;
        wrongN: number;
        partialN: number;
        unresolvedN: number;
        decisiveN: number;
        hitRate: number | null;
        lastResolved: string | null;
    }, {
        agentSource: string;
        taskType: "review-catch" | "bug-localization" | "diagnostic-harness" | "diagnostic-screenshot" | "layout-design" | "code-impl";
        correctN: number;
        wrongN: number;
        partialN: number;
        unresolvedN: number;
        decisiveN: number;
        hitRate: number | null;
        lastResolved: string | null;
    }>, "many">;
}, "strip", z.ZodTypeAny, {
    resolutionHorizon: string;
    rows: {
        agentSource: string;
        taskType: "review-catch" | "bug-localization" | "diagnostic-harness" | "diagnostic-screenshot" | "layout-design" | "code-impl";
        correctN: number;
        wrongN: number;
        partialN: number;
        unresolvedN: number;
        decisiveN: number;
        hitRate: number | null;
        lastResolved: string | null;
    }[];
}, {
    resolutionHorizon: string;
    rows: {
        agentSource: string;
        taskType: "review-catch" | "bug-localization" | "diagnostic-harness" | "diagnostic-screenshot" | "layout-design" | "code-impl";
        correctN: number;
        wrongN: number;
        partialN: number;
        unresolvedN: number;
        decisiveN: number;
        hitRate: number | null;
        lastResolved: string | null;
    }[];
}>;
export type CapabilityLedger = z.infer<typeof CapabilityLedgerSchema>;
/**
 * Deterministic `claimId` (#697 fold 1): a versioned, canonically-serialized digest of
 * the IDENTITY fields only — `payload`/`assertedAt` are excluded so re-back-mining or a
 * payload edit never re-keys the claim and orphans the join (FM-a). `nativeKey` is the
 * primary discriminator (one source primitive can yield N claims); `claimKind` defends
 * against future-task collisions. Key order is irrelevant (canonical serialization).
 */
export declare function deriveClaimId(input: {
    agentSource: string;
    taskType: TaskType;
    claimKind: string;
    provenanceRef: string;
    commitSha: string;
    nativeKey: string;
}): string;
//# sourceMappingURL=schema.d.ts.map