maxt-bindings-common 0.2.1

//! Official API coverage used by code generation and documentation.

use maxt::Exchange;

/// Date of the official documentation snapshot represented by this catalog.
pub const BASELINE_DATE: &str = "2026-08-10";

/// Network interface that carries an operation.
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
pub enum ApiInterface {
    /// HTTP request and response.
    Http,
    /// Request and response messages over WebSocket.
    WebSocketRequest,
    /// Subscription feed over WebSocket.
    WebSocketStream,
    /// FIX session protocol.
    Fix,
    /// JSON-RPC.
    JsonRpc,
    /// On-chain contract call.
    Contract,
}

impl ApiInterface {
    /// Stable documentation identifier.
    pub const fn id(self) -> &'static str {
        match self {
            Self::Http => "http",
            Self::WebSocketRequest => "websocket_request",
            Self::WebSocketStream => "websocket_stream",
            Self::Fix => "fix",
            Self::JsonRpc => "json_rpc",
            Self::Contract => "contract",
        }
    }
}

/// Payload encoding, kept separate from the network interface.
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
pub enum Encoding {
    /// JSON text.
    Json,
    /// Simple Binary Encoding.
    Sbe,
    /// FIX tag-value messages.
    FixTagValue,
    /// FIX messages encoded with SBE.
    FixSbe,
    /// Provider-specific binary payload.
    Binary,
}

impl Encoding {
    /// Stable documentation identifier.
    pub const fn id(self) -> &'static str {
        match self {
            Self::Json => "json",
            Self::Sbe => "sbe",
            Self::FixTagValue => "fix_tag_value",
            Self::FixSbe => "fix_sbe",
            Self::Binary => "binary",
        }
    }
}

/// Authentication required by one operation.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Authentication {
    /// No secret is required.
    Public,
    /// API key header without a request signature.
    ApiKey,
    /// HMAC-signed request.
    Hmac,
    /// JWT-signed request.
    Jwt,
    /// RSA-signed request.
    Rsa,
    /// Ed25519-signed request.
    Ed25519,
    /// EIP-712 user signature.
    Eip712,
    /// OAuth access token.
    OAuth,
    /// Contracted partner credentials.
    Partner,
}

/// Side-effect risk of one operation.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum OperationRisk {
    /// Read-only.
    Read,
    /// Reversible account configuration change.
    AccountWrite,
    /// Order, transfer, loan, subscription, or other financial write.
    FinancialWrite,
    /// Credential, KYC, deployer, or partner administration.
    AdministrativeWrite,
}

/// How an official operation is exposed publicly by maxt.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum OperationMapping {
    /// Common [`maxt::Client`] operation.
    Common(&'static str),
    /// One provider operation supplies several common [`maxt::Client`] operations.
    CommonMany(&'static [&'static str]),
    /// Exchange-specific typed service operation.
    Provider(&'static str),
    /// One provider operation supplies common and exchange-specific APIs.
    CommonAndProvider {
        /// Common [`maxt::Client`] operations.
        common: &'static [&'static str],
        /// Exchange-specific typed service operations.
        provider: &'static [&'static str],
    },
    /// Typed service operation unavailable on one platform.
    PlatformLimited {
        /// Service method.
        service: &'static str,
        /// Unsupported platform.
        platform: &'static str,
    },
}

/// Current implementation state.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Implementation {
    /// Catalogued but not implemented.
    Planned,
    /// The operation exists, but does not yet cover its full official contract.
    Partial,
    /// Implemented in the Rust core.
    Implemented,
}

/// Strongest verification completed for an operation.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Validation {
    /// Official contract recorded only.
    Documented,
    /// Request and response fixture verified.
    Fixture,
    /// Official testnet verified.
    Testnet,
    /// Real read-only request verified.
    LiveRead,
    /// Real write request verified.
    LiveWrite,
}

/// Availability restriction published by the provider.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Availability {
    /// Generally available to eligible exchange users.
    General,
    /// Limited to one named region.
    Region(&'static str),
    /// Limited to approved partners or account tiers.
    Partner,
    /// Requires a named account, jurisdiction, or product eligibility condition.
    Eligibility(&'static str),
    /// Officially marked beta.
    Beta,
    /// Testnet only.
    Testnet,
}

/// One product in an exchange's official API catalog.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct ProductCoverage {
    /// Owning exchange.
    pub exchange: Exchange,
    /// Stable exchange-local identifier.
    pub id: &'static str,
    /// Official product name.
    pub name: &'static str,
    /// Endpoint count published by the official catalog, when available.
    pub endpoint_count: Option<u16>,
    /// Official network interfaces.
    pub interfaces: &'static [ApiInterface],
    /// Official payload encodings.
    pub encodings: &'static [Encoding],
}

impl ProductCoverage {
    /// Number of operations currently recorded for this product.
    pub fn mapped_operations(self) -> usize {
        OPERATIONS
            .iter()
            .filter(|operation| operation.exchange == self.exchange && operation.product == self.id)
            .count()
    }

    /// Number of recorded operations whose full official contract is implemented.
    pub fn implemented_operations(self) -> usize {
        OPERATIONS
            .iter()
            .filter(|operation| {
                operation.exchange == self.exchange
                    && operation.product == self.id
                    && operation.implementation == Implementation::Implemented
            })
            .count()
    }

    /// Number of recorded operations with a partial Rust implementation.
    pub fn partial_operations(self) -> usize {
        OPERATIONS
            .iter()
            .filter(|operation| {
                operation.exchange == self.exchange
                    && operation.product == self.id
                    && operation.implementation == Implementation::Partial
            })
            .count()
    }

    /// Product status derived from operation records rather than edited by hand.
    pub fn stage(self) -> CoverageStage {
        let mapped = self.mapped_operations();
        if self.implemented_operations() + self.partial_operations() == 0 {
            return CoverageStage::Planned;
        }
        if self.endpoint_count == u16::try_from(mapped).ok()
            && self.implemented_operations() == mapped
        {
            CoverageStage::Complete
        } else {
            CoverageStage::Partial
        }
    }
}

/// Derived product implementation state.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum CoverageStage {
    /// No operation is implemented yet.
    Planned,
    /// At least one operation is mapped, but the official product is incomplete.
    Partial,
    /// Every active endpoint in the pinned official count is implemented.
    Complete,
}

impl CoverageStage {
    /// Human-readable documentation label.
    pub const fn label(self) -> &'static str {
        match self {
            Self::Planned => "Planned",
            Self::Partial => "Partial",
            Self::Complete => "Complete",
        }
    }
}

/// One official endpoint, request message, stream, or protocol operation.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct OperationCoverage {
    /// Owning exchange.
    pub exchange: Exchange,
    /// Product identifier from [`PRODUCTS`].
    pub product: &'static str,
    /// Stable operation identifier.
    pub id: &'static str,
    /// HTTP verb or protocol action.
    pub method: &'static str,
    /// Official path, stream, or message name.
    pub path: &'static str,
    /// Network interface.
    pub interface: ApiInterface,
    /// Payload encoding.
    pub encoding: Encoding,
    /// Authentication mode.
    pub authentication: Authentication,
    /// Side-effect risk.
    pub risk: OperationRisk,
    /// Public maxt mapping.
    pub mapping: OperationMapping,
    /// Current implementation state.
    pub implementation: Implementation,
    /// Strongest completed verification.
    pub validation: Validation,
    /// Account, region, or rollout restriction.
    pub availability: Availability,
}

const HTTP: &[ApiInterface] = &[ApiInterface::Http];
const HTTP_STREAM: &[ApiInterface] = &[ApiInterface::Http, ApiInterface::WebSocketStream];
const HTTP_WS_STREAM: &[ApiInterface] = &[
    ApiInterface::Http,
    ApiInterface::WebSocketRequest,
    ApiInterface::WebSocketStream,
];
const SPOT_INTERFACES: &[ApiInterface] = &[
    ApiInterface::Http,
    ApiInterface::WebSocketRequest,
    ApiInterface::WebSocketStream,
    ApiInterface::Fix,
];
const HYPERLIQUID_REQUEST: &[ApiInterface] = &[ApiInterface::Http, ApiInterface::WebSocketRequest];
const HYPERLIQUID_HIP3: &[ApiInterface] = &[
    ApiInterface::Http,
    ApiInterface::WebSocketRequest,
    ApiInterface::WebSocketStream,
    ApiInterface::Contract,
];
const JSON: &[Encoding] = &[Encoding::Json];
const JSON_BINARY: &[Encoding] = &[Encoding::Json, Encoding::Binary];
const BINANCE_SPOT_ENCODINGS: &[Encoding] = &[
    Encoding::Json,
    Encoding::Sbe,
    Encoding::FixTagValue,
    Encoding::FixSbe,
];

const fn product(
    exchange: Exchange,
    id: &'static str,
    name: &'static str,
    endpoint_count: Option<u16>,
    interfaces: &'static [ApiInterface],
    encodings: &'static [Encoding],
) -> ProductCoverage {
    ProductCoverage {
        exchange,
        id,
        name,
        endpoint_count,
        interfaces,
        encodings,
    }
}

/// Products listed by official documentation at [`BASELINE_DATE`].
pub const PRODUCTS: &[ProductCoverage] = &[
    product(
        Exchange::Upbit,
        "quotation",
        "Quotation",
        Some(17),
        HTTP_WS_STREAM,
        JSON,
    ),
    product(
        Exchange::Upbit,
        "exchange",
        "Exchange",
        Some(14),
        HTTP_STREAM,
        JSON,
    ),
    product(
        Exchange::Upbit,
        "wallet",
        "Deposits and withdrawals",
        Some(13),
        HTTP,
        JSON,
    ),
    product(
        Exchange::Upbit,
        "travel_rule",
        "Travel Rule",
        Some(3),
        HTTP,
        JSON,
    ),
    product(
        Exchange::Upbit,
        "pockets",
        "Korea pockets",
        None,
        HTTP,
        JSON,
    ),
    product(
        Exchange::Bithumb,
        "quotation",
        "Quotation",
        Some(14),
        HTTP_STREAM,
        JSON,
    ),
    product(
        Exchange::Bithumb,
        "exchange",
        "Exchange",
        Some(13),
        HTTP_STREAM,
        JSON,
    ),
    product(
        Exchange::Bithumb,
        "wallet",
        "Deposits and withdrawals",
        Some(13),
        HTTP,
        JSON,
    ),
    product(Exchange::Bithumb, "twap", "TWAP", Some(3), HTTP, JSON),
    product(
        Exchange::Bithumb,
        "krw",
        "KRW deposits and withdrawals",
        Some(4),
        HTTP,
        JSON,
    ),
    product(
        Exchange::Binance,
        "spot",
        "Spot Trading",
        Some(118),
        SPOT_INTERFACES,
        BINANCE_SPOT_ENCODINGS,
    ),
    product(
        Exchange::Binance,
        "usd_m",
        "Futures (USDⓈ-M)",
        Some(133),
        HTTP_WS_STREAM,
        JSON,
    ),
    product(
        Exchange::Binance,
        "coin_m",
        "Futures (COIN-M)",
        Some(93),
        HTTP_WS_STREAM,
        JSON,
    ),
    product(
        Exchange::Binance,
        "options",
        "Options",
        Some(54),
        HTTP_STREAM,
        JSON,
    ),
    product(Exchange::Binance, "margin", "Margin", Some(65), HTTP, JSON),
    product(Exchange::Binance, "wallet", "Wallet", Some(50), HTTP, JSON),
    product(Exchange::Binance, "convert", "Convert", Some(9), HTTP, JSON),
    product(
        Exchange::Binance,
        "portfolio_margin",
        "Portfolio Margin",
        Some(109),
        HTTP,
        JSON,
    ),
    product(
        Exchange::Binance,
        "portfolio_margin_pro",
        "Portfolio Margin Pro",
        Some(24),
        HTTP,
        JSON,
    ),
    product(
        Exchange::Binance,
        "algo",
        "Algo Trading",
        Some(11),
        HTTP,
        JSON,
    ),
    product(
        Exchange::Binance,
        "copy_trading",
        "Copy Trading",
        Some(2),
        HTTP,
        JSON,
    ),
    product(
        Exchange::Binance,
        "institutional_loan",
        "Institutional Loan",
        Some(16),
        HTTP,
        JSON,
    ),
    product(
        Exchange::Binance,
        "alpha",
        "Alpha Trading",
        Some(19),
        HTTP_STREAM,
        JSON,
    ),
    product(
        Exchange::Binance,
        "stocks",
        "Stocks Trading",
        Some(23),
        HTTP_STREAM,
        JSON,
    ),
    product(
        Exchange::Binance,
        "sub_account",
        "Sub Account",
        Some(49),
        HTTP,
        JSON,
    ),
    product(
        Exchange::Binance,
        "spot_block_matching",
        "Spot Block Matching",
        Some(7),
        HTTP,
        JSON,
    ),
    product(
        Exchange::Binance,
        "vip_service",
        "VIP Service",
        Some(11),
        HTTP,
        JSON,
    ),
    product(
        Exchange::Binance,
        "caas",
        "Crypto-as-a-Service (CAAS)",
        Some(10),
        HTTP,
        JSON,
    ),
    product(
        Exchange::Binance,
        "fund_account",
        "Fund Account",
        Some(4),
        HTTP,
        JSON,
    ),
    product(
        Exchange::Binance,
        "link_plus",
        "Link Plus",
        Some(8),
        HTTP,
        JSON,
    ),
    product(
        Exchange::Binance,
        "exchange_link",
        "Exchange Link",
        Some(35),
        HTTP,
        JSON,
    ),
    product(
        Exchange::Binance,
        "kyc_saas",
        "KYC SaaS",
        Some(12),
        HTTP,
        JSON,
    ),
    product(
        Exchange::Binance,
        "link_and_trade",
        "Link and Trade",
        Some(23),
        HTTP,
        JSON,
    ),
    product(
        Exchange::Binance,
        "staking",
        "Staking",
        Some(37),
        HTTP,
        JSON,
    ),
    product(Exchange::Binance, "mining", "Mining", Some(13), HTTP, JSON),
    product(
        Exchange::Binance,
        "crypto_loan",
        "Crypto Loan",
        Some(16),
        HTTP,
        JSON,
    ),
    product(
        Exchange::Binance,
        "vip_loan",
        "VIP Loan",
        Some(14),
        HTTP,
        JSON,
    ),
    product(Exchange::Binance, "c2c", "C2C", Some(1), HTTP, JSON),
    product(Exchange::Binance, "fiat", "Fiat", Some(5), HTTP, JSON),
    product(
        Exchange::Binance,
        "gift_card",
        "Gift Card",
        Some(6),
        HTTP,
        JSON,
    ),
    product(Exchange::Binance, "rebate", "Rebate", Some(1), HTTP, JSON),
    product(
        Exchange::Binance,
        "simple_earn",
        "Simple Earn",
        Some(41),
        HTTP,
        JSON,
    ),
    product(
        Exchange::Binance,
        "discount_buy",
        "Discount Buy",
        Some(4),
        HTTP,
        JSON,
    ),
    product(
        Exchange::Binance,
        "dual_investment",
        "Dual Investment",
        Some(5),
        HTTP,
        JSON,
    ),
    product(Exchange::Binance, "pay", "Pay", Some(1), HTTP, JSON),
    product(
        Exchange::Binance,
        "prediction",
        "Prediction Trading",
        Some(26),
        HTTP,
        JSON,
    ),
    product(
        Exchange::Hyperliquid,
        "info",
        "Info",
        None,
        HYPERLIQUID_REQUEST,
        JSON,
    ),
    product(
        Exchange::Hyperliquid,
        "exchange",
        "Exchange",
        None,
        HYPERLIQUID_REQUEST,
        JSON,
    ),
    product(
        Exchange::Hyperliquid,
        "subscriptions",
        "WebSocket subscriptions",
        None,
        &[ApiInterface::WebSocketStream],
        JSON_BINARY,
    ),
    product(
        Exchange::Hyperliquid,
        "hip3",
        "HIP-3 DEX",
        None,
        HYPERLIQUID_HIP3,
        JSON,
    ),
    product(
        Exchange::Hyperliquid,
        "vaults",
        "Subaccounts and vaults",
        None,
        HTTP_STREAM,
        JSON,
    ),
    product(
        Exchange::Hyperliquid,
        "staking",
        "Staking",
        None,
        HYPERLIQUID_REQUEST,
        JSON,
    ),
    product(
        Exchange::Hyperliquid,
        "outcomes",
        "Outcome markets",
        None,
        HYPERLIQUID_HIP3,
        JSON,
    ),
    product(
        Exchange::Hyperliquid,
        "deployers",
        "Deployer actions",
        None,
        HYPERLIQUID_HIP3,
        JSON,
    ),
    product(
        Exchange::Hyperliquid,
        "hyperevm",
        "HyperEVM",
        None,
        &[ApiInterface::JsonRpc, ApiInterface::Contract],
        JSON,
    ),
];

#[allow(clippy::too_many_arguments)]
const fn operation(
    exchange: Exchange,
    product: &'static str,
    id: &'static str,
    method: &'static str,
    path: &'static str,
    interface: ApiInterface,
    authentication: Authentication,
    risk: OperationRisk,
    mapping: OperationMapping,
    validation: Validation,
) -> OperationCoverage {
    OperationCoverage {
        exchange,
        product,
        id,
        method,
        path,
        interface,
        encoding: Encoding::Json,
        authentication,
        risk,
        mapping,
        implementation: Implementation::Implemented,
        validation,
        availability: Availability::General,
    }
}

const fn partial(mut operation: OperationCoverage) -> OperationCoverage {
    operation.implementation = Implementation::Partial;
    operation
}

const fn planned(mut operation: OperationCoverage) -> OperationCoverage {
    operation.implementation = Implementation::Planned;
    operation
}

const fn restricted(
    mut operation: OperationCoverage,
    availability: Availability,
) -> OperationCoverage {
    operation.availability = availability;
    operation
}

/// Initial operation-level inventory. Each provider batch expands this list.
pub const OPERATIONS: &[OperationCoverage] = &[
    operation(
        Exchange::Upbit,
        "quotation",
        "markets",
        "GET",
        "/v1/market/all",
        ApiInterface::Http,
        Authentication::Public,
        OperationRisk::Read,
        OperationMapping::CommonAndProvider {
            common: &["markets"],
            provider: &["market_events"],
        },
        Validation::LiveRead,
    ),
    operation(
        Exchange::Upbit,
        "quotation",
        "candles_seconds",
        "GET",
        "/v1/candles/seconds",
        ApiInterface::Http,
        Authentication::Public,
        OperationRisk::Read,
        OperationMapping::Common("candles"),
        Validation::LiveRead,
    ),
    operation(
        Exchange::Upbit,
        "quotation",
        "candles_minutes",
        "GET",
        "/v1/candles/minutes/{unit}",
        ApiInterface::Http,
        Authentication::Public,
        OperationRisk::Read,
        OperationMapping::Common("candles"),
        Validation::LiveRead,
    ),
    operation(
        Exchange::Upbit,
        "quotation",
        "candles_days",
        "GET",
        "/v1/candles/days",
        ApiInterface::Http,
        Authentication::Public,
        OperationRisk::Read,
        OperationMapping::Common("candles"),
        Validation::LiveRead,
    ),
    operation(
        Exchange::Upbit,
        "quotation",
        "candles_weeks",
        "GET",
        "/v1/candles/weeks",
        ApiInterface::Http,
        Authentication::Public,
        OperationRisk::Read,
        OperationMapping::Common("candles"),
        Validation::LiveRead,
    ),
    operation(
        Exchange::Upbit,
        "quotation",
        "candles_months",
        "GET",
        "/v1/candles/months",
        ApiInterface::Http,
        Authentication::Public,
        OperationRisk::Read,
        OperationMapping::Common("candles"),
        Validation::LiveRead,
    ),
    operation(
        Exchange::Upbit,
        "quotation",
        "candles_years",
        "GET",
        "/v1/candles/years",
        ApiInterface::Http,
        Authentication::Public,
        OperationRisk::Read,
        OperationMapping::Provider("year_candles"),
        Validation::LiveRead,
    ),
    operation(
        Exchange::Upbit,
        "quotation",
        "trades_ticks",
        "GET",
        "/v1/trades/ticks",
        ApiInterface::Http,
        Authentication::Public,
        OperationRisk::Read,
        OperationMapping::Common("trades"),
        Validation::LiveRead,
    ),
    operation(
        Exchange::Upbit,
        "quotation",
        "ticker",
        "GET",
        "/v1/ticker",
        ApiInterface::Http,
        Authentication::Public,
        OperationRisk::Read,
        OperationMapping::CommonAndProvider {
            common: &["ticker"],
            provider: &["tickers"],
        },
        Validation::LiveRead,
    ),
    operation(
        Exchange::Upbit,
        "quotation",
        "tickers_by_quote",
        "GET",
        "/v1/ticker/all",
        ApiInterface::Http,
        Authentication::Public,
        OperationRisk::Read,
        OperationMapping::Provider("tickers_by_quote"),
        Validation::LiveRead,
    ),
    operation(
        Exchange::Upbit,
        "quotation",
        "orderbook",
        "GET",
        "/v1/orderbook",
        ApiInterface::Http,
        Authentication::Public,
        OperationRisk::Read,
        OperationMapping::CommonAndProvider {
            common: &["order_book"],
            provider: &["order_books", "order_books_at_level"],
        },
        Validation::LiveRead,
    ),
    operation(
        Exchange::Upbit,
        "quotation",
        "orderbook_instruments",
        "GET",
        "/v1/orderbook/instruments",
        ApiInterface::Http,
        Authentication::Public,
        OperationRisk::Read,
        OperationMapping::Provider("orderbook_instruments"),
        Validation::LiveRead,
    ),
    partial(operation(
        Exchange::Upbit,
        "quotation",
        "ticker_stream",
        "SUBSCRIBE",
        "ticker",
        ApiInterface::WebSocketStream,
        Authentication::Public,
        OperationRisk::Read,
        OperationMapping::Common("subscribe"),
        Validation::LiveRead,
    )),
    partial(operation(
        Exchange::Upbit,
        "quotation",
        "trade_stream",
        "SUBSCRIBE",
        "trade",
        ApiInterface::WebSocketStream,
        Authentication::Public,
        OperationRisk::Read,
        OperationMapping::Common("subscribe"),
        Validation::LiveRead,
    )),
    partial(operation(
        Exchange::Upbit,
        "quotation",
        "orderbook_stream",
        "SUBSCRIBE",
        "orderbook",
        ApiInterface::WebSocketStream,
        Authentication::Public,
        OperationRisk::Read,
        OperationMapping::Common("subscribe"),
        Validation::LiveRead,
    )),
    partial(operation(
        Exchange::Upbit,
        "quotation",
        "candle_stream",
        "SUBSCRIBE",
        "candle.{unit}",
        ApiInterface::WebSocketStream,
        Authentication::Public,
        OperationRisk::Read,
        OperationMapping::Common("subscribe"),
        Validation::LiveRead,
    )),
    planned(operation(
        Exchange::Upbit,
        "quotation",
        "list_subscriptions",
        "LIST_SUBSCRIPTIONS",
        "LIST_SUBSCRIPTIONS",
        ApiInterface::WebSocketRequest,
        Authentication::Public,
        OperationRisk::Read,
        OperationMapping::Provider("list_subscriptions"),
        Validation::Documented,
    )),
    operation(
        Exchange::Upbit,
        "exchange",
        "balances",
        "GET",
        "/v1/accounts",
        ApiInterface::Http,
        Authentication::Jwt,
        OperationRisk::Read,
        OperationMapping::Common("balances"),
        Validation::Fixture,
    ),
    operation(
        Exchange::Upbit,
        "exchange",
        "available_order_info",
        "GET",
        "/v1/orders/chance",
        ApiInterface::Http,
        Authentication::Jwt,
        OperationRisk::Read,
        OperationMapping::Common("order_rules"),
        Validation::Fixture,
    ),
    partial(operation(
        Exchange::Upbit,
        "exchange",
        "test_order",
        "POST",
        "/v1/orders/test",
        ApiInterface::Http,
        Authentication::Jwt,
        OperationRisk::Read,
        OperationMapping::Provider("test_order"),
        Validation::Fixture,
    )),
    operation(
        Exchange::Upbit,
        "exchange",
        "open_orders",
        "GET",
        "/v1/orders/open",
        ApiInterface::Http,
        Authentication::Jwt,
        OperationRisk::Read,
        OperationMapping::Common("open_orders"),
        Validation::Fixture,
    ),
    partial(operation(
        Exchange::Upbit,
        "exchange",
        "get_order",
        "GET",
        "/v1/order",
        ApiInterface::Http,
        Authentication::Jwt,
        OperationRisk::Read,
        OperationMapping::CommonMany(&["order", "order_by_client_id"]),
        Validation::Fixture,
    )),
    partial(operation(
        Exchange::Upbit,
        "exchange",
        "orders_by_ids",
        "GET",
        "/v1/orders/uuids",
        ApiInterface::Http,
        Authentication::Jwt,
        OperationRisk::Read,
        OperationMapping::Common("orders_by_ids"),
        Validation::Fixture,
    )),
    partial(operation(
        Exchange::Upbit,
        "exchange",
        "closed_orders",
        "GET",
        "/v1/orders/closed",
        ApiInterface::Http,
        Authentication::Jwt,
        OperationRisk::Read,
        OperationMapping::Common("order_history"),
        Validation::Fixture,
    )),
    partial(operation(
        Exchange::Upbit,
        "exchange",
        "new_order",
        "POST",
        "/v1/orders",
        ApiInterface::Http,
        Authentication::Jwt,
        OperationRisk::FinancialWrite,
        OperationMapping::Common("place_order"),
        Validation::Fixture,
    )),
    partial(operation(
        Exchange::Upbit,
        "exchange",
        "cancel_order",
        "DELETE",
        "/v1/order",
        ApiInterface::Http,
        Authentication::Jwt,
        OperationRisk::FinancialWrite,
        OperationMapping::CommonMany(&["cancel_order", "cancel_order_by_client_id"]),
        Validation::Fixture,
    )),
    partial(operation(
        Exchange::Upbit,
        "exchange",
        "cancel_orders_by_ids",
        "DELETE",
        "/v1/orders/uuids",
        ApiInterface::Http,
        Authentication::Jwt,
        OperationRisk::FinancialWrite,
        OperationMapping::Common("cancel_orders"),
        Validation::Fixture,
    )),
    operation(
        Exchange::Upbit,
        "exchange",
        "batch_cancel_open_orders",
        "DELETE",
        "/v1/orders/open",
        ApiInterface::Http,
        Authentication::Jwt,
        OperationRisk::FinancialWrite,
        OperationMapping::Provider("batch_cancel_open_orders"),
        Validation::Fixture,
    ),
    partial(operation(
        Exchange::Upbit,
        "exchange",
        "cancel_and_new_order",
        "POST",
        "/v1/orders/cancel_and_new",
        ApiInterface::Http,
        Authentication::Jwt,
        OperationRisk::FinancialWrite,
        OperationMapping::Provider("cancel_and_new_order"),
        Validation::Fixture,
    )),
    partial(operation(
        Exchange::Upbit,
        "exchange",
        "my_order_stream",
        "SUBSCRIBE",
        "myOrder",
        ApiInterface::WebSocketStream,
        Authentication::Jwt,
        OperationRisk::Read,
        OperationMapping::Common("subscribe_account"),
        Validation::Fixture,
    )),
    partial(operation(
        Exchange::Upbit,
        "exchange",
        "my_asset_stream",
        "SUBSCRIBE",
        "myAsset",
        ApiInterface::WebSocketStream,
        Authentication::Jwt,
        OperationRisk::Read,
        OperationMapping::Common("subscribe_account"),
        Validation::Fixture,
    )),
    operation(
        Exchange::Upbit,
        "wallet",
        "wallet_status",
        "GET",
        "/v1/status/wallet",
        ApiInterface::Http,
        Authentication::Jwt,
        OperationRisk::Read,
        OperationMapping::Common("asset_networks"),
        Validation::Fixture,
    ),
    operation(
        Exchange::Upbit,
        "wallet",
        "deposit_chance",
        "GET",
        "/v1/deposits/chance/coin",
        ApiInterface::Http,
        Authentication::Jwt,
        OperationRisk::Read,
        OperationMapping::Provider("deposit_info"),
        Validation::Fixture,
    ),
    operation(
        Exchange::Upbit,
        "wallet",
        "deposit_addresses",
        "GET",
        "/v1/deposits/coin_addresses",
        ApiInterface::Http,
        Authentication::Jwt,
        OperationRisk::Read,
        OperationMapping::Common("deposit_addresses"),
        Validation::Fixture,
    ),
    operation(
        Exchange::Upbit,
        "wallet",
        "deposit_address",
        "GET",
        "/v1/deposits/coin_address",
        ApiInterface::Http,
        Authentication::Jwt,
        OperationRisk::Read,
        OperationMapping::Common("deposit_address"),
        Validation::Fixture,
    ),
    operation(
        Exchange::Upbit,
        "wallet",
        "create_deposit_address",
        "POST",
        "/v1/deposits/generate_coin_address",
        ApiInterface::Http,
        Authentication::Jwt,
        OperationRisk::AccountWrite,
        OperationMapping::Common("create_deposit_address"),
        Validation::Fixture,
    ),
    operation(
        Exchange::Upbit,
        "wallet",
        "withdraw_chance",
        "GET",
        "/v1/withdraws/chance",
        ApiInterface::Http,
        Authentication::Jwt,
        OperationRisk::Read,
        OperationMapping::Common("prepare_withdrawal"),
        Validation::Fixture,
    ),
    operation(
        Exchange::Upbit,
        "wallet",
        "withdraw_addresses",
        "GET",
        "/v1/withdraws/coin_addresses",
        ApiInterface::Http,
        Authentication::Jwt,
        OperationRisk::Read,
        OperationMapping::Common("prepare_withdrawal"),
        Validation::Fixture,
    ),
    operation(
        Exchange::Upbit,
        "wallet",
        "withdraw_coin",
        "POST",
        "/v1/withdraws/coin",
        ApiInterface::Http,
        Authentication::Jwt,
        OperationRisk::FinancialWrite,
        OperationMapping::Common("withdraw"),
        Validation::Fixture,
    ),
    partial(operation(
        Exchange::Upbit,
        "wallet",
        "withdrawal",
        "GET",
        "/v1/withdraw",
        ApiInterface::Http,
        Authentication::Jwt,
        OperationRisk::Read,
        OperationMapping::Common("withdrawal"),
        Validation::Fixture,
    )),
    partial(operation(
        Exchange::Upbit,
        "wallet",
        "cancel_withdrawal",
        "DELETE",
        "/v1/withdraws/coin",
        ApiInterface::Http,
        Authentication::Jwt,
        OperationRisk::FinancialWrite,
        OperationMapping::Common("cancel_withdrawal"),
        Validation::Fixture,
    )),
    operation(
        Exchange::Upbit,
        "wallet",
        "deposits",
        "GET",
        "/v1/deposits",
        ApiInterface::Http,
        Authentication::Jwt,
        OperationRisk::Read,
        OperationMapping::Common("deposits"),
        Validation::Fixture,
    ),
    partial(operation(
        Exchange::Upbit,
        "wallet",
        "deposit",
        "GET",
        "/v1/deposit",
        ApiInterface::Http,
        Authentication::Jwt,
        OperationRisk::Read,
        OperationMapping::Common("deposit"),
        Validation::Fixture,
    )),
    operation(
        Exchange::Upbit,
        "wallet",
        "withdrawals",
        "GET",
        "/v1/withdraws",
        ApiInterface::Http,
        Authentication::Jwt,
        OperationRisk::Read,
        OperationMapping::Common("withdrawals"),
        Validation::Fixture,
    ),
    restricted(
        operation(
            Exchange::Upbit,
            "travel_rule",
            "travel_rule_vasps",
            "GET",
            "/v1/travel_rule/vasps",
            ApiInterface::Http,
            Authentication::Jwt,
            OperationRisk::Read,
            OperationMapping::Provider("travel_rule_vasps"),
            Validation::Fixture,
        ),
        Availability::Region("Korea or Singapore"),
    ),
    restricted(
        operation(
            Exchange::Upbit,
            "travel_rule",
            "travel_rule_verify_uuid",
            "POST",
            "/v1/travel_rule/deposit/uuid",
            ApiInterface::Http,
            Authentication::Jwt,
            OperationRisk::FinancialWrite,
            OperationMapping::Provider("verify_travel_rule_by_uuid"),
            Validation::Fixture,
        ),
        Availability::Region("Korea or Singapore"),
    ),
    restricted(
        operation(
            Exchange::Upbit,
            "travel_rule",
            "travel_rule_verify_txid",
            "POST",
            "/v1/travel_rule/deposit/txid",
            ApiInterface::Http,
            Authentication::Jwt,
            OperationRisk::FinancialWrite,
            OperationMapping::Provider("verify_travel_rule_by_txid"),
            Validation::Fixture,
        ),
        Availability::Region("Korea or Singapore"),
    ),
    operation(
        Exchange::Bithumb,
        "quotation",
        "markets",
        "GET",
        "/v1/market/all",
        ApiInterface::Http,
        Authentication::Public,
        OperationRisk::Read,
        OperationMapping::CommonAndProvider {
            common: &["markets"],
            provider: &["market_warnings"],
        },
        Validation::LiveRead,
    ),
    operation(
        Exchange::Bithumb,
        "quotation",
        "candles_minutes",
        "GET",
        "/v1/candles/minutes/{unit}",
        ApiInterface::Http,
        Authentication::Public,
        OperationRisk::Read,
        OperationMapping::Common("candles"),
        Validation::LiveRead,
    ),
    operation(
        Exchange::Bithumb,
        "quotation",
        "candles_days",
        "GET",
        "/v1/candles/days",
        ApiInterface::Http,
        Authentication::Public,
        OperationRisk::Read,
        OperationMapping::Common("candles"),
        Validation::LiveRead,
    ),
    operation(
        Exchange::Bithumb,
        "quotation",
        "candles_weeks",
        "GET",
        "/v1/candles/weeks",
        ApiInterface::Http,
        Authentication::Public,
        OperationRisk::Read,
        OperationMapping::Common("candles"),
        Validation::LiveRead,
    ),
    operation(
        Exchange::Bithumb,
        "quotation",
        "candles_months",
        "GET",
        "/v1/candles/months",
        ApiInterface::Http,
        Authentication::Public,
        OperationRisk::Read,
        OperationMapping::Common("candles"),
        Validation::LiveRead,
    ),
    operation(
        Exchange::Bithumb,
        "quotation",
        "trades_ticks",
        "GET",
        "/v1/trades/ticks",
        ApiInterface::Http,
        Authentication::Public,
        OperationRisk::Read,
        OperationMapping::Common("trades"),
        Validation::LiveRead,
    ),
    partial(operation(
        Exchange::Bithumb,
        "quotation",
        "ticker",
        "GET",
        "/v1/ticker",
        ApiInterface::Http,
        Authentication::Public,
        OperationRisk::Read,
        OperationMapping::Common("ticker"),
        Validation::LiveRead,
    )),
    partial(operation(
        Exchange::Bithumb,
        "quotation",
        "orderbook",
        "GET",
        "/v1/orderbook",
        ApiInterface::Http,
        Authentication::Public,
        OperationRisk::Read,
        OperationMapping::Common("order_book"),
        Validation::LiveRead,
    )),
    operation(
        Exchange::Bithumb,
        "quotation",
        "virtual_asset_warning",
        "GET",
        "/v1/market/virtual_asset_warning",
        ApiInterface::Http,
        Authentication::Public,
        OperationRisk::Read,
        OperationMapping::Provider("market_alerts"),
        Validation::LiveRead,
    ),
    operation(
        Exchange::Bithumb,
        "quotation",
        "notices",
        "GET",
        "/v1/notices",
        ApiInterface::Http,
        Authentication::Public,
        OperationRisk::Read,
        OperationMapping::Provider("notices"),
        Validation::LiveRead,
    ),
    operation(
        Exchange::Bithumb,
        "quotation",
        "inout_fee",
        "GET",
        "/v2/fee/inout/{currency}",
        ApiInterface::Http,
        Authentication::Public,
        OperationRisk::Read,
        OperationMapping::Provider("transfer_fees"),
        Validation::LiveRead,
    ),
    partial(operation(
        Exchange::Bithumb,
        "quotation",
        "ticker_stream",
        "SUBSCRIBE",
        "ticker",
        ApiInterface::WebSocketStream,
        Authentication::Public,
        OperationRisk::Read,
        OperationMapping::Common("subscribe"),
        Validation::LiveRead,
    )),
    partial(operation(
        Exchange::Bithumb,
        "quotation",
        "trade_stream",
        "SUBSCRIBE",
        "trade",
        ApiInterface::WebSocketStream,
        Authentication::Public,
        OperationRisk::Read,
        OperationMapping::Common("subscribe"),
        Validation::LiveRead,
    )),
    partial(operation(
        Exchange::Bithumb,
        "quotation",
        "orderbook_stream",
        "SUBSCRIBE",
        "orderbook",
        ApiInterface::WebSocketStream,
        Authentication::Public,
        OperationRisk::Read,
        OperationMapping::Common("subscribe"),
        Validation::LiveRead,
    )),
    operation(
        Exchange::Bithumb,
        "exchange",
        "balances",
        "GET",
        "/v1/accounts",
        ApiInterface::Http,
        Authentication::Jwt,
        OperationRisk::Read,
        OperationMapping::Common("balances"),
        Validation::Fixture,
    ),
    operation(
        Exchange::Bithumb,
        "exchange",
        "available_order_info",
        "GET",
        "/v1/orders/chance",
        ApiInterface::Http,
        Authentication::Jwt,
        OperationRisk::Read,
        OperationMapping::Common("order_rules"),
        Validation::Fixture,
    ),
    partial(operation(
        Exchange::Bithumb,
        "exchange",
        "orders",
        "GET",
        "/v1/orders",
        ApiInterface::Http,
        Authentication::Jwt,
        OperationRisk::Read,
        OperationMapping::Common("open_orders"),
        Validation::Fixture,
    )),
    partial(operation(
        Exchange::Bithumb,
        "exchange",
        "get_order",
        "GET",
        "/v1/order",
        ApiInterface::Http,
        Authentication::Jwt,
        OperationRisk::Read,
        OperationMapping::CommonMany(&["order", "order_by_client_id"]),
        Validation::Fixture,
    )),
    partial(operation(
        Exchange::Bithumb,
        "exchange",
        "orders_by_ids",
        "POST",
        "/v2/orders/search",
        ApiInterface::Http,
        Authentication::Jwt,
        OperationRisk::Read,
        OperationMapping::Common("orders_by_ids"),
        Validation::Fixture,
    )),
    operation(
        Exchange::Bithumb,
        "exchange",
        "pending_orders",
        "GET",
        "/v2/orders/pending",
        ApiInterface::Http,
        Authentication::Jwt,
        OperationRisk::Read,
        OperationMapping::Provider("pending_orders"),
        Validation::Fixture,
    ),
    partial(operation(
        Exchange::Bithumb,
        "exchange",
        "closed_orders",
        "GET",
        "/v2/orders/history",
        ApiInterface::Http,
        Authentication::Jwt,
        OperationRisk::Read,
        OperationMapping::Common("order_history"),
        Validation::Fixture,
    )),
    partial(operation(
        Exchange::Bithumb,
        "exchange",
        "new_order",
        "POST",
        "/v2/orders",
        ApiInterface::Http,
        Authentication::Jwt,
        OperationRisk::FinancialWrite,
        OperationMapping::Common("place_order"),
        Validation::Fixture,
    )),
    partial(operation(
        Exchange::Bithumb,
        "exchange",
        "batch_orders",
        "POST",
        "/v2/orders/batch",
        ApiInterface::Http,
        Authentication::Jwt,
        OperationRisk::FinancialWrite,
        OperationMapping::Provider("batch_orders"),
        Validation::Fixture,
    )),
    partial(operation(
        Exchange::Bithumb,
        "exchange",
        "cancel_order",
        "DELETE",
        "/v2/order",
        ApiInterface::Http,
        Authentication::Jwt,
        OperationRisk::FinancialWrite,
        OperationMapping::CommonMany(&["cancel_order", "cancel_order_by_client_id"]),
        Validation::Fixture,
    )),
    partial(operation(
        Exchange::Bithumb,
        "exchange",
        "cancel_orders",
        "POST",
        "/v2/orders/cancel",
        ApiInterface::Http,
        Authentication::Jwt,
        OperationRisk::FinancialWrite,
        OperationMapping::Common("cancel_orders"),
        Validation::Fixture,
    )),
    partial(operation(
        Exchange::Bithumb,
        "exchange",
        "my_order_stream",
        "SUBSCRIBE",
        "myOrder",
        ApiInterface::WebSocketStream,
        Authentication::Jwt,
        OperationRisk::Read,
        OperationMapping::Common("subscribe_account"),
        Validation::Fixture,
    )),
    partial(operation(
        Exchange::Bithumb,
        "exchange",
        "my_asset_stream",
        "SUBSCRIBE",
        "myAsset",
        ApiInterface::WebSocketStream,
        Authentication::Jwt,
        OperationRisk::Read,
        OperationMapping::Common("subscribe_account"),
        Validation::Fixture,
    )),
    operation(
        Exchange::Bithumb,
        "wallet",
        "wallet_status",
        "GET",
        "/v1/status/wallet",
        ApiInterface::Http,
        Authentication::Jwt,
        OperationRisk::Read,
        OperationMapping::Common("asset_networks"),
        Validation::Fixture,
    ),
    operation(
        Exchange::Bithumb,
        "wallet",
        "deposit_addresses",
        "GET",
        "/v1/deposits/coin_addresses",
        ApiInterface::Http,
        Authentication::Jwt,
        OperationRisk::Read,
        OperationMapping::Common("deposit_addresses"),
        Validation::Fixture,
    ),
    operation(
        Exchange::Bithumb,
        "wallet",
        "deposit_address",
        "GET",
        "/v1/deposits/coin_address",
        ApiInterface::Http,
        Authentication::Jwt,
        OperationRisk::Read,
        OperationMapping::Common("deposit_address"),
        Validation::Fixture,
    ),
    operation(
        Exchange::Bithumb,
        "wallet",
        "create_deposit_address",
        "POST",
        "/v1/deposits/generate_coin_address",
        ApiInterface::Http,
        Authentication::Jwt,
        OperationRisk::AccountWrite,
        OperationMapping::Common("create_deposit_address"),
        Validation::Fixture,
    ),
    operation(
        Exchange::Bithumb,
        "wallet",
        "withdraw_chance",
        "GET",
        "/v1/withdraws/chance",
        ApiInterface::Http,
        Authentication::Jwt,
        OperationRisk::Read,
        OperationMapping::Common("prepare_withdrawal"),
        Validation::Fixture,
    ),
    operation(
        Exchange::Bithumb,
        "wallet",
        "withdraw_addresses",
        "GET",
        "/v1/withdraws/coin_addresses",
        ApiInterface::Http,
        Authentication::Jwt,
        OperationRisk::Read,
        OperationMapping::Common("prepare_withdrawal"),
        Validation::Fixture,
    ),
    operation(
        Exchange::Bithumb,
        "wallet",
        "withdraw_coin",
        "POST",
        "/v1/withdraws/coin",
        ApiInterface::Http,
        Authentication::Jwt,
        OperationRisk::FinancialWrite,
        OperationMapping::Common("withdraw"),
        Validation::Fixture,
    ),
    partial(operation(
        Exchange::Bithumb,
        "wallet",
        "withdrawal",
        "GET",
        "/v1/withdraw",
        ApiInterface::Http,
        Authentication::Jwt,
        OperationRisk::Read,
        OperationMapping::Common("withdrawal"),
        Validation::Fixture,
    )),
    partial(operation(
        Exchange::Bithumb,
        "wallet",
        "cancel_withdrawal",
        "DELETE",
        "/v1/withdraws/coin",
        ApiInterface::Http,
        Authentication::Jwt,
        OperationRisk::FinancialWrite,
        OperationMapping::Common("cancel_withdrawal"),
        Validation::Fixture,
    )),
    operation(
        Exchange::Bithumb,
        "wallet",
        "deposits",
        "GET",
        "/v1/deposits",
        ApiInterface::Http,
        Authentication::Jwt,
        OperationRisk::Read,
        OperationMapping::Common("deposits"),
        Validation::Fixture,
    ),
    partial(operation(
        Exchange::Bithumb,
        "wallet",
        "deposit",
        "GET",
        "/v1/deposit",
        ApiInterface::Http,
        Authentication::Jwt,
        OperationRisk::Read,
        OperationMapping::Common("deposit"),
        Validation::Fixture,
    )),
    operation(
        Exchange::Bithumb,
        "wallet",
        "withdrawals",
        "GET",
        "/v1/withdraws",
        ApiInterface::Http,
        Authentication::Jwt,
        OperationRisk::Read,
        OperationMapping::Common("withdrawals"),
        Validation::Fixture,
    ),
    operation(
        Exchange::Bithumb,
        "wallet",
        "api_keys",
        "GET",
        "/v1/api_keys",
        ApiInterface::Http,
        Authentication::Jwt,
        OperationRisk::Read,
        OperationMapping::Provider("api_keys"),
        Validation::Fixture,
    ),
    operation(
        Exchange::Bithumb,
        "twap",
        "twap",
        "GET",
        "/v1/twap",
        ApiInterface::Http,
        Authentication::Jwt,
        OperationRisk::Read,
        OperationMapping::Provider("twap_orders"),
        Validation::Fixture,
    ),
    operation(
        Exchange::Bithumb,
        "twap",
        "create_twap",
        "POST",
        "/v1/twap",
        ApiInterface::Http,
        Authentication::Jwt,
        OperationRisk::FinancialWrite,
        OperationMapping::Provider("create_twap_order"),
        Validation::Fixture,
    ),
    operation(
        Exchange::Bithumb,
        "twap",
        "cancel_twap",
        "DELETE",
        "/v1/twap",
        ApiInterface::Http,
        Authentication::Jwt,
        OperationRisk::FinancialWrite,
        OperationMapping::Provider("cancel_twap_order"),
        Validation::Fixture,
    ),
    operation(
        Exchange::Bithumb,
        "krw",
        "withdrawals",
        "GET",
        "/v1/withdraws/krw",
        ApiInterface::Http,
        Authentication::Jwt,
        OperationRisk::Read,
        OperationMapping::Provider("krw_withdrawals"),
        Validation::Fixture,
    ),
    operation(
        Exchange::Bithumb,
        "krw",
        "withdraw",
        "POST",
        "/v1/withdraws/krw",
        ApiInterface::Http,
        Authentication::Jwt,
        OperationRisk::FinancialWrite,
        OperationMapping::Provider("withdraw_krw"),
        Validation::Fixture,
    ),
    operation(
        Exchange::Bithumb,
        "krw",
        "deposits",
        "GET",
        "/v1/deposits/krw",
        ApiInterface::Http,
        Authentication::Jwt,
        OperationRisk::Read,
        OperationMapping::Provider("krw_deposits"),
        Validation::Fixture,
    ),
    operation(
        Exchange::Bithumb,
        "krw",
        "deposit",
        "POST",
        "/v1/deposits/krw",
        ApiInterface::Http,
        Authentication::Jwt,
        OperationRisk::FinancialWrite,
        OperationMapping::Provider("deposit_krw"),
        Validation::Fixture,
    ),
    operation(
        Exchange::Binance,
        "spot",
        "exchange_info",
        "GET",
        "/api/v3/exchangeInfo",
        ApiInterface::Http,
        Authentication::Public,
        OperationRisk::Read,
        OperationMapping::CommonAndProvider {
            common: &["markets"],
            provider: &["spot_symbol_filters"],
        },
        Validation::LiveRead,
    ),
    operation(
        Exchange::Binance,
        "spot",
        "recent_trades",
        "GET",
        "/api/v3/trades",
        ApiInterface::Http,
        Authentication::Public,
        OperationRisk::Read,
        OperationMapping::Common("trades"),
        Validation::LiveRead,
    ),
    operation(
        Exchange::Binance,
        "spot",
        "order_book",
        "GET",
        "/api/v3/depth",
        ApiInterface::Http,
        Authentication::Public,
        OperationRisk::Read,
        OperationMapping::Common("order_book"),
        Validation::LiveRead,
    ),
    operation(
        Exchange::Binance,
        "spot",
        "ticker_24hr",
        "GET",
        "/api/v3/ticker/24hr",
        ApiInterface::Http,
        Authentication::Public,
        OperationRisk::Read,
        OperationMapping::Common("ticker"),
        Validation::LiveRead,
    ),
    operation(
        Exchange::Binance,
        "spot",
        "klines",
        "GET",
        "/api/v3/klines",
        ApiInterface::Http,
        Authentication::Public,
        OperationRisk::Read,
        OperationMapping::Common("candles"),
        Validation::LiveRead,
    ),
    operation(
        Exchange::Binance,
        "spot",
        "account_information",
        "GET",
        "/api/v3/account",
        ApiInterface::Http,
        Authentication::Hmac,
        OperationRisk::Read,
        OperationMapping::Common("balances"),
        Validation::Fixture,
    ),
    operation(
        Exchange::Binance,
        "spot",
        "open_orders",
        "GET",
        "/api/v3/openOrders",
        ApiInterface::Http,
        Authentication::Hmac,
        OperationRisk::Read,
        OperationMapping::Common("open_orders"),
        Validation::Fixture,
    ),
    partial(operation(
        Exchange::Binance,
        "spot",
        "new_order",
        "POST",
        "/api/v3/order",
        ApiInterface::Http,
        Authentication::Hmac,
        OperationRisk::FinancialWrite,
        OperationMapping::Common("place_order"),
        Validation::Fixture,
    )),
    partial(operation(
        Exchange::Binance,
        "spot",
        "cancel_order",
        "DELETE",
        "/api/v3/order",
        ApiInterface::Http,
        Authentication::Hmac,
        OperationRisk::FinancialWrite,
        OperationMapping::CommonMany(&["cancel_order", "cancel_order_by_client_id"]),
        Validation::Fixture,
    )),
    operation(
        Exchange::Binance,
        "spot",
        "query_order",
        "GET",
        "/api/v3/order",
        ApiInterface::Http,
        Authentication::Hmac,
        OperationRisk::Read,
        OperationMapping::Provider("spot_order"),
        Validation::Fixture,
    ),
    partial(operation(
        Exchange::Binance,
        "spot",
        "trade_stream",
        "SUBSCRIBE",
        "{symbol}@trade",
        ApiInterface::WebSocketStream,
        Authentication::Public,
        OperationRisk::Read,
        OperationMapping::Common("subscribe"),
        Validation::LiveRead,
    )),
    partial(operation(
        Exchange::Binance,
        "spot",
        "partial_book_depth_stream",
        "SUBSCRIBE",
        "{symbol}@depth{levels}@{updateSpeed}",
        ApiInterface::WebSocketStream,
        Authentication::Public,
        OperationRisk::Read,
        OperationMapping::Common("subscribe"),
        Validation::LiveRead,
    )),
    partial(operation(
        Exchange::Binance,
        "spot",
        "ticker_stream",
        "SUBSCRIBE",
        "{symbol}@ticker",
        ApiInterface::WebSocketStream,
        Authentication::Public,
        OperationRisk::Read,
        OperationMapping::Common("subscribe"),
        Validation::LiveRead,
    )),
    partial(operation(
        Exchange::Binance,
        "spot",
        "kline_stream",
        "SUBSCRIBE",
        "{symbol}@kline_{interval}",
        ApiInterface::WebSocketStream,
        Authentication::Public,
        OperationRisk::Read,
        OperationMapping::Common("subscribe"),
        Validation::LiveRead,
    )),
    partial(operation(
        Exchange::Binance,
        "spot",
        "user_data_stream_signature",
        "REQUEST",
        "userDataStream.subscribe.signature",
        ApiInterface::WebSocketRequest,
        Authentication::Hmac,
        OperationRisk::Read,
        OperationMapping::Common("subscribe_account"),
        Validation::Fixture,
    )),
    operation(
        Exchange::Binance,
        "usd_m",
        "exchange_info",
        "GET",
        "/fapi/v1/exchangeInfo",
        ApiInterface::Http,
        Authentication::Public,
        OperationRisk::Read,
        OperationMapping::Common("markets"),
        Validation::LiveRead,
    ),
    operation(
        Exchange::Binance,
        "usd_m",
        "recent_trades",
        "GET",
        "/fapi/v1/trades",
        ApiInterface::Http,
        Authentication::Public,
        OperationRisk::Read,
        OperationMapping::Common("trades"),
        Validation::LiveRead,
    ),
    operation(
        Exchange::Binance,
        "usd_m",
        "order_book",
        "GET",
        "/fapi/v1/depth",
        ApiInterface::Http,
        Authentication::Public,
        OperationRisk::Read,
        OperationMapping::Common("order_book"),
        Validation::LiveRead,
    ),
    operation(
        Exchange::Binance,
        "usd_m",
        "ticker_24hr",
        "GET",
        "/fapi/v1/ticker/24hr",
        ApiInterface::Http,
        Authentication::Public,
        OperationRisk::Read,
        OperationMapping::Common("ticker"),
        Validation::LiveRead,
    ),
    operation(
        Exchange::Binance,
        "usd_m",
        "mark_price",
        "GET",
        "/fapi/v1/premiumIndex?symbol={symbol}",
        ApiInterface::Http,
        Authentication::Public,
        OperationRisk::Read,
        OperationMapping::Provider("mark_price"),
        Validation::Fixture,
    ),
    operation(
        Exchange::Binance,
        "usd_m",
        "mark_prices",
        "GET",
        "/fapi/v1/premiumIndex",
        ApiInterface::Http,
        Authentication::Public,
        OperationRisk::Read,
        OperationMapping::Provider("mark_prices"),
        Validation::Fixture,
    ),
    operation(
        Exchange::Binance,
        "usd_m",
        "open_interest",
        "GET",
        "/fapi/v1/openInterest?symbol={symbol}",
        ApiInterface::Http,
        Authentication::Public,
        OperationRisk::Read,
        OperationMapping::Provider("open_interest"),
        Validation::Fixture,
    ),
    operation(
        Exchange::Binance,
        "usd_m",
        "klines",
        "GET",
        "/fapi/v1/klines",
        ApiInterface::Http,
        Authentication::Public,
        OperationRisk::Read,
        OperationMapping::Common("candles"),
        Validation::LiveRead,
    ),
    operation(
        Exchange::Binance,
        "usd_m",
        "account_information_v3",
        "GET",
        "/fapi/v3/account",
        ApiInterface::Http,
        Authentication::Hmac,
        OperationRisk::Read,
        OperationMapping::CommonMany(&["balances", "margin_summary"]),
        Validation::Fixture,
    ),
    operation(
        Exchange::Binance,
        "usd_m",
        "open_orders",
        "GET",
        "/fapi/v1/openOrders",
        ApiInterface::Http,
        Authentication::Hmac,
        OperationRisk::Read,
        OperationMapping::Common("open_orders"),
        Validation::Fixture,
    ),
    partial(operation(
        Exchange::Binance,
        "usd_m",
        "new_order",
        "POST",
        "/fapi/v1/order",
        ApiInterface::Http,
        Authentication::Hmac,
        OperationRisk::FinancialWrite,
        OperationMapping::Common("place_order"),
        Validation::Fixture,
    )),
    partial(operation(
        Exchange::Binance,
        "usd_m",
        "cancel_order",
        "DELETE",
        "/fapi/v1/order",
        ApiInterface::Http,
        Authentication::Hmac,
        OperationRisk::FinancialWrite,
        OperationMapping::CommonMany(&["cancel_order", "cancel_order_by_client_id"]),
        Validation::Fixture,
    )),
    operation(
        Exchange::Binance,
        "usd_m",
        "position_information_v3",
        "GET",
        "/fapi/v3/positionRisk",
        ApiInterface::Http,
        Authentication::Hmac,
        OperationRisk::Read,
        OperationMapping::Common("positions"),
        Validation::Fixture,
    ),
    operation(
        Exchange::Binance,
        "usd_m",
        "funding_rate_history",
        "GET",
        "/fapi/v1/fundingRate",
        ApiInterface::Http,
        Authentication::Public,
        OperationRisk::Read,
        OperationMapping::Common("funding_rates"),
        Validation::LiveRead,
    ),
    operation(
        Exchange::Binance,
        "usd_m",
        "income_history",
        "GET",
        "/fapi/v1/income",
        ApiInterface::Http,
        Authentication::Hmac,
        OperationRisk::Read,
        OperationMapping::Common("funding_payments"),
        Validation::Fixture,
    ),
    operation(
        Exchange::Binance,
        "usd_m",
        "change_initial_leverage",
        "POST",
        "/fapi/v1/leverage",
        ApiInterface::Http,
        Authentication::Hmac,
        OperationRisk::AccountWrite,
        OperationMapping::Common("set_margin"),
        Validation::Fixture,
    ),
    operation(
        Exchange::Binance,
        "usd_m",
        "change_margin_type",
        "POST",
        "/fapi/v1/marginType",
        ApiInterface::Http,
        Authentication::Hmac,
        OperationRisk::AccountWrite,
        OperationMapping::Common("set_margin"),
        Validation::Fixture,
    ),
    operation(
        Exchange::Binance,
        "usd_m",
        "start_user_data_stream",
        "POST",
        "/fapi/v1/listenKey",
        ApiInterface::Http,
        Authentication::ApiKey,
        OperationRisk::AccountWrite,
        OperationMapping::Provider("usd_m_create_listen_key"),
        Validation::Fixture,
    ),
    operation(
        Exchange::Binance,
        "usd_m",
        "keepalive_user_data_stream",
        "PUT",
        "/fapi/v1/listenKey",
        ApiInterface::Http,
        Authentication::ApiKey,
        OperationRisk::AccountWrite,
        OperationMapping::Provider("usd_m_keepalive_listen_key"),
        Validation::Fixture,
    ),
    operation(
        Exchange::Binance,
        "usd_m",
        "close_user_data_stream",
        "DELETE",
        "/fapi/v1/listenKey",
        ApiInterface::Http,
        Authentication::ApiKey,
        OperationRisk::AccountWrite,
        OperationMapping::Provider("usd_m_close_listen_key"),
        Validation::Fixture,
    ),
    partial(operation(
        Exchange::Binance,
        "usd_m",
        "aggregate_trades",
        "GET",
        "/fapi/v1/aggTrades",
        ApiInterface::Http,
        Authentication::Public,
        OperationRisk::Read,
        OperationMapping::Provider("aggregate_trades"),
        Validation::Fixture,
    )),
    planned(operation(
        Exchange::Binance,
        "usd_m",
        "aggregate_trade_stream",
        "SUBSCRIBE",
        "{symbol}@aggTrade",
        ApiInterface::WebSocketStream,
        Authentication::Public,
        OperationRisk::Read,
        OperationMapping::Provider("aggregate_trades"),
        Validation::Documented,
    )),
    partial(operation(
        Exchange::Binance,
        "usd_m",
        "partial_book_depth_stream",
        "SUBSCRIBE",
        "{symbol}@depth{levels}@{updateSpeed}",
        ApiInterface::WebSocketStream,
        Authentication::Public,
        OperationRisk::Read,
        OperationMapping::Common("subscribe"),
        Validation::LiveRead,
    )),
    partial(operation(
        Exchange::Binance,
        "usd_m",
        "ticker_stream",
        "SUBSCRIBE",
        "{symbol}@ticker",
        ApiInterface::WebSocketStream,
        Authentication::Public,
        OperationRisk::Read,
        OperationMapping::Common("subscribe"),
        Validation::LiveRead,
    )),
    partial(operation(
        Exchange::Binance,
        "usd_m",
        "kline_stream",
        "SUBSCRIBE",
        "{symbol}@kline_{interval}",
        ApiInterface::WebSocketStream,
        Authentication::Public,
        OperationRisk::Read,
        OperationMapping::Common("subscribe"),
        Validation::LiveRead,
    )),
    operation(
        Exchange::Binance,
        "wallet",
        "all_coins_information",
        "GET",
        "/sapi/v1/capital/config/getall",
        ApiInterface::Http,
        Authentication::Hmac,
        OperationRisk::Read,
        OperationMapping::Common("asset_networks"),
        Validation::Fixture,
    ),
    operation(
        Exchange::Binance,
        "wallet",
        "deposit_address",
        "GET",
        "/sapi/v1/capital/deposit/address",
        ApiInterface::Http,
        Authentication::Hmac,
        OperationRisk::Read,
        OperationMapping::Common("deposit_address"),
        Validation::Fixture,
    ),
    operation(
        Exchange::Binance,
        "wallet",
        "api_key_permissions",
        "GET",
        "/sapi/v1/account/apiRestrictions",
        ApiInterface::Http,
        Authentication::Hmac,
        OperationRisk::Read,
        OperationMapping::Common("prepare_withdrawal"),
        Validation::Fixture,
    ),
    operation(
        Exchange::Binance,
        "wallet",
        "withdraw_address_list",
        "GET",
        "/sapi/v1/capital/withdraw/address/list",
        ApiInterface::Http,
        Authentication::Hmac,
        OperationRisk::Read,
        OperationMapping::Common("prepare_withdrawal"),
        Validation::Fixture,
    ),
    restricted(
        operation(
            Exchange::Binance,
            "wallet",
            "questionnaire_requirements",
            "GET",
            "/sapi/v1/localentity/questionnaire-requirements",
            ApiInterface::Http,
            Authentication::Hmac,
            OperationRisk::Read,
            OperationMapping::Common("prepare_withdrawal"),
            Validation::Fixture,
        ),
        Availability::Eligibility("local entity and Travel Rule requirements"),
    ),
    operation(
        Exchange::Binance,
        "wallet",
        "withdraw",
        "POST",
        "/sapi/v1/capital/withdraw/apply",
        ApiInterface::Http,
        Authentication::Hmac,
        OperationRisk::FinancialWrite,
        OperationMapping::Common("withdraw"),
        Validation::Fixture,
    ),
    operation(
        Exchange::Binance,
        "wallet",
        "deposit_history",
        "GET",
        "/sapi/v1/capital/deposit/hisrec",
        ApiInterface::Http,
        Authentication::Hmac,
        OperationRisk::Read,
        OperationMapping::Common("deposits"),
        Validation::Fixture,
    ),
    operation(
        Exchange::Binance,
        "wallet",
        "withdraw_history",
        "GET",
        "/sapi/v1/capital/withdraw/history",
        ApiInterface::Http,
        Authentication::Hmac,
        OperationRisk::Read,
        OperationMapping::Common("withdrawals"),
        Validation::Fixture,
    ),
    partial(operation(
        Exchange::Hyperliquid,
        "info",
        "meta",
        "POST",
        "/info type=meta",
        ApiInterface::Http,
        Authentication::Public,
        OperationRisk::Read,
        OperationMapping::Common("markets"),
        Validation::LiveRead,
    )),
    operation(
        Exchange::Hyperliquid,
        "info",
        "spot_meta",
        "POST",
        "/info type=spotMeta",
        ApiInterface::Http,
        Authentication::Public,
        OperationRisk::Read,
        OperationMapping::Common("markets"),
        Validation::LiveRead,
    ),
    partial(operation(
        Exchange::Hyperliquid,
        "info",
        "all_mids",
        "POST",
        "/info type=allMids",
        ApiInterface::Http,
        Authentication::Public,
        OperationRisk::Read,
        OperationMapping::Provider("all_mids"),
        Validation::Fixture,
    )),
    partial(operation(
        Exchange::Hyperliquid,
        "info",
        "meta_and_asset_contexts",
        "POST",
        "/info type=metaAndAssetCtxs",
        ApiInterface::Http,
        Authentication::Public,
        OperationRisk::Read,
        OperationMapping::CommonAndProvider {
            common: &["ticker"],
            provider: &["asset_context"],
        },
        Validation::LiveRead,
    )),
    operation(
        Exchange::Hyperliquid,
        "info",
        "spot_meta_and_asset_contexts",
        "POST",
        "/info type=spotMetaAndAssetCtxs",
        ApiInterface::Http,
        Authentication::Public,
        OperationRisk::Read,
        OperationMapping::CommonAndProvider {
            common: &["ticker"],
            provider: &["asset_context"],
        },
        Validation::LiveRead,
    ),
    operation(
        Exchange::Hyperliquid,
        "info",
        "l2_book",
        "POST",
        "/info type=l2Book",
        ApiInterface::Http,
        Authentication::Public,
        OperationRisk::Read,
        OperationMapping::Common("order_book"),
        Validation::LiveRead,
    ),
    operation(
        Exchange::Hyperliquid,
        "info",
        "recent_trades",
        "POST",
        "/info type=recentTrades",
        ApiInterface::Http,
        Authentication::Public,
        OperationRisk::Read,
        OperationMapping::Common("trades"),
        Validation::LiveRead,
    ),
    operation(
        Exchange::Hyperliquid,
        "info",
        "candle_snapshot",
        "POST",
        "/info type=candleSnapshot",
        ApiInterface::Http,
        Authentication::Public,
        OperationRisk::Read,
        OperationMapping::Common("candles"),
        Validation::LiveRead,
    ),
    operation(
        Exchange::Hyperliquid,
        "info",
        "spot_clearinghouse_state",
        "POST",
        "/info type=spotClearinghouseState",
        ApiInterface::Http,
        Authentication::Public,
        OperationRisk::Read,
        OperationMapping::Common("balances"),
        Validation::Fixture,
    ),
    partial(operation(
        Exchange::Hyperliquid,
        "info",
        "clearinghouse_state",
        "POST",
        "/info type=clearinghouseState",
        ApiInterface::Http,
        Authentication::Public,
        OperationRisk::Read,
        OperationMapping::CommonMany(&["positions", "margin_summary"]),
        Validation::Fixture,
    )),
    partial(operation(
        Exchange::Hyperliquid,
        "info",
        "frontend_open_orders",
        "POST",
        "/info type=frontendOpenOrders",
        ApiInterface::Http,
        Authentication::Public,
        OperationRisk::Read,
        OperationMapping::Common("open_orders"),
        Validation::Fixture,
    )),
    operation(
        Exchange::Hyperliquid,
        "info",
        "funding_history",
        "POST",
        "/info type=fundingHistory",
        ApiInterface::Http,
        Authentication::Public,
        OperationRisk::Read,
        OperationMapping::Common("funding_rates"),
        Validation::LiveRead,
    ),
    operation(
        Exchange::Hyperliquid,
        "info",
        "user_funding",
        "POST",
        "/info type=userFunding",
        ApiInterface::Http,
        Authentication::Public,
        OperationRisk::Read,
        OperationMapping::Common("funding_payments"),
        Validation::Fixture,
    ),
    operation(
        Exchange::Hyperliquid,
        "info",
        "user_non_funding_ledger_updates",
        "POST",
        "/info type=userNonFundingLedgerUpdates",
        ApiInterface::Http,
        Authentication::Public,
        OperationRisk::Read,
        OperationMapping::CommonMany(&["deposits", "withdrawals"]),
        Validation::Fixture,
    ),
    partial(operation(
        Exchange::Hyperliquid,
        "exchange",
        "order",
        "POST",
        "/exchange action=order",
        ApiInterface::Http,
        Authentication::Eip712,
        OperationRisk::FinancialWrite,
        OperationMapping::Common("place_order"),
        Validation::Fixture,
    )),
    partial(operation(
        Exchange::Hyperliquid,
        "exchange",
        "cancel",
        "POST",
        "/exchange action=cancel",
        ApiInterface::Http,
        Authentication::Eip712,
        OperationRisk::FinancialWrite,
        OperationMapping::Common("cancel_order"),
        Validation::Fixture,
    )),
    operation(
        Exchange::Hyperliquid,
        "exchange",
        "update_leverage",
        "POST",
        "/exchange action=updateLeverage",
        ApiInterface::Http,
        Authentication::Eip712,
        OperationRisk::AccountWrite,
        OperationMapping::Common("set_margin"),
        Validation::Fixture,
    ),
    operation(
        Exchange::Hyperliquid,
        "subscriptions",
        "trades",
        "SUBSCRIBE",
        "trades",
        ApiInterface::WebSocketStream,
        Authentication::Public,
        OperationRisk::Read,
        OperationMapping::Common("subscribe"),
        Validation::LiveRead,
    ),
    operation(
        Exchange::Hyperliquid,
        "subscriptions",
        "l2_book",
        "SUBSCRIBE",
        "l2Book",
        ApiInterface::WebSocketStream,
        Authentication::Public,
        OperationRisk::Read,
        OperationMapping::Common("subscribe"),
        Validation::LiveRead,
    ),
    operation(
        Exchange::Hyperliquid,
        "subscriptions",
        "active_asset_context",
        "SUBSCRIBE",
        "activeAssetCtx",
        ApiInterface::WebSocketStream,
        Authentication::Public,
        OperationRisk::Read,
        OperationMapping::Common("subscribe"),
        Validation::LiveRead,
    ),
    operation(
        Exchange::Hyperliquid,
        "subscriptions",
        "candle",
        "SUBSCRIBE",
        "candle",
        ApiInterface::WebSocketStream,
        Authentication::Public,
        OperationRisk::Read,
        OperationMapping::Common("subscribe"),
        Validation::LiveRead,
    ),
    operation(
        Exchange::Hyperliquid,
        "subscriptions",
        "order_updates",
        "SUBSCRIBE",
        "orderUpdates",
        ApiInterface::WebSocketStream,
        Authentication::Public,
        OperationRisk::Read,
        OperationMapping::Common("subscribe_account"),
        Validation::Fixture,
    ),
    operation(
        Exchange::Hyperliquid,
        "subscriptions",
        "spot_state",
        "SUBSCRIBE",
        "spotState",
        ApiInterface::WebSocketStream,
        Authentication::Public,
        OperationRisk::Read,
        OperationMapping::Common("subscribe_account"),
        Validation::Fixture,
    ),
    operation(
        Exchange::Hyperliquid,
        "subscriptions",
        "ping",
        "REQUEST",
        "ping",
        ApiInterface::WebSocketStream,
        Authentication::Public,
        OperationRisk::Read,
        OperationMapping::Common("subscribe"),
        Validation::Fixture,
    ),
];