@lore-co/core 0.1.17 → 0.1.19

package/dist/reliability-schemas.d.ts

@@ -0,0 +1,723 @@
+import { z } from "zod";
+export declare const RELIABILITY_CONTRACT_VERSION: "reliability-v1";
+export declare const RELIABILITY_V1_MEDIA_TYPE: "application/vnd.lore.reliability-v1+json";
+export declare const CAPTURE_EXTRACT_JOB_VERSION: "capture-extract-v1";
+export declare const MEMORY_EMBED_JOB_VERSION: "memory-embed-v1";
+export declare const ReliabilityContractVersionSchema: z.ZodLiteral<"reliability-v1">;
+export type ReliabilityContractVersion = z.infer<typeof ReliabilityContractVersionSchema>;
+export declare const ReliabilityOperationSchema: z.ZodEnum<{
+    capture: "capture";
+    retrieval: "retrieval";
+    guard: "guard";
+}>;
+export type ReliabilityOperation = z.infer<typeof ReliabilityOperationSchema>;
+export declare const ReliabilityStatusSchema: z.ZodEnum<{
+    ok: "ok";
+    degraded: "degraded";
+    blocked: "blocked";
+    overridden: "overridden";
+    failed: "failed";
+}>;
+export type ReliabilityStatus = z.infer<typeof ReliabilityStatusSchema>;
+export declare const ReliabilitySourceSchema: z.ZodEnum<{
+    live: "live";
+    cache: "cache";
+    local_queue: "local_queue";
+    none: "none";
+}>;
+export type ReliabilitySource = z.infer<typeof ReliabilitySourceSchema>;
+export declare const ReliabilityFallbackModeSchema: z.ZodEnum<{
+    local_queue: "local_queue";
+    none: "none";
+    live_lexical: "live_lexical";
+    cached_context: "cached_context";
+    cached_policy: "cached_policy";
+    break_glass: "break_glass";
+}>;
+export type ReliabilityFallbackMode = z.infer<typeof ReliabilityFallbackModeSchema>;
+export declare const ReliabilityReasonCodeSchema: z.ZodEnum<{
+    semantic_unavailable: "semantic_unavailable";
+    cached_context: "cached_context";
+    cached_policy: "cached_policy";
+    live_success: "live_success";
+    idempotent_replay: "idempotent_replay";
+    lexical_fallback: "lexical_fallback";
+    live_unavailable: "live_unavailable";
+    no_usable_cache: "no_usable_cache";
+    capture_queued: "capture_queued";
+    local_persistence_failed: "local_persistence_failed";
+    governed_rule: "governed_rule";
+    policy_unavailable: "policy_unavailable";
+    policy_expired: "policy_expired";
+    user_override: "user_override";
+    invalid_response: "invalid_response";
+    integration_unsupported: "integration_unsupported";
+}>;
+export type ReliabilityReasonCode = z.infer<typeof ReliabilityReasonCodeSchema>;
+export declare const ReliabilityFreshnessSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    asOf: z.ZodISODateTime;
+    ageMs: z.ZodNumber;
+    validUntil: z.ZodNullable<z.ZodISODateTime>;
+    state: z.ZodLiteral<"fresh">;
+}, z.core.$strict>, z.ZodObject<{
+    asOf: z.ZodISODateTime;
+    ageMs: z.ZodNumber;
+    validUntil: z.ZodNullable<z.ZodISODateTime>;
+    state: z.ZodLiteral<"stale">;
+}, z.core.$strict>, z.ZodObject<{
+    state: z.ZodLiteral<"unknown">;
+    asOf: z.ZodNull;
+    ageMs: z.ZodNull;
+    validUntil: z.ZodNull;
+}, z.core.$strict>], "state">;
+export type ReliabilityFreshness = z.infer<typeof ReliabilityFreshnessSchema>;
+export declare const ReliabilityPolicyReferenceSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    source: z.ZodLiteral<"live">;
+    version: z.ZodString;
+    loadedAt: z.ZodISODateTime;
+    validUntil: z.ZodNullable<z.ZodISODateTime>;
+}, z.core.$strict>, z.ZodObject<{
+    source: z.ZodLiteral<"cache">;
+    version: z.ZodString;
+    loadedAt: z.ZodISODateTime;
+    validUntil: z.ZodISODateTime;
+}, z.core.$strict>, z.ZodObject<{
+    source: z.ZodLiteral<"none">;
+    version: z.ZodNull;
+    loadedAt: z.ZodNull;
+    validUntil: z.ZodNull;
+}, z.core.$strict>], "source">;
+export type ReliabilityPolicyReference = z.infer<typeof ReliabilityPolicyReferenceSchema>;
+export declare const ReliabilityMetadataSchema: z.ZodObject<{
+    contractVersion: z.ZodLiteral<"reliability-v1">;
+    operation: z.ZodEnum<{
+        capture: "capture";
+        retrieval: "retrieval";
+        guard: "guard";
+    }>;
+    status: z.ZodEnum<{
+        ok: "ok";
+        degraded: "degraded";
+        blocked: "blocked";
+        overridden: "overridden";
+        failed: "failed";
+    }>;
+    source: z.ZodEnum<{
+        live: "live";
+        cache: "cache";
+        local_queue: "local_queue";
+        none: "none";
+    }>;
+    freshness: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        asOf: z.ZodISODateTime;
+        ageMs: z.ZodNumber;
+        validUntil: z.ZodNullable<z.ZodISODateTime>;
+        state: z.ZodLiteral<"fresh">;
+    }, z.core.$strict>, z.ZodObject<{
+        asOf: z.ZodISODateTime;
+        ageMs: z.ZodNumber;
+        validUntil: z.ZodNullable<z.ZodISODateTime>;
+        state: z.ZodLiteral<"stale">;
+    }, z.core.$strict>, z.ZodObject<{
+        state: z.ZodLiteral<"unknown">;
+        asOf: z.ZodNull;
+        ageMs: z.ZodNull;
+        validUntil: z.ZodNull;
+    }, z.core.$strict>], "state">;
+    fallback: z.ZodEnum<{
+        local_queue: "local_queue";
+        none: "none";
+        live_lexical: "live_lexical";
+        cached_context: "cached_context";
+        cached_policy: "cached_policy";
+        break_glass: "break_glass";
+    }>;
+    policy: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        source: z.ZodLiteral<"live">;
+        version: z.ZodString;
+        loadedAt: z.ZodISODateTime;
+        validUntil: z.ZodNullable<z.ZodISODateTime>;
+    }, z.core.$strict>, z.ZodObject<{
+        source: z.ZodLiteral<"cache">;
+        version: z.ZodString;
+        loadedAt: z.ZodISODateTime;
+        validUntil: z.ZodISODateTime;
+    }, z.core.$strict>, z.ZodObject<{
+        source: z.ZodLiteral<"none">;
+        version: z.ZodNull;
+        loadedAt: z.ZodNull;
+        validUntil: z.ZodNull;
+    }, z.core.$strict>], "source">;
+    reasons: z.ZodArray<z.ZodEnum<{
+        semantic_unavailable: "semantic_unavailable";
+        cached_context: "cached_context";
+        cached_policy: "cached_policy";
+        live_success: "live_success";
+        idempotent_replay: "idempotent_replay";
+        lexical_fallback: "lexical_fallback";
+        live_unavailable: "live_unavailable";
+        no_usable_cache: "no_usable_cache";
+        capture_queued: "capture_queued";
+        local_persistence_failed: "local_persistence_failed";
+        governed_rule: "governed_rule";
+        policy_unavailable: "policy_unavailable";
+        policy_expired: "policy_expired";
+        user_override: "user_override";
+        invalid_response: "invalid_response";
+        integration_unsupported: "integration_unsupported";
+    }>>;
+    requestId: z.ZodNullable<z.ZodString>;
+}, z.core.$strict>;
+export type ReliabilityMetadata = z.infer<typeof ReliabilityMetadataSchema>;
+export declare const CaptureAcknowledgementSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    state: z.ZodLiteral<"queued_local">;
+    durability: z.ZodLiteral<"local_machine">;
+    replayPending: z.ZodLiteral<true>;
+    replayed: z.ZodLiteral<false>;
+    processing: z.ZodLiteral<"pending_upload">;
+    contractVersion: z.ZodLiteral<"reliability-v1">;
+    captureId: z.ZodUUID;
+    idempotencyKey: z.ZodString;
+    acknowledgedAt: z.ZodISODateTime;
+}, z.core.$strict>, z.ZodObject<{
+    state: z.ZodLiteral<"committed_server">;
+    durability: z.ZodLiteral<"workspace_database">;
+    replayPending: z.ZodLiteral<false>;
+    replayed: z.ZodBoolean;
+    processing: z.ZodEnum<{
+        pending_extraction: "pending_extraction";
+        completed: "completed";
+    }>;
+    eventId: z.ZodUUID;
+    memoryIds: z.ZodArray<z.ZodUUID>;
+    contractVersion: z.ZodLiteral<"reliability-v1">;
+    captureId: z.ZodUUID;
+    idempotencyKey: z.ZodString;
+    acknowledgedAt: z.ZodISODateTime;
+}, z.core.$strict>], "state">;
+export type CaptureAcknowledgement = z.infer<typeof CaptureAcknowledgementSchema>;
+export declare const CaptureProcessingResultSchema: z.ZodObject<{
+    created: z.ZodNumber;
+    duplicates: z.ZodNumber;
+    reconciled: z.ZodNumber;
+    superseded: z.ZodNumber;
+}, z.core.$strict>;
+export type CaptureProcessingResult = z.infer<typeof CaptureProcessingResultSchema>;
+export declare const CaptureExtractJobPayloadSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    jobVersion: z.ZodLiteral<"capture-extract-v1">;
+    kind: z.ZodLiteral<"observation">;
+    captureId: z.ZodUUID;
+    eventId: z.ZodUUID;
+    idempotencyKey: z.ZodString;
+    requestHash: z.ZodString;
+    interaction: z.ZodObject<{
+        agent: z.ZodString;
+        workspaceId: z.ZodUUID;
+        eventId: z.ZodUUID;
+        userId: z.ZodOptional<z.ZodUUID>;
+        scope: z.ZodObject<{
+            organization: z.ZodString;
+            project: z.ZodOptional<z.ZodString>;
+            repo: z.ZodOptional<z.ZodString>;
+            path: z.ZodOptional<z.ZodString>;
+            component: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>;
+        sessionId: z.ZodString;
+        messages: z.ZodArray<z.ZodObject<{
+            role: z.ZodEnum<{
+                system: "system";
+                user: "user";
+                assistant: "assistant";
+                tool: "tool";
+            }>;
+            timestamp: z.ZodOptional<z.ZodISODateTime>;
+            content: z.ZodString;
+            id: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+    provenance: z.ZodObject<{
+        task: z.ZodNullable<z.ZodString>;
+        connector: z.ZodString;
+        externalEventId: z.ZodString;
+        redacted: z.ZodBoolean;
+        redactionFindings: z.ZodArray<z.ZodObject<{
+            kind: z.ZodEnum<{
+                jwt: "jwt";
+                circular: "circular";
+                pre_redacted: "pre_redacted";
+                private_key: "private_key";
+                authorization: "authorization";
+                connection_url: "connection_url";
+                provider_token: "provider_token";
+                credential: "credential";
+            }>;
+            count: z.ZodNumber;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+}, z.core.$strict>, z.ZodObject<{
+    jobVersion: z.ZodLiteral<"capture-extract-v1">;
+    kind: z.ZodLiteral<"paired_turn">;
+    captureId: z.ZodUUID;
+    eventId: z.ZodUUID;
+    idempotencyKey: z.ZodString;
+    requestHash: z.ZodString;
+    interaction: z.ZodObject<{
+        agent: z.ZodString;
+        workspaceId: z.ZodUUID;
+        eventId: z.ZodUUID;
+        userId: z.ZodOptional<z.ZodUUID>;
+        scope: z.ZodObject<{
+            organization: z.ZodString;
+            project: z.ZodOptional<z.ZodString>;
+            repo: z.ZodOptional<z.ZodString>;
+            path: z.ZodOptional<z.ZodString>;
+            component: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>;
+        sessionId: z.ZodString;
+        messages: z.ZodArray<z.ZodObject<{
+            role: z.ZodEnum<{
+                system: "system";
+                user: "user";
+                assistant: "assistant";
+                tool: "tool";
+            }>;
+            timestamp: z.ZodOptional<z.ZodISODateTime>;
+            content: z.ZodString;
+            id: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+    provenance: z.ZodObject<{
+        previousAssistantMessageId: z.ZodNullable<z.ZodString>;
+        connector: z.ZodString;
+        externalEventId: z.ZodString;
+        redacted: z.ZodBoolean;
+        redactionFindings: z.ZodArray<z.ZodObject<{
+            kind: z.ZodEnum<{
+                jwt: "jwt";
+                circular: "circular";
+                pre_redacted: "pre_redacted";
+                private_key: "private_key";
+                authorization: "authorization";
+                connection_url: "connection_url";
+                provider_token: "provider_token";
+                credential: "credential";
+            }>;
+            count: z.ZodNumber;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+}, z.core.$strict>], "kind">;
+export type CaptureExtractJobPayload = z.infer<typeof CaptureExtractJobPayloadSchema>;
+export declare const CaptureExtractJobResultSchema: z.ZodObject<{
+    memoryIds: z.ZodArray<z.ZodUUID>;
+    result: z.ZodObject<{
+        created: z.ZodNumber;
+        duplicates: z.ZodNumber;
+        reconciled: z.ZodNumber;
+        superseded: z.ZodNumber;
+    }, z.core.$strict>;
+    jobVersion: z.ZodLiteral<"capture-extract-v1">;
+    captureId: z.ZodUUID;
+    eventId: z.ZodUUID;
+}, z.core.$strict>;
+export type CaptureExtractJobResult = z.infer<typeof CaptureExtractJobResultSchema>;
+export declare const MemoryEmbedJobPayloadV1Schema: z.ZodObject<{
+    jobVersion: z.ZodLiteral<"memory-embed-v1">;
+    workspaceId: z.ZodUUID;
+    memoryId: z.ZodUUID;
+    updatedAt: z.ZodISODateTime;
+    fingerprint: z.ZodString;
+    contentSha256: z.ZodString;
+    provider: z.ZodString;
+    model: z.ZodString;
+    embeddingSpaceId: z.ZodString;
+    dimensions: z.ZodNumber;
+}, z.core.$strict>;
+export type MemoryEmbedJobPayloadV1 = z.infer<typeof MemoryEmbedJobPayloadV1Schema>;
+export declare const MemoryEmbedJobResultV1Schema: z.ZodObject<{
+    jobVersion: z.ZodLiteral<"memory-embed-v1">;
+    memoryId: z.ZodUUID;
+    embeddingSpaceId: z.ZodString;
+    outcome: z.ZodEnum<{
+        stale: "stale";
+        stored: "stored";
+    }>;
+}, z.core.$strict>;
+export type MemoryEmbedJobResultV1 = z.infer<typeof MemoryEmbedJobResultV1Schema>;
+export declare const CaptureStatusResponseSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    processing: z.ZodLiteral<"pending_extraction">;
+    attempts: z.ZodNumber;
+    contractVersion: z.ZodLiteral<"reliability-v1">;
+    captureId: z.ZodUUID;
+    eventId: z.ZodUUID;
+    createdAt: z.ZodISODateTime;
+    updatedAt: z.ZodISODateTime;
+}, z.core.$strict>, z.ZodObject<{
+    memoryIds: z.ZodArray<z.ZodUUID>;
+    result: z.ZodObject<{
+        created: z.ZodNumber;
+        duplicates: z.ZodNumber;
+        reconciled: z.ZodNumber;
+        superseded: z.ZodNumber;
+    }, z.core.$strict>;
+    processing: z.ZodLiteral<"completed">;
+    attempts: z.ZodNumber;
+    completedAt: z.ZodISODateTime;
+    contractVersion: z.ZodLiteral<"reliability-v1">;
+    captureId: z.ZodUUID;
+    eventId: z.ZodUUID;
+    createdAt: z.ZodISODateTime;
+    updatedAt: z.ZodISODateTime;
+}, z.core.$strict>, z.ZodObject<{
+    processing: z.ZodLiteral<"dead">;
+    attempts: z.ZodNumber;
+    deadAt: z.ZodISODateTime;
+    failure: z.ZodObject<{
+        code: z.ZodString;
+        message: z.ZodString;
+    }, z.core.$strict>;
+    contractVersion: z.ZodLiteral<"reliability-v1">;
+    captureId: z.ZodUUID;
+    eventId: z.ZodUUID;
+    createdAt: z.ZodISODateTime;
+    updatedAt: z.ZodISODateTime;
+}, z.core.$strict>], "processing">;
+export type CaptureStatusResponse = z.infer<typeof CaptureStatusResponseSchema>;
+export declare const CaptureStatusSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    processing: z.ZodLiteral<"pending_extraction">;
+    attempts: z.ZodNumber;
+    contractVersion: z.ZodLiteral<"reliability-v1">;
+    captureId: z.ZodUUID;
+    eventId: z.ZodUUID;
+    createdAt: z.ZodISODateTime;
+    updatedAt: z.ZodISODateTime;
+}, z.core.$strict>, z.ZodObject<{
+    memoryIds: z.ZodArray<z.ZodUUID>;
+    result: z.ZodObject<{
+        created: z.ZodNumber;
+        duplicates: z.ZodNumber;
+        reconciled: z.ZodNumber;
+        superseded: z.ZodNumber;
+    }, z.core.$strict>;
+    processing: z.ZodLiteral<"completed">;
+    attempts: z.ZodNumber;
+    completedAt: z.ZodISODateTime;
+    contractVersion: z.ZodLiteral<"reliability-v1">;
+    captureId: z.ZodUUID;
+    eventId: z.ZodUUID;
+    createdAt: z.ZodISODateTime;
+    updatedAt: z.ZodISODateTime;
+}, z.core.$strict>, z.ZodObject<{
+    processing: z.ZodLiteral<"dead">;
+    attempts: z.ZodNumber;
+    deadAt: z.ZodISODateTime;
+    failure: z.ZodObject<{
+        code: z.ZodString;
+        message: z.ZodString;
+    }, z.core.$strict>;
+    contractVersion: z.ZodLiteral<"reliability-v1">;
+    captureId: z.ZodUUID;
+    eventId: z.ZodUUID;
+    createdAt: z.ZodISODateTime;
+    updatedAt: z.ZodISODateTime;
+}, z.core.$strict>], "processing">;
+export type CaptureStatus = CaptureStatusResponse;
+export declare const CaptureReliabilityResultSchema: z.ZodObject<{
+    reliability: z.ZodObject<{
+        contractVersion: z.ZodLiteral<"reliability-v1">;
+        operation: z.ZodEnum<{
+            capture: "capture";
+            retrieval: "retrieval";
+            guard: "guard";
+        }>;
+        status: z.ZodEnum<{
+            ok: "ok";
+            degraded: "degraded";
+            blocked: "blocked";
+            overridden: "overridden";
+            failed: "failed";
+        }>;
+        source: z.ZodEnum<{
+            live: "live";
+            cache: "cache";
+            local_queue: "local_queue";
+            none: "none";
+        }>;
+        freshness: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            asOf: z.ZodISODateTime;
+            ageMs: z.ZodNumber;
+            validUntil: z.ZodNullable<z.ZodISODateTime>;
+            state: z.ZodLiteral<"fresh">;
+        }, z.core.$strict>, z.ZodObject<{
+            asOf: z.ZodISODateTime;
+            ageMs: z.ZodNumber;
+            validUntil: z.ZodNullable<z.ZodISODateTime>;
+            state: z.ZodLiteral<"stale">;
+        }, z.core.$strict>, z.ZodObject<{
+            state: z.ZodLiteral<"unknown">;
+            asOf: z.ZodNull;
+            ageMs: z.ZodNull;
+            validUntil: z.ZodNull;
+        }, z.core.$strict>], "state">;
+        fallback: z.ZodEnum<{
+            local_queue: "local_queue";
+            none: "none";
+            live_lexical: "live_lexical";
+            cached_context: "cached_context";
+            cached_policy: "cached_policy";
+            break_glass: "break_glass";
+        }>;
+        policy: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            source: z.ZodLiteral<"live">;
+            version: z.ZodString;
+            loadedAt: z.ZodISODateTime;
+            validUntil: z.ZodNullable<z.ZodISODateTime>;
+        }, z.core.$strict>, z.ZodObject<{
+            source: z.ZodLiteral<"cache">;
+            version: z.ZodString;
+            loadedAt: z.ZodISODateTime;
+            validUntil: z.ZodISODateTime;
+        }, z.core.$strict>, z.ZodObject<{
+            source: z.ZodLiteral<"none">;
+            version: z.ZodNull;
+            loadedAt: z.ZodNull;
+            validUntil: z.ZodNull;
+        }, z.core.$strict>], "source">;
+        reasons: z.ZodArray<z.ZodEnum<{
+            semantic_unavailable: "semantic_unavailable";
+            cached_context: "cached_context";
+            cached_policy: "cached_policy";
+            live_success: "live_success";
+            idempotent_replay: "idempotent_replay";
+            lexical_fallback: "lexical_fallback";
+            live_unavailable: "live_unavailable";
+            no_usable_cache: "no_usable_cache";
+            capture_queued: "capture_queued";
+            local_persistence_failed: "local_persistence_failed";
+            governed_rule: "governed_rule";
+            policy_unavailable: "policy_unavailable";
+            policy_expired: "policy_expired";
+            user_override: "user_override";
+            invalid_response: "invalid_response";
+            integration_unsupported: "integration_unsupported";
+        }>>;
+        requestId: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>;
+    acknowledgement: z.ZodNullable<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        state: z.ZodLiteral<"queued_local">;
+        durability: z.ZodLiteral<"local_machine">;
+        replayPending: z.ZodLiteral<true>;
+        replayed: z.ZodLiteral<false>;
+        processing: z.ZodLiteral<"pending_upload">;
+        contractVersion: z.ZodLiteral<"reliability-v1">;
+        captureId: z.ZodUUID;
+        idempotencyKey: z.ZodString;
+        acknowledgedAt: z.ZodISODateTime;
+    }, z.core.$strict>, z.ZodObject<{
+        state: z.ZodLiteral<"committed_server">;
+        durability: z.ZodLiteral<"workspace_database">;
+        replayPending: z.ZodLiteral<false>;
+        replayed: z.ZodBoolean;
+        processing: z.ZodEnum<{
+            pending_extraction: "pending_extraction";
+            completed: "completed";
+        }>;
+        eventId: z.ZodUUID;
+        memoryIds: z.ZodArray<z.ZodUUID>;
+        contractVersion: z.ZodLiteral<"reliability-v1">;
+        captureId: z.ZodUUID;
+        idempotencyKey: z.ZodString;
+        acknowledgedAt: z.ZodISODateTime;
+    }, z.core.$strict>], "state">>;
+}, z.core.$strict>;
+export type CaptureReliabilityResult = z.infer<typeof CaptureReliabilityResultSchema>;
+export declare const ReliableGuardDecisionSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    decision: z.ZodLiteral<"allow">;
+    checkId: z.ZodUUID;
+    requiresConfirmation: z.ZodLiteral<false>;
+    matchedRuleIds: z.ZodArray<z.ZodUUID>;
+}, z.core.$strict>, z.ZodObject<{
+    decision: z.ZodLiteral<"block">;
+    checkId: z.ZodUUID;
+    requiresConfirmation: z.ZodLiteral<true>;
+    blockingRuleIds: z.ZodArray<z.ZodUUID>;
+    confirmation: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"approval">;
+        command: z.ZodString;
+        expiresAt: z.ZodISODateTime;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"break_glass">;
+        command: z.ZodString;
+        expiresAt: z.ZodISODateTime;
+    }, z.core.$strict>], "kind">;
+}, z.core.$strict>, z.ZodObject<{
+    decision: z.ZodLiteral<"override">;
+    checkId: z.ZodUUID;
+    requiresConfirmation: z.ZodLiteral<false>;
+    overriddenRuleIds: z.ZodArray<z.ZodUUID>;
+    override: z.ZodObject<{
+        id: z.ZodUUID;
+        reason: z.ZodString;
+        auditPending: z.ZodBoolean;
+    }, z.core.$strict>;
+}, z.core.$strict>], "decision">;
+export type ReliableGuardDecision = z.infer<typeof ReliableGuardDecisionSchema>;
+export declare const GuardReliabilityResultSchema: z.ZodObject<{
+    reliability: z.ZodObject<{
+        contractVersion: z.ZodLiteral<"reliability-v1">;
+        operation: z.ZodEnum<{
+            capture: "capture";
+            retrieval: "retrieval";
+            guard: "guard";
+        }>;
+        status: z.ZodEnum<{
+            ok: "ok";
+            degraded: "degraded";
+            blocked: "blocked";
+            overridden: "overridden";
+            failed: "failed";
+        }>;
+        source: z.ZodEnum<{
+            live: "live";
+            cache: "cache";
+            local_queue: "local_queue";
+            none: "none";
+        }>;
+        freshness: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            asOf: z.ZodISODateTime;
+            ageMs: z.ZodNumber;
+            validUntil: z.ZodNullable<z.ZodISODateTime>;
+            state: z.ZodLiteral<"fresh">;
+        }, z.core.$strict>, z.ZodObject<{
+            asOf: z.ZodISODateTime;
+            ageMs: z.ZodNumber;
+            validUntil: z.ZodNullable<z.ZodISODateTime>;
+            state: z.ZodLiteral<"stale">;
+        }, z.core.$strict>, z.ZodObject<{
+            state: z.ZodLiteral<"unknown">;
+            asOf: z.ZodNull;
+            ageMs: z.ZodNull;
+            validUntil: z.ZodNull;
+        }, z.core.$strict>], "state">;
+        fallback: z.ZodEnum<{
+            local_queue: "local_queue";
+            none: "none";
+            live_lexical: "live_lexical";
+            cached_context: "cached_context";
+            cached_policy: "cached_policy";
+            break_glass: "break_glass";
+        }>;
+        policy: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            source: z.ZodLiteral<"live">;
+            version: z.ZodString;
+            loadedAt: z.ZodISODateTime;
+            validUntil: z.ZodNullable<z.ZodISODateTime>;
+        }, z.core.$strict>, z.ZodObject<{
+            source: z.ZodLiteral<"cache">;
+            version: z.ZodString;
+            loadedAt: z.ZodISODateTime;
+            validUntil: z.ZodISODateTime;
+        }, z.core.$strict>, z.ZodObject<{
+            source: z.ZodLiteral<"none">;
+            version: z.ZodNull;
+            loadedAt: z.ZodNull;
+            validUntil: z.ZodNull;
+        }, z.core.$strict>], "source">;
+        reasons: z.ZodArray<z.ZodEnum<{
+            semantic_unavailable: "semantic_unavailable";
+            cached_context: "cached_context";
+            cached_policy: "cached_policy";
+            live_success: "live_success";
+            idempotent_replay: "idempotent_replay";
+            lexical_fallback: "lexical_fallback";
+            live_unavailable: "live_unavailable";
+            no_usable_cache: "no_usable_cache";
+            capture_queued: "capture_queued";
+            local_persistence_failed: "local_persistence_failed";
+            governed_rule: "governed_rule";
+            policy_unavailable: "policy_unavailable";
+            policy_expired: "policy_expired";
+            user_override: "user_override";
+            invalid_response: "invalid_response";
+            integration_unsupported: "integration_unsupported";
+        }>>;
+        requestId: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>;
+    verdict: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        decision: z.ZodLiteral<"allow">;
+        checkId: z.ZodUUID;
+        requiresConfirmation: z.ZodLiteral<false>;
+        matchedRuleIds: z.ZodArray<z.ZodUUID>;
+    }, z.core.$strict>, z.ZodObject<{
+        decision: z.ZodLiteral<"block">;
+        checkId: z.ZodUUID;
+        requiresConfirmation: z.ZodLiteral<true>;
+        blockingRuleIds: z.ZodArray<z.ZodUUID>;
+        confirmation: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"approval">;
+            command: z.ZodString;
+            expiresAt: z.ZodISODateTime;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"break_glass">;
+            command: z.ZodString;
+            expiresAt: z.ZodISODateTime;
+        }, z.core.$strict>], "kind">;
+    }, z.core.$strict>, z.ZodObject<{
+        decision: z.ZodLiteral<"override">;
+        checkId: z.ZodUUID;
+        requiresConfirmation: z.ZodLiteral<false>;
+        overriddenRuleIds: z.ZodArray<z.ZodUUID>;
+        override: z.ZodObject<{
+            id: z.ZodUUID;
+            reason: z.ZodString;
+            auditPending: z.ZodBoolean;
+        }, z.core.$strict>;
+    }, z.core.$strict>], "decision">;
+}, z.core.$strict>;
+export type GuardReliabilityResult = z.infer<typeof GuardReliabilityResultSchema>;
+export declare const AgentReliabilityCapabilitiesSchema: z.ZodObject<{
+    contractVersion: z.ZodLiteral<"reliability-v1">;
+    agent: z.ZodString;
+    contextDelivery: z.ZodEnum<{
+        none: "none";
+        prompt: "prompt";
+        pre_action: "pre_action";
+    }>;
+    captureDurability: z.ZodEnum<{
+        memory: "memory";
+        server: "server";
+        none: "none";
+        local_disk: "local_disk";
+    }>;
+    guardBoundaryCoverage: z.ZodEnum<{
+        none: "none";
+        partial: "partial";
+        full: "full";
+    }>;
+    guardedActions: z.ZodArray<z.ZodEnum<{
+        other: "other";
+        edit: "edit";
+        command: "command";
+        mcp: "mcp";
+        commit: "commit";
+        deploy: "deploy";
+        plan: "plan";
+    }>>;
+    enforcement: z.ZodEnum<{
+        confirm: "confirm";
+        none: "none";
+        context_only: "context_only";
+        deny: "deny";
+    }>;
+    stateDurability: z.ZodEnum<{
+        memory: "memory";
+        server: "server";
+        none: "none";
+        local_disk: "local_disk";
+    }>;
+    runtimeCoverage: z.ZodArray<z.ZodEnum<{
+        local: "local";
+        cloud: "cloud";
+    }>>;
+}, z.core.$strict>;
+export type AgentReliabilityCapabilities = z.infer<typeof AgentReliabilityCapabilitiesSchema>;
+//# sourceMappingURL=reliability-schemas.d.ts.map