@catena/sdk 0.0.0-alpha-20260724191736

package/dist/client-DZHdFs_y.d.mts

@@ -0,0 +1,566 @@
+import * as v from "valibot";
+
+//#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
+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>;
+  readonly operatorEmail: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+}, undefined>;
+type Agent = v.InferOutput<typeof agentSchema>;
+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.PicklistSchema<["open", "restricted"], undefined>;
+    readonly allowedCounterparties: v.OptionalSchema<v.ArraySchema<v.StringSchema<undefined>, undefined>, undefined>;
+    readonly createAction: v.OptionalSchema<v.PicklistSchema<["allow", "block", "require_approval"], undefined>, 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.PicklistSchema<["query_balance", "read", "send", "transfer"], undefined>;
+    readonly accountId: v.StringSchema<undefined>;
+    readonly rules: v.ArraySchema<v.ObjectSchema<{
+      readonly id: v.StringSchema<undefined>;
+      readonly ruleType: v.PicklistSchema<["per_transaction_amount", "daily_amount", "weekly_amount", "monthly_amount", "hourly_count", "daily_count"], undefined>;
+      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.PicklistSchema<["block", "require_approval"], undefined>;
+      readonly requiredApprovals: v.NumberSchema<undefined>;
+      readonly accountAggregationScope: v.PicklistSchema<["per_account", "across_accounts"], undefined>;
+      readonly actorAggregationScope: v.PicklistSchema<["per_agent", "per_policy"], undefined>;
+      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>;
+}, 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` (what a send is checked against) is `total` minus reserved
+   * funds. Absent only from API deployments that predate the field.
+   */
+  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>;
+  }, undefined>, undefined>;
+}, undefined>;
+type AccountBalanceResponse = v.InferOutput<typeof accountBalanceResponseSchema>;
+declare const accountTransactionsResponseSchema: v.ObjectSchema<{
+  readonly accountId: v.StringSchema<undefined>;
+  readonly transactions: v.ArraySchema<v.ObjectSchema<{
+    readonly id: v.StringSchema<undefined>;
+    readonly type: v.PicklistSchema<["operator-send", "operator-transfer", "operator-deposit", "operator-refund", "microdeposit"], undefined>;
+    /**
+     * 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.PicklistSchema<["pending", "processing", "completed", "failed", "reversed"], undefined>;
+    readonly movementStatus: v.PicklistSchema<["initiated", "provider_pending", "processing", "completed", "failed", "reversed", "manual_review"], undefined>;
+    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>;
+    readonly counterpartyName: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+    readonly method: v.OptionalSchema<v.PicklistSchema<["ach", "wire", "on-chain"], undefined>, 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 accountDepositAddressResponseSchema: v.ObjectSchema<{
+  readonly accountId: v.StringSchema<undefined>;
+  readonly address: v.StringSchema<undefined>;
+  readonly liquidationAddressId: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+  readonly source: v.PicklistSchema<["wallet", "liquidation"], undefined>;
+}, 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" | (string & {});
+type OnchainAssetInput = "usdc" | (string & {});
+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`/`network`, bank rails carry `bankName`/`accountNumber`),
+ * and a server that later adds a new rail type must not break older clients.
+ */
+declare const counterpartySchema: v.ObjectSchema<{
+  readonly id: v.StringSchema<undefined>;
+  readonly name: v.StringSchema<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>;
+    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 with a wallet rail at this address.
+   */
+  address?: `0x${string}` | undefined;
+  /**
+   * Only counterparties with a wallet rail on this network.
+   */
+  network?: OnchainNetworkInput | undefined;
+};
+declare const wireIntentResultSchema: v.ObjectSchema<{
+  readonly id: v.StringSchema<undefined>;
+  readonly type: v.PicklistSchema<["send", "transfer", "wallet_send", "create_counterparty", "x402"], undefined>;
+  /**
+   * Disposition of the intent:
+   *
+   * - "pending" — accepted but not yet executing, typically parked for a human
+   *   approval; `reasons` says why and `expiresAt` when it lapses.
+   * - "processing" — accepted and in progress. Executing intents advance on their
+   *   own; poll `getIntent`. An approved x402 payment instead rests here until
+   *   the paid request is re-run — polling never advances it — and `expiresAt`
+   *   is when that grant lapses.
+   * - "completed" — the action succeeded: money moved for send, transfer, and
+   *   wallet_send; for x402 the payment authorization was delivered
+   *   (`data.x402.paymentSignature`), 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 x402 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>;
+  /**
+   * Intent-type-specific payload. A completed x402 intent carries the encoded
+   * retry header at `data.x402.paymentSignature`.
+   */
+  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>;
+  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>;
+  }, 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 SEND_METHODS: readonly ["ach", "wire", "on-chain"];
+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 intentActionSchema: v.VariantSchema<"type", [v.ObjectSchema<{
+  readonly type: v.LiteralSchema<"send", undefined>;
+  readonly accountId: v.StringSchema<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>;
+  readonly method: v.PicklistSchema<readonly ["ach", "wire", "on-chain"], undefined>;
+  readonly memo: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+  readonly description: v.OptionalSchema<v.StringSchema<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.ObjectSchema<{
+  readonly type: v.LiteralSchema<"create_counterparty", undefined>;
+  readonly name: v.StringSchema<undefined>;
+  readonly email: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+  readonly rail: v.UnknownSchema;
+}, 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>;
+}, 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.
+ */
+declare class ApiError extends Error {
+  readonly status: number;
+  readonly code: string | undefined;
+  constructor(status: number, message: string, code?: string);
+}
+/**
+ * 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` with a fresh explicit `idempotencyKey`
+ *   (without one, the server's content-derived default replays the stranded
+ *   intent), typically after fixing the signing credential; 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`.
+   */
+  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;
+}
+declare class CatenaClient {
+  #private;
+  constructor(opts: CatenaClientOptions);
+  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`.
+   *
+   * The server derives a replay-safe default idempotency key when none is
+   * supplied. Pass `idempotencyKey` only to intentionally submit a distinct
+   * duplicate with the same details.
+   *
+   * Errors: create-phase failures propagate unwrapped — `ApiError` for
+   * non-OK responses (callers depend on its `code`), 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>;
+  /**
+   * 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 the facilitator's on-chain settlement tx for a completed x402
+   * payment, decoded from the paid retry's PAYMENT-RESPONSE header. An
+   * untrusted hint the server stores for ops/debugging and to narrow the
+   * chain verifier's log range; never a money effect. The x402 fetch wrapper
+   * calls this automatically.
+   */
+  reportSettlement(params: {
+    intentId: string;
+    txHash: string;
+  }): 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). This factory is
+ * the only way to construct a client; `CatenaClient` is exported as a type
+ * only. Throws immediately on a malformed key; network traffic starts with
+ * the first method call.
+ */
+declare function createCatenaClient(options: CatenaClientOptions): CatenaClient;
+//#endregion
+export { SendMethod as C, AppInfo as E, SEND_METHODS as S, X402Resource as T, IntentAction as _, IntentSubmitError as a, OnchainNetworkInput as b, AccountDepositAddressParams as c, AccountTransactionsResponse as d, AccountsResponse as f, Counterparty as g, CounterpartiesResponse as h, FetchLike as i, AccountDepositAddressResponse as l, CounterpartiesParams as m, CatenaClient as n, createCatenaClient as o, Agent as p, CatenaClientOptions as r, AccountBalanceResponse as s, ApiError as t, AccountTransactionsParams as u, IntentResult as v, X402PaymentRequirements as w, Policy as x, OnchainAssetInput as y };