import { z } from "zod";
export { PROTOCOL_VERSION } from "../../foundation/schema-core";
export declare const ProtocolObjectTypeSchema: z.ZodEnum<{
    refusal: "refusal";
    proof_gap: "proof_gap";
    receipt: "receipt";
    action_contract: "action_contract";
    greenlight: "greenlight";
    tool_capability: "tool_capability";
    action_type: "action_type";
    gateway_registry_entry: "gateway_registry_entry";
    operating_envelope: "operating_envelope";
    endpoint_access_surface_binding: "endpoint_access_surface_binding";
    agentic_endpoint_access_policy: "agentic_endpoint_access_policy";
    agentic_endpoint_access_attempt: "agentic_endpoint_access_attempt";
    agentic_endpoint_access_clearance_binding: "agentic_endpoint_access_clearance_binding";
    agentic_endpoint_access_lease: "agentic_endpoint_access_lease";
    agentic_endpoint_access_usage_event: "agentic_endpoint_access_usage_event";
    agentic_endpoint_access_readback: "agentic_endpoint_access_readback";
    agentic_endpoint_access_capabilities: "agentic_endpoint_access_capabilities";
    gateway_credential_ref: "gateway_credential_ref";
    delegated_authority_ref: "delegated_authority_ref";
    delegated_authority_status_transition: "delegated_authority_status_transition";
    gateway_custody_proof_packet: "gateway_custody_proof_packet";
    credential_resolution_evidence: "credential_resolution_evidence";
    typed_action_commitment: "typed_action_commitment";
    transition_request_context: "transition_request_context";
    runtime_execution: "runtime_execution";
    generated_execution_graph: "generated_execution_graph";
    idempotency_ledger_entry: "idempotency_ledger_entry";
    bypass_probe: "bypass_probe";
    tool_call_draft: "tool_call_draft";
    protected_path_posture: "protected_path_posture";
    intent_compilation: "intent_compilation";
    delegation_evidence_record: "delegation_evidence_record";
    negotiation_session: "negotiation_session";
    negotiation_offer: "negotiation_offer";
    negotiation_decision: "negotiation_decision";
    linked_agreement: "linked_agreement";
    agreement_obligation_binding: "agreement_obligation_binding";
    agreement_status_transition: "agreement_status_transition";
    authority_certificate: "authority_certificate";
    policy_decision: "policy_decision";
    review_artifact: "review_artifact";
    review_decision: "review_decision";
    breaker_decision: "breaker_decision";
    isolation_state: "isolation_state";
    gateway_check_attempt: "gateway_check_attempt";
    mutation_attempt: "mutation_attempt";
    protected_surface_operation_claim: "protected_surface_operation_claim";
    surface_operation_reconciliation: "surface_operation_reconciliation";
    receipt_export: "receipt_export";
    raw_record_read_audit: "raw_record_read_audit";
    recovery_recommendation: "recovery_recommendation";
    recovery_recommendation_status_transition: "recovery_recommendation_status_transition";
    contract_stream_event: "contract_stream_event";
}>;
export type ProtocolObjectType = z.infer<typeof ProtocolObjectTypeSchema>;
export declare const ProtocolRecordSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
    objectType: z.ZodLiteral<"tool_capability">;
    payload: z.ZodObject<{
        schemaVersion: z.ZodLiteral<"0.2.4">;
        tenantId: z.ZodString;
        organizationId: z.ZodString;
        createdAt: z.ZodString;
        toolCapabilityId: z.ZodString;
        toolCatalogId: z.ZodString;
        toolCatalogVersion: z.ZodString;
        runtimeAdapterId: z.ZodString;
        toolName: z.ZodString;
        toolNamespace: z.ZodString;
        capabilityClass: z.ZodEnum<{
            unknown: "unknown";
            read: "read";
            write: "write";
            network: "network";
            filesystem: "filesystem";
            deploy: "deploy";
            package: "package";
            database: "database";
        }>;
        readWriteClassification: z.ZodEnum<{
            read_only: "read_only";
            consequential: "consequential";
            ambiguous: "ambiguous";
        }>;
        consequentialityDefault: z.ZodEnum<{
            consequential: "consequential";
            non_consequential: "non_consequential";
            requires_classification: "requires_classification";
        }>;
        wrapperStatus: z.ZodEnum<{
            unknown: "unknown";
            wrapped: "wrapped";
            unwrapped: "unwrapped";
        }>;
        rawBypassPossible: z.ZodBoolean;
        inputSchemaRef: z.ZodString;
        outputSchemaRef: z.ZodString;
        secretBearingFields: z.ZodDefault<z.ZodArray<z.ZodString>>;
        supersededAt: z.ZodNullable<z.ZodString>;
    }, z.core.$strict>;
}, z.core.$strict>, z.ZodObject<{
    objectType: z.ZodLiteral<"action_type">;
    payload: z.ZodObject<{
        schemaVersion: z.ZodLiteral<"0.2.4">;
        tenantId: z.ZodString;
        organizationId: z.ZodString;
        createdAt: z.ZodString;
        actionTypeId: z.ZodString;
        actionCatalogId: z.ZodString;
        actionCatalogVersion: z.ZodString;
        actionClass: z.ZodString;
        protectedSurfaceKind: z.ZodString;
        requiredContractFields: z.ZodArray<z.ZodString>;
        canonicalParameterSchemaRef: z.ZodString;
        resourceRefSchemaRef: z.ZodString;
        requiredEvidenceTypes: z.ZodDefault<z.ZodArray<z.ZodString>>;
        allowedBoundsSchemaRef: z.ZodString;
        defaultReceiptRequirement: z.ZodEnum<{
            none: "none";
            gate: "gate";
            mutation: "mutation";
            downstream_finality: "downstream_finality";
        }>;
        defaultIdempotencyRequirement: z.ZodEnum<{
            optional: "optional";
            required: "required";
            forbidden: "forbidden";
        }>;
        supersededAt: z.ZodNullable<z.ZodString>;
    }, z.core.$strict>;
}, z.core.$strict>, z.ZodObject<{
    objectType: z.ZodLiteral<"gateway_registry_entry">;
    payload: z.ZodObject<{
        schemaVersion: z.ZodLiteral<"0.2.4">;
        tenantId: z.ZodString;
        organizationId: z.ZodString;
        createdAt: z.ZodString;
        gatewayRegistryEntryId: z.ZodString;
        gatewayRegistryVersion: z.ZodString;
        gatewayId: z.ZodString;
        protectedSurfaceKind: z.ZodString;
        gatewayAdapterId: z.ZodString;
        gatewayAdapterVersion: z.ZodString;
        gateEndpointRef: z.ZodString;
        gatewayPolicyContractId: z.ZodString;
        gatewayPolicyVersion: z.ZodString;
        gatewayPolicyDriftMode: z.ZodEnum<{
            refuse_on_drift: "refuse_on_drift";
            allow_compatible_stricter: "allow_compatible_stricter";
        }>;
        compatiblePreviousGatewayPolicyVersions: z.ZodDefault<z.ZodArray<z.ZodString>>;
        acceptedActionCatalogVersions: z.ZodArray<z.ZodString>;
        resourceNamespaceRef: z.ZodString;
        canonicalizerVersion: z.ZodString;
        receiptCapabilityStatus: z.ZodEnum<{
            unknown: "unknown";
            available: "available";
            unavailable: "unavailable";
        }>;
        isolationCheckCapabilityStatus: z.ZodEnum<{
            unknown: "unknown";
            available: "available";
            unavailable: "unavailable";
        }>;
        credentialCustodyStatus: z.ZodEnum<{
            unknown: "unknown";
            gateway_held: "gateway_held";
            fixture_gateway_held: "fixture_gateway_held";
            gateway_resolved_from_vault: "gateway_resolved_from_vault";
            provider_gateway_held: "provider_gateway_held";
            unsafe_agent_visible: "unsafe_agent_visible";
            unsafe_runtime_visible: "unsafe_runtime_visible";
            agent_has_raw_credential: "agent_has_raw_credential";
            shared_or_unknown: "shared_or_unknown";
            no_mutation_credential: "no_mutation_credential";
        }>;
        enforcementMode: z.ZodEnum<{
            unknown: "unknown";
            reference_fixture: "reference_fixture";
            customer_gateway_adapter: "customer_gateway_adapter";
            provider_gateway: "provider_gateway";
            hosted_control_plane_only: "hosted_control_plane_only";
        }>;
        mutationCredentialHolderRef: z.ZodString;
        gatewayAuthorityHolderRef: z.ZodString;
        supersededAt: z.ZodNullable<z.ZodString>;
    }, z.core.$strict>;
}, z.core.$strict>, z.ZodObject<{
    objectType: z.ZodLiteral<"operating_envelope">;
    payload: z.ZodObject<{
        schemaVersion: z.ZodLiteral<"0.2.4">;
        tenantId: z.ZodString;
        organizationId: z.ZodString;
        createdAt: z.ZodString;
        envelopeId: z.ZodString;
        principalId: z.ZodString;
        agentId: z.ZodString;
        participantIdentityBindings: z.ZodDefault<z.ZodArray<z.ZodObject<{
            participantRole: z.ZodEnum<{
                principal: "principal";
                agent: "agent";
            }>;
            participantRef: z.ZodString;
            identityProviderRef: z.ZodString;
            subjectRef: z.ZodDefault<z.ZodNullable<z.ZodString>>;
            subjectDigest: z.ZodDefault<z.ZodNullable<z.ZodString>>;
            claimsDigest: z.ZodDefault<z.ZodNullable<z.ZodString>>;
            verificationEvidenceRef: z.ZodString;
            bindingEvidenceRef: z.ZodDefault<z.ZodNullable<z.ZodString>>;
            issuedAt: z.ZodDefault<z.ZodNullable<z.ZodString>>;
            expiresAt: z.ZodDefault<z.ZodNullable<z.ZodString>>;
            authorityPosture: z.ZodDefault<z.ZodLiteral<"evidence_only">>;
        }, z.core.$strict>>>;
        objectiveRef: z.ZodString;
        allowedActionClasses: z.ZodArray<z.ZodString>;
        allowedGateways: z.ZodArray<z.ZodString>;
        allowedResources: z.ZodArray<z.ZodString>;
        requiredProtectedPathState: z.ZodDefault<z.ZodEnum<{
            not_required: "not_required";
            gateway_checked: "gateway_checked";
        }>>;
        evidenceRequirements: z.ZodDefault<z.ZodArray<z.ZodString>>;
        policyPackRef: z.ZodString;
        policyPackVersion: z.ZodString;
        issuedAt: z.ZodString;
        expiresAt: z.ZodString;
        revokedAt: z.ZodNullable<z.ZodString>;
    }, z.core.$strict>;
}, z.core.$strict>, z.ZodObject<{
    objectType: z.ZodLiteral<"endpoint_access_surface_binding">;
    payload: z.ZodObject<{
        schemaVersion: z.ZodLiteral<"handshake.agentic-endpoint-access.v0.3.0">;
        tenantId: z.ZodString;
        organizationId: z.ZodString;
        createdAt: z.ZodString;
        protectedSurfaceBindingId: z.ZodString;
        protectedSurfaceRef: z.ZodString;
        protectedSurfaceKind: z.ZodString;
        resourceRef: z.ZodString;
        gatewayRegistryEntryId: z.ZodString;
        gatewayId: z.ZodString;
        actionClass: z.ZodString;
        protectedSurfaceIntegrationRef: z.ZodDefault<z.ZodNullable<z.ZodString>>;
        bindingSource: z.ZodEnum<{
            protocol_config: "protocol_config";
            cloud_config: "cloud_config";
            ae_projection: "ae_projection";
            operator_config: "operator_config";
            fixture: "fixture";
        }>;
        issuedAt: z.ZodString;
        expiresAt: z.ZodString;
        bindingDigest: z.ZodString;
    }, z.core.$strict>;
}, z.core.$strict>, z.ZodObject<{
    objectType: z.ZodLiteral<"agentic_endpoint_access_policy">;
    payload: z.ZodObject<{
        schemaVersion: z.ZodLiteral<"handshake.agentic-endpoint-access.v0.3.0">;
        tenantId: z.ZodString;
        organizationId: z.ZodString;
        createdAt: z.ZodString;
        policyId: z.ZodString;
        policyVersionId: z.ZodString;
        configRevision: z.ZodString;
        protectedSurfaceBindingId: z.ZodString;
        protectedSurfaceBindingDigest: z.ZodString;
        protectedSurfaceRef: z.ZodString;
        protectedSurfaceKind: z.ZodString;
        resourceRef: z.ZodString;
        operatingBoundsId: z.ZodString;
        gatewayRegistryEntryId: z.ZodString;
        gatewayId: z.ZodString;
        gatewayAuthorityHolderRef: z.ZodString;
        requiredDelegationEvidence: z.ZodDefault<z.ZodArray<z.ZodString>>;
        acceptedAgentRegistrationRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
        principalBindingRequirements: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodType<import("../idempotency-ledger").JsonValue, unknown, z.core.$ZodTypeInternals<import("../idempotency-ledger").JsonValue, unknown>>>>;
        agentBindingRequirements: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodType<import("../idempotency-ledger").JsonValue, unknown, z.core.$ZodTypeInternals<import("../idempotency-ledger").JsonValue, unknown>>>>;
        runtimePostureRequirements: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodType<import("../idempotency-ledger").JsonValue, unknown, z.core.$ZodTypeInternals<import("../idempotency-ledger").JsonValue, unknown>>>>;
        rawBypassPostureRequirements: z.ZodDefault<z.ZodArray<z.ZodEnum<{
            unknown: "unknown";
            stale: "stale";
            blocked: "blocked";
            unblocked: "unblocked";
            inconclusive: "inconclusive";
        }>>>;
        siblingBypassPostureRequirements: z.ZodDefault<z.ZodArray<z.ZodEnum<{
            unknown: "unknown";
            stale: "stale";
            blocked: "blocked";
            unblocked: "unblocked";
            inconclusive: "inconclusive";
        }>>>;
        rateLimit: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodType<import("../idempotency-ledger").JsonValue, unknown, z.core.$ZodTypeInternals<import("../idempotency-ledger").JsonValue, unknown>>>>;
        tokenBudget: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodType<import("../idempotency-ledger").JsonValue, unknown, z.core.$ZodTypeInternals<import("../idempotency-ledger").JsonValue, unknown>>>>;
        toolBudget: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodType<import("../idempotency-ledger").JsonValue, unknown, z.core.$ZodTypeInternals<import("../idempotency-ledger").JsonValue, unknown>>>>;
        costBudget: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodType<import("../idempotency-ledger").JsonValue, unknown, z.core.$ZodTypeInternals<import("../idempotency-ledger").JsonValue, unknown>>>>;
        leaseTtlSeconds: z.ZodNumber;
        failClosedBehavior: z.ZodEnum<{
            proof_gap: "proof_gap";
            refuse: "refuse";
            quarantine: "quarantine";
        }>;
        capabilityRequirements: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodType<import("../idempotency-ledger").JsonValue, unknown, z.core.$ZodTypeInternals<import("../idempotency-ledger").JsonValue, unknown>>>>;
        issuedAt: z.ZodString;
        expiresAt: z.ZodString;
    }, z.core.$strict>;
}, z.core.$strict>, z.ZodObject<{
    objectType: z.ZodLiteral<"agentic_endpoint_access_attempt">;
    payload: z.ZodObject<{
        schemaVersion: z.ZodLiteral<"handshake.agentic-endpoint-access.v0.3.0">;
        tenantId: z.ZodString;
        organizationId: z.ZodString;
        createdAt: z.ZodString;
        attemptId: z.ZodString;
        candidateActionId: z.ZodString;
        generatedCodeOrSpecRef: z.ZodString;
        protectedSurfaceBindingId: z.ZodString;
        protectedSurfaceBindingDigest: z.ZodString;
        protectedSurfaceRef: z.ZodString;
        protectedSurfaceKind: z.ZodString;
        resourceRef: z.ZodString;
        principalRef: z.ZodString;
        agentRef: z.ZodString;
        objectiveRef: z.ZodString;
        delegationEvidenceRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
        agentRegistrationRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
        runtimePostureRefs: z.ZodArray<z.ZodString>;
        rawBypassPosture: z.ZodEnum<{
            unknown: "unknown";
            stale: "stale";
            blocked: "blocked";
            unblocked: "unblocked";
            inconclusive: "inconclusive";
        }>;
        siblingBypassPosture: z.ZodEnum<{
            unknown: "unknown";
            stale: "stale";
            blocked: "blocked";
            unblocked: "unblocked";
            inconclusive: "inconclusive";
        }>;
        gatewayRegistryEntryId: z.ZodString;
        gatewayId: z.ZodString;
        requestEvidence: z.ZodObject<{
            schemaVersion: z.ZodLiteral<"handshake.agentic-endpoint-access.v0.3.0">;
            requestMethod: z.ZodString;
            requestUrlDigest: z.ZodString;
            requestHeaderDigest: z.ZodString;
            requestBodyDigest: z.ZodString;
            redactionPolicyId: z.ZodString;
            requestEvidenceDigest: z.ZodString;
        }, z.core.$strict>;
        requestedLeaseTtlSeconds: z.ZodNumber;
        requestedBudget: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodType<import("../idempotency-ledger").JsonValue, unknown, z.core.$ZodTypeInternals<import("../idempotency-ledger").JsonValue, unknown>>>>;
        kernelVersion: z.ZodString;
        middlewareVersion: z.ZodString;
        capabilitiesPresented: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodType<import("../idempotency-ledger").JsonValue, unknown, z.core.$ZodTypeInternals<import("../idempotency-ledger").JsonValue, unknown>>>>;
        idempotencyKey: z.ZodString;
        attemptedAt: z.ZodString;
    }, z.core.$strict>;
}, z.core.$strict>, z.ZodObject<{
    objectType: z.ZodLiteral<"agentic_endpoint_access_clearance_binding">;
    payload: z.ZodObject<{
        schemaVersion: z.ZodLiteral<"handshake.agentic-endpoint-access.v0.3.0">;
        tenantId: z.ZodString;
        organizationId: z.ZodString;
        createdAt: z.ZodString;
        clearanceBindingId: z.ZodString;
        attemptId: z.ZodString;
        candidateActionId: z.ZodString;
        actionContractId: z.ZodString;
        policyDecisionId: z.ZodNullable<z.ZodString>;
        greenlightId: z.ZodNullable<z.ZodString>;
        gatewayRegistryEntryId: z.ZodString;
        gatewayId: z.ZodString;
        gatewayAuthorityHolderRef: z.ZodString;
        gatewayCheckAttemptId: z.ZodNullable<z.ZodString>;
        protectedSurfaceBindingId: z.ZodString;
        protectedSurfaceBindingDigest: z.ZodString;
        refusalRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
        proofGapRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
        clearanceStatus: z.ZodEnum<{
            proof_gap: "proof_gap";
            refused: "refused";
            leased: "leased";
        }>;
        reasonCodes: z.ZodDefault<z.ZodArray<z.ZodString>>;
        evaluatedAt: z.ZodString;
    }, z.core.$strict>;
}, z.core.$strict>, z.ZodObject<{
    objectType: z.ZodLiteral<"agentic_endpoint_access_lease">;
    payload: z.ZodObject<{
        schemaVersion: z.ZodLiteral<"handshake.agentic-endpoint-access.v0.3.0">;
        tenantId: z.ZodString;
        organizationId: z.ZodString;
        createdAt: z.ZodString;
        leaseId: z.ZodString;
        attemptId: z.ZodString;
        candidateActionId: z.ZodString;
        actionContractId: z.ZodString;
        policyDecisionId: z.ZodString;
        greenlightId: z.ZodString;
        gatewayRegistryEntryId: z.ZodString;
        gatewayId: z.ZodString;
        gatewayAuthorityHolderRef: z.ZodString;
        gatewayCheckAttemptId: z.ZodString;
        protectedSurfaceBindingId: z.ZodString;
        protectedSurfaceBindingDigest: z.ZodString;
        protectedSurfaceRef: z.ZodString;
        protectedSurfaceKind: z.ZodString;
        resourceRef: z.ZodString;
        principalRef: z.ZodString;
        agentRef: z.ZodString;
        operatingBoundsId: z.ZodString;
        policyVersionId: z.ZodString;
        configRevision: z.ZodString;
        runtimePostureRef: z.ZodString;
        rawBypassPosture: z.ZodEnum<{
            unknown: "unknown";
            stale: "stale";
            blocked: "blocked";
            unblocked: "unblocked";
            inconclusive: "inconclusive";
        }>;
        siblingBypassPosture: z.ZodEnum<{
            unknown: "unknown";
            stale: "stale";
            blocked: "blocked";
            unblocked: "unblocked";
            inconclusive: "inconclusive";
        }>;
        allowedUse: z.ZodLiteral<"bounded_endpoint_entry_only">;
        rateLimit: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodType<import("../idempotency-ledger").JsonValue, unknown, z.core.$ZodTypeInternals<import("../idempotency-ledger").JsonValue, unknown>>>>;
        tokenBudget: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodType<import("../idempotency-ledger").JsonValue, unknown, z.core.$ZodTypeInternals<import("../idempotency-ledger").JsonValue, unknown>>>>;
        toolBudget: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodType<import("../idempotency-ledger").JsonValue, unknown, z.core.$ZodTypeInternals<import("../idempotency-ledger").JsonValue, unknown>>>>;
        costBudget: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodType<import("../idempotency-ledger").JsonValue, unknown, z.core.$ZodTypeInternals<import("../idempotency-ledger").JsonValue, unknown>>>>;
        usageCounters: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodNumber>>;
        issuedAt: z.ZodString;
        expiresAt: z.ZodString;
        revokedAt: z.ZodDefault<z.ZodNullable<z.ZodString>>;
        authorityBoundary: z.ZodObject<{
            permitsEndpointAccess: z.ZodLiteral<true>;
            permitsMutation: z.ZodLiteral<false>;
            createsIndependentPolicyDecision: z.ZodLiteral<false>;
            createsIndependentGreenlight: z.ZodLiteral<false>;
            performsIndependentGatewayCheck: z.ZodLiteral<false>;
            exportsDownstreamReceipt: z.ZodLiteral<false>;
            mintsTerminalCertificate: z.ZodLiteral<false>;
            containsCredentialMaterial: z.ZodLiteral<false>;
            containsPaymentMaterial: z.ZodLiteral<false>;
            widensOperatingBounds: z.ZodLiteral<false>;
            freshActionContractRequiredForDownstreamAction: z.ZodLiteral<true>;
        }, z.core.$strict>;
    }, z.core.$strict>;
}, z.core.$strict>, z.ZodObject<{
    objectType: z.ZodLiteral<"agentic_endpoint_access_usage_event">;
    payload: z.ZodObject<{
        schemaVersion: z.ZodLiteral<"handshake.agentic-endpoint-access.v0.3.0">;
        tenantId: z.ZodString;
        organizationId: z.ZodString;
        createdAt: z.ZodString;
        usageEventId: z.ZodString;
        leaseId: z.ZodString;
        protectedSurfaceBindingId: z.ZodString;
        protectedSurfaceRef: z.ZodString;
        protectedSurfaceKind: z.ZodString;
        resourceRef: z.ZodString;
        usageKind: z.ZodEnum<{
            request: "request";
            token: "token";
            tool_call: "tool_call";
            cost_unit: "cost_unit";
        }>;
        amount: z.ZodNumber;
        counterAfter: z.ZodNumber;
        occurredAt: z.ZodString;
        proofGapRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
    }, z.core.$strict>;
}, z.core.$strict>, z.ZodObject<{
    objectType: z.ZodLiteral<"agentic_endpoint_access_readback">;
    payload: z.ZodObject<{
        schemaVersion: z.ZodLiteral<"handshake.agentic-endpoint-access.v0.3.0">;
        tenantId: z.ZodString;
        organizationId: z.ZodString;
        createdAt: z.ZodString;
        readbackId: z.ZodString;
        leaseId: z.ZodNullable<z.ZodString>;
        attemptId: z.ZodString;
        candidateActionId: z.ZodString;
        attemptDigest: z.ZodString;
        requestEvidence: z.ZodObject<{
            schemaVersion: z.ZodLiteral<"handshake.agentic-endpoint-access.v0.3.0">;
            requestMethod: z.ZodString;
            requestUrlDigest: z.ZodString;
            requestHeaderDigest: z.ZodString;
            requestBodyDigest: z.ZodString;
            redactionPolicyId: z.ZodString;
            requestEvidenceDigest: z.ZodString;
        }, z.core.$strict>;
        protectedSurfaceBindingId: z.ZodString;
        protectedSurfaceBindingDigest: z.ZodString;
        protectedSurfaceRef: z.ZodString;
        protectedSurfaceKind: z.ZodString;
        resourceRef: z.ZodString;
        policyVersionId: z.ZodString;
        configRevision: z.ZodString;
        kernelVersion: z.ZodString;
        middlewareVersion: z.ZodString;
        runtimePostureRef: z.ZodString;
        gatewayRegistryEntryId: z.ZodString;
        gatewayId: z.ZodString;
        gatewayAuthorityHolderRef: z.ZodString;
        rawBypassPosture: z.ZodEnum<{
            unknown: "unknown";
            stale: "stale";
            blocked: "blocked";
            unblocked: "unblocked";
            inconclusive: "inconclusive";
        }>;
        siblingBypassPosture: z.ZodEnum<{
            unknown: "unknown";
            stale: "stale";
            blocked: "blocked";
            unblocked: "unblocked";
            inconclusive: "inconclusive";
        }>;
        capabilityReportRef: z.ZodString;
        healthReportRef: z.ZodString;
        usageSummary: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodType<import("../idempotency-ledger").JsonValue, unknown, z.core.$ZodTypeInternals<import("../idempotency-ledger").JsonValue, unknown>>>>;
        linkedActionRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
        linkedReceiptRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
        linkedProofGapRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
        publicVerifyUrl: z.ZodString;
        downstreamReceiptBoundary: z.ZodLiteral<"linked_receipts_are_not_endpoint_access_authorization">;
    }, z.core.$strict>;
}, z.core.$strict>, z.ZodObject<{
    objectType: z.ZodLiteral<"agentic_endpoint_access_capabilities">;
    payload: z.ZodObject<{
        schemaVersion: z.ZodLiteral<"handshake.agentic-endpoint-access.v0.3.0">;
        tenantId: z.ZodString;
        organizationId: z.ZodString;
        createdAt: z.ZodString;
        capabilityReportId: z.ZodString;
        kernelVersion: z.ZodString;
        middlewareVersion: z.ZodString;
        cloudConfigRevision: z.ZodString;
        runtimePostureStatus: z.ZodEnum<{
            unknown: "unknown";
            stale: "stale";
            unsupported: "unsupported";
            supported: "supported";
        }>;
        rawBypassPosture: z.ZodEnum<{
            unknown: "unknown";
            stale: "stale";
            blocked: "blocked";
            unblocked: "unblocked";
            inconclusive: "inconclusive";
        }>;
        siblingBypassPosture: z.ZodEnum<{
            unknown: "unknown";
            stale: "stale";
            blocked: "blocked";
            unblocked: "unblocked";
            inconclusive: "inconclusive";
        }>;
        supportedEndpointAccessSchemaVersions: z.ZodArray<z.ZodString>;
        supportedDelegationEvidenceKinds: z.ZodDefault<z.ZodArray<z.ZodString>>;
        supportedPolicyFeatures: z.ZodDefault<z.ZodArray<z.ZodString>>;
        supportedReadbackKinds: z.ZodDefault<z.ZodArray<z.ZodString>>;
        failClosedReasons: z.ZodDefault<z.ZodArray<z.ZodString>>;
        reportedAt: z.ZodString;
    }, z.core.$strict>;
}, z.core.$strict>, z.ZodObject<{
    objectType: z.ZodLiteral<"gateway_credential_ref">;
    payload: z.ZodObject<{
        schemaVersion: z.ZodLiteral<"0.2.4">;
        tenantId: z.ZodString;
        organizationId: z.ZodString;
        createdAt: z.ZodString;
        gatewayCredentialRefId: z.ZodString;
        gatewayCredentialRefDigest: z.ZodString;
        principalId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
        gatewayId: z.ZodString;
        gatewayRegistryEntryId: z.ZodString;
        protectedSurfaceKind: z.ZodString;
        actionClasses: z.ZodArray<z.ZodString>;
        resourceRefs: z.ZodArray<z.ZodString>;
        resourceNamespaceRef: z.ZodString;
        credentialKind: z.ZodString;
        custodyStatus: z.ZodEnum<{
            unknown: "unknown";
            gateway_held: "gateway_held";
            fixture_gateway_held: "fixture_gateway_held";
            gateway_resolved_from_vault: "gateway_resolved_from_vault";
            provider_gateway_held: "provider_gateway_held";
            unsafe_agent_visible: "unsafe_agent_visible";
            unsafe_runtime_visible: "unsafe_runtime_visible";
            agent_has_raw_credential: "agent_has_raw_credential";
            shared_or_unknown: "shared_or_unknown";
            no_mutation_credential: "no_mutation_credential";
        }>;
        providerClass: z.ZodString;
        providerRegistryRef: z.ZodString;
        providerRegistryDigest: z.ZodDefault<z.ZodNullable<z.ZodString>>;
        resolverRef: z.ZodString;
        resolverVersion: z.ZodString;
        evidenceExpectationRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
        redactionProfileRef: z.ZodLiteral<"gateway-credential-ref:v0.2-redacted">;
        secretMaterialIncluded: z.ZodLiteral<false>;
        issuedAt: z.ZodString;
        expiresAt: z.ZodNullable<z.ZodString>;
    }, z.core.$strict>;
}, z.core.$strict>, z.ZodObject<{
    objectType: z.ZodLiteral<"delegated_authority_ref">;
    payload: z.ZodObject<{
        schemaVersion: z.ZodLiteral<"0.2.4">;
        tenantId: z.ZodString;
        organizationId: z.ZodString;
        createdAt: z.ZodString;
        delegatedAuthorityRefId: z.ZodString;
        delegatedAuthorityRefDigest: z.ZodString;
        principalId: z.ZodString;
        agentId: z.ZodString;
        runtimeAdapterId: z.ZodString;
        operatingEnvelopeId: z.ZodString;
        gatewayId: z.ZodString;
        gatewayRegistryEntryId: z.ZodString;
        protectedSurfaceKind: z.ZodString;
        actionClasses: z.ZodArray<z.ZodString>;
        resourceRefs: z.ZodArray<z.ZodString>;
        authorityKind: z.ZodEnum<{
            mutation: "mutation";
            spend: "spend";
            api_call: "api_call";
        }>;
        grantStatus: z.ZodEnum<{
            active: "active";
            revoked: "revoked";
            expired: "expired";
        }>;
        policyPackRef: z.ZodString;
        policyPackVersion: z.ZodString;
        amountParameterName: z.ZodDefault<z.ZodNullable<z.ZodString>>;
        maxAtomicAmountPerAction: z.ZodDefault<z.ZodNullable<z.ZodString>>;
        evidenceExpectationRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
        redactionProfileRef: z.ZodLiteral<"delegated-authority-ref:v0.2-redacted">;
        secretMaterialIncluded: z.ZodLiteral<false>;
        mutationAuthorityCreated: z.ZodLiteral<false>;
        greenlightCreated: z.ZodLiteral<false>;
        issuedAt: z.ZodString;
        expiresAt: z.ZodString;
    }, z.core.$strict>;
}, z.core.$strict>, z.ZodObject<{
    objectType: z.ZodLiteral<"delegated_authority_status_transition">;
    payload: z.ZodObject<{
        schemaVersion: z.ZodLiteral<"0.2.4">;
        tenantId: z.ZodString;
        organizationId: z.ZodString;
        createdAt: z.ZodString;
        delegatedAuthorityStatusTransitionId: z.ZodString;
        delegatedAuthorityRefId: z.ZodString;
        delegatedAuthorityRefDigest: z.ZodString;
        previousGrantStatus: z.ZodEnum<{
            active: "active";
            revoked: "revoked";
            expired: "expired";
        }>;
        nextGrantStatus: z.ZodEnum<{
            revoked: "revoked";
            expired: "expired";
        }>;
        reasonCode: z.ZodString;
        reasonSummary: z.ZodString;
        changedByRef: z.ZodString;
        changedAt: z.ZodString;
        isolationStateId: z.ZodString;
        transitionDigest: z.ZodString;
    }, z.core.$strict>;
}, z.core.$strict>, z.ZodObject<{
    objectType: z.ZodLiteral<"gateway_custody_proof_packet">;
    payload: z.ZodObject<{
        schemaVersion: z.ZodLiteral<"0.2.4">;
        tenantId: z.ZodString;
        organizationId: z.ZodString;
        createdAt: z.ZodString;
        gatewayCustodyProofPacketId: z.ZodString;
        gatewayCustodyProofPacketDigest: z.ZodString;
        gatewayCredentialRefId: z.ZodString;
        gatewayCredentialRefDigest: z.ZodString;
        protectedPathPostureId: z.ZodString;
        protectedPathPostureDigest: z.ZodString;
        gatewayInstallEvidenceRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
        gatewayInstallEvidenceDigests: z.ZodDefault<z.ZodArray<z.ZodString>>;
        bypassProbeIds: z.ZodDefault<z.ZodArray<z.ZodString>>;
        bypassProbeDigests: z.ZodDefault<z.ZodArray<z.ZodString>>;
        gatewayId: z.ZodString;
        gatewayRegistryEntryId: z.ZodString;
        protectedSurfaceKind: z.ZodString;
        actionClasses: z.ZodArray<z.ZodString>;
        resourceRefs: z.ZodArray<z.ZodString>;
        custodyProviderClass: z.ZodString;
        custodyProviderRegistryRef: z.ZodString;
        custodyProviderRegistryDigest: z.ZodDefault<z.ZodNullable<z.ZodString>>;
        opaqueKeyHandleRef: z.ZodString;
        opaqueKeyHandleDigest: z.ZodString;
        credentialKind: z.ZodString;
        credentialCustodyStatus: z.ZodEnum<{
            unknown: "unknown";
            gateway_held: "gateway_held";
            fixture_gateway_held: "fixture_gateway_held";
            gateway_resolved_from_vault: "gateway_resolved_from_vault";
            provider_gateway_held: "provider_gateway_held";
            unsafe_agent_visible: "unsafe_agent_visible";
            unsafe_runtime_visible: "unsafe_runtime_visible";
            agent_has_raw_credential: "agent_has_raw_credential";
            shared_or_unknown: "shared_or_unknown";
            no_mutation_credential: "no_mutation_credential";
        }>;
        custodyClaimLevel: z.ZodEnum<{
            proof_gap: "proof_gap";
            local_fixture: "local_fixture";
            customer_gateway_evidence: "customer_gateway_evidence";
            provider_gateway_evidence: "provider_gateway_evidence";
        }>;
        resolverRef: z.ZodString;
        resolverVersion: z.ZodString;
        leaseRef: z.ZodDefault<z.ZodNullable<z.ZodString>>;
        leaseVersion: z.ZodDefault<z.ZodNullable<z.ZodString>>;
        leaseIssuedAt: z.ZodDefault<z.ZodNullable<z.ZodString>>;
        leaseExpiresAt: z.ZodDefault<z.ZodNullable<z.ZodString>>;
        attestationRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
        attestationDigests: z.ZodDefault<z.ZodArray<z.ZodString>>;
        redactedAuditRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
        redactedAuditDigest: z.ZodDefault<z.ZodNullable<z.ZodString>>;
        custodyDriftStatus: z.ZodEnum<{
            proof_gap: "proof_gap";
            current: "current";
            stale: "stale";
            provider_drift: "provider_drift";
            resolver_drift: "resolver_drift";
            unsafe_custody: "unsafe_custody";
        }>;
        resolverDriftStatus: z.ZodEnum<{
            proof_gap: "proof_gap";
            current: "current";
            stale: "stale";
            provider_drift: "provider_drift";
            resolver_drift: "resolver_drift";
            unsafe_custody: "unsafe_custody";
        }>;
        redactionStatus: z.ZodEnum<{
            proof_gap: "proof_gap";
            redacted: "redacted";
            digest_only: "digest_only";
            redaction_failed: "redaction_failed";
        }>;
        externalVerificationStatus: z.ZodEnum<{
            not_required: "not_required";
            required_before_live_claim: "required_before_live_claim";
            verified_by_official_source: "verified_by_official_source";
        }>;
        redactionProfileRef: z.ZodLiteral<"gateway-custody-proof-packet:v0.2-redacted">;
        secretMaterialIncluded: z.ZodLiteral<false>;
        authorityCreated: z.ZodLiteral<false>;
        recordedAt: z.ZodString;
        expiresAt: z.ZodString;
    }, z.core.$strict>;
}, z.core.$strict>, z.ZodObject<{
    objectType: z.ZodLiteral<"credential_resolution_evidence">;
    payload: z.ZodObject<{
        schemaVersion: z.ZodLiteral<"0.2.4">;
        tenantId: z.ZodString;
        organizationId: z.ZodString;
        createdAt: z.ZodString;
        credentialResolutionEvidenceId: z.ZodString;
        gatewayCredentialRefId: z.ZodString;
        gatewayCredentialRefDigest: z.ZodString;
        actionContractId: z.ZodString;
        greenlightId: z.ZodString;
        gateAttemptId: z.ZodString;
        mutationAttemptId: z.ZodNullable<z.ZodString>;
        gatewayId: z.ZodString;
        providerClass: z.ZodString;
        providerRegistryRef: z.ZodString;
        providerRegistryDigest: z.ZodDefault<z.ZodNullable<z.ZodString>>;
        resolverRef: z.ZodString;
        resolverVersion: z.ZodString;
        requestDigest: z.ZodString;
        resultClass: z.ZodEnum<{
            proof_gap: "proof_gap";
            resolved_for_gateway_use: "resolved_for_gateway_use";
            used_by_gateway: "used_by_gateway";
            refused_missing_ref: "refused_missing_ref";
            refused_stale_ref: "refused_stale_ref";
            refused_provider_unavailable: "refused_provider_unavailable";
            refused_vault_auth_denied: "refused_vault_auth_denied";
            refused_provider_drift: "refused_provider_drift";
            refused_unsafe_custody: "refused_unsafe_custody";
            refused_redaction_failure: "refused_redaction_failure";
            replay_refused: "replay_refused";
            isolation_blocked: "isolation_blocked";
        }>;
        resultReasonCode: z.ZodString;
        redactionStatus: z.ZodEnum<{
            proof_gap: "proof_gap";
            redacted: "redacted";
            digest_only: "digest_only";
            redaction_failed: "redaction_failed";
        }>;
        providerRequestRef: z.ZodDefault<z.ZodNullable<z.ZodString>>;
        providerOperationRef: z.ZodDefault<z.ZodNullable<z.ZodString>>;
        proofGapId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
        refusalId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
        evidenceRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
        redactionProfileRef: z.ZodLiteral<"credential-resolution-evidence:v0.2-redacted">;
        credentialMaterialIncluded: z.ZodLiteral<false>;
        recordedAt: z.ZodString;
        evidenceDigest: z.ZodString;
    }, z.core.$strict>;
}, z.core.$strict>, z.ZodObject<{
    objectType: z.ZodLiteral<"typed_action_commitment">;
    payload: z.ZodObject<{
        schemaVersion: z.ZodLiteral<"0.2.4">;
        tenantId: z.ZodString;
        organizationId: z.ZodString;
        createdAt: z.ZodString;
        typedActionCommitmentId: z.ZodString;
        commitmentDigest: z.ZodString;
        actionContractId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
        subject: z.ZodObject<{
            kind: z.ZodEnum<{
                action_contract: "action_contract";
                service_workflow: "service_workflow";
                x402_payment: "x402_payment";
                agentic_endpoint_access: "agentic_endpoint_access";
                protected_surface: "protected_surface";
                external_evidence: "external_evidence";
            }>;
            ref: z.ZodString;
            digest: z.ZodString;
        }, z.core.$strict>;
        domain: z.ZodObject<{
            domainRef: z.ZodString;
            domainDigest: z.ZodDefault<z.ZodNullable<z.ZodString>>;
            tenantId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
            organizationId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
            gatewayId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
            actionClass: z.ZodDefault<z.ZodNullable<z.ZodString>>;
            providerEnvironmentRef: z.ZodDefault<z.ZodNullable<z.ZodString>>;
        }, z.core.$strict>;
        purpose: z.ZodEnum<{
            external_commitment_evidence: "external_commitment_evidence";
            policy_required_evidence: "policy_required_evidence";
            service_workflow_readback: "service_workflow_readback";
            post_gateway_payment_evidence: "post_gateway_payment_evidence";
            display_binding_evidence: "display_binding_evidence";
        }>;
        profile: z.ZodEnum<{
            handshake_jcs_typed: "handshake_jcs_typed";
            eip712: "eip712";
        }>;
        typedPayload: z.ZodRecord<z.ZodString, z.ZodType<import("../idempotency-ledger").JsonValue, unknown, z.core.$ZodTypeInternals<import("../idempotency-ledger").JsonValue, unknown>>>;
        replayPosture: z.ZodObject<{
            replayStatus: z.ZodEnum<{
                stale: "stale";
                fresh: "fresh";
                replayed: "replayed";
                missing: "missing";
                not_applicable: "not_applicable";
            }>;
            idempotencyKey: z.ZodDefault<z.ZodNullable<z.ZodString>>;
            nonceRef: z.ZodDefault<z.ZodNullable<z.ZodString>>;
            nonceDigest: z.ZodDefault<z.ZodNullable<z.ZodString>>;
            issuedAt: z.ZodDefault<z.ZodNullable<z.ZodString>>;
            expiresAt: z.ZodDefault<z.ZodNullable<z.ZodString>>;
            replayWindowSeconds: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
        }, z.core.$strict>;
        signerOrVerifier: z.ZodObject<{
            verifierRef: z.ZodDefault<z.ZodNullable<z.ZodString>>;
            verifierContextDigest: z.ZodDefault<z.ZodNullable<z.ZodString>>;
            keyId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
            signatureRef: z.ZodDefault<z.ZodNullable<z.ZodString>>;
            signatureDigest: z.ZodDefault<z.ZodNullable<z.ZodString>>;
            providerNativeDigest: z.ZodDefault<z.ZodNullable<z.ZodString>>;
            verificationStatus: z.ZodEnum<{
                unverified: "unverified";
                proof_gap: "proof_gap";
                verified: "verified";
                refused: "refused";
                unsupported: "unsupported";
            }>;
            verificationReasonCode: z.ZodDefault<z.ZodNullable<z.ZodString>>;
        }, z.core.$strict>;
        safetyPosture: z.ZodEnum<{
            proof_gap: "proof_gap";
            refused: "refused";
            display_bound: "display_bound";
            digest_bound: "digest_bound";
            verifier_bound: "verifier_bound";
            provider_observed: "provider_observed";
        }>;
        projectionClass: z.ZodDefault<z.ZodEnum<{
            public_redacted: "public_redacted";
            operator_redacted: "operator_redacted";
            auditor_export: "auditor_export";
        }>>;
        authorityBoundary: z.ZodObject<{
            createsPolicyDecision: z.ZodLiteral<false>;
            createsGreenlight: z.ZodLiteral<false>;
            performsGatewayCheck: z.ZodLiteral<false>;
            authorizesMutation: z.ZodLiteral<false>;
            createsReceipt: z.ZodLiteral<false>;
            mintsCertificate: z.ZodLiteral<false>;
            provesPrincipalConsent: z.ZodLiteral<false>;
            provesSignerCustody: z.ZodLiteral<false>;
            provesPaymentCustody: z.ZodLiteral<false>;
            createsEndpointLease: z.ZodLiteral<false>;
            provesDownstreamSuccess: z.ZodLiteral<false>;
        }, z.core.$strict>;
        refusalRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
        proofGapRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
        evidenceRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
        recordedAt: z.ZodString;
    }, z.core.$strict>;
}, z.core.$strict>, z.ZodObject<{
    objectType: z.ZodLiteral<"transition_request_context">;
    payload: z.ZodObject<{
        schemaVersion: z.ZodLiteral<"0.2.4">;
        tenantId: z.ZodString;
        organizationId: z.ZodString;
        createdAt: z.ZodString;
        transitionRequestContextId: z.ZodString;
        protocolVersionSeen: z.ZodString;
        requestIdentity: z.ZodString;
        originatingIdentityDigest: z.ZodNullable<z.ZodString>;
        originatingIdentityRef: z.ZodNullable<z.ZodString>;
        callerCustodyRole: z.ZodEnum<{
            control_plane: "control_plane";
            runtime_evidence: "runtime_evidence";
            gateway_custody: "gateway_custody";
            review_custody: "review_custody";
        }>;
        callerIdentityRef: z.ZodDefault<z.ZodNullable<z.ZodString>>;
        callerSubjectDigest: z.ZodDefault<z.ZodNullable<z.ZodString>>;
        callerTenantId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
        callerOrganizationId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
        callerIdentityClaimsDigest: z.ZodDefault<z.ZodNullable<z.ZodString>>;
        authProviderRef: z.ZodDefault<z.ZodNullable<z.ZodString>>;
        authSessionDigest: z.ZodDefault<z.ZodNullable<z.ZodString>>;
        serviceCredentialDigest: z.ZodDefault<z.ZodNullable<z.ZodString>>;
        revocationEpochRef: z.ZodDefault<z.ZodNullable<z.ZodString>>;
        callerIdentityIssuedAt: z.ZodDefault<z.ZodNullable<z.ZodString>>;
        callerIdentityExpiresAt: z.ZodDefault<z.ZodNullable<z.ZodString>>;
        transitionName: z.ZodString;
        routePattern: z.ZodString;
        requestDigest: z.ZodString;
        acceptedAt: z.ZodString;
        requestContextDigest: z.ZodString;
    }, z.core.$strict>;
}, z.core.$strict>, z.ZodObject<{
    objectType: z.ZodLiteral<"runtime_execution">;
    payload: z.ZodObject<{
        schemaVersion: z.ZodLiteral<"0.2.4">;
        tenantId: z.ZodString;
        organizationId: z.ZodString;
        createdAt: z.ZodString;
        runtimeExecutionId: z.ZodString;
        principalIntentRef: z.ZodString;
        principalId: z.ZodString;
        agentId: z.ZodString;
        runId: z.ZodString;
        runtimeAdapterId: z.ZodString;
        executionShape: z.ZodEnum<{
            unknown: "unknown";
            single_tool_call: "single_tool_call";
            tool_dispatch_chain: "tool_dispatch_chain";
            generated_mcp_tool_chain: "generated_mcp_tool_chain";
            codemode_block: "codemode_block";
            shell_exec_block: "shell_exec_block";
            browser_action: "browser_action";
            scheduled_job: "scheduled_job";
            gateway_only: "gateway_only";
        }>;
        runtimePosture: z.ZodEnum<{
            unknown: "unknown";
            prompt_guidance: "prompt_guidance";
            hook_assisted: "hook_assisted";
            protected_capability: "protected_capability";
            bounded_generation: "bounded_generation";
            gateway_enforced_only: "gateway_enforced_only";
            hosted_control_plane: "hosted_control_plane";
        }>;
        executionBlockRef: z.ZodString;
        executionBlockDigest: z.ZodString;
        generatedCodeOrSpecRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
        allowedToolCapabilityIds: z.ZodDefault<z.ZodArray<z.ZodString>>;
        observedToolCallRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
        observedConsequentialCallCount: z.ZodNumber;
        loopDetected: z.ZodBoolean;
        retryDetected: z.ZodBoolean;
        branchDetected: z.ZodBoolean;
        dynamicToolConstructionDetected: z.ZodBoolean;
        unobservedRegionRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
        accessPosture: z.ZodEnum<{
            unknown: "unknown";
            isolated: "isolated";
            controlled_outbound: "controlled_outbound";
            filesystem_available: "filesystem_available";
            network_available: "network_available";
            secrets_available: "secrets_available";
        }>;
        uncertaintyMarkers: z.ZodDefault<z.ZodArray<z.ZodString>>;
        refusalReasonCodes: z.ZodDefault<z.ZodArray<z.ZodString>>;
        evidenceRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
        runtimeExecutionDigest: z.ZodString;
    }, z.core.$strict>;
}, z.core.$strict>, z.ZodObject<{
    objectType: z.ZodLiteral<"generated_execution_graph">;
    payload: z.ZodObject<{
        schemaVersion: z.ZodLiteral<"0.2.4">;
        tenantId: z.ZodString;
        organizationId: z.ZodString;
        createdAt: z.ZodString;
        generatedExecutionGraphId: z.ZodString;
        runtimeExecutionId: z.ZodString;
        runtimeExecutionDigest: z.ZodString;
        executionBlockDigest: z.ZodString;
        graphIssuerRef: z.ZodString;
        graphIssuerAuthority: z.ZodEnum<{
            host_runtime_adapter: "host_runtime_adapter";
            kernel_fixture: "kernel_fixture";
            conformance_fixture: "conformance_fixture";
        }>;
        graphIssuedAt: z.ZodString;
        graphNonce: z.ZodString;
        graphInputDigest: z.ZodString;
        graphSchemaVersion: z.ZodString;
        parserVersion: z.ZodString;
        supportedGrammarVersion: z.ZodString;
        coverageValidatorVersion: z.ZodString;
        graphDigest: z.ZodString;
        coverageStatus: z.ZodEnum<{
            unknown: "unknown";
            fully_covered_no_unsupported_nodes: "fully_covered_no_unsupported_nodes";
            nonconsequential_only: "nonconsequential_only";
            contains_refusal: "contains_refusal";
            contains_coverage_gap: "contains_coverage_gap";
            contains_bypass_risk: "contains_bypass_risk";
            unsupported_or_ambiguous: "unsupported_or_ambiguous";
        }>;
        terminalReasonCodes: z.ZodDefault<z.ZodArray<z.ZodString>>;
        entryNodeIds: z.ZodDefault<z.ZodArray<z.ZodString>>;
        edges: z.ZodDefault<z.ZodArray<z.ZodObject<{
            fromNodeId: z.ZodString;
            toNodeId: z.ZodString;
            edgeKind: z.ZodEnum<{
                unknown: "unknown";
                sequence: "sequence";
                branch: "branch";
                retry: "retry";
                callback: "callback";
                watcher: "watcher";
            }>;
        }, z.core.$strict>>>;
        nodeCount: z.ZodNumber;
        edgeCount: z.ZodNumber;
        maxNodeCount: z.ZodNumber;
        maxEdgeCount: z.ZodNumber;
        maxDepth: z.ZodNumber;
        graphByteSize: z.ZodNumber;
        maxGraphByteSize: z.ZodNumber;
        truncationStatus: z.ZodEnum<{
            unknown: "unknown";
            complete: "complete";
            truncated: "truncated";
            over_limit: "over_limit";
        }>;
        catalogSnapshotDigest: z.ZodString;
        gatewayRegistrySnapshotDigest: z.ZodString;
        registryBindingSetDigest: z.ZodString;
        nodes: z.ZodDefault<z.ZodArray<z.ZodObject<{
            nodeId: z.ZodString;
            nodeKind: z.ZodEnum<{
                unknown: "unknown";
                shell_command: "shell_command";
                codemode_action: "codemode_action";
                observer_event: "observer_event";
                hidden_trigger: "hidden_trigger";
            }>;
            classification: z.ZodEnum<{
                read_only: "read_only";
                ambiguous: "ambiguous";
                unsupported: "unsupported";
                hidden_trigger: "hidden_trigger";
                candidate_action_eligible: "candidate_action_eligible";
                nonconsequential: "nonconsequential";
                bypass_risk: "bypass_risk";
                observer_only: "observer_only";
            }>;
            actionClass: z.ZodDefault<z.ZodNullable<z.ZodString>>;
            toolCapabilityId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
            actionTypeId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
            gatewayRegistryEntryId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
            resourceRef: z.ZodDefault<z.ZodNullable<z.ZodString>>;
            paramsDigest: z.ZodDefault<z.ZodNullable<z.ZodString>>;
            nodeDigest: z.ZodString;
            nodeGatewayBindingDigest: z.ZodDefault<z.ZodNullable<z.ZodString>>;
            sourceSpanDigest: z.ZodDefault<z.ZodNullable<z.ZodString>>;
            redactedArgvSummary: z.ZodDefault<z.ZodArray<z.ZodString>>;
            argvDigest: z.ZodDefault<z.ZodNullable<z.ZodString>>;
            argvRedactionStatus: z.ZodEnum<{
                unknown: "unknown";
                redacted: "redacted";
                digest_only: "digest_only";
                secret_refs_only: "secret_refs_only";
                raw_material_present: "raw_material_present";
            }>;
            stdinDigest: z.ZodDefault<z.ZodNullable<z.ZodString>>;
            stdinRedactionStatus: z.ZodEnum<{
                unknown: "unknown";
                redacted: "redacted";
                digest_only: "digest_only";
                secret_refs_only: "secret_refs_only";
                raw_material_present: "raw_material_present";
            }>;
            envAllowlistDigest: z.ZodDefault<z.ZodNullable<z.ZodString>>;
            rawSecretMaterialDetected: z.ZodDefault<z.ZodBoolean>;
            commandRiskClassifierRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
            commandRiskClassifierPosture: z.ZodDefault<z.ZodEnum<{
                unknown: "unknown";
                absent: "absent";
                advisory_allow: "advisory_allow";
                advisory_no_match: "advisory_no_match";
                deny: "deny";
                warn: "warn";
                fail_open: "fail_open";
                allowlist: "allowlist";
                allow_once: "allow_once";
                bypass_detected: "bypass_detected";
                skipped: "skipped";
            }>>;
            commandRiskRuleRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
            commandRiskBypassRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
            unsupportedReasonCodes: z.ZodDefault<z.ZodArray<z.ZodString>>;
        }, z.core.$strict>>>;
    }, z.core.$strict>;
}, z.core.$strict>, z.ZodObject<{
    objectType: z.ZodLiteral<"idempotency_ledger_entry">;
    payload: z.ZodObject<{
        schemaVersion: z.ZodLiteral<"0.2.4">;
        tenantId: z.ZodString;
        organizationId: z.ZodString;
        createdAt: z.ZodString;
        idempotencyLedgerEntryId: z.ZodString;
        ledgerKeyDigest: z.ZodString;
        gatewayId: z.ZodString;
        protectedSurfaceKind: z.ZodString;
        actionClass: z.ZodString;
        resourceRef: z.ZodString;
        idempotencyKey: z.ZodString;
        paramsDigest: z.ZodString;
        actionContractId: z.ZodString;
        policyDecisionId: z.ZodString;
        greenlightId: z.ZodNullable<z.ZodString>;
        gateAttemptId: z.ZodNullable<z.ZodString>;
        mutationAttemptId: z.ZodNullable<z.ZodString>;
        receiptId: z.ZodNullable<z.ZodString>;
        ledgerState: z.ZodEnum<{
            terminal_unknown: "terminal_unknown";
            authority_reserved: "authority_reserved";
            mutation_started: "mutation_started";
            terminal_succeeded: "terminal_succeeded";
            terminal_failed: "terminal_failed";
            terminal_refused: "terminal_refused";
        }>;
        reasonCode: z.ZodString;
        evidenceRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
        firstReservedAt: z.ZodString;
        updatedAt: z.ZodString;
        ledgerDigest: z.ZodString;
    }, z.core.$strict>;
}, z.core.$strict>, z.ZodObject<{
    objectType: z.ZodLiteral<"bypass_probe">;
    payload: z.ZodObject<{
        schemaVersion: z.ZodLiteral<"0.2.4">;
        tenantId: z.ZodString;
        organizationId: z.ZodString;
        createdAt: z.ZodString;
        bypassProbeId: z.ZodString;
        postureScopeKey: z.ZodString;
        runtimeAdapterId: z.ZodString;
        gatewayId: z.ZodString;
        actionClass: z.ZodString;
        resourceRef: z.ZodString;
        protectedSurfaceKind: z.ZodString;
        probeKind: z.ZodEnum<{
            credential_custody: "credential_custody";
            raw_sibling_blocking: "raw_sibling_blocking";
            mcp_direct_call_blocking: "mcp_direct_call_blocking";
            token_passthrough_blocking: "token_passthrough_blocking";
            wrapper_drift: "wrapper_drift";
            failure_closed: "failure_closed";
        }>;
        probeOutcome: z.ZodEnum<{
            inconclusive: "inconclusive";
            passed: "passed";
            failed: "failed";
        }>;
        sourceAuthority: z.ZodEnum<{
            unknown: "unknown";
            conformance_fixture: "conformance_fixture";
            runtime_probe: "runtime_probe";
            gateway_probe: "gateway_probe";
            operator_attestation: "operator_attestation";
            hosted_monitor: "hosted_monitor";
        }>;
        reasonCodes: z.ZodDefault<z.ZodArray<z.ZodString>>;
        evidenceRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
        observedAt: z.ZodString;
        expiresAt: z.ZodString;
        probeDigest: z.ZodString;
    }, z.core.$strict>;
}, z.core.$strict>, z.ZodObject<{
    objectType: z.ZodLiteral<"tool_call_draft">;
    payload: z.ZodObject<{
        schemaVersion: z.ZodLiteral<"0.2.4">;
        tenantId: z.ZodString;
        organizationId: z.ZodString;
        createdAt: z.ZodString;
        toolCallDraftId: z.ZodString;
        runtimeExecutionId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
        generatedExecutionGraphId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
        generatedExecutionNodeId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
        toolCapabilityId: z.ZodString;
        actionTypeId: z.ZodString;
        gatewayRegistryEntryId: z.ZodString;
        actionClass: z.ZodString;
        gatewayId: z.ZodString;
        resourceRef: z.ZodString;
        draftState: z.ZodEnum<{
            invalid: "invalid";
            opened: "opened";
            streaming: "streaming";
            finalized: "finalized";
            abandoned: "abandoned";
        }>;
        parameters: z.ZodRecord<z.ZodString, z.ZodType<import("../idempotency-ledger").JsonValue, unknown, z.core.$ZodTypeInternals<import("../idempotency-ledger").JsonValue, unknown>>>;
        nonSecretParamsSummary: z.ZodRecord<z.ZodString, z.ZodType<import("../idempotency-ledger").JsonValue, unknown, z.core.$ZodTypeInternals<import("../idempotency-ledger").JsonValue, unknown>>>;
        secretRefs: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
        gatewayCredentialRefs: z.ZodDefault<z.ZodArray<z.ZodObject<{
            credentialUseName: z.ZodString;
            gatewayCredentialRefId: z.ZodString;
            gatewayCredentialRefDigest: z.ZodString;
            providerRegistryRef: z.ZodString;
            providerRegistryDigest: z.ZodDefault<z.ZodNullable<z.ZodString>>;
            requiredCredentialCustodyStatus: z.ZodEnum<{
                unknown: "unknown";
                gateway_held: "gateway_held";
                fixture_gateway_held: "fixture_gateway_held";
                gateway_resolved_from_vault: "gateway_resolved_from_vault";
                provider_gateway_held: "provider_gateway_held";
                unsafe_agent_visible: "unsafe_agent_visible";
                unsafe_runtime_visible: "unsafe_runtime_visible";
                agent_has_raw_credential: "agent_has_raw_credential";
                shared_or_unknown: "shared_or_unknown";
                no_mutation_credential: "no_mutation_credential";
            }>;
            evidenceExpectationRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
        }, z.core.$strict>>>;
        delegatedAuthorityRefs: z.ZodDefault<z.ZodArray<z.ZodObject<{
            authorityUseName: z.ZodString;
            delegatedAuthorityRefId: z.ZodString;
            delegatedAuthorityRefDigest: z.ZodString;
            requiredGrantStatus: z.ZodDefault<z.ZodLiteral<"active">>;
            authorityKind: z.ZodEnum<{
                mutation: "mutation";
                spend: "spend";
                api_call: "api_call";
            }>;
            policyPackRef: z.ZodString;
            policyPackVersion: z.ZodString;
            evidenceExpectationRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
        }, z.core.$strict>>>;
        paramsDigest: z.ZodString;
        finalizedAt: z.ZodDefault<z.ZodNullable<z.ZodString>>;
        expiresAt: z.ZodString;
        invalidReasonCodes: z.ZodDefault<z.ZodArray<z.ZodString>>;
        evidenceRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
        draftDigest: z.ZodString;
    }, z.core.$strict>;
}, z.core.$strict>, z.ZodObject<{
    objectType: z.ZodLiteral<"protected_path_posture">;
    payload: z.ZodObject<{
        schemaVersion: z.ZodLiteral<"0.2.4">;
        tenantId: z.ZodString;
        organizationId: z.ZodString;
        createdAt: z.ZodString;
        protectedPathPostureId: z.ZodString;
        postureScopeKey: z.ZodString;
        runtimeAdapterId: z.ZodString;
        gatewayId: z.ZodString;
        actionClass: z.ZodString;
        resourceRef: z.ZodString;
        protectedSurfaceKind: z.ZodString;
        postureState: z.ZodEnum<{
            gateway_checked: "gateway_checked";
            bypass_risk: "bypass_risk";
            advisory: "advisory";
            blind: "blind";
            fixture_only: "fixture_only";
        }>;
        credentialCustodyStatus: z.ZodEnum<{
            unknown: "unknown";
            gateway_held: "gateway_held";
            fixture_gateway_held: "fixture_gateway_held";
            gateway_resolved_from_vault: "gateway_resolved_from_vault";
            provider_gateway_held: "provider_gateway_held";
            unsafe_agent_visible: "unsafe_agent_visible";
            unsafe_runtime_visible: "unsafe_runtime_visible";
            agent_has_raw_credential: "agent_has_raw_credential";
            shared_or_unknown: "shared_or_unknown";
            no_mutation_credential: "no_mutation_credential";
        }>;
        rawSiblingToolStatus: z.ZodEnum<{
            unknown: "unknown";
            absent: "absent";
            blocked: "blocked";
            present: "present";
        }>;
        sourceAuthority: z.ZodEnum<{
            unknown: "unknown";
            conformance_fixture: "conformance_fixture";
            runtime_probe: "runtime_probe";
            gateway_probe: "gateway_probe";
            operator_attestation: "operator_attestation";
            hosted_monitor: "hosted_monitor";
        }>;
        reasonCodes: z.ZodDefault<z.ZodArray<z.ZodString>>;
        evidenceRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
        bypassProbeIds: z.ZodDefault<z.ZodArray<z.ZodString>>;
        bypassProbeDigests: z.ZodDefault<z.ZodArray<z.ZodString>>;
        bypassProbeCoverage: z.ZodDefault<z.ZodArray<z.ZodObject<{
            bypassProbeId: z.ZodString;
            probeKind: z.ZodEnum<{
                credential_custody: "credential_custody";
                raw_sibling_blocking: "raw_sibling_blocking";
                mcp_direct_call_blocking: "mcp_direct_call_blocking";
                token_passthrough_blocking: "token_passthrough_blocking";
                wrapper_drift: "wrapper_drift";
                failure_closed: "failure_closed";
            }>;
            probeOutcome: z.ZodEnum<{
                inconclusive: "inconclusive";
                passed: "passed";
                failed: "failed";
            }>;
            sourceAuthority: z.ZodEnum<{
                unknown: "unknown";
                conformance_fixture: "conformance_fixture";
                runtime_probe: "runtime_probe";
                gateway_probe: "gateway_probe";
                operator_attestation: "operator_attestation";
                hosted_monitor: "hosted_monitor";
            }>;
            probeDigest: z.ZodString;
        }, z.core.$strict>>>;
        observedAt: z.ZodString;
        expiresAt: z.ZodString;
        postureDigest: z.ZodString;
    }, z.core.$strict>;
}, z.core.$strict>, z.ZodObject<{
    objectType: z.ZodLiteral<"intent_compilation">;
    payload: z.ZodObject<{
        schemaVersion: z.ZodLiteral<"0.2.4">;
        tenantId: z.ZodString;
        organizationId: z.ZodString;
        createdAt: z.ZodString;
        intentCompilationId: z.ZodString;
        principalIntentRef: z.ZodString;
        principalId: z.ZodString;
        agentId: z.ZodString;
        runId: z.ZodString;
        runtimeAdapterId: z.ZodString;
        operatingEnvelopeId: z.ZodString;
        toolCatalogRef: z.ZodString;
        actionCatalogRef: z.ZodString;
        gatewayRegistryRef: z.ZodString;
        runtimeExecutionId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
        runtimeExecutionDigest: z.ZodDefault<z.ZodNullable<z.ZodString>>;
        generatedCodeOrSpecRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
        declaredAssumptions: z.ZodDefault<z.ZodArray<z.ZodString>>;
        uncertaintyMarkers: z.ZodDefault<z.ZodArray<z.ZodString>>;
        candidateAction: z.ZodObject<{
            candidateActionId: z.ZodString;
            candidateStatus: z.ZodEnum<{
                contractable: "contractable";
                rejected: "rejected";
            }>;
            candidateDigest: z.ZodNullable<z.ZodString>;
            refusalReasonCodes: z.ZodDefault<z.ZodArray<z.ZodString>>;
            toolCapabilityId: z.ZodString;
            toolCapabilityDigest: z.ZodNullable<z.ZodString>;
            toolCatalogVersion: z.ZodNullable<z.ZodString>;
            actionTypeId: z.ZodString;
            actionTypeDigest: z.ZodNullable<z.ZodString>;
            actionCatalogVersion: z.ZodNullable<z.ZodString>;
            gatewayRegistryEntryId: z.ZodString;
            gatewayRegistryDigest: z.ZodNullable<z.ZodString>;
            gatewayRegistryVersion: z.ZodNullable<z.ZodString>;
            operatingEnvelopeId: z.ZodString;
            operatingEnvelopeDigest: z.ZodNullable<z.ZodString>;
            actionClass: z.ZodString;
            gatewayId: z.ZodString;
            resourceRef: z.ZodString;
            sequenceNumber: z.ZodNumber;
            requiredPriorActionContractIds: z.ZodDefault<z.ZodArray<z.ZodString>>;
            recoveryRecommendationId: z.ZodNullable<z.ZodString>;
            parameters: z.ZodRecord<z.ZodString, z.ZodType<import("../idempotency-ledger").JsonValue, unknown, z.core.$ZodTypeInternals<import("../idempotency-ledger").JsonValue, unknown>>>;
            paramsDigest: z.ZodString;
            nonSecretParamsSummary: z.ZodRecord<z.ZodString, z.ZodType<import("../idempotency-ledger").JsonValue, unknown, z.core.$ZodTypeInternals<import("../idempotency-ledger").JsonValue, unknown>>>;
            secretRefs: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
            gatewayCredentialRefs: z.ZodDefault<z.ZodArray<z.ZodObject<{
                credentialUseName: z.ZodString;
                gatewayCredentialRefId: z.ZodString;
                gatewayCredentialRefDigest: z.ZodString;
                providerRegistryRef: z.ZodString;
                providerRegistryDigest: z.ZodDefault<z.ZodNullable<z.ZodString>>;
                requiredCredentialCustodyStatus: z.ZodEnum<{
                    unknown: "unknown";
                    gateway_held: "gateway_held";
                    fixture_gateway_held: "fixture_gateway_held";
                    gateway_resolved_from_vault: "gateway_resolved_from_vault";
                    provider_gateway_held: "provider_gateway_held";
                    unsafe_agent_visible: "unsafe_agent_visible";
                    unsafe_runtime_visible: "unsafe_runtime_visible";
                    agent_has_raw_credential: "agent_has_raw_credential";
                    shared_or_unknown: "shared_or_unknown";
                    no_mutation_credential: "no_mutation_credential";
                }>;
                evidenceExpectationRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
            }, z.core.$strict>>>;
            delegatedAuthorityRefs: z.ZodDefault<z.ZodArray<z.ZodObject<{
                authorityUseName: z.ZodString;
                delegatedAuthorityRefId: z.ZodString;
                delegatedAuthorityRefDigest: z.ZodString;
                requiredGrantStatus: z.ZodDefault<z.ZodLiteral<"active">>;
                authorityKind: z.ZodEnum<{
                    mutation: "mutation";
                    spend: "spend";
                    api_call: "api_call";
                }>;
                policyPackRef: z.ZodString;
                policyPackVersion: z.ZodString;
                evidenceExpectationRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
            }, z.core.$strict>>>;
            purposeCode: z.ZodString;
            expectedSideEffectCodes: z.ZodArray<z.ZodString>;
            evidenceRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
            clearingEvidenceRefs: z.ZodDefault<z.ZodObject<{
                correlationRef: z.ZodOptional<z.ZodString>;
                obligationRef: z.ZodOptional<z.ZodString>;
                counterpartyRef: z.ZodOptional<z.ZodString>;
            }, z.core.$strict>>;
            bounds: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodType<import("../idempotency-ledger").JsonValue, unknown, z.core.$ZodTypeInternals<import("../idempotency-ledger").JsonValue, unknown>>>>;
            idempotencyKey: z.ZodString;
            rollbackHint: z.ZodNullable<z.ZodString>;
            expiresAt: z.ZodString;
            generatedCodeOrSpecRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
            runtimeExecutionId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
            runtimeExecutionDigest: z.ZodDefault<z.ZodNullable<z.ZodString>>;
            generatedExecutionGraphId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
            generatedExecutionGraphDigest: z.ZodDefault<z.ZodNullable<z.ZodString>>;
            generatedExecutionCoverageStatus: z.ZodDefault<z.ZodNullable<z.ZodEnum<{
                unknown: "unknown";
                fully_covered_no_unsupported_nodes: "fully_covered_no_unsupported_nodes";
                nonconsequential_only: "nonconsequential_only";
                contains_refusal: "contains_refusal";
                contains_coverage_gap: "contains_coverage_gap";
                contains_bypass_risk: "contains_bypass_risk";
                unsupported_or_ambiguous: "unsupported_or_ambiguous";
            }>>>;
            generatedExecutionNodeId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
            generatedExecutionNodeDigest: z.ZodDefault<z.ZodNullable<z.ZodString>>;
            generatedExecutionCatalogSnapshotDigest: z.ZodDefault<z.ZodNullable<z.ZodString>>;
            generatedExecutionGatewayRegistrySnapshotDigest: z.ZodDefault<z.ZodNullable<z.ZodString>>;
            generatedExecutionRegistryBindingSetDigest: z.ZodDefault<z.ZodNullable<z.ZodString>>;
            generatedExecutionNodeGatewayBindingDigest: z.ZodDefault<z.ZodNullable<z.ZodString>>;
            toolCallDraftId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
            toolCallDraftDigest: z.ZodDefault<z.ZodNullable<z.ZodString>>;
            toolCallDraftState: z.ZodDefault<z.ZodNullable<z.ZodEnum<{
                invalid: "invalid";
                opened: "opened";
                streaming: "streaming";
                finalized: "finalized";
                abandoned: "abandoned";
            }>>>;
            delegationEvidenceRef: z.ZodDefault<z.ZodNullable<z.ZodObject<{
                delegationEvidenceRefId: z.ZodString;
                evidenceBindingDigest: z.ZodString;
                a1ChainFingerprint: z.ZodString;
                storeRef: z.ZodString;
                verifyOutcome: z.ZodEnum<{
                    valid: "valid";
                    invalid: "invalid";
                }>;
                a1VerifierVersion: z.ZodString;
            }, z.core.$strict>>>;
        }, z.core.$strict>;
        candidateActionContractRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
        rejectedCandidateRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
        overreachReasonCodes: z.ZodDefault<z.ZodArray<z.ZodString>>;
        requiredEvidenceRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
        compilationRefusalId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
        compilerVersion: z.ZodString;
    }, z.core.$strict>;
}, z.core.$strict>, z.ZodObject<{
    objectType: z.ZodLiteral<"delegation_evidence_record">;
    payload: z.ZodObject<{
        schemaVersion: z.ZodLiteral<"0.2.4">;
        tenantId: z.ZodString;
        organizationId: z.ZodString;
        createdAt: z.ZodString;
        delegationEvidenceRecordId: z.ZodString;
        evidenceRecord: z.ZodObject<{
            schemaId: z.ZodLiteral<"delegation-evidence-record">;
            schemaVersion: z.ZodLiteral<1>;
            a1ChainFingerprint: z.ZodString;
            certFingerprints: z.ZodArray<z.ZodString>;
            chainDepth: z.ZodNumber;
            principalPkFingerprint: z.ZodString;
            terminalDelegatePkFingerprint: z.ZodString;
            a1VerifierVersion: z.ZodString;
            verifyPath: z.ZodEnum<{
                ts: "ts";
                sidecar: "sidecar";
            }>;
            verifyOutcome: z.ZodEnum<{
                valid: "valid";
                invalid: "invalid";
            }>;
            reasonCodes: z.ZodArray<z.ZodString>;
            evidenceBindingDigest: z.ZodNullable<z.ZodString>;
            presentedAtUnix: z.ZodNumber;
            mutationAuthorityCreated: z.ZodLiteral<false>;
            greenlightCreated: z.ZodLiteral<false>;
        }, z.core.$strict>;
    }, z.core.$strict>;
}, z.core.$strict>, z.ZodObject<{
    objectType: z.ZodLiteral<"negotiation_session">;
    payload: z.ZodObject<{
        schemaVersion: z.ZodLiteral<"0.2.4">;
        tenantId: z.ZodString;
        organizationId: z.ZodString;
        createdAt: z.ZodString;
        negotiationSessionId: z.ZodString;
        negotiationSessionDigest: z.ZodString;
        subjectResourceRef: z.ZodString;
        subjectProtectedActionContextRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
        runtimePosture: z.ZodEnum<{
            proof_gap_recorded: "proof_gap_recorded";
            declared_runtime_context: "declared_runtime_context";
            observed_runtime_evidence: "observed_runtime_evidence";
        }>;
        parties: z.ZodArray<z.ZodObject<{
            partyId: z.ZodString;
            partyRole: z.ZodEnum<{
                initiator: "initiator";
                counterparty: "counterparty";
                observer: "observer";
            }>;
            agentRef: z.ZodString;
            organizationRef: z.ZodDefault<z.ZodNullable<z.ZodString>>;
            runtimeRef: z.ZodDefault<z.ZodNullable<z.ZodString>>;
            endpointRef: z.ZodDefault<z.ZodNullable<z.ZodString>>;
            identityProofPosture: z.ZodEnum<{
                proof_gap_recorded: "proof_gap_recorded";
                self_attested: "self_attested";
                host_verified_ref: "host_verified_ref";
            }>;
            identityEvidenceRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
            identityProofDigest: z.ZodDefault<z.ZodNullable<z.ZodString>>;
            proofGapRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
        }, z.core.$strict>>;
        generatedCodeOrSpecRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
        declaredAssumptions: z.ZodDefault<z.ZodArray<z.ZodString>>;
        uncertaintyMarkers: z.ZodDefault<z.ZodArray<z.ZodString>>;
        externalProtocolEvidenceRefs: z.ZodDefault<z.ZodArray<z.ZodObject<{
            protocol: z.ZodEnum<{
                a2a: "a2a";
                acp: "acp";
                anp: "anp";
                ap2: "ap2";
                mcp: "mcp";
                runtime_handoff: "runtime_handoff";
                other: "other";
            }>;
            protocolVersion: z.ZodString;
            objectKind: z.ZodString;
            objectRef: z.ZodString;
            objectDigest: z.ZodString;
            evidencePosture: z.ZodLiteral<"imported_evidence_only">;
            evidenceUse: z.ZodEnum<{
                conversation_context: "conversation_context";
                descriptor_context: "descriptor_context";
                runtime_context: "runtime_context";
                mandate_context_evidence: "mandate_context_evidence";
                tool_context: "tool_context";
                handoff_context: "handoff_context";
                other_context: "other_context";
            }>;
            proofGapRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
        }, z.core.$strict>>>;
        clearingEvidenceRefs: z.ZodDefault<z.ZodObject<{
            correlationRef: z.ZodOptional<z.ZodString>;
            obligationRef: z.ZodOptional<z.ZodString>;
            counterpartyRef: z.ZodOptional<z.ZodString>;
        }, z.core.$strict>>;
        expiresAt: z.ZodDefault<z.ZodNullable<z.ZodString>>;
    }, z.core.$strict>;
}, z.core.$strict>, z.ZodObject<{
    objectType: z.ZodLiteral<"negotiation_offer">;
    payload: z.ZodObject<{
        schemaVersion: z.ZodLiteral<"0.2.4">;
        tenantId: z.ZodString;
        organizationId: z.ZodString;
        createdAt: z.ZodString;
        negotiationOfferId: z.ZodString;
        negotiationSessionId: z.ZodString;
        offerVersionId: z.ZodString;
        offerSequence: z.ZodNumber;
        offeredByPartyId: z.ZodString;
        previousOfferVersionId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
        supersedesOfferVersionId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
        offerContentDigest: z.ZodString;
        offerObjectRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
        offerContentRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
        proofGapRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
        externalProtocolEvidenceRefs: z.ZodDefault<z.ZodArray<z.ZodObject<{
            protocol: z.ZodEnum<{
                a2a: "a2a";
                acp: "acp";
                anp: "anp";
                ap2: "ap2";
                mcp: "mcp";
                runtime_handoff: "runtime_handoff";
                other: "other";
            }>;
            protocolVersion: z.ZodString;
            objectKind: z.ZodString;
            objectRef: z.ZodString;
            objectDigest: z.ZodString;
            evidencePosture: z.ZodLiteral<"imported_evidence_only">;
            evidenceUse: z.ZodEnum<{
                conversation_context: "conversation_context";
                descriptor_context: "descriptor_context";
                runtime_context: "runtime_context";
                mandate_context_evidence: "mandate_context_evidence";
                tool_context: "tool_context";
                handoff_context: "handoff_context";
                other_context: "other_context";
            }>;
            proofGapRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
        }, z.core.$strict>>>;
        generatedCodeOrSpecRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
        declaredAssumptions: z.ZodDefault<z.ZodArray<z.ZodString>>;
        uncertaintyMarkers: z.ZodDefault<z.ZodArray<z.ZodString>>;
        clearingEvidenceRefs: z.ZodDefault<z.ZodObject<{
            correlationRef: z.ZodOptional<z.ZodString>;
            obligationRef: z.ZodOptional<z.ZodString>;
            counterpartyRef: z.ZodOptional<z.ZodString>;
        }, z.core.$strict>>;
        expiresAt: z.ZodDefault<z.ZodNullable<z.ZodString>>;
    }, z.core.$strict>;
}, z.core.$strict>, z.ZodObject<{
    objectType: z.ZodLiteral<"negotiation_decision">;
    payload: z.ZodObject<{
        schemaVersion: z.ZodLiteral<"0.2.4">;
        tenantId: z.ZodString;
        organizationId: z.ZodString;
        createdAt: z.ZodString;
        negotiationDecisionId: z.ZodString;
        negotiationSessionId: z.ZodString;
        decidedOfferVersionId: z.ZodString;
        decidedOfferSequence: z.ZodNumber;
        decidedByPartyId: z.ZodString;
        decision: z.ZodEnum<{
            accept: "accept";
            reject: "reject";
            counter: "counter";
            withdraw: "withdraw";
            expire: "expire";
        }>;
        reasonCodes: z.ZodDefault<z.ZodArray<z.ZodString>>;
        evidenceRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
        proofGapRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
        counterOfferVersionId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
        decisionDigest: z.ZodString;
    }, z.core.$strict>;
}, z.core.$strict>, z.ZodObject<{
    objectType: z.ZodLiteral<"linked_agreement">;
    payload: z.ZodObject<{
        schemaVersion: z.ZodLiteral<"0.2.4">;
        tenantId: z.ZodString;
        organizationId: z.ZodString;
        createdAt: z.ZodString;
        linkedAgreementId: z.ZodString;
        negotiationSessionId: z.ZodString;
        acceptedNegotiationDecisionId: z.ZodString;
        acceptedOfferVersionId: z.ZodString;
        acceptedOfferSequence: z.ZodNumber;
        acceptedOfferContentDigest: z.ZodString;
        acceptedByPartyId: z.ZodString;
        counterpartyRef: z.ZodString;
        agreementDigest: z.ZodString;
        agreementObjectRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
        agreementContentRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
        proofGapRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
        agreementEvidencePosture: z.ZodLiteral<"local_evidence_only">;
        clearingEvidenceRefs: z.ZodDefault<z.ZodObject<{
            correlationRef: z.ZodOptional<z.ZodString>;
            obligationRef: z.ZodOptional<z.ZodString>;
            counterpartyRef: z.ZodOptional<z.ZodString>;
        }, z.core.$strict>>;
        externalProtocolEvidenceRefs: z.ZodDefault<z.ZodArray<z.ZodObject<{
            protocol: z.ZodEnum<{
                a2a: "a2a";
                acp: "acp";
                anp: "anp";
                ap2: "ap2";
                mcp: "mcp";
                runtime_handoff: "runtime_handoff";
                other: "other";
            }>;
            protocolVersion: z.ZodString;
            objectKind: z.ZodString;
            objectRef: z.ZodString;
            objectDigest: z.ZodString;
            evidencePosture: z.ZodLiteral<"imported_evidence_only">;
            evidenceUse: z.ZodEnum<{
                conversation_context: "conversation_context";
                descriptor_context: "descriptor_context";
                runtime_context: "runtime_context";
                mandate_context_evidence: "mandate_context_evidence";
                tool_context: "tool_context";
                handoff_context: "handoff_context";
                other_context: "other_context";
            }>;
            proofGapRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
        }, z.core.$strict>>>;
        expiresAt: z.ZodDefault<z.ZodNullable<z.ZodString>>;
    }, z.core.$strict>;
}, z.core.$strict>, z.ZodObject<{
    objectType: z.ZodLiteral<"agreement_obligation_binding">;
    payload: z.ZodObject<{
        schemaVersion: z.ZodLiteral<"0.2.4">;
        tenantId: z.ZodString;
        organizationId: z.ZodString;
        createdAt: z.ZodString;
        agreementObligationBindingId: z.ZodString;
        linkedAgreementId: z.ZodString;
        negotiationSessionId: z.ZodString;
        obligationRef: z.ZodString;
        obligationDigest: z.ZodDefault<z.ZodNullable<z.ZodString>>;
        actionContractId: z.ZodString;
        actionContractDigest: z.ZodString;
        paramsDigest: z.ZodString;
        actionTypeId: z.ZodString;
        actionClass: z.ZodString;
        resourceRef: z.ZodString;
        counterpartyRef: z.ZodString;
        maxUses: z.ZodDefault<z.ZodLiteral<1>>;
        bindingPosture: z.ZodLiteral<"local_evidence_only">;
        localProtectedActionEvidenceRefs: z.ZodArray<z.ZodObject<{
            refKind: z.ZodEnum<{
                action_contract: "action_contract";
                generated_execution_graph: "generated_execution_graph";
                intent_compilation: "intent_compilation";
                candidate_action: "candidate_action";
            }>;
            ref: z.ZodString;
            digest: z.ZodDefault<z.ZodNullable<z.ZodString>>;
        }, z.core.$strict>>;
        evidenceRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
        proofGapRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
    }, z.core.$strict>;
}, z.core.$strict>, z.ZodObject<{
    objectType: z.ZodLiteral<"agreement_status_transition">;
    payload: z.ZodObject<{
        schemaVersion: z.ZodLiteral<"0.2.4">;
        tenantId: z.ZodString;
        organizationId: z.ZodString;
        createdAt: z.ZodString;
        agreementStatusTransitionId: z.ZodString;
        linkedAgreementId: z.ZodString;
        negotiationSessionId: z.ZodString;
        fromStatus: z.ZodEnum<{
            active: "active";
            expired: "expired";
            resolved: "resolved";
            proposed: "proposed";
            superseded: "superseded";
            disputed: "disputed";
            withdrawn: "withdrawn";
        }>;
        toStatus: z.ZodEnum<{
            active: "active";
            expired: "expired";
            resolved: "resolved";
            superseded: "superseded";
            disputed: "disputed";
            withdrawn: "withdrawn";
        }>;
        reasonCodes: z.ZodDefault<z.ZodArray<z.ZodString>>;
        evidenceRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
        proofGapRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
        transitionDigest: z.ZodString;
    }, z.core.$strict>;
}, z.core.$strict>, z.ZodObject<{
    objectType: z.ZodLiteral<"action_contract">;
    payload: z.ZodObject<{
        schemaVersion: z.ZodLiteral<"0.2.4">;
        tenantId: z.ZodString;
        organizationId: z.ZodString;
        createdAt: z.ZodString;
        actionContractId: z.ZodString;
        intentCompilationId: z.ZodString;
        candidateActionId: z.ZodString;
        candidateDigest: z.ZodString;
        envelopeId: z.ZodString;
        operatingEnvelopeDigest: z.ZodString;
        agentId: z.ZodString;
        principalId: z.ZodString;
        participantIdentityBindings: z.ZodDefault<z.ZodArray<z.ZodObject<{
            participantRole: z.ZodEnum<{
                principal: "principal";
                agent: "agent";
            }>;
            participantRef: z.ZodString;
            identityProviderRef: z.ZodString;
            subjectRef: z.ZodDefault<z.ZodNullable<z.ZodString>>;
            subjectDigest: z.ZodDefault<z.ZodNullable<z.ZodString>>;
            claimsDigest: z.ZodDefault<z.ZodNullable<z.ZodString>>;
            verificationEvidenceRef: z.ZodString;
            bindingEvidenceRef: z.ZodDefault<z.ZodNullable<z.ZodString>>;
            issuedAt: z.ZodDefault<z.ZodNullable<z.ZodString>>;
            expiresAt: z.ZodDefault<z.ZodNullable<z.ZodString>>;
            authorityPosture: z.ZodDefault<z.ZodLiteral<"evidence_only">>;
        }, z.core.$strict>>>;
        runId: z.ZodString;
        runtimeAdapterId: z.ZodString;
        sequenceNumber: z.ZodNumber;
        requiredPriorActionContractIds: z.ZodDefault<z.ZodArray<z.ZodString>>;
        recoveryRecommendationId: z.ZodNullable<z.ZodString>;
        recoverySourceReceiptId: z.ZodNullable<z.ZodString>;
        recoveryRecommendationDigest: z.ZodNullable<z.ZodString>;
        issuedAt: z.ZodString;
        expiresAt: z.ZodString;
        gatewayRegistryEntryId: z.ZodString;
        gatewayRegistryDigest: z.ZodString;
        gatewayRegistryVersion: z.ZodString;
        gatewayId: z.ZodString;
        gatewayPolicyContractId: z.ZodString;
        gatewayPolicyVersion: z.ZodString;
        credentialCustodyStatus: z.ZodEnum<{
            unknown: "unknown";
            gateway_held: "gateway_held";
            fixture_gateway_held: "fixture_gateway_held";
            gateway_resolved_from_vault: "gateway_resolved_from_vault";
            provider_gateway_held: "provider_gateway_held";
            unsafe_agent_visible: "unsafe_agent_visible";
            unsafe_runtime_visible: "unsafe_runtime_visible";
            agent_has_raw_credential: "agent_has_raw_credential";
            shared_or_unknown: "shared_or_unknown";
            no_mutation_credential: "no_mutation_credential";
        }>;
        enforcementMode: z.ZodEnum<{
            unknown: "unknown";
            reference_fixture: "reference_fixture";
            customer_gateway_adapter: "customer_gateway_adapter";
            provider_gateway: "provider_gateway";
            hosted_control_plane_only: "hosted_control_plane_only";
        }>;
        mutationCredentialHolderRef: z.ZodString;
        gatewayAuthorityHolderRef: z.ZodString;
        toolCapabilityId: z.ZodString;
        toolCapabilityDigest: z.ZodString;
        actionTypeId: z.ZodString;
        actionTypeDigest: z.ZodString;
        actionClass: z.ZodString;
        protectedSurfaceKind: z.ZodString;
        resourceRef: z.ZodString;
        requiredProtectedPathState: z.ZodEnum<{
            not_required: "not_required";
            gateway_checked: "gateway_checked";
        }>;
        runtimeExecutionId: z.ZodNullable<z.ZodString>;
        runtimeExecutionDigest: z.ZodNullable<z.ZodString>;
        generatedExecutionGraphId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
        generatedExecutionGraphDigest: z.ZodDefault<z.ZodNullable<z.ZodString>>;
        generatedExecutionCoverageStatus: z.ZodDefault<z.ZodNullable<z.ZodEnum<{
            unknown: "unknown";
            fully_covered_no_unsupported_nodes: "fully_covered_no_unsupported_nodes";
            nonconsequential_only: "nonconsequential_only";
            contains_refusal: "contains_refusal";
            contains_coverage_gap: "contains_coverage_gap";
            contains_bypass_risk: "contains_bypass_risk";
            unsupported_or_ambiguous: "unsupported_or_ambiguous";
        }>>>;
        generatedExecutionNodeId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
        generatedExecutionNodeDigest: z.ZodDefault<z.ZodNullable<z.ZodString>>;
        generatedExecutionCatalogSnapshotDigest: z.ZodDefault<z.ZodNullable<z.ZodString>>;
        generatedExecutionGatewayRegistrySnapshotDigest: z.ZodDefault<z.ZodNullable<z.ZodString>>;
        generatedExecutionRegistryBindingSetDigest: z.ZodDefault<z.ZodNullable<z.ZodString>>;
        generatedExecutionNodeGatewayBindingDigest: z.ZodDefault<z.ZodNullable<z.ZodString>>;
        parameters: z.ZodRecord<z.ZodString, z.ZodType<import("../idempotency-ledger").JsonValue, unknown, z.core.$ZodTypeInternals<import("../idempotency-ledger").JsonValue, unknown>>>;
        paramsDigest: z.ZodString;
        nonSecretParamsSummary: z.ZodRecord<z.ZodString, z.ZodType<import("../idempotency-ledger").JsonValue, unknown, z.core.$ZodTypeInternals<import("../idempotency-ledger").JsonValue, unknown>>>;
        secretRefs: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
        gatewayCredentialRefs: z.ZodDefault<z.ZodArray<z.ZodObject<{
            credentialUseName: z.ZodString;
            gatewayCredentialRefId: z.ZodString;
            gatewayCredentialRefDigest: z.ZodString;
            providerRegistryRef: z.ZodString;
            providerRegistryDigest: z.ZodDefault<z.ZodNullable<z.ZodString>>;
            requiredCredentialCustodyStatus: z.ZodEnum<{
                unknown: "unknown";
                gateway_held: "gateway_held";
                fixture_gateway_held: "fixture_gateway_held";
                gateway_resolved_from_vault: "gateway_resolved_from_vault";
                provider_gateway_held: "provider_gateway_held";
                unsafe_agent_visible: "unsafe_agent_visible";
                unsafe_runtime_visible: "unsafe_runtime_visible";
                agent_has_raw_credential: "agent_has_raw_credential";
                shared_or_unknown: "shared_or_unknown";
                no_mutation_credential: "no_mutation_credential";
            }>;
            evidenceExpectationRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
        }, z.core.$strict>>>;
        delegatedAuthorityRefs: z.ZodDefault<z.ZodArray<z.ZodObject<{
            authorityUseName: z.ZodString;
            delegatedAuthorityRefId: z.ZodString;
            delegatedAuthorityRefDigest: z.ZodString;
            requiredGrantStatus: z.ZodDefault<z.ZodLiteral<"active">>;
            authorityKind: z.ZodEnum<{
                mutation: "mutation";
                spend: "spend";
                api_call: "api_call";
            }>;
            policyPackRef: z.ZodString;
            policyPackVersion: z.ZodString;
            evidenceExpectationRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
        }, z.core.$strict>>>;
        purposeCode: z.ZodString;
        expectedSideEffectCodes: z.ZodArray<z.ZodString>;
        evidenceRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
        clearingEvidenceRefs: z.ZodDefault<z.ZodObject<{
            correlationRef: z.ZodOptional<z.ZodString>;
            obligationRef: z.ZodOptional<z.ZodString>;
            counterpartyRef: z.ZodOptional<z.ZodString>;
        }, z.core.$strict>>;
        bounds: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodType<import("../idempotency-ledger").JsonValue, unknown, z.core.$ZodTypeInternals<import("../idempotency-ledger").JsonValue, unknown>>>>;
        idempotencyKey: z.ZodString;
        rollbackHint: z.ZodNullable<z.ZodString>;
        canonicalizerVersion: z.ZodString;
        actionContractDigest: z.ZodString;
        contractSignature: z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodString]>>;
        signaturePosture: z.ZodEnum<{
            unsigned: "unsigned";
            local_hmac: "local_hmac";
            external_signature: "external_signature";
            unverified: "unverified";
        }>;
        keyIdentityRef: z.ZodNullable<z.ZodString>;
        verificationPolicyRef: z.ZodNullable<z.ZodString>;
    }, z.core.$strict>;
}, z.core.$strict>, z.ZodObject<{
    objectType: z.ZodLiteral<"authority_certificate">;
    payload: z.ZodObject<{
        schemaVersion: z.ZodLiteral<"0.2.4">;
        tenantId: z.ZodString;
        organizationId: z.ZodString;
        createdAt: z.ZodString;
        authorityCertificateId: z.ZodString;
        authorityCertificateVersion: z.ZodLiteral<"1.0.0">;
        canonicalizerVersion: z.ZodString;
        terminalizedAt: z.ZodString;
        terminal: z.ZodObject<{
            terminalKind: z.ZodEnum<{
                proof_gap: "proof_gap";
                receipt: "receipt";
                durable_refusal: "durable_refusal";
                replay_refusal: "replay_refusal";
            }>;
            terminalObjectRef: z.ZodString;
            actionContractId: z.ZodString;
            policyDecisionId: z.ZodNullable<z.ZodString>;
            greenlightId: z.ZodNullable<z.ZodString>;
            gatewayId: z.ZodNullable<z.ZodString>;
        }, z.core.$strict>;
        envelope: z.ZodObject<{
            actionContractRef: z.ZodString;
            contractDigest: z.ZodString;
            policyDecisionRef: z.ZodString;
            policyDecisionStatus: z.ZodEnum<{
                review_required: "review_required";
                proof_gap: "proof_gap";
                refuse: "refuse";
                quarantine: "quarantine";
                greenlight: "greenlight";
                halt: "halt";
            }>;
            greenlightRef: z.ZodNullable<z.ZodString>;
            gateAttemptRef: z.ZodNullable<z.ZodString>;
            mutationAttemptRef: z.ZodNullable<z.ZodString>;
            receiptRef: z.ZodNullable<z.ZodString>;
            principalRef: z.ZodString;
            agentRef: z.ZodString;
            participantIdentityBindings: z.ZodDefault<z.ZodArray<z.ZodObject<{
                participantRole: z.ZodEnum<{
                    principal: "principal";
                    agent: "agent";
                }>;
                participantRef: z.ZodString;
                identityProviderRef: z.ZodString;
                subjectRef: z.ZodDefault<z.ZodNullable<z.ZodString>>;
                subjectDigest: z.ZodDefault<z.ZodNullable<z.ZodString>>;
                claimsDigest: z.ZodDefault<z.ZodNullable<z.ZodString>>;
                verificationEvidenceRef: z.ZodString;
                bindingEvidenceRef: z.ZodDefault<z.ZodNullable<z.ZodString>>;
                issuedAt: z.ZodDefault<z.ZodNullable<z.ZodString>>;
                expiresAt: z.ZodDefault<z.ZodNullable<z.ZodString>>;
                authorityPosture: z.ZodDefault<z.ZodLiteral<"evidence_only">>;
            }, z.core.$strict>>>;
            runId: z.ZodString;
            runtimeAdapterRef: z.ZodString;
            actionClass: z.ZodString;
            protectedSurfaceKind: z.ZodString;
            resourceRef: z.ZodString;
            gatewayId: z.ZodString;
            gatewayPolicyVersion: z.ZodString;
            idempotencyKey: z.ZodString;
            paramsDigest: z.ZodString;
            nonSecretParamsSummary: z.ZodRecord<z.ZodString, z.ZodType<import("../idempotency-ledger").JsonValue, unknown, z.core.$ZodTypeInternals<import("../idempotency-ledger").JsonValue, unknown>>>;
            clearingEvidenceRefs: z.ZodDefault<z.ZodObject<{
                correlationRef: z.ZodOptional<z.ZodString>;
                obligationRef: z.ZodOptional<z.ZodString>;
                counterpartyRef: z.ZodOptional<z.ZodString>;
            }, z.core.$strict>>;
            surfaceOperationRef: z.ZodNullable<z.ZodString>;
            surfaceOperationReconciliationRef: z.ZodNullable<z.ZodString>;
            surfaceOperationEvidenceLabels: z.ZodDefault<z.ZodArray<z.ZodString>>;
            surfaceOperationEvidenceRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
            gatewayCredentialEvidenceRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
            delegatedAuthorityEvidenceRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
            credentialResolutionEvidenceRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
            typedCommitmentRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
            typedCommitmentSetDigest: z.ZodDefault<z.ZodNullable<z.ZodString>>;
            typedCommitmentProjectionClass: z.ZodDefault<z.ZodNullable<z.ZodEnum<{
                public_redacted: "public_redacted";
                operator_redacted: "operator_redacted";
                auditor_export: "auditor_export";
            }>>>;
            typedCommitmentSummaries: z.ZodDefault<z.ZodArray<z.ZodObject<{
                typedActionCommitmentId: z.ZodString;
                commitmentDigest: z.ZodString;
                subjectDigest: z.ZodString;
                purpose: z.ZodEnum<{
                    external_commitment_evidence: "external_commitment_evidence";
                    policy_required_evidence: "policy_required_evidence";
                    service_workflow_readback: "service_workflow_readback";
                    post_gateway_payment_evidence: "post_gateway_payment_evidence";
                    display_binding_evidence: "display_binding_evidence";
                }>;
                profile: z.ZodEnum<{
                    handshake_jcs_typed: "handshake_jcs_typed";
                    eip712: "eip712";
                }>;
                verificationStatus: z.ZodEnum<{
                    unverified: "unverified";
                    proof_gap: "proof_gap";
                    verified: "verified";
                    refused: "refused";
                    unsupported: "unsupported";
                }>;
                replayStatus: z.ZodEnum<{
                    stale: "stale";
                    fresh: "fresh";
                    replayed: "replayed";
                    missing: "missing";
                    not_applicable: "not_applicable";
                }>;
                verifierContextDigest: z.ZodDefault<z.ZodNullable<z.ZodString>>;
                safetyPosture: z.ZodEnum<{
                    proof_gap: "proof_gap";
                    refused: "refused";
                    display_bound: "display_bound";
                    digest_bound: "digest_bound";
                    verifier_bound: "verifier_bound";
                    provider_observed: "provider_observed";
                }>;
            }, z.core.$strict>>>;
            typedCommitmentProjections: z.ZodDefault<z.ZodArray<z.ZodObject<{
                typedActionCommitmentRef: z.ZodString;
                actionContractRef: z.ZodNullable<z.ZodString>;
                projectionClass: z.ZodEnum<{
                    public_redacted: "public_redacted";
                    operator_redacted: "operator_redacted";
                    auditor_export: "auditor_export";
                }>;
                commitmentDigest: z.ZodString;
                subject: z.ZodObject<{
                    kind: z.ZodEnum<{
                        action_contract: "action_contract";
                        service_workflow: "service_workflow";
                        x402_payment: "x402_payment";
                        agentic_endpoint_access: "agentic_endpoint_access";
                        protected_surface: "protected_surface";
                        external_evidence: "external_evidence";
                    }>;
                    ref: z.ZodString;
                    digest: z.ZodString;
                }, z.core.$strict>;
                purpose: z.ZodEnum<{
                    external_commitment_evidence: "external_commitment_evidence";
                    policy_required_evidence: "policy_required_evidence";
                    service_workflow_readback: "service_workflow_readback";
                    post_gateway_payment_evidence: "post_gateway_payment_evidence";
                    display_binding_evidence: "display_binding_evidence";
                }>;
                profile: z.ZodEnum<{
                    handshake_jcs_typed: "handshake_jcs_typed";
                    eip712: "eip712";
                }>;
                domain: z.ZodObject<{
                    domainRef: z.ZodString;
                    domainDigest: z.ZodDefault<z.ZodNullable<z.ZodString>>;
                    tenantId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
                    organizationId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
                    gatewayId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
                    actionClass: z.ZodDefault<z.ZodNullable<z.ZodString>>;
                    providerEnvironmentRef: z.ZodDefault<z.ZodNullable<z.ZodString>>;
                }, z.core.$strict>;
                verificationStatus: z.ZodEnum<{
                    unverified: "unverified";
                    proof_gap: "proof_gap";
                    verified: "verified";
                    refused: "refused";
                    unsupported: "unsupported";
                }>;
                verificationReasonCode: z.ZodNullable<z.ZodString>;
                replayStatus: z.ZodEnum<{
                    stale: "stale";
                    fresh: "fresh";
                    replayed: "replayed";
                    missing: "missing";
                    not_applicable: "not_applicable";
                }>;
                idempotencyKey: z.ZodNullable<z.ZodString>;
                nonceRef: z.ZodNullable<z.ZodString>;
                nonceDigest: z.ZodNullable<z.ZodString>;
                replayWindowSeconds: z.ZodNullable<z.ZodNumber>;
                verifierRef: z.ZodNullable<z.ZodString>;
                verifierContextDigest: z.ZodNullable<z.ZodString>;
                keyId: z.ZodNullable<z.ZodString>;
                providerNativeDigest: z.ZodNullable<z.ZodString>;
                safetyPosture: z.ZodEnum<{
                    proof_gap: "proof_gap";
                    refused: "refused";
                    display_bound: "display_bound";
                    digest_bound: "digest_bound";
                    verifier_bound: "verifier_bound";
                    provider_observed: "provider_observed";
                }>;
                displayBindingStatus: z.ZodEnum<{
                    proof_gap: "proof_gap";
                    refused: "refused";
                    display_bound: "display_bound";
                    digest_bound: "digest_bound";
                    verifier_bound: "verifier_bound";
                    provider_observed: "provider_observed";
                }>;
                authorityBoundary: z.ZodObject<{
                    createsPolicyDecision: z.ZodLiteral<false>;
                    createsGreenlight: z.ZodLiteral<false>;
                    performsGatewayCheck: z.ZodLiteral<false>;
                    authorizesMutation: z.ZodLiteral<false>;
                    createsReceipt: z.ZodLiteral<false>;
                    mintsCertificate: z.ZodLiteral<false>;
                    provesPrincipalConsent: z.ZodLiteral<false>;
                    provesSignerCustody: z.ZodLiteral<false>;
                    provesPaymentCustody: z.ZodLiteral<false>;
                    createsEndpointLease: z.ZodLiteral<false>;
                    provesDownstreamSuccess: z.ZodLiteral<false>;
                }, z.core.$strict>;
                refusalRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
                proofGapRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
                evidenceRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
                signatureEvidence: z.ZodNullable<z.ZodObject<{
                    signatureRef: z.ZodNullable<z.ZodString>;
                    signatureDigest: z.ZodNullable<z.ZodString>;
                }, z.core.$strict>>;
                rawReadAudit: z.ZodNullable<z.ZodObject<{
                    rawRecordReadAuditRef: z.ZodString;
                    rawRecordReadAuditDigest: z.ZodString;
                    redactionPosture: z.ZodLiteral<"auditor_signature_digest_only">;
                }, z.core.$strict>>;
                rawTypedPayloadIncluded: z.ZodLiteral<false>;
                rawSignatureIncluded: z.ZodLiteral<false>;
                rawCredentialMaterialIncluded: z.ZodLiteral<false>;
                rawPaymentMaterialIncluded: z.ZodLiteral<false>;
                rawRequestBodyIncluded: z.ZodLiteral<false>;
                commandMaterialIncluded: z.ZodLiteral<false>;
                redactionProfileRef: z.ZodEnum<{
                    public_redacted: "public_redacted";
                    operator_redacted: "operator_redacted";
                    auditor_signature_digest_only: "auditor_signature_digest_only";
                }>;
                omittedFields: z.ZodDefault<z.ZodArray<z.ZodString>>;
            }, z.core.$strict>>>;
            typedCommitmentRefusalRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
            typedCommitmentProofGapRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
            signerInvocationEvidenceRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
            downstreamEvidenceRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
            authMdEvidenceRefs: z.ZodObject<{
                discoveryRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
                authorizationServerRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
                identityAssertionRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
                registrationRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
                claimRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
                revocationRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
                credentialCustodyRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
                credentialResolutionRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
                protectedApiCallRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
                downstreamEvidenceRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
            }, z.core.$strict>;
            authMdEvidenceLabels: z.ZodDefault<z.ZodArray<z.ZodString>>;
            providerRequestRef: z.ZodNullable<z.ZodString>;
            providerOperationRef: z.ZodNullable<z.ZodString>;
            downstreamRetryability: z.ZodNullable<z.ZodEnum<{
                unknown: "unknown";
                retryable: "retryable";
                non_retryable: "non_retryable";
            }>>;
            reconciliationFinalityStatus: z.ZodNullable<z.ZodEnum<{
                unknown: "unknown";
                pending: "pending";
                final: "final";
                suspect: "suspect";
            }>>;
            gatewayAdmissionStatus: z.ZodEnum<{
                proof_gap: "proof_gap";
                refused: "refused";
                replayed: "replayed";
                not_requested: "not_requested";
                admitted: "admitted";
            }>;
            greenlightConsumptionStatus: z.ZodNullable<z.ZodEnum<{
                replayed: "replayed";
                not_applicable: "not_applicable";
                not_consumed: "not_consumed";
                consumed: "consumed";
            }>>;
            downstreamOutcomeStatus: z.ZodEnum<{
                unknown: "unknown";
                refused: "refused";
                failed: "failed";
                succeeded: "succeeded";
                pending: "pending";
                not_started: "not_started";
            }>;
            proofGapRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
            proofGapReasonCodes: z.ZodDefault<z.ZodArray<z.ZodString>>;
            refusalRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
            refusalReasonCodes: z.ZodDefault<z.ZodArray<z.ZodString>>;
            idempotencyLedgerRef: z.ZodNullable<z.ZodString>;
            idempotencyLedgerState: z.ZodNullable<z.ZodEnum<{
                terminal_unknown: "terminal_unknown";
                authority_reserved: "authority_reserved";
                mutation_started: "mutation_started";
                terminal_succeeded: "terminal_succeeded";
                terminal_failed: "terminal_failed";
                terminal_refused: "terminal_refused";
            }>>;
            idempotencyRecoveryDisposition: z.ZodNullable<z.ZodEnum<{
                missing: "missing";
                same_params_result_available: "same_params_result_available";
                same_params_duplicate_refused: "same_params_duplicate_refused";
                different_params_refused: "different_params_refused";
                terminal_unknown_requires_recovery: "terminal_unknown_requires_recovery";
            }>>;
            idempotencyReasonCodes: z.ZodDefault<z.ZodArray<z.ZodString>>;
            recoveryRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
            isolationRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
            authorityCertificateRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
            evidenceRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
            streamOffsets: z.ZodDefault<z.ZodArray<z.ZodObject<{
                streamId: z.ZodString;
                streamScope: z.ZodEnum<{
                    tenant: "tenant";
                    organization: "organization";
                    run: "run";
                    protected_surface_resource: "protected_surface_resource";
                }>;
                partitionKey: z.ZodString;
                offsetStart: z.ZodNumber;
                offsetEnd: z.ZodNumber;
                terminalEventDigest: z.ZodString;
            }, z.core.$strict>>>;
            receiptDigest: z.ZodNullable<z.ZodString>;
            auditChainDigest: z.ZodNullable<z.ZodString>;
            receiptExportRef: z.ZodNullable<z.ZodString>;
            redactionProfileRef: z.ZodLiteral<"agent-transaction-envelope:v0.2-redacted">;
            omittedFields: z.ZodDefault<z.ZodArray<z.ZodString>>;
            envelopeDigest: z.ZodString;
        }, z.core.$strict>;
        envelopeDigest: z.ZodString;
        artifacts: z.ZodArray<z.ZodObject<{
            kind: z.ZodEnum<{
                refusal: "refusal";
                proof_gap: "proof_gap";
                receipt: "receipt";
                action_contract: "action_contract";
                greenlight: "greenlight";
                credential_resolution_evidence: "credential_resolution_evidence";
                typed_action_commitment: "typed_action_commitment";
                idempotency_ledger_entry: "idempotency_ledger_entry";
                policy_decision: "policy_decision";
                isolation_state: "isolation_state";
                gateway_check_attempt: "gateway_check_attempt";
                mutation_attempt: "mutation_attempt";
                surface_operation_reconciliation: "surface_operation_reconciliation";
                receipt_export: "receipt_export";
                recovery_recommendation: "recovery_recommendation";
                recovery_recommendation_status_transition: "recovery_recommendation_status_transition";
            }>;
            objectRef: z.ZodString;
            digest: z.ZodString;
        }, z.core.$strict>>;
        verificationPolicy: z.ZodObject<{
            verificationPolicyId: z.ZodString;
            terminalKind: z.ZodEnum<{
                proof_gap: "proof_gap";
                receipt: "receipt";
                durable_refusal: "durable_refusal";
                replay_refusal: "replay_refusal";
            }>;
            actionClass: z.ZodString;
            gatewayAdmissionRequired: z.ZodBoolean;
            requiredSignerRoles: z.ZodArray<z.ZodEnum<{
                gateway: "gateway";
                operator_policy: "operator_policy";
            }>>;
            requiredArtifactKinds: z.ZodDefault<z.ZodArray<z.ZodEnum<{
                refusal: "refusal";
                proof_gap: "proof_gap";
                receipt: "receipt";
                action_contract: "action_contract";
                greenlight: "greenlight";
                credential_resolution_evidence: "credential_resolution_evidence";
                typed_action_commitment: "typed_action_commitment";
                idempotency_ledger_entry: "idempotency_ledger_entry";
                policy_decision: "policy_decision";
                isolation_state: "isolation_state";
                gateway_check_attempt: "gateway_check_attempt";
                mutation_attempt: "mutation_attempt";
                surface_operation_reconciliation: "surface_operation_reconciliation";
                receipt_export: "receipt_export";
                recovery_recommendation: "recovery_recommendation";
                recovery_recommendation_status_transition: "recovery_recommendation_status_transition";
            }>>>;
        }, z.core.$strict>;
        signatures: z.ZodArray<z.ZodObject<{
            signerRole: z.ZodEnum<{
                gateway: "gateway";
                operator_policy: "operator_policy";
            }>;
            keyIdentityRef: z.ZodString;
            algorithm: z.ZodEnum<{
                ed25519: "ed25519";
                "hmac-sha256": "hmac-sha256";
            }>;
            signedOver: z.ZodString;
            signature: z.ZodUnion<readonly [z.ZodString, z.ZodString]>;
        }, z.core.$strict>>;
        consumerBindings: z.ZodDefault<z.ZodArray<z.ZodObject<{
            bindingKind: z.ZodString;
            bindingRef: z.ZodString;
            digest: z.ZodDefault<z.ZodNullable<z.ZodString>>;
        }, z.core.$strict>>>;
        extensions: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodType<import("../idempotency-ledger").JsonValue, unknown, z.core.$ZodTypeInternals<import("../idempotency-ledger").JsonValue, unknown>>>>;
        emittedAt: z.ZodString;
        signingInputDigest: z.ZodString;
    }, z.core.$strict>;
}, z.core.$strict>, z.ZodObject<{
    objectType: z.ZodLiteral<"policy_decision">;
    payload: z.ZodObject<{
        schemaVersion: z.ZodLiteral<"0.2.4">;
        tenantId: z.ZodString;
        organizationId: z.ZodString;
        createdAt: z.ZodString;
        policyDecisionId: z.ZodString;
        actionContractId: z.ZodString;
        envelopeId: z.ZodString;
        policyPackRef: z.ZodString;
        policyPackVersion: z.ZodString;
        policyEvaluatorVersion: z.ZodString;
        policyInputDigest: z.ZodString;
        decision: z.ZodEnum<{
            review_required: "review_required";
            proof_gap: "proof_gap";
            refuse: "refuse";
            quarantine: "quarantine";
            greenlight: "greenlight";
            halt: "halt";
        }>;
        decisionReasonCode: z.ZodString;
        decisionReason: z.ZodString;
        matchedRuleIds: z.ZodDefault<z.ZodArray<z.ZodString>>;
        requiredReceipt: z.ZodEnum<{
            none: "none";
            gate: "gate";
            mutation: "mutation";
            downstream_finality: "downstream_finality";
        }>;
        isolationSnapshotRef: z.ZodString;
        expiresAt: z.ZodString;
        decisionSignature: z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodString]>>;
        signaturePosture: z.ZodEnum<{
            unsigned: "unsigned";
            local_hmac: "local_hmac";
            external_signature: "external_signature";
            unverified: "unverified";
        }>;
        keyIdentityRef: z.ZodNullable<z.ZodString>;
        verificationPolicyRef: z.ZodNullable<z.ZodString>;
    }, z.core.$strict>;
}, z.core.$strict>, z.ZodObject<{
    objectType: z.ZodLiteral<"greenlight">;
    payload: z.ZodObject<{
        schemaVersion: z.ZodLiteral<"0.2.4">;
        tenantId: z.ZodString;
        organizationId: z.ZodString;
        createdAt: z.ZodString;
        greenlightId: z.ZodString;
        actionContractId: z.ZodString;
        policyDecisionId: z.ZodString;
        gatewayRegistryEntryId: z.ZodString;
        gatewayRegistryDigest: z.ZodDefault<z.ZodNullable<z.ZodString>>;
        gatewayRegistryVersion: z.ZodString;
        gatewayId: z.ZodString;
        gatewayPolicyVersion: z.ZodString;
        policyVersionRef: z.ZodDefault<z.ZodNullable<z.ZodString>>;
        policyVersionDigest: z.ZodDefault<z.ZodNullable<z.ZodString>>;
        gatewayReadinessRef: z.ZodDefault<z.ZodNullable<z.ZodString>>;
        gatewayReadinessDigest: z.ZodDefault<z.ZodNullable<z.ZodString>>;
        actionClass: z.ZodString;
        resourceRef: z.ZodString;
        requiredProtectedPathState: z.ZodEnum<{
            not_required: "not_required";
            gateway_checked: "gateway_checked";
        }>;
        protectedPathPostureId: z.ZodNullable<z.ZodString>;
        protectedPathPostureDigest: z.ZodNullable<z.ZodString>;
        gatewayCredentialRefIds: z.ZodDefault<z.ZodArray<z.ZodString>>;
        gatewayCredentialRefDigests: z.ZodDefault<z.ZodArray<z.ZodString>>;
        delegatedAuthorityRefIds: z.ZodDefault<z.ZodArray<z.ZodString>>;
        delegatedAuthorityRefDigests: z.ZodDefault<z.ZodArray<z.ZodString>>;
        requiredTypedCommitmentRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
        requiredTypedCommitmentSetDigest: z.ZodDefault<z.ZodNullable<z.ZodString>>;
        paramsDigest: z.ZodString;
        contractDigest: z.ZodString;
        idempotencyKey: z.ZodDefault<z.ZodNullable<z.ZodString>>;
        idempotencyLedgerKeyDigest: z.ZodDefault<z.ZodNullable<z.ZodString>>;
        maxUses: z.ZodLiteral<1>;
        issuedAt: z.ZodString;
        notBefore: z.ZodString;
        expiresAt: z.ZodString;
        isolationSnapshotRef: z.ZodString;
        requiredReceipt: z.ZodEnum<{
            none: "none";
            gate: "gate";
            mutation: "mutation";
            downstream_finality: "downstream_finality";
        }>;
        decisionSignature: z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodString]>>;
        signaturePosture: z.ZodEnum<{
            unsigned: "unsigned";
            local_hmac: "local_hmac";
            external_signature: "external_signature";
            unverified: "unverified";
        }>;
        keyIdentityRef: z.ZodNullable<z.ZodString>;
        verificationPolicyRef: z.ZodNullable<z.ZodString>;
        consumedAt: z.ZodNullable<z.ZodString>;
        consumedByGateAttemptId: z.ZodNullable<z.ZodString>;
    }, z.core.$strict>;
}, z.core.$strict>, z.ZodObject<{
    objectType: z.ZodLiteral<"review_artifact">;
    payload: z.ZodObject<{
        schemaVersion: z.ZodLiteral<"0.2.4">;
        tenantId: z.ZodString;
        organizationId: z.ZodString;
        createdAt: z.ZodString;
        reviewArtifactId: z.ZodString;
        reviewArtifactRef: z.ZodString;
        reviewRenderSchemaVersion: z.ZodString;
        rendererRef: z.ZodString;
        actionContractId: z.ZodString;
        actionContractDigest: z.ZodString;
        policyDecisionId: z.ZodString;
        policyInputDigest: z.ZodString;
        gatewayPolicyVersion: z.ZodString;
        renderedContractDigest: z.ZodString;
        renderedPolicyInputDigest: z.ZodString;
        renderedUncertaintyDigest: z.ZodString;
        renderedArtifactDigest: z.ZodString;
        catalogDigest: z.ZodDefault<z.ZodNullable<z.ZodString>>;
        rendererDigest: z.ZodDefault<z.ZodNullable<z.ZodString>>;
        actionBindingDigest: z.ZodDefault<z.ZodNullable<z.ZodString>>;
        hiddenActionPosture: z.ZodDefault<z.ZodEnum<{
            unknown: "unknown";
            no_hidden_actions_detected: "no_hidden_actions_detected";
            hidden_action_risk: "hidden_action_risk";
        }>>;
        secondaryActionPosture: z.ZodDefault<z.ZodEnum<{
            unknown: "unknown";
            no_secondary_actions_detected: "no_secondary_actions_detected";
            secondary_action_risk: "secondary_action_risk";
        }>>;
        uncertaintyMarkers: z.ZodDefault<z.ZodArray<z.ZodString>>;
        evidenceRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
        reviewArtifactDigest: z.ZodString;
    }, z.core.$strict>;
}, z.core.$strict>, z.ZodObject<{
    objectType: z.ZodLiteral<"review_decision">;
    payload: z.ZodObject<{
        schemaVersion: z.ZodLiteral<"0.2.4">;
        tenantId: z.ZodString;
        organizationId: z.ZodString;
        createdAt: z.ZodString;
        reviewDecisionId: z.ZodString;
        reviewArtifactId: z.ZodString;
        reviewArtifactRef: z.ZodString;
        reviewArtifactDigest: z.ZodString;
        reviewRenderSchemaVersion: z.ZodString;
        reviewerPrincipalId: z.ZodString;
        actionContractId: z.ZodString;
        actionContractDigest: z.ZodString;
        policyInputDigest: z.ZodString;
        gatewayPolicyVersion: z.ZodString;
        decision: z.ZodEnum<{
            reject: "reject";
            approve: "approve";
            needs_changes: "needs_changes";
        }>;
        decisionReasonCode: z.ZodString;
        decisionExpiresAt: z.ZodString;
        signatureOrAttestationRef: z.ZodString;
    }, z.core.$strict>;
}, z.core.$strict>, z.ZodObject<{
    objectType: z.ZodLiteral<"breaker_decision">;
    payload: z.ZodObject<{
        schemaVersion: z.ZodLiteral<"0.2.4">;
        tenantId: z.ZodString;
        organizationId: z.ZodString;
        createdAt: z.ZodString;
        breakerDecisionId: z.ZodString;
        listenerId: z.ZodString;
        listenerVersion: z.ZodString;
        rulePackRef: z.ZodString;
        rulePackVersion: z.ZodString;
        observedStreamOffsets: z.ZodArray<z.ZodObject<{
            streamId: z.ZodString;
            partitionKey: z.ZodString;
            observedOffsetStart: z.ZodNumber;
            observedOffsetEnd: z.ZodNumber;
            observedEventDigest: z.ZodNullable<z.ZodString>;
        }, z.core.$strict>>;
        observedWindowDigest: z.ZodString;
        decision: z.ZodEnum<{
            revoked: "revoked";
            quarantined: "quarantined";
            review_only: "review_only";
            rate_limited: "rate_limited";
            halted: "halted";
            state_suspect: "state_suspect";
        }>;
        decisionReasonCode: z.ZodString;
        decisionReason: z.ZodString;
        targetScopeType: z.ZodEnum<{
            gateway: "gateway";
            agent: "agent";
            tenant: "tenant";
            organization: "organization";
            run: "run";
            envelope: "envelope";
            action_class: "action_class";
            credential_ref: "credential_ref";
            authority_ref: "authority_ref";
            resource: "resource";
        }>;
        targetScopeId: z.ZodString;
        createdIsolationStateId: z.ZodString;
        agentId: z.ZodNullable<z.ZodString>;
        runId: z.ZodNullable<z.ZodString>;
        gatewayId: z.ZodNullable<z.ZodString>;
        resourceRef: z.ZodNullable<z.ZodString>;
        actionClass: z.ZodNullable<z.ZodString>;
        sequenceRiskScore: z.ZodNumber;
        matchedBreakerRuleIds: z.ZodDefault<z.ZodArray<z.ZodString>>;
        supportingEventRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
        missingEventRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
        proofGapRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
        decisionEffectiveAt: z.ZodString;
        decisionExpiresAt: z.ZodNullable<z.ZodString>;
        watermarkAtDecision: z.ZodString;
    }, z.core.$strict>;
}, z.core.$strict>, z.ZodObject<{
    objectType: z.ZodLiteral<"isolation_state">;
    payload: z.ZodObject<{
        schemaVersion: z.ZodLiteral<"0.2.4">;
        tenantId: z.ZodString;
        organizationId: z.ZodString;
        createdAt: z.ZodString;
        isolationStateId: z.ZodString;
        scopeType: z.ZodEnum<{
            gateway: "gateway";
            agent: "agent";
            tenant: "tenant";
            organization: "organization";
            run: "run";
            envelope: "envelope";
            action_class: "action_class";
            credential_ref: "credential_ref";
            authority_ref: "authority_ref";
            resource: "resource";
        }>;
        scopeId: z.ZodString;
        state: z.ZodEnum<{
            active: "active";
            revoked: "revoked";
            quarantined: "quarantined";
            review_only: "review_only";
            rate_limited: "rate_limited";
            halted: "halted";
            state_suspect: "state_suspect";
        }>;
        reasonCode: z.ZodString;
        reasonSummary: z.ZodString;
        sourceDecisionRef: z.ZodString;
        effectiveAt: z.ZodString;
        expiresAt: z.ZodNullable<z.ZodString>;
        clearedAt: z.ZodNullable<z.ZodString>;
        observedStreamOffsets: z.ZodDefault<z.ZodArray<z.ZodObject<{
            streamId: z.ZodString;
            partitionKey: z.ZodString;
            observedOffsetStart: z.ZodNumber;
            observedOffsetEnd: z.ZodNumber;
            observedEventDigest: z.ZodNullable<z.ZodString>;
        }, z.core.$strict>>>;
        version: z.ZodNumber;
    }, z.core.$strict>;
}, z.core.$strict>, z.ZodObject<{
    objectType: z.ZodLiteral<"gateway_check_attempt">;
    payload: z.ZodObject<{
        schemaVersion: z.ZodLiteral<"0.2.4">;
        tenantId: z.ZodString;
        organizationId: z.ZodString;
        createdAt: z.ZodString;
        gateAttemptId: z.ZodString;
        gatewayId: z.ZodString;
        gatewayPolicyContractId: z.ZodString;
        gatewayPolicyVersion: z.ZodString;
        pinnedGatewayPolicyVersion: z.ZodString;
        currentGatewayPolicyVersion: z.ZodNullable<z.ZodString>;
        gatewayPolicyDriftStatus: z.ZodEnum<{
            unknown: "unknown";
            same_version: "same_version";
            compatible_stricter: "compatible_stricter";
            incompatible: "incompatible";
        }>;
        actionContractId: z.ZodString;
        greenlightId: z.ZodString;
        contractDigestSeen: z.ZodString;
        greenlightDigestSeen: z.ZodString;
        paramsDigestSeen: z.ZodString;
        idempotencyKeySeen: z.ZodString;
        isolationSnapshotRef: z.ZodString;
        protectedPathPostureIdSeen: z.ZodNullable<z.ZodString>;
        protectedPathPostureDigestSeen: z.ZodNullable<z.ZodString>;
        protectedPathPostureStateSeen: z.ZodNullable<z.ZodEnum<{
            gateway_checked: "gateway_checked";
            bypass_risk: "bypass_risk";
            advisory: "advisory";
            blind: "blind";
            fixture_only: "fixture_only";
        }>>;
        observedTypedCommitmentRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
        observedTypedCommitmentSetDigest: z.ZodDefault<z.ZodNullable<z.ZodString>>;
        typedCommitmentRefusalReasonCodes: z.ZodDefault<z.ZodArray<z.ZodString>>;
        gateDecision: z.ZodEnum<{
            proof_gap: "proof_gap";
            refused: "refused";
            passed: "passed";
        }>;
        gateDecisionReasonCode: z.ZodString;
        consumedGreenlight: z.ZodBoolean;
        mutationAttemptId: z.ZodNullable<z.ZodString>;
    }, z.core.$strict>;
}, z.core.$strict>, z.ZodObject<{
    objectType: z.ZodLiteral<"mutation_attempt">;
    payload: z.ZodObject<{
        schemaVersion: z.ZodLiteral<"0.2.4">;
        tenantId: z.ZodString;
        organizationId: z.ZodString;
        createdAt: z.ZodString;
        mutationAttemptId: z.ZodString;
        gateAttemptId: z.ZodString;
        actionContractId: z.ZodString;
        greenlightId: z.ZodString;
        gatewayId: z.ZodString;
        actionClass: z.ZodString;
        resourceRef: z.ZodString;
        idempotencyKey: z.ZodString;
        outcome: z.ZodEnum<{
            unknown: "unknown";
            failed: "failed";
            not_attempted: "not_attempted";
            submitted: "submitted";
            succeeded: "succeeded";
            downstream_refused: "downstream_refused";
        }>;
        outcomeReasonCode: z.ZodString;
        surfaceOperationRef: z.ZodNullable<z.ZodString>;
        startedAt: z.ZodString;
        finishedAt: z.ZodNullable<z.ZodString>;
    }, z.core.$strict>;
}, z.core.$strict>, z.ZodObject<{
    objectType: z.ZodLiteral<"protected_surface_operation_claim">;
    payload: z.ZodObject<{
        schemaVersion: z.ZodLiteral<"0.2.4">;
        tenantId: z.ZodString;
        organizationId: z.ZodString;
        createdAt: z.ZodString;
        protectedSurfaceOperationClaimId: z.ZodString;
        claimKeyDigest: z.ZodString;
        gatewayId: z.ZodString;
        protectedSurfaceKind: z.ZodString;
        actionClass: z.ZodString;
        resourceRef: z.ZodString;
        actionContractId: z.ZodString;
        greenlightId: z.ZodString;
        gateAttemptId: z.ZodString;
        mutationAttemptId: z.ZodNullable<z.ZodString>;
        claimState: z.ZodEnum<{
            terminal_unknown: "terminal_unknown";
            active: "active";
            isolated: "isolated";
            terminal_succeeded: "terminal_succeeded";
            terminal_failed: "terminal_failed";
            terminal_refused: "terminal_refused";
        }>;
        claimedAt: z.ZodString;
        terminalAt: z.ZodNullable<z.ZodString>;
        terminalReasonCode: z.ZodNullable<z.ZodString>;
        releasedByRef: z.ZodNullable<z.ZodString>;
        claimDigest: z.ZodString;
    }, z.core.$strict>;
}, z.core.$strict>, z.ZodObject<{
    objectType: z.ZodLiteral<"surface_operation_reconciliation">;
    payload: z.ZodObject<{
        schemaVersion: z.ZodLiteral<"0.2.4">;
        tenantId: z.ZodString;
        organizationId: z.ZodString;
        createdAt: z.ZodString;
        reconciliationId: z.ZodString;
        mutationAttemptId: z.ZodString;
        gateAttemptId: z.ZodString;
        actionContractId: z.ZodString;
        greenlightId: z.ZodString;
        gatewayId: z.ZodString;
        idempotencyKey: z.ZodString;
        surfaceOperationRef: z.ZodNullable<z.ZodString>;
        previousMutationOutcome: z.ZodEnum<{
            unknown: "unknown";
            failed: "failed";
            not_attempted: "not_attempted";
            submitted: "submitted";
            succeeded: "succeeded";
            downstream_refused: "downstream_refused";
        }>;
        observedDownstreamStatus: z.ZodEnum<{
            unknown: "unknown";
            refused: "refused";
            failed: "failed";
            succeeded: "succeeded";
            pending: "pending";
        }>;
        downstreamRetryability: z.ZodDefault<z.ZodEnum<{
            unknown: "unknown";
            retryable: "retryable";
            non_retryable: "non_retryable";
        }>>;
        providerRequestRef: z.ZodDefault<z.ZodNullable<z.ZodString>>;
        providerOperationRef: z.ZodDefault<z.ZodNullable<z.ZodString>>;
        redactedDiagnosticsDigest: z.ZodDefault<z.ZodNullable<z.ZodString>>;
        traceRef: z.ZodDefault<z.ZodNullable<z.ZodString>>;
        spanRef: z.ZodDefault<z.ZodNullable<z.ZodString>>;
        diagnosticsRedactionPosture: z.ZodDefault<z.ZodEnum<{
            unknown: "unknown";
            none: "none";
            redacted: "redacted";
            digest_only: "digest_only";
        }>>;
        observedAt: z.ZodString;
        evidenceRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
        resolvedProofGapIds: z.ZodDefault<z.ZodArray<z.ZodString>>;
        reconciliationStatus: z.ZodEnum<{
            failed: "failed";
            pending: "pending";
            resolved: "resolved";
            still_unknown: "still_unknown";
        }>;
        finalityStatus: z.ZodEnum<{
            unknown: "unknown";
            pending: "pending";
            final: "final";
            suspect: "suspect";
        }>;
    }, z.core.$strict>;
}, z.core.$strict>, z.ZodObject<{
    objectType: z.ZodLiteral<"proof_gap">;
    payload: z.ZodObject<{
        schemaVersion: z.ZodLiteral<"0.2.4">;
        tenantId: z.ZodString;
        organizationId: z.ZodString;
        createdAt: z.ZodString;
        proofGapId: z.ZodString;
        gapPhase: z.ZodEnum<{
            compilation: "compilation";
            policy: "policy";
            recovery: "recovery";
            receipt: "receipt";
            gate: "gate";
            mutation: "mutation";
            stream: "stream";
        }>;
        expectedEvidenceType: z.ZodString;
        missingOrInvalidEvidenceRef: z.ZodString;
        affectedObjectRefs: z.ZodArray<z.ZodString>;
        gateAttemptId: z.ZodNullable<z.ZodString>;
        mutationAttemptId: z.ZodNullable<z.ZodString>;
        receiptId: z.ZodNullable<z.ZodString>;
        reasonCode: z.ZodString;
        finalityImpact: z.ZodEnum<{
            unknown: "unknown";
            none: "none";
            suspect: "suspect";
            invalid: "invalid";
        }>;
        recoveryRequirement: z.ZodString;
        resolvedAt: z.ZodNullable<z.ZodString>;
        resolvedByRef: z.ZodNullable<z.ZodString>;
    }, z.core.$strict>;
}, z.core.$strict>, z.ZodObject<{
    objectType: z.ZodLiteral<"refusal">;
    payload: z.ZodObject<{
        schemaVersion: z.ZodLiteral<"0.2.4">;
        tenantId: z.ZodString;
        organizationId: z.ZodString;
        createdAt: z.ZodString;
        refusalId: z.ZodString;
        phase: z.ZodEnum<{
            compilation: "compilation";
            policy: "policy";
            review: "review";
            gateway: "gateway";
            recovery: "recovery";
            receipt_export: "receipt_export";
            transition: "transition";
        }>;
        actionContractId: z.ZodNullable<z.ZodString>;
        policyDecisionId: z.ZodNullable<z.ZodString>;
        greenlightId: z.ZodNullable<z.ZodString>;
        gateAttemptId: z.ZodNullable<z.ZodString>;
        refusedObjectRef: z.ZodNullable<z.ZodString>;
        reasonCode: z.ZodString;
        reason: z.ZodString;
        mutationAttempted: z.ZodLiteral<false>;
        authorityCreated: z.ZodLiteral<false>;
        evidenceRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
        refusedAt: z.ZodString;
    }, z.core.$strict>;
}, z.core.$strict>, z.ZodObject<{
    objectType: z.ZodLiteral<"receipt">;
    payload: z.ZodObject<{
        schemaVersion: z.ZodLiteral<"0.2.4">;
        tenantId: z.ZodString;
        organizationId: z.ZodString;
        createdAt: z.ZodString;
        receiptId: z.ZodString;
        actionContractId: z.ZodString;
        policyDecisionId: z.ZodString;
        greenlightId: z.ZodNullable<z.ZodString>;
        gateAttemptId: z.ZodNullable<z.ZodString>;
        mutationAttemptId: z.ZodNullable<z.ZodString>;
        gatewayId: z.ZodString;
        policyDecisionStatus: z.ZodEnum<{
            review_required: "review_required";
            proof_gap: "proof_gap";
            refuse: "refuse";
            quarantine: "quarantine";
            greenlight: "greenlight";
            halt: "halt";
        }>;
        gatewayCheckStatus: z.ZodNullable<z.ZodEnum<{
            proof_gap: "proof_gap";
            refused: "refused";
            passed: "passed";
        }>>;
        gatewayAdmissionStatus: z.ZodEnum<{
            proof_gap: "proof_gap";
            refused: "refused";
            replayed: "replayed";
            not_requested: "not_requested";
            admitted: "admitted";
        }>;
        greenlightConsumptionStatus: z.ZodEnum<{
            replayed: "replayed";
            not_applicable: "not_applicable";
            not_consumed: "not_consumed";
            consumed: "consumed";
        }>;
        mutationAttemptStatus: z.ZodEnum<{
            unknown: "unknown";
            failed: "failed";
            not_attempted: "not_attempted";
            submitted: "submitted";
            succeeded: "succeeded";
            downstream_refused: "downstream_refused";
        }>;
        downstreamExecutionStatus: z.ZodEnum<{
            unknown: "unknown";
            refused: "refused";
            failed: "failed";
            succeeded: "succeeded";
            pending: "pending";
            not_started: "not_started";
        }>;
        downstreamOutcomeStatus: z.ZodEnum<{
            unknown: "unknown";
            refused: "refused";
            failed: "failed";
            succeeded: "succeeded";
            pending: "pending";
            not_started: "not_started";
        }>;
        proofGapIds: z.ZodDefault<z.ZodArray<z.ZodString>>;
        evidenceRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
        streamEventIds: z.ZodDefault<z.ZodArray<z.ZodString>>;
        streamOffsets: z.ZodDefault<z.ZodArray<z.ZodObject<{
            streamId: z.ZodString;
            streamScope: z.ZodEnum<{
                tenant: "tenant";
                organization: "organization";
                run: "run";
                protected_surface_resource: "protected_surface_resource";
            }>;
            partitionKey: z.ZodString;
            offsetStart: z.ZodNumber;
            offsetEnd: z.ZodNumber;
            terminalEventDigest: z.ZodString;
        }, z.core.$strict>>>;
        receiptDigest: z.ZodNullable<z.ZodString>;
        auditChainDigest: z.ZodNullable<z.ZodString>;
        finalityStatus: z.ZodEnum<{
            unknown: "unknown";
            pending: "pending";
            final: "final";
            suspect: "suspect";
        }>;
        emittedAt: z.ZodString;
    }, z.core.$strict>;
}, z.core.$strict>, z.ZodObject<{
    objectType: z.ZodLiteral<"receipt_export">;
    payload: z.ZodObject<{
        schemaVersion: z.ZodLiteral<"0.2.4">;
        tenantId: z.ZodString;
        organizationId: z.ZodString;
        createdAt: z.ZodString;
        receiptExportId: z.ZodString;
        receiptId: z.ZodString;
        actionContractId: z.ZodString;
        policyDecisionId: z.ZodString;
        greenlightId: z.ZodNullable<z.ZodString>;
        gateAttemptId: z.ZodNullable<z.ZodString>;
        mutationAttemptId: z.ZodNullable<z.ZodString>;
        gatewayId: z.ZodString;
        principalId: z.ZodString;
        agentId: z.ZodString;
        runId: z.ZodString;
        gatewayPolicyVersion: z.ZodString;
        policyDecisionStatus: z.ZodEnum<{
            review_required: "review_required";
            proof_gap: "proof_gap";
            refuse: "refuse";
            quarantine: "quarantine";
            greenlight: "greenlight";
            halt: "halt";
        }>;
        gatewayCheckStatus: z.ZodNullable<z.ZodEnum<{
            proof_gap: "proof_gap";
            refused: "refused";
            passed: "passed";
        }>>;
        gatewayAdmissionStatus: z.ZodEnum<{
            proof_gap: "proof_gap";
            refused: "refused";
            replayed: "replayed";
            not_requested: "not_requested";
            admitted: "admitted";
        }>;
        gatewayCheckedAt: z.ZodNullable<z.ZodString>;
        greenlightConsumptionStatus: z.ZodEnum<{
            replayed: "replayed";
            not_applicable: "not_applicable";
            not_consumed: "not_consumed";
            consumed: "consumed";
        }>;
        mutationAttemptStatus: z.ZodEnum<{
            unknown: "unknown";
            failed: "failed";
            not_attempted: "not_attempted";
            submitted: "submitted";
            succeeded: "succeeded";
            downstream_refused: "downstream_refused";
        }>;
        downstreamExecutionStatus: z.ZodEnum<{
            unknown: "unknown";
            refused: "refused";
            failed: "failed";
            succeeded: "succeeded";
            pending: "pending";
            not_started: "not_started";
        }>;
        downstreamOutcomeStatus: z.ZodEnum<{
            unknown: "unknown";
            refused: "refused";
            failed: "failed";
            succeeded: "succeeded";
            pending: "pending";
            not_started: "not_started";
        }>;
        proofGapStatus: z.ZodEnum<{
            none: "none";
            present: "present";
        }>;
        proofGapIds: z.ZodDefault<z.ZodArray<z.ZodString>>;
        proofGapReasonCodes: z.ZodDefault<z.ZodArray<z.ZodString>>;
        finalityStatus: z.ZodEnum<{
            unknown: "unknown";
            pending: "pending";
            final: "final";
            suspect: "suspect";
        }>;
        evidenceRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
        streamOffsets: z.ZodDefault<z.ZodArray<z.ZodObject<{
            streamId: z.ZodString;
            streamScope: z.ZodEnum<{
                tenant: "tenant";
                organization: "organization";
                run: "run";
                protected_surface_resource: "protected_surface_resource";
            }>;
            partitionKey: z.ZodString;
            offsetStart: z.ZodNumber;
            offsetEnd: z.ZodNumber;
            terminalEventDigest: z.ZodString;
        }, z.core.$strict>>>;
        receiptDigest: z.ZodString;
        auditChainDigest: z.ZodString;
        signaturePosture: z.ZodEnum<{
            unsigned: "unsigned";
            local_hmac: "local_hmac";
            external_signature: "external_signature";
            unverified: "unverified";
        }>;
        keyIdentityRef: z.ZodNullable<z.ZodString>;
        verificationPolicyRef: z.ZodNullable<z.ZodString>;
        exportFormat: z.ZodEnum<{
            json: "json";
            redacted_json: "redacted_json";
        }>;
        redactionProfileRef: z.ZodString;
        exportPurposeCode: z.ZodString;
        requestedByRef: z.ZodString;
        evidenceRetentionUntil: z.ZodNullable<z.ZodString>;
        exportedAt: z.ZodString;
        exportDigest: z.ZodString;
        delegationProvenance: z.ZodOptional<z.ZodObject<{
            a1ChainFingerprint: z.ZodString;
            chainDepth: z.ZodNumber;
            principalPkFingerprint: z.ZodString;
            terminalDelegatePkFingerprint: z.ZodString;
            verifyOutcome: z.ZodEnum<{
                valid: "valid";
                invalid: "invalid";
            }>;
            reasonCodes: z.ZodArray<z.ZodString>;
            evidenceBindingDigest: z.ZodString;
            a1VerifierVersion: z.ZodString;
            mutationAuthorityCreated: z.ZodLiteral<false>;
            greenlightCreated: z.ZodLiteral<false>;
        }, z.core.$strict>>;
    }, z.core.$strict>;
}, z.core.$strict>, z.ZodObject<{
    objectType: z.ZodLiteral<"raw_record_read_audit">;
    payload: z.ZodObject<{
        schemaVersion: z.ZodLiteral<"0.2.4">;
        tenantId: z.ZodString;
        organizationId: z.ZodString;
        createdAt: z.ZodString;
        rawRecordReadAuditId: z.ZodString;
        targetObjectType: z.ZodString;
        targetObjectId: z.ZodString;
        targetRecordDigest: z.ZodString;
        targetRecordSchemaVersion: z.ZodString;
        targetRecordCreatedAt: z.ZodString;
        callerIdentityRef: z.ZodString;
        callerSubjectDigest: z.ZodString;
        authProviderRef: z.ZodString;
        authSessionDigest: z.ZodNullable<z.ZodString>;
        serviceCredentialDigest: z.ZodNullable<z.ZodString>;
        projectId: z.ZodNullable<z.ZodString>;
        workspaceId: z.ZodNullable<z.ZodString>;
        custodyRoles: z.ZodArray<z.ZodString>;
        hostedRoles: z.ZodArray<z.ZodString>;
        hostedScopes: z.ZodArray<z.ZodString>;
        rawReadPurposeDigest: z.ZodString;
        purposeRedactionPolicyId: z.ZodLiteral<"hosted-raw-read-purpose-digest.v1">;
        rawReadExpiresAt: z.ZodString;
        routeId: z.ZodLiteral<"readProtocolRecord">;
        requestMethod: z.ZodLiteral<"GET">;
        requestedAt: z.ZodString;
        rawRecordReturned: z.ZodLiteral<true>;
        rawRecordPayloadIncludedInAudit: z.ZodLiteral<false>;
        authorityBoundary: z.ZodObject<{
            createsPolicyDecision: z.ZodLiteral<false>;
            createsGreenlight: z.ZodLiteral<false>;
            performsGatewayCheck: z.ZodLiteral<false>;
            createsMutationAuthority: z.ZodLiteral<false>;
            createsRawReadAuthority: z.ZodLiteral<false>;
            exposesRawRecordInAudit: z.ZodLiteral<false>;
        }, z.core.$strict>;
    }, z.core.$strict>;
}, z.core.$strict>, z.ZodObject<{
    objectType: z.ZodLiteral<"recovery_recommendation">;
    payload: z.ZodObject<{
        schemaVersion: z.ZodLiteral<"0.2.4">;
        tenantId: z.ZodString;
        organizationId: z.ZodString;
        createdAt: z.ZodString;
        recoveryRecommendationId: z.ZodString;
        sourceReceiptId: z.ZodString;
        sourceActionContractId: z.ZodString;
        sourcePolicyDecisionId: z.ZodString;
        sourceGreenlightId: z.ZodNullable<z.ZodString>;
        sourceGateAttemptId: z.ZodNullable<z.ZodString>;
        sourceMutationAttemptId: z.ZodNullable<z.ZodString>;
        sourceRefusalOrGapRef: z.ZodString;
        sourceFinalityStatus: z.ZodEnum<{
            unknown: "unknown";
            pending: "pending";
            final: "final";
            suspect: "suspect";
        }>;
        sourceGatewayCheckStatus: z.ZodNullable<z.ZodEnum<{
            proof_gap: "proof_gap";
            refused: "refused";
            passed: "passed";
        }>>;
        sourceMutationAttemptStatus: z.ZodEnum<{
            unknown: "unknown";
            failed: "failed";
            not_attempted: "not_attempted";
            submitted: "submitted";
            succeeded: "succeeded";
            downstream_refused: "downstream_refused";
        }>;
        sourceDownstreamExecutionStatus: z.ZodEnum<{
            unknown: "unknown";
            refused: "refused";
            failed: "failed";
            succeeded: "succeeded";
            pending: "pending";
            not_started: "not_started";
        }>;
        recommendedPath: z.ZodEnum<{
            narrower_action_contract_required: "narrower_action_contract_required";
            gateway_reconciliation_required: "gateway_reconciliation_required";
            human_review_required: "human_review_required";
            compensating_action_contract_required: "compensating_action_contract_required";
            halt_without_retry: "halt_without_retry";
        }>;
        allowedNextActionClasses: z.ZodDefault<z.ZodArray<z.ZodString>>;
        requiredNewEvidence: z.ZodDefault<z.ZodArray<z.ZodString>>;
        requiresHumanReview: z.ZodBoolean;
        safeRetryAvailable: z.ZodBoolean;
        scopeNarrowingRequired: z.ZodBoolean;
        policyUpdateCandidate: z.ZodBoolean;
        agentInstructionUpdateCandidate: z.ZodBoolean;
        principalId: z.ZodString;
        agentId: z.ZodString;
        runId: z.ZodString;
        gatewayId: z.ZodString;
        resourceRef: z.ZodString;
        actionClass: z.ZodString;
        failureReceiptRef: z.ZodString;
        proofGapIds: z.ZodDefault<z.ZodArray<z.ZodString>>;
        missingEvidenceRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
        reviewDecisionRef: z.ZodNullable<z.ZodString>;
        policyChangeRef: z.ZodNullable<z.ZodString>;
        sourceReceiptDigest: z.ZodString;
        sourceAuditChainDigest: z.ZodString;
        sourceStreamOffsets: z.ZodDefault<z.ZodArray<z.ZodObject<{
            streamId: z.ZodString;
            streamScope: z.ZodEnum<{
                tenant: "tenant";
                organization: "organization";
                run: "run";
                protected_surface_resource: "protected_surface_resource";
            }>;
            partitionKey: z.ZodString;
            offsetStart: z.ZodNumber;
            offsetEnd: z.ZodNumber;
            terminalEventDigest: z.ZodString;
        }, z.core.$strict>>>;
        reasonCode: z.ZodString;
        reasonSummary: z.ZodString;
        recommendedAt: z.ZodString;
        recoveryExpiresAt: z.ZodNullable<z.ZodString>;
        reviewDueAt: z.ZodNullable<z.ZodString>;
        retryNotBefore: z.ZodNullable<z.ZodString>;
        mustCreateNewActionContract: z.ZodLiteral<true>;
        mayReuseGreenlight: z.ZodLiteral<false>;
        mayMutateProtectedSurface: z.ZodLiteral<false>;
        recommendationStatus: z.ZodEnum<{
            open: "open";
            expired: "expired";
            superseded: "superseded";
        }>;
        statusChangedAt: z.ZodNullable<z.ZodString>;
        statusChangedByRef: z.ZodNullable<z.ZodString>;
        statusReasonCode: z.ZodNullable<z.ZodString>;
        statusReasonSummary: z.ZodNullable<z.ZodString>;
        supersededByActionContractId: z.ZodNullable<z.ZodString>;
        recommendationDigest: z.ZodString;
    }, z.core.$strict>;
}, z.core.$strict>, z.ZodObject<{
    objectType: z.ZodLiteral<"recovery_recommendation_status_transition">;
    payload: z.ZodObject<{
        schemaVersion: z.ZodLiteral<"0.2.4">;
        tenantId: z.ZodString;
        organizationId: z.ZodString;
        createdAt: z.ZodString;
        recoveryRecommendationStatusTransitionId: z.ZodString;
        recoveryRecommendationId: z.ZodString;
        sourceReceiptId: z.ZodString;
        sourceActionContractId: z.ZodString;
        previousStatus: z.ZodEnum<{
            open: "open";
            expired: "expired";
            superseded: "superseded";
        }>;
        nextStatus: z.ZodEnum<{
            expired: "expired";
            superseded: "superseded";
        }>;
        recommendationDigest: z.ZodString;
        reasonCode: z.ZodString;
        reasonSummary: z.ZodString;
        changedByRef: z.ZodString;
        changedAt: z.ZodString;
        supersededByActionContractId: z.ZodNullable<z.ZodString>;
        transitionDigest: z.ZodString;
    }, z.core.$strict>;
}, z.core.$strict>, z.ZodObject<{
    objectType: z.ZodLiteral<"contract_stream_event">;
    payload: z.ZodObject<{
        schemaVersion: z.ZodLiteral<"0.2.4">;
        tenantId: z.ZodString;
        organizationId: z.ZodString;
        createdAt: z.ZodString;
        streamEventId: z.ZodString;
        streamId: z.ZodString;
        streamScope: z.ZodEnum<{
            tenant: "tenant";
            organization: "organization";
            run: "run";
            protected_surface_resource: "protected_surface_resource";
        }>;
        offset: z.ZodNumber;
        partitionKey: z.ZodString;
        eventType: z.ZodEnum<{
            protected_path_posture_recorded: "protected_path_posture_recorded";
            review_required: "review_required";
            review_artifact_recorded: "review_artifact_recorded";
            review_decision_recorded: "review_decision_recorded";
            receipt_exported: "receipt_exported";
            recovery_recommended: "recovery_recommended";
            proof_gap_resolved: "proof_gap_resolved";
            gateway_checked: "gateway_checked";
            intent_compiled: "intent_compiled";
            runtime_execution_recorded: "runtime_execution_recorded";
            generated_execution_graph_recorded: "generated_execution_graph_recorded";
            install_setup_recorded: "install_setup_recorded";
            install_setup_refused: "install_setup_refused";
            gateway_credential_ref_registered: "gateway_credential_ref_registered";
            delegated_authority_ref_registered: "delegated_authority_ref_registered";
            delegated_authority_status_changed: "delegated_authority_status_changed";
            gateway_custody_proof_packet_recorded: "gateway_custody_proof_packet_recorded";
            credential_resolution_recorded: "credential_resolution_recorded";
            typed_action_commitment_recorded: "typed_action_commitment_recorded";
            idempotency_ledger_recorded: "idempotency_ledger_recorded";
            bypass_probe_recorded: "bypass_probe_recorded";
            tool_call_draft_recorded: "tool_call_draft_recorded";
            negotiation_session_recorded: "negotiation_session_recorded";
            negotiation_offer_recorded: "negotiation_offer_recorded";
            negotiation_decision_recorded: "negotiation_decision_recorded";
            linked_agreement_recorded: "linked_agreement_recorded";
            agreement_obligation_binding_recorded: "agreement_obligation_binding_recorded";
            agreement_status_transition_recorded: "agreement_status_transition_recorded";
            action_proposed: "action_proposed";
            policy_decision_recorded: "policy_decision_recorded";
            action_greenlit: "action_greenlit";
            action_refused: "action_refused";
            mutation_attempted: "mutation_attempted";
            protected_surface_operation_claimed: "protected_surface_operation_claimed";
            protected_surface_operation_released: "protected_surface_operation_released";
            surface_operation_reconciled: "surface_operation_reconciled";
            gateway_refused: "gateway_refused";
            breaker_decision_recorded: "breaker_decision_recorded";
            receipt_emitted: "receipt_emitted";
            authority_certificate_emitted: "authority_certificate_emitted";
            raw_evidence_read_audited: "raw_evidence_read_audited";
            recovery_status_changed: "recovery_status_changed";
            proof_gap_recorded: "proof_gap_recorded";
            isolation_changed: "isolation_changed";
        }>;
        eventTime: z.ZodString;
        producerRef: z.ZodString;
        objectRefs: z.ZodArray<z.ZodString>;
        previousEventDigest: z.ZodNullable<z.ZodString>;
        eventDigest: z.ZodString;
        payload: z.ZodRecord<z.ZodString, z.ZodType<import("../idempotency-ledger").JsonValue, unknown, z.core.$ZodTypeInternals<import("../idempotency-ledger").JsonValue, unknown>>>;
    }, z.core.$strict>;
}, z.core.$strict>], "objectType">;
export type ProtocolRecord = z.infer<typeof ProtocolRecordSchema>;