import { z } from "zod";
export declare const A2ANegotiationAdapterTranscriptAuthorityBoundarySchema: z.ZodObject<{
    transcriptCreatedAuthority: z.ZodLiteral<false>;
    admissionCreatedAuthority: z.ZodLiteral<false>;
    checkpointRecorded: z.ZodBoolean;
    adapterMoveCompiled: z.ZodBoolean;
    negotiationEvidenceCommitted: z.ZodBoolean;
    actionContractCreated: z.ZodLiteral<false>;
    policyEvaluated: z.ZodLiteral<false>;
    greenlightIssued: z.ZodLiteral<false>;
    gatewayCheckPerformed: z.ZodLiteral<false>;
    mutationAttempted: z.ZodLiteral<false>;
    receiptExported: z.ZodLiteral<false>;
    rawTranscriptIncluded: z.ZodLiteral<false>;
    rawOfferTermsIncluded: z.ZodLiteral<false>;
    credentialMaterialIncluded: z.ZodLiteral<false>;
    paymentMaterialIncluded: z.ZodLiteral<false>;
    signerMaterialIncluded: z.ZodLiteral<false>;
}, z.core.$strict>;
export type A2ANegotiationAdapterTranscriptAuthorityBoundary = z.infer<typeof A2ANegotiationAdapterTranscriptAuthorityBoundarySchema>;
export declare const A2ANegotiationAdapterTranscriptOutcomeSchema: z.ZodEnum<{
    stopped_before_normalization: "stopped_before_normalization";
    waiting_for_normalization: "waiting_for_normalization";
    waiting_for_checkpoint_record: "waiting_for_checkpoint_record";
    waiting_for_adapter_move: "waiting_for_adapter_move";
    waiting_for_adapter_apply: "waiting_for_adapter_apply";
    adapter_writes_applied: "adapter_writes_applied";
    adapter_refused: "adapter_refused";
    adapter_proof_gap: "adapter_proof_gap";
    adapter_write_failed: "adapter_write_failed";
    adapter_partial_commit_proof_gap: "adapter_partial_commit_proof_gap";
}>;
export type A2ANegotiationAdapterTranscriptOutcome = z.infer<typeof A2ANegotiationAdapterTranscriptOutcomeSchema>;
export declare const A2ANegotiationAdapterTranscriptNextStepSchema: z.ZodEnum<{
    call_normalize_a2a_ingress: "call_normalize_a2a_ingress";
    call_normalize_a2a_ingress_with_proof_gaps: "call_normalize_a2a_ingress_with_proof_gaps";
    stop_apply_back_pressure: "stop_apply_back_pressure";
    stop_refuse_raw_material: "stop_refuse_raw_material";
    record_a2a_ingress_checkpoint: "record_a2a_ingress_checkpoint";
    derive_game_state_and_compile_a2a_adapter_move: "derive_game_state_and_compile_a2a_adapter_move";
    apply_a2a_adapter_writes: "apply_a2a_adapter_writes";
    stop_move_refused: "stop_move_refused";
    stop_move_proof_gap: "stop_move_proof_gap";
    stop_apply_not_compiled: "stop_apply_not_compiled";
    stop_apply_proof_gap: "stop_apply_proof_gap";
    stop_apply_write_failed: "stop_apply_write_failed";
    stop_apply_partial_commit: "stop_apply_partial_commit";
    adapter_transcript_complete: "adapter_transcript_complete";
    derive_game_state_after_offer: "derive_game_state_after_offer";
    derive_game_state_after_counter: "derive_game_state_after_counter";
    link_agreement_from_bindable_resolution: "link_agreement_from_bindable_resolution";
    project_no_agreement_readback: "project_no_agreement_readback";
}>;
export type A2ANegotiationAdapterTranscriptNextStep = z.infer<typeof A2ANegotiationAdapterTranscriptNextStepSchema>;
export declare const A2ANegotiationAdapterTranscriptInputSchema: z.ZodObject<{
    schemaVersion: z.ZodLiteral<"0.2.4">;
    tenantId: z.ZodString;
    organizationId: z.ZodString;
    createdAt: z.ZodString;
    transcriptKind: z.ZodLiteral<"a2a_negotiation_adapter_transcript_input">;
    transcriptId: z.ZodString;
    admissionReadback: z.ZodObject<{
        schemaVersion: z.ZodLiteral<"0.2.4">;
        tenantId: z.ZodString;
        organizationId: z.ZodString;
        createdAt: z.ZodString;
        packetKind: z.ZodLiteral<"a2a_negotiation_ingress_admission_readback">;
        readbackId: z.ZodString;
        readbackSchemaVersion: z.ZodLiteral<"a2a.ingress.admission.readback.v1">;
        ingressAdapterId: z.ZodString;
        transportWindowRef: z.ZodString;
        pressure: z.ZodObject<{
            pressureOutcome: z.ZodEnum<{
                refuse_raw_material: "refuse_raw_material";
                within_budget: "within_budget";
                back_pressure_required: "back_pressure_required";
                proof_gap_required: "proof_gap_required";
            }>;
            observedEventCount: z.ZodNumber;
            uniqueCheckpointCount: z.ZodNumber;
            checkpointBudget: z.ZodNumber;
            checkpointCandidateCount: z.ZodNumber;
            deferredCheckpointRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
            refusedEventRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
        }, z.core.$strict>;
        admission: z.ZodObject<{
            admissionOutcome: z.ZodEnum<{
                refuse_raw_material: "refuse_raw_material";
                back_pressure_required: "back_pressure_required";
                ready_to_normalize: "ready_to_normalize";
                normalize_with_proof_gaps: "normalize_with_proof_gaps";
            }>;
            admissionReasonCode: z.ZodDefault<z.ZodNullable<z.ZodString>>;
            checkpointNormalizationReady: z.ZodBoolean;
            admittedCheckpointRef: z.ZodString;
            admittedReplayKeyDigest: z.ZodString;
            nextAdapterStep: z.ZodEnum<{
                call_normalize_a2a_ingress: "call_normalize_a2a_ingress";
                call_normalize_a2a_ingress_with_proof_gaps: "call_normalize_a2a_ingress_with_proof_gaps";
                stop_apply_back_pressure: "stop_apply_back_pressure";
                stop_refuse_raw_material: "stop_refuse_raw_material";
            }>;
        }, z.core.$strict>;
        evidenceRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
        proofGapRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
        refusedEvidenceRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
        nonClaims: z.ZodArray<z.ZodEnum<{
            mutation: "mutation";
            receipt_export: "receipt_export";
            gateway_check: "gateway_check";
            a2a_transport_operation: "a2a_transport_operation";
            counterparty_authentication: "counterparty_authentication";
            protocol_record_commit: "protocol_record_commit";
            action_contract_creation: "action_contract_creation";
            policy_evaluation: "policy_evaluation";
            greenlight_issuance: "greenlight_issuance";
        }>>;
        authorityBoundary: z.ZodObject<{
            admissionCreatedAuthority: z.ZodLiteral<false>;
            checkpointRecorded: z.ZodLiteral<false>;
            adapterMoveCompiled: z.ZodLiteral<false>;
            protocolRecordsCommitted: z.ZodLiteral<false>;
            actionContractCreated: z.ZodLiteral<false>;
            policyEvaluated: z.ZodLiteral<false>;
            greenlightIssued: z.ZodLiteral<false>;
            gatewayCheckPerformed: z.ZodLiteral<false>;
            mutationAttempted: z.ZodLiteral<false>;
            rawTranscriptIncluded: z.ZodLiteral<false>;
            rawMessagePartsIncluded: z.ZodLiteral<false>;
            rawArtifactPartsIncluded: z.ZodLiteral<false>;
            credentialMaterialIncluded: z.ZodLiteral<false>;
            paymentMaterialIncluded: z.ZodLiteral<false>;
            signerMaterialIncluded: z.ZodLiteral<false>;
        }, z.core.$strict>;
    }, z.core.$strict>;
    normalizationResult: z.ZodDefault<z.ZodNullable<z.ZodObject<{
        schemaVersion: z.ZodLiteral<"0.2.4">;
        tenantId: z.ZodString;
        organizationId: z.ZodString;
        createdAt: z.ZodString;
        resultKind: z.ZodLiteral<"a2a_negotiation_ingress_normalization_result">;
        normalizerId: z.ZodString;
        ingressAdapterId: z.ZodString;
        adapterId: z.ZodString;
        sourceProtocol: z.ZodLiteral<"a2a">;
        normalizationOutcome: z.ZodEnum<{
            refuse_raw_material: "refuse_raw_material";
            checkpoint_ready: "checkpoint_ready";
            checkpoint_proof_gap: "checkpoint_proof_gap";
            checkpoint_replay_refused: "checkpoint_replay_refused";
        }>;
        checkpoint: z.ZodDefault<z.ZodNullable<z.ZodObject<{
            schemaVersion: z.ZodLiteral<"0.2.4">;
            tenantId: z.ZodString;
            organizationId: z.ZodString;
            createdAt: z.ZodString;
            a2aIngressCheckpointId: z.ZodString;
            ingressCheckpointDigest: z.ZodString;
            ingressAdapterId: z.ZodString;
            negotiationSessionId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
            subjectResourceRef: z.ZodString;
            externalCorrelationRef: z.ZodString;
            protocolVersion: z.ZodString;
            protocolBinding: z.ZodEnum<{
                other: "other";
                json_rpc_http: "json_rpc_http";
                grpc: "grpc";
                sse: "sse";
            }>;
            protocolVersionPosture: z.ZodEnum<{
                accepted_current: "accepted_current";
                accepted_compatible: "accepted_compatible";
                downgrade_refused: "downgrade_refused";
                unsupported_proof_gap: "unsupported_proof_gap";
            }>;
            counterpartyAgentRef: z.ZodString;
            agentCard: z.ZodObject<{
                agentCardRef: z.ZodString;
                agentCardDigest: z.ZodDefault<z.ZodNullable<z.ZodString>>;
                agentCardUrlRef: z.ZodDefault<z.ZodNullable<z.ZodString>>;
                discoveryPosture: z.ZodEnum<{
                    proof_gap_recorded: "proof_gap_recorded";
                    well_known_pinned: "well_known_pinned";
                    authenticated_extended_card: "authenticated_extended_card";
                    imported_unpinned: "imported_unpinned";
                }>;
                protocolVersionDeclared: z.ZodDefault<z.ZodNullable<z.ZodString>>;
                capabilitiesDigest: z.ZodDefault<z.ZodNullable<z.ZodString>>;
                authSchemes: z.ZodDefault<z.ZodArray<z.ZodString>>;
                evidenceRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
                proofGapRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
            }, z.core.$strict>;
            task: z.ZodObject<{
                taskRef: z.ZodString;
                taskDigest: z.ZodDefault<z.ZodNullable<z.ZodString>>;
                taskState: z.ZodEnum<{
                    unknown: "unknown";
                    failed: "failed";
                    submitted: "submitted";
                    working: "working";
                    input_required: "input_required";
                    completed: "completed";
                    canceled: "canceled";
                }>;
                taskOwnershipPosture: z.ZodEnum<{
                    bound_to_counterparty: "bound_to_counterparty";
                    ambiguous_proof_gap: "ambiguous_proof_gap";
                    unverified_imported: "unverified_imported";
                }>;
                evidenceRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
                proofGapRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
            }, z.core.$strict>;
            messageRefs: z.ZodDefault<z.ZodArray<z.ZodObject<{
                messageRef: z.ZodString;
                messageDigest: z.ZodDefault<z.ZodNullable<z.ZodString>>;
                taskRef: z.ZodString;
                role: z.ZodEnum<{
                    unknown: "unknown";
                    agent: "agent";
                    user: "user";
                }>;
                messagePersistencePosture: z.ZodEnum<{
                    proof_gap_recorded: "proof_gap_recorded";
                    task_history_persisted: "task_history_persisted";
                    stream_observed_only: "stream_observed_only";
                }>;
                evidenceUse: z.ZodEnum<{
                    other: "other";
                    negotiation_context: "negotiation_context";
                    decision_context: "decision_context";
                    status_context: "status_context";
                }>;
                evidenceRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
                proofGapRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
            }, z.core.$strict>>>;
            artifactRefs: z.ZodDefault<z.ZodArray<z.ZodObject<{
                artifactRef: z.ZodString;
                artifactDigest: z.ZodDefault<z.ZodNullable<z.ZodString>>;
                taskRef: z.ZodString;
                artifactUse: z.ZodEnum<{
                    other: "other";
                    offer_terms_ref: "offer_terms_ref";
                    agreement_terms_ref: "agreement_terms_ref";
                    result_ref: "result_ref";
                }>;
                redactionDigest: z.ZodDefault<z.ZodNullable<z.ZodString>>;
                evidenceRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
                proofGapRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
            }, z.core.$strict>>>;
            authPosture: z.ZodEnum<{
                authenticated_request: "authenticated_request";
                declared_auth_only: "declared_auth_only";
                unauthenticated_proof_gap: "unauthenticated_proof_gap";
                auth_refused: "auth_refused";
            }>;
            replayKey: z.ZodString;
            replayKeyDigest: z.ZodString;
            replayPosture: z.ZodEnum<{
                unique_import_key: "unique_import_key";
                replay_proof_gap: "replay_proof_gap";
                duplicate_refused: "duplicate_refused";
            }>;
            ingressOutcome: z.ZodDefault<z.ZodEnum<{
                proof_gap: "proof_gap";
                replay_refused: "replay_refused";
                accepted_checkpoint: "accepted_checkpoint";
            }>>;
            downgradeEvidenceRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
            replayEvidenceRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
            normalizedEvidenceRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
            proofGapRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
            refusalReasonCodes: z.ZodDefault<z.ZodArray<z.ZodString>>;
            redaction: z.ZodObject<{
                rawTranscriptIncluded: z.ZodLiteral<false>;
                rawMessagePartsIncluded: z.ZodLiteral<false>;
                rawArtifactPartsIncluded: z.ZodLiteral<false>;
                credentialMaterialIncluded: z.ZodLiteral<false>;
                paymentMaterialIncluded: z.ZodLiteral<false>;
                signerMaterialIncluded: z.ZodLiteral<false>;
                redactionEvidenceRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
            }, z.core.$strict>;
            nonAuthority: z.ZodObject<{
                actionContractCreated: z.ZodLiteral<false>;
                authorityCreated: z.ZodLiteral<false>;
                policyEvaluated: z.ZodLiteral<false>;
                greenlightIssued: z.ZodLiteral<false>;
                gatewayCheckPerformed: z.ZodLiteral<false>;
                mutationAttempted: z.ZodLiteral<false>;
            }, z.core.$strict>;
        }, z.core.$strict>>>;
        adapterMoveRequestDraft: z.ZodDefault<z.ZodNullable<z.ZodObject<{
            requestKind: z.ZodLiteral<"a2a_negotiation_adapter_move_request_draft">;
            requestId: z.ZodString;
            adapterId: z.ZodString;
            sourceProtocol: z.ZodEnum<{
                runtime_evidence: "runtime_evidence";
                a2a: "a2a";
                acp: "acp";
                anp: "anp";
                ap2: "ap2";
                ucp: "ucp";
                x402: "x402";
                local_reference: "local_reference";
            }>;
            requiredCheckpointId: z.ZodString;
            checkpointRecordRequired: z.ZodLiteral<true>;
            gameStateRequired: z.ZodLiteral<true>;
            move: z.ZodEnum<{
                request_for_proposal: "request_for_proposal";
                offer: "offer";
                counter: "counter";
                accept: "accept";
                reject: "reject";
                withdraw: "withdraw";
                expire: "expire";
                dispute: "dispute";
            }>;
            resolverPolicy: z.ZodDefault<z.ZodNullable<z.ZodObject<{
                schemaVersion: z.ZodLiteral<"0.2.4">;
                tenantId: z.ZodString;
                organizationId: z.ZodString;
                createdAt: z.ZodString;
                negotiationResolverPolicyId: z.ZodString;
                resolverVersion: z.ZodString;
                resolverPolicyDigest: z.ZodString;
                resolverKind: z.ZodEnum<{
                    bilateral_protected_action_terms_v1: "bilateral_protected_action_terms_v1";
                    contract_net_protected_action_terms_v1: "contract_net_protected_action_terms_v1";
                }>;
                allowedMoves: z.ZodArray<z.ZodEnum<{
                    request_for_proposal: "request_for_proposal";
                    offer: "offer";
                    counter: "counter";
                    accept: "accept";
                    reject: "reject";
                    withdraw: "withdraw";
                    expire: "expire";
                    dispute: "dispute";
                }>>;
                requiredPartyProofPosture: z.ZodEnum<{
                    allow_self_attested_with_gap: "allow_self_attested_with_gap";
                    require_host_verified_refs: "require_host_verified_refs";
                }>;
                staleOfferPolicy: z.ZodLiteral<"reject_accepting_non_current_offer">;
                replayPolicy: z.ZodLiteral<"reject_duplicate_decision_and_binding">;
                unknownConstraintPolicy: z.ZodLiteral<"proof_gap">;
                authorityPosture: z.ZodLiteral<"non_authority_resolver">;
                evidenceRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
                proofGapRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
            }, z.core.$strict>>>;
            offerDraft: z.ZodDefault<z.ZodNullable<z.ZodObject<{
                negotiationOfferId: z.ZodString;
                offerVersionId: z.ZodString;
                offerSequence: z.ZodNumber;
                offeredByPartyId: 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<{
                        mcp: "mcp";
                        a2a: "a2a";
                        acp: "acp";
                        anp: "anp";
                        ap2: "ap2";
                        ucp: "ucp";
                        payment_protocol: "payment_protocol";
                        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>>>;
            decisionDraft: z.ZodDefault<z.ZodNullable<z.ZodObject<{
                negotiationDecisionId: z.ZodString;
                decidedByPartyId: z.ZodString;
                reasonCodes: z.ZodDefault<z.ZodArray<z.ZodString>>;
                evidenceRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
                proofGapRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
                decisionDigest: z.ZodString;
            }, z.core.$strict>>>;
            resolutionDraft: z.ZodDefault<z.ZodNullable<z.ZodObject<{
                negotiationResolutionId: z.ZodString;
                resolutionDigest: z.ZodString;
                evidenceRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
                proofGapRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
                unknownConstraintRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
            }, z.core.$strict>>>;
            candidateObligation: z.ZodDefault<z.ZodNullable<z.ZodObject<{
                obligationRef: z.ZodString;
                obligationDigest: z.ZodDefault<z.ZodNullable<z.ZodString>>;
                actionTypeId: z.ZodString;
                actionClass: z.ZodString;
                resourceRef: z.ZodString;
                counterpartyRef: z.ZodString;
                maxUses: z.ZodDefault<z.ZodLiteral<1>>;
                evidenceRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
            }, z.core.$strict>>>;
            evidenceRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
            proofGapRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
            authorityBoundary: z.ZodObject<{
                checkpointRecorded: z.ZodLiteral<false>;
                adapterMoveCompiled: z.ZodLiteral<false>;
                protocolRecordsCommitted: z.ZodLiteral<false>;
                actionContractCreated: z.ZodLiteral<false>;
                policyEvaluated: z.ZodLiteral<false>;
                greenlightIssued: z.ZodLiteral<false>;
                gatewayCheckPerformed: z.ZodLiteral<false>;
                mutationAttempted: z.ZodLiteral<false>;
            }, z.core.$strict>;
        }, z.core.$strict>>>;
        stopReasonCode: z.ZodDefault<z.ZodNullable<z.ZodString>>;
        evidenceRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
        proofGapRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
        refusedEvidenceRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
        authorityBoundary: z.ZodObject<{
            normalizerCreatedAuthority: z.ZodLiteral<false>;
            checkpointRecorded: z.ZodLiteral<false>;
            adapterMoveCompiled: z.ZodLiteral<false>;
            protocolRecordsCommitted: z.ZodLiteral<false>;
            actionContractCreated: z.ZodLiteral<false>;
            policyEvaluated: z.ZodLiteral<false>;
            greenlightIssued: z.ZodLiteral<false>;
            gatewayCheckPerformed: z.ZodLiteral<false>;
            mutationAttempted: z.ZodLiteral<false>;
            rawTranscriptIncluded: z.ZodLiteral<false>;
            rawMessagePartsIncluded: z.ZodLiteral<false>;
            rawArtifactPartsIncluded: z.ZodLiteral<false>;
            credentialMaterialIncluded: z.ZodLiteral<false>;
            paymentMaterialIncluded: z.ZodLiteral<false>;
            signerMaterialIncluded: z.ZodLiteral<false>;
        }, z.core.$strict>;
    }, z.core.$strict>>>;
    checkpointRecordRef: z.ZodDefault<z.ZodNullable<z.ZodString>>;
    moveResult: z.ZodDefault<z.ZodNullable<z.ZodObject<{
        schemaVersion: z.ZodLiteral<"0.2.4">;
        tenantId: z.ZodString;
        organizationId: z.ZodString;
        createdAt: z.ZodString;
        resultKind: z.ZodLiteral<"a2a_negotiation_adapter_move_result">;
        requestId: z.ZodString;
        adapterId: z.ZodString;
        sourceProtocol: z.ZodEnum<{
            runtime_evidence: "runtime_evidence";
            a2a: "a2a";
            acp: "acp";
            anp: "anp";
            ap2: "ap2";
            ucp: "ucp";
            x402: "x402";
            local_reference: "local_reference";
        }>;
        negotiationSessionId: z.ZodString;
        ingressCheckpointId: z.ZodString;
        requestedMove: z.ZodEnum<{
            request_for_proposal: "request_for_proposal";
            offer: "offer";
            counter: "counter";
            accept: "accept";
            reject: "reject";
            withdraw: "withdraw";
            expire: "expire";
            dispute: "dispute";
        }>;
        resultOutcome: z.ZodEnum<{
            proof_gap: "proof_gap";
            refuse: "refuse";
            compiled: "compiled";
        }>;
        plan: z.ZodDefault<z.ZodNullable<z.ZodObject<{
            schemaVersion: z.ZodLiteral<"0.2.4">;
            tenantId: z.ZodString;
            organizationId: z.ZodString;
            createdAt: z.ZodString;
            planKind: z.ZodLiteral<"a2a_negotiation_move_plan">;
            planId: z.ZodString;
            negotiationSessionId: z.ZodString;
            ingressCheckpointId: z.ZodString;
            requestedMove: z.ZodEnum<{
                request_for_proposal: "request_for_proposal";
                offer: "offer";
                counter: "counter";
                accept: "accept";
                reject: "reject";
                withdraw: "withdraw";
                expire: "expire";
                dispute: "dispute";
            }>;
            planOutcome: z.ZodEnum<{
                proof_gap: "proof_gap";
                refuse: "refuse";
                emit_offer: "emit_offer";
                emit_counter_offer_decision_and_resolution: "emit_counter_offer_decision_and_resolution";
                emit_decision_and_resolution: "emit_decision_and_resolution";
            }>;
            orderedTransitionCalls: z.ZodDefault<z.ZodArray<z.ZodEnum<{
                recordNegotiationOffer: "recordNegotiationOffer";
                recordNegotiationDecision: "recordNegotiationDecision";
                resolveNegotiation: "resolveNegotiation";
            }>>>;
            offer: z.ZodDefault<z.ZodNullable<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<{
                        mcp: "mcp";
                        a2a: "a2a";
                        acp: "acp";
                        anp: "anp";
                        ap2: "ap2";
                        ucp: "ucp";
                        payment_protocol: "payment_protocol";
                        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>>>;
            decision: z.ZodDefault<z.ZodNullable<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<{
                    counter: "counter";
                    accept: "accept";
                    reject: "reject";
                    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>>>;
            resolutionInput: z.ZodDefault<z.ZodNullable<z.ZodObject<{
                schemaVersion: z.ZodLiteral<"0.2.4">;
                tenantId: z.ZodString;
                organizationId: z.ZodString;
                createdAt: z.ZodString;
                negotiationResolutionId: z.ZodString;
                resolverPolicy: z.ZodObject<{
                    schemaVersion: z.ZodLiteral<"0.2.4">;
                    tenantId: z.ZodString;
                    organizationId: z.ZodString;
                    createdAt: z.ZodString;
                    negotiationResolverPolicyId: z.ZodString;
                    resolverVersion: z.ZodString;
                    resolverPolicyDigest: z.ZodString;
                    resolverKind: z.ZodEnum<{
                        bilateral_protected_action_terms_v1: "bilateral_protected_action_terms_v1";
                        contract_net_protected_action_terms_v1: "contract_net_protected_action_terms_v1";
                    }>;
                    allowedMoves: z.ZodArray<z.ZodEnum<{
                        request_for_proposal: "request_for_proposal";
                        offer: "offer";
                        counter: "counter";
                        accept: "accept";
                        reject: "reject";
                        withdraw: "withdraw";
                        expire: "expire";
                        dispute: "dispute";
                    }>>;
                    requiredPartyProofPosture: z.ZodEnum<{
                        allow_self_attested_with_gap: "allow_self_attested_with_gap";
                        require_host_verified_refs: "require_host_verified_refs";
                    }>;
                    staleOfferPolicy: z.ZodLiteral<"reject_accepting_non_current_offer">;
                    replayPolicy: z.ZodLiteral<"reject_duplicate_decision_and_binding">;
                    unknownConstraintPolicy: z.ZodLiteral<"proof_gap">;
                    authorityPosture: z.ZodLiteral<"non_authority_resolver">;
                    evidenceRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
                    proofGapRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
                }, z.core.$strict>;
                negotiationSessionId: z.ZodString;
                evaluatedMove: z.ZodEnum<{
                    request_for_proposal: "request_for_proposal";
                    offer: "offer";
                    counter: "counter";
                    accept: "accept";
                    reject: "reject";
                    withdraw: "withdraw";
                    expire: "expire";
                    dispute: "dispute";
                }>;
                decisionId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
                candidateObligation: z.ZodDefault<z.ZodNullable<z.ZodObject<{
                    obligationRef: z.ZodString;
                    obligationDigest: z.ZodDefault<z.ZodNullable<z.ZodString>>;
                    actionTypeId: z.ZodString;
                    actionClass: z.ZodString;
                    resourceRef: z.ZodString;
                    counterpartyRef: z.ZodString;
                    maxUses: z.ZodDefault<z.ZodLiteral<1>>;
                    evidenceRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
                }, z.core.$strict>>>;
                unknownConstraintRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
                evidenceRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
                proofGapRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
                resolutionDigest: z.ZodString;
            }, z.core.$strict>>>;
            stopReasonCode: z.ZodDefault<z.ZodNullable<z.ZodString>>;
            evidenceRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
            proofGapRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
            authorityBoundary: z.ZodObject<{
                protocolRecordsCommitted: z.ZodLiteral<false>;
                actionContractCreated: z.ZodLiteral<false>;
                authorityCreated: z.ZodLiteral<false>;
                policyEvaluated: z.ZodLiteral<false>;
                greenlightIssued: z.ZodLiteral<false>;
                gatewayCheckPerformed: z.ZodLiteral<false>;
                mutationAttempted: z.ZodLiteral<false>;
            }, z.core.$strict>;
        }, z.core.$strict>>>;
        orderedProtocolWrites: z.ZodDefault<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
            writeKind: z.ZodLiteral<"negotiation_offer">;
            transition: z.ZodLiteral<"recordNegotiationOffer">;
            objectId: z.ZodString;
            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<{
                        mcp: "mcp";
                        a2a: "a2a";
                        acp: "acp";
                        anp: "anp";
                        ap2: "ap2";
                        ucp: "ucp";
                        payment_protocol: "payment_protocol";
                        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<{
            writeKind: z.ZodLiteral<"negotiation_decision">;
            transition: z.ZodLiteral<"recordNegotiationDecision">;
            objectId: z.ZodString;
            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<{
                    counter: "counter";
                    accept: "accept";
                    reject: "reject";
                    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<{
            writeKind: z.ZodLiteral<"negotiation_resolution_input">;
            transition: z.ZodLiteral<"resolveNegotiation">;
            objectId: z.ZodString;
            payload: z.ZodObject<{
                schemaVersion: z.ZodLiteral<"0.2.4">;
                tenantId: z.ZodString;
                organizationId: z.ZodString;
                createdAt: z.ZodString;
                negotiationResolutionId: z.ZodString;
                resolverPolicy: z.ZodObject<{
                    schemaVersion: z.ZodLiteral<"0.2.4">;
                    tenantId: z.ZodString;
                    organizationId: z.ZodString;
                    createdAt: z.ZodString;
                    negotiationResolverPolicyId: z.ZodString;
                    resolverVersion: z.ZodString;
                    resolverPolicyDigest: z.ZodString;
                    resolverKind: z.ZodEnum<{
                        bilateral_protected_action_terms_v1: "bilateral_protected_action_terms_v1";
                        contract_net_protected_action_terms_v1: "contract_net_protected_action_terms_v1";
                    }>;
                    allowedMoves: z.ZodArray<z.ZodEnum<{
                        request_for_proposal: "request_for_proposal";
                        offer: "offer";
                        counter: "counter";
                        accept: "accept";
                        reject: "reject";
                        withdraw: "withdraw";
                        expire: "expire";
                        dispute: "dispute";
                    }>>;
                    requiredPartyProofPosture: z.ZodEnum<{
                        allow_self_attested_with_gap: "allow_self_attested_with_gap";
                        require_host_verified_refs: "require_host_verified_refs";
                    }>;
                    staleOfferPolicy: z.ZodLiteral<"reject_accepting_non_current_offer">;
                    replayPolicy: z.ZodLiteral<"reject_duplicate_decision_and_binding">;
                    unknownConstraintPolicy: z.ZodLiteral<"proof_gap">;
                    authorityPosture: z.ZodLiteral<"non_authority_resolver">;
                    evidenceRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
                    proofGapRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
                }, z.core.$strict>;
                negotiationSessionId: z.ZodString;
                evaluatedMove: z.ZodEnum<{
                    request_for_proposal: "request_for_proposal";
                    offer: "offer";
                    counter: "counter";
                    accept: "accept";
                    reject: "reject";
                    withdraw: "withdraw";
                    expire: "expire";
                    dispute: "dispute";
                }>;
                decisionId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
                candidateObligation: z.ZodDefault<z.ZodNullable<z.ZodObject<{
                    obligationRef: z.ZodString;
                    obligationDigest: z.ZodDefault<z.ZodNullable<z.ZodString>>;
                    actionTypeId: z.ZodString;
                    actionClass: z.ZodString;
                    resourceRef: z.ZodString;
                    counterpartyRef: z.ZodString;
                    maxUses: z.ZodDefault<z.ZodLiteral<1>>;
                    evidenceRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
                }, z.core.$strict>>>;
                unknownConstraintRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
                evidenceRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
                proofGapRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
                resolutionDigest: z.ZodString;
            }, z.core.$strict>;
        }, z.core.$strict>], "writeKind">>>;
        stopReasonCode: z.ZodDefault<z.ZodNullable<z.ZodString>>;
        evidenceRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
        proofGapRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
        authorityBoundary: z.ZodObject<{
            adapterRequestCreatedAuthority: z.ZodLiteral<false>;
            protocolRecordsCommitted: z.ZodLiteral<false>;
            actionContractCreated: z.ZodLiteral<false>;
            policyEvaluated: z.ZodLiteral<false>;
            greenlightIssued: z.ZodLiteral<false>;
            gatewayCheckPerformed: z.ZodLiteral<false>;
            mutationAttempted: z.ZodLiteral<false>;
            rawTranscriptIncluded: z.ZodLiteral<false>;
            credentialMaterialIncluded: z.ZodLiteral<false>;
            paymentMaterialIncluded: z.ZodLiteral<false>;
            signerMaterialIncluded: z.ZodLiteral<false>;
        }, z.core.$strict>;
    }, z.core.$strict>>>;
    applyResult: z.ZodDefault<z.ZodNullable<z.ZodObject<{
        schemaVersion: z.ZodLiteral<"0.2.4">;
        tenantId: z.ZodString;
        organizationId: z.ZodString;
        createdAt: z.ZodString;
        resultKind: z.ZodLiteral<"a2a_negotiation_adapter_apply_result">;
        applyId: z.ZodString;
        adapterId: z.ZodString;
        sourceProtocol: z.ZodEnum<{
            runtime_evidence: "runtime_evidence";
            a2a: "a2a";
            acp: "acp";
            anp: "anp";
            ap2: "ap2";
            ucp: "ucp";
            x402: "x402";
            local_reference: "local_reference";
        }>;
        negotiationSessionId: z.ZodString;
        ingressCheckpointId: z.ZodString;
        requestedMove: z.ZodEnum<{
            request_for_proposal: "request_for_proposal";
            offer: "offer";
            counter: "counter";
            accept: "accept";
            reject: "reject";
            withdraw: "withdraw";
            expire: "expire";
            dispute: "dispute";
        }>;
        applyOutcome: z.ZodEnum<{
            proof_gap: "proof_gap";
            applied: "applied";
            not_compiled: "not_compiled";
            write_failed: "write_failed";
            partial_commit_proof_gap: "partial_commit_proof_gap";
        }>;
        appliedWrites: z.ZodDefault<z.ZodArray<z.ZodObject<{
            writeKind: z.ZodEnum<{
                negotiation_offer: "negotiation_offer";
                negotiation_decision: "negotiation_decision";
                negotiation_resolution_input: "negotiation_resolution_input";
            }>;
            transition: z.ZodEnum<{
                recordNegotiationOffer: "recordNegotiationOffer";
                recordNegotiationDecision: "recordNegotiationDecision";
                resolveNegotiation: "resolveNegotiation";
            }>;
            objectId: z.ZodString;
            committedObjectRef: z.ZodString;
            commitState: z.ZodLiteral<"committed">;
        }, z.core.$strict>>>;
        failedWrite: z.ZodDefault<z.ZodNullable<z.ZodObject<{
            writeKind: z.ZodEnum<{
                negotiation_offer: "negotiation_offer";
                negotiation_decision: "negotiation_decision";
                negotiation_resolution_input: "negotiation_resolution_input";
            }>;
            transition: z.ZodEnum<{
                recordNegotiationOffer: "recordNegotiationOffer";
                recordNegotiationDecision: "recordNegotiationDecision";
                resolveNegotiation: "resolveNegotiation";
            }>;
            objectId: z.ZodString;
            failureReasonCode: z.ZodString;
            failureMessage: z.ZodString;
            commitState: z.ZodEnum<{
                unknown: "unknown";
                not_applicable: "not_applicable";
                not_started: "not_started";
                not_committed: "not_committed";
                committed: "committed";
            }>;
        }, z.core.$strict>>>;
        stopReasonCode: z.ZodDefault<z.ZodNullable<z.ZodString>>;
        evidenceRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
        proofGapRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
        authorityBoundary: z.ZodObject<{
            adapterApplyCreatedAuthority: z.ZodLiteral<false>;
            negotiationEvidenceCommitted: z.ZodBoolean;
            actionContractCreated: z.ZodLiteral<false>;
            policyEvaluated: z.ZodLiteral<false>;
            greenlightIssued: z.ZodLiteral<false>;
            gatewayCheckPerformed: z.ZodLiteral<false>;
            mutationAttempted: z.ZodLiteral<false>;
            rawTranscriptIncluded: z.ZodLiteral<false>;
            credentialMaterialIncluded: z.ZodLiteral<false>;
            paymentMaterialIncluded: z.ZodLiteral<false>;
            signerMaterialIncluded: z.ZodLiteral<false>;
        }, z.core.$strict>;
    }, z.core.$strict>>>;
    evidenceRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
    proofGapRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
    authorityBoundary: z.ZodObject<{
        transcriptCreatedAuthority: z.ZodLiteral<false>;
        admissionCreatedAuthority: z.ZodLiteral<false>;
        checkpointRecorded: z.ZodBoolean;
        adapterMoveCompiled: z.ZodBoolean;
        negotiationEvidenceCommitted: z.ZodBoolean;
        actionContractCreated: z.ZodLiteral<false>;
        policyEvaluated: z.ZodLiteral<false>;
        greenlightIssued: z.ZodLiteral<false>;
        gatewayCheckPerformed: z.ZodLiteral<false>;
        mutationAttempted: z.ZodLiteral<false>;
        receiptExported: z.ZodLiteral<false>;
        rawTranscriptIncluded: z.ZodLiteral<false>;
        rawOfferTermsIncluded: z.ZodLiteral<false>;
        credentialMaterialIncluded: z.ZodLiteral<false>;
        paymentMaterialIncluded: z.ZodLiteral<false>;
        signerMaterialIncluded: z.ZodLiteral<false>;
    }, z.core.$strict>;
}, z.core.$strict>;
export type A2ANegotiationAdapterTranscriptInput = z.infer<typeof A2ANegotiationAdapterTranscriptInputSchema>;
export declare const A2ANegotiationAdapterTranscriptPacketSchema: z.ZodObject<{
    schemaVersion: z.ZodLiteral<"0.2.4">;
    tenantId: z.ZodString;
    organizationId: z.ZodString;
    createdAt: z.ZodString;
    packetKind: z.ZodLiteral<"a2a_negotiation_adapter_transcript">;
    transcriptId: z.ZodString;
    transcriptSchemaVersion: z.ZodLiteral<"a2a.adapter.transcript.v1">;
    ingressAdapterId: z.ZodString;
    adapterId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
    transcriptOutcome: z.ZodEnum<{
        stopped_before_normalization: "stopped_before_normalization";
        waiting_for_normalization: "waiting_for_normalization";
        waiting_for_checkpoint_record: "waiting_for_checkpoint_record";
        waiting_for_adapter_move: "waiting_for_adapter_move";
        waiting_for_adapter_apply: "waiting_for_adapter_apply";
        adapter_writes_applied: "adapter_writes_applied";
        adapter_refused: "adapter_refused";
        adapter_proof_gap: "adapter_proof_gap";
        adapter_write_failed: "adapter_write_failed";
        adapter_partial_commit_proof_gap: "adapter_partial_commit_proof_gap";
    }>;
    nextAdapterStep: z.ZodEnum<{
        call_normalize_a2a_ingress: "call_normalize_a2a_ingress";
        call_normalize_a2a_ingress_with_proof_gaps: "call_normalize_a2a_ingress_with_proof_gaps";
        stop_apply_back_pressure: "stop_apply_back_pressure";
        stop_refuse_raw_material: "stop_refuse_raw_material";
        record_a2a_ingress_checkpoint: "record_a2a_ingress_checkpoint";
        derive_game_state_and_compile_a2a_adapter_move: "derive_game_state_and_compile_a2a_adapter_move";
        apply_a2a_adapter_writes: "apply_a2a_adapter_writes";
        stop_move_refused: "stop_move_refused";
        stop_move_proof_gap: "stop_move_proof_gap";
        stop_apply_not_compiled: "stop_apply_not_compiled";
        stop_apply_proof_gap: "stop_apply_proof_gap";
        stop_apply_write_failed: "stop_apply_write_failed";
        stop_apply_partial_commit: "stop_apply_partial_commit";
        adapter_transcript_complete: "adapter_transcript_complete";
        derive_game_state_after_offer: "derive_game_state_after_offer";
        derive_game_state_after_counter: "derive_game_state_after_counter";
        link_agreement_from_bindable_resolution: "link_agreement_from_bindable_resolution";
        project_no_agreement_readback: "project_no_agreement_readback";
    }>;
    admission: z.ZodObject<{
        admissionOutcome: z.ZodEnum<{
            refuse_raw_material: "refuse_raw_material";
            back_pressure_required: "back_pressure_required";
            ready_to_normalize: "ready_to_normalize";
            normalize_with_proof_gaps: "normalize_with_proof_gaps";
        }>;
        checkpointNormalizationReady: z.ZodBoolean;
        admissionReasonCode: z.ZodDefault<z.ZodNullable<z.ZodString>>;
        nextAdapterStep: z.ZodEnum<{
            call_normalize_a2a_ingress: "call_normalize_a2a_ingress";
            call_normalize_a2a_ingress_with_proof_gaps: "call_normalize_a2a_ingress_with_proof_gaps";
            stop_apply_back_pressure: "stop_apply_back_pressure";
            stop_refuse_raw_material: "stop_refuse_raw_material";
            record_a2a_ingress_checkpoint: "record_a2a_ingress_checkpoint";
            derive_game_state_and_compile_a2a_adapter_move: "derive_game_state_and_compile_a2a_adapter_move";
            apply_a2a_adapter_writes: "apply_a2a_adapter_writes";
            stop_move_refused: "stop_move_refused";
            stop_move_proof_gap: "stop_move_proof_gap";
            stop_apply_not_compiled: "stop_apply_not_compiled";
            stop_apply_proof_gap: "stop_apply_proof_gap";
            stop_apply_write_failed: "stop_apply_write_failed";
            stop_apply_partial_commit: "stop_apply_partial_commit";
            adapter_transcript_complete: "adapter_transcript_complete";
            derive_game_state_after_offer: "derive_game_state_after_offer";
            derive_game_state_after_counter: "derive_game_state_after_counter";
            link_agreement_from_bindable_resolution: "link_agreement_from_bindable_resolution";
            project_no_agreement_readback: "project_no_agreement_readback";
        }>;
    }, z.core.$strict>;
    normalization: z.ZodObject<{
        stageStatus: z.ZodEnum<{
            not_started: "not_started";
            checkpoint_ready: "checkpoint_ready";
            checkpoint_proof_gap: "checkpoint_proof_gap";
            checkpoint_replay_refused: "checkpoint_replay_refused";
            raw_material_refused: "raw_material_refused";
        }>;
        normalizationOutcome: z.ZodDefault<z.ZodNullable<z.ZodEnum<{
            refuse_raw_material: "refuse_raw_material";
            checkpoint_ready: "checkpoint_ready";
            checkpoint_proof_gap: "checkpoint_proof_gap";
            checkpoint_replay_refused: "checkpoint_replay_refused";
        }>>>;
        checkpointId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
        adapterMoveRequestDraftReady: z.ZodBoolean;
        stopReasonCode: z.ZodDefault<z.ZodNullable<z.ZodString>>;
    }, z.core.$strict>;
    checkpoint: z.ZodObject<{
        checkpointRecordRef: z.ZodDefault<z.ZodNullable<z.ZodString>>;
        checkpointRecorded: z.ZodBoolean;
        checkpointRecordRequiredBeforeMove: z.ZodBoolean;
    }, z.core.$strict>;
    adapterMove: z.ZodObject<{
        stageStatus: z.ZodEnum<{
            proof_gap: "proof_gap";
            refuse: "refuse";
            not_started: "not_started";
            compiled: "compiled";
        }>;
        requestedMove: z.ZodDefault<z.ZodNullable<z.ZodEnum<{
            request_for_proposal: "request_for_proposal";
            offer: "offer";
            counter: "counter";
            accept: "accept";
            reject: "reject";
            withdraw: "withdraw";
            expire: "expire";
            dispute: "dispute";
        }>>>;
        orderedProtocolWriteCount: z.ZodNumber;
        stopReasonCode: z.ZodDefault<z.ZodNullable<z.ZodString>>;
    }, z.core.$strict>;
    resolver: z.ZodObject<{
        resolverInputPrepared: z.ZodBoolean;
        resolverInputPosture: z.ZodEnum<{
            no_agreement: "no_agreement";
            bindable_obligation_candidate: "bindable_obligation_candidate";
            continue_negotiation: "continue_negotiation";
            not_prepared: "not_prepared";
            stopped_before_resolver: "stopped_before_resolver";
        }>;
        evaluatedMove: z.ZodDefault<z.ZodNullable<z.ZodEnum<{
            request_for_proposal: "request_for_proposal";
            offer: "offer";
            counter: "counter";
            accept: "accept";
            reject: "reject";
            withdraw: "withdraw";
            expire: "expire";
            dispute: "dispute";
        }>>>;
        resolverInputRef: z.ZodDefault<z.ZodNullable<z.ZodString>>;
        candidateObligationRef: z.ZodDefault<z.ZodNullable<z.ZodString>>;
        counterOfferVersionId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
    }, z.core.$strict>;
    apply: z.ZodObject<{
        stageStatus: z.ZodEnum<{
            proof_gap: "proof_gap";
            not_started: "not_started";
            applied: "applied";
            not_compiled: "not_compiled";
            write_failed: "write_failed";
            partial_commit_proof_gap: "partial_commit_proof_gap";
        }>;
        appliedWriteCount: z.ZodNumber;
        failedWriteKind: z.ZodDefault<z.ZodNullable<z.ZodString>>;
        stopReasonCode: z.ZodDefault<z.ZodNullable<z.ZodString>>;
    }, z.core.$strict>;
    evidenceRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
    proofGapRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
    refusedEvidenceRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
    nonClaims: z.ZodArray<z.ZodEnum<{
        mutation: "mutation";
        receipt_export: "receipt_export";
        gateway_check: "gateway_check";
        counterparty_authentication: "counterparty_authentication";
        action_contract_creation: "action_contract_creation";
        policy_evaluation: "policy_evaluation";
        greenlight_issuance: "greenlight_issuance";
        payment_authorization: "payment_authorization";
        signer_use: "signer_use";
        raw_transcript_custody: "raw_transcript_custody";
    }>>;
    authorityBoundary: z.ZodObject<{
        transcriptCreatedAuthority: z.ZodLiteral<false>;
        admissionCreatedAuthority: z.ZodLiteral<false>;
        checkpointRecorded: z.ZodBoolean;
        adapterMoveCompiled: z.ZodBoolean;
        negotiationEvidenceCommitted: z.ZodBoolean;
        actionContractCreated: z.ZodLiteral<false>;
        policyEvaluated: z.ZodLiteral<false>;
        greenlightIssued: z.ZodLiteral<false>;
        gatewayCheckPerformed: z.ZodLiteral<false>;
        mutationAttempted: z.ZodLiteral<false>;
        receiptExported: z.ZodLiteral<false>;
        rawTranscriptIncluded: z.ZodLiteral<false>;
        rawOfferTermsIncluded: z.ZodLiteral<false>;
        credentialMaterialIncluded: z.ZodLiteral<false>;
        paymentMaterialIncluded: z.ZodLiteral<false>;
        signerMaterialIncluded: z.ZodLiteral<false>;
    }, z.core.$strict>;
}, z.core.$strict>;
export type A2ANegotiationAdapterTranscriptPacket = z.infer<typeof A2ANegotiationAdapterTranscriptPacketSchema>;
export declare function projectA2ANegotiationAdapterTranscript(inputValue: A2ANegotiationAdapterTranscriptInput): A2ANegotiationAdapterTranscriptPacket;