@outlayer/sdk 0.1.0-alpha.1

package/dist/index.d.ts

@@ -0,0 +1,1788 @@
+import { Client } from 'openapi-fetch';
+
+/**
+ * This file was auto-generated by openapi-typescript.
+ * Do not make direct changes to the file.
+ */
+interface paths {
+    "/register": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Register a new wallet
+         * @description Creates a new multi-chain wallet and returns an API key. For most
+         *     callers, send `{}` — an anonymous wallet is created and an API key is
+         *     returned in `api_key` (shown once, not retrievable later).
+         *
+         *     Optional fields enable advanced registration paths:
+         *     - `account_id` + `pubkey` + `message` + `signature`: bind the wallet to
+         *       a NEAR account via NEP-413 proof-of-ownership.
+         *     - `vault_id`: bind to a customer-owned vault for sovereign custody (see
+         *       vault docs).
+         *
+         *     Rate-limited: 30 requests per minute per IP.
+         */
+        post: operations["registerWallet"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/wallet/v1/address": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Derive wallet address for a chain
+         * @description Returns the deterministically-derived address for the wallet on the
+         *     requested chain. Same `wallet_id` always produces the same addresses
+         *     across chains.
+         */
+        get: operations["getAddress"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/wallet/v1/balance": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Read balance
+         * @description Returns the balance for a token on the requested chain. Currently only
+         *     `chain=near` is supported for native balance reads; cross-chain balances
+         *     should be read from the upstream chain directly.
+         *
+         *     Set `source=intents` to read the wallet's intents.near balance
+         *     (`mt_balance_of`) instead of the on-chain account balance.
+         */
+        get: operations["getBalance"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/wallet/v1/tokens": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * List supported tokens
+         * @description Returns the token catalog supported for swaps and cross-chain withdraws
+         *     via NEAR Intents. Token IDs are typed as `nep141:<contract>` and map to
+         *     each chain via `defuse_asset_id`.
+         */
+        get: operations["listTokens"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/wallet/v1/call": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Sign and broadcast a NEAR function call
+         * @description Native NEAR contract call. Policy is enforced before signing; if the
+         *     call exceeds limits, the response carries `status=pending_approval`
+         *     and an `approval_id` for the multisig flow.
+         */
+        post: operations["call"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/wallet/v1/transfer": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Native chain transfer
+         * @description Chain-agnostic native transfer (NEAR yoctoNEAR units). Currently only
+         *     `chain=near` is supported; other chains return `unsupported_chain`.
+         */
+        post: operations["transfer"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/wallet/v1/intents/deposit": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Deposit FT into intents.near
+         * @description Wraps `ft_transfer_call` to `intents.near`, auto-handling storage
+         *     deposit if required. After this call, the wallet's intents.near balance
+         *     increases by `amount` of `token` and is available for swaps and
+         *     gasless cross-chain withdrawals.
+         */
+        post: operations["intentsDeposit"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/wallet/v1/intents/withdraw": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Withdraw via NEAR Intents (gasless cross-chain)
+         * @description Gasless cross-chain withdrawal through NEAR Intents solver relay. The
+         *     wallet's intents.near balance is debited; the receiver gets funds on
+         *     the destination chain (NEAR, Ethereum, Solana, Bitcoin) without paying
+         *     gas on either side.
+         *
+         *     If the policy requires approval, returns `status=pending_approval` with
+         *     an `approval_id`.
+         */
+        post: operations["intentsWithdraw"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/wallet/v1/intents/withdraw/dry-run": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Simulate a withdraw (policy + balance check, no execution)
+         * @description Runs the full policy and balance check for a withdraw without signing
+         *     or broadcasting. Useful for showing the user whether an action would
+         *     succeed before they confirm.
+         */
+        post: operations["intentsWithdrawDryRun"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/wallet/v1/intents/swap": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Swap via NEAR Intents (1Click)
+         * @description Cross-chain swap via the 1Click solver. Quote → deposit to intents.near
+         *     → mt_transfer → poll. Returns when the swap settles or fails.
+         */
+        post: operations["intentsSwap"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/wallet/v1/intents/swap/quote": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Get a swap quote (no execution)
+         * @description Returns the indicative output and deadline for a swap without executing
+         *     it. Use this before calling `/intents/swap` to show the user expected
+         *     output and allow them to set `min_amount_out`.
+         */
+        post: operations["intentsSwapQuote"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/wallet/v1/sign-message": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Sign an arbitrary message (NEP-413 or raw)
+         * @description Signs a message with the wallet's NEAR key. Use `format=nep413` (default)
+         *     for the standard NEP-413 signing scheme; use `format=raw` for raw byte
+         *     signing.
+         *
+         *     Policy and freeze still apply — a frozen wallet cannot sign.
+         */
+        post: operations["signMessage"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/wallet/v1/requests": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** List async wallet requests */
+        get: operations["listRequests"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/wallet/v1/requests/{id}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** Get a single request's status */
+        get: operations["getRequest"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/wallet/v1/policy": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Get current decrypted policy
+         * @description Returns the wallet's current policy (decrypted by the keystore TEE),
+         *     plus the current usage counters used by velocity-limit checks.
+         */
+        get: operations["getPolicy"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/wallet/v1/encrypt-policy": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Encrypt a policy for on-chain storage
+         * @description Sends a policy JSON to the keystore TEE for encryption. The returned
+         *     `encrypted_base64` is what gets stored in NEAR via
+         *     `store_wallet_policy(...)` after the keystore signs it.
+         */
+        post: operations["encryptPolicy"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/wallet/v1/sign-policy": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Sign an encrypted policy (for on-chain submission)
+         * @description The keystore signs `SHA256(encrypted_data)` with the wallet's key. The
+         *     signature + encrypted data + public key form the payload for the
+         *     on-chain `store_wallet_policy(...)` call.
+         */
+        post: operations["signPolicy"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/wallet/v1/invalidate-cache": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Invalidate negative policy cache
+         * @description Forces the coordinator to drop its cached `no_policy` flag for a wallet.
+         *     Call this after submitting `store_wallet_policy(...)` on-chain so that
+         *     subsequent operations pick up the new policy without waiting for the
+         *     5-minute TTL to expire.
+         */
+        post: operations["invalidatePolicyCache"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/wallet/v1/pending_approvals": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** List pending multisig approvals */
+        get: operations["listPendingApprovals"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/wallet/v1/approve/{id}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Approve a pending action (NEP-413 signed)
+         * @description Submits an approver's NEP-413 signature for a pending action. When the
+         *     approval threshold is reached, the action auto-executes. No API key
+         *     required — auth is established by the NEP-413 signature in the body.
+         */
+        post: operations["approveRequest"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/wallet/v1/reject/{id}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /** Reject a pending action (NEP-413 signed) */
+        post: operations["rejectRequest"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/wallet/v1/audit": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** Event history for the wallet */
+        get: operations["listAuditEvents"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+}
+interface components {
+    schemas: {
+        /**
+         * @description Supported chain identifier.
+         * @enum {string}
+         */
+        Chain: "near" | "ethereum" | "solana" | "bitcoin";
+        /** @enum {string} */
+        RequestType: "call" | "transfer" | "withdraw" | "deposit" | "swap";
+        /** @enum {string} */
+        RequestStatus: "processing" | "success" | "failed" | "pending_approval" | "approved" | "rejected";
+        /** @enum {string} */
+        ErrorCode: "missing_auth" | "invalid_api_key" | "missing_wallet_id" | "missing_signature" | "timestamp_expired" | "wallet_frozen" | "policy_denied" | "not_approver" | "insufficient_balance" | "invalid_address" | "rate_limited" | "unsupported_chain" | "unsupported_token" | "request_not_found" | "approval_not_found" | "bad_request" | "duplicate_idempotency_key" | "internal_error";
+        ErrorResponse: {
+            error: components["schemas"]["ErrorCode"];
+            message?: string;
+            details?: {
+                [key: string]: unknown;
+            };
+        };
+        /**
+         * @description For the common case (anonymous wallet on OutLayer's shared master),
+         *     send empty `{}`. Optional fields enable advanced flows:
+         *
+         *     - `vault_id`: bind this wallet to an existing customer-owned vault,
+         *       so the wallet's master is derived through the vault's per-customer
+         *       MPC-derived master instead of OutLayer's shared default. The vault
+         *       must already be deployed and verified — **vault deployment is not
+         *       done through this endpoint**. Use the dashboard
+         *       (https://outlayer.fastnear.com/vault) or the CLI
+         *       (`outlayer vault init`) to deploy. Reference:
+         *       https://outlayer.fastnear.com/docs/vaults
+         *     - `account_id` + `pubkey` + `message` + `signature`: bind the wallet
+         *       to a verified NEAR account via NEP-413 proof-of-ownership. Used
+         *       by clients that want operational keys (`wk_...`) tied to a real
+         *       NEAR account.
+         */
+        RegisterRequest: {
+            /** @description NEAR account ID to bind the wallet to (requires NEP-413 signature). */
+            account_id?: string;
+            /** @description Reserved for deterministic-wallet derivation. Most callers leave unset. */
+            seed?: string;
+            /** @description NEP-413 signer pubkey (paired with `account_id` + `signature`). */
+            pubkey?: string;
+            /** @description NEP-413 message that was signed. */
+            message?: string;
+            /** @description NEP-413 signature over `message`. */
+            signature?: string;
+            /**
+             * @description ID of a deployed and verified customer vault (e.g. `vault.alice.near`).
+             *     Binding is permanent — the resulting API key is tied to this vault
+             *     for its lifetime. All subsequent operations on the API key
+             *     automatically derive keys through the per-vault master; you do
+             *     NOT pass `vault_id` on every call.
+             */
+            vault_id?: string;
+        };
+        RegisterResponse: {
+            /** Format: uuid */
+            wallet_id: string;
+            /** @description Shown once. Not retrievable later — save it now. */
+            api_key?: string;
+            near_account_id: string;
+            /**
+             * Format: uri
+             * @description Dashboard URL where the controller sets policy.
+             */
+            handoff_url?: string;
+            trial?: components["schemas"]["TrialInfo"];
+        };
+        TrialInfo: {
+            calls_remaining?: number;
+            /** Format: date-time */
+            expires_at?: string;
+            limits?: {
+                max_instructions?: number;
+                max_execution_seconds?: number;
+                max_memory_mb?: number;
+            };
+        };
+        AddressResponse: {
+            wallet_id: string;
+            chain: components["schemas"]["Chain"];
+            address: string;
+            public_key: string;
+            vault_id?: string | null;
+        };
+        BalanceResponse: {
+            /** @description Amount in token's smallest unit. */
+            balance: string;
+            token: string;
+            account_id: string;
+        };
+        TokenInfo: {
+            id: string;
+            symbol: string;
+            chains: components["schemas"]["Chain"][];
+            decimals: number;
+            defuse_asset_id?: string;
+        };
+        TokensResponse: {
+            tokens: components["schemas"]["TokenInfo"][];
+        };
+        CallRequest: {
+            receiver_id: string;
+            method_name: string;
+            /** @description Method arguments as a JSON object. Mutually exclusive with `args_base64`. */
+            args?: {
+                [key: string]: unknown;
+            };
+            /** @description Pre-encoded base64 args. Use for non-JSON encodings. */
+            args_base64?: string;
+            /** @description Gas budget in TGas as a string. Defaults to `30000000000000` (30 TGas) server-side. */
+            gas?: string;
+            /** @description Attached NEAR deposit in yoctoNEAR. Defaults to `0` server-side. */
+            deposit?: string;
+        };
+        CallResponse: {
+            /** Format: uuid */
+            request_id: string;
+            status: components["schemas"]["RequestStatus"];
+            tx_hash?: string | null;
+            result?: {
+                [key: string]: unknown;
+            } | null;
+            /** Format: uuid */
+            approval_id?: string | null;
+            required?: number | null;
+            approved?: number | null;
+        };
+        TransferRequest: {
+            /** @description Chain to transfer on. Defaults to `near` server-side. */
+            chain?: components["schemas"]["Chain"];
+            receiver_id: string;
+            amount: string;
+        };
+        IntentsDepositRequest: {
+            token: string;
+            amount: string;
+        };
+        IntentsDepositResponse: {
+            /** Format: uuid */
+            request_id: string;
+            status: components["schemas"]["RequestStatus"];
+            tx_hash?: string | null;
+        };
+        WithdrawRequest: {
+            chain: components["schemas"]["Chain"];
+            /** @description Destination address on the target chain. */
+            to?: string;
+            amount: string;
+            /** @description Token ID, e.g. `nep141:usdt.tether-token.near`. Omit for native asset. */
+            token?: string;
+        };
+        WithdrawResponse: {
+            /** Format: uuid */
+            request_id: string;
+            status: components["schemas"]["RequestStatus"];
+            /** Format: uuid */
+            approval_id?: string | null;
+            required?: number | null;
+            approved?: number | null;
+        };
+        DryRunResponse: {
+            would_succeed?: boolean;
+            reason?: string;
+            message?: string;
+            estimated_fee?: string;
+            fee_token?: string;
+            policy_check?: {
+                /** @enum {string} */
+                decision?: "allowed" | "denied" | "requires_approval" | "frozen" | "no_policy_allow";
+                reason?: string;
+                required_approvals?: number;
+            };
+        };
+        SwapRequest: {
+            token_in: string;
+            token_out: string;
+            amount_in: string;
+            min_amount_out?: string;
+        };
+        SwapResponse: {
+            /** Format: uuid */
+            request_id: string;
+            status: components["schemas"]["RequestStatus"];
+            amount_out?: string;
+            intent_hash?: string;
+        };
+        SwapQuoteResponse: {
+            amount_out?: string;
+            min_amount_out?: string;
+            /** Format: date-time */
+            deadline?: string;
+            time_estimate_seconds?: number;
+        };
+        SignMessageRequest: {
+            message: string;
+            recipient: string;
+            /** @description Base64-encoded 32-byte nonce. Auto-generated if omitted. */
+            nonce?: string;
+            /**
+             * @default nep413
+             * @enum {string}
+             */
+            format: "nep413" | "raw";
+        };
+        SignMessageResponse: {
+            account_id?: string;
+            signature?: string;
+            signature_base64?: string;
+            public_key?: string;
+            nonce?: string;
+        };
+        PolicyRules: {
+            limits?: components["schemas"]["PolicyLimits"];
+            addresses?: components["schemas"]["AddressList"];
+            transaction_types?: components["schemas"]["RequestType"][];
+            time_restrictions?: components["schemas"]["TimeRestrictions"];
+            rate_limit?: components["schemas"]["RateLimit"];
+        };
+        /**
+         * @description Per-period spending limits. Each field is a map of `token_id → amount`.
+         *     Use `"*"` as the key to match all tokens.
+         */
+        PolicyLimits: {
+            per_transaction?: {
+                [key: string]: string;
+            };
+            hourly?: {
+                [key: string]: string;
+            };
+            daily?: {
+                [key: string]: string;
+            };
+            monthly?: {
+                [key: string]: string;
+            };
+        };
+        AddressList: {
+            /** @enum {string} */
+            mode: "whitelist" | "blacklist";
+            list: string[];
+        };
+        TimeRestrictions: {
+            /** @description IANA timezone name, e.g. `UTC` or `Europe/Berlin`. */
+            timezone?: string;
+            allowed_hours?: number[];
+            /** @description 0 = Sunday, 6 = Saturday. */
+            allowed_days?: number[];
+        };
+        RateLimit: {
+            max_per_hour?: number;
+        };
+        ApprovalConfig: {
+            threshold?: {
+                required: number;
+                of: number;
+            };
+            /** @description Approval gate triggers when transaction value exceeds this USD amount. */
+            above_usd?: number;
+            approvers?: components["schemas"]["Approver"][];
+        };
+        Approver: {
+            /** @description Public key, e.g. `ed25519:...`. */
+            id: string;
+            /** @enum {string} */
+            role: "admin" | "signer";
+        };
+        AdminQuorum: {
+            required: number;
+            admins: string[];
+        };
+        PolicyResponse: {
+            wallet_id: string;
+            /** @description NEAR account that owns the policy. */
+            controller: string;
+            frozen: boolean;
+            rules?: components["schemas"]["PolicyRules"];
+            approval?: components["schemas"]["ApprovalConfig"];
+            authorized_key_hashes?: string[];
+            /**
+             * @description Current accumulated usage per token, per period. Same shape as
+             *     `PolicyLimits` — used for client-side velocity-limit visualization.
+             */
+            usage?: {
+                [key: string]: unknown;
+            };
+        };
+        EncryptPolicyRequest: {
+            wallet_id: string;
+            rules: components["schemas"]["PolicyRules"];
+            approval?: components["schemas"]["ApprovalConfig"];
+            admin_quorum?: components["schemas"]["AdminQuorum"];
+            /** Format: uri */
+            webhook_url?: string;
+            authorized_key_hashes?: string[];
+        };
+        EncryptPolicyResponse: {
+            encrypted_base64: string;
+            wallet_pubkey: string;
+        };
+        SignPolicyRequest: {
+            encrypted_data: string;
+        };
+        SignPolicyResponse: {
+            signature_hex: string;
+            public_key_hex: string;
+        };
+        InvalidateCacheRequest: {
+            wallet_id: string;
+        };
+        PendingApproval: {
+            /** Format: uuid */
+            approval_id: string;
+            /** Format: uuid */
+            request_id?: string | null;
+            type: components["schemas"]["RequestType"];
+            request_data: {
+                [key: string]: unknown;
+            };
+            required: number;
+            approved: number;
+            /** Format: date-time */
+            expires_at: string;
+        };
+        PendingApprovalsResponse: {
+            approvals: components["schemas"]["PendingApproval"][];
+        };
+        /**
+         * @description NEP-413 signed authentication payload. The signed message is
+         *     `approve:{approval_id}:{request_hash}` for approve or
+         *     `reject:{approval_id}:{request_hash}` for reject.
+         */
+        Nep413Auth: {
+            signature: string;
+            public_key: string;
+            account_id: string;
+            nonce: string;
+        };
+        RejectRequest: components["schemas"]["Nep413Auth"] & {
+            reason?: string;
+        };
+        ApproveResponse: {
+            /** Format: uuid */
+            approval_id: string;
+            /** @enum {string} */
+            status: "pending" | "approved" | "rejected" | "expired";
+            approved: number;
+            required: number;
+            /** Format: uuid */
+            request_id?: string | null;
+        };
+        AuditEvent: {
+            type: string;
+            request_id?: string | null;
+            status?: string | null;
+            details: {
+                [key: string]: unknown;
+            };
+            /** Format: date-time */
+            at: string;
+        };
+        AuditResponse: {
+            events: components["schemas"]["AuditEvent"][];
+        };
+        RequestStatusResponse: {
+            /** Format: uuid */
+            request_id: string;
+            type: components["schemas"]["RequestType"];
+            status: components["schemas"]["RequestStatus"];
+            result?: {
+                [key: string]: unknown;
+            } | null;
+            /** Format: date-time */
+            created_at: string;
+            /** Format: date-time */
+            updated_at?: string | null;
+        };
+        RequestListResponse: {
+            requests: components["schemas"]["RequestStatusResponse"][];
+            total: number;
+        };
+    };
+    responses: {
+        /** @description Invalid request */
+        BadRequest: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content: {
+                "application/json": components["schemas"]["ErrorResponse"];
+            };
+        };
+        /** @description Missing or invalid credentials */
+        Unauthorized: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content: {
+                "application/json": components["schemas"]["ErrorResponse"];
+            };
+        };
+        /** @description Action blocked by policy or wallet state */
+        Forbidden: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content: {
+                "application/json": components["schemas"]["ErrorResponse"];
+            };
+        };
+        /** @description Resource does not exist */
+        NotFound: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content: {
+                "application/json": components["schemas"]["ErrorResponse"];
+            };
+        };
+        /** @description Too many requests */
+        RateLimited: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content: {
+                "application/json": components["schemas"]["ErrorResponse"];
+            };
+        };
+        /** @description Server error */
+        InternalError: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content: {
+                "application/json": components["schemas"]["ErrorResponse"];
+            };
+        };
+    };
+    parameters: {
+        /**
+         * @description Optional idempotency token. Resubmitting a write request with the same
+         *     key returns the original result without re-execution. Recommended for
+         *     clients that retry on network failure.
+         */
+        IdempotencyKey: string;
+    };
+    requestBodies: never;
+    headers: never;
+    pathItems: never;
+}
+interface operations {
+    registerWallet: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: {
+            content: {
+                "application/json": components["schemas"]["RegisterRequest"];
+            };
+        };
+        responses: {
+            /** @description Wallet created */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["RegisterResponse"];
+                };
+            };
+            400: components["responses"]["BadRequest"];
+            429: components["responses"]["RateLimited"];
+            500: components["responses"]["InternalError"];
+        };
+    };
+    getAddress: {
+        parameters: {
+            query: {
+                chain: components["schemas"]["Chain"];
+            };
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Address derived */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    /**
+                     * @example {
+                     *       "wallet_id": "9c3c9e10-1c1f-4f5e-9c4a-1d7b9a8f3c20",
+                     *       "chain": "near",
+                     *       "address": "9c3c9e101c1f4f5e9c4a1d7b9a8f3c20",
+                     *       "public_key": "ed25519:7BcBZ9Z...",
+                     *       "vault_id": null
+                     *     }
+                     */
+                    "application/json": components["schemas"]["AddressResponse"];
+                };
+            };
+            400: components["responses"]["BadRequest"];
+            401: components["responses"]["Unauthorized"];
+            500: components["responses"]["InternalError"];
+        };
+    };
+    getBalance: {
+        parameters: {
+            query?: {
+                chain?: components["schemas"]["Chain"];
+                /** @description Token ID (`nep141:<contract>` or `native`). */
+                token?: string;
+                source?: "chain" | "intents";
+            };
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Balance */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    /**
+                     * @example {
+                     *       "balance": "1000000000000000000000000",
+                     *       "token": "NEAR",
+                     *       "account_id": "9c3c9e101c1f4f5e9c4a1d7b9a8f3c20"
+                     *     }
+                     */
+                    "application/json": components["schemas"]["BalanceResponse"];
+                };
+            };
+            400: components["responses"]["BadRequest"];
+            401: components["responses"]["Unauthorized"];
+            500: components["responses"]["InternalError"];
+        };
+    };
+    listTokens: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Token list */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["TokensResponse"];
+                };
+            };
+            401: components["responses"]["Unauthorized"];
+            500: components["responses"]["InternalError"];
+        };
+    };
+    call: {
+        parameters: {
+            query?: never;
+            header?: {
+                /**
+                 * @description Optional idempotency token. Resubmitting a write request with the same
+                 *     key returns the original result without re-execution. Recommended for
+                 *     clients that retry on network failure.
+                 */
+                "Idempotency-Key"?: components["parameters"]["IdempotencyKey"];
+            };
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                /**
+                 * @example {
+                 *       "receiver_id": "usdt.tether-token.near",
+                 *       "method_name": "ft_transfer",
+                 *       "args": {
+                 *         "receiver_id": "bob.near",
+                 *         "amount": "1000000"
+                 *       },
+                 *       "gas": "30000000000000",
+                 *       "deposit": "1"
+                 *     }
+                 */
+                "application/json": components["schemas"]["CallRequest"];
+            };
+        };
+        responses: {
+            /** @description Call submitted (or queued for approval) */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["CallResponse"];
+                };
+            };
+            400: components["responses"]["BadRequest"];
+            401: components["responses"]["Unauthorized"];
+            403: components["responses"]["Forbidden"];
+            429: components["responses"]["RateLimited"];
+            500: components["responses"]["InternalError"];
+        };
+    };
+    transfer: {
+        parameters: {
+            query?: never;
+            header?: {
+                /**
+                 * @description Optional idempotency token. Resubmitting a write request with the same
+                 *     key returns the original result without re-execution. Recommended for
+                 *     clients that retry on network failure.
+                 */
+                "Idempotency-Key"?: components["parameters"]["IdempotencyKey"];
+            };
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                /**
+                 * @example {
+                 *       "chain": "near",
+                 *       "receiver_id": "bob.near",
+                 *       "amount": "1000000000000000000000000"
+                 *     }
+                 */
+                "application/json": components["schemas"]["TransferRequest"];
+            };
+        };
+        responses: {
+            /** @description Transfer submitted */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["CallResponse"];
+                };
+            };
+            400: components["responses"]["BadRequest"];
+            401: components["responses"]["Unauthorized"];
+            403: components["responses"]["Forbidden"];
+            500: components["responses"]["InternalError"];
+        };
+    };
+    intentsDeposit: {
+        parameters: {
+            query?: never;
+            header?: {
+                /**
+                 * @description Optional idempotency token. Resubmitting a write request with the same
+                 *     key returns the original result without re-execution. Recommended for
+                 *     clients that retry on network failure.
+                 */
+                "Idempotency-Key"?: components["parameters"]["IdempotencyKey"];
+            };
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                /**
+                 * @example {
+                 *       "token": "wrap.near",
+                 *       "amount": "5000000000000000000000000"
+                 *     }
+                 */
+                "application/json": components["schemas"]["IntentsDepositRequest"];
+            };
+        };
+        responses: {
+            /** @description Deposit submitted */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["IntentsDepositResponse"];
+                };
+            };
+            400: components["responses"]["BadRequest"];
+            401: components["responses"]["Unauthorized"];
+            403: components["responses"]["Forbidden"];
+            500: components["responses"]["InternalError"];
+        };
+    };
+    intentsWithdraw: {
+        parameters: {
+            query?: never;
+            header?: {
+                /**
+                 * @description Optional idempotency token. Resubmitting a write request with the same
+                 *     key returns the original result without re-execution. Recommended for
+                 *     clients that retry on network failure.
+                 */
+                "Idempotency-Key"?: components["parameters"]["IdempotencyKey"];
+            };
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                /**
+                 * @example {
+                 *       "chain": "ethereum",
+                 *       "to": "0x742d35Cc6634C0532925a3b844Bc9e7595f8b4f5",
+                 *       "amount": "1000000",
+                 *       "token": "nep141:usdt.tether-token.near"
+                 *     }
+                 */
+                "application/json": components["schemas"]["WithdrawRequest"];
+            };
+        };
+        responses: {
+            /** @description Withdraw submitted (or queued for approval) */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["WithdrawResponse"];
+                };
+            };
+            400: components["responses"]["BadRequest"];
+            401: components["responses"]["Unauthorized"];
+            403: components["responses"]["Forbidden"];
+            500: components["responses"]["InternalError"];
+        };
+    };
+    intentsWithdrawDryRun: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["WithdrawRequest"];
+            };
+        };
+        responses: {
+            /** @description Dry-run result */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["DryRunResponse"];
+                };
+            };
+            400: components["responses"]["BadRequest"];
+            401: components["responses"]["Unauthorized"];
+            500: components["responses"]["InternalError"];
+        };
+    };
+    intentsSwap: {
+        parameters: {
+            query?: never;
+            header?: {
+                /**
+                 * @description Optional idempotency token. Resubmitting a write request with the same
+                 *     key returns the original result without re-execution. Recommended for
+                 *     clients that retry on network failure.
+                 */
+                "Idempotency-Key"?: components["parameters"]["IdempotencyKey"];
+            };
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                /**
+                 * @example {
+                 *       "token_in": "nep141:wrap.near",
+                 *       "token_out": "nep141:usdt.tether-token.near",
+                 *       "amount_in": "5000000000000000000000000",
+                 *       "min_amount_out": "24000000"
+                 *     }
+                 */
+                "application/json": components["schemas"]["SwapRequest"];
+            };
+        };
+        responses: {
+            /** @description Swap submitted */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["SwapResponse"];
+                };
+            };
+            400: components["responses"]["BadRequest"];
+            401: components["responses"]["Unauthorized"];
+            403: components["responses"]["Forbidden"];
+            500: components["responses"]["InternalError"];
+        };
+    };
+    intentsSwapQuote: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["SwapRequest"];
+            };
+        };
+        responses: {
+            /** @description Quote */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["SwapQuoteResponse"];
+                };
+            };
+            400: components["responses"]["BadRequest"];
+            401: components["responses"]["Unauthorized"];
+            500: components["responses"]["InternalError"];
+        };
+    };
+    signMessage: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                /**
+                 * @example {
+                 *       "message": "login:myapp:1716200000",
+                 *       "recipient": "myapp.example",
+                 *       "format": "nep413"
+                 *     }
+                 */
+                "application/json": components["schemas"]["SignMessageRequest"];
+            };
+        };
+        responses: {
+            /** @description Signature */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["SignMessageResponse"];
+                };
+            };
+            400: components["responses"]["BadRequest"];
+            401: components["responses"]["Unauthorized"];
+            403: components["responses"]["Forbidden"];
+            500: components["responses"]["InternalError"];
+        };
+    };
+    listRequests: {
+        parameters: {
+            query?: {
+                type?: components["schemas"]["RequestType"];
+                status?: components["schemas"]["RequestStatus"];
+                limit?: number;
+                offset?: number;
+            };
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Request list */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["RequestListResponse"];
+                };
+            };
+            401: components["responses"]["Unauthorized"];
+            500: components["responses"]["InternalError"];
+        };
+    };
+    getRequest: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Request status */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["RequestStatusResponse"];
+                };
+            };
+            401: components["responses"]["Unauthorized"];
+            404: components["responses"]["NotFound"];
+            500: components["responses"]["InternalError"];
+        };
+    };
+    getPolicy: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Current policy + usage */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["PolicyResponse"];
+                };
+            };
+            401: components["responses"]["Unauthorized"];
+            500: components["responses"]["InternalError"];
+        };
+    };
+    encryptPolicy: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["EncryptPolicyRequest"];
+            };
+        };
+        responses: {
+            /** @description Encrypted policy */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["EncryptPolicyResponse"];
+                };
+            };
+            400: components["responses"]["BadRequest"];
+            401: components["responses"]["Unauthorized"];
+            500: components["responses"]["InternalError"];
+        };
+    };
+    signPolicy: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["SignPolicyRequest"];
+            };
+        };
+        responses: {
+            /** @description Signature */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["SignPolicyResponse"];
+                };
+            };
+            400: components["responses"]["BadRequest"];
+            401: components["responses"]["Unauthorized"];
+            500: components["responses"]["InternalError"];
+        };
+    };
+    invalidatePolicyCache: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["InvalidateCacheRequest"];
+            };
+        };
+        responses: {
+            /** @description Cache cleared */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        ok?: boolean;
+                    };
+                };
+            };
+            400: components["responses"]["BadRequest"];
+            500: components["responses"]["InternalError"];
+        };
+    };
+    listPendingApprovals: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Pending approvals */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["PendingApprovalsResponse"];
+                };
+            };
+            401: components["responses"]["Unauthorized"];
+            500: components["responses"]["InternalError"];
+        };
+    };
+    approveRequest: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: string;
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["Nep413Auth"];
+            };
+        };
+        responses: {
+            /** @description Approval recorded */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ApproveResponse"];
+                };
+            };
+            403: components["responses"]["Forbidden"];
+            404: components["responses"]["NotFound"];
+            500: components["responses"]["InternalError"];
+        };
+    };
+    rejectRequest: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: string;
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["RejectRequest"];
+            };
+        };
+        responses: {
+            /** @description Rejection recorded */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ApproveResponse"];
+                };
+            };
+            403: components["responses"]["Forbidden"];
+            404: components["responses"]["NotFound"];
+            500: components["responses"]["InternalError"];
+        };
+    };
+    listAuditEvents: {
+        parameters: {
+            query?: {
+                limit?: number;
+                offset?: number;
+            };
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Event list */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["AuditResponse"];
+                };
+            };
+            401: components["responses"]["Unauthorized"];
+            500: components["responses"]["InternalError"];
+        };
+    };
+}
+
+type RetryConfig = {
+    maxAttempts?: number;
+    initialDelayMs?: number;
+    maxDelayMs?: number;
+};
+type ClientOptions = {
+    apiKey: string;
+    baseUrl?: string;
+    fetch?: typeof fetch;
+    retry?: RetryConfig;
+};
+type UnauthenticatedOptions = {
+    baseUrl?: string;
+    fetch?: typeof fetch;
+};
+type FetchClient = Client<paths, `${string}/${string}`>;
+
+type Schemas = components['schemas'];
+type Chain = Schemas['Chain'];
+type RequestType = Schemas['RequestType'];
+type RequestStatus = Schemas['RequestStatus'];
+type RegisterRequest = Schemas['RegisterRequest'];
+type RegisterResponse = Schemas['RegisterResponse'];
+type AddressResponse = Schemas['AddressResponse'];
+type BalanceResponse = Schemas['BalanceResponse'];
+type TokensResponse = Schemas['TokensResponse'];
+type CallRequest = Schemas['CallRequest'];
+type CallResponse = Schemas['CallResponse'];
+type TransferRequest = Schemas['TransferRequest'];
+type IntentsDepositRequest = Schemas['IntentsDepositRequest'];
+type IntentsDepositResponse = Schemas['IntentsDepositResponse'];
+type WithdrawRequest = Schemas['WithdrawRequest'];
+type WithdrawResponse = Schemas['WithdrawResponse'];
+type DryRunResponse = Schemas['DryRunResponse'];
+type SwapRequest = Schemas['SwapRequest'];
+type SwapResponse = Schemas['SwapResponse'];
+type SwapQuoteResponse = Schemas['SwapQuoteResponse'];
+type SignMessageRequest = Schemas['SignMessageRequest'];
+type SignMessageResponse = Schemas['SignMessageResponse'];
+type RequestStatusResponse = Schemas['RequestStatusResponse'];
+type RequestListResponse = Schemas['RequestListResponse'];
+type PolicyResponse = Schemas['PolicyResponse'];
+type PolicyRules = Schemas['PolicyRules'];
+type ApprovalConfig = Schemas['ApprovalConfig'];
+type EncryptPolicyRequest = Schemas['EncryptPolicyRequest'];
+type EncryptPolicyResponse = Schemas['EncryptPolicyResponse'];
+type SignPolicyResponse = Schemas['SignPolicyResponse'];
+type PendingApproval = Schemas['PendingApproval'];
+type PendingApprovalsResponse = Schemas['PendingApprovalsResponse'];
+type Nep413Auth = Schemas['Nep413Auth'];
+type ApproveResponse = Schemas['ApproveResponse'];
+type AuditEvent = Schemas['AuditEvent'];
+type AuditResponse = Schemas['AuditResponse'];
+type Idempotent = {
+    idempotencyKey?: string;
+};
+declare class PolicyAPI {
+    private readonly client;
+    private readonly retry;
+    constructor(client: FetchClient, retry: Required<RetryConfig>);
+    get(): Promise<PolicyResponse>;
+    encrypt(body: EncryptPolicyRequest): Promise<EncryptPolicyResponse>;
+    sign(encryptedData: string): Promise<SignPolicyResponse>;
+    invalidateCache(walletId: string): Promise<void>;
+}
+declare class ApprovalsAPI {
+    private readonly client;
+    private readonly retry;
+    constructor(client: FetchClient, retry: Required<RetryConfig>);
+    listPending(): Promise<PendingApprovalsResponse>;
+    approve(approvalId: string, auth: Nep413Auth): Promise<ApproveResponse>;
+    reject(approvalId: string, auth: Nep413Auth, reason?: string): Promise<ApproveResponse>;
+}
+declare class AuditAPI {
+    private readonly client;
+    private readonly retry;
+    constructor(client: FetchClient, retry: Required<RetryConfig>);
+    list(opts?: {
+        limit?: number;
+        offset?: number;
+    }): Promise<AuditResponse>;
+}
+declare class OutlayerClient {
+    private readonly client;
+    private readonly retry;
+    readonly policy: PolicyAPI;
+    readonly approvals: ApprovalsAPI;
+    readonly audit: AuditAPI;
+    constructor(opts: ClientOptions);
+    /**
+     * Register a new wallet and obtain an API key.
+     *
+     * - Empty call: anonymous wallet on OutLayer's shared master. Convenient, no setup.
+     * - With `vaultId`: bind to a deployed customer vault so keys derive through
+     *   the per-vault master. Vault binding is permanent.
+     * - With `body`: full control — pass any `RegisterRequest` field (e.g., NEP-413
+     *   account-binding fields). `vaultId` is merged into `body.vault_id` if not
+     *   already set.
+     *
+     * Vault deployment is NOT done here — use the dashboard
+     * (https://outlayer.fastnear.com/vault) or `outlayer vault init` CLI.
+     * See docs/vaults.md for the full flow.
+     */
+    static register(opts?: {
+        vaultId?: string;
+        body?: RegisterRequest;
+    } & UnauthenticatedOptions): Promise<RegisterResponse>;
+    getAddress(chain: Chain): Promise<AddressResponse>;
+    getBalance(opts?: {
+        chain?: Chain;
+        token?: string;
+        source?: 'chain' | 'intents';
+    }): Promise<BalanceResponse>;
+    listTokens(): Promise<TokensResponse>;
+    call(opts: CallRequest & Idempotent): Promise<CallResponse>;
+    transfer(opts: TransferRequest & Idempotent): Promise<CallResponse>;
+    intentsDeposit(opts: IntentsDepositRequest & Idempotent): Promise<IntentsDepositResponse>;
+    withdraw(opts: WithdrawRequest & Idempotent): Promise<WithdrawResponse>;
+    withdrawDryRun(opts: WithdrawRequest): Promise<DryRunResponse>;
+    swap(opts: SwapRequest & Idempotent): Promise<SwapResponse>;
+    swapQuote(opts: SwapRequest): Promise<SwapQuoteResponse>;
+    signMessage(opts: SignMessageRequest): Promise<SignMessageResponse>;
+    getRequest(id: string): Promise<RequestStatusResponse>;
+    listRequests(opts?: {
+        type?: RequestType;
+        status?: RequestStatus;
+        limit?: number;
+        offset?: number;
+    }): Promise<RequestListResponse>;
+}
+
+type ApiErrorCode = components['schemas']['ErrorCode'];
+type ErrorCode = ApiErrorCode | 'network_error' | 'parse_error';
+interface OutlayerErrorOptions {
+    code: ErrorCode;
+    message: string;
+    status: number;
+    details?: unknown;
+}
+declare class OutlayerError extends Error {
+    readonly code: ErrorCode;
+    readonly status: number;
+    readonly details: unknown;
+    constructor(opts: OutlayerErrorOptions);
+}
+declare class PolicyDeniedError extends OutlayerError {
+    constructor(opts: OutlayerErrorOptions);
+}
+declare class WalletFrozenError extends OutlayerError {
+    constructor(opts: OutlayerErrorOptions);
+}
+declare class UnauthorizedError extends OutlayerError {
+    constructor(opts: OutlayerErrorOptions);
+}
+declare class RateLimitedError extends OutlayerError {
+    constructor(opts: OutlayerErrorOptions);
+}
+declare class NotFoundError extends OutlayerError {
+    constructor(opts: OutlayerErrorOptions);
+}
+declare class BadRequestError extends OutlayerError {
+    constructor(opts: OutlayerErrorOptions);
+}
+
+export { type AddressResponse, type ApiErrorCode, type ApprovalConfig, ApprovalsAPI, type ApproveResponse, AuditAPI, type AuditEvent, type AuditResponse, BadRequestError, type BalanceResponse, type CallRequest, type CallResponse, type Chain, type ClientOptions, type DryRunResponse, type EncryptPolicyRequest, type EncryptPolicyResponse, type ErrorCode, type IntentsDepositRequest, type IntentsDepositResponse, type Nep413Auth, NotFoundError, OutlayerClient, OutlayerError, type PendingApproval, type PendingApprovalsResponse, PolicyAPI, PolicyDeniedError, type PolicyResponse, type PolicyRules, RateLimitedError, type RegisterRequest, type RegisterResponse, type RequestListResponse, type RequestStatus, type RequestStatusResponse, type RequestType, type RetryConfig, type SignMessageRequest, type SignMessageResponse, type SignPolicyResponse, type SwapQuoteResponse, type SwapRequest, type SwapResponse, type TokensResponse, type TransferRequest, type UnauthenticatedOptions, UnauthorizedError, WalletFrozenError, type WithdrawRequest, type WithdrawResponse };