@botanary/agent 0.1.0-alpha.1

package/dist/generated/schema.d.ts

@@ -0,0 +1,2903 @@
+export interface paths {
+    "/agents/pair": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Begin an agent pairing - the agent signs to prove it holds the key
+         * @description Public endpoint (no session required). The agent signs over `(code || timestamp)`, proving it holds the private key for the claimed public key. We verify the signature recovers to that key and hold the proof until the account owner claims it via `POST /agents/{code}/claim`.
+         *     The signature is the load-bearing check: a pairing code seen over someone's shoulder is worthless on its own. **Claiming binds THE AGENT THAT SIGNED, never the person who typed the code.** That is what makes agent pairing password-free and rotation-free (design §5-41): there is no secret to write down, type into the wrong window, or rotate later.
+         *     Codes are single-use and expire in minutes; the timestamp window is ±5 minutes so a captured proof cannot be replayed later. Pending pairings are in-memory coordination state (not persisted) - a backend restart loses pending pairings, which simply means the agent regenerates a code and signs again.
+         *     Refused with 400 when: - The timestamp is outside the ±5-minute window (too old or too far in the future). - The signature does not recover to the claimed public key (the proof belongs to a different agent). - The signature is over a different code than the one claimed (a proof from elsewhere).
+         */
+        post: operations["pairAgent"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/agents/session/nonce": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Issue a nonce for an agent to sign, to mint a session
+         * @description Public endpoint (no session required). Returns a fresh, single-use, server-issued nonce for the named agent address. The agent signs this exact nonce with its private key and exchanges the signature for a session token via `POST /agents/session`. The nonce expires after a few minutes if unused. Challenges are shared across API replicas and bind the connected agent and its authentication generation. A newer challenge for the address replaces the prior challenge.
+         */
+        post: operations["issueAgentSessionNonce"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/agents/session": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Mint an agent session by signing a server-issued nonce
+         * @description Public endpoint (no session required). Exchanges a signature over the nonce from `POST /agents/session/nonce` for a short-lived bearer token (`ags_...`) that grants access to every `@AgentAllowed()` route, scoped to whichever account this agent is connected to (`POST /agents/{code}/claim`). Refused with 401 when the nonce is missing/expired, the signature does not recover to this agent's key, or the address names no LIVE connected agent (never connected, or disconnected). Key verification precedes atomic challenge consumption and hash-only session creation. Concurrent replay has one winner. Disablement invalidates sessions and earlier authentication challenges across replicas and process restarts.
+         */
+        post: operations["mintAgentSession"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/agents/me": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * An agent's own question - who am I, what account, and what may I do
+         * @description Requires an agent session (`@AgentAllowed()`) - an owner session gets 404, since the question ("what can THIS agent do") has no owner-side referent. Answers three things at once: this agent's own identity (id/name/address/fingerprint/connectedAt, mirroring `ConnectedAgent`), the account it is bound to, and its live grant if one exists - including the `permissionId` a delegated spend needs, the grant's bounds (`policySet`) and plain-language sentence (`humanSummary`), and its current `status`.
+         *     When the owner has granted this agent nothing yet, `grant` is `null` - an honest, explicit answer (not an error, not an empty object): the agent can still read and draft under every `@AgentAllowed()` route, and every attempt to spend is refused for lack of authority, never silently.
+         *     This is a convenience read, never the check - the only boundary that counts is on-chain. An agent (or whoever built it) can use this to learn its bounds WITHOUT hitting them first, but a bug or a lie in this response changes nothing about what the agent can actually get away with.
+         */
+        get: operations["getAgentSelf"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/agents/requests": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * List agent requests for this account or agent
+         * @description The owner sees all requests for their account. An agent session sees only its own requests. Requests expire in minutes; an expired request stays in the list marked `expired` rather than vanishing.
+         */
+        get: operations["listAgentRequests"];
+        put?: never;
+        /**
+         * Raise a request when hitting a delegation bound
+         * @description The agent has attempted an action that exceeds its delegated grant. Instead of a bare decline, it raises a request carrying WHICH bound was crossed (§6-40) - derived from the agent's live grant and the proposed calls, never a generic reason. An agent with no grant at all gets `no_policies_set`, never a guessed cap; calls this cannot decode into a token/amount/recipient get `malformed_call`, never a plausible guess. A revoked agent cannot raise requests - its session is already gone (§6-38).
+         *     Refused with 400 if the proposed calls are already inside the grant - there is nothing to request, since the action can be performed directly under the delegation.
+         */
+        post: operations["raiseAgentRequest"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/balance": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Get the unified multi-stablecoin balance (presentation-only)
+         * @description A single unified balance over the owner's own per-token holdings, with each token carrying its live peg status. **Presentation + spendability only - never pooled or custodial** (FR-S1).
+         */
+        get: operations["getUnifiedBalance"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/chains": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** List supported chains */
+        get: operations["listChains"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/gas/methods": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * List gas methods with per-method balances (FR-8)
+         * @description Available gas methods for a chain. At least one of `chainId` (EVM) or `key` (Solana/Stellar) is required - gas availability is per-chain (USDC gas exists only on Base and Arbitrum), so a request with neither is rejected rather than answered about some default chain. If both are supplied, `key` takes priority. Every action MUST remain executable at native balance = 0 via sponsored / USDC / USDT.
+         */
+        get: operations["listGasMethods"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/account": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** Get the owner's smart account */
+        get: operations["getAccount"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/delegations/{delegationId}/actions": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /** @example d1 */
+                delegationId: components["parameters"]["DelegationId"];
+            };
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Build a bounded delegated action (the binding-boundary demonstration)
+         * @description Builds an UNSIGNED Smart Sessions op - a bounded transfer performed with this delegation's **session key** (not the owner). The op runs raw Kernel `execute` under the SS validator lane; Smart Sessions re-checks it against the granted policies in its validation phase. In-scope executes; out-of-scope (wrong recipient / over the per-action or cumulative cap) is rejected pre-inclusion. The client signs the returned hash with the session key it holds and relays via `POST /userops`. The API never signs.
+         *     **`@AgentAllowed()`** - this is the connected agent's own build lane (Flow 7c: an outside agent proposing a payment under its grant), the ONLY lane that builds in the session nonce key with fixed native gas a session-key signature can actually validate. An agent session may only build against the delegation that names ITS OWN address as `delegateeAddress` - naming a *different* agent's delegation id is refused with 403, not merely refused on-chain later (§6-34: "A grant names one agent, and no other can draw on it"). An owner session is unaffected: it may still build against any delegation on its own account, exactly as before.
+         */
+        post: operations["buildDelegatedAction"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/delegations/{delegationId}/actions/exact": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Build an agent action using exact base units
+         * @description Requires the grant-bound agent session. The account ID, account address, chain and asset are explicit and must match the stored delegation. Native gas only. App keys and console/owner sessions are refused. On-chain capabilities remain testnet-only; this endpoint does not create a grant.
+         */
+        post: operations["buildExactDelegatedAction"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/userops": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Relay a client-signed UserOp to the bundler
+         * @description The single relay boundary. Accepts a `SignedUserOp` (the client attached the owner's, or a connected agent's own session key's, signature to a previously built op) and submits it to the bundler/paymaster. Returns a receipt to poll. **This is availability, never authority** - the server cannot alter the signed op's effect, and the on-chain policy bounds it regardless.
+         *     **`@AgentAllowed()`** - a connected agent relays here too, signing with its own session key (e.g. after `POST /delegations/{id}/actions`). This route never interprets or authorizes what the op DOES; it only forwards a signed payload, so opening it to an agent adds no new authority - a signature over the wrong session key fails Smart Sessions' own on-chain check exactly as an owner op signed by the wrong EOA already does.
+         */
+        post: operations["submitUserOp"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/userops/{userOpId}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                userOpId: string;
+            };
+            cookie?: never;
+        };
+        /** Track a submitted UserOp */
+        get: operations["getUserOp"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/userops/by-hash/{chainId}/{userOpHash}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Reconcile an agent operation by its original hash
+         * @description Requires the agent session that submitted the operation. A missing record does not prove that the network rejected a timed-out submission. Do not build a replacement based on a 404.
+         */
+        get: operations["getAgentUserOpByHash"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/apis/providers": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Ranked, searchable, paged catalog of API providers
+         * @description Ranked, searchable, paged catalog of API providers. Ranking is by `rankScore`, the provider's busiest endpoint measured in 30-day unique payers. Every discovered provider is listed; each endpoint carries a `verification` state saying whether we measured its 402, measured that it is free, have not probed it yet, found it quoting another chain, or found it unreachable. Endpoints are NOT inlined here - fetch `/apis/providers/{providerId}` for those. `total` counts what matched before paging; `hidden` counts providers a chain or asset filter left with nothing to show, and `reasons` explains at most 50 of them (`reasonsTruncated` says when it is not all of them). Spec 2026-08-13 §9.
+         */
+        get: operations["listApiProviders"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/apis/providers/{providerId}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * One provider with a page of its endpoints
+         * @description Detailed view of one provider: the same fields the list carries, plus a searchable, paged `endpoints` array and the `endpointTotal` it is a page of. One provider carries up to 965 endpoints, so this route pages as well. Each endpoint states its `verification`, its price as measured or as declared, and whether it is `payable` on that chain. Spec 2026-08-13 §9.
+         */
+        get: operations["getApiProvider"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/apis/budget": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Read the current API budget and its state
+         * @description Returns remaining count, per-call max, expiry, epoch, token, max exposure, and amount spent. Spec 2026-08-13 §9.
+         */
+        get: operations["getApiBudget"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/apis/calls/requirements": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Check the gate and allocate a budget index for an API call
+         * @description Runs the gate, fetches the provider's 402, allocates an index, and returns the EIP-3009 payload the agent must sign, plus everything else needed to build the ERC-1271 envelope around the signature (`authorization`, `index`, `validator` - Task 13). Returns no signature - the agent signs and passes the sig to relay. Spec 2026-08-13 §9.
+         *     Task 11: a call above the agent's mandate `confirmAbove` threshold does NOT build ready to sign. `status: 'pending_approval'` is returned instead - `payload`/`requirements`/ `authorization`/`index`/`validator` are all absent, structurally, not merely empty. Poll `GET /apis/calls/requirements/{id}` for the owner's decision; once `POST /apis/calls/requirements/{id}/approve` has run, that same poll route starts returning `payload`/`authorization`/`index`/`validator` together (Task 14) - a client that only ever sees `pending_approval` here still gets everything it needs to build the signature once approved.
+         */
+        post: operations["buildApiCallRequirements"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/apis/calls/requirements/{id}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Poll a call raised above the agent's confirmAbove threshold
+         * @description Task 11. What the owner decided, if anything, about a `pending_approval` call from `buildApiCallRequirements`. `@AgentAllowed` - this is what the agent polls, since the digest was withheld at build time.
+         *     THE SECURITY PROPERTY: `payload`, `authorization`, `index` and `validator` (Task 14) are present ONLY when `status: 'approved'`. `X402PaymentValidator`'s nonce is a `pure` function of public inputs and `validBefore` is the agent's own to choose, so an agent holding all four before the owner has actually approved could sign and relay to any facilitator without ever calling Botanary again - returning them any earlier would make the threshold decorative. `validator` itself is not secret - it is a public contract address - but it is withheld alongside the other three so a client never has a reason to reach for it before it also has something to sign.
+         */
+        get: operations["getApiCallRequirementStatus"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/apis/calls/relay": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Relay an authorized API call with payment
+         * @description Claims the requirement durably before forwarding payment once. Returns the provider response when available, with payment status based on finalized chain evidence. A timeout or provider success does not prove settlement. Repeating the same requirement returns its stored status without forwarding again; recover with GET /apis/calls/relay/{id}. The authenticated account must own the requirement. An agent session may relay only its own requirement on that account; another agent on the same account cannot relay it. Unknown, unsubmitted expired and out-of-scope requirement IDs return the same requirement_expired decline without forwarding payment or changing another caller's state.
+         */
+        post: operations["relayApiCall"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/apis/calls/relay/{id}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Recover the same API payment without submitting again
+         * @description Reads the durable requirement, provider observation and finalized payment status. The same account and agent scope as relay applies. Submitted calls remain recoverable after their authorization expires. No provider request or signature is sent by this endpoint.
+         */
+        get: operations["getApiCallStatus"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+}
+export type webhooks = Record<string, never>;
+export interface components {
+    schemas: {
+        /** @description Request to pair a new agent. The agent signs over `(code || timestamp)` with its secp256k1 private key, proving it holds the key for the claimed public key. The signature is verified to recover to that key before the pairing proof is held (in-memory, expiring in minutes). */
+        AgentPairInput: {
+            /**
+             * @description The pairing code (format XXXXXX-XXXXXX). Identifies the agent by its signature.
+             * @example a1b2c3-d4e5f6
+             */
+            code: string;
+            /**
+             * @description The agent's secp256k1 public key (hex, with 0x prefix).
+             * @example 0x...
+             */
+            publicKey: string;
+            /**
+             * @description The agent's secp256k1 signature over keccak256(code || timestamp) (hex, with 0x prefix).
+             * @example 0x...
+             */
+            signature: string;
+            /** @description Unix seconds at the time the agent signed. Used for replay protection (±5 minutes). */
+            timestamp: number;
+            /**
+             * @description OPTIONAL. The coding tool the connector reports itself to be, slugified from the MCP `clientInfo.name` it received at initialize. Travels with the signed proof, so the tool a pairing claims to be is fixed by the connector that holds the key, not by whoever claims the code.
+             *     Unverified by construction - `clientInfo` is self-reported and the server cannot check it. It is stored on the resulting `ConnectedAgent.client` and shown to the owner as a quoted claim. The pattern is a whitelist because this value is displayed at the moment the owner decides what to authorize, so it may not carry markup, whitespace or direction-control characters that could dress one tool up as another.
+             *     Omitted by every connector released before this field existed; those pairings still work and store null.
+             * @example claude-code
+             */
+            client?: string;
+            /**
+             * @description OPTIONAL. The connector-side profile key behind this keypair - `<tool>` for a tool's default agent, `<tool>.<agent>` for a further one. Same unverified caveat as `client`.
+             * @example claude-code.trading
+             */
+            profile?: string;
+        };
+        ApiError: {
+            error: {
+                /**
+                 * @description Machine code - validation_error | unauthorized | forbidden | not_found | out_of_scope | conflict | internal | unavailable.
+                 * @example out_of_scope
+                 */
+                code: string;
+                /** @example This action exceeds the per-action cap. */
+                message: string;
+                declineReason?: components["schemas"]["DeclineReason"] | null;
+                details?: {
+                    [key: string]: unknown;
+                } | null;
+                requestId?: string | null;
+            };
+        };
+        /**
+         * @description Maps 1:1 to AgentGuard reverts (owner lane, execution phase) / Smart Sessions policy rejections (delegated lane, validation phase) / MandateExecutor reverts (delegated lane, execution phase). AgentGuard and MandateExecutor name the exact rule that failed; Smart Sessions returns only PolicyViolation, so `policy_violation` is genuinely all that is knowable there. Only the execution-phase reasons carry a transaction hash: a validation-phase rejection is dropped by the bundler before inclusion, so it has no artifact to link.
+         * @enum {string}
+         */
+        DeclineReason: "cap_exceeded" | "per_action_exceeded" | "recipient_not_allowed" | "contract_not_allowed" | "contract_denied" | "stablecoin_not_permitted" | "expired" | "max_actions_exceeded" | "account_frozen" | "admin_call_denied" | "delegatecall_denied" | "malformed_call" | "policy_violation" | "delegation_revoked" | "paymaster_not_permitted" | "no_policies_set" | "mandate_revoked" | "venue_not_allowed" | "selector_not_allowed" | "residual_allowance" | "value_not_zero" | "chain_capability_unavailable" | "route_unavailable" | "route_spender_mismatch" | "grant_swap_not_authorised" | "slippage_exceeded" | "mandate_paused" | "venue_denied" | "value_exceeded" | "budget_exceeded" | "arg_cap_exceeded" | "arg_not_allowed" | "insufficient_fee_balance" | "rent_exempt_shortfall" | "blockhash_expired" | "blockhash_not_found" | "mint_not_supported" | "account_not_found" | "trustline_missing" | "reserve_shortfall" | "tx_expired" | "relayer_unavailable" | "bridge_route_unavailable" | "bridge_pool_depth_exceeded" | "pool_not_actionable" | "exit_capacity_exceeded" | "nothing_to_claim" | "farm_simulation_failed" | "privy_rule_blocked" | "insufficient_usdc_for_gas" | "gasless_unavailable" | "kora_cosign_rejected" | "validator_inactive" | "not_enough_approvals" | "gas_cost_exceeds_ceiling" | "action_nonce_already_used" | "unknown_signer" | "duplicate_approval" | "expiry_required" | "approval_blob_too_short" | "approval_entry_out_of_bounds" | "approval_proof_out_of_bounds" | "trailing_approval_bytes" | "unsupported_scheme" | "endpoint_disabled" | "unsupported_endpoint_method" | "request_body_not_supported" | "request_body_too_large" | "provider_unavailable_on_chain" | "provider_unverified" | "provider_unreachable" | "budget_exhausted" | "over_per_call_max" | "payment_required" | "budget_expired" | "requirement_expired" | "validator_not_installed" | "token_not_configured" | "facilitator_rejected" | "provider_rejected_request" | "apis_budget_headroom" | "apis_budget_account_rules" | "commit_not_on_chain" | "mandate_not_found" | "api_mandate_paused" | "mandate_expired" | "provider_not_in_mandate" | "endpoint_not_in_mandate" | "velocity_exceeded" | "over_mandate_per_call_max" | "mandate_budget_exceeded" | "approval_required" | "approval_declined" | "approval_timed_out" | "revoke_requires_uninstall";
+        /** @description Request a fresh nonce for an agent to sign, to mint a session (POST /agents/session). */
+        AgentSessionNonceInput: {
+            /** @description The agent's secp256k1 address (must already be a LIVE connected agent). */
+            address: components["schemas"]["Address"];
+        };
+        /**
+         * @description A 20-byte EVM address.
+         * @example 0x8f2A9c4419aD77b0392bC41D8123aa77c0Fe41D0
+         */
+        Address: string;
+        /**
+         * @description A 32-byte hash (tx hash, userOpHash, permissionId, audit hash).
+         * @example 0x4c1f9a0b2d7e8c3f1a6b0d4e2c9f7a1b4c1f9a0b2d7e8c3f1a6b0d4e2c9f7a1b
+         */
+        Hash32: string;
+        /** @description Mint an agent session by proving possession of the private key behind `address`: sign the exact nonce issued by POST /agents/session/nonce and submit the signature here. */
+        AgentSessionInput: {
+            address: components["schemas"]["Address"];
+            /** @description The nonce returned by POST /agents/session/nonce. */
+            nonce: components["schemas"]["Hash32"];
+            /**
+             * @description The agent's secp256k1 signature over `nonce` (hex, with 0x prefix).
+             * @example 0x...
+             */
+            signature: string;
+        };
+        /** @description A short-lived agent session token (Bearer `ags_...`), scoped to @AgentAllowed() routes. */
+        AgentSessionResponse: {
+            /**
+             * @description Opaque, revocable bearer token - never derived from the agent's key.
+             * @example ags_...
+             */
+            token: string;
+            /** Format: date-time */
+            expiresAt: string;
+        };
+        /**
+         * @description GET /agents/me's answer to an agent's own three questions: who am I, what account am I bound to, and what may I do. `grant` is resolved by matching a Delegation's delegateeAddress against this agent's OWN address - null is a real, honest answer (this agent has been granted nothing yet, not an error and not an empty object), not a placeholder for a future field. This agent can still read and draft under every @AgentAllowed() route regardless of `grant`; every attempt to spend without one is refused for lack of authority, never silently.
+         *     Whatever an agent reads here is a convenience for whoever built it - never the check. The only boundary that counts is on-chain; a bug or a lie in this response changes nothing about what the agent can actually get away with.
+         */
+        AgentSelf: {
+            /** @description This agent's connection record ID (same as ConnectedAgent.id). */
+            id: string;
+            /** @example Claude Code */
+            name: string;
+            address: components["schemas"]["Address"];
+            /** @example a1b2c3 */
+            fingerprint: string;
+            /** Format: date-time */
+            connectedAt: string;
+            /** @description The account this agent is bound to. */
+            accountId: string;
+            /** @description That account's own on-chain address - the same string the owner sees in the account switcher, so "which account is this agent on?" is answerable without an internal id lookup. accountId above is opaque and appears nowhere in the app, which made an agent paired to a DIFFERENT login than the one the owner had open indistinguishable from a broken pairing. null only when the account row no longer exists - never fabricated. */
+            accountAddress: components["schemas"]["Address"] | null;
+            /** @description The live delegation whose delegateeAddress is this agent's own address, or null when the owner has granted this agent nothing (yet). Carries the grant's permissionId, bounds (policySet), plain-language sentence (humanSummary) and status - everything the MCP connector's spend tool needs to spend under it. */
+            grant: components["schemas"]["Delegation"] | null;
+            /** @description Whether the grant's own chain has every setup module the account needs, and which are absent. Exists so an agent learns this BEFORE it spends rather than from a reverted op: a missing executor makes every action under the grant fail identically, and no retry can change it, because installing a module is an authority change only the owner can sign. null when there is no grant (nothing to be ready for) or the check could not be completed - an honest gap, never a fabricated ready:true. */
+            accountSetup: components["schemas"]["AgentAccountSetup"] | null;
+        };
+        /**
+         * @description A scoped, revocable session-key delegation = policy set + spent-to-date.
+         * @example {
+         *       "id": "d1",
+         *       "permissionId": "0x1111111111111111111111111111111111111111111111111111111111111111",
+         *       "name": "Uniswap",
+         *       "kind": "dApp",
+         *       "icon": "arrow-left-right",
+         *       "delegateeAddress": "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
+         *       "chain": "Arbitrum",
+         *       "chainId": 42161,
+         *       "status": "active",
+         *       "humanSummary": "This dApp can spend up to 100 USDC in total, and may call 0x3593564c() on Universal Router and approve() on Permit2, max 50 per action, limited to 10 actions. Expires on 2026-08-03.",
+         *       "policySet": {
+         *         "budgets": [
+         *           {
+         *             "token": {
+         *               "symbol": "USDC",
+         *               "chainId": 42161
+         *             },
+         *             "amount": 100
+         *           }
+         *         ],
+         *         "perActionMax": {
+         *           "token": {
+         *             "symbol": "USDC",
+         *             "chainId": 42161
+         *           },
+         *           "amount": 50
+         *         },
+         *         "maxActions": 10,
+         *         "recipientAllowlist": [],
+         *         "allowedActions": [
+         *           {
+         *             "name": "Universal Router",
+         *             "target": "0x66a9893cC07D91D95644AEDD05D03f95e1dBA8Af",
+         *             "selectors": [
+         *               "0x3593564c"
+         *             ]
+         *           },
+         *           {
+         *             "name": "Permit2",
+         *             "target": "0x000000000022D473030F116dDEE9F6B43aC78BA3",
+         *             "selectors": [
+         *               "0x095ea7b3"
+         *             ]
+         *           }
+         *         ],
+         *         "expiresAt": "2026-08-03T00:00:00Z",
+         *         "freezeGated": false
+         *       },
+         *       "spentToDate": [
+         *         {
+         *           "token": {
+         *             "symbol": "USDC",
+         *             "chainId": 42161
+         *           },
+         *           "limit": 100,
+         *           "spent": 42.5,
+         *           "remaining": 57.5,
+         *           "expiresAt": "2026-08-03T00:00:00Z"
+         *         }
+         *       ]
+         *     }
+         */
+        Delegation: {
+            /** @example d1 */
+            id: string;
+            permissionId: components["schemas"]["Hash32"];
+            /**
+             * @description GRANT-ONLY, mandate-sourced only. Which mandate this grant was compiled from. Null on the legacy name-salted branch and on every non-grant kind. The chain can never tell you which mandate a permission id came from, so the row carries it - and a client that needs to correlate a grant back to its mandate MUST read this rather than matching on `name`, which is not unique within an agent.
+             * @example m_7f3a
+             */
+            mandateId?: string | null;
+            /**
+             * @description The version of `mandateId` this grant compiled from. Always set together with `mandateId`; a row carrying one without the other is refused at build time.
+             * @example 2
+             */
+            mandateVersion?: number | null;
+            /** @example Uniswap */
+            name: string;
+            kind: components["schemas"]["DelegationKind"];
+            /**
+             * @description Lucide icon name (design-system hint).
+             * @example arrow-left-right
+             */
+            icon?: string | null;
+            delegateeAddress: components["schemas"]["Address"];
+            /** @example Arbitrum */
+            chain: string;
+            /** @example 42161 */
+            chainId: number;
+            status: components["schemas"]["DelegationStatus"];
+            policySet: components["schemas"]["PolicySet"];
+            /** @description One meter per budget, in the same order as policySet.budgets. */
+            spentToDate: components["schemas"]["SpendMeter"][];
+            /**
+             * @description Plain-language rendering of exactly what the encoder bound (FR-1 fidelity).
+             * @example This dApp can spend up to 100 USDC in total, max 50 per action, limited to 10 actions. Expires on 2026-08-03.
+             */
+            humanSummary: string;
+            /** Format: date-time */
+            createdAt?: string;
+            /** Format: date-time */
+            expiresAt?: string | null;
+            /**
+             * @description Set only on the POST /delegations (enable) response, to the just-relayed enable op's id. The grant audit row is normally appended synchronously by a bounded server-side confirm, but that confirm can time out on a slow chain; poll GET /userops/{userOpId} (the same reconciler every other build->sign->relay flow already uses) to reach a terminal audit row for the grant. Absent/null on every other response that returns a Delegation - there is no op to poll there.
+             * @example op_9f2a1c
+             */
+            userOpId?: string | null;
+        };
+        /** @enum {string} */
+        DelegationKind: "dApp" | "automation" | "recurring" | "mandate" | "grant";
+        /** @enum {string} */
+        DelegationStatus: "active" | "frozen" | "expired" | "revoked";
+        /** @description Exactly what a delegation binds on-chain via Smart Sessions. Every field here is enforced by a policy, and the plain-language summary is rendered from this and nothing else. Two absences are deliberate, both from ERC-7562 rule OP-011 (no TIMESTAMP opcode in the validation phase where session policies run): there is no per-period cap (a delegation carries a lifetime `budgets` total plus an `expiresAt`, never "100 USDC per week") and no rate limit (`maxActions` is a lifetime count, never "3 per day"). A per-period cap on the owner's OWN account is a different thing that does exist - see AccountCap. */
+        PolicySet: {
+            /** @description Total spend allowed over the delegation's life, one entry per permitted stablecoin. */
+            budgets: components["schemas"]["TokenAmount"][];
+            perActionMax?: components["schemas"]["TokenAmount"] | null;
+            /**
+             * @description Lifetime cap on the NUMBER of delegated actions (Rhinestone UsageLimitPolicy). Not a rate.
+             * @example 10
+             */
+            maxActions?: number | null;
+            /** @description Approved recipients. Empty means genuinely unbounded - the delegatee may pay anyone. */
+            recipientAllowlist: components["schemas"]["AddressBookEntry"][];
+            /** @description The (contract, function) pairs the delegatee may call, beyond the budgeted transfers. */
+            allowedActions: components["schemas"]["ActionPermission"][];
+            /** Format: date-time */
+            expiresAt: string;
+            /** @description Whether a global account freeze also stops this delegation (AgentGuardFreezePolicy attached). */
+            freezeGated: boolean;
+            /** @description GRANT-ONLY, and ABSENT unless the grant asked to swap. Records which router/token/ceiling this grant's SECOND session action (GrantExecutor.executeUnderGrantWithAllowance) pins - the fact POST /delegations/{delegationId}/actions reads to decide whether a swap is expressible at all. A compiled session is not readable back from a permissionId, so this is the record. */
+            swapVenue?: components["schemas"]["GrantSwapVenue"];
+        };
+        TokenAmount: {
+            token: components["schemas"]["TokenRef"];
+            /** @example 50 */
+            amount: number;
+        };
+        /** @description A lightweight reference to a coin. */
+        TokenRef: {
+            /**
+             * @description PREFERRED. CAIP-19 asset ref, e.g. `eip155:8453/erc20:0x8335...`. Authoritative when present; `symbol` is advisory.
+             * @example eip155:8453/erc20:0x8335...
+             */
+            assetRef?: string | null;
+            /**
+             * @description ADVISORY. A label a contract picked for itself - never authoritative, never resolved against.
+             * @example USDC
+             */
+            symbol: string;
+            /** @example 42161 */
+            chainId?: number | null;
+            address?: components["schemas"]["Address"] | null;
+        };
+        /** @description A named address in the owner's book. `chainId` is OPTIONAL by design: an entry that predates the field, or one whose chain is genuinely unknown, is still a valid entry - the client renders it copy-only with no explorer link rather than guessing a network and emitting a URL that resolves nowhere. */
+        AddressBookEntry: {
+            /** @example Universal Router */
+            name?: string | null;
+            address: components["schemas"]["Address"];
+            /**
+             * @description Which chain this address is meaningful on, when known. Drives the client's explorer link.
+             * @example 8453
+             */
+            chainId?: number | null;
+        };
+        /**
+         * @description A contract a delegation or grant may call, and (where the lane can express it) which functions on it.
+         *
+         *     **In a REQUEST** (`DelegationIntent.allowedActions`) `selectors` MUST name at least one 4-byte selector, and an empty list is refused with 422. Smart Sessions binds a delegation's policies to `(actionTarget, selector)` pairs, so "any function on X" is not expressible on that lane and an allowlisted contract with no selector would grant nothing.
+         *
+         *     **In a RESPONSE** an EMPTY `selectors` list is meaningful, and appears on a `kind: 'grant'` `PolicySet`. A grant binds its allowed contract as a call ARGUMENT (`ArgRuleSetPolicy`, `EQ` at the wrapper's target offset) rather than as the action target - every grant call routes through `GrantExecutor.executeUnderGrant` whatever the inner function is - so the bound genuinely is "any function on this contract", and an empty list is how that is said. The grant's own `humanSummary` names the contract either way.
+         */
+        ActionPermission: {
+            target: components["schemas"]["Address"];
+            /** @example Universal Router */
+            name?: string | null;
+            /**
+             * @example [
+             *       "0x3593564c"
+             *     ]
+             */
+            selectors: string[];
+        };
+        /**
+         * @description The venue a swap-capable grant is bound to: the ONE router the agent may be given an allowance to, the ONE token that allowance may be on, and the ceiling on it. All three are required together - a swap's tokens leave via the ROUTER's own transferFrom, in a frame whose msg.sender is the router and which no AgentGuard hook sees, so the three EQ/LTE session rules these compile to (plus the mandatory permissionId pin) are the ONLY thing bounding what may be approved, to whom, and how much. The token must be one the same grant also BUDGETS, and must not be the native asset (there is no allowance to grant on native); both are refused at build time.
+         * @example {
+         *       "router": "0x111111125421cA6dc452d289314280a0f8842A65",
+         *       "token": {
+         *         "symbol": "USDC",
+         *         "chainId": 421614
+         *       },
+         *       "maxAllowance": 50
+         *     }
+         */
+        GrantSwapVenue: {
+            /** @description Gets both the allowance and the routed call - the entrypoint has ONE (token, target) pair. A route quote whose approvalAddress differs from its router is declined route_spender_mismatch. */
+            router: components["schemas"]["Address"];
+            token: components["schemas"]["TokenRef"];
+            /** @description Ceiling on a single frame's allowance, in display units. */
+            maxAllowance: number;
+        };
+        /** @description A delegation's spend against one of its budgets. Budgets do not reset - they end at expiry - so there is no period/resetsAt here (unlike AccountCap, which is periodic). */
+        SpendMeter: {
+            token: components["schemas"]["TokenRef"];
+            /** @example 100 */
+            limit: number;
+            /** @example 42.5 */
+            spent: number;
+            /** @example 57.5 */
+            remaining: number;
+            /** Format: date-time */
+            expiresAt?: string | null;
+        };
+        /** @description Setup readiness for the chain an agent's grant lives on. See AgentSelf.accountSetup. */
+        AgentAccountSetup: {
+            /** @description True when nothing is missing; an agent may spend without consulting `missing`. */
+            ready: boolean;
+            /**
+             * @description Module names absent from the account, in install order. Empty exactly when ready.
+             * @example [
+             *       "GrantExecutor"
+             *     ]
+             */
+            missing: string[];
+            /**
+             * @description The chain assessed - the grant's own chain, never the agent's pinned row.
+             * @example 5042002
+             */
+            chainId: number;
+        };
+        /** @description One in-flight agent request. The agent has asked the owner to approve an action that exceeded its delegated grant. Requests expire in minutes; an expired request stays in the list marked `expired` so expiry is a recorded, visible event (D8). The owner approves it as their own action - not delegated (§5-43), so the unsigned op carries no `permissionId`. */
+        AgentRequest: {
+            /** @description The request ID. */
+            id: string;
+            /** @description The agent that raised this request. */
+            agentId: string;
+            /** @description The account this request belongs to. */
+            accountId: string;
+            /** @description The calls the agent wanted to make, exactly as proposed. */
+            calls: {
+                /**
+                 * @description The target contract address.
+                 * @example 0x...
+                 */
+                to: string;
+                /**
+                 * @description The encoded call data (hex, with 0x prefix).
+                 * @example 0x...
+                 */
+                data: string;
+                /**
+                 * @description The native wei to send (decimal string). Usually '0'.
+                 * @example 0
+                 */
+                value: string;
+                /**
+                 * @description The chain ID where this call should execute.
+                 * @example 8453
+                 */
+                chainId: number;
+            }[];
+            /**
+             * @description WHICH bound was crossed - a specific DeclineReason, never a generic failure. Specific enough for the agent to narrow what it was doing (§6-40).
+             * @example cap_exceeded
+             */
+            declineReason: string;
+            /**
+             * @description Human-readable reason from the agent.
+             * @example Pay the invoice
+             */
+            reason: string;
+            /**
+             * Format: date-time
+             * @description When the request was raised.
+             */
+            raisedAt: string;
+            /**
+             * Format: date-time
+             * @description When this request expires (visible from the moment it is raised, D8). The owner cannot approve it after this time, but the request stays in the list marked `expired` rather than vanishing.
+             */
+            expiresAt: string;
+            /**
+             * @description The request's current status. `open` = awaiting approval. `approved` = owner approved and the op was built. `expired` = past the deadline. `withdrawn` = agent gave up. Expired requests stay visible.
+             * @enum {string}
+             */
+            status: "open" | "approved" | "expired" | "withdrawn";
+        };
+        /** @description Request to raise a pending request when an agent hits a delegation bound. The request carries the originally-proposed calls and the reason the agent is asking, plus a decline reason naming which specific bound was crossed. */
+        AgentRequestInput: {
+            /**
+             * @description A human-readable reason for the request (e.g. 'Pay the invoice').
+             * @example Pay the invoice
+             */
+            reason: string;
+            /** @description The calls the agent wanted to make (and was declined). */
+            calls: {
+                /**
+                 * @description The target contract address.
+                 * @example 0x...
+                 */
+                to: string;
+                /**
+                 * @description The encoded call data (hex, with 0x prefix).
+                 * @example 0x...
+                 */
+                data: string;
+                /**
+                 * @description The native wei to send (decimal string). Usually '0'.
+                 * @example 0
+                 */
+                value: string;
+                /**
+                 * @description The chain ID where this call should execute.
+                 * @example 8453
+                 */
+                chainId: number;
+            }[];
+        };
+        /**
+         * @description A view over the owner's own holdings. Never pooled or custodial (FR-S1).
+         * @example {
+         *       "totalFiat": 12480.06,
+         *       "change24h": 2.4,
+         *       "stablecoinFiat": 12235.32,
+         *       "status": "ready",
+         *       "asOf": "2026-07-07T09:42:00Z",
+         *       "holdings": [
+         *         {
+         *           "assetRef": "eip155:42161/erc20:0xaf88d065e77c8cc2239327c5edb3a432268e5831",
+         *           "symbol": "USDC",
+         *           "amount": 6420.5,
+         *           "priceUsd": 1,
+         *           "fiat": 6420.5,
+         *           "priceAdvisory": true
+         *         },
+         *         {
+         *           "assetRef": "eip155:42161/erc20:0xfd086bc7cd5c481dcc9c85ebe478a1c0b69fcbb9",
+         *           "symbol": "USDT",
+         *           "amount": 2100,
+         *           "priceUsd": 1,
+         *           "fiat": 2100,
+         *           "priceAdvisory": true
+         *         },
+         *         {
+         *           "assetRef": "eip155:42161/slip44:60",
+         *           "symbol": "ETH",
+         *           "amount": 0.0921,
+         *           "priceUsd": 2657.3,
+         *           "fiat": 244.74,
+         *           "priceAdvisory": false
+         *         }
+         *       ],
+         *       "tokens": [
+         *         {
+         *           "symbol": "USDC",
+         *           "name": "USD Coin",
+         *           "chain": "Arbitrum",
+         *           "chainId": 42161,
+         *           "tokenAddress": "0xaf88d065e77c8cC2239327C5EDb3A432268e5831",
+         *           "decimals": 6,
+         *           "amount": 6420.5,
+         *           "fiat": 6420.5,
+         *           "price": 1,
+         *           "change24h": 0,
+         *           "isStablecoin": true,
+         *           "peg": {
+         *             "symbol": "USDC",
+         *             "price": 1,
+         *             "target": 1,
+         *             "deviationBps": 0,
+         *             "status": "ok",
+         *             "observedAt": "2026-07-07T09:40:00Z",
+         *             "source": "chainlink"
+         *           },
+         *           "spendable": true,
+         *           "source": "registry"
+         *         },
+         *         {
+         *           "symbol": "USDT",
+         *           "name": "Tether",
+         *           "chain": "Arbitrum",
+         *           "chainId": 42161,
+         *           "tokenAddress": "0xFd086bC7CD5C481DCC9C85ebE478A1C0b69FCbb9",
+         *           "decimals": 6,
+         *           "amount": 2100,
+         *           "fiat": 2100.42,
+         *           "price": 1.0002,
+         *           "change24h": 0.01,
+         *           "isStablecoin": true,
+         *           "peg": {
+         *             "symbol": "USDT",
+         *             "price": 0.9938,
+         *             "target": 1,
+         *             "deviationBps": -62,
+         *             "status": "watch",
+         *             "observedAt": "2026-07-07T09:40:00Z",
+         *             "source": "chainlink"
+         *           },
+         *           "spendable": true,
+         *           "source": "registry"
+         *         },
+         *         {
+         *           "symbol": "ETH",
+         *           "name": "Ether",
+         *           "chain": "Arbitrum",
+         *           "chainId": 42161,
+         *           "tokenAddress": "0x0000000000000000000000000000000000000000",
+         *           "decimals": 18,
+         *           "amount": 0.0921,
+         *           "fiat": 244.74,
+         *           "price": 2657.3,
+         *           "change24h": -1.2,
+         *           "isStablecoin": false,
+         *           "peg": null,
+         *           "spendable": true,
+         *           "source": "registry"
+         *         }
+         *       ]
+         *     }
+         */
+        UnifiedBalance: {
+            /** @example 12480.06 */
+            totalFiat: number;
+            /**
+             * @description 24h change, percent.
+             * @example 2.4
+             */
+            change24h: number;
+            /**
+             * @description The unified stablecoin figure (excludes non-stable assets like ETH).
+             * @example 12235.32
+             */
+            stablecoinFiat: number;
+            /** @description Every priced holding across every chain family (EVM, Solana and Stellar alike), each in the one ValuedHolding shape - the row ValuationService.value() produces, the exact function GET /balance and GET /balance/history both call so the headline total and the chart's last point can never disagree. Always present (`[]` when empty), mirroring the three sidecar arrays below. The portfolio-history redesign's Task 21 wires this response up; tokens/ solanaTokens/stellarTokens are DEPRECATED in its favor and kept, unchanged, only until the frontend cuts over to it. */
+            holdings: components["schemas"]["ValuedHolding"][];
+            /**
+             * @deprecated
+             * @description DEPRECATED - superseded by holdings. Kept, unchanged, until the frontend cuts over (portfolio-history redesign Task 22).
+             */
+            tokens: components["schemas"]["TokenBalance"][];
+            /**
+             * @deprecated
+             * @description DEPRECATED - superseded by holdings. Solana holdings. Always present (`[]` when empty) so a consumer never distinguishes "no Solana holdings" from "this build does not serve Solana". `totalFiat`, `stablecoinFiat` and `change24h` INCLUDE these rows.
+             */
+            solanaTokens: components["schemas"]["SolanaTokenBalance"][];
+            /**
+             * @deprecated
+             * @description DEPRECATED - superseded by holdings. Stellar holdings. Always present (`[]` when empty), mirroring `solanaTokens` exactly. UNLIKE `solanaTokens`, each row carries no `fiat`/`price` field at all (no dedicated Stellar price port). `totalFiat`/`stablecoinFiat`/`change24h` are summed from `holdings[]` (chain-agnostic), so a Stellar trustline whose symbol is a recognized stablecoin (USDC/USDT) DOES contribute via the same $1 peg-advisory rule any other chain's stablecoin uses; an asset with no such recognition and no price observation (native XLM, today) still contributes nothing.
+             */
+            stellarTokens: components["schemas"]["StellarTokenBalance"][];
+            /**
+             * @description The account's backfill/health state (portfolio-history redesign, Task 21 fix round 1). `building` means the background sweep has not reached this account yet (no sync state, or a sync state with no ledger rows behind it) - `holdings` may be empty and `totalFiat` may read 0, and this is NOT a confirmed zero balance: a client MUST treat a `building` response as unknown, never render it as a real $0. At the moment this redesign first ships, EVERY existing account starts in `building` - the background sweep has never run in production before this cutover - so this is not a rare edge case for launch day, it is the expected state for the whole account population until the sweep catches up. `degraded` means the account has ledger data, but at least one of its chains' background sync is unhealthy right now - `holdings`/`totalFiat` still reflect whatever WAS last successfully synced for every chain, never blanked over one bad chain. `ready` means every chain's last sync succeeded.
+             * @example ready
+             * @enum {string}
+             */
+            status: "ready" | "building" | "degraded";
+            /** Format: date-time */
+            asOf: string;
+        };
+        /** @description One priced holding, chain-agnostic (EVM/Solana/Stellar alike) - the exact row shape ValuationService.value() produces (src/modules/portfolio/valuation.service.ts), shared verbatim by GET /balance's headline total and GET /balance/history's chart bucket-by-bucket, so the two are structurally incapable of disagreeing. UnifiedBalance.holdings wiring lands in the portfolio-history redesign's Task 21. */
+        ValuedHolding: {
+            /**
+             * @description CAIP-19 asset reference, e.g. `eip155:8453/erc20:0x8335...` for an ERC-20, or `eip155:8453/slip44:60` for that chain's native coin. The address segment of an erc20 reference is always lowercased.
+             * @example eip155:8453/erc20:0x833589fcd6edb6e08f4c7c32d4f71b54bda02913
+             */
+            assetRef: string;
+            /** @example USDC */
+            symbol: string;
+            /**
+             * @description Display amount, decimal-formatted from the underlying base-unit balance.
+             * @example 6420.5
+             */
+            amount: number;
+            /**
+             * @description The price this holding was valued at - an observed price when priceAdvisory is false, or the $1 stablecoin TARGET when priceAdvisory is true. 0 when unresolvable (never fabricated).
+             * @example 1
+             */
+            priceUsd: number;
+            /**
+             * @description amount × priceUsd, rounded to 2dp.
+             * @example 6420.5
+             */
+            fiat: number;
+            /** @description True only for a stablecoin with no observed price currently in force: priceUsd is then the $1 peg TARGET, not an observation - FR-9's honesty signal, telling a reader the number is a target rather than confirmation the asset is actually on peg, even mid-depeg. False in every other case, including a real observed price (stablecoin or not) and an unresolvable price (priceUsd: 0). Today this is the ONLY path ever taken for a stablecoin: no peg-observation source feeds PriceSeries yet (see the portfolio-history redesign design doc's §4 - DepegObservation exists in the schema but nothing writes it), so in practice every stablecoin prices at exactly $1.00 with priceAdvisory true even mid-depeg. An accepted fidelity limitation, not a hidden one. */
+            priceAdvisory: boolean;
+        };
+        /** @description One held token, presentation-shaped (amount/fiat/price are display values) - EXCEPT amountRaw, which is not: it carries the exact base-unit balance, so this schema is no longer purely presentational and does not carry the x-presentation-only flag the other balance schemas do. Still never pooled or custodial (FR-S1) - only the "presentation-only" framing was inaccurate, never the custody guarantee. */
+        TokenBalance: {
+            /**
+             * @description CAIP-19 asset ref, e.g. `eip155:42161/erc20:0x...`. Authoritative identifier for the token.
+             * @example eip155:42161/erc20:0xFF970A61A04b1cA14834A43f5dE4533eBDDB5F86
+             */
+            assetRef?: string;
+            /** @example USDC */
+            symbol: string;
+            /** @example USD Coin */
+            name: string;
+            /** @example Arbitrum */
+            chain: string;
+            /** @example 42161 */
+            chainId: number;
+            tokenAddress: components["schemas"]["Address"];
+            /** @example 6 */
+            decimals: number;
+            /** @example 6420.5 */
+            amount: number;
+            /** @example 6420.5 */
+            fiat: number;
+            /** @example 1 */
+            price: number;
+            /** @example 0 */
+            change24h: number;
+            isStablecoin: boolean;
+            peg?: components["schemas"]["PegStatus"] | null;
+            /** @description Whether Send/Grant can build against this token today - it has an adapter entry (see `GET /adapters`) for this chain + symbol, or it is native ETH. A displayable token (`registry ∪ discovered ∪ imported`) is not necessarily spendable. */
+            spendable: boolean;
+            /**
+             * @description Which feed produced this row. `registry` is the curated, priced set; `discovered` is best-effort on-chain auto-discovery; `imported` is a token the owner added by hand.
+             * @enum {string}
+             */
+            source: "registry" | "discovered" | "imported";
+            /** @description Coarse spam signal, set only on `discovered` rows with no price and an unrecognized symbol. Never set on `registry`/`imported` rows. A flag only - it never blocks display. */
+            unrecognized?: boolean;
+            /**
+             * @description Virtuals launchpad stage, present only for recognized agent tokens.
+             * @enum {string}
+             */
+            graduationStatus?: "sentient" | "prototype" | "unknown";
+            /** @description True when the price source confirmed this is a real (Virtuals) token. */
+            recognized?: boolean;
+            /** @description Fully-diluted valuation in USD when reported; never fabricated. */
+            fdvUsd?: number | null;
+            /**
+             * @description The exact base-unit magnitude backing amount, as a decimal string - e.g. "1500500001" for a 6-decimal token whose true on-chain balance is 1500.500001, alongside amount: 1500.5 (2dp-rounded for display). Copied straight from the on-chain bigint read (bigint.toString()) - never a decimal-string parse and never a Number round-trip - so it carries no rounding beyond whatever the chain itself reported. This is the truth anchor the portfolio-history redesign's balance projection reads: re-deriving base units by multiplying amount back out would replay display rounding into that projection. Only ever set on a REAL on-chain read; omitted, never fabricated, on a fake-mode seeded row.
+             * @example 1500500001
+             */
+            amountRaw?: string;
+        };
+        /** @description Peg observation for one stablecoin. Visibility-only in v1. */
+        PegStatus: {
+            /** @example USDT */
+            symbol: string;
+            /**
+             * @description Null iff status = unknown - never defaulted to 1, which would read as "on peg".
+             * @example 0.9938
+             */
+            price: number | null;
+            /** @example 1 */
+            target: number;
+            /**
+             * @description Signed basis points from target. Null iff status = unknown.
+             * @example -62
+             */
+            deviationBps: number | null;
+            status: components["schemas"]["PegStatusLevel"];
+            /** Format: date-time */
+            observedAt: string;
+            /** @example chainlink */
+            source?: string | null;
+            /**
+             * @description Why the peg could not be observed. Set iff status = unknown.
+             * @example Chainlink oracle unavailable
+             */
+            unavailableReason?: string | null;
+        };
+        /**
+         * @description `unknown` is not cosmetic: FR-9 forbids *silently* holding a depegged asset, so an unobservable peg reads as "we don't know" (price/deviationBps null, unavailableReason set), never as "on peg".
+         * @enum {string}
+         */
+        PegStatusLevel: "ok" | "watch" | "depegged" | "unknown";
+        /** @description One Solana holding. Deliberately parallel to `TokenBalance` rather than a variant of it: `TokenBalance` requires `chainId` and a 0x `tokenAddress`, and loosening either would make two Solana rows compare equal on chainId. */
+        SolanaTokenBalance: {
+            /** @example SOL */
+            symbol: string;
+            /** @example SOL */
+            name: string;
+            /** @example Solana Devnet */
+            chain: string;
+            /** @example solana-devnet */
+            key: string;
+            /** @description The SPL mint, or null for native SOL, which genuinely has no mint. */
+            mint: components["schemas"]["SolanaAddress"] | null;
+            /** @example 9 */
+            decimals: number;
+            amount: number;
+            fiat: number;
+            price: number;
+            change24h: number;
+            isStablecoin: boolean;
+            peg?: components["schemas"]["PegStatus"] | null;
+            /** @description Always false in this build - the Solana send path does not exist yet. */
+            spendable: boolean;
+            /** @enum {string} */
+            source: "registry" | "discovered";
+        };
+        /**
+         * @description A Solana address (base58-encoded Ed25519 public key, 32-44 characters). DELIBERATELY separate from `Address` rather than widening it: `Address`'s `^0x[a-fA-F0-9]{40}$` pattern is enforced on ~12 DTOs, and widening it to accept base58 would silently weaken every one of them.
+         * @example 9WzDXwBbmkg8ZTbNMqUxvQRAyrZzDsGYdLVL9zYtAWWM
+         */
+        SolanaAddress: string;
+        /** @description One Stellar balance row - native XLM or a trustline asset. Deliberately a RAW shape, unlike `SolanaTokenBalance`: there is no Stellar price port yet, so this carries no `amount`/`fiat`/ `price` - only what the RPC actually observed. */
+        StellarTokenBalance: {
+            /** @example XLM */
+            symbol: string;
+            /** @description The trustline asset's issuer account, or null for native XLM, which genuinely has none. */
+            issuer: components["schemas"]["StellarAddress"] | null;
+            /**
+             * @description The raw on-chain balance as a decimal string (bigint-safe transport) - never a number, which would lose precision.
+             * @example 1000.0000000
+             */
+            rawAmount: string;
+            /** @example 7 */
+            decimals: number;
+            /**
+             * @description The chain KEY this row was read from ('stellar' or 'stellar-testnet'), mirroring `SolanaTokenBalance.key`. Distinguishes otherwise-identical XLM/trustline rows held on both Stellar networks.
+             * @example stellar
+             */
+            key: string;
+        };
+        /**
+         * @description A Stellar account address (StrKey-encoded Ed25519 public key, starts with `G`, 56 characters). DELIBERATELY separate from `Address` and `SolanaAddress` - never widen either existing schema to accept this format.
+         * @example GBRPYHIL2CI3FNQ4BXLFMNDLFJUNPU2HY3ZMFSHONUCEOASW7QC7OX2H
+         */
+        StellarAddress: string;
+        /** @description A reference chain. `tier`/`explorerUrl`/`blockscoutUrl`/`gasTokens` are populated by `GET /chains` (Plan 3 Task 5) - the same schema used unenriched elsewhere (`SessionContext.chains`, `ReceiveInfo.chains`) may omit them. */
+        Chain: {
+            /** @example Arbitrum */
+            name: string;
+            /**
+             * @description The EVM chainId. `null` on a non-EVM chain (Solana) - the same answer `LaunchpadToken.chainId` gives for a Solana launchpad token. Use `key` to address a chain across namespaces.
+             * @example 42161
+             */
+            chainId: number | null;
+            /**
+             * @description CAIP-2 chain reference (e.g. eip155:84532, solana:EtWTRABZaYq6iMfeYKouRu166VU2xqa1, stellar:testnet). The namespace-agnostic identity for this chain - unlike chainId, which is null for every non-EVM chain. Clients scoping a request by chain (GET /balance/history's chainRefs, GET /balance's focusChainRef) MUST send this value, not a key or a name.
+             * @example eip155:84532
+             */
+            chainRef: string;
+            /**
+             * @description Which address/transaction family this chain belongs to. `eip155` is every EVM chain. `solana` is the SVM lane. `stellar` is the Stellar lane - StrKey `G...` addresses, transactions relayed via `POST /stellar/transactions` (a later phase). Clients MUST branch on this to pick an address format and a send path.
+             * @example eip155
+             * @enum {string}
+             */
+            namespace: "eip155" | "solana" | "stellar";
+            /**
+             * @description The canonical identifier for this chain across both namespaces. For an EVM chain this is the stringified `chainId` ("8453"); for Solana it is a slug ("solana", "solana-devnet").
+             * @example 8453
+             */
+            key: string;
+            /** @example arb */
+            shortName?: string | null;
+            /** @example false */
+            testnet: boolean;
+            /** @example ETH */
+            nativeSymbol?: string | null;
+            /**
+             * @description `botanary` iff AgentGuard is deployed (delegation/freeze/rules available); `basic` iff the chain has a bundler but no AgentGuard (send only, no delegation); `watch` otherwise (balances/reads only). From `GET /chains` only.
+             * @example botanary
+             * @enum {string}
+             */
+            tier?: "watch" | "basic" | "botanary";
+            /**
+             * @description Block-explorer link base for this chain (currently always Blockscout). From `GET /chains` only.
+             * @example https://base-sepolia.blockscout.com
+             */
+            explorerUrl?: string;
+            /**
+             * @description The Blockscout instance base URL for this chain. From `GET /chains` only.
+             * @example https://base-sepolia.blockscout.com
+             */
+            blockscoutUrl?: string;
+            /**
+             * @description Assets that can pay this chain's gas - `native` always, `+USDC` where Circle Paymaster gas is available. From `GET /chains` only.
+             * @example [
+             *       "native",
+             *       "USDC"
+             *     ]
+             */
+            gasTokens?: string[];
+            /**
+             * @description The ERC-20 identity address for a chain whose NATIVE asset is itself a token (Arc: gas is USDC), for DISPLAY/verification only - e.g. a token detail view's "Contract" field and block-explorer link for that chain's native balance row, which otherwise carries the `0x0` native sentinel (not a real, explorer-verifiable contract). `null` on every other chain, and `null` here too on a token-native chain whose ERC-20 address is unverified. Balances are never read or deduped through this address - only through the native sentinel. From `GET /chains` only.
+             * @example 0x3600000000000000000000000000000000000000
+             */
+            nativeErc20Address?: string | null;
+        };
+        /** @description How an owner may pay a network fee (FR-8). `usdc` is the default: FR-8 promises that no action requires holding a native gas token, and an owner who has only ever received stablecoins holds none. Choosing it makes `POST /money/send/build` return a `gasPermit`. */
+        GasMethod: {
+            method: components["schemas"]["GasMethodName"];
+            /** @example Sponsored */
+            label: string;
+            /** @description What the BOUND backend adapter can build - not what a given client can carry to a mined transaction. `usdt` is false in real mode: its Permit2 leg is a seam, not an implementation. */
+            available: boolean;
+            token?: components["schemas"]["TokenRef"] | null;
+            balance?: number | null;
+            balanceFiat?: number | null;
+            isDefault: boolean;
+            /** @example Pay the network fee in USDC. No ETH needed. */
+            note?: string | null;
+            /**
+             * @description What one send is expected to cost with this method, denominated in this method's own `token` - so a client can reserve the fee before there is an op to price. A MAX/"send everything" control MUST subtract this from the balance when `token` is the asset being sent, or it composes a transfer whose fee has nowhere to come from.
+             *     An ESTIMATE. The authority on affordability is the build (`POST /money/send/build`), which prices the real UserOp and refuses with exact numbers rather than returning a signable op that cannot settle. `native` is priced from the chain's own `maxFeePerGas` and includes the account's deployment while it is still counterfactual. `null` means not estimable here (a paymaster whose spread this endpoint cannot read) - reserve nothing and let the build be the judge. `sponsored` is `0`: nothing leaves the account.
+             * @example 0.0009
+             */
+            estimatedFee?: number | null;
+        };
+        /** @enum {string} */
+        GasMethodName: "sponsored" | "usdc" | "usdt" | "native";
+        Account: {
+            /** @example acct_01H8 */
+            id: string;
+            /** @example Main account */
+            label: string;
+            address: components["schemas"]["Address"];
+            /** @description The address this account was previously stored as on this chain if it required migration to a new address. Null means the address has never changed on this chain, which is the normal case. */
+            supersededAddress?: string | null;
+            /** @example Smart account */
+            type: string;
+            deploymentStatus: components["schemas"]["AccountDeploymentStatus"];
+            /**
+             * @description `null` on a non-EVM account (Solana). Use `key` to identify the chain. On a collapsed `GET /accounts` entry this is the CANONICAL row's home chain, NOT the only chain the account exists on - the address is the same on every EVM chain, and `chains[]` enumerates the ones it has rows on.
+             * @example 42161
+             */
+            chainId: number | null;
+            /**
+             * @description The chain key this account belongs to ("8453", "solana", "solana-devnet").
+             * @example 8453
+             */
+            key?: string;
+            /**
+             * @example eip155
+             * @enum {string}
+             */
+            namespace?: "eip155" | "solana" | "stellar";
+            /** @description `null` when this account has NO smart account - a plain Solana wallet, where the key and the money share an address. On EVM this is absent, because the account itself IS the smart account. Present-and-null is the seam that lets a program vault be added later additively. */
+            smartAccount?: Record<string, never> | null;
+            signerAddress: components["schemas"]["Address"];
+            /** @description Account-level kill-switch state. On a collapsed `GET /accounts` entry, `true` when AT LEAST ONE of `chains[]` is frozen - AgentGuard is deployed per chain, so the flag is per chain underneath; which chain is frozen, and the id to unfreeze it with, are in `chains[]`. Required, because every account this API serves today is an EVM account (`address` is 0x-typed) and every one of them has a kill-switch. A chain with no kill-switch mechanism will OMIT this rather than send `false` - `false` would read as "not frozen" when it means "freeze does not exist here" - and will be expressed as its own arm of a `oneOf` discriminated on `namespace`, not by relaxing this list. */
+            frozen: boolean;
+            /**
+             * @description The CREATE2 factory salt this account was derived at. 0 is the first ("Main") account.
+             * @example 0
+             */
+            index: number;
+            /** @description Presentation-only. A hidden account is NOT deleted: it remains on-chain, remains bounded by AgentGuard, and its delegations remain revocable. Hiding only removes it from the picker. */
+            hidden: boolean;
+            /**
+             * @description What this account is for. Absent on an older/legacy account row - treat as "primary". "acp_spending" marks the dedicated, capped account a bounded ACP hire pays from.
+             * @example primary
+             * @enum {string}
+             */
+            purpose?: "primary" | "acp_spending";
+            /** Format: date-time */
+            createdAt?: string;
+            /**
+             * @description This account's own unified-balance total (fiat). Present only on `GET /accounts` rows - absent on every other Account-shaped response (`GET /account`, `POST /accounts`, `PATCH /accounts/:id`, …).
+             * @example 8765.66
+             */
+            totalFiat?: number;
+            /** @description Every chain this ONE logical account exists on, one entry per backing row. Present only where an Account is a COLLAPSED group - `GET /accounts` rows and the `PATCH /accounts/:id` response - and absent everywhere else (`GET /account`, `POST /accounts`, …), which return a single chain's row and mean it. Its presence is what says "this is the account, not one chain of it". The entries carry the per-chain truth the collapsed fields can only summarise: `deploymentStatus` and `frozen` genuinely differ per chain, and `accountId` is what an inherently per-chain operation (`POST /account/freeze` and `/unfreeze`, `POST /accounts/{id}/tokens`) must be given to target one specific chain. */
+            chains?: components["schemas"]["AccountChain"][];
+        };
+        /** @enum {string} */
+        AccountDeploymentStatus: "counterfactual" | "deployed";
+        /** @description One chain a logical account exists on. NOT a separate account: every entry shares the owner's `address`, `label` and `index` - the same counterfactual Kernel account, whose deployment state is per-chain. */
+        AccountChain: {
+            /** @example 84532 */
+            chainId: number;
+            /**
+             * @description The backing row's id, for endpoints that act on ONE chain. The group's own `id` is the canonical row's id and appears here too.
+             * @example acct_01H8
+             */
+            accountId: string;
+            deploymentStatus: components["schemas"]["AccountDeploymentStatus"];
+            /** @description This chain's own kill-switch state - AgentGuard is deployed per chain, so an account can be frozen on one chain and live on another. */
+            frozen: boolean;
+            /**
+             * @description Whether this chain carries BotanaryPolicyValidator at all - i.e. whether signers and signing policies could EVER work here, independent of anything about this account.
+             *
+             *     A CLIENT CANNOT DERIVE THIS. `chainTier` is no substitute: it keys off `agentGuard`, a different contract, so a `basic`-tier chain and a validator-carrying one are indistinguishable through it. Shipping without this field meant the signing-policy network selector offered - and defaulted to - chains where the feature is permanently impossible.
+             *
+             *     Deliberately about the CHAIN, not the account. `installed`/`migrationEligible` (GET /account/policies) answer "can THIS account use it here", a different and later question. A chain that is `false` here can never become usable; one that is `true` but not yet installed only needs a step, and must stay offered so the owner can take it.
+             */
+            authorityCore: boolean;
+        };
+        /** @description TWO shapes, discriminated by `action`. Omitting `action` is a TRANSFER - `recipient` and `amount` required, unchanged since the route's first shape. Which token it moves is named by `token` (a contract address or CAIP-19 asset ref - Task A11) or, for callers that predate that field, the LEGACY `tokenSymbol` (by symbol); both are optional when the delegation budgets exactly one token. `action: swap` is the swap shape: it requires `tokenIn`, `tokenOut` and `amountIn`, ignores `recipient`/`amount`/`token`/`tokenSymbol`, and is GRANT-ONLY. A swap is refused `grant_swap_not_authorised` unless the grant was built with a `swapVenue` AND the route agrees with the router, token and allowance ceiling that venue pins; and `route_spender_mismatch` when the route's approval spender and router are different addresses (a grant approves exactly the contract it calls, so such a route is not expressible). */
+        DelegatedActionInput: {
+            /**
+             * @description Which shape this body is. Omitted → transfer.
+             * @enum {string}
+             */
+            action?: "transfer" | "swap";
+            /** @description TRANSFER shape, required there. The transfer recipient (re-checked against the delegation's allowlist on-chain). */
+            recipient: string;
+            /** @description TRANSFER shape, required there. Amount in the delegation's stablecoin (re-checked against per-action + cumulative caps). */
+            amount: number;
+            /**
+             * @description TRANSFER shape. Which budgeted token to move, by contract address or CAIP-19 asset ref - NEVER a symbol. Same pattern and same rule as `CliSendIntent.token` (see that field's own description): a symbol is a label a contract chose for itself, and this route will not guess which one a caller meant. Optional when the delegation budgets exactly one token (defaults to it); when it budgets more than one, name it explicitly here or in `tokenSymbol` below, or the build is refused rather than silently picking the first budgeted token. Whenever named, must be one of the tokens this delegation actually budgets, or the build declines `stablecoin_not_permitted`.
+             * @example 0x036CbD53842c5426634e7929541eC2318f3dCF7e
+             */
+            token?: string;
+            /** @description TRANSFER shape. LEGACY - the pre-Task-A11 way to name a budgeted token, BY SYMBOL (e.g. "USDC"). Kept only for callers that predate `token` above; prefer `token`, since a symbol is a label a contract chose for itself and two contracts on one chain can share one. Also matched against the delegation's budgeted assetRefs and declined `stablecoin_not_permitted` when it names an unbudgeted token. */
+            tokenSymbol?: string;
+            /** @description SWAP shape, required there. The token being SOLD, by symbol. Must be the one token this grant's swapVenue pins. */
+            tokenIn?: string;
+            /** @description SWAP shape, required there. The token being BOUGHT, by symbol. Unbounded by the grant - what the account receives increases its holdings, and a grant meters only what leaves. */
+            tokenOut?: string;
+            /** @description SWAP shape, required there. How much of tokenIn to sell, in display units. Must be at or under the venue's maxAllowance. */
+            amountIn?: number;
+            /** @description SWAP shape. Slippage tolerance for the route quote. Defaults to 50 bps. */
+            maxSlippageBps?: number;
+        };
+        /** @description A built (unsigned) op ready for the owner to sign, with the hash to sign + context. */
+        UserOpBuild: {
+            intentType: components["schemas"]["IntentType"];
+            userOp: components["schemas"]["UnsignedUserOp"];
+            userOpHash: components["schemas"]["Hash32"];
+            humanSummary?: string | null;
+            simulation?: components["schemas"]["Simulation"] | null;
+            /** @description Present for swaps whose route supplies exact output amounts; never derived from rounded display amounts. */
+            swapQuote?: components["schemas"]["SwapExecutionQuote"];
+            /** @description Freeze/revoke/withdraw-to-safety - instant, never gated on native gas (FR-2/FR-8). */
+            riskReducing: boolean;
+            instant: boolean;
+            /** @description Pre-wired to the sponsored / revoke-only paymaster. */
+            gasless: boolean;
+            /** @description Set only when the send chose to pay its fee in USDC. When present, `userOpHash` above is stale - the client attaches `paymasterData` and recomputes it. See GasPermit. */
+            gasPermit?: components["schemas"]["GasPermit"] | null;
+            /** @description Set only when the send chose to pay its fee in USDT and the account's on-chain allowance needed raising. INFORMATIONAL: `calls` are already batched into `userOp.callData`, so - unlike `gasPermit` - no second signature is required and `userOpHash` above remains the hash to sign. */
+            usdtApproval?: components["schemas"]["UsdtApproval"] | null;
+            /** @description Present ONLY for `intentType: farm_deposit` / `farm_withdraw` - live exit constraints for the target pool, probed after the op is built and never cached, so what the owner sees is what the chain says at signing time. Absent (not merely null) for every other intentType. */
+            exit?: components["schemas"]["ExitTerms"] | null;
+            /** @description Present for `intentType: farm_deposit` / `farm_withdraw` / `farm_claim` (Plan 5 Task 4/7 extends this to the claim build), alongside `exit` above where applicable - the verbs this pool's adapter implements for this account, from the same live probe (design spec §7). Absent for every other intentType, and optional here so this addition is non-breaking for clients that predate it. */
+            verbs?: components["schemas"]["VerbAvailability"][];
+            /** @description Present ONLY for `intentType: farm_claim` (Plan 5 Task 4/7) - the reward rows this build read from the SAME probe used to decide whether to build at all, so a client can show what was actually claimed without a second round trip. Absent (not merely `[]`) for every other intentType, including `farm_deposit`/`farm_withdraw` - see `ClaimableReward` for the absence-vs-empty distinction this field itself carries when it IS present. */
+            claimable?: components["schemas"]["ClaimableReward"][];
+            /** @description Present ONLY for the seven v1-authority-core `intentType`s (`policy_set`, `policy_remove`, `signer_add`, `signer_remove`, `guardians_set`, `condition_set_member_set`, `signers_recover`) - what this op costs, both today and once it lands. Absent for every other intentType. */
+            securityPricing?: components["schemas"]["SecurityPricing"] | null;
+            /** @description Present ONLY for `intentType: signers_recover` (Flow 9). Every ACTIVE policy whose `approvals` requirement is clamped down by this signer-set rotation - empty (never absent) when none is affected. Absent for every other intentType. See `PolicyImpact` for exactly what this does and does not capture. */
+            policyImpact?: components["schemas"]["PolicyImpact"][] | null;
+            /** @description Present ONLY for `intentType: signers_recover`, always `true` there - `recover` unconditionally deletes the account's guardian set as part of the same call, regardless of `newSigners`/ `newThreshold`. A structured twin of the same fact already stated in `humanSummary`. Absent for every other intentType. */
+            guardiansCleared?: boolean | null;
+        };
+        /** @enum {string} */
+        IntentType: "send" | "swap" | "delegation_enable" | "delegation_freeze" | "delegation_unfreeze" | "delegation_revoke" | "account_freeze" | "account_unfreeze" | "rules_update" | "guardian_add" | "guardian_remove" | "account_deploy" | "account_fund" | "panic_install" | "panic_freeze" | "delegated_action" | "device_add" | "device_remove" | "device_threshold" | "managed_deposit" | "agent_deposit" | "farm_deposit" | "farm_withdraw" | "farm_claim" | "pay_sh_topup" | "policy_set" | "policy_remove" | "signer_add" | "signer_remove" | "signer_threshold" | "guardians_set" | "condition_set_member_set" | "signers_recover" | "action_announce" | "authority_migration_op_a" | "authority_migration_op_b" | "trust_anchor_set" | "apis_budget_commit" | "apis_budget_revoke";
+        /** @description ERC-4337 (EntryPoint v0.7) UserOp with an empty signature. The owner signs `userOpHash` (returned alongside in the build envelope) client-side against their Privy embedded wallet. The backend builds and later relays it - it never signs. */
+        UnsignedUserOp: {
+            sender: components["schemas"]["Address"];
+            /**
+             * @description uint256 as a decimal/hex string.
+             * @example 0
+             */
+            nonce: string;
+            factory?: components["schemas"]["Address"] | null;
+            factoryData?: components["schemas"]["Hex"] | null;
+            callData: components["schemas"]["Hex"];
+            /** @example 200000 */
+            callGasLimit: string;
+            /** @example 150000 */
+            verificationGasLimit: string;
+            /** @example 50000 */
+            preVerificationGas: string;
+            /** @example 1000000000 */
+            maxFeePerGas: string;
+            /** @example 1000000000 */
+            maxPriorityFeePerGas: string;
+            paymaster?: components["schemas"]["Address"] | null;
+            paymasterVerificationGasLimit?: string | null;
+            paymasterPostOpGasLimit?: string | null;
+            paymasterData?: components["schemas"]["Hex"] | null;
+            signature: components["schemas"]["Hex"];
+            entryPoint: components["schemas"]["Address"];
+            /** @example 42161 */
+            chainId: number;
+        };
+        /**
+         * @description Arbitrary-length hex byte string (calldata, paymaster data, signature).
+         * @example 0x
+         */
+        Hex: string;
+        /** @description Advisory pre-flight (FR-4). The on-chain hook re-asserts. */
+        Simulation: {
+            id: string;
+            intentType: components["schemas"]["IntentType"];
+            willSucceed: boolean;
+            declineReason?: components["schemas"]["DeclineReason"] | null;
+            amountIn?: components["schemas"]["TokenAmount"] | null;
+            amountOut?: components["schemas"]["TokenAmount"] | null;
+            /** @example 1.08 */
+            rate?: number | null;
+            /** @example USDC → EURC via Uniswap v3 */
+            route?: string | null;
+            /** @example 30 */
+            slippageBps?: number | null;
+            fees: components["schemas"]["TokenAmount"][];
+            gas: components["schemas"]["GasEstimate"];
+            warnings: string[];
+            /** Format: date-time */
+            expiresAt?: string | null;
+        };
+        GasEstimate: {
+            method: components["schemas"]["GasMethodName"];
+            cost?: components["schemas"]["TokenAmount"] | null;
+            sponsored: boolean;
+        };
+        /** @description Exact quote amounts in integer base units, associated with this unsigned swap build. These are estimates for review and subsequent financial-effect reconciliation. This object alone does not prove that the router calldata enforces a minimum or that execution settled. */
+        SwapExecutionQuote: {
+            chainId: number;
+            toChainId: number;
+            accountAddress: components["schemas"]["Address"];
+            /** @description Input token address, or the zero address for native currency. */
+            inputAsset: components["schemas"]["Address"];
+            /** @description Output token address, or the zero address for native currency. */
+            outputAsset: components["schemas"]["Address"];
+            /** @description Exact input amount, at most uint256 max. */
+            amountInRaw: string;
+            /** @description Estimated output amount, at most uint256 max. */
+            estimatedOutRaw: string;
+            /** @description Quoted minimum output, no greater than estimatedOutRaw. */
+            minimumOutRaw: string;
+        };
+        /**
+         * @description Present only when `gasMethod: usdc`. Everything the client needs to let the Circle Paymaster take this op's network fee in USDC, and nothing it could compute for itself.
+         *
+         *     The paymaster is paid through a USDC EIP-2612 permit whose `owner` is the SMART ACCOUNT, so USDC verifies it via ERC-1271 and the owner signs a Kernel-wrapped digest rather than the permit's own EIP-712 hash. The backend reads the chain and computes that digest. **It holds no key and produces no signature** - a hash is not an authorization.
+         *
+         *     The permit is independent of the UserOp, while `paymasterData` is hashed INTO the userOpHash. The order is therefore forced, and **`UserOpBuild.userOpHash` is NOT the hash to sign when this object is present**: sign `permitDigest`, assemble `paymasterData` as `abi.encodePacked(uint8 0, token, permitAmount, signaturePrefix ‖ permitSignature)`, RECOMPUTE the userOpHash over the completed op, sign that, then relay. Two owner signatures per USDC-gassed op; USDC's permit nonce increments on use, so a permit is single-shot and cannot be cached.
+         *
+         *     Every field of the permit is returned, not just the digest, so a client can rebuild the digest and refuse to sign one it did not derive.
+         */
+        GasPermit: {
+            paymaster: components["schemas"]["Address"];
+            token: components["schemas"]["Address"];
+            /**
+             * @description The token's on-chain `name()` - part of its EIP-712 domain. Differs per chain.
+             * @example USD Coin
+             */
+            tokenName: string;
+            /** @example 2 */
+            tokenVersion: string;
+            /**
+             * @description The account version whose ERC-1271 wrapper produced `permitDigest`.
+             * @example 0.3.3
+             */
+            kernelVersion: string;
+            /**
+             * @description The permit's `value`, in the token's base units. MUST equal the amount encoded into `paymasterData`; the two are checked against each other on-chain.
+             * @example 212142
+             */
+            permitAmount: string;
+            /** @example 2 */
+            permitNonce: string;
+            /** @description uint256 max - a permit is spent by its nonce, not by time. */
+            permitDeadline: string;
+            permitDigest: components["schemas"]["Hash32"];
+            /** @description Prepend to the owner's 65-byte signature - Kernel's ERC-1271 envelope (`0x01 ‖ rootValidator`). */
+            signaturePrefix: components["schemas"]["Hex"];
+            /**
+             * @description The USDC the paymaster pulls up front in the validation phase, refunding the unused part in postOp. The account must hold this on top of the amount it is sending.
+             * @example 0.031296
+             */
+            estimatedFee: number;
+        };
+        /** @description The one-time on-chain USDT allowance Pimlico's ERC-20 paymaster needs before it can pull its fee. Present only when `gasMethod: usdt` AND the account's current on-chain `USDT.allowance(account, paymaster)` is insufficient - omitted once approved. USDT has no EIP-2612 permit: `calls` are already batched into `UserOpBuild.userOp.callData`, so there is no digest and no second signature. INFORMATIONAL only - render it, but never collect a second signature. */
+        UsdtApproval: {
+            /** @description USDT on this chain - also every `calls[i].to`. */
+            token: components["schemas"]["Address"];
+            /** @description The Pimlico ERC-20 paymaster being granted the allowance - matches `userOp.paymaster`. */
+            paymaster: components["schemas"]["Address"];
+            /** @description The amount being approved, in USDT base units (a large, persistent allowance). */
+            amount: string;
+            /** @description Unsigned calls, already batched into the op the owner signs once. */
+            calls: components["schemas"]["UsdtApprovalCall"][];
+        };
+        /** @description One unsigned ERC-20 call, ready to batch into the account's own execution ahead of its intended action (Kernel v3.3 `execute`, batch mode). Not a signed leg - see `UsdtApproval`. */
+        UsdtApprovalCall: {
+            to: components["schemas"]["Address"];
+            data: components["schemas"]["Hex"];
+            /** @description Always `"0"` - an ERC-20 `approve` carries no native value. */
+            value: string;
+        };
+        /** @description Live exit constraints, probed at read time and NEVER cached. ERC-4626 does not guarantee an owner can leave: `maxWithdraw`/`maxRedeem` exist in the standard precisely because a vault can cap exits behind a notice period, a withdrawal queue, or simply pay out only what is currently liquid. All amounts are base-unit decimal strings, never numbers - a vault's TVL overflows float64 precision. */
+        ExitTerms: {
+            /** @description The underlying actually sitting in the vault/reserve right now, base units - ACCOUNT-INDEPENDENT, and the one honest pre-deposit signal: `maxWithdraw` is 0 and meaningless before the account holds any shares. */
+            liquidAssets: string;
+            /** @description The account's own live `maxWithdraw`, base units - what `POST /farm/withdraw/build` enforces against. Null when no account was in scope for the probe (`GET /farm/pools/{id}/terms`, asked before any deposit exists) - never a false zero standing in for "unknown". */
+            maxWithdrawAssets: string | null;
+            /** @description Same null convention as `maxWithdrawAssets`, share-denominated. */
+            maxRedeemShares: string | null;
+            /** @description True only when the account's WHOLE position can be withdrawn right now. Null under the same no-account-in-scope condition as `maxWithdrawAssets`. */
+            fullExitAvailable: boolean | null;
+            /**
+             * Format: date-time
+             * @description When this probe ran. Never cached - always "now", not a stale sync timestamp.
+             */
+            probedAt: string;
+        };
+        /**
+         * @description Whether an account can perform ONE verb against a pool RIGHT NOW, discovered from live chain state (design spec §7) rather than an editorial table. Two things the field names alone do not convey:
+         *
+         *     ABSENCE of a verb from the containing `verbs` array is meaningful, and DIFFERENT from an entry present with `available: false`. Absence means this adapter has NO CLAIM PATH at all for this pool - e.g. `claim` on any pool but Aave-v3 (EVM) or Kamino (Solana). An entry present with `available: false` means the verb IS implemented but is closed right now, with `reason` saying why - for `claim` specifically, `nothing_accrued` (a reward program exists, proven zero accrued) or `rewards_unreadable` (the accrual read itself failed - never reported as a zero, see `ClaimableReward`). Clients depend on this distinction - do not conflate the two.
+         *
+         *     `max: null` means NO PROVEN BOUND, never "unlimited" - a client must not render `null` as a Max amount.
+         */
+        VerbAvailability: {
+            verb: components["schemas"]["PoolVerb"];
+            available: boolean;
+            /** @description Upper bound in the asset's base units, when the adapter can PROVE one. `null` means no proven bound - see the schema description above. */
+            max: string | null;
+            /** @description Machine-readable why-not. Always `null` when `available` is true. */
+            reason: string | null;
+        };
+        /**
+         * @description One action a pool's adapter can attempt against a live pool (design spec §7): `deposit`, `withdraw`, or `claim`. As of Plan 5, `claim` is a REAL verb two adapters emit: the EVM Aave-v3 adapter (`class: lending`, reading `DEFAULT_INCENTIVES_CONTROLLER`) and the Solana Kamino adapter (`class: kamino-lend`, reading a farm's `UserState`). Every other adapter (ERC-4626, Compound v3, Marinade, Solend, Jito) still never emits it - see `VerbAvailability`'s own description for what that absence means versus a present-but-closed entry.
+         * @enum {string}
+         */
+        PoolVerb: "deposit" | "withdraw" | "claim";
+        /**
+         * @description One accrued reward-token row (design spec §9, Plan 5). Reward tokens are frequently NOT the pool's own asset (e.g. ARB or GHO accrued on an Aave USDC reserve) - `token`/`symbol`/`decimals` describe the REWARD, not the pool.
+         *
+         *     Two things a client cannot infer from the field names alone, and must not conflate:
+         *
+         *     `claimable: []` on a probe response with NO `claim` entry in that same response's `verbs` means this adapter has NO CLAIM PATH for this pool at all - never fabricate a row to fill the gap.
+         *
+         *     A `claim` entry present in `verbs` with `available: false` means claimable IN PRINCIPLE, not right now, and `verbs[].reason` says why - `claimable` itself may still be `[]` in that case (nothing accrued, a PROVEN zero - see `nothing_accrued`) or may carry a nonzero row alongside an `available: false` entry caused by something else entirely (e.g. the reward could not be priced - pricing never gates availability, see `usdValue` below).
+         */
+        ClaimableReward: {
+            /**
+             * @description The reward token's contract address (EVM) or mint (Solana) - never the pool's own asset.
+             * @example 0x912CE59144191C1204E64559FE8253a0e49E6548
+             */
+            token: string;
+            /** @description Accrued amount in the reward token's own base units, base-unit decimal string like every other on-chain amount in this API. NEVER a fabricated zero standing in for "the read failed" - see the schema description above. */
+            amount: string;
+            /** @description Null when the reward token's symbol could not be resolved. */
+            symbol: string | null;
+            /** @description Null when the reward token's decimals could not be resolved. */
+            decimals: number | null;
+            /** @description Best-effort USD value of `amount`, priced through the existing oracle/market-data port (Plan 5 Task 5). `null` when the price is missing, stale, the source is unreachable, or `decimals` above is itself `null` (no honest way to scale `amount` into a human figure to price). DISPLAY ONLY: a missing price must NEVER suppress the `claim` verb or drop a row from `claimable` - a claimable reward with no price is still claimable. No "guaranteed" or APY language applies to this figure. */
+            usdValue: number | null;
+        };
+        /** @description What a policy/signer/guardian/condition-set change costs. `before` is `securityThresholdOf` as it stood BEFORE this change - the number of approvals the returned op itself needs - so tightening a send-policy from 2 to 3 costs 2, and loosening it from 3 back to 2 costs 3. `after` is what `securityThresholdOf` becomes once this change lands, so the UI can show the new cost before the owner commits. */
+        SecurityPricing: {
+            before: number;
+            after: number;
+        };
+        /**
+         * @description One ACTIVE policy whose required approval COUNT no longer fits a `signers_recover` rotation (Flow 9 - flows doc §5 test 30 / §3.6.1: "any policy that no longer fits comes down with them - shown before it takes effect"). `approvalsAfter` is always `<= approvalsBefore` (a rotation can only ever shrink what fits) and always `>= 1` (an active policy is never silently zeroed by this preview - `recover` can never leave an account with zero signers).
+         *     DELIBERATELY NARROWER THAN "everything recover changes about this policy". Every ACTIVE policy is ALSO repointed to the WHOLE new signer set, regardless of whether it appears here - a policy that named one specific person becomes satisfiable by any of the new signers. That repoint is unconditional and already stated in the build's `humanSummary`; this list surfaces only the policies whose required NUMBER of approvals actually drops.
+         */
+        PolicyImpact: {
+            slot: number;
+            approvalsBefore: number;
+            approvalsAfter: number;
+        };
+        ExactDelegatedActionInput: {
+            accountId: string;
+            accountAddress: string;
+            chainId: number;
+            /** @enum {string} */
+            action: "transfer" | "swap";
+            tokenAddress: string;
+            /** @description Positive integer base units. Maximum uint256; never converted through a floating-point amount for encoding or route requests. */
+            amount: string;
+            recipient?: string;
+            tokenOutAddress?: string;
+            /** @description Defaults to 50 basis points for swaps. Omit for transfers. */
+            maxSlippageBps?: number;
+        } & ({
+            /** @constant */
+            action: "transfer";
+            recipient: string;
+        } | {
+            /** @constant */
+            action: "swap";
+            tokenOutAddress: string;
+        });
+        ExactDelegatedActionBuild: components["schemas"]["UserOpBuild"] & {
+            execution: components["schemas"]["ExactDelegatedExecution"];
+        };
+        ExactDelegatedExecution: {
+            delegationId: string;
+            permissionId: string;
+            accountId: string;
+            accountAddress: string;
+            chainId: number;
+            /** @enum {string} */
+            action: "transfer" | "swap";
+            tokenAddress: string;
+            /** @description Positive integer base units. Maximum uint256; never converted through a floating-point amount for encoding or route requests. */
+            amount: string;
+            recipient?: string;
+            tokenOutAddress?: string;
+            /** @description Defaults to 50 basis points for swaps. Omit for transfers. */
+            maxSlippageBps?: number;
+            /** @constant */
+            gasMethod: "native";
+        };
+        /** @description A previously built op with the owner's client-side signature attached, for relay. */
+        SignedUserOp: {
+            userOp: components["schemas"]["UnsignedUserOp"];
+            userOpHash: components["schemas"]["Hash32"];
+            intentType: components["schemas"]["IntentType"];
+            /** @description Owner-browser-only durable approval context. Never accepted from an agent or platform credential. */
+            hostedOperation?: components["schemas"]["HostedOperationContext"];
+        };
+        HostedOperationContext: {
+            operationId: string;
+            attemptId: string;
+        };
+        UserOpReceipt: {
+            /** @example op_01H8 */
+            id: string;
+            userOpHash: components["schemas"]["Hash32"];
+            status: components["schemas"]["UserOpStatus"];
+            txHash?: components["schemas"]["Hash32"] | null;
+            /** Format: date-time */
+            submittedAt: string;
+            error?: string | null;
+        };
+        /** @enum {string} */
+        UserOpStatus: "pending" | "included" | "failed";
+        /** @description One page of the ranked provider catalog, with the total it is a page of. */
+        ApiProviderList: {
+            /** @description This page, ranked by `rankScore` descending then `id` ascending. */
+            providers: components["schemas"]["ApiProviderListItem"][];
+            /** @description Providers matching the filters BEFORE paging. */
+            total: number;
+            /** @description EXACT count of providers withheld. Never capped - the number is the honest part. Since spec 2026-08-26 §12 this is usually the LARGE number: the catalog returns only providers a paid call could complete against, so a provider that has never been measured on this chain is withheld with `provider_unverified`, and most of the catalog is in that state. */
+            hidden: number;
+            /** @description Why providers were hidden, mapped from providerId. Capped at 50 entries, because a chain filter over ~1,498 providers would otherwise staple tens of kilobytes of explanation to a 50-row page. */
+            reasons: {
+                [key: string]: string;
+            };
+            /** @description True when `reasons` was cut short of `hidden`. A cap the caller cannot see is a cap that lies, so the cut is reported rather than left for the map and the count to disagree about. */
+            reasonsTruncated: boolean;
+            /** @description How much of the catalog in scope has actually been MEASURED. Not decoration: the catalog returns only what a paid call could complete against, and the large majority of endpoints have never been probed - so a short or empty page is usually a measurement gap rather than a broken catalog, and this is what lets a surface say which. */
+            coverage: {
+                /** @description Endpoint rows in scope carrying at least one probe on a chain in scope. Intersected with the live catalog, so a probe that outlived the endpoint it measured cannot inflate it. */
+                probedEndpoints: number;
+                /** @description Endpoint rows in scope. Never less than `probedEndpoints`. */
+                totalEndpoints: number;
+            };
+        };
+        /** @description One row of the catalog grid. Deliberately carries NO `endpoints` array - at ~14,000 endpoints across ~1,498 providers, one of them with 965 endpoints of its own, inlining them makes the list a multi-megabyte response to render a grid that shows a count. `GET /apis/providers/{providerId}` serves the endpoints, a page at a time. */
+        ApiProviderListItem: {
+            id: string;
+            name: string;
+            /** @description Grouping the surface filters on, e.g. search, market-data, onchain-analytics. */
+            category: string;
+            /** @description The provider's human documentation page, WITHHELD once a sync has checked it and found it dead. A 200 is not enough to keep it: `arkham.io/docs` answers 200 with a parked "domain for sale" page, so the check also requires a real page title. Null here therefore means "no docs link to offer", never "not checked yet", and the surface renders no button. */
+            docsUrl: string | null;
+            /** @description The provider's own OpenAPI document, where a sync found one. It is both the source of that provider's `openapi` endpoint rows and the fallback the detail page links as "API reference" when there is no live `docsUrl`. A machine document, not a written guide, and labelled as such wherever it is rendered. */
+            openapiUrl: string | null;
+            baseUrl: string;
+            /** @description Owner has blocked this provider for EVERY agent on this account, whatever their mandates say. Absent state is `false` - a catalog of ~36,000 endpoints is not something an owner opts into one at a time. A convenience filter and a kill-switch, never an authority bound: what binds money is `ApiMandate` plus the on-chain envelope. Was `enabled` (inverted) until spec 2026-08-30 §3.2. */
+            blocked: boolean;
+            /** @description Sorted unique set of chains this provider's listed endpoints sit on. This CAN be the whole supported set: an endpoint that has never been probed and declares no chain of its own is evidence-free, so with no chain filter it lists on every supported chain. That is what "we do not know where this runs" looks like, not a claim that the provider is live everywhere. */
+            chains: number[];
+            /** @description True for the hand-maintained catalog; false for discovery-index entries. Also the list's first sort key, and the surface renders it as a "Verified" badge against "Community" - a curated entry is one a human checked, where a discovered one is self-reported. */
+            curated: boolean;
+            /** @description Responses are synthetic. Must remain visible to agents, not only to humans. */
+            simulated: boolean;
+            /** @description The provider's own mark, hosted by the provider: the icon it registered with the discovery index if it has one, otherwise the icon its own website serves, resolved once at sync time. Null when neither exists, and the surface falls back to a monogram rather than inventing one. */
+            iconUrl: string | null;
+            description: string | null;
+            /** @description DISTINCT endpoints matching the filters, not listing rows - an endpoint listed on two chains is still one endpoint. */
+            endpointCount: number;
+            /** @description Distinct endpoints we have actually MEASURED - a 402 we parsed, or a 200 proving the endpoint is free. Never exceeds `endpointCount`. */
+            verifiedCount: number;
+            /** @description The provider's busiest endpoint in 30-day unique payers. The list's sort key. */
+            rankScore: number;
+            /** @description Cheapest price across this provider's listed endpoints, in atomic token units. Null when no endpoint carries a usable price. */
+            minPriceUnits: string | null;
+            /** @description Dearest price across this provider's listed endpoints, in atomic token units. */
+            maxPriceUnits: string | null;
+        };
+        /** @description One provider: every field of `ApiProviderListItem`, plus one page of its endpoints and the `endpointTotal` that page is a page of. */
+        ApiProviderDetail: components["schemas"]["ApiProviderListItem"] & {
+            /** @description One page of endpoints, busiest first. One endpoint listed on two chains appears once per chain, each row with its own price and payability. */
+            endpoints: components["schemas"]["ApiEndpointSummary"][];
+            /** @description Endpoints matching the filters BEFORE paging - what `endpoints` is a page of. */
+            endpointTotal: number;
+            /** @description Where this provider is available, when the family being viewed is not it. A family view drops every listing measured as selling elsewhere, so this is what tells an owner on Testnet that the provider is available on Mainnet at all. Built from the other family's OWN probes - distinct endpoints measured `verified` or `free` there - never inferred from the rows dropped here, because a probe records THAT a provider quoted elsewhere and not WHERE. Null when no `net` was requested and null at a count of zero, so a client renders the pointer only when there is something to point at. */
+            otherFamily?: {
+                /**
+                 * @description The family the endpoints below were measured on. Never the family being viewed.
+                 * @enum {string}
+                 */
+                net: "mainnet" | "testnet";
+                /** @description Distinct endpoints measured available in that family - `verified` or `free`, so this counts reachability and not sales. */
+                endpointCount: number;
+            } | null;
+        };
+        /** @description One endpoint under a provider, on one chain. */
+        ApiEndpointSummary: {
+            id: string;
+            path: string;
+            /** @enum {string} */
+            method: "GET" | "POST" | "HEAD" | "PUT" | "PATCH" | "DELETE";
+            summary: string;
+            /** @description Owner has blocked this endpoint for every agent on this account. Resolved: true when EITHER this endpoint or its provider is blocked. Absent state is `false`. Was `enabled` (inverted) until spec 2026-08-30 §3.2. */
+            blocked: boolean;
+            /** @description The chain this endpoint is listed on. Endpoints of one provider may differ. */
+            chainId: number;
+            /** @description Price in atomic token units - measured where `verification` is `verified`, otherwise the provider's own declaration. Null on a `free` endpoint and wherever no usable figure exists; never a fabricated zero. */
+            priceUnits: string | null;
+            asset: string | null;
+            /** @description Whether a paid call to this row could succeed at all. True only when an x402PaymentValidator is deployed on this endpoint's chain, the endpoint's `method` is one the paid lane can settle (GET or POST), `verification` is not `free`, AND `verification` is `verified` - that is, a probe has actually MEASURED a settleable 402 here. Never a policy decision - see `blocked` for that. The measured clause is spec 2026-08-26 §12: without it a never-probed row and a measured-failing row both read as payable, which offers a call the proxy would decline. */
+            payable: boolean;
+            /** @description Which of them, when `payable` is false. Reported in the order the proxy itself checks them, so the reason named is the one a caller would actually hit: `chain_capability_unavailable` (no validator on this chain - the only one a caller can act on, so it leads), `unsupported_endpoint_method` (the discovery index publishes all six verbs; the paid lane settles only GET and POST, and will not issue a stranger's DELETE to discover its price), `no_payment_required` (we measured a 200; there is nothing to settle), `provider_unverified` (never probed on this chain, so we cannot say a paid call would complete - the ORDINARY case, since most endpoints have never been probed), `provider_unreachable` (the last probe genuinely failed) or `provider_unavailable_on_chain` (measured as quoting elsewhere). */
+            unpayableReason: string | null;
+            /**
+             * @description What we MEASURED, never a gate. `verified` - a probe returned a 402 quoting this chain. `free` - a probe returned 200. `declared` - not probed yet, so price and asset are the provider's own claim. `other_chain` - the provider answered with a valid 402 but quoted payment on a DIFFERENT chain, so there is nothing to settle against here; it is reachable and is not a failure. A listing in this state is dropped from every family-scoped and chain-filtered response before a client ever sees it, so the value is retained in this enum only for backward compatibility and no longer appears on a returned row. `unreachable` - the last probe genuinely failed (a non-402 status, an unparseable challenge, a timeout); still listed, so a vanished provider has an explanation rather than silently disappearing. `other_chain` was carved OUT of `unreachable`: 650 of 1,510 stored probes are that case, and reporting a live provider as unreachable because it sells on mainnet is a false claim about a third party.
+             * @enum {string}
+             */
+            verification: "verified" | "free" | "declared" | "unreachable" | "other_chain";
+            /** @description 30-day unique payers, from the discovery index. A ranking signal only, never a gate. */
+            uniquePayers: number;
+            /** @description The provider's own OpenAPI OPERATION for this endpoint - `parameters` plus the JSON Schema at `requestBody.content['application/json'].schema` - matched by path and method from a document the SITE pass already fetched. NULL means the provider publishes no OpenAPI document, the sync has not read it yet, or the matched operation exceeded the size this catalog is willing to store (half a schema is worse than none). A NULL HERE MEANS THE CALLING AGENT IS GUESSING AT THE REQUEST SHAPE - there is no way to tell "no schema published" from "not fetched yet" apart from this field alone, and `call_api` pays before the provider gets a chance to reject a malformed body. */
+            requestSchema: {
+                parameters?: unknown[];
+                requestBody?: unknown;
+            } | null;
+        };
+        /** @description The current API budget state for an agent on a chain. */
+        ApiBudget: {
+            agentId: string;
+            chainId: number;
+            /** @description Unused indices below count. */
+            remaining: number;
+            /** @description Maximum value per call in token units. */
+            perCallMax: string;
+            /** Format: date-time */
+            expiresAt: string;
+            epoch: number;
+            /** @description The ERC-20 token address. */
+            token: string;
+            /** @description Maximum value exposure in token units. */
+            maxExposure: string;
+            /** @description Amount already spent in token units. */
+            spent: string;
+        };
+        /** @description The disjoint outcomes of `buildApiCallRequirements` - see each branch's own description. A `oneOf` discriminated on the literal `status` value (mirrors the `kind`-discriminated intent union on `POST /delegations/build`), so a client can never read `payload`/`authorization`/ `index`/`validator` off a response that carries none of them. */
+        ApiCallRequirements: components["schemas"]["ApiCallRequirementsReady"] | components["schemas"]["ApiCallRequirementsPending"];
+        /** @description `buildApiCallRequirements`'s ready branch - carries the EIP-3009 payload to sign, plus everything else a client needs to build the ERC-1271 envelope around its signature. For a Kernel account (the only kind this product ever creates) the relay signature is `0x01 || validator || abi.encode(agentKey, authorization, index, rawSig)`: `index` is a stateful server-side reservation with no formula a caller could reproduce, `authorization.validBefore` is stamped off the server's clock, and `validator` is returned rather than hardcoded because deployment addresses are nonce-shifted between chains - the same address is `agentGuard` on one chain and something else on another. */
+        ApiCallRequirementsReady: {
+            requirementId: string;
+            /**
+             * @description discriminator enum property added by openapi-typescript
+             * @enum {string}
+             */
+            status: "ready";
+            /** @description The EIP-3009 digest to sign. */
+            payload: string;
+            /** @description The provider's own quoted payment schemes (the x402 `accepts` array), echoed so a client can show what it is about to pay for without re-challenging. */
+            requirements: {
+                [key: string]: unknown;
+            }[];
+            /** @description The EIP-3009 authorization the payload digests. */
+            authorization: components["schemas"]["X402Authorization"];
+            /** @description The reserved authorization index. */
+            index: number;
+            /** @description The `X402PaymentValidator` address on this chain - bytes 1 to 20 of the Kernel ERC-1271 envelope a client must build around its signature. */
+            validator: string;
+        };
+        /** @description The exact EIP-3009 `TransferWithAuthorization` tuple `payload` digests. Building the Kernel- prefixed ERC-1271 signature envelope needs this verbatim - see `X402ProxyService.buildRequirements`'s own doc comment in the BE source for the byte layout. */
+        X402Authorization: {
+            /** @description The owner's account address. */
+            from: string;
+            /** @description The provider's `payTo` address. */
+            to: string;
+            /** @description Base units, decimal string - the wire format, not a bigint. */
+            value: string;
+            /** @description Unix seconds, decimal string. Always '0' today. */
+            validAfter: string;
+            /** @description Unix seconds, decimal string - timestamped off the BACKEND's clock at build time, never the caller's, and bounded by the provider's own stated timeout. */
+            validBefore: string;
+            /** @description 32 bytes, hex. Read live from `X402PaymentValidator.authorizationNonce` for this exact (epoch, index) - never generated by the backend. */
+            nonce: string;
+        };
+        /** @description `buildApiCallRequirements`'s pending branch (Task 11) - the quoted call crossed the agent's mandate `confirmAbove` threshold, so nothing sign-able was built. THE SECURITY PROPERTY: `payload`, `authorization`, `index` and `validator` are not merely empty here, they are not declared on this branch at all - `X402PaymentValidator._authorizationNonce` is a `pure` function of public inputs and the agent chooses its own `validBefore`, so an agent holding `(authorization, index, payload)` could sign and settle through any facilitator without ever calling Botanary again, which would make the confirmation threshold decorative. Poll `GET /apis/calls/requirements/{id}` for the owner's decision. */
+        ApiCallRequirementsPending: {
+            requirementId: string;
+            /**
+             * @description discriminator enum property added by openapi-typescript
+             * @enum {string}
+             */
+            status: "pending_approval";
+            /** @description The raised request's own id (equal to `requirementId`). */
+            approvalId: string;
+            /**
+             * Format: date-time
+             * @description When this pending approval closes unanswered - the same instant `requirementId` itself expires.
+             */
+            expiresAt: string;
+        };
+        /** @description `GET /apis/calls/requirements/{id}` (Task 11) - what the owner decided, if anything, about a call raised above the agent's `confirmAbove` threshold. See that route's own description for THE SECURITY PROPERTY this schema encodes: `payload`/`authorization`/`index`/`validator` (Task 14) present only when `status: 'approved'`. */
+        ApiCallRequirementStatus: {
+            /** @enum {string} */
+            status: "pending" | "approved" | "declined" | "expired";
+            /** @description The EIP-3009 digest to sign. Present only when status is 'approved'. */
+            payload?: string;
+            authorization?: components["schemas"]["X402Authorization"];
+            /** @description The reserved authorization index. Present only when status is 'approved'. */
+            index?: number;
+            /** @description The `X402PaymentValidator` address on this requirement's chain - bytes 1 to 20 of the Kernel ERC-1271 envelope a client builds around the signature. Present only when status is 'approved', same as the three fields above. */
+            validator?: string;
+        };
+        /** @description Recoverable payment status. Submitted means the provider may have received the authorization; never create another paid call to recover it. Settled means finalized chain evidence proves payment. The provider may still have refused the requested service; inspect providerStatus. */
+        ApiCallResult: {
+            requirementId: string;
+            /** @enum {string} */
+            status: "ready" | "pending_approval" | "submitted" | "settled" | "declined";
+            /** @enum {string} */
+            paymentStatus: "not_submitted" | "pending" | "settled" | "not_settled";
+            /** @description True if the provider or chain evidence is simulated. */
+            simulated: boolean;
+            /** @description The provider HTTP status, when a response was recorded. It is not payment proof. */
+            providerStatus?: number;
+            /** @description The provider response body, when available. May be any JSON value. */
+            response?: unknown;
+            /** @description Verified finalized transaction hash. Provider hints are not exposed as proof. */
+            txHash?: string;
+            facilitatorReason?: string;
+            /** @description Signing material is present only for an unsubmitted requirement with any required owner approval satisfied. */
+            ready?: {
+                payload: string;
+                authorization: components["schemas"]["X402Authorization"];
+                index: number;
+                validator: string;
+            };
+        };
+        DeveloperAgentChallenge: {
+            id: string;
+            appId: string;
+            /** @enum {string} */
+            environment: "test" | "live";
+            address: string;
+            publicKey: string;
+            message: string;
+            /** Format: date-time */
+            expiresAt: string;
+        };
+        DeveloperAgentRegistration: {
+            id: string;
+            appId: string;
+            /** @enum {string} */
+            environment: "test" | "live";
+            name: string;
+            publicKey: string;
+            address: string;
+            fingerprint: string;
+            /** Format: date-time */
+            createdAt: string;
+            /** Format: date-time */
+            disabledAt: string | null;
+            /** @enum {string} */
+            apiAccess: "awaiting_connection" | "active" | "disabled" | "app_disabled" | "key_revoked" | "connection_revoked" | "unavailable";
+            /** @enum {string} */
+            grantStatus: "none" | "pending" | "active" | "paused" | "expired" | "revoked" | "unknown";
+            /** @description Durable grants attributed to this exact registration, including strict observed chain state when available. */
+            grants?: components["schemas"]["PublicGrant"][];
+            connectionId: string | null;
+        };
+        PublicGrant: {
+            id: string;
+            appId: string;
+            /** @enum {string} */
+            environment: "test" | "live";
+            connectionId: string;
+            registrationId: string;
+            agentId: string;
+            accountId: string;
+            accountAddress: components["schemas"]["Address"];
+            agentAddress: components["schemas"]["Address"];
+            /** @enum {integer} */
+            chainId: 84532;
+            name: string;
+            version: number;
+            permissionId: string;
+            grantExecutor: components["schemas"]["Address"];
+            policy: components["schemas"]["PublicGrantPolicy"];
+            compiled: components["schemas"]["PublicGrantCompiled"];
+            /** @enum {string} */
+            apiAccess: "active" | "awaiting_connection" | "connection_revoked" | "key_revoked" | "disabled" | "app_disabled" | "unavailable";
+            chainState: components["schemas"]["PublicGrantChainState"];
+            createOperationId: string;
+            /** Format: uri */
+            createApprovalUrl: string;
+            /** @enum {string} */
+            createStatus: "awaiting_approval" | "submitted" | "confirmed" | "failed" | "canceled" | "expired" | "unresolved";
+            revokeOperationId: string | null;
+            /** Format: uri */
+            revokeApprovalUrl: string | null;
+            /** @enum {string|null} */
+            revokeStatus: "awaiting_approval" | "submitted" | "confirmed" | "failed" | "canceled" | "expired" | "unresolved" | null;
+            /** Format: date-time */
+            createdAt: string;
+            /** Format: date-time */
+            updatedAt: string;
+        };
+        PublicGrantPolicy: {
+            budgets: {
+                assetRef: string;
+                token: components["schemas"]["Address"];
+                decimals: number;
+                amountRaw: string;
+            }[];
+            perActionMaxRaw: string | null;
+            recipients: components["schemas"]["Address"][];
+            allowedContract: components["schemas"]["Address"] | null;
+            deniedContracts: components["schemas"]["Address"][];
+            venues: components["schemas"]["Address"][];
+            conditions: components["schemas"]["PublicGrantCondition"][];
+            maxActions: number | null;
+            rate: {
+                assetRef: string;
+                token: components["schemas"]["Address"];
+                limitRaw: string;
+                periodSeconds: number;
+            } | null;
+            swapVenue: {
+                router: components["schemas"]["Address"];
+                assetRef: string;
+                token: components["schemas"]["Address"];
+                maxAllowanceRaw: string;
+            } | null;
+            /** Format: date-time */
+            expiresAt: string;
+        };
+        PublicGrantCondition: {
+            /** @enum {string} */
+            field: "class" | "token" | "amount" | "total_value" | "recipient" | "target" | "selector" | "arg" | "call_count";
+            /** @enum {string} */
+            op: "eq" | "neq" | "gte" | "lte" | "in_set" | "not_in_set";
+            argOffset: number;
+            value: string;
+        };
+        PublicGrantCompiled: {
+            enableCallData: string;
+            configCalls: components["schemas"]["PublicGrantConfigurationCall"][];
+            /** @description Ordered account-global AgentGuard calls, including any transition from allow-all to an explicit token set. */
+            accountGlobalConfigurationCalls: components["schemas"]["PublicGrantConfigurationCall"][];
+        };
+        PublicGrantConfigurationCall: {
+            to: components["schemas"]["Address"];
+            valueRaw: string;
+            data: string;
+        };
+        PublicGrantChainState: {
+            /** @enum {string} */
+            status: "unknown" | "active" | "paused" | "expired" | "revoked";
+            /** @enum {string|null} */
+            reason: "not_observed" | "inconsistent_limits" | "observation_unavailable" | null;
+            observedAt?: components["schemas"]["ConnectionOperationChainPoint"];
+            remaining?: components["schemas"]["PublicGrantRemaining"][];
+        };
+        ConnectionOperationChainPoint: {
+            blockNumber: string;
+            blockHash: string;
+        };
+        PublicGrantRemaining: {
+            token: components["schemas"]["Address"];
+            limitRaw: string;
+            spentRaw: string;
+            remainingRaw: string;
+        };
+        DeveloperAgentChallengeInput: {
+            name: string;
+            publicKey: string;
+        };
+        DeveloperAgentRegistrationInput: {
+            challengeId: string;
+            signature: string;
+        };
+    };
+    responses: {
+        /** @description Malformed request. */
+        BadRequest: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content: {
+                "application/json": components["schemas"]["ApiError"];
+            };
+        };
+        /** @description Missing or invalid session token. */
+        Unauthorized: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content: {
+                /**
+                 * @example {
+                 *       "error": {
+                 *         "code": "unauthorized",
+                 *         "message": "Session token missing or expired."
+                 *       }
+                 *     }
+                 */
+                "application/json": components["schemas"]["ApiError"];
+            };
+        };
+        /** @description Access denied. */
+        Forbidden: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content: {
+                /**
+                 * @example {
+                 *       "error": {
+                 *         "code": "forbidden",
+                 *         "message": "Access denied."
+                 *       }
+                 *     }
+                 */
+                "application/json": components["schemas"]["ApiError"];
+            };
+        };
+        /** @description Resource not found. */
+        NotFound: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content: {
+                "application/json": components["schemas"]["ApiError"];
+            };
+        };
+        /** @description The intent is out of scope for the account rules or delegation policy. Carries the same decline-reason vocabulary the on-chain revert would produce. */
+        PolicyDeclined: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content: {
+                "application/json": components["schemas"]["ApiError"];
+            };
+        };
+        /** @description This surface is turned off by an operator kill-switch (e.g. `PAY_SH_ENABLED=false`). Unlike NotImplemented, this IS transient: the same request will succeed once the flag is flipped back, with no other state to reconcile. */
+        ServiceUnavailable: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content: {
+                /**
+                 * @example {
+                 *       "error": {
+                 *         "code": "unavailable",
+                 *         "message": "pay.sh is temporarily disabled."
+                 *       }
+                 *     }
+                 */
+                "application/json": components["schemas"]["ApiError"];
+            };
+        };
+    };
+    parameters: {
+        /** @example d1 */
+        DelegationId: string;
+    };
+    requestBodies: never;
+    headers: never;
+    pathItems: never;
+}
+export type $defs = Record<string, never>;
+export interface operations {
+    pairAgent: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["AgentPairInput"];
+            };
+        };
+        responses: {
+            /** @description Pairing initiated - the code is now active for claiming. */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        /** @example a1b2c3-d4e5f6 */
+                        code: string;
+                    };
+                };
+            };
+            400: components["responses"]["BadRequest"];
+        };
+    };
+    issueAgentSessionNonce: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["AgentSessionNonceInput"];
+            };
+        };
+        responses: {
+            /** @description A fresh nonce to sign. */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        nonce: components["schemas"]["Hash32"];
+                    };
+                };
+            };
+        };
+    };
+    mintAgentSession: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["AgentSessionInput"];
+            };
+        };
+        responses: {
+            /** @description A fresh agent session token. */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["AgentSessionResponse"];
+                };
+            };
+            401: components["responses"]["Unauthorized"];
+        };
+    };
+    getAgentSelf: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description This agent's identity, account, and (if any) live grant. */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["AgentSelf"];
+                };
+            };
+            401: components["responses"]["Unauthorized"];
+            403: components["responses"]["Forbidden"];
+            404: components["responses"]["NotFound"];
+        };
+    };
+    listAgentRequests: {
+        parameters: {
+            query?: {
+                /** @description Specific account ID (owner only). Defaults to primary. */
+                accountId?: string;
+            };
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Array of agent requests (may be empty). */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["AgentRequest"][];
+                };
+            };
+            401: components["responses"]["Unauthorized"];
+            404: components["responses"]["NotFound"];
+        };
+    };
+    raiseAgentRequest: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["AgentRequestInput"];
+            };
+        };
+        responses: {
+            /** @description The request has been raised. */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["AgentRequest"];
+                };
+            };
+            400: components["responses"]["BadRequest"];
+            401: components["responses"]["Unauthorized"];
+            403: components["responses"]["Forbidden"];
+            404: components["responses"]["NotFound"];
+        };
+    };
+    getUnifiedBalance: {
+        parameters: {
+            query?: {
+                /** @description Scope the read to this specific account of the caller's (must belong to the authenticated signer - a foreign or unknown id is rejected, never silently ignored). Omitted defaults to the signer's lowest-visible-index account. */
+                accountId?: string;
+                /**
+                 * @description The chain the caller is currently viewing, as a CAIP-2 ref. A hint only: it promotes that chain to the front of this account's next background refresh so a first-ever deposit on an otherwise-untouched chain appears promptly. Never affects the response body. Forgiving - an unrecognized value is ignored, never a 400.
+                 * @example solana:EtWTRABZaYq6iMfeYKouRu166VU2xqa1
+                 */
+                focusChainRef?: string;
+            };
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description The unified balance. */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["UnifiedBalance"];
+                };
+            };
+            401: components["responses"]["Unauthorized"];
+            404: components["responses"]["NotFound"];
+        };
+    };
+    listChains: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Supported chains. */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Chain"][];
+                };
+            };
+            401: components["responses"]["Unauthorized"];
+        };
+    };
+    listGasMethods: {
+        parameters: {
+            query?: {
+                /** @description Scope the per-method balances to this specific account of the caller's (must belong to the authenticated signer - a foreign or unknown id is rejected, never silently ignored). Omitted defaults to the signer's lowest-visible-index account. */
+                accountId?: string;
+                /** @description Compute gas-method availability for this specific EVM chain. A basic-tier chain (a bundler but no Circle Paymaster - e.g. Robinhood) reports USDC/USDT gas as unavailable and native gas as the default. At least one of `chainId`/`key` is REQUIRED; a request with neither is a 400. If both are supplied, `key` takes priority and this is ignored. */
+                chainId?: number;
+                /**
+                 * @description Compute gas-method availability for this specific Stellar chain KEY instead of an EVM `chainId` (Stellar is key-keyed, not chainId-keyed). When present, returns Stellar's `native` (always) and `usdc` (only when the hosted gasless relayer - design doc §2 - is healthy) rows, in place of the EVM chainId-keyed path.
+                 * @example stellar-testnet
+                 */
+                key?: string;
+            };
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Gas methods. */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["GasMethod"][];
+                };
+            };
+            400: components["responses"]["BadRequest"];
+            401: components["responses"]["Unauthorized"];
+            404: components["responses"]["NotFound"];
+        };
+    };
+    getAccount: {
+        parameters: {
+            query?: {
+                /** @description When present, returns the address that is actually usable on this chain, deriving and persisting a counterfactual record for it if the account has never touched it. Omitted keeps the chain-blind default (whichever row is deployed, or the lowest index). */
+                chainId?: number;
+            };
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description The account. */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Account"];
+                };
+            };
+            401: components["responses"]["Unauthorized"];
+            404: components["responses"]["NotFound"];
+        };
+    };
+    buildDelegatedAction: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /** @example d1 */
+                delegationId: components["parameters"]["DelegationId"];
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["DelegatedActionInput"];
+            };
+        };
+        responses: {
+            /** @description Unsigned delegated-action op (session-key-signed). */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["UserOpBuild"];
+                };
+            };
+            401: components["responses"]["Unauthorized"];
+            403: components["responses"]["Forbidden"];
+            404: components["responses"]["NotFound"];
+            422: components["responses"]["BadRequest"];
+        };
+    };
+    buildExactDelegatedAction: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                delegationId: string;
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["ExactDelegatedActionInput"];
+            };
+        };
+        responses: {
+            /** @description Unsigned agent operation bound to the explicit execution context. */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ExactDelegatedActionBuild"];
+                };
+            };
+            /** @description Request refused or unavailable; no signature is produced by the API. */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ApiError"];
+                };
+            };
+            /** @description Request refused or unavailable; no signature is produced by the API. */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ApiError"];
+                };
+            };
+            /** @description Request refused or unavailable; no signature is produced by the API. */
+            403: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ApiError"];
+                };
+            };
+            /** @description Request refused or unavailable; no signature is produced by the API. */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ApiError"];
+                };
+            };
+            /** @description Request refused or unavailable; no signature is produced by the API. */
+            409: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ApiError"];
+                };
+            };
+            /** @description Request refused or unavailable; no signature is produced by the API. */
+            422: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ApiError"];
+                };
+            };
+            /** @description Request refused or unavailable; no signature is produced by the API. */
+            429: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ApiError"];
+                };
+            };
+            /** @description Request refused or unavailable; no signature is produced by the API. */
+            500: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ApiError"];
+                };
+            };
+            /** @description Request refused or unavailable; no signature is produced by the API. */
+            503: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ApiError"];
+                };
+            };
+        };
+    };
+    submitUserOp: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["SignedUserOp"];
+            };
+        };
+        responses: {
+            /** @description Accepted for relay. */
+            202: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["UserOpReceipt"];
+                };
+            };
+            400: components["responses"]["BadRequest"];
+            401: components["responses"]["Unauthorized"];
+            /** @description Hosted operation requires the authenticated owner browser. */
+            403: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ApiError"];
+                };
+            };
+            /** @description Hosted submission is already in progress or its review changed. Resume the durable operation ID. */
+            409: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ApiError"];
+                };
+            };
+            422: components["responses"]["PolicyDeclined"];
+        };
+    };
+    getUserOp: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                userOpId: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description The UserOp receipt / status. */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["UserOpReceipt"];
+                };
+            };
+            401: components["responses"]["Unauthorized"];
+            404: components["responses"]["NotFound"];
+        };
+    };
+    getAgentUserOpByHash: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                chainId: number;
+                userOpHash: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description The recorded operation and its current settlement status. */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["UserOpReceipt"];
+                };
+            };
+            /** @description Receipt lookup refused, unknown or unavailable. */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ApiError"];
+                };
+            };
+            /** @description Receipt lookup refused, unknown or unavailable. */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ApiError"];
+                };
+            };
+            /** @description Receipt lookup refused, unknown or unavailable. */
+            403: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ApiError"];
+                };
+            };
+            /** @description Receipt lookup refused, unknown or unavailable. */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ApiError"];
+                };
+            };
+            /** @description Receipt lookup refused, unknown or unavailable. */
+            429: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ApiError"];
+                };
+            };
+            /** @description Receipt lookup refused, unknown or unavailable. */
+            500: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ApiError"];
+                };
+            };
+            /** @description Receipt lookup refused, unknown or unavailable. */
+            503: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ApiError"];
+                };
+            };
+        };
+    };
+    listApiProviders: {
+        parameters: {
+            query?: {
+                /** @description The chain to filter by. Only providers with an endpoint listed on this chain are included. Omitted, every chain the catalog knows is returned instead. */
+                chainId?: number;
+                /** @description Optional asset address. If provided, further filters to providers quoting this specific asset on the chain. Bounded like the other free-text filters - an EVM address is 42 characters, a Solana mint at most 44. */
+                asset?: string;
+                /** @description Case-insensitive substring over a provider's id, name, category and description. Applied server-side, and to the hidden set as well as the shown one, so `hidden` answers the question the search asked rather than one about the whole catalog. */
+                q?: string;
+                /** @description Page size. Out of range is refused, never clamped. */
+                limit?: number;
+                /** @description Rows to skip. The order is total (`curated` first, then `rankScore` descending, then `id` ascending), so paging can neither duplicate nor drop a provider. The curated tier leads because it is the only tier anyone has reviewed; `rankScore` measures traffic, not trust. */
+                offset?: number;
+            };
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description One page of the ranked catalog, with the total it is a page of. */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ApiProviderList"];
+                };
+            };
+            400: components["responses"]["BadRequest"];
+            401: components["responses"]["Unauthorized"];
+            503: components["responses"]["ServiceUnavailable"];
+        };
+    };
+    getApiProvider: {
+        parameters: {
+            query?: {
+                /** @description The chain to FILTER endpoints by. Only endpoints with measured or declared evidence for this chain are included. Omitted, every chain the catalog knows is included, so an endpoint with no measured or declared chain lists once per supported chain. */
+                chainId?: number;
+                /** @description Which network family to VIEW this provider on - a view scope, not a filter, and NOT a synonym for `chainId`. It narrows the chains considered to that family without asking an evidence question, so an endpoint that declares no chain still lists once, unmeasured, instead of disappearing. This is what makes a Testnet/Mainnet toggle possible on a provider whose endpoints declare no chain, which is every curated provider in the catalog. Sending both is accepted and `chainId` wins, being the stricter of the two. */
+                net?: "mainnet" | "testnet";
+                /** @description Case-insensitive substring over an endpoint's path, summary and method. */
+                q?: string;
+                /** @description Page size. Out of range is refused, never clamped. */
+                limit?: number;
+                /** @description Endpoints to skip. The order is total (`uniquePayers` descending, then path, chainId, id), so paging can neither duplicate nor drop a row. */
+                offset?: number;
+            };
+            header?: never;
+            path: {
+                providerId: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description The provider, with one page of its endpoints. */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ApiProviderDetail"];
+                };
+            };
+            400: components["responses"]["BadRequest"];
+            401: components["responses"]["Unauthorized"];
+            503: components["responses"]["ServiceUnavailable"];
+        };
+    };
+    getApiBudget: {
+        parameters: {
+            query: {
+                chainId: number;
+                agentId: string;
+            };
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description The current budget state. */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ApiBudget"];
+                };
+            };
+            400: components["responses"]["BadRequest"];
+            401: components["responses"]["Unauthorized"];
+            503: components["responses"]["ServiceUnavailable"];
+        };
+    };
+    buildApiCallRequirements: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": {
+                    chainId: number;
+                    providerId: string;
+                    endpointId: string;
+                    agentId: string;
+                    /**
+                     * Format: uri
+                     * @description Full URL of the endpoint to call, query parameters included. A GET endpoint's parameters belong here - it is the only place they can go.
+                     */
+                    url: string;
+                    /** @description Raw request body for a POST endpoint, forwarded to the provider byte for byte and never parsed, reshaped or logged by Botanary - it may carry the caller's own credentials for that provider. Send it as a string (JSON endpoints: the serialised JSON), not an object. The body a price is quoted for is the body that gets paid for: it is captured with the 402 challenge and replayed at relay, so it cannot be changed after the quote. Supplying one for a GET endpoint is declined (`request_body_not_supported`). Size limit: **32768 UTF-8 BYTES**, measured on the wire - not characters. The `maxLength: 32768` above is JSON Schema's own rule and counts CHARACTERS, so it is a necessary bound but not the whole one: a string under 32768 characters can still be up to four times that in UTF-8, and the server declines it with `request_body_too_large`. Size the body in bytes, not in `String.length`. */
+                    body?: string;
+                };
+            };
+        };
+        responses: {
+            /** @description The EIP-3009 authorization payload. */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ApiCallRequirements"];
+                };
+            };
+            400: components["responses"]["BadRequest"];
+            401: components["responses"]["Unauthorized"];
+            503: components["responses"]["ServiceUnavailable"];
+        };
+    };
+    getApiCallRequirementStatus: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /** @description The requirement id from `buildApiCallRequirements`. */
+                id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description The current status, and the signing material once (and only once) approved. */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ApiCallRequirementStatus"];
+                };
+            };
+            400: components["responses"]["BadRequest"];
+            401: components["responses"]["Unauthorized"];
+            /** @description No such id, it does not belong to this account, or it belongs to a different agent - the same refusal for all three, since which one is true is not information this route may leak. */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ApiError"];
+                };
+            };
+            503: components["responses"]["ServiceUnavailable"];
+        };
+    };
+    relayApiCall: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": {
+                    /** @description The ID returned by buildApiCallRequirements. */
+                    requirementId: string;
+                    /** @description The agent's signature of the EIP-3009 payload. */
+                    signature: string;
+                };
+            };
+        };
+        responses: {
+            /** @description The provider's response, marked simulated or real. */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ApiCallResult"];
+                };
+            };
+            400: components["responses"]["BadRequest"];
+            401: components["responses"]["Unauthorized"];
+            422: components["responses"]["PolicyDeclined"];
+            503: components["responses"]["ServiceUnavailable"];
+        };
+    };
+    getApiCallStatus: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Durable status, with signing material only while ready and authorized. */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ApiCallResult"];
+                };
+            };
+            401: components["responses"]["Unauthorized"];
+            422: components["responses"]["PolicyDeclined"];
+            503: components["responses"]["ServiceUnavailable"];
+        };
+    };
+}
+//# sourceMappingURL=schema.d.ts.map