@binance/connector-typescript/dist/index.d.mts

This is a lightweight library that works as a connector to the Binance public API.

import { AxiosProxyConfig } from 'axios';
import WebSocketClient from 'ws';

declare enum AccountSnapshotType {
    SPOT = "SPOT",
    MARGIN = "MARGIN",
    FUTURES = "FUTURES"
}
declare enum AddLiquidityPreviewType {
    SINGLE = "SINGLE",
    COMBINATION = "COMBINATION"
}
declare enum AutoCompoundPlan {
    NONE = "NONE",
    STANDARD = "STANDARD",
    ADVANCED = "ADVANCED"
}
declare enum BusdStableCoinsConversion {
    USDC = "USDC",
    USDP = "USDP",
    TUSD = "TUSD"
}
declare enum CancelReplaceMode {
    ALLOW_FAILURE = "ALLOW_FAILURE",
    STOP_ON_FAILURE = "STOP_ON_FAILURE"
}
declare enum CancelResult {
    SUCCESS = "SUCCESS",
    FAILURE = "FAILURE"
}
declare enum CancelRestrictions {
    ONLY_NEW = "ONLY_NEW",
    ONLY_PARTIALLY_FILLED = "ONLY_PARTIALLY_FILLED"
}
declare enum ConvertExpiredType {
    One_Day = "1_D",
    Three_Day = "3_D",
    Seven_Day = "7_D",
    Thirty_Day = "30_D"
}
declare enum ConvertOrderStatus {
    PROCESS = "PROCESS",
    ACCEPT_SUCCESS = "ACCEPT_SUCCESS",
    SUCCESS = "SUCCESS",
    FAIL = "FAIL"
}
declare enum ConvertSide {
    BUY = "BUY",
    SELL = "SELL"
}
declare enum CrossMarginAccountTransferType {
    TransferFromMainAccountToMarginAccount = 1,
    TransferFromMarginAccountToMainAccount = 2
}
declare enum CrossMarginAccountType {
    MARGIN_1 = "MARGIN_1",
    MARGIN_2 = "MARGIN_2"
}
declare enum CrossMarginTrans {
    SPOT = "SPOT",
    FUTURES = "FUTURES",
    FIAT = "FIAT",
    DELIVERY = "DELIVERY",
    MINING = "MINING",
    ISOLATED_MARGIN = "ISOLATED_MARGIN",
    FUNDING = "FUNDING",
    MOTHER_SPOT = "MOTHER_SPOT",
    OPTION = "OPTION",
    SUB_SPOT = "SUB_SPOT",
    SUB_MARGIN = "SUB_MARGIN",
    CROSS_MARGIN = "CROSS_MARGIN"
}
declare enum DepositHistory {
    Pending = 0,
    CreditedButCannotWithdraw = 6,
    Success = 1
}
declare enum Direction {
    ADDITIONAL = "ADDITIONAL",
    REDUCED = "REDUCED"
}
declare enum DualInvestmentPurchaseStatus {
    PENDING = "PENDING",
    PURCHASE_SUCCESS = "PURCHASE_SUCCESS",
    SETTLED = "SETTLED",
    PURCHASE_FAIL = "PURCHASE_FAIL",
    REFUNDING = "REFUNDING",
    REFUND_SUCCESS = "REFUND_SUCCESS",
    SETTLING = "SETTLING"
}
declare enum Featured {
    ALL = "ALL",
    TRUE = "TRUE"
}
declare enum FixedAndActivityProductType {
    ACTIVITY = "ACTIVITY",
    CUSTOMIZED_FIXED = "CUSTOMIZED_FIXED"
}
declare enum FlexibleProductStatus {
    ALL = "ALL",
    SUBSCRIBABLE = "SUBSCRIBABLE",
    UNSUBSCRIBABLE = "UNSUBSCRIBABLE"
}
declare enum FlexibleProductType {
    FAST = "FAST",
    NORMAL = "NORMAL"
}
declare enum FromAccountType {
    SPOT = "SPOT",
    USDT_FUTURE = "USDT_FUTURE",
    COIN_FUTURE = "COIN_FUTURE",
    MARGIN = "MARGIN",
    ISOLATED_MARGIN = "ISOLATED_MARGIN"
}
declare enum FuturesType {
    USDTMarginedFutures = 1,
    COINMarginedFutures = 2
}
declare enum FuturesTransferType {
    TransferFromSubaccountSpotAccountToItsUSDT = 1,
    TransferFromSubaccountUSDT = 2,
    TransferFromSubaccountSpotAccountToItsCOIN = 3,
    TransferFromSubaccountCOIN = 4
}
declare enum DustAccountType {
    SPOT = "SPOT",
    MARGIN = "MARGIN"
}
declare enum GetCrossMargingTransferHistoryType {
    ROLL_IN = "ROLL_IN",
    ROLL_OUT = "ROLL_OUT"
}
declare enum HisrecStatus {
    Pending = 0,
    CreditedButCannotWithdraw = 6,
    Success = 1
}
declare enum HistoryStatus {
    EmailSent = 0,
    Cancelled = 1,
    AwaitingApproval = 2,
    Rejected = 3,
    Processing = 4,
    Failure = 5,
    Completed = 6
}
declare enum IncomeType {
    borrowIn = "borrowIn",
    collateralSpent = "collateralSpent",
    repayAmount = "repayAmount",
    collateralReturn = "collateralReturn",
    addCollateral = "addCollateral",
    removeCollateral = "removeCollateral",
    collateralReturnAfterLiquidation = "collateralReturnAfterLiquidation"
}
declare enum InterestBNBBurn {
    true = "true",
    false = "false"
}
declare enum Interval {
    '1s' = "1s",
    '1m' = "1m",
    '3m' = "3m",
    '5m' = "5m",
    '15m' = "15m",
    '30m' = "30m",
    '1h' = "1h",
    '2h' = "2h",
    '4h' = "4h",
    '6h' = "6h",
    '8h' = "8h",
    '12h' = "12h",
    '1d' = "1d",
    '3d' = "3d",
    '1w' = "1w",
    '1M' = "1M"
}
declare enum IsFreeze {
    true = "true",
    false = "false"
}
declare enum IsIsolatedMargin {
    TRUE = "TRUE",
    FALSE = "FALSE"
}
declare enum LendingType {
    DAILY = "DAILY",
    ACTIVITY = "ACTIVITY",
    CUSTOMIZED_FIXED = "CUSTOMIZED_FIXED"
}
declare enum LiquidityAddType {
    SINGLE = "SINGLE",
    COMBINATION = "COMBINATION"
}
declare enum LiquidityRemoveType {
    SINGLE = "SINGLE",
    COMBINATION = "COMBINATION"
}
declare enum LogLevel {
    NONE = "",
    DEBUG = "debug",
    INFO = "info",
    WARN = "warn",
    ERROR = "error"
}
declare enum MarginBorrowRepayType {
    BORROW = "BORROW",
    REPAY = "REPAY"
}
declare enum MargintransferType {
    TransferFromMainAccountToMarginAccount = 1,
    TransferFromMarginAccountToMainAccount = 2
}
declare enum MarginTransferType {
    ROLL_IN = "ROLL_IN",
    ROLL_OUT = "ROLL_OUT"
}
declare enum MarginStatus {
    CONFIRMED = "CONFIRMED",
    PENDING = "PENDING",
    FAILED = "FAILED"
}
declare enum MarginInterestHistory {
    PERIODIC = "PERIODIC",
    ON_BORROW = "ON_BORROW",
    PERIODIC_CONVERTED = "PERIODIC_CONVERTED",
    ON_BORROW_CONVERTED = "ON_BORROW_CONVERTED",
    PORTFOLIO = "PORTFOLIO"
}
declare enum MarginArchive {
    true = "true",
    false = "false"
}
declare enum MarginLevelStatus {
    EXCESSIVE = "EXCESSIVE",
    NORMAL = "NORMAL",
    MARGIN_CALL = "MARGIN_CALL",
    PRE_LIQUIDATION = "PRE_LIQUIDATION",
    FORCE_LIQUIDATION = "FORCE_LIQUIDATION"
}
declare enum MarginSubAccountTransferType {
    TransferFromSubaccountSpotAccountToMarginAccount = 1,
    TransferFromSubaccountMarginAccountToItsSpotAccount = 2
}
declare enum NeedBtcValuation {
    true = "true",
    false = "false"
}
declare enum NewOrderRespType {
    ACK = "ACK",
    RESULT = "RESULT",
    FULL = "FULL"
}
declare enum NewOrderResult {
    SUCCESS = "SUCCESS",
    FAILURE = "FAILURE",
    NOT_ATTEMPTED = "NOT_ATTEMPTED"
}
declare enum OrderListOrderStatus {
    EXECUTING = "EXECUTING",
    ALL_DONE = "ALL_DONE",
    REJECT = "REJECT"
}
declare enum OrderListAboveBelowType {
    STOP_LOSS_LIMIT = "STOP_LOSS_LIMIT",
    STOP_LOSS = "STOP_LOSS",
    LIMIT_MAKER = "LIMIT_MAKER"
}
declare enum OcoNewOrderRespType {
    ACK = "ACK",
    RESULT = "RESULT",
    FULL = "FULL"
}
declare enum OrderListStatusType {
    RESPONSE = "RESPONSE",
    EXEC_STARTED = "EXEC_STARTED",
    ALL_DONE = "ALL_DONE"
}
declare enum Operation {
    ADD = "ADD",
    REMOVE = "REMOVE"
}
declare enum OptionalFixedAndActivityProductStatus {
    ALL = "ALL",
    SUBSCRIBABLE = "SUBSCRIBABLE",
    UNSUBSCRIBABLE = "UNSUBSCRIBABLE"
}
declare enum OptionalFlexibleProductStatus {
    ALL = "ALL",
    SUBSCRIBABLE = "SUBSCRIBABLE",
    UNSUBSCRIBABLE = "UNSUBSCRIBABLE"
}
declare enum OptionalSide {
    SELL = "SELL",
    BUY = "BUY"
}
declare enum OptionalTransFrom {
    SPOT = "SPOT",
    ISOLATED_MARGIN = "ISOLATED_MARGIN"
}
declare enum OptionalTransTo {
    SPOT = "SPOT",
    ISOLATED_MARGIN = "ISOLATED_MARGIN"
}
declare enum OptionType {
    CALL = "CALL",
    PUT = "PUT"
}
declare enum OrderStatus {
    NEW = "NEW",
    PENDING_NEW = "PENDING_NEW",
    PARTIALLY_FILLED = "PARTIALLY_FILLED",
    FILLED = "FILLED",
    CANCELED = "CANCELED",
    PENDING_CANCEL = "PENDING_CANCEL",
    REJECTED = "REJECTED",
    EXPIRED = "EXPIRED",
    EXPIRED_IN_MATCH = "EXPIRED_IN_MATCH"
}
declare enum OrderType {
    LIMIT = "LIMIT",
    MARKET = "MARKET",
    STOP_LOSS = "STOP_LOSS",
    STOP_LOSS_LIMIT = "STOP_LOSS_LIMIT",
    TAKE_PROFIT = "TAKE_PROFIT",
    TAKE_PROFIT_LIMIT = "TAKE_PROFIT_LIMIT",
    LIMIT_MAKER = "LIMIT_MAKER"
}
declare enum OtoPendingType {
    LIMIT = "LIMIT",
    STOP_LOSS = "STOP_LOSS",
    TAKE_PROFIT = "TAKE_PROFIT",
    STOP_LOSS_LIMIT = "STOP_LOSS_LIMIT",
    TAKE_PROFIT_LIMIT = "TAKE_PROFIT_LIMIT"
}
declare enum OrderListWorkingType {
    LIMIT = "LIMIT",
    LIMIT_MAKER = "LIMIT_MAKER"
}
declare enum Permissions {
    SPOT = "SPOT",
    MARGIN = "MARGIN",
    LEVERAGED = "LEVERAGED",
    TRD_GRP_002 = "TRD_GRP_002",
    TRD_GRP_003 = "TRD_GRP_003",
    TRD_GRP_004 = "TRD_GRP_004",
    TRD_GRP_005 = "TRD_GRP_005",
    TRD_GRP_006 = "TRD_GRP_006",
    TRD_GRP_007 = "TRD_GRP_007",
    TRD_GRP_008 = "TRD_GRP_008",
    TRD_GRP_009 = "TRD_GRP_009",
    TRD_GRP_010 = "TRD_GRP_010",
    TRD_GRP_011 = "TRD_GRP_011",
    TRD_GRP_012 = "TRD_GRP_012",
    TRD_GRP_013 = "TRD_GRP_013"
}
declare enum PortfolioAccountStatus {
    NORMAL = "NORMAL",
    MARGIN_CALL = "MARGIN_CALL",
    SUPPLY_MARGIN = "SUPPLY_MARGIN",
    REDUCE_ONLY = "REDUCE_ONLY",
    ACTIVE_LIQUIDATION = "ACTIVE_LIQUIDATION",
    FORCE_LIQUIDATION = "FORCE_LIQUIDATION",
    BANKRUPTED = "BANKRUPTED"
}
declare enum PortfolioAccountType {
    PM_1 = "PM_1",
    PM_2 = "PM_2",
    PM_3 = "PM_3"
}
declare enum PortfolioMarginFrom {
    SPOT = "SPOT",
    MARGIN = "MARGIN"
}
declare enum PositionSide {
    BOTH = "BOTH",
    LONG = "LONG",
    SHORT = "SHORT"
}
declare enum PositionStatus {
    HOLDING = "HOLDING",
    REDEEMED = "REDEEMED"
}
declare enum QuerySubAccountList {
    true = "true",
    false = "false"
}
declare enum RemoveLiquidityPreviewType {
    SINGLE = "SINGLE",
    COMBINATION = "COMBINATION"
}
declare enum RedeemDestAccount {
    SPOT = "SPOT",
    FUND = "FUND",
    ALL = "ALL"
}
declare enum RedeemOption {
    SPOT = "SPOT",
    FLEXIBLE = "FLEXIBLE"
}
declare enum SelfTradePreventionMode {
    EXPIRE_TAKER = "EXPIRE_TAKER",
    EXPIRE_MAKER = "EXPIRE_MAKER",
    EXPIRE_BOTH = "EXPIRE_BOTH",
    NONE = "NONE"
}
declare enum Side {
    SELL = "SELL",
    BUY = "BUY"
}
declare enum SideEffectType {
    NO_SIDE_EFFECT = "NO_SIDE_EFFECT",
    MARGIN_BUY = "MARGIN_BUY",
    AUTO_REPAY = "AUTO_REPAY",
    AUTO_BORROW_REPAY = "AUTO_BORROW_REPAY"
}
declare enum SimpleEarnDestAccount {
    SPOT = "SPOT",
    FUNDING = "FUNDING"
}
declare enum SimpleEarnFlexibleRewards {
    BONUS = "BONUS",
    REALTIME = "REALTIME",
    REWARDS = "REWARDS"
}
declare enum SimpleEarnLockedRedemption {
    MATURE = "MATURE",
    NEW_TRANSFERRED = "NEW_TRANSFERRED",
    AHEAD = "AHEAD"
}
declare enum SimpleEarnSourceAccount {
    SPOT = "SPOT",
    FUNDING = "FUNDING",
    SPOTANDFUNDING = "SPOTANDFUNDING"
}
declare enum SimpleEarnStatus {
    SUCCESS = "SUCCESS",
    PURCHASING = "PURCHASING",
    FAILED = "FAILED"
}
declare enum SimpleEarnType {
    AUTO = "AUTO",
    NORMAL = "NORMAL",
    CONVERT = "CONVERT",
    LOAN = "LOAN",
    AI = "AI",
    TRANSFER = "TRANSFER"
}
declare enum SortBy {
    START_TIME = "START_TIME",
    LOT_SIZE = "LOT_SIZE",
    INTEREST_RATE = "INTEREST_RATE",
    DURATION = "DURATION"
}
declare enum SpotBNBBurn {
    true = "true",
    false = "false"
}
declare enum StopLimitTimeInForce {
    GTC = "GTC",
    FOK = "FOK",
    IOC = "IOC"
}
declare enum SubAccountStatus {
    SUCCESS = "SUCCESS",
    PROCESS = "PROCESS",
    FAILURE = "FAILURE"
}
declare enum SubAccountTransferLog {
    SPOT = "SPOT",
    USDT_FUTURE = "USDT_FUTURE",
    COIN_FUTURE = "COIN_FUTURE",
    MARGIN = "MARGIN",
    ISOLATED_MARGIN = "ISOLATED_MARGIN"
}
declare enum SubscribeSourceAccount {
    SPOT = "SPOT",
    FUND = "FUND",
    ALL = "ALL"
}
declare enum SubUserHistoryType {
    TransferIn = 1,
    TransferOut = 2
}
declare enum SwapStatus {
    PendingForSwap = 0,
    Success = 1,
    Failed = 2
}
declare enum SymbolStatus {
    TRADING = "TRADING",
    HALT = "HALT",
    BREAK = "BREAK "
}
declare enum TimeInForce {
    GTC = "GTC",
    IOC = "IOC",
    FOK = "FOK"
}
declare enum ToAccountType {
    SPOT = "SPOT",
    USDT_FUTURE = "USDT_FUTURE",
    COIN_FUTURE = "COIN_FUTURE",
    MARGIN = "MARGIN",
    ISOLATED_MARGIN = "ISOLATED_MARGIN"
}
declare enum TradeType {
    BUY = "BUY",
    SELL = "SELL"
}
declare enum TransFrom {
    SPOT = "SPOT",
    ISOLATED_MARGIN = "ISOLATED_MARGIN"
}
declare enum TransferSide {
    TO_UM = "TO_UM",
    FROM_UM = "FROM_UM"
}
declare enum TransTo {
    SPOT = "SPOT",
    ISOLATED_MARGIN = "ISOLATED_MARGIN"
}
declare enum TransactionType {
    Deposit = "0",
    Withdraw = "1"
}
declare enum UnivStatus {
    CONFIRMED = "CONFIRMED",
    PENDING = "PENDING",
    FAILED = "FAILED"
}
declare enum UnivTransferType {
    MAIN_MARGIN = "MAIN_MARGIN",
    CMFUTURE_MAIN = "CMFUTURE_MAIN",
    MARGIN_MAIN = "MARGIN_MAIN",
    ISOLATEDMARGIN_MARGIN = "ISOLATEDMARGIN_MARGIN",
    MARGIN_ISOLATEDMARGIN = "MARGIN_ISOLATEDMARGIN",
    ISOLATEDMARGIN_ISOLATEDMARGIN = "ISOLATEDMARGIN_ISOLATEDMARGIN",
    MARGIN_FUNDING = "MARGIN_FUNDING",
    FUNDING_MARGIN = "FUNDING_MARGIN",
    OPTION_MAIN = "OPTION_MAIN",
    MARGIN_OPTION = "MARGIN_OPTION",
    OPTION_MARGIN = "OPTION_MARGIN",
    FUNDING_OPTION = "FUNDING_OPTION",
    OPTION_FUNDING = "OPTION_FUNDING",
    MAIN_PORTFOLIO_MARGIN = "MAIN_PORTFOLIO_MARGIN",
    PORTFOLIO_MARGIN_MAIN = "PORTFOLIO_MARGIN_MAIN",
    MAIN_ISOLATED_MARGIN = "MAIN_ISOLATED_MARGIN",
    ISOLATED_MARGIN_MAIN = "ISOLATED_MARGIN_MAIN",
    MAIN_FUNDING = "MAIN_FUNDING",
    FUNDING_MAIN = "FUNDING_MAIN"
}
declare enum Urgency {
    LOW = "LOW",
    MEDIUM = "MEDIUM",
    HIGH = "HIGH"
}
declare enum ValidTime {
    '10s' = "10s",
    '30s' = "30s",
    '1m' = "1m",
    '2m' = "2m"
}
declare enum WalletType {
    SPOT = "SPOT",
    FUNDING = "FUNDING"
}
declare enum WithdrawHistory {
    EmailSent = 0,
    Cancelled = 1,
    AwaitingApproval = 2,
    Rejected = 3,
    Processing = 4,
    Failure = 5,
    Completed = 6
}
declare enum WorkingFloor {
    EXCHANGE = "EXCHANGE",
    SOR = "SOR"
}

interface listAllConvertPairsOptions {
    fromAsset?: string;
    toAsset?: string;
    recvWindow?: number;
}
interface listAllConvertPairsResponse {
    fromAsset: string;
    toAsset: string;
    fromAssetMinAmount: string;
    fromAssetMaxAmount: string;
    toAssetMinAmount: string;
    toAssetMaxAmount: string;
}
interface getOrderQuantityPrecisionPerAssetOptions {
    recvWindow?: number;
}
interface getOrderQuantityPrecisionPerAssetResponse {
    asset: string;
    fraction: number;
}
interface sendQuoteRequestOptions {
    fromAmount?: number;
    toAmount?: number;
    walletType?: WalletType;
    validTime?: ValidTime;
    recvWindow?: number;
}
interface sendQuoteRequestResponse {
    quoteId: string;
    ratio: string;
    inverseRatio: string;
    validTimestamp: number;
    toAmount: string;
    fromAmount: string;
}
interface acceptQuoteOptions {
    recvWindow?: number;
}
interface acceptQuoteResponse {
    orderId: string;
    createTime: number;
    orderStatus: ConvertOrderStatus;
}
interface orderStatusOptions {
    orderId?: string;
    quoteId?: string;
    recvWindow?: number;
}
interface orderStatusResponse {
    orderId: bigint;
    orderStatus: ConvertOrderStatus;
    fromAsset: string;
    fromAmount: string;
    toAsset: string;
    toAmount: string;
    ratio: string;
    inverseRatio: string;
    createTime: number;
}
interface getConvertTradeHistoryOptions {
    limit?: number;
    recvWindow?: number;
}
interface getConvertTradeHistoryResponse {
    list: getConvertTradeHistoryList[];
    startTime: number;
    endTime: number;
    limit: number;
    moreData: boolean;
}
interface getConvertTradeHistoryList {
    quoteId: string;
    orderId: bigint;
    orderStatus: string;
    fromAsset: string;
    fromAmount: string;
    toAsset: string;
    toAmount: string;
    ratio: string;
    inverseRatio: string;
    createTime: number;
}
interface queryLimitOpenOrdersOptions {
    recvWindow?: number;
}
interface queryLimitOpenOrdersResponse {
    list: queryLimitOpenOrdersList[];
}
interface queryLimitOpenOrdersList {
    quoteId: string;
    orderId: number;
    orderStatus: ConvertOrderStatus;
    fromAsset: string;
    fromAmount: string;
    toAsset: string;
    toAmount: string;
    ratio: string;
    inverseRatio: string;
    createTime: number;
    expiredTimestamp: number;
}
interface placeLimitOrderOptions {
    baseAmount?: number;
    quoteAmount?: number;
    walletType?: WalletType;
    recvWindow?: number;
}
interface placeLimitOrderResponse {
    orderId: number;
    status: string;
}
interface cancelLimitOrderOptions {
    recvWindow?: number;
}
interface cancelLimitOrderResponse {
    orderId: number;
    status: string;
}

type types$c_acceptQuoteOptions = acceptQuoteOptions;
type types$c_acceptQuoteResponse = acceptQuoteResponse;
type types$c_cancelLimitOrderOptions = cancelLimitOrderOptions;
type types$c_cancelLimitOrderResponse = cancelLimitOrderResponse;
type types$c_getConvertTradeHistoryList = getConvertTradeHistoryList;
type types$c_getConvertTradeHistoryOptions = getConvertTradeHistoryOptions;
type types$c_getConvertTradeHistoryResponse = getConvertTradeHistoryResponse;
type types$c_getOrderQuantityPrecisionPerAssetOptions = getOrderQuantityPrecisionPerAssetOptions;
type types$c_getOrderQuantityPrecisionPerAssetResponse = getOrderQuantityPrecisionPerAssetResponse;
type types$c_listAllConvertPairsOptions = listAllConvertPairsOptions;
type types$c_listAllConvertPairsResponse = listAllConvertPairsResponse;
type types$c_orderStatusOptions = orderStatusOptions;
type types$c_orderStatusResponse = orderStatusResponse;
type types$c_placeLimitOrderOptions = placeLimitOrderOptions;
type types$c_placeLimitOrderResponse = placeLimitOrderResponse;
type types$c_queryLimitOpenOrdersList = queryLimitOpenOrdersList;
type types$c_queryLimitOpenOrdersOptions = queryLimitOpenOrdersOptions;
type types$c_queryLimitOpenOrdersResponse = queryLimitOpenOrdersResponse;
type types$c_sendQuoteRequestOptions = sendQuoteRequestOptions;
type types$c_sendQuoteRequestResponse = sendQuoteRequestResponse;
declare namespace types$c {
  export {
    types$c_acceptQuoteOptions as acceptQuoteOptions,
    types$c_acceptQuoteResponse as acceptQuoteResponse,
    types$c_cancelLimitOrderOptions as cancelLimitOrderOptions,
    types$c_cancelLimitOrderResponse as cancelLimitOrderResponse,
    types$c_getConvertTradeHistoryList as getConvertTradeHistoryList,
    types$c_getConvertTradeHistoryOptions as getConvertTradeHistoryOptions,
    types$c_getConvertTradeHistoryResponse as getConvertTradeHistoryResponse,
    types$c_getOrderQuantityPrecisionPerAssetOptions as getOrderQuantityPrecisionPerAssetOptions,
    types$c_getOrderQuantityPrecisionPerAssetResponse as getOrderQuantityPrecisionPerAssetResponse,
    types$c_listAllConvertPairsOptions as listAllConvertPairsOptions,
    types$c_listAllConvertPairsResponse as listAllConvertPairsResponse,
    types$c_orderStatusOptions as orderStatusOptions,
    types$c_orderStatusResponse as orderStatusResponse,
    types$c_placeLimitOrderOptions as placeLimitOrderOptions,
    types$c_placeLimitOrderResponse as placeLimitOrderResponse,
    types$c_queryLimitOpenOrdersList as queryLimitOpenOrdersList,
    types$c_queryLimitOpenOrdersOptions as queryLimitOpenOrdersOptions,
    types$c_queryLimitOpenOrdersResponse as queryLimitOpenOrdersResponse,
    types$c_sendQuoteRequestOptions as sendQuoteRequestOptions,
    types$c_sendQuoteRequestResponse as sendQuoteRequestResponse,
  };
}

interface DualInvestmentMethods$1 {
    getDualInvestmentProductList(optionType: OptionType, exercisedCoin: string, investCoin: string, options?: getDualInvestmentProductListOptions): Promise<getDualInvestmentProductListResponse>;
    subscribeDualInvestmentProducts(id: string, orderId: string, depositAmount: number, autoCompoundPlan: AutoCompoundPlan, options?: subscribeDualInvestmentProductsOptions): Promise<subscribeDualInvestmentProductsResponse>;
    getDualInvestmentPositions(options?: getDualInvestmentPositionsOptions): Promise<getDualInvestmentPositionsResponse>;
    checkDualInvestmentAccounts(options?: checkDualInvestmentAccountsOptions): Promise<checkDualInvestmentAccountsResponse>;
    changeAutoCompoundStatus(positionId: number, autoCompoundPlan: AutoCompoundPlan, options?: changeAutoCompoundStatusOptions): Promise<changeAutoCompoundStatusResponse>;
}
interface getDualInvestmentProductListOptions {
    pageSize?: number;
    pageIndex?: number;
    recvWindow?: number;
}
interface getDualInvestmentProductListResponse {
    total: number;
    list: getDualInvestmentProductListList[];
}
interface getDualInvestmentProductListList {
    id: string;
    investCoin: string;
    exercisedCoin: string;
    strikePrice: string;
    duration: number;
    settleDate: number;
    purchaseDecimal: number;
    purchaseEndTime: number;
    canPurchase: boolean;
    apr: string;
    orderId: number;
    minAmount: string;
    maxAmount: string;
    createTimestamp: number;
    optionType: OptionType;
    isAutoCompoundEnable: boolean;
    autoCompoundPlanList: AutoCompoundPlan[];
}
interface subscribeDualInvestmentProductsOptions {
    recvWindow?: number;
}
interface subscribeDualInvestmentProductsResponse {
    positionId: number;
    investCoin: string;
    exercisedCoin: string;
    subscriptionAmount: string;
    duration: number;
    autoCompoundPlan: AutoCompoundPlan;
    strikePrice: string;
    settleDate: number;
    purchaseStatus: DualInvestmentPurchaseStatus;
    apr: string;
    orderId: number;
    purchaseTime: number;
    optionType: OptionType;
}
interface getDualInvestmentPositionsOptions {
    status?: DualInvestmentPurchaseStatus;
    pageSize?: number;
    pageIndex?: number;
    recvWindow?: number;
}
interface getDualInvestmentPositionsResponse {
    total: number;
    list: getDualInvestmentPositionsList[];
}
interface getDualInvestmentPositionsList {
    id: string;
    investCoin: string;
    exercisedCoin: string;
    subscriptionAmount: string;
    strikePrice: string;
    duration: number;
    settleDate: number;
    purchaseStatus: DualInvestmentPurchaseStatus;
    apr: string;
    orderId: number;
    purchaseEndTime: number;
    optionType: OptionType;
    autoCompoundPlan: AutoCompoundPlan;
}
interface checkDualInvestmentAccountsOptions {
    recvWindow?: number;
}
interface checkDualInvestmentAccountsResponse {
    totalAmountInBTC: string;
    totalAmountInUSDT: string;
}
interface changeAutoCompoundStatusOptions {
    recvWindow?: number;
}
interface changeAutoCompoundStatusResponse {
    positionId: string;
    autoCompoundPlan: AutoCompoundPlan;
}

type types$b_changeAutoCompoundStatusOptions = changeAutoCompoundStatusOptions;
type types$b_changeAutoCompoundStatusResponse = changeAutoCompoundStatusResponse;
type types$b_checkDualInvestmentAccountsOptions = checkDualInvestmentAccountsOptions;
type types$b_checkDualInvestmentAccountsResponse = checkDualInvestmentAccountsResponse;
type types$b_getDualInvestmentPositionsOptions = getDualInvestmentPositionsOptions;
type types$b_getDualInvestmentPositionsResponse = getDualInvestmentPositionsResponse;
type types$b_getDualInvestmentProductListOptions = getDualInvestmentProductListOptions;
type types$b_getDualInvestmentProductListResponse = getDualInvestmentProductListResponse;
type types$b_subscribeDualInvestmentProductsOptions = subscribeDualInvestmentProductsOptions;
type types$b_subscribeDualInvestmentProductsResponse = subscribeDualInvestmentProductsResponse;
declare namespace types$b {
  export {
    DualInvestmentMethods$1 as DualInvestmentMethods,
    types$b_changeAutoCompoundStatusOptions as changeAutoCompoundStatusOptions,
    types$b_changeAutoCompoundStatusResponse as changeAutoCompoundStatusResponse,
    types$b_checkDualInvestmentAccountsOptions as checkDualInvestmentAccountsOptions,
    types$b_checkDualInvestmentAccountsResponse as checkDualInvestmentAccountsResponse,
    types$b_getDualInvestmentPositionsOptions as getDualInvestmentPositionsOptions,
    types$b_getDualInvestmentPositionsResponse as getDualInvestmentPositionsResponse,
    types$b_getDualInvestmentProductListOptions as getDualInvestmentProductListOptions,
    types$b_getDualInvestmentProductListResponse as getDualInvestmentProductListResponse,
    types$b_subscribeDualInvestmentProductsOptions as subscribeDualInvestmentProductsOptions,
    types$b_subscribeDualInvestmentProductsResponse as subscribeDualInvestmentProductsResponse,
  };
}

interface getAllMarginAssetsOptions {
    asset?: string;
}
interface getAllMarginAssetsResponse {
    assetFullName: string;
    assetName: string;
    isBorrowable: boolean;
    isMortgageable: boolean;
    userMinBorrow: string;
    userMinRepay: string;
    delistTime: number;
}
interface getAllCrossMarginPairsOptions {
    symbol?: string;
}
interface getAllCrossMarginPairsResponse {
    base: string;
    id: bigint;
    isBuyAllowed: boolean;
    isMarginTrade: boolean;
    isSellAllowed: boolean;
    quote: string;
    symbol: string;
    delistTime?: number;
}
interface getMarginPriceIndexResponse {
    calcTime: number;
    price: string;
    symbol: string;
}
interface marginAccountNewOrderOptions {
    isIsolated?: IsIsolatedMargin;
    quantity?: number;
    quoteOrderQty?: number;
    price?: number;
    stopPrice?: number;
    newClientOrderId?: string;
    icebergQty?: number;
    newOrderRespType?: NewOrderRespType;
    sideEffectType?: SideEffectType;
    timeInForce?: TimeInForce;
    selfTradePreventionMode?: SelfTradePreventionMode;
    autoRepayAtCancel?: boolean;
    recvWindow?: number;
}
interface marginAccountNewOrderResponse {
    symbol: string;
    orderId: number;
    clientOrderId: string;
    isIsolated: boolean;
    transactTime: number;
    price?: string;
    origQty?: string;
    executedQty?: string;
    cummulativeQuoteQty?: string;
    status?: OrderStatus;
    timeInForce?: TimeInForce;
    type?: OrderType;
    side?: Side;
    selfTradePreventionMode?: SelfTradePreventionMode;
    fills?: marginAccountNewOrderFills[];
}
interface marginAccountNewOrderFills {
    price: string;
    qty: string;
    commission: string;
    commissionAsset: string;
}
interface marginAccountCancelOrderOptions {
    isIsolated?: IsIsolatedMargin;
    orderId?: number;
    origClientOrderId?: string;
    newClientOrderId?: string;
    recvWindow?: number;
}
interface marginAccountCancelOrderResponse {
    symbol: string;
    isIsolated: boolean;
    orderId: number;
    origClientOrderId: string;
    clientOrderId: string;
    price: string;
    origQty: string;
    executedQty: string;
    cummulativeQuoteQty: string;
    status: OrderStatus;
    timeInForce: TimeInForce;
    type: OrderType;
    side: Side;
}
interface marginAccountCancelAllOpenOrdersOnASymbolOptions {
    isIsolated?: IsIsolatedMargin;
    recvWindow?: number;
}
interface marginAccountCancelAllOpenOrdersOnASymbolResponse {
    symbol: string;
    isIsolated: boolean;
    origClientOrderId: string;
    orderId: number;
    orderListId: number;
    clientOrderId: string;
    price: string;
    origQty: string;
    executedQty: string;
    cummulativeQuoteQty: string;
    status: OrderStatus;
    timeInForce: TimeInForce;
    type: OrderType;
    side: Side;
    selfTradePreventionMode: SelfTradePreventionMode;
}
interface adjustCrossMarginMaxLeverageResponse {
    success: boolean;
}
interface getCrossMarginTransferHistoryOptions {
    asset?: string;
    type?: GetCrossMargingTransferHistoryType;
    startTime?: number;
    endTime?: number;
    current?: number;
    size?: number;
    isolatedSymbol?: string;
    archived?: MarginArchive;
    recvWindow?: number;
}
interface getCrossMarginTransferHistoryResponse {
    rows: getCrossMarginTransferHistoryRows[];
    total: number;
}
interface getCrossMarginTransferHistoryRows {
    amount: string;
    asset: string;
    status: MarginStatus;
    timestamp: number;
    txId: number;
    type: GetCrossMargingTransferHistoryType;
    transFrom?: CrossMarginTrans;
    transTo?: CrossMarginTrans;
    fromSymbol?: string;
    toSymbol?: string;
}
interface getInterestHistoryOptions {
    asset?: string;
    isolatedSymbol?: string;
    startTime?: number;
    endTime?: number;
    current?: number;
    size?: number;
    archived?: MarginArchive;
    recvWindow?: number;
}
interface getInterestHistoryResponse {
    rows: getInterestHistoryRows[];
    total: number;
}
interface getInterestHistoryRows {
    txId: bigint;
    interestAccuredTime: number;
    asset: string;
    rawAsset: string;
    principal: string;
    interest: string;
    interestRate: string;
    type: MarginInterestHistory;
    isolatedSymbol: string;
}
interface getForceLiquidationRecordOptions {
    startTime?: number;
    endTime?: number;
    isolatedSymbol?: string;
    current?: number;
    size?: number;
    recvWindow?: number;
}
interface getForceLiquidationRecordResponse {
    rows: getForceLiquidationRecordRows[];
    total: number;
}
interface getForceLiquidationRecordRows {
    avgPrice: string;
    executedQty: string;
    orderId: number;
    price: string;
    qty: string;
    side: Side;
    symbol: string;
    timeInForce: TimeInForce;
    isIsolated: boolean;
    updatedTime: number;
}
interface getCrossMarginAccountDetailsOptions {
    recvWindow?: number;
}
interface getCrossMarginAccountDetailsResponse {
    created: boolean;
    borrowEnabled: boolean;
    marginLevel: string;
    collateralMarginLevel: string;
    totalAssetOfBtc: string;
    totalLiabilityOfBtc: string;
    totalNetAssetOfBtc: string;
    TotalCollateralValueInUSDT: string;
    tradeEnabled: boolean;
    transferInEnabled: boolean;
    transferOutEnabled: boolean;
    accountType: CrossMarginAccountType;
    userAssets: getCrossMarginAccountDetailsUserassets[];
}
interface getCrossMarginAccountDetailsUserassets {
    asset: string;
    borrowed: string;
    free: string;
    interest: string;
    locked: string;
    netAsset: string;
}
interface getMarginAccountOrderOptions {
    isIsolated?: IsIsolatedMargin;
    orderId?: number;
    origClientOrderId?: string;
    recvWindow?: number;
}
interface getMarginAccountOrderResponse {
    clientOrderId: string;
    cummulativeQuoteQty: string;
    executedQty: string;
    icebergQty: string;
    isWorking: boolean;
    orderId: number;
    origQty: string;
    price: string;
    side: Side;
    status: OrderStatus;
    stopPrice: string;
    symbol: string;
    isIsolated: boolean;
    time: number;
    timeInForce: TimeInForce;
    type: OrderType;
    selfTradePreventionMode: SelfTradePreventionMode;
    updateTime: number;
}
interface getMarginAccountOpenOrdersOptions {
    symbol?: string;
    isIsolated?: IsIsolatedMargin;
    recvWindow?: number;
}
interface getMarginAccountOpenOrdersResponse {
    clientOrderId: string;
    cummulativeQuoteQty: string;
    executedQty: string;
    icebergQty: string;
    isWorking: boolean;
    orderId: number;
    origQty: string;
    price: string;
    side: Side;
    status: OrderStatus;
    stopPrice: string;
    symbol: string;
    isIsolated: boolean;
    time: number;
    timeInForce: TimeInForce;
    type: OrderType;
    selfTradePreventionMode: SelfTradePreventionMode;
    updateTime: number;
}
interface getMarginAccountAllOrdersOptions {
    isIsolated?: IsIsolatedMargin;
    orderId?: number;
    startTime?: number;
    endTime?: number;
    limit?: number;
    recvWindow?: number;
}
interface getMarginAccountAllOrdersResponse {
    clientOrderId: string;
    cummulativeQuoteQty: string;
    executedQty: string;
    icebergQty: string;
    isWorking: boolean;
    orderId: number;
    origQty: string;
    price: string;
    side: Side;
    status: OrderStatus;
    stopPrice: string;
    symbol: string;
    isIsolated: boolean;
    time: number;
    timeInForce: TimeInForce;
    type: OrderType;
    selfTradePreventionMode: SelfTradePreventionMode;
    updateTime: number;
}
interface marginAccountNewOcoOptions {
    isIsolated?: IsIsolatedMargin;
    listClientOrderId?: string;
    limitClientOrderId?: string;
    limitIcebergQty?: number;
    stopClientOrderId?: string;
    stopLimitPrice?: number;
    stopIcebergQty?: number;
    stopLimitTimeInForce?: StopLimitTimeInForce;
    newOrderRespType?: NewOrderRespType;
    sideEffectType?: SideEffectType;
    selfTradePreventionMode?: SelfTradePreventionMode;
    autoRepayAtCancel?: boolean;
    recvWindow?: number;
}
interface marginAccountNewOcoResponse {
    orderListId: number;
    contingencyType: string;
    listStatusType: string;
    listOrderStatus: string;
    listClientOrderId: string;
    transactionTime: number;
    symbol: string;
    marginBuyBorrowAmount: string;
    marginBuyBorrowAsset: string;
    isIsolated: boolean;
    orders: marginAccountNewOcoOrders[];
    orderReports: marginAccountNewOcoOrderreports[];
}
interface marginAccountNewOcoOrders {
    symbol: string;
    orderId: number;
    clientOrderId: string;
}
interface marginAccountNewOcoOrderreports {
    symbol: string;
    orderId: number;
    orderListId: number;
    clientOrderId: string;
    transactTime: number;
    price: string;
    origQty: string;
    executedQty: string;
    cummulativeQuoteQty: string;
    status: OrderStatus;
    timeInForce: TimeInForce;
    type: OrderType;
    side: Side;
    stopPrice: string;
    selfTradePreventionMode: SelfTradePreventionMode;
}
interface marginAccountCancelOcoOptions {
    isIsolated?: IsIsolatedMargin;
    orderListId?: number;
    listClientOrderId?: string;
    newClientOrderId?: string;
    recvWindow?: number;
}
interface marginAccountCancelOcoResponse {
    orderListId: number;
    contingencyType: string;
    listStatusType: OrderListStatusType;
    listOrderStatus: OrderListOrderStatus;
    listClientOrderId: string;
    transactionTime: number;
    symbol: string;
    isIsolated: boolean;
    orders: marginAccountCancelOcoOrders[];
    orderReports: marginAccountCancelOcoOrderReports[];
}
interface marginAccountCancelOcoOrders {
    symbol: string;
    orderId: number;
    clientOrderId: string;
}
interface marginAccountCancelOcoOrderReports {
    symbol: string;
    origClientOrderId: string;
    orderId: number;
    orderListId: number;
    clientOrderId: string;
    price: string;
    origQty: string;
    executedQty: string;
    cummulativeQuoteQty: string;
    status: OrderStatus;
    timeInForce: TimeInForce;
    type: OrderType;
    side: Side;
    stopPrice: string;
    selfTradePreventionMode: SelfTradePreventionMode;
}
interface getMarginAccountOcoOptions {
    isIsolated?: IsIsolatedMargin;
    symbol?: string;
    orderListId?: number;
    origClientOrderId?: string;
    recvWindow?: number;
}
interface getMarginAccountOcoResponse {
    orderListId: number;
    contingencyType: string;
    listStatusType: OrderListStatusType;
    listOrderStatus: OrderListOrderStatus;
    listClientOrderId: string;
    transactionTime: number;
    symbol: string;
    isIsolated: boolean;
    orders: getMarginAccountOcoOrders[];
}
interface getMarginAccountOcoOrders {
    symbol: string;
    orderId: number;
    clientOrderId: string;
}
interface getMarginAccountAllOcoOptions {
    isIsolated?: IsIsolatedMargin;
    symbol?: string;
    fromId?: string;
    startTime?: number;
    endTime?: number;
    limit?: number;
    recvWindow?: number;
}
interface getMarginAccountAllOcoResponse {
    orderListId: number;
    contingencyType: string;
    listStatusType: OrderListStatusType;
    listOrderStatus: OrderListOrderStatus;
    listClientOrderId: string;
    transactionTime: number;
    symbol: string;
    isIsolated: boolean;
    orders: getMarginAccountAllOcoOrders[];
}
interface getMarginAccountAllOcoOrders {
    symbol: string;
    orderId: number;
    clientOrderId: string;
}
interface getMarginAccountOpenOcoOptions {
    isIsolated?: IsIsolatedMargin;
    symbol?: string;
    recvWindow?: number;
}
interface getMarginAccountOpenOcoResponse {
    orderListId: number;
    contingencyType: string;
    listStatusType: OrderListStatusType;
    listOrderStatus: OrderListOrderStatus;
    listClientOrderId: string;
    transactionTime: number;
    symbol: string;
    isIsolated: boolean;
    orders: getMarginAccountOpenOcoOrders[];
}
interface getMarginAccountOpenOcoOrders {
    symbol: string;
    orderId: number;
    clientOrderId: string;
}
interface getMarginAccountTradeListOptions {
    isIsolated?: IsIsolatedMargin;
    orderId?: number;
    startTime?: number;
    endTime?: number;
    fromId?: number;
    limit?: number;
    recvWindow?: number;
}
interface getMarginAccountTradeListResponse {
    commission: string;
    commissionAsset: string;
    id: number;
    isBestMatch: boolean;
    isBuyer: boolean;
    isMaker: boolean;
    orderId: number;
    price: string;
    qty: string;
    symbol: string;
    isIsolated: boolean;
    time: number;
}
interface getMaxBorrowOptions {
    isolatedSymbol?: string;
    recvWindow?: number;
}
interface getMaxBorrowResponse {
    amount: string;
    borrowLimit: string;
}
interface getMaxTransferoutAmountOptions {
    isolatedSymbol?: string;
    recvWindow?: number;
}
interface getMaxTransferoutAmountResponse {
    amount: string;
}
interface getSummaryOfMarginAccountOptions {
    recvWindow?: number;
}
interface getSummaryOfMarginAccountResponse {
    normalBar: string;
    marginCallBar: string;
    forceLiquidationBar: string;
}
interface getIsolatedMarginAccountInfoOptions {
    symbols?: string;
    recvWindow?: number;
}
interface getIsolatedMarginAccountInfoResponse {
    assets: getIsolatedMarginAccountInfoAssets[];
    totalAssetOfBtc?: string;
    totalLiabilityOfBtc?: string;
    totalNetAssetOfBtc?: string;
}
interface getIsolatedMarginAccountInfoBaseasset {
    asset: string;
    borrowEnabled: boolean;
    borrowed: string;
    free: string;
    interest: string;
    locked: string;
    netAsset: string;
    netAssetOfBtc: string;
    repayEnabled: boolean;
    totalAsset: string;
}
interface getIsolatedMarginAccountInfoQuoteasset {
    asset: string;
    borrowEnabled: boolean;
    borrowed: string;
    free: string;
    interest: string;
    locked: string;
    netAsset: string;
    netAssetOfBtc: string;
    repayEnabled: boolean;
    totalAsset: string;
}
interface getIsolatedMarginAccountInfoAssets {
    baseAsset: getIsolatedMarginAccountInfoBaseasset;
    quoteAsset: getIsolatedMarginAccountInfoQuoteasset;
    symbol: string;
    isolatedCreated: boolean;
    enabled: boolean;
    marginLevel: string;
    marginLevelStatus: MarginLevelStatus;
    marginRatio: string;
    indexPrice: string;
    liquidatePrice: string;
    liquidateRate: string;
    tradeEnabled: boolean;
}
interface disableIsolatedMarginAccountOptions {
    recvWindow?: number;
}
interface disableIsolatedMarginAccountResponse {
    success: boolean;
    symbol: string;
}
interface enableIsolatedMarginAccountOptions {
    recvWindow?: number;
}
interface enableIsolatedMarginAccountResponse {
    success: boolean;
    symbol: string;
}
interface getEnabledIsolatedMarginAccountLimitOptions {
    recvWindow?: number;
}
interface getEnabledIsolatedMarginAccountLimitResponse {
    enabledAccount: number;
    maxAccount: number;
}
interface getAllIsolatedMarginSymbolOptions {
    symbol?: string;
    recvWindow?: number;
}
interface getAllIsolatedMarginSymbolResponse {
    symbol: string;
    base: string;
    quote: string;
    isMarginTrade: boolean;
    isBuyAllowed: boolean;
    isSellAllowed: boolean;
}
interface toggleBnbBurnOnSpotTradeAndMarginInterestOptions {
    spotBNBBurn?: SpotBNBBurn;
    interestBNBBurn?: InterestBNBBurn;
    recvWindow?: number;
}
interface toggleBnbBurnOnSpotTradeAndMarginInterestResponse {
    spotBNBBurn: boolean;
    interestBNBBurn: boolean;
}
interface getBnbBurnStatusOptions {
    recvWindow?: number;
}
interface getBnbBurnStatusResponse {
    spotBNBBurn: boolean;
    interestBNBBurn: boolean;
}
interface marginInterestRateHistoryOptions {
    vipLevel?: number;
    startTime?: number;
    endTime?: number;
    recvWindow?: number;
}
interface marginInterestRateHistoryResponse {
    asset: string;
    dailyInterestRate: string;
    timestamp: number;
    vipLevel: number;
}
interface getCrossMarginFeeDataOptions {
    vipLevel?: number;
    coin?: string;
    recvWindow?: number;
}
interface getCrossMarginFeeDataResponse {
    vipLevel: number;
    coin: string;
    transferIn: boolean;
    borrowable: boolean;
    dailyInterest: string;
    yearlyInterest: string;
    borrowLimit: string;
    marginablePairs: string[];
}
interface getIsolatedMarginFeeDataOptions {
    vipLevel?: number;
    symbol?: string;
    recvWindow?: number;
}
interface getIsolatedMarginFeeDataResponse {
    vipLevel: number;
    symbol: string;
    leverage: string;
    data: getIsolatedMarginFeeDataData[];
}
interface getIsolatedMarginFeeDataData {
    coin: string;
    dailyInterest: string;
    borrowLimit: string;
}
interface getIsolatedMarginTierDataOptions {
    tier?: number;
    recvWindow?: number;
}
interface getIsolatedMarginTierDataResponse {
    symbol: string;
    tier: number;
    effectiveMultiple: string;
    initialRiskRatio: string;
    liquidationRiskRatio: string;
    baseAssetMaxBorrowable: string;
    quoteAssetMaxBorrowable: string;
}
interface getCurrentMarginOrderCountUsageOptions {
    isIsolated?: IsIsolatedMargin;
    symbol?: string;
    recvWindow?: number;
}
interface getCurrentMarginOrderCountUsageResponse {
    rateLimitType: string;
    interval: string;
    intervalNum: number;
    limit: number;
    count: number;
}
interface crossMarginCollateralRatioResponse {
    collaterals: crossMarginCollateralRatioCollaterals[];
    assetNames: string[];
}
interface crossMarginCollateralRatioCollaterals {
    minUsdValue: string;
    maxUsdValue?: string;
    discountRate: string;
}
interface getSmallLiabilityExchangeCoinListOptions {
    recvWindow?: number;
}
interface getSmallLiabilityExchangeCoinListResponse {
    asset: string;
    interest: string;
    principal: string;
    liabilityAsset: string;
    liabilityQty: string;
}
interface smallLiabilityExchangeOptions {
    assetNames?: string;
}
interface smallLiabilityExchangeResponse {
    asset: string;
    interest: string;
    principal: string;
    liabilityAsset: string;
    liabilityQty: string;
}
interface getSmallLiabilityExchangeHistoryOptions {
    startTime?: number;
    endTime?: number;
    recvWindow?: number;
}
interface getSmallLiabilityExchangeHistoryResponse {
    total: number;
    rows: getSmallLiabilityExchangeHistoryRows[];
}
interface getSmallLiabilityExchangeHistoryRows {
    asset: string;
    amount: string;
    targetAsset: string;
    targetAmount: string;
    bizType: string;
    timestamp: number;
}
interface getFutureHoulyInterestRateResponse {
    asset: string;
    nextHourlyInterestRate: string;
}
interface getTokensOrSymbolsDelistScheduleForCrossMarginAndIsolatedMarginOptions {
    recvWindow?: number;
}
interface getTokensOrSymbolsDelistScheduleForCrossMarginAndIsolatedMarginResponse {
    delistTime: number;
    crossMarginAssets: string[];
    isolatedMarginSymbols: string[];
}
interface getMarginAvailableInventoryOptions {
    recvWindow?: number;
}
interface getMarginAvailableInventoryResponse {
    assets: {
        [key: string]: string;
    };
    updateTime: number;
}
interface marginManualLiquidationOptions {
    symbol?: string;
    recvWindow?: number;
}
interface marginManualLiquidationResponse {
    asset: string;
    interest: string;
    principal: string;
    liabilityAsset: string;
    liabilityQty: number;
}
interface marginAccountNewOtoOptions {
    isIsolated?: string;
    listClientOrderId?: string;
    newOrderRespType?: NewOrderRespType;
    sideEffectType?: SideEffectType;
    selfTradePreventionMode?: string;
    autoRepayAtCancel?: boolean;
    workingClientOrderId?: string;
    workingIcebergQty?: number;
    workingTimeInForce?: TimeInForce;
    pendingClientOrderId?: string;
    pendingPrice?: number;
    pendingStopPrice?: number;
    pendingTrailingDelta?: number;
    pendingIcebergQty?: number;
    pendingTimeInForce?: TimeInForce;
    recvWindow?: number;
}
interface marginAccountNewOtoResponse {
    orderListId: number;
    contingencyType: string;
    listStatusType: OrderListStatusType;
    listOrderStatus: OrderListOrderStatus;
    listClientOrderId: string;
    transactionTime: number;
    symbol: string;
    isIsolated: boolean;
    orders: marginAccountOrders[];
    orderReports: marginAccountOrderReports[];
}
interface marginAccountOrders {
    symbol: string;
    orderId: number;
    clientOrderId: string;
}
interface marginAccountOrderReports {
    symbol: string;
    orderId: number;
    orderListId: number;
    clientOrderId: string;
    transactTime: number;
    price: string;
    origQty: string;
    executedQty: string;
    cummulativeQuoteQty: string;
    status: OrderStatus;
    timeInForce: TimeInForce;
    type: OrderType;
    side: Side;
    stopPrice?: string;
    selfTradePreventionMode: SelfTradePreventionMode;
}
interface marginAccountNewOtocoOptions {
    isIsolated?: string;
    sideEffectType?: SideEffectType;
    autoRepayAtCancel?: boolean;
    listClientOrderId?: string;
    newOrderRespType?: NewOrderRespType;
    selfTradePreventionMode?: string;
    workingClientOrderId?: string;
    workingIcebergQty?: number;
    workingTimeInForce?: TimeInForce;
    pendingAboveClientOrderId?: string;
    pendingAbovePrice?: number;
    pendingAboveStopPrice?: number;
    pendingAboveTrailingDelta?: number;
    pendingAboveIcebergQty?: number;
    pendingAboveTimeInForce?: TimeInForce;
    pendingBelowType?: OrderListAboveBelowType;
    pendingBelowClientOrderId?: string;
    pendingBelowPrice?: number;
    pendingBelowStopPrice?: number;
    pendingBelowTrailingDelta?: number;
    pendingBelowIcebergQty?: number;
    pendingBelowTimeInForce?: TimeInForce;
    recvWindow?: number;
}
interface marginAccountNewOtocoResponse {
    orderListId: number;
    contingencyType: string;
    listStatusType: OrderListStatusType;
    listOrderStatus: OrderListOrderStatus;
    listClientOrderId: string;
    transactionTime: number;
    symbol: string;
    isIsolated: boolean;
    orders: marginAccountOrders[];
    orderReports: marginAccountOrderReports[];
}
interface getLeverageBracketResponse {
    assetNames: string[];
    rank: number;
    brackets: leverageBracket[];
}
interface leverageBracket {
    leverage: number;
    maxDebt: number;
    maintenanceMarginRate: number;
    initialMarginRate: number;
    fastNum: number;
}
interface marginAccountBorrowRepayOptions {
    recvWindow?: number;
}
interface marginAccountBorrowRepayResponse {
    tranId: number;
}
interface getBorrowRepayRecordsOptions {
    asset?: string;
    isolatedSymbol?: string;
    txId?: number;
    startTime?: number;
    endTime?: number;
    current?: number;
    size?: number;
    recvWindow?: number;
}
interface getBorrowRepayRecordsResponse {
    rows: BorrowRepayRecordsRow[];
    total: number;
}
interface BorrowRepayRecordsRow {
    isolatedSymbol: string;
    amount: string;
    asset: string;
    interest: string;
    principal: string;
    status: MarginStatus;
    timestamp: number;
    txId: number;
}

type types$a_BorrowRepayRecordsRow = BorrowRepayRecordsRow;
type types$a_adjustCrossMarginMaxLeverageResponse = adjustCrossMarginMaxLeverageResponse;
type types$a_crossMarginCollateralRatioCollaterals = crossMarginCollateralRatioCollaterals;
type types$a_crossMarginCollateralRatioResponse = crossMarginCollateralRatioResponse;
type types$a_disableIsolatedMarginAccountOptions = disableIsolatedMarginAccountOptions;
type types$a_disableIsolatedMarginAccountResponse = disableIsolatedMarginAccountResponse;
type types$a_enableIsolatedMarginAccountOptions = enableIsolatedMarginAccountOptions;
type types$a_enableIsolatedMarginAccountResponse = enableIsolatedMarginAccountResponse;
type types$a_getAllCrossMarginPairsOptions = getAllCrossMarginPairsOptions;
type types$a_getAllCrossMarginPairsResponse = getAllCrossMarginPairsResponse;
type types$a_getAllIsolatedMarginSymbolOptions = getAllIsolatedMarginSymbolOptions;
type types$a_getAllIsolatedMarginSymbolResponse = getAllIsolatedMarginSymbolResponse;
type types$a_getAllMarginAssetsOptions = getAllMarginAssetsOptions;
type types$a_getAllMarginAssetsResponse = getAllMarginAssetsResponse;
type types$a_getBnbBurnStatusOptions = getBnbBurnStatusOptions;
type types$a_getBnbBurnStatusResponse = getBnbBurnStatusResponse;
type types$a_getBorrowRepayRecordsOptions = getBorrowRepayRecordsOptions;
type types$a_getBorrowRepayRecordsResponse = getBorrowRepayRecordsResponse;
type types$a_getCrossMarginAccountDetailsOptions = getCrossMarginAccountDetailsOptions;
type types$a_getCrossMarginAccountDetailsResponse = getCrossMarginAccountDetailsResponse;
type types$a_getCrossMarginAccountDetailsUserassets = getCrossMarginAccountDetailsUserassets;
type types$a_getCrossMarginFeeDataOptions = getCrossMarginFeeDataOptions;
type types$a_getCrossMarginFeeDataResponse = getCrossMarginFeeDataResponse;
type types$a_getCrossMarginTransferHistoryOptions = getCrossMarginTransferHistoryOptions;
type types$a_getCrossMarginTransferHistoryResponse = getCrossMarginTransferHistoryResponse;
type types$a_getCrossMarginTransferHistoryRows = getCrossMarginTransferHistoryRows;
type types$a_getCurrentMarginOrderCountUsageOptions = getCurrentMarginOrderCountUsageOptions;
type types$a_getCurrentMarginOrderCountUsageResponse = getCurrentMarginOrderCountUsageResponse;
type types$a_getEnabledIsolatedMarginAccountLimitOptions = getEnabledIsolatedMarginAccountLimitOptions;
type types$a_getEnabledIsolatedMarginAccountLimitResponse = getEnabledIsolatedMarginAccountLimitResponse;
type types$a_getForceLiquidationRecordOptions = getForceLiquidationRecordOptions;
type types$a_getForceLiquidationRecordResponse = getForceLiquidationRecordResponse;
type types$a_getForceLiquidationRecordRows = getForceLiquidationRecordRows;
type types$a_getFutureHoulyInterestRateResponse = getFutureHoulyInterestRateResponse;
type types$a_getInterestHistoryOptions = getInterestHistory