@catena/sdk 0.0.0-bootstrap.0 → 0.4.0

package/dist/client-B_Gi0aqH.d.mts

@@ -0,0 +1,1353 @@
+import * as v from "valibot";
+//#region src/offer-receipt.d.ts
+/**
+ * `acceptIndex` exists only on offers (it points at an `accepts[]` entry);
+ * receipts get their own schema without it so the public receipt type does
+ * not advertise a field receipts never carry.
+ */
+declare const x402SignedArtifactSchema: v.VariantSchema<"format", [v.LooseObjectSchema<{
+  readonly format: v.LiteralSchema<"eip712", undefined>;
+  readonly acceptIndex: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
+  readonly payload: v.RecordSchema<v.StringSchema<undefined>, v.UnknownSchema, undefined>;
+  readonly signature: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "Expected a 65-byte hex signature">]>;
+}, undefined>, v.LooseObjectSchema<{
+  readonly format: v.LiteralSchema<"jws", undefined>;
+  readonly acceptIndex: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
+  readonly signature: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MaxLengthAction<string, number, undefined>, v.RegexAction<string, "Expected a JWS compact serialization">]>;
+}, undefined>], undefined>;
+declare const x402SignedReceiptSchema: v.VariantSchema<"format", [v.LooseObjectSchema<{
+  readonly format: v.LiteralSchema<"eip712", undefined>;
+  readonly payload: v.RecordSchema<v.StringSchema<undefined>, v.UnknownSchema, undefined>;
+  readonly signature: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "Expected a 65-byte hex signature">]>;
+}, undefined>, v.LooseObjectSchema<{
+  readonly format: v.LiteralSchema<"jws", undefined>;
+  readonly signature: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MaxLengthAction<string, number, undefined>, v.RegexAction<string, "Expected a JWS compact serialization">]>;
+}, undefined>], undefined>;
+/**
+ * A seller-signed offer from a 402 challenge's `extensions["offer-receipt"]`
+ * (x402 Offer & Receipt extension), relayed to Catena verbatim for
+ * verification and storage as payment evidence. `eip712` artifacts carry the
+ * signed payload alongside the signature; `jws` artifacts carry it inside the
+ * compact serialization.
+ */
+type X402SignedOffer = v.InferOutput<typeof x402SignedArtifactSchema>;
+/**
+ * A seller-signed receipt from the paid retry's `PAYMENT-RESPONSE`
+ * `extensions["offer-receipt"]`, relayed to Catena verbatim for verification
+ * and storage as payment evidence — the seller's attestation that it was paid
+ * and delivered.
+ */
+type X402SignedReceipt = v.InferOutput<typeof x402SignedReceiptSchema>;
+//#endregion
+//#region src/user-agent.d.ts
+/**
+ * Optional caller identification prepended to the User-Agent, Stripe-style
+ * (`name/version (url)`). Telemetry only: the value is self-reported and
+ * spoofable, so it must never carry authority — client kind and privilege
+ * are derived server-side from the OAuth client_id.
+ */
+interface AppInfo {
+  name: string;
+  version?: string;
+  url?: string;
+}
+//#endregion
+//#region src/schemas.d.ts
+/**
+ * A response value known to this SDK release, or an opaque string added by a
+ * newer server. The known half preserves editor autocomplete without making an
+ * additive server change fail validation in an installed client. Blank and
+ * whitespace-only values still fail validation.
+ */
+type ExtensibleString<TKnown extends readonly string[]> = TKnown[number] | (string & {});
+declare const agentSchema: v.ObjectSchema<{
+  readonly id: v.StringSchema<undefined>;
+  readonly name: v.StringSchema<undefined>;
+  readonly status: v.StringSchema<undefined>;
+  readonly organizationId: v.StringSchema<undefined>;
+}, undefined>;
+type Agent = v.InferOutput<typeof agentSchema>;
+declare const POLICY_RULE_TYPES: readonly ["per_transaction_amount", "daily_amount", "weekly_amount", "monthly_amount", "hourly_count", "daily_count"];
+declare const POLICY_RULE_ACTIONS: readonly ["block", "require_approval"];
+declare const ACCOUNT_AGGREGATION_SCOPES: readonly ["per_account", "across_accounts"];
+declare const ACTOR_AGGREGATION_SCOPES: readonly ["per_agent", "per_policy"];
+declare const POLICY_CAPABILITIES: readonly ["query_balance", "read", "send", "transfer"];
+declare const COUNTERPARTY_ACTIONS: readonly ["allow", "block", "require_approval"];
+declare const COUNTERPARTY_RULE_MODES: readonly ["open", "restricted"];
+declare const policySchema: v.ObjectSchema<{
+  readonly id: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+  readonly description: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+  readonly version: v.OptionalSchema<v.NumberSchema<undefined>, undefined>;
+  readonly name: v.StringSchema<undefined>;
+  readonly capabilities: v.ArraySchema<v.StringSchema<undefined>, undefined>;
+  readonly counterpartyRules: v.OptionalSchema<v.ObjectSchema<{
+    readonly mode: v.GenericSchema<string, ExtensibleString<readonly ["open", "restricted"]>>;
+    readonly allowedCounterparties: v.OptionalSchema<v.ArraySchema<v.StringSchema<undefined>, undefined>, undefined>;
+    readonly createAction: v.OptionalSchema<v.GenericSchema<string, ExtensibleString<readonly ["allow", "block", "require_approval"]>>, undefined>;
+    readonly requestPaymentDetailsAction: v.OptionalSchema<v.GenericSchema<string, ExtensibleString<readonly ["allow", "block", "require_approval"]>>, undefined>;
+    readonly allowCreate: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
+  }, undefined>, undefined>;
+  readonly policyCapabilities: v.ArraySchema<v.ObjectSchema<{
+    readonly id: v.StringSchema<undefined>;
+    readonly organizationId: v.StringSchema<undefined>;
+    readonly policyId: v.StringSchema<undefined>;
+    readonly capability: v.GenericSchema<string, ExtensibleString<readonly ["query_balance", "read", "send", "transfer"]>>;
+    readonly accountId: v.StringSchema<undefined>;
+    readonly rules: v.ArraySchema<v.ObjectSchema<{
+      readonly id: v.StringSchema<undefined>;
+      readonly ruleType: v.GenericSchema<string, ExtensibleString<readonly ["per_transaction_amount", "daily_amount", "weekly_amount", "monthly_amount", "hourly_count", "daily_count"]>>;
+      readonly thresholdAmount: v.OptionalSchema<v.ObjectSchema<{
+        /**
+         * Decimal string in the asset's major unit: "12.50" is $12.50. Never cents or
+         * atomic units.
+         */
+        readonly amount: v.StringSchema<undefined>;
+        /**
+         * Asset identifier, e.g. "USD".
+         */
+        readonly asset_id: v.StringSchema<undefined>;
+      }, undefined>, undefined>;
+      readonly thresholdCount: v.OptionalSchema<v.NumberSchema<undefined>, undefined>;
+      readonly action: v.GenericSchema<string, ExtensibleString<readonly ["block", "require_approval"]>>;
+      readonly requiredApprovals: v.NumberSchema<undefined>;
+      readonly accountAggregationScope: v.GenericSchema<string, ExtensibleString<readonly ["per_account", "across_accounts"]>>;
+      readonly actorAggregationScope: v.GenericSchema<string, ExtensibleString<readonly ["per_agent", "per_policy"]>>;
+      readonly displayOrder: v.NumberSchema<undefined>;
+    }, undefined>, undefined>;
+    readonly createdAt: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, undefined>]>;
+    readonly updatedAt: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, undefined>]>;
+  }, undefined>, undefined>;
+  /**
+   * "override" means a temporary policy override is active; `expiresAt` is
+   * when it lapses and the base policy applies again. Absent on servers
+   * that predate overrides and under the base policy respectively.
+   */
+  readonly kind: v.OptionalSchema<v.PicklistSchema<["base", "override"], undefined>, undefined>;
+  readonly expiresAt: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+}, undefined>;
+type Policy = v.InferOutput<typeof policySchema>;
+declare const accountsResponseSchema: v.ObjectSchema<{
+  readonly accounts: v.ArraySchema<v.ObjectSchema<{
+    readonly id: v.StringSchema<undefined>;
+    readonly name: v.StringSchema<undefined>;
+    readonly type: v.StringSchema<undefined>;
+    readonly currency: v.StringSchema<undefined>;
+  }, undefined>, undefined>;
+}, undefined>;
+type AccountsResponse = v.InferOutput<typeof accountsResponseSchema>;
+declare const accountBalanceResponseSchema: v.ObjectSchema<{
+  readonly accountId: v.StringSchema<undefined>;
+  /**
+   * @deprecated Flat alias of `balances.total`; use `balances` instead.
+   */
+  readonly balance: v.ObjectSchema<{
+    /**
+     * Decimal string in the asset's major unit: "12.50" is $12.50. Never cents or
+     * atomic units.
+     */
+    readonly amount: v.StringSchema<undefined>;
+    /**
+     * Asset identifier, e.g. "USD".
+     */
+    readonly asset_id: v.StringSchema<undefined>;
+  }, undefined>;
+  /**
+   * `available` is the most one payment from this account can move: every
+   * network it may use together where a plan carries the payment across
+   * them, otherwise the balance on the one network that payment binds, or
+   * the largest of them while that network holds nothing yet. It is zero
+   * while the account is not active, and zero when the only network the
+   * account holds is one agents may not use. A transfer to a Catena
+   * account still binds one network, so a plan's figure can be more than
+   * such a transfer accepts. Absent only from API deployments that predate
+   * these fields.
+   */
+  readonly balances: v.OptionalSchema<v.ObjectSchema<{
+    readonly total: v.ObjectSchema<{
+      /**
+       * Decimal string in the asset's major unit: "12.50" is $12.50. Never cents or
+       * atomic units.
+       */
+      readonly amount: v.StringSchema<undefined>;
+      /**
+       * Asset identifier, e.g. "USD".
+       */
+      readonly asset_id: v.StringSchema<undefined>;
+    }, undefined>;
+    readonly available: v.ObjectSchema<{
+      /**
+       * Decimal string in the asset's major unit: "12.50" is $12.50. Never cents or
+       * atomic units.
+       */
+      readonly amount: v.StringSchema<undefined>;
+      /**
+       * Asset identifier, e.g. "USD".
+       */
+      readonly asset_id: v.StringSchema<undefined>;
+    }, undefined>;
+    /**
+     * `total` and `available` for each network that the account holds and
+     * agents may use. The entries can add up to less than `balances.total`,
+     * which also counts a network agents may not use, and their `available`
+     * can add up to more than `balances.available`, which one payment binds
+     * to one network. Every `available` is zero while the account is not
+     * active. An empty array means no network the account holds is open to
+     * agents. Absent until the account's money is split by network,
+     * and from API deployments that predate the field.
+     */
+    readonly byNetwork: v.OptionalSchema<v.ArraySchema<v.ObjectSchema<{
+      readonly network: v.StringSchema<undefined>;
+      readonly total: v.ObjectSchema<{
+        /**
+         * Decimal string in the asset's major unit: "12.50" is $12.50. Never cents or
+         * atomic units.
+         */
+        readonly amount: v.StringSchema<undefined>;
+        /**
+         * Asset identifier, e.g. "USD".
+         */
+        readonly asset_id: v.StringSchema<undefined>;
+      }, undefined>;
+      readonly available: v.ObjectSchema<{
+        /**
+         * Decimal string in the asset's major unit: "12.50" is $12.50. Never cents or
+         * atomic units.
+         */
+        readonly amount: v.StringSchema<undefined>;
+        /**
+         * Asset identifier, e.g. "USD".
+         */
+        readonly asset_id: v.StringSchema<undefined>;
+      }, undefined>;
+    }, undefined>, undefined>, undefined>;
+  }, undefined>, undefined>;
+}, undefined>;
+type AccountBalanceResponse = v.InferOutput<typeof accountBalanceResponseSchema>;
+declare const ACCOUNT_TRANSACTION_TYPES: readonly ["operator-send", "operator-transfer", "operator-deposit", "operator-refund", "microdeposit"];
+declare const ACCOUNT_TRANSACTION_STATUSES: readonly ["pending", "processing", "completed", "failed", "reversed"];
+declare const ACCOUNT_TRANSACTION_MOVEMENT_STATUSES: readonly ["initiated", "provider_pending", "processing", "completed", "failed", "reversed", "manual_review"];
+declare const SEND_METHODS: readonly ["ach", "wire", "on-chain"];
+declare const ACCOUNT_TRANSACTION_METHODS: readonly ["ach", "wire", "on-chain"];
+declare const accountTransactionsResponseSchema: v.ObjectSchema<{
+  readonly accountId: v.StringSchema<undefined>;
+  readonly transactions: v.ArraySchema<v.ObjectSchema<{
+    readonly id: v.StringSchema<undefined>;
+    readonly type: v.GenericSchema<string, ExtensibleString<readonly ["operator-send", "operator-transfer", "operator-deposit", "operator-refund", "microdeposit"]>>;
+    /**
+     * Display action — `receive` for on-chain receives, distinct from the raw
+     * `type`. Optional to tolerate an API deployed before this field existed.
+     */
+    readonly action: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+    readonly status: v.GenericSchema<string, ExtensibleString<readonly ["pending", "processing", "completed", "failed", "reversed"]>>;
+    readonly movementStatus: v.GenericSchema<string, ExtensibleString<readonly ["initiated", "provider_pending", "processing", "completed", "failed", "reversed", "manual_review"]>>;
+    readonly direction: v.PicklistSchema<["incoming", "outgoing"], undefined>;
+    readonly amount: v.ObjectSchema<{
+      /**
+       * Decimal string in the asset's major unit: "12.50" is $12.50. Never cents or
+       * atomic units.
+       */
+      readonly amount: v.StringSchema<undefined>;
+      /**
+       * Asset identifier, e.g. "USD".
+       */
+      readonly asset_id: v.StringSchema<undefined>;
+    }, undefined>;
+    readonly fee: v.ObjectSchema<{
+      /**
+       * Decimal string in the asset's major unit: "12.50" is $12.50. Never cents or
+       * atomic units.
+       */
+      readonly amount: v.StringSchema<undefined>;
+      /**
+       * Asset identifier, e.g. "USD".
+       */
+      readonly asset_id: v.StringSchema<undefined>;
+    }, undefined>;
+    readonly currency: v.StringSchema<undefined>;
+    /**
+     * On-chain network, absent for fiat and older transactions.
+     */
+    readonly network: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+    readonly counterpartyName: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+    readonly method: v.OptionalSchema<v.GenericSchema<string, ExtensibleString<readonly ["ach", "wire", "on-chain"]>>, undefined>;
+    readonly memo: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+    readonly description: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+    readonly txHash: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+    readonly createdAt: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, undefined>]>;
+    readonly completedAt: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, undefined>]>, undefined>;
+  }, undefined>, undefined>;
+  readonly total: v.NumberSchema<undefined>;
+}, undefined>;
+type AccountTransactionsResponse = v.InferOutput<typeof accountTransactionsResponseSchema>;
+type AccountTransactionsParams = {
+  /**
+   * Inclusive lower bound on `createdAt`, as an ISO 8601 timestamp.
+   */
+  start?: string;
+  /**
+   * Inclusive upper bound on `createdAt`, as an ISO 8601 timestamp.
+   */
+  end?: string;
+  /**
+   * Page size; positive integer, defaults to 50, values above 200 are
+   * clamped to 200. Non-integer or non-positive values are rejected (400).
+   */
+  limit?: number;
+  /**
+   * Rows to skip; nonnegative integer, defaults to 0. Non-integer or
+   * negative values are rejected (400).
+   */
+  offset?: number;
+};
+declare const ACCOUNT_DEPOSIT_ADDRESS_SOURCES: readonly ["wallet", "liquidation"];
+declare const accountDepositAddressResponseSchema: v.ObjectSchema<{
+  readonly accountId: v.StringSchema<undefined>;
+  readonly address: v.StringSchema<undefined>;
+  readonly liquidationAddressId: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+  readonly source: v.GenericSchema<string, ExtensibleString<readonly ["wallet", "liquidation"]>>;
+}, undefined>;
+type AccountDepositAddressResponse = v.InferOutput<typeof accountDepositAddressResponseSchema>;
+/**
+ * Widened network/asset inputs: autocomplete from the literal half, but any
+ * string is accepted — the server is the enforcement boundary, so a network
+ * or asset added server-side never becomes a compile-time wall for an older
+ * SDK. Response schemas parse plain strings for the same reason.
+ */
+type OnchainNetworkInput = "base" | "base-sepolia" | "arc" | (string & {});
+type OnchainAssetInput = "usdc" | (string & {});
+declare const walletCounterpartyRailSchema: v.ObjectSchema<{
+  readonly type: v.LiteralSchema<"wallet", undefined>;
+  readonly walletAddress: v.CustomSchema<`0x${string}`, undefined>;
+  readonly network: v.CustomSchema<OnchainNetworkInput, undefined>;
+}, undefined>;
+/**
+ * Catena wallet rail returned for deliberate counterparty recovery. It can be
+ * passed directly as `create_counterparty`'s `rail` after the caller chooses a
+ * name and confirms the recipient.
+ */
+type WalletCounterpartyRail = v.InferOutput<typeof walletCounterpartyRailSchema>;
+type AccountDepositAddressParams = {
+  network: OnchainNetworkInput;
+  asset: OnchainAssetInput;
+};
+/**
+ * Rails are modeled tolerantly rather than as a variant on `type`: each
+ * field is present only on the rail types it applies to (wallet rails carry
+ * `walletAddress` and may carry `network`; bank rails carry
+ * `bankName`/`accountNumber`), and a server that later adds a new rail type
+ * must not break older clients. A wallet rail omits `network` when its
+ * configured destination is unavailable to the agent; it cannot receive an
+ * agent send until that configuration or the organization's capability changes.
+ */
+declare const counterpartySchema: v.ObjectSchema<{
+  readonly id: v.StringSchema<undefined>;
+  readonly name: v.StringSchema<undefined>;
+  /**
+   * Server-derived payment-detail readiness. Current values are "ready" and
+   * "awaiting_details"; treat other strings as future lifecycle states.
+   * Optional so this SDK can still read responses from older servers.
+   */
+  readonly status: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+  readonly rails: v.ArraySchema<v.ObjectSchema<{
+    readonly id: v.StringSchema<undefined>;
+    /**
+     * Rail kind — currently "wallet" or "bank"; treat other values as
+     * future rail types. Sends must match method to rail: "ach" and
+     * "wire" need a bank rail, "on-chain" needs a wallet rail.
+     */
+    readonly type: v.StringSchema<undefined>;
+    readonly walletAddress: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+    readonly network: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+    readonly bankName: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+    readonly accountNumber: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+  }, undefined>, undefined>;
+}, undefined>;
+type Counterparty = v.InferOutput<typeof counterpartySchema>;
+declare const counterpartiesResponseSchema: v.ObjectSchema<{
+  readonly counterparties: v.ArraySchema<v.ObjectSchema<{
+    readonly id: v.StringSchema<undefined>;
+    readonly name: v.StringSchema<undefined>;
+    /**
+     * Server-derived payment-detail readiness. Current values are "ready" and
+     * "awaiting_details"; treat other strings as future lifecycle states.
+     * Optional so this SDK can still read responses from older servers.
+     */
+    readonly status: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+    readonly rails: v.ArraySchema<v.ObjectSchema<{
+      readonly id: v.StringSchema<undefined>;
+      /**
+       * Rail kind — currently "wallet" or "bank"; treat other values as
+       * future rail types. Sends must match method to rail: "ach" and
+       * "wire" need a bank rail, "on-chain" needs a wallet rail.
+       */
+      readonly type: v.StringSchema<undefined>;
+      readonly walletAddress: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+      readonly network: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+      readonly bankName: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+      readonly accountNumber: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+    }, undefined>, undefined>;
+  }, undefined>, undefined>;
+}, undefined>;
+type CounterpartiesResponse = v.InferOutput<typeof counterpartiesResponseSchema>;
+type CounterpartiesParams = {
+  /**
+   * Only counterparties that own this wallet address.
+   */
+  address?: `0x${string}` | undefined;
+  /**
+   * Only counterparties that own a wallet address in this network class.
+   * This does not promise that a payment can settle on the queried network.
+   */
+  network?: OnchainNetworkInput | undefined;
+};
+declare const INTENT_ACTION_TYPES: readonly ["send", "transfer", "create_counterparty", "request_counterparty_details", "x402", "mpp", "policy_override"];
+/**
+ * Present on a send that crosses chains: the counterparty wallet sits on the
+ * other side of the Base and Arc lane and the account had no balance to pay
+ * it there, so the first signature burned the amount toward the account's own
+ * address on the destination. `nextStep` is the whole contract: `wait` and
+ * poll while the crossing runs, `continue` when `continueIntent` is due,
+ * `done` once the counterparty was paid, `blocked` when an operator must
+ * step in. `state` walks `burning`, `attesting`, `minting`, `ready`,
+ * `delivering`, `delivered`; `failed` and `manual_review` are terminal.
+ */
+declare const CROSS_CHAIN_STATES: readonly ["burning", "attesting", "minting", "ready", "delivering", "delivered", "failed", "manual_review"];
+declare const CROSS_CHAIN_NEXT_STEPS: readonly ["wait", "continue", "done", "blocked"];
+declare const crossChainSendSchema: v.ObjectSchema<{
+  readonly id: v.StringSchema<undefined>;
+  readonly sourceNetwork: v.StringSchema<undefined>;
+  readonly destinationNetwork: v.StringSchema<undefined>;
+  readonly state: v.GenericSchema<string, ExtensibleString<readonly ["burning", "attesting", "minting", "ready", "delivering", "delivered", "failed", "manual_review"]>>;
+  readonly nextStep: v.GenericSchema<string, ExtensibleString<readonly ["wait", "continue", "done", "blocked"]>>;
+  readonly readyAt: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, undefined>]>, undefined>;
+  readonly deliveredAt: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, undefined>]>, undefined>;
+  readonly failureReason: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+}, undefined>;
+type CrossChainSend = v.InferOutput<typeof crossChainSendSchema>;
+declare const MOVEMENT_NEXT_STEPS: readonly ["wait", "continue", "done", "blocked"];
+/**
+ * Present on a payment carried by a movement plan.
+ *
+ * `nextStep` is what the payment is waiting for, which `status` cannot say on
+ * its own: a payment an admin is signing and one whose signature is already in
+ * flight are both "processing".
+ *
+ * - "wait" — nothing to do here. A person is deciding the payment, or has
+ *   approved it and an admin is finishing it. Read it again with
+ *   getIntent(...). If you restarted before signing a payment nobody had to
+ *   approve, send the original request again on the same idempotency key.
+ *   Within about five minutes of the first send it answers
+ *   `movement_authorization_in_progress`; after that it hands the payment back
+ *   for you to sign.
+ * - "done" — the payment completed.
+ * - "blocked" — it ended without paying. Read `reasons` for why; it is empty when
+ *   an approval lapsed.
+ *
+ * A payment a person has to approve is never handed back to you to finish:
+ * "continue" belongs to a send that crossed chains and is not an answer this
+ * field gives. It stays in the list because both fields are parsed against one
+ * vocabulary.
+ */
+declare const movementSchema: v.ObjectSchema<{
+  readonly planId: v.StringSchema<undefined>;
+  readonly nextStep: v.GenericSchema<string, ExtensibleString<readonly ["wait", "continue", "done", "blocked"]>>;
+}, undefined>;
+type Movement = v.InferOutput<typeof movementSchema>;
+declare const wireIntentResultSchema: v.ObjectSchema<{
+  readonly id: v.StringSchema<undefined>;
+  /**
+   * Resolved source account, pinned at creation even if policy later changes.
+   * Omitted for actions without an account and by older servers.
+   */
+  readonly accountId: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+  readonly type: v.GenericSchema<string, ExtensibleString<readonly ["send", "transfer", "create_counterparty", "request_counterparty_details", "x402", "mpp", "policy_override"]>>;
+  /**
+   * Disposition of the intent:
+   *
+   * - "pending" — accepted but not yet executing, typically parked for a human
+   *   approval; `reasons` says why and `expiresAt` when it lapses. A client
+   *   with no registered signing key has every wallet payment parked, whatever
+   *   the amount, and `reasons` carries `agent_signer_not_registered` (or
+   *   `operator_signature_required` for a payment with no `movement`).
+   * - "processing" — accepted and in progress. Executing intents advance on their
+   *   own; poll `getIntent`. An approved MPP or x402 payment instead rests here
+   *   until the paid request is re-run — polling never advances it — and
+   *   `expiresAt` is when that grant lapses. A payment a person approved also
+   *   rests here while an admin signs it, and `movement.nextStep` reads "wait"
+   *   until it is done or blocked.
+   * - "completed" — the action succeeded: money moved for send and transfer; for
+   *   MPP and x402 the payment authorization was delivered
+   *   (`data.paymentCredential.value`), with on-chain settlement verified
+   *   separately; for create_counterparty the counterparty exists.
+   * - "blocked" — declined by policy or denied by an operator; `reasons` explains
+   *   why approval was required, not necessarily why it was denied. Terminal.
+   * - "failed" — failed, expired, or reversed. Terminal.
+   */
+  readonly status: v.PicklistSchema<["pending", "processing", "completed", "blocked", "failed"], undefined>;
+  /**
+   * Human-readable explanations for a pending, blocked, or failed status.
+   */
+  readonly reasons: v.ArraySchema<v.StringSchema<undefined>, undefined>;
+  /**
+   * Deadline for an awaiting state: while parked for approval, when the
+   * request self-expires; while an approved payment grant rests, when the
+   * grant lapses. Optional to tolerate an API deployed before this field
+   * existed.
+   */
+  readonly expiresAt: v.OptionalSchema<v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, undefined>]>, undefined>, null>;
+  /**
+   * True when `submitIntent` matched an earlier request and the server handed
+   * that intent back rather than accepting a new action — so a `completed`
+   * status describes the earlier movement, not one this call made. Check
+   * `data.transaction` to see which movement it is. Always false on a read, and
+   * on an API deployed before this field existed.
+   */
+  readonly replayed: v.OptionalSchema<v.BooleanSchema<undefined>, false>;
+  /**
+   * Intent-type-specific payload. A completed payment intent carries the
+   * credential to present to the seller at `data.paymentCredential`
+   * (`{ protocol, value }`, where `value` is the serialized retry credential)
+   * and its transaction at `data.transaction`; `data.x402` is a deprecated
+   * x402-specific copy of both.
+   */
+  readonly data: v.OptionalSchema<v.NullableSchema<v.RecordSchema<v.StringSchema<undefined>, v.UnknownSchema, undefined>, undefined>, null>;
+  readonly metadata: v.OptionalSchema<v.ObjectSchema<{
+    readonly dataUrl: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+  }, undefined>, undefined>;
+  /**
+   * Present on a send that crosses chains. See `CrossChainSend`.
+   */
+  readonly crossChain: v.OptionalSchema<v.ObjectSchema<{
+    readonly id: v.StringSchema<undefined>;
+    readonly sourceNetwork: v.StringSchema<undefined>;
+    readonly destinationNetwork: v.StringSchema<undefined>;
+    readonly state: v.GenericSchema<string, ExtensibleString<readonly ["burning", "attesting", "minting", "ready", "delivering", "delivered", "failed", "manual_review"]>>;
+    readonly nextStep: v.GenericSchema<string, ExtensibleString<readonly ["wait", "continue", "done", "blocked"]>>;
+    readonly readyAt: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, undefined>]>, undefined>;
+    readonly deliveredAt: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, undefined>]>, undefined>;
+    readonly failureReason: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+  }, undefined>, undefined>;
+  /**
+   * Present on a payment carried by a movement plan, and absent from a server
+   * that has not deployed them. See `Movement`.
+   */
+  readonly movement: v.OptionalSchema<v.ObjectSchema<{
+    readonly planId: v.StringSchema<undefined>;
+    readonly nextStep: v.GenericSchema<string, ExtensibleString<readonly ["wait", "continue", "done", "blocked"]>>;
+  }, undefined>, undefined>;
+  readonly nextAction: v.OptionalSchema<v.ObjectSchema<{
+    readonly type: v.LiteralSchema<"submit_stamp", undefined>;
+    readonly signingRequestId: v.StringSchema<undefined>;
+    readonly signer: v.ObjectSchema<{
+      readonly algorithm: v.LiteralSchema<"p256", undefined>;
+      readonly publicKeyHex: v.StringSchema<undefined>;
+    }, undefined>;
+    readonly preparedBody: v.ObjectSchema<{
+      readonly body: v.StringSchema<undefined>;
+      readonly bodyHash: v.StringSchema<undefined>;
+      readonly expiresAt: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, undefined>]>;
+      readonly prepareToken: v.StringSchema<undefined>;
+    }, undefined>;
+    /**
+     * Present when the approval covers a movement plan, whose one signature
+     * authorizes several digests at once. It carries what each of those digests
+     * commits to, so the signer can rebuild them rather than stamp bytes it has
+     * not read.
+     */
+    readonly movement: v.OptionalSchema<v.ObjectSchema<{
+      readonly planId: v.StringSchema<undefined>;
+      readonly signerAddress: v.StringSchema<undefined>;
+      readonly digests: v.ArraySchema<v.StringSchema<undefined>, undefined>;
+      readonly instructions: v.ArraySchema<v.LooseObjectSchema<{
+        readonly kind: v.StringSchema<undefined>;
+        readonly network: v.StringSchema<undefined>;
+        readonly signerAddress: v.StringSchema<undefined>;
+        readonly digest: v.StringSchema<undefined>;
+        readonly payload: v.RecordSchema<v.StringSchema<undefined>, v.UnknownSchema, undefined>;
+      }, undefined>, undefined>;
+    }, undefined>, undefined>;
+  }, undefined>, undefined>;
+}, undefined>;
+type WireIntentResult = v.InferOutput<typeof wireIntentResultSchema>;
+/**
+ * Public view of an intent, as returned by `submitIntent` and `getIntent`.
+ * Branch on `status`; `reasons` explains non-completed outcomes.
+ *
+ * The co-signing step inside `submitIntent` is not resumable from a re-read
+ * intent: one awaiting its co-signature reads as plain "processing" here.
+ * Recovery from a failed submit follows `IntentSubmitError`'s outcome
+ * contract: a new `submitIntent` only when the outcome was "not-submitted";
+ * when it was "unknown", poll `getIntent` to a terminal status and submit
+ * again only if it ended blocked or failed.
+ */
+type IntentResult = Omit<WireIntentResult, "nextAction">;
+declare const sendMethodSchema: v.PicklistSchema<readonly ["ach", "wire", "on-chain"], undefined>;
+type SendMethod = v.InferOutput<typeof sendMethodSchema>;
+/**
+ * The `PaymentRequirements` a 402 challenge names, relayed to the API
+ * verbatim. Loose on purpose: the API is the enforcement boundary (shape,
+ * guardrails, policy); the client only needs the discriminating fields to
+ * pick a candidate from `accepts`.
+ */
+declare const x402PaymentRequirementsSchema: v.LooseObjectSchema<{
+  readonly scheme: v.StringSchema<undefined>;
+  readonly network: v.StringSchema<undefined>;
+  readonly asset: v.StringSchema<undefined>;
+  readonly amount: v.StringSchema<undefined>;
+  readonly payTo: v.StringSchema<undefined>;
+  readonly maxTimeoutSeconds: v.NumberSchema<undefined>;
+}, undefined>;
+type X402PaymentRequirements = v.InferOutput<typeof x402PaymentRequirementsSchema>;
+declare const x402ResourceSchema: v.LooseObjectSchema<{
+  readonly url: v.StringSchema<undefined>;
+  /**
+   * Human-readable name of the paid service, when the challenge advertises
+   * one — a suggested name when creating the counterparty. Parsed leniently:
+   * a malformed value (non-string, or over-long) drops to undefined rather
+   * than failing the whole challenge parse, which would silently downgrade
+   * an otherwise-payable 402 to an unpaid passthrough.
+   */
+  readonly serviceName: v.SchemaWithFallback<v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>, undefined>;
+}, undefined>;
+type X402Resource = v.InferOutput<typeof x402ResourceSchema>;
+declare const x402AuthorizationSchema: v.ObjectSchema<{
+  /**
+   * Wallet address the transfer draws from. Must be the paying account's
+   * wallet address; the server rejects any other value. A mixed-case
+   * spelling must carry a valid EIP-55 checksum; all-lowercase is accepted.
+   */
+  readonly from: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "Expected a 20-byte hex address">]>;
+  /**
+   * Recipient address. Must equal the requirement's `payTo` (case may
+   * differ) and resolve to a saved counterparty wallet rail. A mixed-case
+   * spelling must carry a valid EIP-55 checksum; all-lowercase is accepted.
+   */
+  readonly to: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "Expected a 20-byte hex address">]>;
+  /**
+   * Amount in atomic token units as a canonical decimal string (no leading
+   * zeros). Must equal the requirement's `amount`.
+   */
+  readonly value: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MaxLengthAction<string, 78, undefined>, v.RegexAction<string, "Expected a canonical decimal integer string">]>;
+  /**
+   * Unix seconds the authorization becomes valid, as a canonical decimal
+   * string. Must not be in the future.
+   */
+  readonly validAfter: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MaxLengthAction<string, 78, undefined>, v.RegexAction<string, "Expected a canonical decimal integer string">]>;
+  /**
+   * Unix seconds the authorization expires, as a canonical decimal string.
+   * Bounded by the requirement's `maxTimeoutSeconds` and must leave time to
+   * settle.
+   */
+  readonly validBefore: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MaxLengthAction<string, 78, undefined>, v.RegexAction<string, "Expected a canonical decimal integer string">]>;
+  /**
+   * 32-byte hex nonce (`0x` + 64 hex characters), unique per payment for
+   * the wallet. A nonce ever used by an earlier payment is refused; retry
+   * with a fresh one.
+   */
+  readonly nonce: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "Expected a 32-byte hex nonce">]>;
+}, undefined>;
+/**
+ * Caller-supplied EIP-3009 `TransferWithAuthorization` message. When present
+ * on an x402 action, the server validates and signs these exact values
+ * instead of minting its own authorization, so the returned payment
+ * signature verifies against typed data the caller constructed.
+ */
+type X402Authorization = v.InferOutput<typeof x402AuthorizationSchema>;
+declare const mppChallengeSchema: v.ObjectSchema<{
+  /**
+   * Seller-issued challenge identifier.
+   */
+  readonly id: v.StringSchema<undefined>;
+  /**
+   * Seller protection space that issued the challenge.
+   */
+  readonly realm: v.StringSchema<undefined>;
+  /**
+   * Supported MPP payment method.
+   */
+  readonly method: v.PicklistSchema<["evm", "usdc"], undefined>;
+  /**
+   * Catena supports MPP charge intents only.
+   */
+  readonly intent: v.LiteralSchema<"charge", undefined>;
+  /**
+   * Base64url-encoded, canonical MPP payment request.
+   */
+  readonly request: v.StringSchema<undefined>;
+  /**
+   * Optional seller description of the charge.
+   */
+  readonly description: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+  /**
+   * Optional seller-declared request-body digest, relayed unchanged.
+   */
+  readonly digest: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+  /**
+   * UTC challenge expiry timestamp.
+   */
+  readonly expires: v.StringSchema<undefined>;
+  /**
+   * Alternate field for the credential when HTTP Authorization is occupied.
+   */
+  readonly header: v.OptionalSchema<v.LiteralSchema<"Payment-Authorization", undefined>, undefined>;
+  /**
+   * Opaque base64url seller state, relayed unchanged.
+   */
+  readonly opaque: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+}, undefined>;
+/**
+ * Serialized MPP challenge accepted by the Catena intent API. `request` is
+ * the challenge's base64url-encoded payment request; `digest`, when present,
+ * is relayed unchanged for the seller to verify.
+ */
+type MppChallenge = v.InferOutput<typeof mppChallengeSchema>;
+declare const mppResourceSchema: v.ObjectSchema<{
+  /**
+   * Absolute URL of the paid resource.
+   */
+  readonly url: v.StringSchema<undefined>;
+  /**
+   * Optional human-readable seller or service name.
+   */
+  readonly serviceName: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+}, undefined>;
+/**
+ * Optional seller resource metadata attached by low-level callers.
+ */
+type MppResource = v.InferOutput<typeof mppResourceSchema>;
+declare const mppActionSchema: v.ObjectSchema<{
+  /**
+   * MPP payment action discriminator.
+   */
+  readonly type: v.LiteralSchema<"mpp", undefined>;
+  /**
+   * Catena account whose wallet authorizes the charge.
+   */
+  readonly accountId: v.StringSchema<undefined>;
+  /**
+   * Serialized seller challenge to authorize.
+   */
+  readonly challenge: v.ObjectSchema<{
+    /**
+     * Seller-issued challenge identifier.
+     */
+    readonly id: v.StringSchema<undefined>;
+    /**
+     * Seller protection space that issued the challenge.
+     */
+    readonly realm: v.StringSchema<undefined>;
+    /**
+     * Supported MPP payment method.
+     */
+    readonly method: v.PicklistSchema<["evm", "usdc"], undefined>;
+    /**
+     * Catena supports MPP charge intents only.
+     */
+    readonly intent: v.LiteralSchema<"charge", undefined>;
+    /**
+     * Base64url-encoded, canonical MPP payment request.
+     */
+    readonly request: v.StringSchema<undefined>;
+    /**
+     * Optional seller description of the charge.
+     */
+    readonly description: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+    /**
+     * Optional seller-declared request-body digest, relayed unchanged.
+     */
+    readonly digest: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+    /**
+     * UTC challenge expiry timestamp.
+     */
+    readonly expires: v.StringSchema<undefined>;
+    /**
+     * Alternate field for the credential when HTTP Authorization is occupied.
+     */
+    readonly header: v.OptionalSchema<v.LiteralSchema<"Payment-Authorization", undefined>, undefined>;
+    /**
+     * Opaque base64url seller state, relayed unchanged.
+     */
+    readonly opaque: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+  }, undefined>;
+  /**
+   * Optional resource binding for low-level callers.
+   */
+  readonly resource: v.OptionalSchema<v.ObjectSchema<{
+    /**
+     * Absolute URL of the paid resource.
+     */
+    readonly url: v.StringSchema<undefined>;
+    /**
+     * Optional human-readable seller or service name.
+     */
+    readonly serviceName: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+  }, undefined>, undefined>;
+}, undefined>;
+/**
+ * Low-level Catena intent action for an MPP charge.
+ */
+type MppAction = v.InferOutput<typeof mppActionSchema>;
+declare const POLICY_OVERRIDE_CAPABILITIES: readonly ["send", "transfer"];
+declare const intentActionSchema: v.UnionSchema<[v.VariantSchema<"method", [v.ObjectSchema<{
+  readonly type: v.LiteralSchema<"send", undefined>;
+  /**
+   * Omit when the current policy allows sends from exactly one account.
+   * Zero or multiple send accounts require a policy change or an explicit id.
+   */
+  readonly accountId: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>, undefined>;
+  /**
+   * Id of one entry in a counterparty's `rails` array (from
+   * `listCounterparties`) — not the counterparty id itself.
+   */
+  readonly counterpartyRailId: v.StringSchema<undefined>;
+  /**
+   * Decimal USD string: "12.50" is $12.50. Never cents or atomic units.
+   */
+  readonly amount: v.StringSchema<undefined>;
+  /**
+   * Internal note stored in Catena.
+   */
+  readonly description: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+  readonly method: v.LiteralSchema<"ach", undefined>;
+  /**
+   * Reference sent with the ACH payment.
+   */
+  readonly memo: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+}, undefined>, v.ObjectSchema<{
+  readonly type: v.LiteralSchema<"send", undefined>;
+  /**
+   * Omit when the current policy allows sends from exactly one account.
+   * Zero or multiple send accounts require a policy change or an explicit id.
+   */
+  readonly accountId: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>, undefined>;
+  /**
+   * Id of one entry in a counterparty's `rails` array (from
+   * `listCounterparties`) — not the counterparty id itself.
+   */
+  readonly counterpartyRailId: v.StringSchema<undefined>;
+  /**
+   * Decimal USD string: "12.50" is $12.50. Never cents or atomic units.
+   */
+  readonly amount: v.StringSchema<undefined>;
+  /**
+   * Internal note stored in Catena.
+   */
+  readonly description: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+  readonly method: v.LiteralSchema<"wire", undefined>;
+  /**
+   * Reference sent with the wire payment.
+   */
+  readonly memo: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+}, undefined>, v.ObjectSchema<{
+  readonly type: v.LiteralSchema<"send", undefined>;
+  /**
+   * Omit when the current policy allows sends from exactly one account.
+   * Zero or multiple send accounts require a policy change or an explicit id.
+   */
+  readonly accountId: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>, undefined>;
+  /**
+   * Id of one entry in a counterparty's `rails` array (from
+   * `listCounterparties`) — not the counterparty id itself.
+   */
+  readonly counterpartyRailId: v.StringSchema<undefined>;
+  /**
+   * Decimal USD string: "12.50" is $12.50. Never cents or atomic units.
+   */
+  readonly amount: v.StringSchema<undefined>;
+  /**
+   * Internal note stored in Catena.
+   */
+  readonly description: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+  readonly method: v.LiteralSchema<"on-chain", undefined>;
+  /**
+   * @deprecated Not sent to the blockchain. Use `description` for an internal
+   *   note.
+   */
+  readonly memo: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+}, undefined>], undefined>, v.ObjectSchema<{
+  readonly type: v.LiteralSchema<"transfer", undefined>;
+  readonly accountId: v.StringSchema<undefined>;
+  readonly toAccountId: v.StringSchema<undefined>;
+  /**
+   * Decimal USD string: "12.50" is $12.50. Never cents or atomic units.
+   */
+  readonly amount: v.StringSchema<undefined>;
+  readonly memo: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+  readonly description: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+}, undefined>, v.UnionSchema<[v.ObjectSchema<{
+  readonly type: v.LiteralSchema<"create_counterparty", undefined>;
+  readonly name: v.StringSchema<undefined>;
+  readonly email: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+  readonly rail: v.NonOptionalSchema<v.UnknownSchema, undefined>;
+}, undefined>, v.ObjectSchema<{
+  readonly type: v.LiteralSchema<"create_counterparty", undefined>;
+  readonly name: v.StringSchema<undefined>;
+  /**
+   * Required when no rail is supplied. This records contact information only;
+   * creating the counterparty does not send an email.
+   */
+  readonly email: v.StringSchema<undefined>;
+}, undefined>], undefined>, v.ObjectSchema<{
+  readonly type: v.LiteralSchema<"request_counterparty_details", undefined>;
+  readonly counterpartyId: v.StringSchema<undefined>;
+  readonly methods: v.SchemaWithPipe<readonly [v.ObjectSchema<{
+    readonly bank: v.BooleanSchema<undefined>;
+    readonly wallet: v.BooleanSchema<undefined>;
+  }, undefined>, v.CheckAction<{
+    bank: boolean;
+    wallet: boolean;
+  }, "Select at least one payment method to request">]>;
+}, undefined>, v.ObjectSchema<{
+  readonly type: v.LiteralSchema<"x402", undefined>;
+  readonly accountId: v.StringSchema<undefined>;
+  readonly paymentRequirements: v.LooseObjectSchema<{
+    readonly scheme: v.StringSchema<undefined>;
+    readonly network: v.StringSchema<undefined>;
+    readonly asset: v.StringSchema<undefined>;
+    readonly amount: v.StringSchema<undefined>;
+    readonly payTo: v.StringSchema<undefined>;
+    readonly maxTimeoutSeconds: v.NumberSchema<undefined>;
+  }, undefined>;
+  readonly resource: v.OptionalSchema<v.LooseObjectSchema<{
+    readonly url: v.StringSchema<undefined>;
+    /**
+     * Human-readable name of the paid service, when the challenge advertises
+     * one — a suggested name when creating the counterparty. Parsed leniently:
+     * a malformed value (non-string, or over-long) drops to undefined rather
+     * than failing the whole challenge parse, which would silently downgrade
+     * an otherwise-payable 402 to an unpaid passthrough.
+     */
+    readonly serviceName: v.SchemaWithFallback<v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>, undefined>;
+  }, undefined>, undefined>;
+  /**
+   * Optional caller-supplied authorization; the server mints its own when
+   * absent.
+   */
+  readonly authorization: v.OptionalSchema<v.ObjectSchema<{
+    /**
+     * Wallet address the transfer draws from. Must be the paying account's
+     * wallet address; the server rejects any other value. A mixed-case
+     * spelling must carry a valid EIP-55 checksum; all-lowercase is accepted.
+     */
+    readonly from: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "Expected a 20-byte hex address">]>;
+    /**
+     * Recipient address. Must equal the requirement's `payTo` (case may
+     * differ) and resolve to a saved counterparty wallet rail. A mixed-case
+     * spelling must carry a valid EIP-55 checksum; all-lowercase is accepted.
+     */
+    readonly to: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "Expected a 20-byte hex address">]>;
+    /**
+     * Amount in atomic token units as a canonical decimal string (no leading
+     * zeros). Must equal the requirement's `amount`.
+     */
+    readonly value: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MaxLengthAction<string, 78, undefined>, v.RegexAction<string, "Expected a canonical decimal integer string">]>;
+    /**
+     * Unix seconds the authorization becomes valid, as a canonical decimal
+     * string. Must not be in the future.
+     */
+    readonly validAfter: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MaxLengthAction<string, 78, undefined>, v.RegexAction<string, "Expected a canonical decimal integer string">]>;
+    /**
+     * Unix seconds the authorization expires, as a canonical decimal string.
+     * Bounded by the requirement's `maxTimeoutSeconds` and must leave time to
+     * settle.
+     */
+    readonly validBefore: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MaxLengthAction<string, 78, undefined>, v.RegexAction<string, "Expected a canonical decimal integer string">]>;
+    /**
+     * 32-byte hex nonce (`0x` + 64 hex characters), unique per payment for
+     * the wallet. A nonce ever used by an earlier payment is refused; retry
+     * with a fresh one.
+     */
+    readonly nonce: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "Expected a 32-byte hex nonce">]>;
+  }, undefined>, undefined>;
+  /**
+   * The seller's signed offer for this requirement (x402 Offer & Receipt
+   * extension), relayed verbatim; the server verifies it and stores it as
+   * payment evidence. The x402 fetch wrapper attaches it automatically when
+   * the 402 challenge carries one.
+   */
+  readonly signedOffer: v.OptionalSchema<v.VariantSchema<"format", [v.LooseObjectSchema<{
+    readonly format: v.LiteralSchema<"eip712", undefined>;
+    readonly acceptIndex: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
+    readonly payload: v.RecordSchema<v.StringSchema<undefined>, v.UnknownSchema, undefined>;
+    readonly signature: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "Expected a 65-byte hex signature">]>;
+  }, undefined>, v.LooseObjectSchema<{
+    readonly format: v.LiteralSchema<"jws", undefined>;
+    readonly acceptIndex: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
+    readonly signature: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MaxLengthAction<string, number, undefined>, v.RegexAction<string, "Expected a JWS compact serialization">]>;
+  }, undefined>], undefined>, undefined>;
+}, undefined>, v.ObjectSchema<{
+  /**
+   * MPP payment action discriminator.
+   */
+  readonly type: v.LiteralSchema<"mpp", undefined>;
+  /**
+   * Catena account whose wallet authorizes the charge.
+   */
+  readonly accountId: v.StringSchema<undefined>;
+  /**
+   * Serialized seller challenge to authorize.
+   */
+  readonly challenge: v.ObjectSchema<{
+    /**
+     * Seller-issued challenge identifier.
+     */
+    readonly id: v.StringSchema<undefined>;
+    /**
+     * Seller protection space that issued the challenge.
+     */
+    readonly realm: v.StringSchema<undefined>;
+    /**
+     * Supported MPP payment method.
+     */
+    readonly method: v.PicklistSchema<["evm", "usdc"], undefined>;
+    /**
+     * Catena supports MPP charge intents only.
+     */
+    readonly intent: v.LiteralSchema<"charge", undefined>;
+    /**
+     * Base64url-encoded, canonical MPP payment request.
+     */
+    readonly request: v.StringSchema<undefined>;
+    /**
+     * Optional seller description of the charge.
+     */
+    readonly description: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+    /**
+     * Optional seller-declared request-body digest, relayed unchanged.
+     */
+    readonly digest: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+    /**
+     * UTC challenge expiry timestamp.
+     */
+    readonly expires: v.StringSchema<undefined>;
+    /**
+     * Alternate field for the credential when HTTP Authorization is occupied.
+     */
+    readonly header: v.OptionalSchema<v.LiteralSchema<"Payment-Authorization", undefined>, undefined>;
+    /**
+     * Opaque base64url seller state, relayed unchanged.
+     */
+    readonly opaque: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+  }, undefined>;
+  /**
+   * Optional resource binding for low-level callers.
+   */
+  readonly resource: v.OptionalSchema<v.ObjectSchema<{
+    /**
+     * Absolute URL of the paid resource.
+     */
+    readonly url: v.StringSchema<undefined>;
+    /**
+     * Optional human-readable seller or service name.
+     */
+    readonly serviceName: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+  }, undefined>, undefined>;
+}, undefined>, v.ObjectSchema<{
+  readonly type: v.LiteralSchema<"policy_override", undefined>;
+  readonly operations: v.SchemaWithPipe<readonly [v.ArraySchema<v.UnionSchema<[v.StrictObjectSchema<{
+    readonly type: v.LiteralSchema<"increase_limit", undefined>;
+    readonly accountId: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
+    readonly capability: v.PicklistSchema<readonly ["send", "transfer"], undefined>;
+    readonly limitType: v.PicklistSchema<["per_transaction_amount", "daily_amount", "weekly_amount", "monthly_amount"], undefined>;
+    readonly newLimit: v.StrictObjectSchema<{
+      readonly amount: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, undefined>, v.CheckAction<string, "The amount must be greater than zero">]>;
+      readonly assetId: v.LiteralSchema<"USD", undefined>;
+    }, undefined>;
+  }, undefined>, v.StrictObjectSchema<{
+    readonly type: v.LiteralSchema<"increase_limit", undefined>;
+    readonly accountId: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
+    readonly capability: v.PicklistSchema<readonly ["send", "transfer"], undefined>;
+    readonly limitType: v.PicklistSchema<["hourly_count", "daily_count"], undefined>;
+    readonly newLimit: v.StrictObjectSchema<{
+      readonly count: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>;
+    }, undefined>;
+  }, undefined>], undefined>, undefined>, v.MinLengthAction<({
+    type: "increase_limit";
+    accountId: string;
+    capability: "send" | "transfer";
+    limitType: "daily_amount" | "monthly_amount" | "per_transaction_amount" | "weekly_amount";
+    newLimit: {
+      amount: string;
+      assetId: "USD";
+    };
+  } | {
+    type: "increase_limit";
+    accountId: string;
+    capability: "send" | "transfer";
+    limitType: "daily_count" | "hourly_count";
+    newLimit: {
+      count: number;
+    };
+  })[], 1, undefined>, v.MaxLengthAction<({
+    type: "increase_limit";
+    accountId: string;
+    capability: "send" | "transfer";
+    limitType: "daily_amount" | "monthly_amount" | "per_transaction_amount" | "weekly_amount";
+    newLimit: {
+      amount: string;
+      assetId: "USD";
+    };
+  } | {
+    type: "increase_limit";
+    accountId: string;
+    capability: "send" | "transfer";
+    limitType: "daily_count" | "hourly_count";
+    newLimit: {
+      count: number;
+    };
+  })[], 10, undefined>, v.CheckAction<({
+    type: "increase_limit";
+    accountId: string;
+    capability: "send" | "transfer";
+    limitType: "daily_amount" | "monthly_amount" | "per_transaction_amount" | "weekly_amount";
+    newLimit: {
+      amount: string;
+      assetId: "USD";
+    };
+  } | {
+    type: "increase_limit";
+    accountId: string;
+    capability: "send" | "transfer";
+    limitType: "daily_count" | "hourly_count";
+    newLimit: {
+      count: number;
+    };
+  })[], "Each account, capability, and limit type may appear only once">]>;
+  /**
+   * One minute to seven days; the clock starts at approval.
+   */
+  readonly durationSeconds: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 60, undefined>, v.MaxValueAction<number, number, undefined>]>;
+  readonly reason: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 280, undefined>]>;
+}, undefined>], undefined>;
+type IntentAction = v.InferOutput<typeof intentActionSchema>;
+//#endregion
+//#region src/client.d.ts
+/**
+ * Non-OK API response. `code` is the API's stable error code — branch on it,
+ * not on message prose. The code is also embedded in the message so hosts
+ * that only print `error.message` still surface it.
+ * Field explanations are included in the message and preserved on `fields`.
+ */
+declare class ApiError extends Error {
+  readonly status: number;
+  readonly code: string | undefined;
+  readonly details: Record<string, unknown> | undefined;
+  /**
+   * Validation explanations keyed by request field path, when present.
+   * The `request` key represents a request-wide issue rather than a field;
+   * its explanation appears in `message` without a field-path prefix.
+   */
+  readonly fields: Record<string, string> | undefined;
+  constructor(status: number, message: string, code?: string, details?: Record<string, unknown>, fields?: Record<string, string>);
+}
+/**
+ * An HTTP exchange exceeded the client's configured deadline. The deadline
+ * starts when the signed request is dispatched and remains active until the
+ * response body has been fully consumed and validated. This means the SDK
+ * stopped waiting, not that the server did no work.
+ */
+declare class TimeoutError extends Error {
+  readonly timeoutMs: number;
+  constructor(timeoutMs: number);
+}
+/**
+ * A `submitIntent` failure after the intent was created. `outcome` is the
+ * contract — callers branch on effect, never on which internal phase failed:
+ *
+ * - `"not-submitted"`: nothing happened server-side after create; no money moved.
+ *   Recovery is a new `submitIntent` invocation with a new idempotency key,
+ *   typically after fixing the signing credential. Omit `idempotencyKey` to
+ *   generate one, or supply a different value; do not reuse the original key.
+ *   Reusing it finds the stranded intent and can return a 409 rather than
+ *   restart signing. The stranded intent settles or expires server-side.
+ * - `"unknown"`: the failure landed where the server may have already acted. Poll
+ *   `getIntent(intentId)` to a terminal status — completed means it succeeded;
+ *   submit again only after blocked or failed. A blind re-submit risks a double
+ *   effect.
+ *
+ * `cause` carries the raw underlying error for diagnostics, not contract.
+ * Its summary is embedded in the message so hosts that print only
+ * `error.message` keep the actionable detail — e.g. which key a signer
+ * mismatch names.
+ */
+declare class IntentSubmitError extends Error {
+  readonly intentId: string;
+  readonly outcome: "not-submitted" | "unknown";
+  constructor(params: {
+    intentId: string;
+    outcome: "not-submitted" | "unknown";
+    cause: unknown;
+  });
+}
+/**
+ * Transport signature: the callable subset of the global `fetch`. Deliberately
+ * structural rather than `typeof globalThis.fetch` — that alias resolves
+ * against the consumer's platform types, where fetch may carry extra statics
+ * (e.g. Bun's `fetch.preconnect`) that custom transports and the x402 wrapper
+ * do not have. Exported so hosts can type a custom implementation and name
+ * what `wrapFetchWithX402Payment` returns.
+ */
+type FetchLike = (input: string | URL | Request, init?: RequestInit) => Promise<Response>;
+interface CatenaClientOptions {
+  /**
+   * API origin, defaulting to the hosted Catena API. Override for local
+   * development or a self-hosted deployment.
+   */
+  baseUrl?: string;
+  /**
+   * P-256 private key of a linked agent credential, 64 hex characters (see
+   * `@catena/sdk/keypair` to generate one). The public half is derived, so a
+   * corrupt value throws here instead of failing with 401s at the bank. The
+   * key signs every request (RFC 9421) and co-signs wallet sends during
+   * `submitIntent`. When this option is `undefined`, the client reads
+   * `CATENA_SECRET_KEY` from the process environment. An explicit value always
+   * wins and is validated even when it is empty.
+   */
+  privateKeyHex?: string;
+  /**
+   * Signature-Agent identity URL, defaulting to a URL derived from the
+   * key's thumbprint. The default changes on key rotation; pass a stable
+   * URL (an agent page, a self-hosted JWKS) when the identity must survive it.
+   */
+  identityUrl?: string;
+  /**
+   * Caller identification prepended to the User-Agent. Telemetry only —
+   * never carries authority.
+   */
+  appInfo?: AppInfo;
+  /**
+   * Merged into every request; per-request headers win.
+   */
+  defaultHeaders?: Record<string, string>;
+  /**
+   * Transport override, defaulting to the global `fetch`. Injected so hosts can
+   * route requests through a proxy or instrumentation layer, and so tests can
+   * pass a stub instead of patching `globalThis.fetch`.
+   */
+  fetch?: FetchLike;
+  /**
+   * Deadline in milliseconds for each HTTP exchange, from dispatch through
+   * complete response-body parsing. Defaults to 80,000ms. Multi-exchange
+   * operations such as `submitIntent` receive a fresh deadline per exchange.
+   * Must be a positive integer no greater than 2,147,483,647.
+   */
+  timeout?: number;
+}
+declare class CatenaClient {
+  #private;
+  constructor(opts: CatenaClientOptions & {
+    privateKeyHex: string;
+  });
+  whoami(): Promise<Agent>;
+  /**
+   * Send free-form feedback about this integration to the bank's operators —
+   * an in-band channel for agents to report friction, confusing errors, or
+   * missing capabilities. Stored for humans to read; never a protocol or
+   * money effect.
+   */
+  submitFeedback(body: string): Promise<void>;
+  getPolicy(): Promise<Policy>;
+  listAccounts(): Promise<AccountsResponse>;
+  getAccountBalance(accountId: string): Promise<AccountBalanceResponse>;
+  listAccountTransactions(accountId: string, params?: AccountTransactionsParams): Promise<AccountTransactionsResponse>;
+  getAccountDepositAddress(accountId: string, params: AccountDepositAddressParams): Promise<AccountDepositAddressResponse>;
+  listCounterparties(params?: CounterpartiesParams): Promise<CounterpartiesResponse>;
+  /**
+   * Submit an intent and run its full lifecycle: create, and when the server
+   * requires a co-signature, stamp and submit it. Returns the final intent
+   * view from the submit response itself — no follow-up `getIntent` needed.
+   * The result is a disposition, not a guarantee of execution — the intent
+   * may be completed, blocked, or parked pending approval; branch on `status`
+   * and read `reasons`.
+   *
+   * Generates a fresh idempotency key for this invocation when none is
+   * supplied. Pass an explicit `idempotencyKey` when separate invocations or
+   * processes must identify the same logical operation. The server does not
+   * infer operation identity from matching request payloads.
+   *
+   * Errors: create-phase failures propagate unwrapped — `ApiError` for
+   * non-OK responses (callers depend on its `code`), `TimeoutError` when the
+   * exchange deadline expires, and raw transport/signing errors otherwise.
+   * Once the intent exists, failures surface as `IntentSubmitError` — see its
+   * outcome contract.
+   */
+  submitIntent(params: {
+    action: IntentAction;
+    idempotencyKey?: string;
+  }): Promise<IntentResult>;
+  getIntent(id: string): Promise<IntentResult>;
+  /**
+   * Finish a send that crossed chains, once `crossChain.nextStep` reads
+   * "continue": prepares and signs the send to the counterparty on the
+   * destination network. Gas is paid by Catena. A destination the provider does
+   * not sponsor yet is refused with `wallet_send_action_not_yet_enabled`; the
+   * intent stays at "continue" and the call can be made again later.
+   *
+   * A payment a person had to approve is NOT continued here. Once it is
+   * approved an admin finishes it, and this call refuses it with
+   * `movement_admin_completes_payment`; `movement.nextStep` stays "wait" and
+   * resolves to "done" or "blocked" on its own. Resending the original request
+   * does not finish it either — that hands back the payment's intent, or tells
+   * you to read it, never a new signature.
+   *
+   * It continues the same intent, so no second intent, spend or approval is
+   * involved, and the result is the intent view after the signature, the same
+   * shape `getIntent(...)` serves.
+   *
+   * `action` is the one you originally submitted. It is compared only against
+   * a movement stamp, and a continuation now only finishes a send that crossed
+   * chains, which carries none, so today it is accepted and not checked.
+   *
+   * Errors: failures in the continue exchange propagate unwrapped — `ApiError`
+   * for non-OK responses (the refusals above among them), `TimeoutError` when
+   * the exchange deadline expires, and raw transport, signing and
+   * response-parsing errors otherwise. Once the continuation is prepared,
+   * failures while stamping or signing it surface as `IntentSubmitError` with
+   * outcome `"not-submitted"`; from the first dispatched byte they surface
+   * with outcome `"unknown"`, and `getIntent(...)` is the reconciliation
+   * handle.
+   */
+  continueIntent(params: {
+    intentId: string;
+    idempotencyKey?: string;
+    action?: IntentAction;
+  }): Promise<IntentResult>;
+  /**
+   * Permanently sever this agent link: the server revokes the link's active
+   * auth keys, so every request signed with this credential fails from then
+   * on. Irreversible — recovery is a new linking ceremony in the host app.
+   */
+  unlinkAgent(): Promise<void>;
+  /**
+   * Report an on-chain settlement transaction for a completed protocol
+   * payment. This is an untrusted hint the server stores for ops/debugging and
+   * to narrow the chain verifier's log range; it is never a money effect. The
+   * managed x402 and MPP fetch wrappers call this automatically when their
+   * paid response carries a valid EVM transaction reference.
+   */
+  reportSettlement(params: {
+    intentId: string;
+    txHash: string;
+    /**
+     * The seller's signed receipt from the paid retry's `PAYMENT-RESPONSE`
+     * extensions (x402 Offer & Receipt extension), relayed verbatim; the
+     * server verifies it and stores it as payment evidence. The x402 fetch
+     * wrapper attaches it automatically when the seller sends one.
+     */
+    receipt?: X402SignedReceipt;
+  }): Promise<void>;
+}
+/**
+ * Create a client for the Catena agent API from a linked agent's P-256 private
+ * key (see `@catena/sdk/keypair` to generate one). Pass `privateKeyHex`
+ * explicitly or omit it to read `CATENA_SECRET_KEY` from the process
+ * environment; an explicit value always wins. This factory is the only way to
+ * construct a client; `CatenaClient` is exported as a type only. Throws
+ * {@link InvalidKeyError} immediately when neither credential source is
+ * configured or the resolved key is malformed; throws `TypeError` when
+ * `timeout` is not an integer between 1 and 2,147,483,647 milliseconds. Network
+ * traffic starts with the first method call.
+ */
+declare function createCatenaClient(options?: CatenaClientOptions): CatenaClient;
+//#endregion
+export { X402SignedOffer as $, ExtensibleString as A, OnchainNetworkInput as B, COUNTERPARTY_RULE_MODES as C, CounterpartiesResponse as D, CounterpartiesParams as E, Movement as F, Policy as G, POLICY_OVERRIDE_CAPABILITIES as H, MppAction as I, WalletCounterpartyRail as J, SEND_METHODS as K, MppChallenge as L, IntentAction as M, IntentResult as N, Counterparty as O, MOVEMENT_NEXT_STEPS as P, AppInfo as Q, MppResource as R, COUNTERPARTY_ACTIONS as S, CROSS_CHAIN_STATES as T, POLICY_RULE_ACTIONS as U, POLICY_CAPABILITIES as V, POLICY_RULE_TYPES as W, X402PaymentRequirements as X, X402Authorization as Y, X402Resource as Z, AccountDepositAddressResponse as _, IntentSubmitError as a, AccountsResponse as b, ACCOUNT_AGGREGATION_SCOPES as c, ACCOUNT_TRANSACTION_MOVEMENT_STATUSES as d, X402SignedReceipt as et, ACCOUNT_TRANSACTION_STATUSES as f, AccountDepositAddressParams as g, AccountBalanceResponse as h, FetchLike as i, INTENT_ACTION_TYPES as j, CrossChainSend as k, ACCOUNT_DEPOSIT_ADDRESS_SOURCES as l, ACTOR_AGGREGATION_SCOPES as m, CatenaClient as n, TimeoutError as o, ACCOUNT_TRANSACTION_TYPES as p, SendMethod as q, CatenaClientOptions as r, createCatenaClient as s, ApiError as t, ACCOUNT_TRANSACTION_METHODS as u, AccountTransactionsParams as v, CROSS_CHAIN_NEXT_STEPS as w, Agent as x, AccountTransactionsResponse as y, OnchainAssetInput as z };