@cexyio/cexy 0.1.0-dev.0

package/dist/index.d.ts

@@ -0,0 +1,3929 @@
+/** The parts of an outgoing request an authenticator may read or change. */
+interface AuthRequest {
+    readonly method: string;
+    /** Full URL including the query string. Credentials must never be added to it. */
+    readonly url: URL;
+    readonly headers: Headers;
+    /** The exact body bytes that will be sent (JSON text), if any. */
+    readonly body: string | undefined;
+}
+/**
+ * Adds credentials to requests for operations that need an API key.
+ *
+ * Called once per attempt (retries included), so a future signing implementation can put a
+ * fresh timestamp and nonce on each attempt. It is never called for public operations.
+ */
+interface Authenticator {
+    /** Short, non-secret description, e.g. `"api-key"`. */
+    readonly kind: string;
+    authenticate(request: AuthRequest): void | Promise<void>;
+    /** Removes any secret material from `text` (used on error messages and logs). */
+    redact(text: string): string;
+}
+/**
+ * Today's scheme: `X-API-Key` and `X-API-Secret` headers on every private request.
+ * HMAC request signing is planned before SDK 1.0 and will be another `Authenticator`.
+ */
+declare class ApiKeyAuthenticator implements Authenticator {
+    #private;
+    readonly kind = "api-key";
+    constructor(apiKey: string, apiSecret: string);
+    /** A non-secret hint for logs: the first characters of the key id. */
+    get keyHint(): string;
+    authenticate(request: AuthRequest): void;
+    redact(text: string): string;
+    toString(): string;
+    toJSON(): Record<string, string>;
+}
+
+/**
+ * Client-side token bucket. `CexyClient` defaults to 100 requests/minute without credentials
+ * and 300/minute with an API key (the server allows about 120/min per IP and 600/min per
+ * key; this keeps a margin). It adapts to `X-RateLimit-Limit`, `X-RateLimit-Remaining` and
+ * `X-RateLimit-Reset` when the server sends them, and to 429 `Retry-After`.
+ */
+interface RateLimiterOptions {
+    requestsPerMinute: number;
+    /** @internal for tests */
+    now?: () => number;
+    /** @internal for tests */
+    sleep?: (ms: number, signal?: AbortSignal) => Promise<void>;
+}
+interface RateLimiterState {
+    requestsPerMinute: number;
+    tokens: number;
+    blockedUntil: number;
+}
+declare class RateLimiter {
+    #private;
+    constructor(opts: RateLimiterOptions);
+    get state(): RateLimiterState;
+    /** Waits until a request may be sent, then takes a token. */
+    acquire(signal?: AbortSignal): Promise<void>;
+    /** Adapts to the server's rate-limit headers. Never raises the configured limit. */
+    update(headers: Headers): void;
+    /** Blocks all requests for `ms` (used for 429 Retry-After). */
+    blockFor(ms: number): void;
+}
+
+/**
+ * The SDK surface: exactly the operations in cexy-api-spec/spec/openapi.sdk.json.
+ * `auth` decides whether credentials are attached; a test asserts this table against the spec.
+ */
+type OperationAuth = "none" | "api_key";
+type OperationScope = "read" | "trade" | null;
+type HttpMethod = "GET" | "POST" | "DELETE";
+interface OperationInfo {
+    readonly method: HttpMethod;
+    readonly path: string;
+    readonly auth: OperationAuth;
+    readonly scope: OperationScope;
+    /** The facade method that calls it. */
+    readonly sdkMethod: string;
+}
+declare const OPERATIONS: {
+    readonly server_time: OperationInfo;
+    readonly exchange_config: OperationInfo;
+    readonly list_fee_schedules: OperationInfo;
+    readonly list_assets: OperationInfo;
+    readonly get_asset: OperationInfo;
+    readonly list_networks: OperationInfo;
+    readonly list_markets: OperationInfo;
+    readonly get_market: OperationInfo;
+    readonly get_order_book: OperationInfo;
+    readonly get_market_trades: OperationInfo;
+    readonly get_candles: OperationInfo;
+    readonly list_pools: OperationInfo;
+    readonly get_pool: OperationInfo;
+    readonly list_balances: OperationInfo;
+    readonly get_balance: OperationInfo;
+    readonly get_ledger: OperationInfo;
+    readonly list_notifications: OperationInfo;
+    readonly list_sub_accounts: OperationInfo;
+    readonly list_api_keys: OperationInfo;
+    readonly export_deposits: OperationInfo;
+    readonly export_ledger: OperationInfo;
+    readonly export_orders: OperationInfo;
+    readonly export_trades: OperationInfo;
+    readonly export_withdrawals: OperationInfo;
+    readonly list_deposits: OperationInfo;
+    readonly get_deposit: OperationInfo;
+    readonly list_withdrawals: OperationInfo;
+    readonly get_withdrawal: OperationInfo;
+    readonly list_withdrawal_addresses: OperationInfo;
+    readonly deposit_address: OperationInfo;
+    readonly list_open_orders: OperationInfo;
+    readonly get_order: OperationInfo;
+    readonly get_order_by_client_id: OperationInfo;
+    readonly order_history: OperationInfo;
+    readonly trade_history: OperationInfo;
+    readonly place_order: OperationInfo;
+    readonly cancel_order: OperationInfo;
+    readonly cancel_all: OperationInfo;
+    readonly join_pool: OperationInfo;
+    readonly exit_pool: OperationInfo;
+};
+type OperationId = keyof typeof OPERATIONS;
+
+type FetchLike = (input: string, init: RequestInit) => Promise<Response>;
+/** Per-call options accepted by every facade method as its last argument. */
+interface RequestOptions {
+    /** Abort the call (including retries and waits). */
+    signal?: AbortSignal;
+    /** Overrides the client's `timeoutMs` for each attempt. */
+    timeoutMs?: number;
+    /** Overrides the client's `maxRetries`. */
+    maxRetries?: number;
+    /**
+     * Mutations only: the `Idempotency-Key` to send. Generated automatically when absent.
+     * The server honours it on pool join/exit; set it yourself to make a retry across process
+     * restarts safe there. Orders and cancels do NOT honour it: their safety comes from
+     * `client_order_id` (see `placeOrder`).
+     */
+    idempotencyKey?: string;
+}
+/** Passed to the `onRetry` hook before the SDK waits and retries. */
+interface RetryInfo {
+    operation: OperationId;
+    method: string;
+    path: string;
+    /** 1 for the first retry. */
+    attempt: number;
+    delayMs: number;
+    error: unknown;
+    idempotencyKey: string | undefined;
+}
+interface TransportConfig {
+    baseUrl: string;
+    timeoutMs: number;
+    maxRetries: number;
+    fetch: FetchLike;
+    authenticator: Authenticator | null;
+    limiter: RateLimiter | null;
+    userAgent: string | null;
+    sleep: (ms: number, signal?: AbortSignal) => Promise<void>;
+    random: () => number;
+    onRetry?: ((info: RetryInfo) => void) | undefined;
+}
+interface CallSpec {
+    op: OperationId;
+    pathParams?: Record<string, string>;
+    query?: Record<string, unknown> | undefined;
+    body?: unknown;
+    responseType?: "json" | "text";
+    idempotencyKey?: string | undefined;
+}
+interface RawResponse {
+    status: number;
+    headers: Headers;
+    data: unknown;
+}
+declare class Transport {
+    readonly config: TransportConfig;
+    constructor(config: TransportConfig);
+    /**
+     * Sends a request with the standard retry policy: GETs retry on retryable errors and
+     * network failures. Mutations carry an `Idempotency-Key` reused on every attempt; the server
+     * honours it on pool join/exit, which makes their retries safe. The other mutations routed
+     * here (cancel-all) are naturally repeatable. `placeOrder` and `cancelOrder` use
+     * `attempt()` with their own policies.
+     */
+    request(spec: CallSpec, opts?: RequestOptions): Promise<RawResponse>;
+    /** Waits before retry number `attempt + 1`, honouring server hints. */
+    backoff(op: OperationId, info: OperationInfo, attempt: number, err: unknown, idempotencyKey: string | undefined, signal?: AbortSignal): Promise<void>;
+    /** Full-jitter exponential backoff, or the server's hint plus a little jitter. */
+    retryDelay(attempt: number, err: unknown): number;
+    /** One attempt: rate limiter, credentials, timeout, error mapping. No retries. */
+    attempt(spec: CallSpec, opts?: RequestOptions): Promise<RawResponse>;
+    buildUrl(info: OperationInfo, pathParams?: Record<string, string>, query?: Record<string, unknown>): URL;
+    redact(text: string): string;
+}
+/** Retryable = a network failure/timeout, or an API error with `retryable: true` (incl. 409 CONCURRENT_MODIFICATION). */
+declare function isRetryable(err: unknown): boolean;
+
+interface paths {
+    "/api/v1/account/api-keys": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** The account's API keys. */
+        get: operations["list_api_keys"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/account/balances": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Balances across every asset the account holds.
+         * @description Zero balances are omitted; ask for one by symbol to see it explicitly.
+         */
+        get: operations["list_balances"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/account/balances/{asset}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** One asset's balance, including a zero one. */
+        get: operations["get_balance"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/account/ledger": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** The account's ledger — every balance change, with its cause. */
+        get: operations["get_ledger"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/account/notifications": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** The account's notices, newest first. */
+        get: operations["list_notifications"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/account/sub-accounts": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** This account's sub-accounts. */
+        get: operations["list_sub_accounts"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/assets": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** Every listed asset, with its networks. */
+        get: operations["list_assets"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/assets/{symbol}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** One asset and its networks. */
+        get: operations["get_asset"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/config": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Public exchange configuration.
+         * @description Everything a frontend needs to render itself: branding, limits, supported intervals and maintenance state.
+         */
+        get: operations["exchange_config"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/exports/deposits": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** Exports the caller's deposits as CSV. */
+        get: operations["export_deposits"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/exports/ledger": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Exports the caller's ledger as CSV.
+         * @description The complete accounting record: every balance change with its cause.
+         */
+        get: operations["export_ledger"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/exports/orders": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** Exports the caller's orders as CSV. */
+        get: operations["export_orders"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/exports/trades": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** Exports the caller's trades as CSV. */
+        get: operations["export_trades"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/exports/withdrawals": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** Exports the caller's withdrawals as CSV. */
+        get: operations["export_withdrawals"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/fees": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** The fee schedule. */
+        get: operations["list_fee_schedules"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/markets": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** Every visible market with its ticker. */
+        get: operations["list_markets"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/markets/{symbol}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** One market. */
+        get: operations["get_market"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/markets/{symbol}/candles": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** OHLCV candles. */
+        get: operations["get_candles"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/markets/{symbol}/orderbook": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** Aggregated order book. */
+        get: operations["get_order_book"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/markets/{symbol}/trades": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** A market's recent trades. */
+        get: operations["get_market_trades"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/networks": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** Every configured network. */
+        get: operations["list_networks"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/pools": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** Every pool and what it holds. */
+        get: operations["list_pools"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/pools/{symbol}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** One market's pool. */
+        get: operations["get_pool"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/pools/{symbol}/exit": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Removes liquidity.
+         * @description The pool's resting orders for the market are cancelled first, because reserves locked in an order cannot be paid out. Shares are burned and a proportional slice of both assets is returned.
+         */
+        post: operations["exit_pool"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/pools/{symbol}/join": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Adds liquidity.
+         * @description Both assets are taken, in the ratio the pool already holds — only the quote that ratio requires is debited, however much is offered. The first join into an empty pool sets the price, and is refused if it strays far from the market's last traded price.
+         *
+         *     Send `Idempotency-Key` so a timed-out request can be retried without adding liquidity twice.
+         */
+        post: operations["join_pool"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/time": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** Server time, so a client can detect clock skew before it breaks two-factor. */
+        get: operations["server_time"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/trading/orders": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** Open orders, newest first. */
+        get: operations["list_open_orders"];
+        put?: never;
+        /**
+         * Places an order.
+         * @description Funds are reserved before the order reaches the book, so a matched order can never be unfunded. On a buy the reservation covers the value plus the **taker** fee, which is the worst case — a maker fill releases the difference.
+         *
+         *     Set `client_order_id` to make a retry safe: it is unique per account, so a repeat is refused before any funds move, and `GET /trading/orders/by-client-id/{client_order_id}` recovers the outcome. `Idempotency-Key` is not honoured here.
+         */
+        post: operations["place_order"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/trading/orders/{order_id}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** One order. */
+        get: operations["get_order"];
+        put?: never;
+        post?: never;
+        /** Cancels an order, releasing only what is still reserved. */
+        delete: operations["cancel_order"];
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/trading/orders/by-client-id/{client_order_id}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** One order, looked up by the id the client supplied. */
+        get: operations["get_order_by_client_id"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/trading/orders/cancel-all": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Cancels every open order, optionally within one market.
+         * @description Best-effort: a failure on one order does not stop the rest, and both outcomes are reported. A panic-button endpoint that stops at the first problem is worse than useless.
+         */
+        post: operations["cancel_all"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/trading/orders/history": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** Order history, including terminal orders. */
+        get: operations["order_history"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/trading/trades": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** The caller's executions. */
+        get: operations["trade_history"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/wallet/deposit-address": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * The caller's deposit address for an asset on a network.
+         * @description The first call for an asset and network creates the address; every later call, and any call racing the first, returns that same address. On chains where an address works across sibling networks, the account's address from a sibling is reused.
+         */
+        get: operations["deposit_address"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/wallet/deposits": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** Deposit history. */
+        get: operations["list_deposits"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/wallet/deposits/{deposit_id}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** One deposit. */
+        get: operations["get_deposit"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/wallet/withdrawal-addresses": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** The caller's saved withdrawal addresses. */
+        get: operations["list_withdrawal_addresses"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/wallet/withdrawals": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** Withdrawal history. */
+        get: operations["list_withdrawals"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/wallet/withdrawals/{withdrawal_id}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** One withdrawal, with its full status history. */
+        get: operations["get_withdrawal"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+}
+interface components {
+    schemas: {
+        /**
+         * @description Exact decimal amount, serialized as a string to avoid floating-point precision loss. Example: "1.50000000".
+         * @example 1.50000000
+         */
+        Amount: string;
+        /** @description An existing key. Never carries the secret. */
+        ApiKeyResponse: {
+            /** @description Permitted source addresses. Empty means unrestricted. */
+            allowed_ips: string[];
+            /**
+             * Format: date-time
+             * @description When it was created.
+             */
+            created_at: string;
+            /**
+             * Format: date-time
+             * @description When it stops working.
+             */
+            expires_at?: string | null;
+            /** @description Opaque key identifier, used to revoke it. */
+            id: string;
+            /** @description The public key id, sent as `X-API-Key`. */
+            key_id: string;
+            /** @description Human label. */
+            label: string;
+            /**
+             * Format: date-time
+             * @description When it was last used, if ever.
+             */
+            last_used_at?: string | null;
+            /** @description Whether it has been revoked. */
+            revoked: boolean;
+            /** @description Granted scopes. */
+            scopes: components["schemas"]["ApiScope"][];
+        };
+        /**
+         * @description Scope attached to an API key.
+         *
+         *      Scopes narrow what an API key may do. They apply to API keys only: a signed-in session carries none and is not limited by them.
+         * @enum {string}
+         */
+        ApiScope: "read" | "trade";
+        /** @description An asset's policy on one network. */
+        AssetNetworkResponse: {
+            /** @description Contract address or chain asset id, for a token. */
+            contract_address?: string | null;
+            /**
+             * Format: int32
+             * @description Confirmations before a deposit is credited.
+             */
+            deposit_confirmations: number;
+            /** @description Whether deposits are accepted. */
+            deposit_enabled: boolean;
+            maintenance?: components["schemas"]["MaintenanceState"] | null;
+            max_withdrawal?: components["schemas"]["Amount"] | null;
+            /** @description What to call the memo field in a UI. */
+            memo_label?: string | null;
+            /** @description Whether a memo is mandatory. */
+            memo_required: boolean;
+            /** @description Whether the network uses a memo / destination tag. */
+            memo_supported: boolean;
+            min_deposit: components["schemas"]["Amount"];
+            min_withdrawal: components["schemas"]["Amount"];
+            /**
+             * @description Network code.
+             * @example bitcoin-mainnet
+             */
+            network: string;
+            /** @description Network display name. */
+            network_name: string;
+            /** @description Operator note. */
+            notice?: string | null;
+            /** @description How the asset exists on this chain. */
+            token_kind: string;
+            /**
+             * Format: int32
+             * @description Decimal places a withdrawal amount is truncated to.
+             */
+            withdrawal_decimals: number;
+            /** @description Whether withdrawals are accepted. */
+            withdrawal_enabled: boolean;
+            withdrawal_fee: components["schemas"]["Amount"];
+            /** @description Asset the withdrawal fee is charged in. */
+            withdrawal_fee_asset: string;
+        };
+        /** @description A tradable asset. */
+        AssetResponse: {
+            /**
+             * Format: int32
+             * @description Accounting precision: the decimal places the exchange records internally.
+             *
+             *     Use this for arithmetic. For rendering, use `display_decimals`.
+             */
+            decimals: number;
+            /**
+             * Format: int32
+             * @description Decimal places to show in a user interface.
+             *
+             *     Always less than or equal to `decimals`. Rounding for display is presentation only and must never be fed back into a request.
+             */
+            display_decimals: number;
+            /** @description Identifier for a client-bundled icon, when no logo URL is set. */
+            icon_key?: string | null;
+            /** @description Logo URL, when the operator has configured one. */
+            logo_url?: string | null;
+            /**
+             * Format: int64
+             * @description How old this asset's price may be before it is refused, in seconds.
+             *
+             *     The global default unless an operator set an override for this asset. Exposed beside the flag because the flag alone cannot explain itself: an asset that is not stale after a week and one that is not stale after an hour look identical without it.
+             */
+            max_price_age_secs: number;
+            /** @description Display name. */
+            name: string;
+            /** @description Networks this asset can be deposited to or withdrawn from. */
+            networks: components["schemas"]["AssetNetworkResponse"][];
+            /** @description Operator note, e.g. why deposits are paused. */
+            notice?: string | null;
+            /**
+             * @description Uppercase ticker.
+             * @example BTC
+             */
+            symbol: string;
+            /** @description Whether the asset may appear in markets. */
+            trading_enabled: boolean;
+            usd_price: components["schemas"]["Amount"];
+            /**
+             * @description Whether that price is too old to compute with.
+             *
+             *     When true, the exchange refuses to derive anything from it: daily limits and auto-approval fail closed rather than guess, and a stored USD value is recorded as absent rather than as a confident wrong figure.
+             */
+            usd_price_stale: boolean;
+            /**
+             * Format: date-time
+             * @description When that price was last set.
+             *
+             *     Exposed because the price is typed in by an operator and refreshed by nothing — there is no feed. Without the timestamp a caller cannot tell a price set an hour ago from one set last month, and both look equally authoritative.
+             */
+            usd_price_updated_at: string;
+            /** @description Project website. */
+            website_url?: string | null;
+        };
+        /** @description A balance in one asset. */
+        BalanceResponse: {
+            /** @description Asset symbol. */
+            asset: string;
+            available: components["schemas"]["Amount"];
+            locked: components["schemas"]["Amount"];
+            pending: components["schemas"]["Amount"];
+            total: components["schemas"]["Amount"];
+        };
+        /** @description Cancels every open order, optionally within one market. */
+        CancelAllRequest: {
+            /** @description Limit the cancellation to one market. Omitted or `null`, every market's open orders are cancelled. */
+            symbol?: string | null;
+        };
+        /** @description What a bulk cancellation achieved. */
+        CancelAllResponse: {
+            /** @description Orders cancelled. */
+            cancelled: string[];
+            /** @description Orders that could not be cancelled. Each failure is logged server-side. */
+            failed: string[];
+        };
+        /**
+         * @description Candle/kline intervals for market data.
+         * @enum {string}
+         */
+        CandleInterval: "1m" | "5m" | "15m" | "30m" | "1h" | "4h" | "1d" | "1w";
+        /** @description An OHLCV bucket. */
+        CandleResponse: {
+            close: components["schemas"]["Amount"];
+            high: components["schemas"]["Amount"];
+            low: components["schemas"]["Amount"];
+            open: components["schemas"]["Amount"];
+            /**
+             * Format: date-time
+             * @description Bucket start.
+             */
+            open_time: string;
+            quote_volume: components["schemas"]["Amount"];
+            /**
+             * Format: int64
+             * @description Number of trades.
+             */
+            trade_count: number;
+            volume: components["schemas"]["Amount"];
+        };
+        /** @description A deposit address. */
+        DepositAddressResponse: {
+            /** @description The address to send to. */
+            address: string;
+            /** @description Asset symbol. */
+            asset: string;
+            /**
+             * Format: date-time
+             * @description When the address was issued.
+             */
+            created_at: string;
+            /**
+             * Format: int32
+             * @description Confirmations before the deposit is credited.
+             */
+            deposit_confirmations: number;
+            /** @description Memo / destination tag. **Required when present** — a deposit without it may be unrecoverable. */
+            memo?: string | null;
+            /** @description What to call the memo field in a UI. */
+            memo_label?: string | null;
+            min_deposit: components["schemas"]["Amount"];
+            /** @description Network code. */
+            network: string;
+        };
+        /** @description A deposit. */
+        DepositResponse: {
+            /** @description Address that received it. */
+            address: string;
+            amount: components["schemas"]["Amount"];
+            /** @description Asset symbol. */
+            asset: string;
+            /**
+             * Format: int32
+             * @description Confirmations observed.
+             */
+            confirmations: number;
+            /**
+             * Format: date-time
+             * @description When it was credited.
+             */
+            credited_at?: string | null;
+            /** @description Explorer link, when the network has one configured. */
+            explorer_url?: string | null;
+            /**
+             * Format: date-time
+             * @description When it was first observed.
+             */
+            first_seen_at: string;
+            /** @description Deposit id. */
+            id: string;
+            /** @description Memo, if any. */
+            memo?: string | null;
+            /** @description Network code. */
+            network: string;
+            /** @description Operator note, e.g. why it was reversed. */
+            note?: string | null;
+            /**
+             * Format: int32
+             * @description Position within the transaction. Distinguishes two outputs of one transaction.
+             */
+            output_index: number;
+            /**
+             * Format: int32
+             * @description Confirmations required to credit.
+             */
+            required_confirmations: number;
+            status: components["schemas"]["DepositStatus"];
+            /** @description Transaction hash. */
+            txid: string;
+        };
+        /**
+         * @description Lifecycle of an incoming blockchain deposit.
+         * @enum {string}
+         */
+        DepositStatus: "detected" | "credited" | "reversed" | "orphaned" | "below_minimum" | "under_review" | "internal";
+        /** @description A structured value attached to an error. Kept deliberately narrow so that no accidental secret (a token, a key, a full document) can be attached. */
+        DetailValue: string | number | boolean;
+        /** @description The `error` object as it appears on the wire. */
+        ErrorBody: {
+            code: components["schemas"]["ErrorCode"];
+            /** @description Structured context, when available. */
+            details?: {
+                [key: string]: components["schemas"]["DetailValue"];
+            };
+            /**
+             * @description Per-field validation messages, keyed by request field name.
+             *
+             *     Present only on validation failures. Render each message beside its input.
+             */
+            fields?: {
+                [key: string]: string;
+            };
+            /** @description Human-readable description. May change between releases. */
+            message: string;
+            /** @description Correlates this response with server logs. Quote it in support requests. */
+            request_id?: string | null;
+            /** @description Whether an identical retry could succeed. */
+            retryable: boolean;
+        };
+        /**
+         * @description Stable, machine-readable error identifiers.
+         *
+         *     Serialized as `SCREAMING_SNAKE_CASE`. Adding a variant is backwards-compatible; renaming or removing one is a breaking API change.
+         * @enum {string}
+         */
+        ErrorCode: "VALIDATION_FAILED" | "MALFORMED_REQUEST" | "INVALID_CURSOR" | "PRECISION_EXCEEDED" | "BELOW_MINIMUM" | "ABOVE_MAXIMUM" | "INVALID_ADDRESS" | "MEMO_REQUIRED" | "UNAUTHENTICATED" | "INVALID_CREDENTIALS" | "TOKEN_EXPIRED" | "SESSION_REVOKED" | "TWO_FACTOR_REQUIRED" | "TWO_FACTOR_INVALID" | "FRESH_TWO_FACTOR_REQUIRED" | "FORBIDDEN" | "API_KEY_NOT_ALLOWED" | "FUTURES_RESTRICTED" | "ACCOUNT_FROZEN" | "ACCOUNT_ON_HOLD" | "EMAIL_NOT_VERIFIED" | "REGION_BLOCKED" | "JURISDICTION_BLOCKED" | "NOT_FOUND" | "METHOD_NOT_ALLOWED" | "ALREADY_EXISTS" | "INVALID_STATE" | "IDEMPOTENCY_KEY_CONFLICT" | "WINDOW_OPEN" | "EVIDENCE_CONTRADICTS" | "AMOUNT_MISMATCH" | "CONCURRENT_MODIFICATION" | "INSUFFICIENT_FUNDS" | "INSUFFICIENT_FEE_FUNDS" | "MARKET_UNAVAILABLE" | "DEPOSIT_DISABLED" | "WITHDRAWAL_DISABLED" | "SELF_TRADE_BLOCKED" | "LIMIT_EXCEEDED" | "RATE_LIMITED" | "INTERNAL" | "SERVICE_UNAVAILABLE" | "UNDER_MAINTENANCE" | "ENGINE_OVERLOADED";
+        /** @description The top-level error envelope. */
+        ErrorResponse: {
+            error: components["schemas"]["ErrorBody"];
+        };
+        /**
+         * @description Public exchange configuration.
+         *
+         *     Everything a frontend needs to render itself without a deploy: branding, limits, supported intervals, and whether the exchange is in maintenance.
+         */
+        ExchangeConfigResponse: {
+            /** @description Candle intervals the API serves. */
+            candle_intervals: components["schemas"]["CandleInterval"][];
+            /**
+             * Format: int32
+             * @description Default page size for paginated endpoints.
+             */
+            default_page_size: number;
+            /** @description Whether registration verifies the email address with an emailed code before the authenticator step. Lets a signup form show the right number of steps up front. */
+            email_verification_required: boolean;
+            /**
+             * @description Feature flags a frontend may use to hide unavailable functionality.
+             *
+             *     Presentation only. The backend enforces every rule independently.
+             */
+            features: {
+                [key: string]: boolean;
+            };
+            /** @description Message to show while in maintenance. */
+            maintenance_message?: string | null;
+            /** @description Whether the exchange is in maintenance mode. */
+            maintenance_mode: boolean;
+            /**
+             * Format: int32
+             * @description Maximum page size.
+             */
+            max_page_size: number;
+            /** @description Display name. */
+            name: string;
+            password_rules: components["schemas"]["PasswordRules"];
+            /** @description Whether new registrations are accepted. */
+            registration_enabled: boolean;
+            /** @description Support contact. */
+            support_url?: string | null;
+            /**
+             * Format: int64
+             * @description Seconds a verified two-factor code authorises sensitive actions for.
+             */
+            two_factor_freshness_seconds: number;
+            /** @description Where to open the realtime connection, relative to this API's origin. */
+            websocket_path: string;
+            /**
+             * Format: int32
+             * @description The realtime protocol version this server speaks.
+             */
+            websocket_protocol_version: number;
+        };
+        /** @description Removes liquidity from a pool. */
+        ExitPoolRequest: {
+            shares: components["schemas"]["Amount"];
+        };
+        /** @description What an exit produced. */
+        ExitPoolResponse: {
+            base_returned: components["schemas"]["Amount"];
+            quote_returned: components["schemas"]["Amount"];
+            shares_burned: components["schemas"]["Amount"];
+            shares_held: components["schemas"]["Amount"];
+        };
+        /** @description A fee tier. */
+        FeeScheduleResponse: {
+            /** @description Human label. */
+            label: string;
+            /**
+             * @description Maker rate, as a percentage.
+             * @example 0.1
+             */
+            maker_fee_percent: string;
+            min_30d_volume_usd: components["schemas"]["Amount"];
+            /**
+             * @description Taker rate, as a percentage.
+             * @example 0.2
+             */
+            taker_fee_percent: string;
+            /**
+             * Format: int32
+             * @description Tier index.
+             */
+            tier: number;
+        };
+        /** @description One of the caller's executions. */
+        FillResponse: {
+            fee: components["schemas"]["Amount"];
+            /** @description Asset the fee was charged in. */
+            fee_asset: string;
+            /** @description The caller's order. */
+            order_id: string;
+            price: components["schemas"]["Amount"];
+            quantity: components["schemas"]["Amount"];
+            quote_quantity: components["schemas"]["Amount"];
+            role: components["schemas"]["LiquidityRole"];
+            side: components["schemas"]["OrderSide"];
+            /** @description Market symbol. */
+            symbol: string;
+            /**
+             * Format: date-time
+             * @description When it executed.
+             */
+            timestamp: string;
+            /** @description Trade id. */
+            trade_id: string;
+        };
+        /** @description Adds liquidity to a pool. */
+        JoinPoolRequest: {
+            base_amount: components["schemas"]["Amount"];
+            /**
+             * @description How far, in percent, the offered ratio may sit from the pool's own before the request is refused rather than repriced. Defaults to 1%.
+             * @example 1
+             */
+            max_ratio_deviation_percent?: string | null;
+            quote_amount: components["schemas"]["Amount"];
+        };
+        /** @description What a join produced. */
+        JoinPoolResponse: {
+            base_deposited: components["schemas"]["Amount"];
+            quote_deposited: components["schemas"]["Amount"];
+            shares_held: components["schemas"]["Amount"];
+            shares_minted: components["schemas"]["Amount"];
+        };
+        /**
+         * @description What a ledger entry records.
+         * @enum {string}
+         */
+        LedgerEntryKind: "deposit" | "deposit_reversal" | "withdrawal_debit" | "withdrawal_fee" | "withdrawal_fee_reserve" | "withdrawal_release" | "withdrawal_fee_release" | "order_reserve" | "withdrawal_reserve" | "order_release" | "trade_debit" | "trade_credit" | "trade_fee" | "transfer_out" | "transfer_in" | "adjustment_credit" | "adjustment_debit" | "rebate" | "pool_join" | "pool_exit" | "futures_transfer_reserve" | "futures_transfer_release" | "futures_collateral_sent" | "futures_collateral_returned" | "trade_fee_revenue" | "withdrawal_fee_revenue" | "futures_transfer_fee_revenue" | "futures_hyperliquid_cost" | "futures_transfer_discrepancy" | "exchange_capital";
+        /** @description One entry from the account's ledger. */
+        LedgerEntryResponse: {
+            /** @description Asset symbol. */
+            asset: string;
+            available_after: components["schemas"]["Amount"];
+            available_delta: components["schemas"]["Amount"];
+            /**
+             * Format: date-time
+             * @description When it was applied.
+             */
+            created_at: string;
+            /** @description Entry id. */
+            id: string;
+            kind: components["schemas"]["LedgerEntryKind"];
+            locked_delta: components["schemas"]["Amount"];
+            pending_delta: components["schemas"]["Amount"];
+            /** @description What caused the entry. */
+            reference: unknown;
+            /**
+             * Format: int64
+             * @description Position in this account's history for this asset.
+             */
+            sequence: number;
+        };
+        /**
+         * @description Whether a fill added liquidity (maker) or removed it (taker).
+         * @enum {string}
+         */
+        LiquidityRole: "maker" | "taker";
+        /**
+         * @description Machine-readable reasons a capability is unavailable.
+         * @enum {string}
+         */
+        MaintenanceReason: "exchange_maintenance" | "network_unavailable" | "deposits_disabled" | "withdrawals_disabled" | "asset_unavailable";
+        /** @description Why a capability is currently unavailable. */
+        MaintenanceState: {
+            /** @description Operator-supplied explanation, when there is one. */
+            message?: string | null;
+            reason: components["schemas"]["MaintenanceReason"];
+        };
+        /** @description A tradable market and its current ticker. */
+        MarketResponse: {
+            /** @description Base asset symbol. */
+            base_asset: string;
+            best_ask: components["schemas"]["Amount"];
+            best_bid: components["schemas"]["Amount"];
+            change_24h_percent: components["schemas"]["Amount"];
+            high_24h: components["schemas"]["Amount"];
+            last_price: components["schemas"]["Amount"];
+            /**
+             * Format: date-time
+             * @description Time of the most recent trade.
+             */
+            last_trade_at?: string | null;
+            lot_size: components["schemas"]["Amount"];
+            low_24h: components["schemas"]["Amount"];
+            max_quantity?: components["schemas"]["Amount"] | null;
+            min_notional: components["schemas"]["Amount"];
+            min_quantity: components["schemas"]["Amount"];
+            /**
+             * Format: int32
+             * @description Decimal places a price may carry.
+             */
+            price_decimals: number;
+            /**
+             * Format: int32
+             * @description Decimal places a quantity may carry.
+             */
+            quantity_decimals: number;
+            /** @description Quote asset symbol. */
+            quote_asset: string;
+            quote_volume_24h: components["schemas"]["Amount"];
+            status: components["schemas"]["MarketStatus"];
+            /** @description Order types this market accepts. */
+            supported_order_types: components["schemas"]["OrderType"][];
+            /** @description Time-in-force options this market accepts. */
+            supported_time_in_force: components["schemas"]["TimeInForce"][];
+            /**
+             * @description `BASE/QUOTE`.
+             * @example BTC/USDT
+             */
+            symbol: string;
+            tick_size: components["schemas"]["Amount"];
+            /**
+             * Format: date-time
+             * @description When trading opens, for a market not yet live.
+             */
+            trading_starts_at?: string | null;
+            volume_24h: components["schemas"]["Amount"];
+        };
+        /**
+         * @description Trading availability of a market.
+         * @enum {string}
+         */
+        MarketStatus: "active" | "paused" | "sell_only" | "pre_trading" | "delisted";
+        /** @description A blockchain network. */
+        NetworkResponse: {
+            /**
+             * Format: int32
+             * @description Typical seconds between blocks, for estimating confirmation time.
+             */
+            average_block_seconds: number;
+            /**
+             * @description Stable code.
+             * @example bitcoin-mainnet
+             */
+            code: string;
+            /**
+             * @description Whether deposits on this network are actually being detected.
+             *
+             *     False means either half of the pipeline is down: the last scan pass failed — a refused block range, a rate limit, a node that answers but will not serve logs — or finality could not be established, so deposits are being held rather than credited.
+             *
+             *     Deposits sent now will be credited late, whenever the chain recovers, rather than lost. This is the field a status page should use to say deposits are degraded; `reachable` only says the node replies, which it may well do while yielding nothing.
+             */
+            deposits_operational: boolean;
+            /** @description Template for an address explorer link. `{address}` is substituted. */
+            explorer_address_url_template?: string | null;
+            /**
+             * @description Template for a transaction explorer link. `{txid}` is substituted.
+             *
+             *     Absent when the operator has configured none; render no link rather than guessing a URL.
+             */
+            explorer_tx_url_template?: string | null;
+            /** @description Whether the network is operational. */
+            is_active: boolean;
+            /** @description Display name. */
+            name: string;
+            /**
+             * @description Whether the node answers at all.
+             *
+             *     Narrower than it sounds, and deliberately so: a reachable node can still be failing to yield deposits. Do not render this alone as "network up".
+             */
+            reachable: boolean;
+        };
+        /**
+         * @description What a notice is about.
+         *
+         *     A closed enum so a client can render each kind deliberately — an icon, a colour, a link — rather than pattern-matching on prose that may be reworded.
+         * @enum {string}
+         */
+        NotificationKind: "deposit_detected" | "deposit_credited" | "withdrawal_requested" | "withdrawal_sent" | "withdrawal_completed" | "withdrawal_failed" | "order_filled" | "security" | "listing_decision" | "announcement";
+        /** @description An in-app notice. */
+        NotificationResponse: {
+            /** @description One or two sentences. */
+            body: string;
+            /**
+             * Format: date-time
+             * @description When it was created.
+             */
+            created_at: string;
+            /** @description Notice id. */
+            id: string;
+            kind: components["schemas"]["NotificationKind"];
+            /** @description Whether it has been read. */
+            read: boolean;
+            /** @description The referenced resource's opaque id, for linking. */
+            resource_id?: string | null;
+            /** @description What it refers to: `deposit`, `withdrawal`, `order`. */
+            resource_type?: string | null;
+            /** @description Short heading. */
+            title: string;
+        };
+        /** @description One side of the order book, aggregated by price. */
+        OrderBookResponse: {
+            /** @description Asks, best first. */
+            asks: components["schemas"]["Amount"][][];
+            /** @description Bids, best first, as `[price, quantity]` pairs. */
+            bids: components["schemas"]["Amount"][][];
+            /**
+             * Format: int64
+             * @description The realtime sequence this snapshot is current as of.
+             *
+             *     Each `orderbook.update` on the `orderbook:{symbol}` websocket channel carries both sides of the top 50 levels in full (`data.full` is always `true`) and replaces the previous state; there are no deltas to buffer. Ignore an update whose `sequence` is at or below the one you hold. A gap only means a book was missed: the next update replaces it whole.
+             */
+            sequence: number;
+            /** @description Market symbol. */
+            symbol: string;
+            /**
+             * Format: date-time
+             * @description When this snapshot was taken.
+             */
+            timestamp: string;
+        };
+        /** @description An order. */
+        OrderResponse: {
+            average_price?: components["schemas"]["Amount"] | null;
+            /** @description Your identifier, if you supplied one. */
+            client_order_id?: string | null;
+            /**
+             * Format: date-time
+             * @description When it reached a terminal state.
+             */
+            closed_at?: string | null;
+            /**
+             * Format: date-time
+             * @description When it was placed.
+             */
+            created_at: string;
+            /** @description Asset the fees were charged in. */
+            fee_asset?: string | null;
+            fee_paid: components["schemas"]["Amount"];
+            filled_quantity: components["schemas"]["Amount"];
+            filled_quote_quantity: components["schemas"]["Amount"];
+            /** @description Order id. */
+            id: string;
+            price?: components["schemas"]["Amount"] | null;
+            quantity: components["schemas"]["Amount"];
+            quote_quantity?: components["schemas"]["Amount"] | null;
+            remaining_quantity: components["schemas"]["Amount"];
+            reserved_remaining: components["schemas"]["Amount"];
+            side: components["schemas"]["OrderSide"];
+            status: components["schemas"]["OrderStatus"];
+            /** @description Why the order was rejected or cancelled. */
+            status_reason?: string | null;
+            stop_price?: components["schemas"]["Amount"] | null;
+            /** @description Market symbol. */
+            symbol: string;
+            time_in_force: components["schemas"]["TimeInForce"];
+            trigger_direction?: components["schemas"]["TriggerDirection"] | null;
+            /**
+             * Format: date-time
+             * @description When the trigger fired, if it has.
+             */
+            triggered_at?: string | null;
+            type: components["schemas"]["OrderType"];
+            /**
+             * Format: date-time
+             * @description When it last changed.
+             */
+            updated_at: string;
+        };
+        /**
+         * @description Which side of a market an order takes.
+         * @enum {string}
+         */
+        OrderSide: "buy" | "sell";
+        /**
+         * @description Lifecycle of an order.
+         * @enum {string}
+         */
+        OrderStatus: "pending" | "open" | "partially_filled" | "filled" | "cancelled" | "rejected" | "pending_trigger" | "expired";
+        /**
+         * @description Order types the matching engine accepts.
+         * @enum {string}
+         */
+        OrderType: "limit" | "market" | "stop_limit" | "stop_market";
+        /** @description Password constraints, published so a form can validate locally. */
+        PasswordRules: {
+            /** @description Whether the password may contain the account's email address. */
+            allows_email_substring: boolean;
+            /** @description A short description of any further rules, for display beside the input. */
+            description: string;
+            /** @description Maximum length in characters. */
+            max_length: number;
+            /** @description Minimum length in characters. */
+            min_length: number;
+        };
+        /**
+         * @description Places an order.
+         *
+         *     Set `client_order_id` to make a retry safe: it is unique per account, so a repeat is refused before any funds move, and `GET /trading/orders/by-client-id/{client_order_id}` recovers the outcome. `Idempotency-Key` is not honoured for orders.
+         */
+        PlaceOrderRequest: {
+            /** @description Your own identifier. Unique per account. */
+            client_order_id?: string | null;
+            price?: components["schemas"]["Amount"] | null;
+            quantity?: components["schemas"]["Amount"] | null;
+            quote_quantity?: components["schemas"]["Amount"] | null;
+            side: components["schemas"]["OrderSide"];
+            stop_price?: components["schemas"]["Amount"] | null;
+            /**
+             * @description Market symbol.
+             * @example BTC/USDT
+             */
+            symbol: string;
+            time_in_force?: components["schemas"]["TimeInForce"] | null;
+            trigger_direction?: components["schemas"]["TriggerDirection"] | null;
+            type: components["schemas"]["OrderType"];
+        };
+        /** @description The result of placing an order, including anything it executed immediately. */
+        PlaceOrderResponse: {
+            /** @description Fills produced on entry, oldest first. */
+            fills: components["schemas"]["FillResponse"][];
+            order: components["schemas"]["OrderResponse"];
+        };
+        /**
+         * @description A pool as a client sees it.
+         *
+         *     Reserves are the custody account's balances, so they include liquidity currently locked in resting orders. `price` is the curve's mid, which sits between the pool's own best bid and ask by exactly its fee — it is not a traded price.
+         */
+        PoolResponse: {
+            base_reserve: components["schemas"]["Amount"];
+            /**
+             * Format: date-time
+             * @description When the pool was created.
+             */
+            created_at: string;
+            /**
+             * @description The pool's fee, in percent, priced into every quote it rests.
+             * @example 0.3
+             */
+            fee_percent: string;
+            /** @description Identifier. */
+            id: string;
+            /**
+             * Format: int32
+             * @description Ladder steps per side.
+             */
+            ladder_steps: number;
+            price?: components["schemas"]["Amount"] | null;
+            quote_reserve: components["schemas"]["Amount"];
+            shares_outstanding: components["schemas"]["Amount"];
+            status: components["schemas"]["PoolStatus"];
+            /** @description Market the pool quotes. */
+            symbol: string;
+        };
+        /**
+         * @description Whether a pool quotes, and whether it accepts new liquidity.
+         * @enum {string}
+         */
+        PoolStatus: "active" | "paused" | "closing";
+        /**
+         * @description A public trade.
+         *
+         *     Deliberately anonymous: no account identifiers, and no indication of which side was the resting order beyond the aggressor direction.
+         */
+        PublicTradeResponse: {
+            /** @description Trade id. */
+            id: string;
+            price: components["schemas"]["Amount"];
+            quantity: components["schemas"]["Amount"];
+            /**
+             * Format: int64
+             * @description Gapless per-market sequence.
+             */
+            sequence: number;
+            side: components["schemas"]["OrderSide"];
+            /**
+             * Format: date-time
+             * @description When it executed.
+             */
+            timestamp: string;
+        };
+        /**
+         * @description The server's clock.
+         *
+         *     Two-factor codes are time-based, so a client can compare its own clock against this before a skewed clock gets a correct code rejected.
+         */
+        ServerTimeResponse: {
+            /**
+             * Format: int64
+             * @description Current time in milliseconds since the Unix epoch.
+             */
+            epoch_ms: number;
+            /**
+             * @description Current time as RFC 3339 with an explicit UTC offset.
+             * @example 2024-05-01T12:34:56.789+00:00
+             */
+            iso: string;
+        };
+        /**
+         * @description Sort direction for a paginated listing.
+         * @enum {string}
+         */
+        SortDirection: "asc" | "desc";
+        /** @description A sub-account. */
+        SubAccountResponse: {
+            /** @description Always `false`. A sub-account has no withdrawal path — stated explicitly so a client does not have to infer it. */
+            can_withdraw: boolean;
+            /**
+             * Format: date-time
+             * @description When it was created.
+             */
+            created_at: string;
+            /** @description Opaque identifier. Use it to transfer funds and to issue API keys. */
+            id: string;
+            /** @description Whether it may trade. */
+            is_active: boolean;
+            /** @description The label given at creation. */
+            label: string;
+        };
+        /**
+         * @description How long an order remains eligible to match.
+         * @enum {string}
+         */
+        TimeInForce: "gtc" | "ioc" | "fok" | "post_only";
+        /**
+         * @description Which way the price must move for a stop to fire.
+         *
+         *     Explicit rather than inferred from the side, because the inference is ambiguous: a sell stop below the market is a stop-loss, and a sell stop above it is a take-profit. Both are legitimate, and guessing wrong means an order that fires at exactly the wrong moment — which is the one thing a protective order must never do.
+         * @enum {string}
+         */
+        TriggerDirection: "above" | "below";
+        /** @description A saved withdrawal address. */
+        WithdrawalAddressResponse: {
+            /** @description The address. */
+            address: string;
+            /** @description Asset, when restricted to one. */
+            asset?: string | null;
+            /**
+             * Format: date-time
+             * @description When it was saved.
+             */
+            created_at: string;
+            /** @description Address-book entry id. */
+            id: string;
+            /** @description Your label. */
+            label: string;
+            /**
+             * Format: date-time
+             * @description When it was last withdrawn to.
+             */
+            last_used_at?: string | null;
+            /** @description Memo, if any. */
+            memo?: string | null;
+            /** @description Network code. */
+            network: string;
+            /** @description Whether ownership has been confirmed. */
+            verified: boolean;
+        };
+        /** @description One transition in a withdrawal's life. */
+        WithdrawalHistoryEntry: {
+            /**
+             * Format: date-time
+             * @description When.
+             */
+            at: string;
+            /** @description Why, where a reason applies. */
+            reason?: string | null;
+            status: components["schemas"]["WithdrawalStatus"];
+        };
+        /** @description A withdrawal. */
+        WithdrawalResponse: {
+            /** @description Destination. */
+            address: string;
+            amount: components["schemas"]["Amount"];
+            /** @description Asset symbol. */
+            asset: string;
+            /**
+             * Format: date-time
+             * @description When it was broadcast.
+             */
+            broadcast_at?: string | null;
+            /** @description Whether the account holder may still cancel it. */
+            cancellable: boolean;
+            /**
+             * Format: date-time
+             * @description When it confirmed to the required depth.
+             */
+            completed_at?: string | null;
+            /**
+             * Format: int32
+             * @description Confirmations observed.
+             */
+            confirmations: number;
+            /**
+             * Format: date-time
+             * @description When it was requested.
+             */
+            created_at: string;
+            /** @description Explorer link, when available. */
+            explorer_url?: string | null;
+            fee: components["schemas"]["Amount"];
+            /** @description Asset the fee was charged in. */
+            fee_asset: string;
+            /** @description Transitions this withdrawal has been through. */
+            history: components["schemas"]["WithdrawalHistoryEntry"][];
+            /** @description Withdrawal id. */
+            id: string;
+            /** @description Memo, if any. */
+            memo?: string | null;
+            /** @description Network code. */
+            network: string;
+            status: components["schemas"]["WithdrawalStatus"];
+            /** @description Transaction hash, once broadcast. */
+            txid?: string | null;
+        };
+        /**
+         * @description Lifecycle of an outgoing withdrawal.
+         *
+         *
+         *
+         *     `pending_approval` waits for an operator to approve the withdrawal. `broadcast_unknown`
+         *     means the transaction may have been sent: the funds stay debited until it is resolved
+         *     against the chain.
+         * @enum {string}
+         */
+        WithdrawalStatus: "requested" | "pending_approval" | "approved" | "processing" | "broadcast" | "completed" | "rejected" | "cancelled" | "failed" | "broadcast_unknown";
+    };
+    responses: never;
+    parameters: never;
+    requestBodies: never;
+    headers: never;
+    pathItems: never;
+}
+interface operations {
+    list_api_keys: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description The account's keys, without secrets */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        data: components["schemas"]["ApiKeyResponse"][];
+                    };
+                };
+            };
+        };
+    };
+    list_balances: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Balances */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        data: components["schemas"]["BalanceResponse"][];
+                    };
+                };
+            };
+        };
+    };
+    get_balance: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /**
+                 * @description Asset symbol
+                 * @example BTC
+                 */
+                asset: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description The balance */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        data: components["schemas"]["BalanceResponse"];
+                    };
+                };
+            };
+            /** @description No such asset */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+        };
+    };
+    get_ledger: {
+        parameters: {
+            query?: {
+                /** @description Limit to one asset. */
+                asset?: string | null;
+                /** @description Opaque cursor from a previous response's `next_cursor`. Omit for the first page. */
+                cursor?: string | null;
+                /** @description Sort direction. Defaults to newest-first. */
+                direction?: components["schemas"]["SortDirection"] | null;
+                /** @description Maximum items to return. Clamped to `MAX_LIMIT`. */
+                limit?: number | null;
+            };
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Ledger entries */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        /** @description Whether another page exists. Equivalent to `next_cursor` being present. */
+                        has_more: boolean;
+                        /** @description The page of items, in the requested direction. */
+                        items: components["schemas"]["LedgerEntryResponse"][];
+                        /** @description Opaque cursor for the next page; pass it back as `cursor`. Omitted on the last page. */
+                        next_cursor?: string;
+                    };
+                };
+            };
+        };
+    };
+    list_notifications: {
+        parameters: {
+            query?: {
+                /** @description Opaque cursor from a previous response's `next_cursor`. Omit for the first page. */
+                cursor?: string | null;
+                /** @description Sort direction. Defaults to newest-first. */
+                direction?: components["schemas"]["SortDirection"] | null;
+                /** @description Maximum items to return. Clamped to `MAX_LIMIT`. */
+                limit?: number | null;
+                /** @description Return only notices that have not been read. */
+                unread_only?: boolean | null;
+            };
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Notices, newest first */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        /** @description Whether another page exists. Equivalent to `next_cursor` being present. */
+                        has_more: boolean;
+                        /** @description The page of items, in the requested direction. */
+                        items: components["schemas"]["NotificationResponse"][];
+                        /** @description Opaque cursor for the next page; pass it back as `cursor`. Omitted on the last page. */
+                        next_cursor?: string;
+                    };
+                };
+            };
+        };
+    };
+    list_sub_accounts: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Sub-accounts, oldest first */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        data: components["schemas"]["SubAccountResponse"][];
+                    };
+                };
+            };
+        };
+    };
+    list_assets: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Listed assets */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        data: components["schemas"]["AssetResponse"][];
+                    };
+                };
+            };
+        };
+    };
+    get_asset: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /**
+                 * @description Asset symbol
+                 * @example BTC
+                 */
+                symbol: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description The asset */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        data: components["schemas"]["AssetResponse"];
+                    };
+                };
+            };
+            /** @description No such asset */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+        };
+    };
+    exchange_config: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Exchange configuration */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        data: components["schemas"]["ExchangeConfigResponse"];
+                    };
+                };
+            };
+        };
+    };
+    export_deposits: {
+        parameters: {
+            query?: {
+                /** @description Start of the period, inclusive. Defaults to 30 days ago. */
+                from?: string | null;
+                /** @description End of the period, inclusive. Defaults to now. */
+                to?: string | null;
+            };
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description CSV of deposits. Columns: deposit_id, time, asset, network, amount, status, txid, output_index, confirmations */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "text/csv": string;
+                };
+            };
+        };
+    };
+    export_ledger: {
+        parameters: {
+            query?: {
+                /** @description Start of the period, inclusive. Defaults to 30 days ago. */
+                from?: string | null;
+                /** @description End of the period, inclusive. Defaults to now. */
+                to?: string | null;
+            };
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description CSV of ledger entries. Columns: entry_id, time, asset, kind, available_delta, locked_delta, pending_delta, available_after, sequence, reference */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "text/csv": string;
+                };
+            };
+        };
+    };
+    export_orders: {
+        parameters: {
+            query?: {
+                /** @description Start of the period, inclusive. Defaults to 30 days ago. */
+                from?: string | null;
+                /** @description End of the period, inclusive. Defaults to now. */
+                to?: string | null;
+            };
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description CSV of orders. Columns: order_id, client_order_id, time, market, side, type, status, price, quantity, filled_quantity, filled_quote_quantity, fee_paid */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "text/csv": string;
+                };
+            };
+            /** @description The date range is invalid or too wide */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+        };
+    };
+    export_trades: {
+        parameters: {
+            query?: {
+                /** @description Start of the period, inclusive. Defaults to 30 days ago. */
+                from?: string | null;
+                /** @description End of the period, inclusive. Defaults to now. */
+                to?: string | null;
+            };
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description CSV of executed trades. Columns: trade_id, time, market, side, role, price, quantity, quote_quantity, fee, fee_asset */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "text/csv": string;
+                };
+            };
+            /** @description The date range is invalid or too wide */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+        };
+    };
+    export_withdrawals: {
+        parameters: {
+            query?: {
+                /** @description Start of the period, inclusive. Defaults to 30 days ago. */
+                from?: string | null;
+                /** @description End of the period, inclusive. Defaults to now. */
+                to?: string | null;
+            };
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description CSV of withdrawals. Columns: withdrawal_id, time, asset, network, amount, fee, fee_asset, status, address, txid */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "text/csv": string;
+                };
+            };
+        };
+    };
+    list_fee_schedules: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Fee tiers */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        data: components["schemas"]["FeeScheduleResponse"][];
+                    };
+                };
+            };
+        };
+    };
+    list_markets: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Markets */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        data: components["schemas"]["MarketResponse"][];
+                    };
+                };
+            };
+        };
+    };
+    get_market: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /**
+                 * @description Market symbol
+                 * @example BTC/USDT
+                 */
+                symbol: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description The market */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        data: components["schemas"]["MarketResponse"];
+                    };
+                };
+            };
+            /** @description No such market */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+        };
+    };
+    get_candles: {
+        parameters: {
+            query: {
+                /** @description Latest bucket to return. */
+                end_time?: string | null;
+                /** @description Bucket width. */
+                interval: components["schemas"]["CandleInterval"];
+                /** @description Maximum buckets. Capped server-side. */
+                limit?: number | null;
+                /** @description Earliest bucket to return. */
+                start_time?: string | null;
+            };
+            header?: never;
+            path: {
+                /**
+                 * @description Market symbol
+                 * @example BTC/USDT
+                 */
+                symbol: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Candles */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        data: components["schemas"]["CandleResponse"][];
+                    };
+                };
+            };
+            /** @description No such market */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+        };
+    };
+    get_order_book: {
+        parameters: {
+            query?: {
+                /** @description Price levels per side. Capped server-side. */
+                depth?: number | null;
+            };
+            header?: never;
+            path: {
+                /**
+                 * @description Market symbol
+                 * @example BTC/USDT
+                 */
+                symbol: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Order book */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        data: components["schemas"]["OrderBookResponse"];
+                    };
+                };
+            };
+            /** @description No such market */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+        };
+    };
+    get_market_trades: {
+        parameters: {
+            query?: {
+                /** @description Opaque cursor from a previous response's `next_cursor`. Omit for the first page. */
+                cursor?: string | null;
+                /** @description Sort direction. Defaults to newest-first. */
+                direction?: components["schemas"]["SortDirection"] | null;
+                /** @description Maximum items to return. Clamped to `MAX_LIMIT`. */
+                limit?: number | null;
+            };
+            header?: never;
+            path: {
+                /**
+                 * @description Market symbol
+                 * @example BTC/USDT
+                 */
+                symbol: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Recent trades */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        /** @description Whether another page exists. Equivalent to `next_cursor` being present. */
+                        has_more: boolean;
+                        /** @description The page of items, in the requested direction. */
+                        items: components["schemas"]["PublicTradeResponse"][];
+                        /** @description Opaque cursor for the next page; pass it back as `cursor`. Omitted on the last page. */
+                        next_cursor?: string;
+                    };
+                };
+            };
+            /** @description No such market */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+        };
+    };
+    list_networks: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Networks */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        data: components["schemas"]["NetworkResponse"][];
+                    };
+                };
+            };
+        };
+    };
+    list_pools: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Liquidity pools */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        data: components["schemas"]["PoolResponse"][];
+                    };
+                };
+            };
+        };
+    };
+    get_pool: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /**
+                 * @description Market symbol
+                 * @example BTC/USDT
+                 */
+                symbol: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description The pool */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        data: components["schemas"]["PoolResponse"];
+                    };
+                };
+            };
+            /** @description No pool for that market */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+        };
+    };
+    exit_pool: {
+        parameters: {
+            query?: never;
+            header?: {
+                /** @description Makes a retry safe */
+                "Idempotency-Key"?: string | null;
+            };
+            path: {
+                /**
+                 * @description Market symbol
+                 * @example BTC/USDT
+                 */
+                symbol: string;
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["ExitPoolRequest"];
+            };
+        };
+        responses: {
+            /** @description Liquidity removed */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        data: components["schemas"]["ExitPoolResponse"];
+                    };
+                };
+            };
+            /** @description More shares than the account holds */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            /** @description No pool, or no position in it */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            /** @description The idempotency key was reused with a different body */
+            409: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+        };
+    };
+    join_pool: {
+        parameters: {
+            query?: never;
+            header?: {
+                /** @description Makes a retry safe */
+                "Idempotency-Key"?: string | null;
+            };
+            path: {
+                /**
+                 * @description Market symbol
+                 * @example BTC/USDT
+                 */
+                symbol: string;
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["JoinPoolRequest"];
+            };
+        };
+        responses: {
+            /** @description Liquidity added */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        data: components["schemas"]["JoinPoolResponse"];
+                    };
+                };
+            };
+            /** @description The amounts or the implied price were refused */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            /** @description No pool for that market */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            /** @description The idempotency key was reused with a different body */
+            409: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            /** @description Insufficient funds */
+            422: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+        };
+    };
+    server_time: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Server time */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        data: components["schemas"]["ServerTimeResponse"];
+                    };
+                };
+            };
+        };
+    };
+    list_open_orders: {
+        parameters: {
+            query?: {
+                /** @description Limit to one status. */
+                status?: components["schemas"]["OrderStatus"] | null;
+                /** @description Limit to one market. */
+                symbol?: string | null;
+            };
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Open orders */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        data: components["schemas"]["OrderResponse"][];
+                    };
+                };
+            };
+        };
+    };
+    place_order: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["PlaceOrderRequest"];
+            };
+        };
+        responses: {
+            /** @description Order accepted, with any immediate fills */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        data: components["schemas"]["PlaceOrderResponse"];
+                    };
+                };
+            };
+            /** @description The order failed validation */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            /** @description That client order id is already in use */
+            409: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            /** @description Insufficient funds, or the market is unavailable */
+            422: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            /** @description The market is saturated; retry shortly */
+            503: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+        };
+    };
+    get_order: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /** @description Order id */
+                order_id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description The order */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        data: components["schemas"]["OrderResponse"];
+                    };
+                };
+            };
+            /** @description No such order on this account */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+        };
+    };
+    cancel_order: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /** @description Order id */
+                order_id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Cancelled */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        data: components["schemas"]["OrderResponse"];
+                    };
+                };
+            };
+            /** @description No such order on this account */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            /** @description The order is no longer open */
+            409: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+        };
+    };
+    get_order_by_client_id: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /** @description Your identifier */
+                client_order_id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description The order */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        data: components["schemas"]["OrderResponse"];
+                    };
+                };
+            };
+            /** @description No such order on this account */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+        };
+    };
+    cancel_all: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["CancelAllRequest"];
+            };
+        };
+        responses: {
+            /** @description What was cancelled */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        data: components["schemas"]["CancelAllResponse"];
+                    };
+                };
+            };
+        };
+    };
+    order_history: {
+        parameters: {
+            query?: {
+                /** @description Opaque cursor from a previous response's `next_cursor`. Omit for the first page. */
+                cursor?: string | null;
+                /** @description Sort direction. Defaults to newest-first. */
+                direction?: components["schemas"]["SortDirection"] | null;
+                /** @description Maximum items to return. Clamped to `MAX_LIMIT`. */
+                limit?: number | null;
+                /** @description Limit to one status. */
+                status?: components["schemas"]["OrderStatus"] | null;
+                /** @description Limit to one market. */
+                symbol?: string | null;
+            };
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Order history */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        /** @description Whether another page exists. Equivalent to `next_cursor` being present. */
+                        has_more: boolean;
+                        /** @description The page of items, in the requested direction. */
+                        items: components["schemas"]["OrderResponse"][];
+                        /** @description Opaque cursor for the next page; pass it back as `cursor`. Omitted on the last page. */
+                        next_cursor?: string;
+                    };
+                };
+            };
+        };
+    };
+    trade_history: {
+        parameters: {
+            query?: {
+                /** @description Opaque cursor from a previous response's `next_cursor`. Omit for the first page. */
+                cursor?: string | null;
+                /** @description Sort direction. Defaults to newest-first. */
+                direction?: components["schemas"]["SortDirection"] | null;
+                /** @description Maximum items to return. Clamped to `MAX_LIMIT`. */
+                limit?: number | null;
+                /** @description Limit to one market. */
+                symbol?: string | null;
+            };
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Trade history */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        /** @description Whether another page exists. Equivalent to `next_cursor` being present. */
+                        has_more: boolean;
+                        /** @description The page of items, in the requested direction. */
+                        items: components["schemas"]["FillResponse"][];
+                        /** @description Opaque cursor for the next page; pass it back as `cursor`. Omitted on the last page. */
+                        next_cursor?: string;
+                    };
+                };
+            };
+        };
+    };
+    deposit_address: {
+        parameters: {
+            query: {
+                /**
+                 * @description Asset symbol.
+                 * @example BTC
+                 */
+                asset: string;
+                /**
+                 * @description Network code.
+                 * @example bitcoin-mainnet
+                 */
+                network: string;
+            };
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description The deposit address */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        data: components["schemas"]["DepositAddressResponse"];
+                    };
+                };
+            };
+            /** @description No such asset or network */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            /** @description Deposits are disabled for this pairing */
+            422: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+        };
+    };
+    list_deposits: {
+        parameters: {
+            query?: {
+                /** @description Limit to one asset. */
+                asset?: string | null;
+                /** @description Opaque cursor from a previous response's `next_cursor`. Omit for the first page. */
+                cursor?: string | null;
+                /** @description Sort direction. Defaults to newest-first. */
+                direction?: components["schemas"]["SortDirection"] | null;
+                /** @description Maximum items to return. Clamped to `MAX_LIMIT`. */
+                limit?: number | null;
+            };
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Deposits */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        /** @description Whether another page exists. Equivalent to `next_cursor` being present. */
+                        has_more: boolean;
+                        /** @description The page of items, in the requested direction. */
+                        items: components["schemas"]["DepositResponse"][];
+                        /** @description Opaque cursor for the next page; pass it back as `cursor`. Omitted on the last page. */
+                        next_cursor?: string;
+                    };
+                };
+            };
+        };
+    };
+    get_deposit: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /** @description Deposit id */
+                deposit_id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description The deposit */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        data: components["schemas"]["DepositResponse"];
+                    };
+                };
+            };
+            /** @description No such deposit on this account */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+        };
+    };
+    list_withdrawal_addresses: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Saved addresses */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        data: components["schemas"]["WithdrawalAddressResponse"][];
+                    };
+                };
+            };
+        };
+    };
+    list_withdrawals: {
+        parameters: {
+            query?: {
+                /** @description Limit to one asset. */
+                asset?: string | null;
+                /** @description Opaque cursor from a previous response's `next_cursor`. Omit for the first page. */
+                cursor?: string | null;
+                /** @description Sort direction. Defaults to newest-first. */
+                direction?: components["schemas"]["SortDirection"] | null;
+                /** @description Maximum items to return. Clamped to `MAX_LIMIT`. */
+                limit?: number | null;
+            };
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Withdrawals */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        /** @description Whether another page exists. Equivalent to `next_cursor` being present. */
+                        has_more: boolean;
+                        /** @description The page of items, in the requested direction. */
+                        items: components["schemas"]["WithdrawalResponse"][];
+                        /** @description Opaque cursor for the next page; pass it back as `cursor`. Omitted on the last page. */
+                        next_cursor?: string;
+                    };
+                };
+            };
+        };
+    };
+    get_withdrawal: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /** @description Withdrawal id */
+                withdrawal_id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description The withdrawal */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        data: components["schemas"]["WithdrawalResponse"];
+                    };
+                };
+            };
+            /** @description No such withdrawal on this account */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+        };
+    };
+}
+
+/**
+ * Friendly names for the generated API models (src/generated/schema.ts).
+ * Amounts are decimal strings; never convert them to `number`.
+ */
+
+type S = components["schemas"];
+type ApiKey = S["ApiKeyResponse"];
+type ApiScope = S["ApiScope"];
+type Asset = S["AssetResponse"];
+type AssetNetwork = S["AssetNetworkResponse"];
+type Balance = S["BalanceResponse"];
+type CancelAllRequest = S["CancelAllRequest"];
+type CancelAllResult = S["CancelAllResponse"];
+type Candle = S["CandleResponse"];
+type CandleInterval = S["CandleInterval"];
+type DepositAddress = S["DepositAddressResponse"];
+type Deposit = S["DepositResponse"];
+type DepositStatus = S["DepositStatus"];
+type ExchangeConfig = S["ExchangeConfigResponse"];
+type ExitPoolRequest = S["ExitPoolRequest"];
+type ExitPoolResult = S["ExitPoolResponse"];
+type FeeSchedule = S["FeeScheduleResponse"];
+type Fill = S["FillResponse"];
+type JoinPoolRequest = S["JoinPoolRequest"];
+type JoinPoolResult = S["JoinPoolResponse"];
+type LedgerEntry = S["LedgerEntryResponse"];
+type LedgerEntryKind = S["LedgerEntryKind"];
+type LiquidityRole = S["LiquidityRole"];
+type MaintenanceState = S["MaintenanceState"];
+type Market = S["MarketResponse"];
+type MarketStatus = S["MarketStatus"];
+type Network = S["NetworkResponse"];
+type Notification = S["NotificationResponse"];
+type NotificationKind = S["NotificationKind"];
+type OrderBook = S["OrderBookResponse"];
+type Order = S["OrderResponse"];
+type OrderSide = S["OrderSide"];
+type OrderStatus = S["OrderStatus"];
+type OrderType = S["OrderType"];
+type PlaceOrderRequest = S["PlaceOrderRequest"];
+type PlaceOrderResponse = S["PlaceOrderResponse"];
+type Pool = S["PoolResponse"];
+type PoolStatus = S["PoolStatus"];
+type PublicTrade = S["PublicTradeResponse"];
+type ServerTime = S["ServerTimeResponse"];
+type SortDirection = S["SortDirection"];
+type SubAccount = S["SubAccountResponse"];
+type TimeInForce = S["TimeInForce"];
+type TriggerDirection = S["TriggerDirection"];
+type WithdrawalAddress = S["WithdrawalAddressResponse"];
+type Withdrawal = S["WithdrawalResponse"];
+type WithdrawalStatus = S["WithdrawalStatus"];
+/** Query parameters of an operation, from the spec. */
+type QueryOf<Op extends keyof operations> = NonNullable<operations[Op]["parameters"]["query"]>;
+/** One page of a cursor-paginated listing. */
+interface Page<T> {
+    items: T[];
+    has_more: boolean;
+    /** Pass back as `cursor` to get the next page. Absent on the last page. */
+    next_cursor?: string;
+}
+/** Cursor paging parameters shared by every paginated listing. */
+interface CursorParams {
+    cursor?: string | null;
+    limit?: number | null;
+    direction?: SortDirection | null;
+}
+
+interface IterateOptions {
+    /** Stop after this many items in total. */
+    maxItems?: number;
+}
+/**
+ * Walks a cursor-paginated listing, yielding items one by one and fetching the next page
+ * lazily. Stops on the last page (`has_more: false` or no `next_cursor`).
+ */
+declare function paginate<T>(fetchPage: (cursor: string | undefined) => Promise<Page<T>>, startCursor?: string | null, opts?: IterateOptions): AsyncGenerator<T, void, undefined>;
+
+type Q<Op extends keyof operations> = QueryOf<Op>;
+/** Shared plumbing for the resource namespaces. */
+declare abstract class Resource {
+    protected readonly t: Transport;
+    constructor(transport: Transport);
+    protected data<T>(spec: CallSpec, opts?: RequestOptions): Promise<T>;
+    protected page<T>(spec: CallSpec, opts?: RequestOptions): Promise<Page<T>>;
+    protected text(spec: CallSpec, opts?: RequestOptions): Promise<string>;
+}
+declare class MarketsResource extends Resource {
+    /** All markets with their current ticker. */
+    list(opts?: RequestOptions): Promise<Market[]>;
+    /** One market, e.g. `"BTC/USDT"`. */
+    get(symbol: string, opts?: RequestOptions): Promise<Market>;
+    /**
+     * Order-book snapshot aggregated by price, with the realtime `sequence` it is current as of.
+     * To follow the book live, use `CexyWebSocket.orderBook()`, which applies the sync rules.
+     */
+    orderbook(symbol: string, params?: Q<"get_order_book">, opts?: RequestOptions): Promise<OrderBook>;
+    /** One page of recent public trades. */
+    trades(symbol: string, params?: Q<"get_market_trades">, opts?: RequestOptions): Promise<Page<PublicTrade>>;
+    /** Every public trade, page by page (`for await`). */
+    iterateTrades(symbol: string, params?: Q<"get_market_trades">, iter?: IterateOptions & RequestOptions): AsyncGenerator<PublicTrade, void, undefined>;
+    /** OHLCV candles. `interval` is required. */
+    candles(symbol: string, params: Q<"get_candles">, opts?: RequestOptions): Promise<Candle[]>;
+}
+declare class AssetsResource extends Resource {
+    list(opts?: RequestOptions): Promise<Asset[]>;
+    get(symbol: string, opts?: RequestOptions): Promise<Asset>;
+}
+declare class NetworksResource extends Resource {
+    list(opts?: RequestOptions): Promise<Network[]>;
+}
+declare class FeesResource extends Resource {
+    /** The fee schedules (maker/taker rates by tier). */
+    get(opts?: RequestOptions): Promise<FeeSchedule[]>;
+}
+declare class PoolsResource extends Resource {
+    list(opts?: RequestOptions): Promise<Pool[]>;
+    get(symbol: string, opts?: RequestOptions): Promise<Pool>;
+    /** Adds liquidity. Needs the `trade` scope. Amounts are decimal strings. */
+    join(symbol: string, body: JoinPoolRequest, opts?: RequestOptions): Promise<JoinPoolResult>;
+    /** Removes liquidity. Needs the `trade` scope. */
+    exit(symbol: string, body: ExitPoolRequest, opts?: RequestOptions): Promise<ExitPoolResult>;
+}
+declare class AccountResource extends Resource {
+    balances(opts?: RequestOptions): Promise<Balance[]>;
+    balance(asset: string, opts?: RequestOptions): Promise<Balance>;
+    ledger(params?: Q<"get_ledger">, opts?: RequestOptions): Promise<Page<LedgerEntry>>;
+    iterateLedger(params?: Q<"get_ledger">, iter?: IterateOptions & RequestOptions): AsyncGenerator<LedgerEntry, void, undefined>;
+    notifications(params?: Q<"list_notifications">, opts?: RequestOptions): Promise<Page<Notification>>;
+    iterateNotifications(params?: Q<"list_notifications">, iter?: IterateOptions & RequestOptions): AsyncGenerator<Notification, void, undefined>;
+    subAccounts(opts?: RequestOptions): Promise<SubAccount[]>;
+    /** Your API keys (metadata only; secrets are never returned). */
+    apiKeys(opts?: RequestOptions): Promise<ApiKey[]>;
+}
+/** CSV exports. Each method returns the CSV text. `from`/`to` are RFC 3339 date-times. */
+declare class ExportsResource extends Resource {
+    deposits(params?: Q<"export_deposits">, opts?: RequestOptions): Promise<string>;
+    ledger(params?: Q<"export_ledger">, opts?: RequestOptions): Promise<string>;
+    orders(params?: Q<"export_orders">, opts?: RequestOptions): Promise<string>;
+    trades(params?: Q<"export_trades">, opts?: RequestOptions): Promise<string>;
+    withdrawals(params?: Q<"export_withdrawals">, opts?: RequestOptions): Promise<string>;
+}
+/** Wallet reads. API keys can never withdraw or transfer; there are no such methods. */
+declare class WalletResource extends Resource {
+    deposits(params?: Q<"list_deposits">, opts?: RequestOptions): Promise<Page<Deposit>>;
+    iterateDeposits(params?: Q<"list_deposits">, iter?: IterateOptions & RequestOptions): AsyncGenerator<Deposit, void, undefined>;
+    deposit(depositId: string, opts?: RequestOptions): Promise<Deposit>;
+    withdrawals(params?: Q<"list_withdrawals">, opts?: RequestOptions): Promise<Page<Withdrawal>>;
+    iterateWithdrawals(params?: Q<"list_withdrawals">, iter?: IterateOptions & RequestOptions): AsyncGenerator<Withdrawal, void, undefined>;
+    withdrawal(withdrawalId: string, opts?: RequestOptions): Promise<Withdrawal>;
+    withdrawalAddresses(opts?: RequestOptions): Promise<WithdrawalAddress[]>;
+    /**
+     * Your deposit address for an asset on a network.
+     *
+     * **Side effect:** the first call for an asset/network CREATES the address (and it is
+     * permanent); later calls return the same address. Always send the `memo` too when the
+     * response has one, or the deposit may be unrecoverable.
+     */
+    depositAddress(params: Q<"deposit_address">, opts?: RequestOptions): Promise<DepositAddress>;
+}
+/** `placeOrder` result. `recovered` is true when the order was found by its client id after an ambiguous failure. */
+interface PlaceOrderResult extends PlaceOrderResponse {
+    /** The `client_order_id` that was sent (generated if you did not set one). */
+    client_order_id: string;
+    /**
+     * True if the POST failed ambiguously and the order was then found by `client_order_id`.
+     * In that case `fills` is empty; use `trading.trades({ symbol })` for executions.
+     */
+    recovered: boolean;
+}
+/**
+ * `cancelAll` target. `symbol` is required: a market such as `"BTC/USDT"`, or `null` to
+ * cancel in EVERY market (only when passed explicitly).
+ */
+interface CancelAllParams {
+    symbol: string | null;
+}
+declare class TradingResource extends Resource {
+    #private;
+    /** Open orders, optionally filtered by market/status. */
+    openOrders(params?: Q<"list_open_orders">, opts?: RequestOptions): Promise<Order[]>;
+    order(orderId: string, opts?: RequestOptions): Promise<Order>;
+    orderByClientId(clientOrderId: string, opts?: RequestOptions): Promise<Order>;
+    orderHistory(params?: Q<"order_history">, opts?: RequestOptions): Promise<Page<Order>>;
+    iterateOrderHistory(params?: Q<"order_history">, iter?: IterateOptions & RequestOptions): AsyncGenerator<Order, void, undefined>;
+    /** Your executions. */
+    trades(params?: Q<"trade_history">, opts?: RequestOptions): Promise<Page<Fill>>;
+    iterateTrades(params?: Q<"trade_history">, iter?: IterateOptions & RequestOptions): AsyncGenerator<Fill, void, undefined>;
+    /**
+     * Places a REAL order (needs the `trade` scope). Amounts must be decimal strings.
+     *
+     * Retry safety rests on `client_order_id` (generated as a UUID when absent): it is unique
+     * per account and the server refuses a repeat before any funds move. The server does NOT
+     * honour `Idempotency-Key` on orders (the header is sent but gives no protection). After an
+     * ambiguous failure (network error, timeout or 5xx) the SDK first looks the order up by
+     * `client_order_id` and returns it if it exists (`recovered: true`); only if it does not
+     * exist does it send the order again, with the same `client_order_id`, so a late-arriving
+     * first attempt makes the resend fail as a duplicate, which is again resolved by lookup.
+     * Throws `OrderStateUnknownError` when even the lookup fails.
+     */
+    placeOrder(order: PlaceOrderRequest, opts?: RequestOptions): Promise<PlaceOrderResult>;
+    /**
+     * Cancels one order (needs the `trade` scope). Retried on network errors and retryable
+     * responses. If a RETRY gets `INVALID_STATE` (the order is no longer open, typically because
+     * the first attempt did cancel it), the cancel is treated as done and the order is fetched
+     * and returned. `INVALID_STATE` on the first attempt is thrown (e.g. already filled).
+     */
+    cancelOrder(orderId: string, opts?: RequestOptions): Promise<Order>;
+    /**
+     * Cancels every open order in one market: `cancelAll({ symbol: "BTC/USDT" })`.
+     * To cancel across ALL markets, pass `symbol: null` explicitly: `cancelAll({ symbol: null })`.
+     * Omitting `symbol` is an error, so an account-wide cancel never happens by accident
+     * (the server itself treats `{}` as every market).
+     *
+     * The server limits cancel-all to 30 calls per minute per account. It is naturally
+     * repeatable, so it is retried after network errors; a retry reports only what that retry
+     * cancelled.
+     */
+    cancelAll(params: CancelAllParams, opts?: RequestOptions): Promise<CancelAllResult>;
+}
+
+/**
+ * Every `error.code` the API is known to return (from cexy-api-spec/errors.yaml, PROVISIONAL
+ * until the served spec includes the ErrorCode schema). New codes can appear at any time, so
+ * the type stays open: always keep a default branch when switching on it.
+ */
+type KnownErrorCode = components["schemas"]["ErrorCode"];
+type ErrorCode = KnownErrorCode | (string & {});
+/** The `error` object of the API's error envelope. */
+type ErrorBody = components["schemas"]["ErrorBody"];
+/** Base class for everything the SDK throws. */
+declare class CexyError extends Error {
+    constructor(message: string, options?: {
+        cause?: unknown;
+    });
+}
+/** Invalid client configuration, detected locally before any request is sent. */
+declare class CexyConfigError extends CexyError {
+}
+/**
+ * A JS `number` (or a malformed string) was passed where the API expects a decimal string.
+ * Thrown before sending: numbers are IEEE-754 doubles and silently corrupt amounts.
+ */
+declare class InvalidAmountError extends CexyError {
+    readonly field: string;
+    constructor(field: string, message: string);
+}
+/** The request never produced an HTTP response (DNS, TLS, connection reset, ...). */
+declare class CexyConnectionError extends CexyError {
+    readonly retryable = true;
+}
+/** The request exceeded `timeoutMs`. */
+declare class CexyTimeoutError extends CexyConnectionError {
+}
+/**
+ * `placeOrder` failed ambiguously (network error or 5xx), and looking the order up by its
+ * `client_order_id` also failed, so it is unknown whether the order exists.
+ * Check `trading.orderByClientId(clientOrderId)` before placing it again.
+ */
+declare class OrderStateUnknownError extends CexyError {
+    readonly clientOrderId: string;
+    constructor(clientOrderId: string, cause: unknown);
+}
+interface CexyApiErrorInit {
+    status: number;
+    code: ErrorCode;
+    message: string;
+    details?: Record<string, unknown> | undefined;
+    fields?: Record<string, string> | undefined;
+    requestId?: string | null | undefined;
+    retryable: boolean;
+    headers?: Headers | undefined;
+}
+/** An error response from the API (the `{"error": {...}}` envelope). Branch on `code`. */
+declare class CexyApiError extends CexyError {
+    readonly status: number;
+    readonly code: ErrorCode;
+    readonly details: Record<string, unknown>;
+    readonly fields: Record<string, string>;
+    readonly requestId: string | null;
+    readonly retryable: boolean;
+    constructor(init: CexyApiErrorInit);
+    toString(): string;
+}
+/** 401: missing or invalid credentials (`UNAUTHENTICATED`, `INVALID_CREDENTIALS`, ...). */
+declare class AuthenticationError extends CexyApiError {
+}
+/** 403: the key lacks a scope (`FORBIDDEN`), or the route is session-only (`API_KEY_NOT_ALLOWED`). */
+declare class ForbiddenError extends CexyApiError {
+}
+/** 404 */
+declare class NotFoundError extends CexyApiError {
+}
+/** 400: the request failed validation; see `fields`. */
+declare class ValidationError extends CexyApiError {
+}
+/** 409: `ALREADY_EXISTS`, `IDEMPOTENCY_KEY_CONFLICT`, `CONCURRENT_MODIFICATION`, ... */
+declare class ConflictError extends CexyApiError {
+}
+/** 422: a business rule refused the request (`INSUFFICIENT_FUNDS`, `MARKET_UNAVAILABLE`, ...). */
+declare class UnprocessableError extends CexyApiError {
+}
+/** 429: rate limited. `retryAfterMs` is how long the server asked to wait. */
+declare class RateLimitError extends CexyApiError {
+    readonly retryAfterMs: number | null;
+    constructor(init: CexyApiErrorInit, retryAfterMs: number | null);
+}
+/** 5xx */
+declare class ServerError extends CexyApiError {
+}
+/** True for codes listed in errors.yaml. */
+declare function isKnownErrorCode(code: string): code is KnownErrorCode;
+/**
+ * Builds the right error subclass for an HTTP error response.
+ * - A known code maps by HTTP status (401 -> AuthenticationError, 403 -> ForbiddenError, ...).
+ * - An unknown code maps to the base `CexyApiError` (never a crash).
+ * - A body without the envelope (a proxy error page) maps by status with code `HTTP_<status>`.
+ */
+declare function errorFromResponse(status: number, body: unknown, headers?: Headers, redact?: (text: string) => string): CexyApiError;
+
+/** A small typed event emitter that works in Node and browsers. */
+type EventMap = Record<string, unknown[]>;
+type Listener<A extends unknown[]> = (...args: A) => void;
+declare class TypedEmitter<E extends EventMap> {
+    #private;
+    /** Adds a listener; returns a function that removes it. */
+    on<K extends keyof E>(event: K, listener: Listener<E[K]>): () => void;
+    once<K extends keyof E>(event: K, listener: Listener<E[K]>): () => void;
+    off<K extends keyof E>(event: K, listener: Listener<E[K]>): void;
+    removeAllListeners(event?: keyof E): void;
+    listenerCount(event: keyof E): number;
+    /** Calls listeners synchronously. A throwing listener does not stop the others. */
+    protected emit<K extends keyof E>(event: K, ...args: E[K]): void;
+}
+
+/** Protocol version this SDK was written for. */
+declare const SUPPORTED_PROTOCOL_VERSION = 1;
+interface WelcomeFrame {
+    type: "welcome";
+    protocol_version: number;
+    /** The server's own pong cadence (30), not a client deadline. */
+    heartbeat_interval_seconds: number;
+    max_subscriptions: number;
+    connection_id: string;
+}
+interface PongFrame {
+    type: "pong";
+    id?: string | null;
+}
+interface SubscribedFrame {
+    type: "subscribed";
+    channels: string[];
+    id?: string | null;
+}
+interface AuthenticatedFrame {
+    type: "authenticated";
+    id?: string | null;
+    user_id?: string;
+}
+interface UnsubscribedFrame {
+    type: "unsubscribed";
+    channels?: string[];
+    id?: string | null;
+}
+interface ErrorFrame {
+    type: "error";
+    code: string;
+    message?: string;
+    id?: string | null;
+}
+/** `[price, quantity]`, both decimal strings. */
+type BookLevel = [price: string, quantity: string];
+interface OrderBookUpdateData {
+    symbol: string;
+    /**
+     * Always `true`: every update is the complete top 50 of both sides and replaces the
+     * previous state. There are no deltas.
+     */
+    full?: boolean;
+    bids: BookLevel[];
+    asks: BookLevel[];
+}
+interface SessionRevokedData {
+    session_id: string | null;
+    reason: string;
+    current: boolean;
+}
+interface EventBase<T extends string, D> {
+    type: T;
+    channel: string;
+    /** Per channel, +1 per update. Resets when the server restarts. */
+    sequence?: number;
+    timestamp?: string;
+    data: D;
+}
+type Data = Record<string, unknown>;
+type OrderBookUpdateEvent = EventBase<"orderbook.update", OrderBookUpdateData>;
+type SessionRevokedEvent = EventBase<"session.revoked", SessionRevokedData>;
+type TickerUpdateEvent = EventBase<"ticker.update", Data>;
+type TradeNewEvent = EventBase<"trade.new", Data>;
+type MarketStatusEvent = EventBase<"market.status", Data>;
+type OrderEvent = EventBase<"order.created" | "order.updated" | "order.cancelled" | "order.filled", Order>;
+type BalanceUpdatedEvent = EventBase<"balance.updated", Data>;
+type DepositEvent = EventBase<"deposit.detected" | "deposit.updated" | "deposit.completed", Data>;
+type WithdrawalUpdatedEvent = EventBase<"withdrawal.updated", Data>;
+/** Every event type the SDK knows. Unknown types are ignored (they may be added without notice). */
+type WsEvent = OrderBookUpdateEvent | SessionRevokedEvent | TickerUpdateEvent | TradeNewEvent | MarketStatusEvent | OrderEvent | BalanceUpdatedEvent | DepositEvent | WithdrawalUpdatedEvent;
+declare const KNOWN_EVENT_TYPES: ReadonlySet<string>;
+/** Channels that need `auth`. */
+declare const PRIVATE_CHANNELS: ReadonlySet<string>;
+/** Minimal WebSocket surface shared by the browser/Node 22 global and the `ws` package. */
+interface WebSocketLike {
+    readonly readyState: number;
+    send(data: string): void;
+    close(code?: number, reason?: string): void;
+    onopen: ((ev: unknown) => void) | null;
+    onmessage: ((ev: {
+        data: unknown;
+    }) => void) | null;
+    onclose: ((ev: {
+        code?: number;
+        reason?: string;
+    }) => void) | null;
+    onerror: ((ev: unknown) => void) | null;
+}
+type WebSocketConstructor = new (url: string, options?: unknown) => WebSocketLike;
+
+/** Levels the WebSocket book carries per side. REST levels deeper than this are never merged. */
+declare const WS_BOOK_DEPTH = 50;
+interface LiveOrderBookOptions {
+    /** Retry delay after a failed snapshot. Default 1000 ms (doubles up to 30 s). */
+    snapshotRetryMs?: number;
+}
+interface LiveOrderBookEvents extends Record<string, unknown[]> {
+    /** The book changed (snapshot applied or update applied). */
+    update: [LiveOrderBook];
+    /** A sequence gap: the book is stale until the next update heals it. */
+    stale: [{
+        expected: number;
+        received: number;
+    }];
+    /** The update after a gap arrived in order; the book is current again. */
+    healed: [];
+    /** A fresh REST snapshot is being taken (reconnect, CONCURRENT_MODIFICATION, first sync). */
+    resync: [];
+    error: [Error];
+}
+/**
+ * A local order book fed by `orderbook:{symbol}`. Created by `CexyWebSocket.orderBook()`.
+ * Levels are `[price, quantity]` decimal strings, best first, at most 50 per side.
+ */
+declare class LiveOrderBook extends TypedEmitter<LiveOrderBookEvents> {
+    #private;
+    readonly symbol: string;
+    bids: BookLevel[];
+    asks: BookLevel[];
+    /** Sequence of the last applied snapshot/update on the current connection. */
+    sequence: number | null;
+    /** True after a sequence gap, until the next in-order update. */
+    stale: boolean;
+    /** False while waiting for a snapshot (after connect, reconnect or resync). */
+    synced: boolean;
+    /** @internal use `CexyWebSocket.orderBook()` */
+    constructor(symbol: string, rest: SnapshotSource, options: LiveOrderBookOptions, onClose: () => void);
+    /** Best bid and ask (null when that side is empty). */
+    get top(): {
+        bid: BookLevel | null;
+        ask: BookLevel | null;
+    };
+    /** @internal The connection dropped: sequences from the next connection are unrelated. */
+    markDisconnected(): void;
+    /**
+     * Takes a fresh REST snapshot and replays buffered updates newer than it.
+     * Called automatically; safe to call yourself.
+     */
+    resync(attempt?: number): Promise<void>;
+    /** @internal */
+    onUpdate(event: OrderBookUpdateEvent): void;
+    /** Stops following the book and unsubscribes. */
+    close(): void;
+}
+
+declare const DEFAULT_WS_URL = "wss://api.cexy.io/api/v1/ws";
+/** A WebSocket protocol error, a server error frame, or a local guard. */
+declare class CexyWebSocketError extends CexyError {
+    readonly code: string;
+    /** True when this came from a server `error` frame (not a local guard or disconnect). */
+    readonly fromServer: boolean;
+    constructor(code: string, message: string, fromServer?: boolean);
+}
+/** Where order-book snapshots come from (a `CexyClient` fits). */
+interface SnapshotSource {
+    markets: {
+        orderbook(symbol: string, params?: {
+            depth?: number | null;
+        }): Promise<OrderBook>;
+    };
+}
+interface WsLogger {
+    warn(message: string): void;
+    debug?(message: string): void;
+}
+interface ReconnectOptions {
+    /** Default 1000 ms. */
+    baseDelayMs?: number;
+    /** Default 30000 ms. */
+    maxDelayMs?: number;
+    /** Default: unlimited. */
+    maxAttempts?: number;
+}
+interface CexyWebSocketOptions {
+    /** Default `wss://api.cexy.io/api/v1/ws`. Must be `wss://` (see `allowInsecure`). */
+    url?: string;
+    /** Allow `ws://`, but ONLY for `localhost`, `127.0.0.1` or `::1` (local test servers). Default false. */
+    allowInsecure?: boolean;
+    /**
+     * WebSocket implementation. Default: in Node the optional `ws` package if installed
+     * (so a User-Agent can be sent), else the global `WebSocket` (browsers, Node 22+).
+     */
+    WebSocket?: WebSocketConstructor;
+    /** REST client used for order-book snapshots (`CexyClient.websocket()` sets it). */
+    restClient?: SnapshotSource;
+    /** Client ping cadence. Required by the server; default 30000 ms. */
+    pingIntervalMs?: number;
+    /** Reconnect if no frame arrives for this long. Default 75000 ms. */
+    livenessTimeoutMs?: number;
+    /** Default 10000 ms. */
+    welcomeTimeoutMs?: number;
+    /** How long `subscribe()` waits for `subscribed`. Default 5000 ms. */
+    ackTimeoutMs?: number;
+    /** Automatic reconnect (default on). */
+    reconnect?: boolean | ReconnectOptions;
+    /** Local subscription cap. Default 100 (the server's limit). */
+    maxSubscriptions?: number;
+    /** Local message cap per fixed minute. Default 200 (server closes above 240). */
+    maxMessagesPerMinute?: number;
+    /** Sent as User-Agent when the implementation allows headers (the `ws` package). */
+    userAgent?: string;
+    logger?: WsLogger;
+    /** @internal deterministic jitter in tests */
+    random?: () => number;
+}
+interface SubscribeResult {
+    /** Channels the server confirmed as newly added. */
+    added: string[];
+    /** Channels refused locally because the subscription cap was reached. */
+    refused: string[];
+    /** Channels already held (nothing sent for them). */
+    alreadySubscribed: string[];
+}
+interface CloseInfo {
+    code: number | undefined;
+    reason: string | undefined;
+    willReconnect: boolean;
+}
+type ResyncReason = "concurrent_modification" | "reconnect";
+interface CexyWebSocketEvents extends Record<string, unknown[]> {
+    open: [];
+    welcome: [WelcomeFrame];
+    /** Every known event (`ticker.update`, `orderbook.update`, `order.*`, ...). */
+    event: [WsEvent];
+    subscribed: [string[]];
+    /** `unsubscribed` acknowledgement. */
+    unsubscribed: [string[]];
+    /** `authenticated` acknowledgement (after `auth()` or the automatic re-auth on reconnect). */
+    authenticated: [userId: string | null];
+    pong: [id: string | null];
+    /** An `error` frame from the server. */
+    serverError: [CexyWebSocketError, ErrorFrame];
+    /** Transport problems and failed resyncs. */
+    error: [Error];
+    close: [CloseInfo];
+    reconnecting: [{
+        attempt: number;
+        delayMs: number;
+    }];
+    /** Reconnected, re-authenticated (if a token was held) and re-subscribed. */
+    reconnected: [WelcomeFrame];
+    /** State may have been missed: refetch anything you keep from private or public channels. */
+    resync: [ResyncReason];
+    /**
+     * `session.revoked` arrived: private channels are dead. The socket stays open; public
+     * channels keep working. Call `auth()` with a new token to restore private channels.
+     */
+    authLost: [SessionRevokedEvent];
+}
+/** Result of `auth()`. */
+interface AuthResult {
+    /** From the `authenticated` acknowledgement; null when queued. */
+    userId: string | null;
+    /** True when not connected: the token is kept and sent (and acknowledged) on connect. */
+    queued: boolean;
+}
+/**
+ * CEXY.io WebSocket client: heartbeat, liveness, subscriptions with local limits, automatic
+ * reconnect with re-auth and re-subscribe, and live order books.
+ *
+ * API-key authentication on the WebSocket is not available yet: `auth()` takes a session
+ * access token. Programs holding only an API key get public channels and poll REST for
+ * private state.
+ */
+declare class CexyWebSocket extends TypedEmitter<CexyWebSocketEvents> {
+    #private;
+    readonly url: string;
+    constructor(options?: CexyWebSocketOptions);
+    /** The last `welcome` frame, or null before the first connection. */
+    get welcome(): WelcomeFrame | null;
+    get connected(): boolean;
+    /** Channels currently held (restored after every reconnect). */
+    get channels(): string[];
+    /** Opens the connection; resolves on the server's `welcome` frame. */
+    connect(): Promise<WelcomeFrame>;
+    /**
+     * Authenticates private channels with a session access token. Resolves on the server's
+     * `authenticated` acknowledgement (same request id); rejects on an `error` with that id
+     * (the token is then forgotten) or when no acknowledgement arrives within `ackTimeoutMs`.
+     * The token is kept in memory and re-sent after each reconnect. When not connected, the
+     * token is queued and the promise resolves with `queued: true`.
+     * (API-key authentication is not available on the WebSocket yet.)
+     */
+    auth(token: string): Promise<AuthResult>;
+    /** Sends a ping with an id and resolves with the round-trip time in ms. */
+    ping(): Promise<number>;
+    /**
+     * Subscribes to channels, e.g. `["ticker:BTC/USDT", "trades:BTC/USDT"]`. Resolves when the
+     * server confirms. Beyond `maxSubscriptions` channels are refused locally (see `refused`).
+     */
+    subscribe(channels: string[]): Promise<SubscribeResult>;
+    /**
+     * Unsubscribes. Resolves on the `unsubscribed` acknowledgement (or after `ackTimeoutMs`
+     * without one); rejects on an `error` with the request id.
+     */
+    unsubscribe(channels: string[]): Promise<void>;
+    /**
+     * A live order book for `symbol` that follows the sync rules: subscribe first, then a REST
+     * snapshot (sequence S); drop updates with sequence <= S; each update replaces the top 50
+     * levels; a gap marks the book stale until the next update; a fresh snapshot after every
+     * reconnect and after `CONCURRENT_MODIFICATION`. Resolves after the first snapshot.
+     */
+    orderBook(symbol: string, options?: LiveOrderBookOptions): Promise<LiveOrderBook>;
+    /** Closes the connection for good (no reconnect). */
+    close(): void;
+}
+
+declare const DEFAULT_BASE_URL = "https://api.cexy.io";
+/** Default client-side limit without credentials (server: about 120/min per IP). */
+declare const DEFAULT_RPM_ANONYMOUS = 100;
+/** Default client-side limit with an API key (server: about 600/min per key). */
+declare const DEFAULT_RPM_WITH_KEY = 300;
+interface CexyClientOptions {
+    /** API key id (`ak_…`). Must be given together with `apiSecret`, or not at all. */
+    apiKey?: string;
+    /** API key secret. Never logged, never put in a URL. */
+    apiSecret?: string;
+    /**
+     * Custom credentials scheme (for example HMAC signing once the API supports it).
+     * Mutually exclusive with `apiKey`/`apiSecret`.
+     */
+    authenticator?: Authenticator;
+    /** Default `https://api.cexy.io`. Must be `https://` (see `allowInsecure`). */
+    baseUrl?: string;
+    /**
+     * Allow plain `http://` (and `ws://` for `websocket()`), but ONLY for a local host
+     * (`localhost`, `127.0.0.1`, `::1`), e.g. a local mock server in tests. Default false.
+     */
+    allowInsecure?: boolean;
+    /** Per-attempt timeout. Default 10000 ms. */
+    timeoutMs?: number;
+    /** Retries after the first attempt for retryable failures. Default 3. */
+    maxRetries?: number;
+    /** A `fetch` implementation. Default: the global `fetch` (Node 20+, browsers). */
+    fetch?: FetchLike;
+    /**
+     * Client-side rate limit in requests per minute, or `false` to disable. Default 100/min
+     * without credentials (the server allows about 120/min per IP for anonymous calls) and
+     * 300/min with an API key (the server allows about 600/min per key). It adapts downwards
+     * to the server's `X-RateLimit-Limit`/`-Remaining`/`-Reset` headers.
+     */
+    rateLimit?: {
+        requestsPerMinute: number;
+    } | false;
+    /**
+     * Appended to the User-Agent, e.g. `"my-bot/1.2"` gives `cexy-typescript/0.1.0 my-bot/1.2`.
+     * Browsers do not let scripts set User-Agent; there it is not sent.
+     */
+    userAgentSuffix?: string;
+    /** Called before each retry (for logging/metrics). Never receives credentials. */
+    onRetry?: (info: RetryInfo) => void;
+    /** @internal Replace timers in tests. */
+    sleep?: (ms: number, signal?: AbortSignal) => Promise<void>;
+    /** @internal Deterministic jitter in tests. */
+    random?: () => number;
+}
+/**
+ * CEXY.io REST client.
+ *
+ * ```ts
+ * const cexy = new CexyClient();                        // public data only
+ * const me = new CexyClient({ apiKey, apiSecret });     // + account, wallet reads, trading
+ * ```
+ */
+declare class CexyClient {
+    #private;
+    readonly markets: MarketsResource;
+    readonly assets: AssetsResource;
+    readonly networks: NetworksResource;
+    readonly fees: FeesResource;
+    readonly pools: PoolsResource;
+    readonly account: AccountResource;
+    readonly exports: ExportsResource;
+    readonly wallet: WalletResource;
+    readonly trading: TradingResource;
+    constructor(options?: CexyClientOptions);
+    /** True if the client holds credentials (private endpoints are available). */
+    get hasCredentials(): boolean;
+    get baseUrl(): string;
+    /** Current client-side rate limit state, or null when disabled. */
+    get rateLimit(): {
+        requestsPerMinute: number;
+        tokens: number;
+        blockedUntil: number;
+    } | null;
+    /** The User-Agent this client sends (null in browsers). */
+    get userAgent(): string | null;
+    /** Server clock. Compare it with yours to detect skew. */
+    time(opts?: RequestOptions): Promise<ServerTime>;
+    /** Public exchange configuration (maintenance state, page sizes, WebSocket path, ...). */
+    config(opts?: RequestOptions): Promise<ExchangeConfig>;
+    /**
+     * A WebSocket client for the same deployment, wired to this client for order-book
+     * snapshots. Call `connect()` on it.
+     */
+    websocket(options?: Omit<CexyWebSocketOptions, "restClient">): CexyWebSocket;
+    toString(): string;
+    toJSON(): Record<string, unknown>;
+}
+
+/**
+ * An exact decimal amount as a string, e.g. `"0.00150000"`. The API never uses JSON numbers
+ * for money. Do arithmetic with a decimal library (decimal.js, big.js, ...), never with `number`.
+ */
+type Amount = string;
+/** True if `value` is a well-formed decimal string (`"1"`, `"0.5"`, `"-2.25"`). */
+declare function isAmount(value: unknown): value is Amount;
+/**
+ * Throws `InvalidAmountError` if an amount field holds a number, bigint or malformed string.
+ * `null`/`undefined` are allowed (optional fields). Called before any request is sent.
+ */
+declare function assertAmountFields(body: Record<string, unknown>, fields: readonly string[], context: string): void;
+
+/** SDK version, kept in sync with package.json (a test enforces this). */
+declare const VERSION = "0.1.0-dev.0";
+/** Default User-Agent product token. */
+declare const USER_AGENT = "cexy-typescript/0.1.0-dev.0";
+
+/** True for loopback hosts, the only ones where plain-text transport may be allowed. */
+declare function isLocalHost(hostname: string): boolean;
+
+export { AccountResource, type Amount, type ApiKey, ApiKeyAuthenticator, type ApiScope, type Asset, type AssetNetwork, AssetsResource, type AuthRequest, type AuthResult, type AuthenticatedFrame, AuthenticationError, type Authenticator, type Balance, type BalanceUpdatedEvent, type BookLevel, type CancelAllParams, type CancelAllRequest, type CancelAllResult, type Candle, type CandleInterval, CexyApiError, type CexyApiErrorInit, CexyClient, type CexyClientOptions, CexyConfigError, CexyConnectionError, CexyError, CexyTimeoutError, CexyWebSocket, CexyWebSocketError, type CexyWebSocketEvents, type CexyWebSocketOptions, type CloseInfo, ConflictError, type CursorParams, DEFAULT_BASE_URL, DEFAULT_RPM_ANONYMOUS, DEFAULT_RPM_WITH_KEY, DEFAULT_WS_URL, type Deposit, type DepositAddress, type DepositEvent, type DepositStatus, type ErrorBody, type ErrorCode, type ErrorFrame, type EventMap, type ExchangeConfig, type ExitPoolRequest, type ExitPoolResult, ExportsResource, type FeeSchedule, FeesResource, type FetchLike, type Fill, ForbiddenError, InvalidAmountError, type IterateOptions, type JoinPoolRequest, type JoinPoolResult, KNOWN_EVENT_TYPES, type KnownErrorCode, type LedgerEntry, type LedgerEntryKind, type LiquidityRole, type Listener, LiveOrderBook, type LiveOrderBookEvents, type LiveOrderBookOptions, type MaintenanceState, type Market, type MarketStatus, type MarketStatusEvent, MarketsResource, type Network, NetworksResource, NotFoundError, type Notification, type NotificationKind, OPERATIONS, type OperationAuth, type OperationId, type OperationInfo, type OperationScope, type Order, type OrderBook, type OrderBookUpdateData, type OrderBookUpdateEvent, type OrderEvent, type OrderSide, OrderStateUnknownError, type OrderStatus, type OrderType, PRIVATE_CHANNELS, type Page, type PlaceOrderRequest, type PlaceOrderResponse, type PlaceOrderResult, type PongFrame, type Pool, type PoolStatus, PoolsResource, type PublicTrade, type QueryOf, RateLimitError, RateLimiter, type RateLimiterOptions, type RateLimiterState, type ReconnectOptions, type RequestOptions, type ResyncReason, type RetryInfo, SUPPORTED_PROTOCOL_VERSION, ServerError, type ServerTime, type SessionRevokedData, type SessionRevokedEvent, type SnapshotSource, type SortDirection, type SubAccount, type SubscribeResult, type SubscribedFrame, type TickerUpdateEvent, type TimeInForce, type TradeNewEvent, TradingResource, type TriggerDirection, TypedEmitter, USER_AGENT, UnprocessableError, type UnsubscribedFrame, VERSION, ValidationError, WS_BOOK_DEPTH, WalletResource, type WebSocketConstructor, type WebSocketLike, type WelcomeFrame, type Withdrawal, type WithdrawalAddress, type WithdrawalStatus, type WithdrawalUpdatedEvent, type WsEvent, type WsLogger, assertAmountFields, type components, errorFromResponse, isAmount, isKnownErrorCode, isLocalHost, isRetryable, type operations, paginate, type paths };