@t402/core 2.3.1 → 2.5.0

package/dist/esm/mechanisms-dYCiYgko.d.mts

@@ -0,0 +1,1195 @@
+import { z } from 'zod';
+
+type PaymentRequirementsV1 = {
+    scheme: string;
+    network: Network;
+    maxAmountRequired: string;
+    resource: string;
+    description: string;
+    mimeType: string;
+    outputSchema: Record<string, unknown>;
+    payTo: string;
+    maxTimeoutSeconds: number;
+    asset: string;
+    extra: Record<string, unknown>;
+};
+type PaymentRequiredV1 = {
+    t402Version: 1;
+    error?: string;
+    accepts: PaymentRequirementsV1[];
+};
+type PaymentPayloadV1 = {
+    t402Version: 1;
+    scheme: string;
+    network: Network;
+    payload: Record<string, unknown>;
+};
+type VerifyRequestV1 = {
+    paymentPayload: PaymentPayloadV1;
+    paymentRequirements: PaymentRequirementsV1;
+};
+type SettleRequestV1 = {
+    paymentPayload: PaymentPayloadV1;
+    paymentRequirements: PaymentRequirementsV1;
+};
+type SettleResponseV1 = {
+    success: boolean;
+    errorReason?: string;
+    payer?: string;
+    transaction: string;
+    network: Network;
+};
+type SupportedResponseV1 = {
+    kinds: {
+        t402Version: number;
+        scheme: string;
+        network: Network;
+        extra?: Record<string, unknown>;
+    }[];
+};
+
+interface ResourceServerExtension {
+    key: string;
+    enrichDeclaration?: (declaration: unknown, transportContext: unknown) => unknown;
+}
+
+/**
+ * A2A (Agent-to-Agent) Transport Types
+ *
+ * Implements t402 payment flows over the Agent-to-Agent protocol
+ * using JSON-RPC messages and task-based state management.
+ *
+ * @see https://github.com/google-a2a/a2a-t402/v0.1
+ */
+
+/**
+ * Payment status values used in A2A metadata
+ */
+type A2APaymentStatus = "payment-required" | "payment-rejected" | "payment-submitted" | "payment-verified" | "payment-completed" | "payment-failed";
+/**
+ * A2A task states that correspond to payment states
+ */
+type A2ATaskState = "submitted" | "working" | "input-required" | "completed" | "canceled" | "failed" | "unknown";
+/**
+ * A2A message part - text content
+ */
+interface A2ATextPart {
+    kind: "text";
+    text: string;
+}
+/**
+ * A2A message part - file content
+ */
+interface A2AFilePart {
+    kind: "file";
+    file: {
+        name?: string;
+        mimeType?: string;
+        bytes?: string;
+        uri?: string;
+    };
+}
+/**
+ * A2A message part - data content
+ */
+interface A2ADataPart {
+    kind: "data";
+    data: Record<string, unknown>;
+}
+type A2AMessagePart = A2ATextPart | A2AFilePart | A2ADataPart;
+/**
+ * A2A payment metadata fields
+ */
+interface A2APaymentMetadata {
+    /** Current payment status */
+    "t402.payment.status"?: A2APaymentStatus;
+    /** Payment requirements (when status is payment-required) */
+    "t402.payment.required"?: PaymentRequired;
+    /** Payment payload (when status is payment-submitted) */
+    "t402.payment.payload"?: PaymentPayload;
+    /** Settlement receipts (when status is payment-completed or payment-failed) */
+    "t402.payment.receipts"?: SettleResponse[];
+    /** Error code (when status is payment-failed) */
+    "t402.payment.error"?: string;
+}
+/**
+ * A2A message with payment metadata
+ */
+interface A2AMessage {
+    kind: "message";
+    messageId?: string;
+    role: "user" | "agent";
+    parts: A2AMessagePart[];
+    metadata?: A2APaymentMetadata & Record<string, unknown>;
+}
+/**
+ * A2A artifact (output from completed task)
+ */
+interface A2AArtifact {
+    kind: string;
+    name?: string;
+    mimeType?: string;
+    data?: string;
+    uri?: string;
+    metadata?: Record<string, unknown>;
+}
+/**
+ * A2A task status
+ */
+interface A2ATaskStatus {
+    state: A2ATaskState;
+    message?: A2AMessage;
+    timestamp?: string;
+}
+/**
+ * A2A task
+ */
+interface A2ATask {
+    kind: "task";
+    id: string;
+    sessionId?: string;
+    status: A2ATaskStatus;
+    artifacts?: A2AArtifact[];
+    history?: A2AMessage[];
+    metadata?: Record<string, unknown>;
+}
+/**
+ * A2A JSON-RPC request
+ */
+interface A2ARequest<T = unknown> {
+    jsonrpc: "2.0";
+    method: string;
+    id: string | number;
+    params?: T;
+}
+/**
+ * A2A JSON-RPC response
+ */
+interface A2AResponse<T = unknown> {
+    jsonrpc: "2.0";
+    id: string | number;
+    result?: T;
+    error?: A2AError;
+}
+/**
+ * A2A JSON-RPC error
+ */
+interface A2AError {
+    code: number;
+    message: string;
+    data?: unknown;
+}
+/**
+ * A2A extension declaration
+ */
+interface A2AExtension {
+    uri: string;
+    description?: string;
+    required?: boolean;
+}
+/**
+ * A2A agent capabilities
+ */
+interface A2ACapabilities {
+    streaming?: boolean;
+    pushNotifications?: boolean;
+    stateTransitionHistory?: boolean;
+    extensions?: A2AExtension[];
+}
+/**
+ * A2A agent card (service advertisement)
+ */
+interface A2AAgentCard {
+    name: string;
+    description?: string;
+    url: string;
+    provider?: {
+        organization?: string;
+        url?: string;
+    };
+    version?: string;
+    documentationUrl?: string;
+    capabilities?: A2ACapabilities;
+    authentication?: {
+        schemes: string[];
+        credentials?: string;
+    };
+    defaultInputModes?: string[];
+    defaultOutputModes?: string[];
+    skills?: A2ASkill[];
+}
+/**
+ * A2A skill definition
+ */
+interface A2ASkill {
+    id: string;
+    name: string;
+    description?: string;
+    tags?: string[];
+    examples?: string[];
+    inputModes?: string[];
+    outputModes?: string[];
+}
+/**
+ * T402 A2A extension URI
+ */
+declare const T402_A2A_EXTENSION_URI = "https://github.com/google-a2a/a2a-t402/v0.1";
+/**
+ * HTTP header for A2A extension activation
+ */
+declare const A2A_EXTENSIONS_HEADER = "X-A2A-Extensions";
+/**
+ * Check if a task is in a payment-required state
+ *
+ * @param task - The A2A task to check
+ * @returns Whether the task requires payment
+ */
+declare function isPaymentRequired(task: A2ATask): boolean;
+/**
+ * Check if a task has completed payment
+ *
+ * @param task - The A2A task to check
+ * @returns Whether the task has completed payment
+ */
+declare function isPaymentCompleted(task: A2ATask): boolean;
+/**
+ * Check if a task has failed payment
+ *
+ * @param task - The A2A task to check
+ * @returns Whether the task has failed payment
+ */
+declare function isPaymentFailed(task: A2ATask): boolean;
+/**
+ * Extract payment requirements from a task
+ *
+ * @param task - The A2A task to extract requirements from
+ * @returns The payment requirements if the task requires payment
+ */
+declare function getPaymentRequired(task: A2ATask): PaymentRequired | undefined;
+/**
+ * Extract payment receipts from a task
+ *
+ * @param task - The A2A task to extract receipts from
+ * @returns The settlement receipts if available
+ */
+declare function getPaymentReceipts(task: A2ATask): SettleResponse[] | undefined;
+/**
+ * Create a payment-required message
+ *
+ * @param paymentRequired - The payment requirements
+ * @param text - Optional message text
+ * @returns An A2A message with payment-required metadata
+ */
+declare function createPaymentRequiredMessage(paymentRequired: PaymentRequired, text?: string): A2AMessage;
+/**
+ * Create a payment submission message
+ *
+ * @param paymentPayload - The payment payload to submit
+ * @param text - Optional message text
+ * @returns An A2A message with payment-submitted metadata
+ */
+declare function createPaymentSubmissionMessage(paymentPayload: PaymentPayload, text?: string): A2AMessage;
+/**
+ * Create a payment completed message
+ *
+ * @param receipts - The settlement receipts
+ * @param text - Optional message text
+ * @returns An A2A message with payment-completed metadata
+ */
+declare function createPaymentCompletedMessage(receipts: SettleResponse[], text?: string): A2AMessage;
+/**
+ * Create a payment failed message
+ *
+ * @param receipts - The settlement receipts
+ * @param errorCode - The error code
+ * @param text - Optional message text
+ * @returns An A2A message with payment-failed metadata
+ */
+declare function createPaymentFailedMessage(receipts: SettleResponse[], errorCode: string, text?: string): A2AMessage;
+/**
+ * Create a T402 extension declaration for agent cards
+ *
+ * @param required - Whether the extension is required
+ * @returns An A2A extension declaration
+ */
+declare function createT402Extension(required?: boolean): A2AExtension;
+
+/**
+ * Up-To Scheme Types
+ *
+ * The `upto` scheme authorizes transfer of up to a maximum amount,
+ * enabling usage-based billing where the final settlement amount
+ * is determined by actual usage.
+ *
+ * @example
+ * ```typescript
+ * // Client authorizes up to $1.00
+ * const requirements: UptoPaymentRequirements = {
+ *   scheme: 'upto',
+ *   network: 'eip155:8453',
+ *   maxAmount: '1000000',  // $1.00 in USDC
+ *   minAmount: '10000',    // $0.01 minimum
+ *   asset: '0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913',
+ *   payTo: '0x...',
+ *   maxTimeoutSeconds: 300,
+ *   extra: {
+ *     unit: 'token',
+ *     unitPrice: '100',
+ *   },
+ * };
+ *
+ * // Server settles for actual usage ($0.15)
+ * const settlement: UptoSettlement = {
+ *   settleAmount: '150000',
+ *   usageDetails: {
+ *     tokensGenerated: 1500,
+ *     unitPrice: '100',
+ *   },
+ * };
+ * ```
+ */
+
+/**
+ * Extended payment requirements for the upto scheme.
+ */
+interface UptoPaymentRequirements extends Omit<PaymentRequirements, "scheme" | "amount"> {
+    /** Scheme identifier - always 'upto' */
+    scheme: "upto";
+    /** Network identifier (CAIP-2 format) */
+    network: Network;
+    /** Maximum amount the client authorizes (in smallest denomination) */
+    maxAmount: string;
+    /** Minimum settlement amount (prevents dust payments) */
+    minAmount?: string;
+    /** Asset contract address or identifier */
+    asset: string;
+    /** Recipient address */
+    payTo: string;
+    /** Maximum time in seconds before payment expires */
+    maxTimeoutSeconds: number;
+    /** Additional scheme-specific data */
+    extra: UptoExtra;
+}
+/**
+ * Extra fields specific to the upto scheme.
+ */
+interface UptoExtra extends Record<string, unknown> {
+    /** Billing unit (e.g., 'token', 'request', 'second', 'byte') */
+    unit?: string;
+    /** Price per unit in smallest denomination */
+    unitPrice?: string;
+    /** EIP-712 domain name (for EVM) */
+    name?: string;
+    /** EIP-712 domain version (for EVM) */
+    version?: string;
+    /** Router contract address (for EVM) */
+    routerAddress?: string;
+}
+/**
+ * Base payload structure for upto scheme.
+ */
+interface UptoPayloadBase {
+    /** Unique nonce to prevent replay attacks */
+    nonce: string;
+}
+/**
+ * EVM-specific upto payload using EIP-2612 Permit.
+ */
+interface UptoEvmPayload extends UptoPayloadBase {
+    /** EIP-2612 permit signature components */
+    signature: {
+        v: number;
+        r: `0x${string}`;
+        s: `0x${string}`;
+    };
+    /** Permit authorization parameters */
+    authorization: {
+        /** Token owner address */
+        owner: `0x${string}`;
+        /** Spender address (router contract) */
+        spender: `0x${string}`;
+        /** Maximum authorized value */
+        value: string;
+        /** Permit deadline (unix timestamp) */
+        deadline: string;
+        /** Permit nonce (from token contract) */
+        nonce: number;
+    };
+}
+/**
+ * Alternative EVM payload with combined signature.
+ */
+interface UptoEvmPayloadCompact extends UptoPayloadBase {
+    /** Combined EIP-2612 permit signature */
+    signature: `0x${string}`;
+    /** Permit authorization parameters */
+    authorization: {
+        owner: `0x${string}`;
+        spender: `0x${string}`;
+        value: string;
+        deadline: string;
+        nonce: number;
+    };
+}
+/**
+ * Settlement request for upto scheme.
+ */
+interface UptoSettlement {
+    /** Actual amount to settle (must be <= maxAmount) */
+    settleAmount: string;
+    /** Optional usage details for auditing */
+    usageDetails?: UptoUsageDetails;
+}
+/**
+ * Usage details for settlement auditing.
+ */
+interface UptoUsageDetails {
+    /** Number of units consumed */
+    unitsConsumed?: number;
+    /** Price per unit used */
+    unitPrice?: string;
+    /** Type of unit */
+    unitType?: string;
+    /** Start timestamp of usage period */
+    startTime?: number;
+    /** End timestamp of usage period */
+    endTime?: number;
+    /** Additional metadata */
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Settlement response for upto scheme.
+ */
+interface UptoSettlementResponse {
+    /** Whether settlement was successful */
+    success: boolean;
+    /** Transaction hash (if on-chain) */
+    transactionHash?: string;
+    /** Actual amount settled */
+    settledAmount: string;
+    /** Maximum amount that was authorized */
+    maxAmount: string;
+    /** Block number (if on-chain) */
+    blockNumber?: number;
+    /** Gas used (if on-chain) */
+    gasUsed?: string;
+    /** Error message if failed */
+    error?: string;
+}
+/**
+ * Validation result for upto payment.
+ */
+interface UptoValidationResult {
+    /** Whether the payment is valid */
+    isValid: boolean;
+    /** Reason if invalid */
+    invalidReason?: string;
+    /** Validated maximum amount */
+    validatedMaxAmount?: string;
+    /** Payer address */
+    payer?: string;
+    /** Expiration timestamp */
+    expiresAt?: number;
+}
+/**
+ * Type guard for UptoPaymentRequirements.
+ *
+ * @param requirements - The value to check
+ * @returns True if the value is UptoPaymentRequirements
+ */
+declare function isUptoPaymentRequirements(requirements: unknown): requirements is UptoPaymentRequirements;
+/**
+ * Type guard for UptoEvmPayload.
+ *
+ * @param payload - The value to check
+ * @returns True if the value is UptoEvmPayload
+ */
+declare function isUptoEvmPayload(payload: unknown): payload is UptoEvmPayload;
+/**
+ * Constants for upto scheme.
+ */
+declare const UPTO_SCHEME: "upto";
+declare const UPTO_DEFAULTS: {
+    /** Default minimum settlement amount (prevents dust) */
+    readonly MIN_AMOUNT: "1000";
+    /** Default maximum timeout in seconds (5 minutes) */
+    readonly MAX_TIMEOUT_SECONDS: 300;
+    /** Supported billing units */
+    readonly UNITS: readonly ["token", "request", "second", "minute", "byte", "kb", "mb"];
+};
+type UptoUnit = (typeof UPTO_DEFAULTS.UNITS)[number];
+
+/**
+ * Standardized T402 error codes returned by the facilitator API.
+ * Error codes follow the format T402-XYYY where X is the category (1-8)
+ * and YYY is the specific error within that category.
+ */
+declare const ERR_INVALID_REQUEST: "T402-1001";
+declare const ERR_MISSING_PAYLOAD: "T402-1002";
+declare const ERR_MISSING_REQUIREMENTS: "T402-1003";
+declare const ERR_INVALID_PAYLOAD: "T402-1004";
+declare const ERR_INVALID_REQUIREMENTS: "T402-1005";
+declare const ERR_INVALID_SIGNATURE: "T402-1006";
+declare const ERR_INVALID_NETWORK: "T402-1007";
+declare const ERR_INVALID_SCHEME: "T402-1008";
+declare const ERR_INVALID_AMOUNT: "T402-1009";
+declare const ERR_INVALID_ADDRESS: "T402-1010";
+declare const ERR_EXPIRED_PAYMENT: "T402-1011";
+declare const ERR_INVALID_NONCE: "T402-1012";
+declare const ERR_INSUFFICIENT_AMOUNT: "T402-1013";
+declare const ERR_INVALID_IDEMPOTENCY_KEY: "T402-1014";
+declare const ERR_SIGNATURE_EXPIRED: "T402-1015";
+declare const ERR_INTERNAL: "T402-2001";
+declare const ERR_DATABASE_UNAVAILABLE: "T402-2002";
+declare const ERR_CACHE_UNAVAILABLE: "T402-2003";
+declare const ERR_RPC_UNAVAILABLE: "T402-2004";
+declare const ERR_RATE_LIMITED: "T402-2005";
+declare const ERR_SERVICE_UNAVAILABLE: "T402-2006";
+declare const ERR_VERIFICATION_FAILED: "T402-3001";
+declare const ERR_SETTLEMENT_FAILED: "T402-3002";
+declare const ERR_INSUFFICIENT_BALANCE: "T402-3003";
+declare const ERR_ALLOWANCE_INSUFFICIENT: "T402-3004";
+declare const ERR_PAYMENT_MISMATCH: "T402-3005";
+declare const ERR_DUPLICATE_PAYMENT: "T402-3006";
+declare const ERR_SETTLEMENT_PENDING: "T402-3007";
+declare const ERR_SETTLEMENT_TIMEOUT: "T402-3008";
+declare const ERR_NONCE_REPLAY: "T402-3009";
+declare const ERR_IDEMPOTENCY_CONFLICT: "T402-3010";
+declare const ERR_IDEMPOTENCY_UNAVAILABLE: "T402-3011";
+declare const ERR_PREVIOUS_REQUEST_FAILED: "T402-3012";
+declare const ERR_REQUEST_IN_PROGRESS: "T402-3013";
+declare const ERR_CHAIN_UNAVAILABLE: "T402-4001";
+declare const ERR_TRANSACTION_FAILED: "T402-4002";
+declare const ERR_TRANSACTION_REVERTED: "T402-4003";
+declare const ERR_GAS_ESTIMATION_FAILED: "T402-4004";
+declare const ERR_NONCE_CONFLICT: "T402-4005";
+declare const ERR_CHAIN_CONGESTED: "T402-4006";
+declare const ERR_CONTRACT_ERROR: "T402-4007";
+declare const ERR_BRIDGE_UNAVAILABLE: "T402-5001";
+declare const ERR_BRIDGE_QUOTE_FAILED: "T402-5002";
+declare const ERR_BRIDGE_TRANSFER_FAILED: "T402-5003";
+declare const ERR_BRIDGE_TIMEOUT: "T402-5004";
+declare const ERR_UNSUPPORTED_ROUTE: "T402-5005";
+declare const ERR_STREAM_NOT_FOUND: "T402-6001";
+declare const ERR_STREAM_ALREADY_CLOSED: "T402-6002";
+declare const ERR_STREAM_ALREADY_PAUSED: "T402-6003";
+declare const ERR_STREAM_NOT_PAUSED: "T402-6004";
+declare const ERR_STREAM_AMOUNT_EXCEEDED: "T402-6005";
+declare const ERR_STREAM_EXPIRED: "T402-6006";
+declare const ERR_STREAM_INVALID_STATE: "T402-6007";
+declare const ERR_STREAM_RATE_LIMITED: "T402-6008";
+declare const ERR_INTENT_NOT_FOUND: "T402-7001";
+declare const ERR_INTENT_ALREADY_EXECUTED: "T402-7002";
+declare const ERR_INTENT_CANCELLED: "T402-7003";
+declare const ERR_INTENT_EXPIRED: "T402-7004";
+declare const ERR_NO_ROUTES_AVAILABLE: "T402-7005";
+declare const ERR_ROUTE_EXPIRED: "T402-7006";
+declare const ERR_ROUTE_NOT_SELECTED: "T402-7007";
+declare const ERR_INTENT_INVALID_STATE: "T402-7008";
+declare const ERR_RESOURCE_NOT_FOUND: "T402-8001";
+declare const ERR_RESOURCE_ALREADY_EXISTS: "T402-8002";
+declare const ERR_INVALID_PARAMETERS: "T402-8003";
+declare const ERR_NOT_AUTHORIZED: "T402-8004";
+/** Union type of all T402 error codes */
+type ErrorCode = typeof ERR_INVALID_REQUEST | typeof ERR_MISSING_PAYLOAD | typeof ERR_MISSING_REQUIREMENTS | typeof ERR_INVALID_PAYLOAD | typeof ERR_INVALID_REQUIREMENTS | typeof ERR_INVALID_SIGNATURE | typeof ERR_INVALID_NETWORK | typeof ERR_INVALID_SCHEME | typeof ERR_INVALID_AMOUNT | typeof ERR_INVALID_ADDRESS | typeof ERR_EXPIRED_PAYMENT | typeof ERR_INVALID_NONCE | typeof ERR_INSUFFICIENT_AMOUNT | typeof ERR_INVALID_IDEMPOTENCY_KEY | typeof ERR_SIGNATURE_EXPIRED | typeof ERR_INTERNAL | typeof ERR_DATABASE_UNAVAILABLE | typeof ERR_CACHE_UNAVAILABLE | typeof ERR_RPC_UNAVAILABLE | typeof ERR_RATE_LIMITED | typeof ERR_SERVICE_UNAVAILABLE | typeof ERR_VERIFICATION_FAILED | typeof ERR_SETTLEMENT_FAILED | typeof ERR_INSUFFICIENT_BALANCE | typeof ERR_ALLOWANCE_INSUFFICIENT | typeof ERR_PAYMENT_MISMATCH | typeof ERR_DUPLICATE_PAYMENT | typeof ERR_SETTLEMENT_PENDING | typeof ERR_SETTLEMENT_TIMEOUT | typeof ERR_NONCE_REPLAY | typeof ERR_IDEMPOTENCY_CONFLICT | typeof ERR_IDEMPOTENCY_UNAVAILABLE | typeof ERR_PREVIOUS_REQUEST_FAILED | typeof ERR_REQUEST_IN_PROGRESS | typeof ERR_CHAIN_UNAVAILABLE | typeof ERR_TRANSACTION_FAILED | typeof ERR_TRANSACTION_REVERTED | typeof ERR_GAS_ESTIMATION_FAILED | typeof ERR_NONCE_CONFLICT | typeof ERR_CHAIN_CONGESTED | typeof ERR_CONTRACT_ERROR | typeof ERR_BRIDGE_UNAVAILABLE | typeof ERR_BRIDGE_QUOTE_FAILED | typeof ERR_BRIDGE_TRANSFER_FAILED | typeof ERR_BRIDGE_TIMEOUT | typeof ERR_UNSUPPORTED_ROUTE | typeof ERR_STREAM_NOT_FOUND | typeof ERR_STREAM_ALREADY_CLOSED | typeof ERR_STREAM_ALREADY_PAUSED | typeof ERR_STREAM_NOT_PAUSED | typeof ERR_STREAM_AMOUNT_EXCEEDED | typeof ERR_STREAM_EXPIRED | typeof ERR_STREAM_INVALID_STATE | typeof ERR_STREAM_RATE_LIMITED | typeof ERR_INTENT_NOT_FOUND | typeof ERR_INTENT_ALREADY_EXECUTED | typeof ERR_INTENT_CANCELLED | typeof ERR_INTENT_EXPIRED | typeof ERR_NO_ROUTES_AVAILABLE | typeof ERR_ROUTE_EXPIRED | typeof ERR_ROUTE_NOT_SELECTED | typeof ERR_INTENT_INVALID_STATE | typeof ERR_RESOURCE_NOT_FOUND | typeof ERR_RESOURCE_ALREADY_EXISTS | typeof ERR_INVALID_PARAMETERS | typeof ERR_NOT_AUTHORIZED;
+/** Structured error response from the facilitator API */
+interface APIError {
+    code: ErrorCode;
+    message: string;
+    details?: string;
+    retry?: boolean;
+}
+/**
+ * Returns the HTTP status code for a given error code
+ *
+ * @param code - The T402 error code
+ * @returns The corresponding HTTP status code
+ */
+declare function httpStatusForCode(code: ErrorCode): number;
+/**
+ * Returns true if the error code is a client error (T402-1xxx)
+ *
+ * @param code - The T402 error code
+ * @returns Whether the error is a client error
+ */
+declare function isClientError(code: ErrorCode): boolean;
+/**
+ * Returns true if the error code is a server error (T402-2xxx)
+ *
+ * @param code - The T402 error code
+ * @returns Whether the error is a server error
+ */
+declare function isServerError(code: ErrorCode): boolean;
+/**
+ * Returns true if the error code is a facilitator error (T402-3xxx)
+ *
+ * @param code - The T402 error code
+ * @returns Whether the error is a facilitator error
+ */
+declare function isFacilitatorError(code: ErrorCode): boolean;
+/**
+ * Returns true if the error code is a chain error (T402-4xxx)
+ *
+ * @param code - The T402 error code
+ * @returns Whether the error is a chain error
+ */
+declare function isChainError(code: ErrorCode): boolean;
+/**
+ * Returns true if the error code is a bridge error (T402-5xxx)
+ *
+ * @param code - The T402 error code
+ * @returns Whether the error is a bridge error
+ */
+declare function isBridgeError(code: ErrorCode): boolean;
+
+/**
+ * Zod schemas for T402 protocol types.
+ * Used for runtime validation of incoming data.
+ */
+declare const NetworkSchema: z.ZodString;
+declare const ResourceInfoSchema: z.ZodObject<{
+    url: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    mimeType: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    url: string;
+    description?: string | undefined;
+    mimeType?: string | undefined;
+}, {
+    url: string;
+    description?: string | undefined;
+    mimeType?: string | undefined;
+}>;
+declare const PaymentRequirementsSchema: z.ZodObject<{
+    scheme: z.ZodString;
+    network: z.ZodString;
+    asset: z.ZodString;
+    amount: z.ZodString;
+    payTo: z.ZodString;
+    maxTimeoutSeconds: z.ZodNumber;
+    extra: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, "strip", z.ZodTypeAny, {
+    scheme: string;
+    amount: string;
+    network: string;
+    asset: string;
+    payTo: string;
+    maxTimeoutSeconds: number;
+    extra: Record<string, unknown>;
+}, {
+    scheme: string;
+    amount: string;
+    network: string;
+    asset: string;
+    payTo: string;
+    maxTimeoutSeconds: number;
+    extra: Record<string, unknown>;
+}>;
+declare const PaymentRequiredSchema: z.ZodObject<{
+    t402Version: z.ZodLiteral<2>;
+    error: z.ZodOptional<z.ZodString>;
+    resource: z.ZodObject<{
+        url: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        mimeType: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        url: string;
+        description?: string | undefined;
+        mimeType?: string | undefined;
+    }, {
+        url: string;
+        description?: string | undefined;
+        mimeType?: string | undefined;
+    }>;
+    accepts: z.ZodArray<z.ZodObject<{
+        scheme: z.ZodString;
+        network: z.ZodString;
+        asset: z.ZodString;
+        amount: z.ZodString;
+        payTo: z.ZodString;
+        maxTimeoutSeconds: z.ZodNumber;
+        extra: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    }, "strip", z.ZodTypeAny, {
+        scheme: string;
+        amount: string;
+        network: string;
+        asset: string;
+        payTo: string;
+        maxTimeoutSeconds: number;
+        extra: Record<string, unknown>;
+    }, {
+        scheme: string;
+        amount: string;
+        network: string;
+        asset: string;
+        payTo: string;
+        maxTimeoutSeconds: number;
+        extra: Record<string, unknown>;
+    }>, "many">;
+    extensions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "strip", z.ZodTypeAny, {
+    t402Version: 2;
+    resource: {
+        url: string;
+        description?: string | undefined;
+        mimeType?: string | undefined;
+    };
+    accepts: {
+        scheme: string;
+        amount: string;
+        network: string;
+        asset: string;
+        payTo: string;
+        maxTimeoutSeconds: number;
+        extra: Record<string, unknown>;
+    }[];
+    error?: string | undefined;
+    extensions?: Record<string, unknown> | undefined;
+}, {
+    t402Version: 2;
+    resource: {
+        url: string;
+        description?: string | undefined;
+        mimeType?: string | undefined;
+    };
+    accepts: {
+        scheme: string;
+        amount: string;
+        network: string;
+        asset: string;
+        payTo: string;
+        maxTimeoutSeconds: number;
+        extra: Record<string, unknown>;
+    }[];
+    error?: string | undefined;
+    extensions?: Record<string, unknown> | undefined;
+}>;
+declare const PaymentPayloadSchema: z.ZodObject<{
+    t402Version: z.ZodLiteral<2>;
+    resource: z.ZodOptional<z.ZodObject<{
+        url: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        mimeType: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        url: string;
+        description?: string | undefined;
+        mimeType?: string | undefined;
+    }, {
+        url: string;
+        description?: string | undefined;
+        mimeType?: string | undefined;
+    }>>;
+    accepted: z.ZodObject<{
+        scheme: z.ZodString;
+        network: z.ZodString;
+        asset: z.ZodString;
+        amount: z.ZodString;
+        payTo: z.ZodString;
+        maxTimeoutSeconds: z.ZodNumber;
+        extra: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    }, "strip", z.ZodTypeAny, {
+        scheme: string;
+        amount: string;
+        network: string;
+        asset: string;
+        payTo: string;
+        maxTimeoutSeconds: number;
+        extra: Record<string, unknown>;
+    }, {
+        scheme: string;
+        amount: string;
+        network: string;
+        asset: string;
+        payTo: string;
+        maxTimeoutSeconds: number;
+        extra: Record<string, unknown>;
+    }>;
+    payload: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    extensions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "strip", z.ZodTypeAny, {
+    t402Version: 2;
+    accepted: {
+        scheme: string;
+        amount: string;
+        network: string;
+        asset: string;
+        payTo: string;
+        maxTimeoutSeconds: number;
+        extra: Record<string, unknown>;
+    };
+    payload: Record<string, unknown>;
+    resource?: {
+        url: string;
+        description?: string | undefined;
+        mimeType?: string | undefined;
+    } | undefined;
+    extensions?: Record<string, unknown> | undefined;
+}, {
+    t402Version: 2;
+    accepted: {
+        scheme: string;
+        amount: string;
+        network: string;
+        asset: string;
+        payTo: string;
+        maxTimeoutSeconds: number;
+        extra: Record<string, unknown>;
+    };
+    payload: Record<string, unknown>;
+    resource?: {
+        url: string;
+        description?: string | undefined;
+        mimeType?: string | undefined;
+    } | undefined;
+    extensions?: Record<string, unknown> | undefined;
+}>;
+declare const VerifyResponseSchema: z.ZodObject<{
+    isValid: z.ZodBoolean;
+    invalidReason: z.ZodOptional<z.ZodString>;
+    payer: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    isValid: boolean;
+    invalidReason?: string | undefined;
+    payer?: string | undefined;
+}, {
+    isValid: boolean;
+    invalidReason?: string | undefined;
+    payer?: string | undefined;
+}>;
+declare const SettleResponseSchema: z.ZodObject<{
+    success: z.ZodBoolean;
+    transaction: z.ZodString;
+    network: z.ZodString;
+    errorReason: z.ZodOptional<z.ZodString>;
+    payer: z.ZodOptional<z.ZodString>;
+    confirmations: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    network: string;
+    success: boolean;
+    transaction: string;
+    payer?: string | undefined;
+    errorReason?: string | undefined;
+    confirmations?: string | undefined;
+}, {
+    network: string;
+    success: boolean;
+    transaction: string;
+    payer?: string | undefined;
+    errorReason?: string | undefined;
+    confirmations?: string | undefined;
+}>;
+declare const PaymentRequirementsV1Schema: z.ZodObject<{
+    scheme: z.ZodString;
+    network: z.ZodString;
+    asset: z.ZodString;
+    amount: z.ZodString;
+    payTo: z.ZodString;
+    maxTimeoutSeconds: z.ZodNumber;
+    extra: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "strip", z.ZodTypeAny, {
+    scheme: string;
+    amount: string;
+    network: string;
+    asset: string;
+    payTo: string;
+    maxTimeoutSeconds: number;
+    extra?: Record<string, unknown> | undefined;
+}, {
+    scheme: string;
+    amount: string;
+    network: string;
+    asset: string;
+    payTo: string;
+    maxTimeoutSeconds: number;
+    extra?: Record<string, unknown> | undefined;
+}>;
+declare const PaymentPayloadV1Schema: z.ZodObject<{
+    t402Version: z.ZodOptional<z.ZodLiteral<1>>;
+    accepted: z.ZodObject<{
+        scheme: z.ZodString;
+        network: z.ZodString;
+        asset: z.ZodString;
+        amount: z.ZodString;
+        payTo: z.ZodString;
+        maxTimeoutSeconds: z.ZodNumber;
+        extra: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, "strip", z.ZodTypeAny, {
+        scheme: string;
+        amount: string;
+        network: string;
+        asset: string;
+        payTo: string;
+        maxTimeoutSeconds: number;
+        extra?: Record<string, unknown> | undefined;
+    }, {
+        scheme: string;
+        amount: string;
+        network: string;
+        asset: string;
+        payTo: string;
+        maxTimeoutSeconds: number;
+        extra?: Record<string, unknown> | undefined;
+    }>;
+    payload: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, "strip", z.ZodTypeAny, {
+    accepted: {
+        scheme: string;
+        amount: string;
+        network: string;
+        asset: string;
+        payTo: string;
+        maxTimeoutSeconds: number;
+        extra?: Record<string, unknown> | undefined;
+    };
+    payload: Record<string, unknown>;
+    t402Version?: 1 | undefined;
+}, {
+    accepted: {
+        scheme: string;
+        amount: string;
+        network: string;
+        asset: string;
+        payTo: string;
+        maxTimeoutSeconds: number;
+        extra?: Record<string, unknown> | undefined;
+    };
+    payload: Record<string, unknown>;
+    t402Version?: 1 | undefined;
+}>;
+type ValidatedPaymentPayload = z.infer<typeof PaymentPayloadSchema>;
+type ValidatedPaymentRequired = z.infer<typeof PaymentRequiredSchema>;
+type ValidatedPaymentRequirements = z.infer<typeof PaymentRequirementsSchema>;
+type ValidatedVerifyResponse = z.infer<typeof VerifyResponseSchema>;
+type ValidatedSettleResponse = z.infer<typeof SettleResponseSchema>;
+/**
+ * Parse and validate a PaymentPayload.
+ *
+ * @param data - The data to parse
+ * @returns The validated payment payload
+ * @throws ZodError if validation fails
+ */
+declare function parsePaymentPayload(data: unknown): ValidatedPaymentPayload;
+/**
+ * Parse and validate a PaymentRequired response.
+ *
+ * @param data - The data to parse
+ * @returns The validated payment required response
+ * @throws ZodError if validation fails
+ */
+declare function parsePaymentRequired(data: unknown): ValidatedPaymentRequired;
+/**
+ * Parse and validate PaymentRequirements.
+ *
+ * @param data - The data to parse
+ * @returns The validated payment requirements
+ * @throws ZodError if validation fails
+ */
+declare function parsePaymentRequirements(data: unknown): ValidatedPaymentRequirements;
+/**
+ * Safely parse a PaymentPayload, returning a result object.
+ *
+ * @param data - The data to parse
+ * @returns The safe parse result
+ */
+declare function safeParsePaymentPayload(data: unknown): z.SafeParseReturnType<unknown, ValidatedPaymentPayload>;
+/**
+ * Safely parse a PaymentRequired response, returning a result object.
+ *
+ * @param data - The data to parse
+ * @returns The safe parse result
+ */
+declare function safeParsePaymentRequired(data: unknown): z.SafeParseReturnType<unknown, ValidatedPaymentRequired>;
+/**
+ * Safely parse PaymentRequirements, returning a result object.
+ *
+ * @param data - The data to parse
+ * @returns The safe parse result
+ */
+declare function safeParsePaymentRequirements(data: unknown): z.SafeParseReturnType<unknown, ValidatedPaymentRequirements>;
+
+type Network = `${string}:${string}`;
+type Money = string | number;
+type AssetAmount = {
+    asset: string;
+    amount: string;
+    extra?: Record<string, unknown>;
+};
+type Price = Money | AssetAmount;
+
+interface ResourceInfo {
+    url: string;
+    description?: string;
+    mimeType?: string;
+}
+type PaymentRequirements = {
+    scheme: string;
+    network: Network;
+    asset: string;
+    amount: string;
+    payTo: string;
+    maxTimeoutSeconds: number;
+    extra: Record<string, unknown>;
+};
+type PaymentRequired = {
+    t402Version: number;
+    error?: string;
+    resource: ResourceInfo;
+    accepts: PaymentRequirements[];
+    extensions?: Record<string, unknown>;
+};
+type PaymentPayload = {
+    t402Version: number;
+    resource?: ResourceInfo;
+    accepted: PaymentRequirements;
+    payload: Record<string, unknown>;
+    extensions?: Record<string, unknown>;
+};
+
+type VerifyRequest = {
+    paymentPayload: PaymentPayload;
+    paymentRequirements: PaymentRequirements;
+};
+type VerifyResponse = {
+    isValid: boolean;
+    invalidReason?: string;
+    payer?: string;
+};
+type SettleRequest = {
+    paymentPayload: PaymentPayload;
+    paymentRequirements: PaymentRequirements;
+};
+type SettleResponse = {
+    success: boolean;
+    errorReason?: string;
+    payer?: string;
+    transaction: string;
+    network: Network;
+    confirmations?: string;
+};
+type SupportedKind = {
+    t402Version: number;
+    scheme: string;
+    network: Network;
+    extra?: Record<string, unknown>;
+};
+type SupportedResponse = {
+    kinds: SupportedKind[];
+    extensions: string[];
+    signers: Record<string, string[]>;
+};
+
+/**
+ * Money parser function that converts a numeric amount to an AssetAmount
+ * Receives the amount as a decimal number (e.g., 1.50 for $1.50)
+ * Returns null to indicate "cannot handle this amount", causing fallback to next parser
+ * Always returns a Promise for consistency - use async/await
+ *
+ * @param amount - The decimal amount (e.g., 1.50)
+ * @param network - The network identifier for context
+ * @returns AssetAmount or null to try next parser
+ */
+type MoneyParser = (amount: number, network: Network) => Promise<AssetAmount | null>;
+interface SchemeNetworkClient {
+    readonly scheme: string;
+    createPaymentPayload(t402Version: number, paymentRequirements: PaymentRequirements): Promise<Pick<PaymentPayload, "t402Version" | "payload">>;
+}
+interface SchemeNetworkFacilitator {
+    readonly scheme: string;
+    /**
+     * CAIP family pattern that this facilitator supports.
+     * Used to group signers by blockchain family in the supported response.
+     *
+     * @example
+     * // EVM facilitators
+     * readonly caipFamily = "eip155:*";
+     *
+     * @example
+     * // SVM facilitators
+     * readonly caipFamily = "solana:*";
+     */
+    readonly caipFamily: string;
+    /**
+     * Get mechanism-specific extra data needed for the supported kinds endpoint.
+     * This method is called when building the facilitator's supported response.
+     *
+     * @param network - The network identifier for context
+     * @returns Extra data object or undefined if no extra data is needed
+     *
+     * @example
+     * // EVM schemes return undefined (no extra data needed)
+     * getExtra(network: Network): undefined {
+     *   return undefined;
+     * }
+     *
+     * @example
+     * // SVM schemes return feePayer address
+     * getExtra(network: Network): Record<string, unknown> | undefined {
+     *   return { feePayer: this.signer.address };
+     * }
+     */
+    getExtra(network: Network): Record<string, unknown> | undefined;
+    /**
+     * Get signer addresses used by this facilitator for a given network.
+     * These are included in the supported response to help clients understand
+     * which addresses might sign/pay for transactions.
+     *
+     * Supports multiple addresses for load balancing, key rotation, and high availability.
+     *
+     * @param network - The network identifier
+     * @returns Array of signer addresses (wallet addresses, fee payer addresses, etc.)
+     *
+     * @example
+     * // EVM facilitator
+     * getSigners(network: string): string[] {
+     *   return [...this.signer.getAddresses()];
+     * }
+     *
+     * @example
+     * // SVM facilitator
+     * getSigners(network: string): string[] {
+     *   return [...this.signer.getAddresses()];
+     * }
+     */
+    getSigners(network: string): string[];
+    verify(payload: PaymentPayload, requirements: PaymentRequirements): Promise<VerifyResponse>;
+    settle(payload: PaymentPayload, requirements: PaymentRequirements): Promise<SettleResponse>;
+}
+interface SchemeNetworkServer {
+    readonly scheme: string;
+    /**
+     * Convert a user-friendly price to the scheme's specific amount and asset format
+     * Always returns a Promise for consistency
+     *
+     * @param price - User-friendly price (e.g., "$0.10", "0.10", { amount: "100000", asset: "USDC" })
+     * @param network - The network identifier for context
+     * @returns Promise that resolves to the converted amount, asset identifier, and any extra metadata
+     *
+     * @example
+     * // For EVM networks with USDC:
+     * await parsePrice("$0.10", "eip155:8453") => { amount: "100000", asset: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913" }
+     *
+     * // For custom schemes:
+     * await parsePrice("10 points", "custom:network") => { amount: "10", asset: "points" }
+     */
+    parsePrice(price: Price, network: Network): Promise<AssetAmount>;
+    /**
+     * Build payment requirements for this scheme/network combination
+     *
+     * @param paymentRequirements - Base payment requirements with amount/asset already set
+     * @param supportedKind - The supported kind from facilitator's /supported endpoint
+     * @param supportedKind.t402Version - The t402 version
+     * @param supportedKind.scheme - The payment scheme
+     * @param supportedKind.network - The network identifier
+     * @param supportedKind.extra - Optional extra metadata
+     * @param facilitatorExtensions - Extensions supported by the facilitator
+     * @returns Enhanced payment requirements ready to be sent to clients
+     */
+    enhancePaymentRequirements(paymentRequirements: PaymentRequirements, supportedKind: {
+        t402Version: number;
+        scheme: string;
+        network: Network;
+        extra?: Record<string, unknown>;
+    }, facilitatorExtensions: string[]): Promise<PaymentRequirements>;
+}
+
+export { ERR_GAS_ESTIMATION_FAILED as $, type A2AAgentCard as A, type A2AResponse as B, type A2ASkill as C, type A2ATask as D, type A2ATaskState as E, type A2ATaskStatus as F, type A2ATextPart as G, A2A_EXTENSIONS_HEADER as H, type APIError as I, type AssetAmount as J, ERR_ALLOWANCE_INSUFFICIENT as K, ERR_BRIDGE_QUOTE_FAILED as L, ERR_BRIDGE_TIMEOUT as M, type Network as N, ERR_BRIDGE_TRANSFER_FAILED as O, type PaymentRequirements as P, ERR_BRIDGE_UNAVAILABLE as Q, type ResourceServerExtension as R, type SettleResponse as S, ERR_CACHE_UNAVAILABLE as T, ERR_CHAIN_CONGESTED as U, type VerifyResponse as V, ERR_CHAIN_UNAVAILABLE as W, ERR_CONTRACT_ERROR as X, ERR_DATABASE_UNAVAILABLE as Y, ERR_DUPLICATE_PAYMENT as Z, ERR_EXPIRED_PAYMENT as _, type PaymentPayload as a, type SettleRequest as a$, ERR_IDEMPOTENCY_CONFLICT as a0, ERR_IDEMPOTENCY_UNAVAILABLE as a1, ERR_INSUFFICIENT_AMOUNT as a2, ERR_INSUFFICIENT_BALANCE as a3, ERR_INTENT_ALREADY_EXECUTED as a4, ERR_INTENT_CANCELLED as a5, ERR_INTENT_EXPIRED as a6, ERR_INTENT_INVALID_STATE as a7, ERR_INTENT_NOT_FOUND as a8, ERR_INTERNAL as a9, ERR_SERVICE_UNAVAILABLE as aA, ERR_SETTLEMENT_FAILED as aB, ERR_SETTLEMENT_PENDING as aC, ERR_SETTLEMENT_TIMEOUT as aD, ERR_SIGNATURE_EXPIRED as aE, ERR_STREAM_ALREADY_CLOSED as aF, ERR_STREAM_ALREADY_PAUSED as aG, ERR_STREAM_AMOUNT_EXCEEDED as aH, ERR_STREAM_EXPIRED as aI, ERR_STREAM_INVALID_STATE as aJ, ERR_STREAM_NOT_FOUND as aK, ERR_STREAM_NOT_PAUSED as aL, ERR_STREAM_RATE_LIMITED as aM, ERR_TRANSACTION_FAILED as aN, ERR_TRANSACTION_REVERTED as aO, ERR_UNSUPPORTED_ROUTE as aP, ERR_VERIFICATION_FAILED as aQ, type ErrorCode as aR, type Money as aS, type MoneyParser as aT, NetworkSchema as aU, PaymentPayloadSchema as aV, PaymentPayloadV1Schema as aW, PaymentRequiredSchema as aX, PaymentRequirementsSchema as aY, PaymentRequirementsV1Schema as aZ, ResourceInfoSchema as a_, ERR_INVALID_ADDRESS as aa, ERR_INVALID_AMOUNT as ab, ERR_INVALID_IDEMPOTENCY_KEY as ac, ERR_INVALID_NETWORK as ad, ERR_INVALID_NONCE as ae, ERR_INVALID_PARAMETERS as af, ERR_INVALID_PAYLOAD as ag, ERR_INVALID_REQUEST as ah, ERR_INVALID_REQUIREMENTS as ai, ERR_INVALID_SCHEME as aj, ERR_INVALID_SIGNATURE as ak, ERR_MISSING_PAYLOAD as al, ERR_MISSING_REQUIREMENTS as am, ERR_NONCE_CONFLICT as an, ERR_NONCE_REPLAY as ao, ERR_NOT_AUTHORIZED as ap, ERR_NO_ROUTES_AVAILABLE as aq, ERR_PAYMENT_MISMATCH as ar, ERR_PREVIOUS_REQUEST_FAILED as as, ERR_RATE_LIMITED as at, ERR_REQUEST_IN_PROGRESS as au, ERR_RESOURCE_ALREADY_EXISTS as av, ERR_RESOURCE_NOT_FOUND as aw, ERR_ROUTE_EXPIRED as ax, ERR_ROUTE_NOT_SELECTED as ay, ERR_RPC_UNAVAILABLE as az, type SchemeNetworkFacilitator as b, SettleResponseSchema as b0, T402_A2A_EXTENSION_URI as b1, UPTO_DEFAULTS as b2, UPTO_SCHEME as b3, type UptoEvmPayload as b4, type UptoEvmPayloadCompact as b5, type UptoExtra as b6, type UptoPayloadBase as b7, type UptoPaymentRequirements as b8, type UptoSettlement as b9, isServerError as bA, isUptoEvmPayload as bB, isUptoPaymentRequirements as bC, parsePaymentPayload as bD, parsePaymentRequired as bE, parsePaymentRequirements as bF, safeParsePaymentPayload as bG, safeParsePaymentRequired as bH, safeParsePaymentRequirements as bI, type UptoSettlementResponse as ba, type UptoUnit as bb, type UptoUsageDetails as bc, type UptoValidationResult as bd, type ValidatedPaymentPayload as be, type ValidatedPaymentRequired as bf, type ValidatedPaymentRequirements as bg, type ValidatedSettleResponse as bh, type ValidatedVerifyResponse as bi, type VerifyRequest as bj, VerifyResponseSchema as bk, createPaymentCompletedMessage as bl, createPaymentFailedMessage as bm, createPaymentRequiredMessage as bn, createPaymentSubmissionMessage as bo, createT402Extension as bp, getPaymentReceipts as bq, getPaymentRequired as br, httpStatusForCode as bs, isBridgeError as bt, isChainError as bu, isClientError as bv, isFacilitatorError as bw, isPaymentCompleted as bx, isPaymentFailed as by, isPaymentRequired as bz, type PaymentRequired as c, type SchemeNetworkClient as d, type SupportedResponse as e, type SchemeNetworkServer as f, type SupportedKind as g, type Price as h, type PaymentPayloadV1 as i, type PaymentRequiredV1 as j, type PaymentRequirementsV1 as k, type SettleRequestV1 as l, type SettleResponseV1 as m, type SupportedResponseV1 as n, type VerifyRequestV1 as o, type A2AArtifact as p, type A2ACapabilities as q, type A2ADataPart as r, type A2AError as s, type A2AExtension as t, type A2AFilePart as u, type A2AMessage as v, type A2AMessagePart as w, type A2APaymentMetadata as x, type A2APaymentStatus as y, type A2ARequest as z };