@petepetrash/circuit 0.1.0

package/dist/release/schemas.d.ts

@@ -0,0 +1,590 @@
+import { z } from 'zod';
+export declare const ReleaseCapabilityStatus: z.ZodEnum<{
+    missing: "missing";
+    planned: "planned";
+    partial: "partial";
+    implemented: "implemented";
+    release_blocker: "release_blocker";
+    approved_exception: "approved_exception";
+}>;
+export type ReleaseCapabilityStatus = z.infer<typeof ReleaseCapabilityStatus>;
+export declare const PublicClaimStatus: z.ZodEnum<{
+    planned: "planned";
+    release_blocker: "release_blocker";
+    approved_exception: "approved_exception";
+    verified_current: "verified_current";
+}>;
+export type PublicClaimStatus = z.infer<typeof PublicClaimStatus>;
+export declare const ProofScenarioStatus: z.ZodEnum<{
+    missing: "missing";
+    planned: "planned";
+    release_blocker: "release_blocker";
+    approved_exception: "approved_exception";
+    verified_current: "verified_current";
+}>;
+export type ProofScenarioStatus = z.infer<typeof ProofScenarioStatus>;
+export declare const ReleaseItemKind: z.ZodEnum<{
+    mode: "mode";
+    flow: "flow";
+    checkpoint: "checkpoint";
+    connector: "connector";
+    host: "host";
+    proof: "proof";
+    continuity: "continuity";
+    docs: "docs";
+    utility: "utility";
+    router_intent: "router_intent";
+    route_outcome: "route_outcome";
+    customization: "customization";
+    plan_execution: "plan_execution";
+    safety: "safety";
+}>;
+export type ReleaseItemKind = z.infer<typeof ReleaseItemKind>;
+export declare const ClaimType: z.ZodEnum<{
+    mode: "mode";
+    flow: "flow";
+    connector: "connector";
+    host: "host";
+    proof: "proof";
+    docs: "docs";
+    customization: "customization";
+    safety: "safety";
+    "first-run": "first-run";
+    "plan-execution": "plan-execution";
+}>;
+export type ClaimType = z.infer<typeof ClaimType>;
+export declare const ReleaseSourceRef: z.ZodObject<{
+    id: z.ZodString;
+    path: z.ZodString;
+    note: z.ZodString;
+}, z.core.$strict>;
+export type ReleaseSourceRef = z.infer<typeof ReleaseSourceRef>;
+export declare const CapabilityAxes: z.ZodObject<{
+    invocation: z.ZodOptional<z.ZodString>;
+    intent_hints: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    modes: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    stage_path: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    outputs: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    checkpoint: z.ZodOptional<z.ZodString>;
+    review: z.ZodOptional<z.ZodString>;
+    verification: z.ZodOptional<z.ZodString>;
+    worker_handoff: z.ZodOptional<z.ZodString>;
+    continuity: z.ZodOptional<z.ZodString>;
+    host_surface: z.ZodOptional<z.ZodString>;
+    proof: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type CapabilityAxes = z.infer<typeof CapabilityAxes>;
+export declare const OriginalCapability: z.ZodObject<{
+    id: z.ZodString;
+    kind: z.ZodEnum<{
+        mode: "mode";
+        flow: "flow";
+        checkpoint: "checkpoint";
+        connector: "connector";
+        host: "host";
+        proof: "proof";
+        continuity: "continuity";
+        docs: "docs";
+        utility: "utility";
+        router_intent: "router_intent";
+        route_outcome: "route_outcome";
+        customization: "customization";
+        plan_execution: "plan_execution";
+        safety: "safety";
+    }>;
+    title: z.ZodString;
+    summary: z.ZodString;
+    release_required: z.ZodDefault<z.ZodBoolean>;
+    axes: z.ZodDefault<z.ZodObject<{
+        invocation: z.ZodOptional<z.ZodString>;
+        intent_hints: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        modes: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        stage_path: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        outputs: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        checkpoint: z.ZodOptional<z.ZodString>;
+        review: z.ZodOptional<z.ZodString>;
+        verification: z.ZodOptional<z.ZodString>;
+        worker_handoff: z.ZodOptional<z.ZodString>;
+        continuity: z.ZodOptional<z.ZodString>;
+        host_surface: z.ZodOptional<z.ZodString>;
+        proof: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    source_refs: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;
+export type OriginalCapability = z.infer<typeof OriginalCapability>;
+export declare const OriginalCapabilitySnapshot: z.ZodObject<{
+    schema_version: z.ZodLiteral<1>;
+    sources: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        path: z.ZodString;
+        note: z.ZodString;
+    }, z.core.$strict>>;
+    capabilities: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        kind: z.ZodEnum<{
+            mode: "mode";
+            flow: "flow";
+            checkpoint: "checkpoint";
+            connector: "connector";
+            host: "host";
+            proof: "proof";
+            continuity: "continuity";
+            docs: "docs";
+            utility: "utility";
+            router_intent: "router_intent";
+            route_outcome: "route_outcome";
+            customization: "customization";
+            plan_execution: "plan_execution";
+            safety: "safety";
+        }>;
+        title: z.ZodString;
+        summary: z.ZodString;
+        release_required: z.ZodDefault<z.ZodBoolean>;
+        axes: z.ZodDefault<z.ZodObject<{
+            invocation: z.ZodOptional<z.ZodString>;
+            intent_hints: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            modes: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            stage_path: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            outputs: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            checkpoint: z.ZodOptional<z.ZodString>;
+            review: z.ZodOptional<z.ZodString>;
+            verification: z.ZodOptional<z.ZodString>;
+            worker_handoff: z.ZodOptional<z.ZodString>;
+            continuity: z.ZodOptional<z.ZodString>;
+            host_surface: z.ZodOptional<z.ZodString>;
+            proof: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+        source_refs: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type OriginalCapabilitySnapshot = z.infer<typeof OriginalCapabilitySnapshot>;
+export declare const FlowAxisSupportRecord: z.ZodObject<{
+    allowed_depths: z.ZodArray<z.ZodEnum<{
+        low: "low";
+        medium: "medium";
+        high: "high";
+    }>>;
+    supports_tournament: z.ZodBoolean;
+    supports_autonomous: z.ZodBoolean;
+    default: z.ZodObject<{
+        depth: z.ZodEnum<{
+            low: "low";
+            medium: "medium";
+            high: "high";
+        }>;
+        tournament: z.ZodBoolean;
+        tournament_n: z.ZodNumber;
+        autonomous: z.ZodBoolean;
+    }, z.core.$strict>;
+    tournament_fan_out_stage: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type FlowAxisSupportRecord = z.infer<typeof FlowAxisSupportRecord>;
+export declare const CurrentCapability: z.ZodObject<{
+    id: z.ZodString;
+    kind: z.ZodEnum<{
+        mode: "mode";
+        flow: "flow";
+        checkpoint: "checkpoint";
+        connector: "connector";
+        host: "host";
+        proof: "proof";
+        continuity: "continuity";
+        docs: "docs";
+        utility: "utility";
+        router_intent: "router_intent";
+        route_outcome: "route_outcome";
+        customization: "customization";
+        plan_execution: "plan_execution";
+        safety: "safety";
+    }>;
+    title: z.ZodString;
+    status: z.ZodEnum<{
+        missing: "missing";
+        planned: "planned";
+        partial: "partial";
+        implemented: "implemented";
+        release_blocker: "release_blocker";
+        approved_exception: "approved_exception";
+    }>;
+    summary: z.ZodString;
+    evidence: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    readiness_refs: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    axes: z.ZodDefault<z.ZodObject<{
+        invocation: z.ZodOptional<z.ZodString>;
+        intent_hints: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        modes: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        stage_path: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        outputs: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        checkpoint: z.ZodOptional<z.ZodString>;
+        review: z.ZodOptional<z.ZodString>;
+        verification: z.ZodOptional<z.ZodString>;
+        worker_handoff: z.ZodOptional<z.ZodString>;
+        continuity: z.ZodOptional<z.ZodString>;
+        host_surface: z.ZodOptional<z.ZodString>;
+        proof: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type CurrentCapability = z.infer<typeof CurrentCapability>;
+export declare const FlowCapabilityRecord: z.ZodObject<{
+    id: z.ZodString;
+    source: z.ZodString;
+    command_path: z.ZodOptional<z.ZodString>;
+    contract_path: z.ZodOptional<z.ZodString>;
+    axis_support: z.ZodObject<{
+        allowed_depths: z.ZodArray<z.ZodEnum<{
+            low: "low";
+            medium: "medium";
+            high: "high";
+        }>>;
+        supports_tournament: z.ZodBoolean;
+        supports_autonomous: z.ZodBoolean;
+        default: z.ZodObject<{
+            depth: z.ZodEnum<{
+                low: "low";
+                medium: "medium";
+                high: "high";
+            }>;
+            tournament: z.ZodBoolean;
+            tournament_n: z.ZodNumber;
+            autonomous: z.ZodBoolean;
+        }, z.core.$strict>;
+        tournament_fan_out_stage: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+    stages: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    reports: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    writers: z.ZodObject<{
+        compose: z.ZodNumber;
+        close: z.ZodNumber;
+        verification: z.ZodNumber;
+        checkpoint: z.ZodNumber;
+    }, z.core.$strict>;
+    route_outcomes: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    unsupported_route_outcomes: z.ZodDefault<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>;
+export type FlowCapabilityRecord = z.infer<typeof FlowCapabilityRecord>;
+export declare const ConnectorCapabilityRecord: z.ZodObject<{
+    id: z.ZodString;
+    status: z.ZodEnum<{
+        missing: "missing";
+        planned: "planned";
+        partial: "partial";
+        implemented: "implemented";
+        release_blocker: "release_blocker";
+        approved_exception: "approved_exception";
+    }>;
+    filesystem: z.ZodOptional<z.ZodString>;
+    structured_output: z.ZodOptional<z.ZodString>;
+    protocol: z.ZodOptional<z.ZodString>;
+    summary: z.ZodString;
+    readiness_refs: z.ZodDefault<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>;
+export type ConnectorCapabilityRecord = z.infer<typeof ConnectorCapabilityRecord>;
+export declare const HostCapabilityRecord: z.ZodObject<{
+    id: z.ZodString;
+    status: z.ZodEnum<{
+        missing: "missing";
+        planned: "planned";
+        partial: "partial";
+        implemented: "implemented";
+        release_blocker: "release_blocker";
+        approved_exception: "approved_exception";
+    }>;
+    summary: z.ZodString;
+    evidence: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    readiness_refs: z.ZodDefault<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>;
+export type HostCapabilityRecord = z.infer<typeof HostCapabilityRecord>;
+export declare const CurrentCapabilitySnapshot: z.ZodObject<{
+    schema_version: z.ZodLiteral<1>;
+    generated_by: z.ZodString;
+    flows: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        source: z.ZodString;
+        command_path: z.ZodOptional<z.ZodString>;
+        contract_path: z.ZodOptional<z.ZodString>;
+        axis_support: z.ZodObject<{
+            allowed_depths: z.ZodArray<z.ZodEnum<{
+                low: "low";
+                medium: "medium";
+                high: "high";
+            }>>;
+            supports_tournament: z.ZodBoolean;
+            supports_autonomous: z.ZodBoolean;
+            default: z.ZodObject<{
+                depth: z.ZodEnum<{
+                    low: "low";
+                    medium: "medium";
+                    high: "high";
+                }>;
+                tournament: z.ZodBoolean;
+                tournament_n: z.ZodNumber;
+                autonomous: z.ZodBoolean;
+            }, z.core.$strict>;
+            tournament_fan_out_stage: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>;
+        stages: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        reports: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        writers: z.ZodObject<{
+            compose: z.ZodNumber;
+            close: z.ZodNumber;
+            verification: z.ZodNumber;
+            checkpoint: z.ZodNumber;
+        }, z.core.$strict>;
+        route_outcomes: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        unsupported_route_outcomes: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>>;
+    commands: z.ZodObject<{
+        source: z.ZodArray<z.ZodString>;
+        claude_plugin: z.ZodArray<z.ZodString>;
+        codex_plugin: z.ZodArray<z.ZodString>;
+        claude_plugin_skills: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>;
+    connectors: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        status: z.ZodEnum<{
+            missing: "missing";
+            planned: "planned";
+            partial: "partial";
+            implemented: "implemented";
+            release_blocker: "release_blocker";
+            approved_exception: "approved_exception";
+        }>;
+        filesystem: z.ZodOptional<z.ZodString>;
+        structured_output: z.ZodOptional<z.ZodString>;
+        protocol: z.ZodOptional<z.ZodString>;
+        summary: z.ZodString;
+        readiness_refs: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>>;
+    hosts: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        status: z.ZodEnum<{
+            missing: "missing";
+            planned: "planned";
+            partial: "partial";
+            implemented: "implemented";
+            release_blocker: "release_blocker";
+            approved_exception: "approved_exception";
+        }>;
+        summary: z.ZodString;
+        evidence: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        readiness_refs: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>>;
+    capabilities: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        kind: z.ZodEnum<{
+            mode: "mode";
+            flow: "flow";
+            checkpoint: "checkpoint";
+            connector: "connector";
+            host: "host";
+            proof: "proof";
+            continuity: "continuity";
+            docs: "docs";
+            utility: "utility";
+            router_intent: "router_intent";
+            route_outcome: "route_outcome";
+            customization: "customization";
+            plan_execution: "plan_execution";
+            safety: "safety";
+        }>;
+        title: z.ZodString;
+        status: z.ZodEnum<{
+            missing: "missing";
+            planned: "planned";
+            partial: "partial";
+            implemented: "implemented";
+            release_blocker: "release_blocker";
+            approved_exception: "approved_exception";
+        }>;
+        summary: z.ZodString;
+        evidence: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        readiness_refs: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        axes: z.ZodDefault<z.ZodObject<{
+            invocation: z.ZodOptional<z.ZodString>;
+            intent_hints: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            modes: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            stage_path: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            outputs: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            checkpoint: z.ZodOptional<z.ZodString>;
+            review: z.ZodOptional<z.ZodString>;
+            verification: z.ZodOptional<z.ZodString>;
+            worker_handoff: z.ZodOptional<z.ZodString>;
+            continuity: z.ZodOptional<z.ZodString>;
+            host_surface: z.ZodOptional<z.ZodString>;
+            proof: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type CurrentCapabilitySnapshot = z.infer<typeof CurrentCapabilitySnapshot>;
+export declare const ParityException: z.ZodObject<{
+    id: z.ZodString;
+    capability_id: z.ZodOptional<z.ZodString>;
+    claim_id: z.ZodOptional<z.ZodString>;
+    proof_id: z.ZodOptional<z.ZodString>;
+    status: z.ZodEnum<{
+        release_blocker: "release_blocker";
+        approved_exception: "approved_exception";
+    }>;
+    readiness_ref: z.ZodString;
+    rationale: z.ZodString;
+    public_wording: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type ParityException = z.infer<typeof ParityException>;
+export declare const ParityExceptionLedger: z.ZodObject<{
+    schema_version: z.ZodLiteral<1>;
+    exceptions: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        capability_id: z.ZodOptional<z.ZodString>;
+        claim_id: z.ZodOptional<z.ZodString>;
+        proof_id: z.ZodOptional<z.ZodString>;
+        status: z.ZodEnum<{
+            release_blocker: "release_blocker";
+            approved_exception: "approved_exception";
+        }>;
+        readiness_ref: z.ZodString;
+        rationale: z.ZodString;
+        public_wording: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type ParityExceptionLedger = z.infer<typeof ParityExceptionLedger>;
+export declare const PublicClaim: z.ZodObject<{
+    id: z.ZodString;
+    claim: z.ZodString;
+    type: z.ZodEnum<{
+        mode: "mode";
+        flow: "flow";
+        connector: "connector";
+        host: "host";
+        proof: "proof";
+        docs: "docs";
+        customization: "customization";
+        safety: "safety";
+        "first-run": "first-run";
+        "plan-execution": "plan-execution";
+    }>;
+    status: z.ZodEnum<{
+        planned: "planned";
+        release_blocker: "release_blocker";
+        approved_exception: "approved_exception";
+        verified_current: "verified_current";
+    }>;
+    surfaces: z.ZodArray<z.ZodString>;
+    backing: z.ZodDefault<z.ZodObject<{
+        capability_ids: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        proof_ids: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        exception_ids: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        test_paths: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        script_checks: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>>;
+    user_risk: z.ZodString;
+    readiness_refs: z.ZodDefault<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>;
+export type PublicClaim = z.infer<typeof PublicClaim>;
+export declare const PublicClaimLedger: z.ZodObject<{
+    schema_version: z.ZodLiteral<1>;
+    claims: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        claim: z.ZodString;
+        type: z.ZodEnum<{
+            mode: "mode";
+            flow: "flow";
+            connector: "connector";
+            host: "host";
+            proof: "proof";
+            docs: "docs";
+            customization: "customization";
+            safety: "safety";
+            "first-run": "first-run";
+            "plan-execution": "plan-execution";
+        }>;
+        status: z.ZodEnum<{
+            planned: "planned";
+            release_blocker: "release_blocker";
+            approved_exception: "approved_exception";
+            verified_current: "verified_current";
+        }>;
+        surfaces: z.ZodArray<z.ZodString>;
+        backing: z.ZodDefault<z.ZodObject<{
+            capability_ids: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            proof_ids: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            exception_ids: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            test_paths: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            script_checks: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        }, z.core.$strict>>;
+        user_risk: z.ZodString;
+        readiness_refs: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type PublicClaimLedger = z.infer<typeof PublicClaimLedger>;
+export declare const ProofScenario: z.ZodObject<{
+    id: z.ZodString;
+    title: z.ZodString;
+    category: z.ZodEnum<{
+        continuity: "continuity";
+        failure: "failure";
+        customization: "customization";
+        "first-run": "first-run";
+        "plan-execution": "plan-execution";
+        "doing-work": "doing-work";
+        deciding: "deciding";
+    }>;
+    command: z.ZodString;
+    expected_flow: z.ZodOptional<z.ZodString>;
+    expected_outcome: z.ZodString;
+    summary_contract: z.ZodString;
+    redaction_policy: z.ZodString;
+    required_files: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    status: z.ZodEnum<{
+        missing: "missing";
+        planned: "planned";
+        release_blocker: "release_blocker";
+        approved_exception: "approved_exception";
+        verified_current: "verified_current";
+    }>;
+    backing_paths: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    exception_ids: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    readiness_refs: z.ZodDefault<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>;
+export type ProofScenario = z.infer<typeof ProofScenario>;
+export declare const ProofScenarioIndex: z.ZodObject<{
+    schema_version: z.ZodLiteral<1>;
+    scenarios: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        title: z.ZodString;
+        category: z.ZodEnum<{
+            continuity: "continuity";
+            failure: "failure";
+            customization: "customization";
+            "first-run": "first-run";
+            "plan-execution": "plan-execution";
+            "doing-work": "doing-work";
+            deciding: "deciding";
+        }>;
+        command: z.ZodString;
+        expected_flow: z.ZodOptional<z.ZodString>;
+        expected_outcome: z.ZodString;
+        summary_contract: z.ZodString;
+        redaction_policy: z.ZodString;
+        required_files: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        status: z.ZodEnum<{
+            missing: "missing";
+            planned: "planned";
+            release_blocker: "release_blocker";
+            approved_exception: "approved_exception";
+            verified_current: "verified_current";
+        }>;
+        backing_paths: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        exception_ids: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        readiness_refs: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type ProofScenarioIndex = z.infer<typeof ProofScenarioIndex>;
+export declare const ReleaseReadinessReport: z.ZodObject<{
+    schema_version: z.ZodLiteral<1>;
+    summary: z.ZodString;
+    blockers: z.ZodArray<z.ZodString>;
+    warnings: z.ZodArray<z.ZodString>;
+    next_actions: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;
+export type ReleaseReadinessReport = z.infer<typeof ReleaseReadinessReport>;
+//# sourceMappingURL=schemas.d.ts.map

package/dist/release/schemas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../src/release/schemas.ts"],"names":[],"mappings":"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"}