ccxt 4.4.41 → 4.4.43

package/js/src/abstract/myokx.d.ts

@@ -0,0 +1,343 @@
+import { implicitReturnType } from '../base/types.js';
+import _okx from '../okx.js';
+interface okx {
+    publicGetMarketBooksFull(params?: {}): Promise<implicitReturnType>;
+    publicGetMarketTickers(params?: {}): Promise<implicitReturnType>;
+    publicGetMarketTicker(params?: {}): Promise<implicitReturnType>;
+    publicGetMarketIndexTickers(params?: {}): Promise<implicitReturnType>;
+    publicGetMarketBooks(params?: {}): Promise<implicitReturnType>;
+    publicGetMarketBooksLite(params?: {}): Promise<implicitReturnType>;
+    publicGetMarketCandles(params?: {}): Promise<implicitReturnType>;
+    publicGetMarketHistoryCandles(params?: {}): Promise<implicitReturnType>;
+    publicGetMarketIndexCandles(params?: {}): Promise<implicitReturnType>;
+    publicGetMarketHistoryIndexCandles(params?: {}): Promise<implicitReturnType>;
+    publicGetMarketMarkPriceCandles(params?: {}): Promise<implicitReturnType>;
+    publicGetMarketHistoryMarkPriceCandles(params?: {}): Promise<implicitReturnType>;
+    publicGetMarketTrades(params?: {}): Promise<implicitReturnType>;
+    publicGetMarketHistoryTrades(params?: {}): Promise<implicitReturnType>;
+    publicGetMarketOptionInstrumentFamilyTrades(params?: {}): Promise<implicitReturnType>;
+    publicGetMarketPlatform24Volume(params?: {}): Promise<implicitReturnType>;
+    publicGetMarketOpenOracle(params?: {}): Promise<implicitReturnType>;
+    publicGetMarketExchangeRate(params?: {}): Promise<implicitReturnType>;
+    publicGetMarketIndexComponents(params?: {}): Promise<implicitReturnType>;
+    publicGetPublicEconomicCalendar(params?: {}): Promise<implicitReturnType>;
+    publicGetMarketBlockTickers(params?: {}): Promise<implicitReturnType>;
+    publicGetMarketBlockTicker(params?: {}): Promise<implicitReturnType>;
+    publicGetPublicBlockTrades(params?: {}): Promise<implicitReturnType>;
+    publicGetPublicInstruments(params?: {}): Promise<implicitReturnType>;
+    publicGetPublicDeliveryExerciseHistory(params?: {}): Promise<implicitReturnType>;
+    publicGetPublicOpenInterest(params?: {}): Promise<implicitReturnType>;
+    publicGetPublicFundingRate(params?: {}): Promise<implicitReturnType>;
+    publicGetPublicFundingRateHistory(params?: {}): Promise<implicitReturnType>;
+    publicGetPublicPriceLimit(params?: {}): Promise<implicitReturnType>;
+    publicGetPublicOptSummary(params?: {}): Promise<implicitReturnType>;
+    publicGetPublicEstimatedPrice(params?: {}): Promise<implicitReturnType>;
+    publicGetPublicDiscountRateInterestFreeQuota(params?: {}): Promise<implicitReturnType>;
+    publicGetPublicTime(params?: {}): Promise<implicitReturnType>;
+    publicGetPublicMarkPrice(params?: {}): Promise<implicitReturnType>;
+    publicGetPublicPositionTiers(params?: {}): Promise<implicitReturnType>;
+    publicGetPublicInterestRateLoanQuota(params?: {}): Promise<implicitReturnType>;
+    publicGetPublicVipInterestRateLoanQuota(params?: {}): Promise<implicitReturnType>;
+    publicGetPublicUnderlying(params?: {}): Promise<implicitReturnType>;
+    publicGetPublicInsuranceFund(params?: {}): Promise<implicitReturnType>;
+    publicGetPublicConvertContractCoin(params?: {}): Promise<implicitReturnType>;
+    publicGetPublicOptionTrades(params?: {}): Promise<implicitReturnType>;
+    publicGetPublicInstrumentTickBands(params?: {}): Promise<implicitReturnType>;
+    publicGetRubikStatTradingDataSupportCoin(params?: {}): Promise<implicitReturnType>;
+    publicGetRubikStatTakerVolume(params?: {}): Promise<implicitReturnType>;
+    publicGetRubikStatMarginLoanRatio(params?: {}): Promise<implicitReturnType>;
+    publicGetRubikStatContractsLongShortAccountRatio(params?: {}): Promise<implicitReturnType>;
+    publicGetRubikStatContractsLongShortAccountRatioContract(params?: {}): Promise<implicitReturnType>;
+    publicGetRubikStatContractsOpenInterestVolume(params?: {}): Promise<implicitReturnType>;
+    publicGetRubikStatOptionOpenInterestVolume(params?: {}): Promise<implicitReturnType>;
+    publicGetRubikStatOptionOpenInterestVolumeRatio(params?: {}): Promise<implicitReturnType>;
+    publicGetRubikStatOptionOpenInterestVolumeExpiry(params?: {}): Promise<implicitReturnType>;
+    publicGetRubikStatOptionOpenInterestVolumeStrike(params?: {}): Promise<implicitReturnType>;
+    publicGetRubikStatOptionTakerBlockVolume(params?: {}): Promise<implicitReturnType>;
+    publicGetSystemStatus(params?: {}): Promise<implicitReturnType>;
+    publicGetSprdSpreads(params?: {}): Promise<implicitReturnType>;
+    publicGetSprdBooks(params?: {}): Promise<implicitReturnType>;
+    publicGetSprdTicker(params?: {}): Promise<implicitReturnType>;
+    publicGetSprdPublicTrades(params?: {}): Promise<implicitReturnType>;
+    publicGetMarketSprdTicker(params?: {}): Promise<implicitReturnType>;
+    publicGetMarketSprdCandles(params?: {}): Promise<implicitReturnType>;
+    publicGetMarketSprdHistoryCandles(params?: {}): Promise<implicitReturnType>;
+    publicGetTradingBotGridAiParam(params?: {}): Promise<implicitReturnType>;
+    publicGetTradingBotGridMinInvestment(params?: {}): Promise<implicitReturnType>;
+    publicGetTradingBotPublicRsiBackTesting(params?: {}): Promise<implicitReturnType>;
+    publicGetAssetExchangeList(params?: {}): Promise<implicitReturnType>;
+    publicGetFinanceStakingDefiEthApyHistory(params?: {}): Promise<implicitReturnType>;
+    publicGetFinanceStakingDefiSolApyHistory(params?: {}): Promise<implicitReturnType>;
+    publicGetFinanceSavingsLendingRateSummary(params?: {}): Promise<implicitReturnType>;
+    publicGetFinanceSavingsLendingRateHistory(params?: {}): Promise<implicitReturnType>;
+    publicGetFinanceFixedLoanLendingOffers(params?: {}): Promise<implicitReturnType>;
+    publicGetFinanceFixedLoanLendingApyHistory(params?: {}): Promise<implicitReturnType>;
+    publicGetFinanceFixedLoanPendingLendingVolume(params?: {}): Promise<implicitReturnType>;
+    publicGetFinanceSfpDcdProducts(params?: {}): Promise<implicitReturnType>;
+    publicGetCopytradingPublicLeadTraders(params?: {}): Promise<implicitReturnType>;
+    publicGetCopytradingPublicWeeklyPnl(params?: {}): Promise<implicitReturnType>;
+    publicGetCopytradingPublicStats(params?: {}): Promise<implicitReturnType>;
+    publicGetCopytradingPublicPreferenceCurrency(params?: {}): Promise<implicitReturnType>;
+    publicGetCopytradingPublicCurrentSubpositions(params?: {}): Promise<implicitReturnType>;
+    publicGetCopytradingPublicSubpositionsHistory(params?: {}): Promise<implicitReturnType>;
+    publicGetSupportAnnouncementsTypes(params?: {}): Promise<implicitReturnType>;
+    privateGetRfqCounterparties(params?: {}): Promise<implicitReturnType>;
+    privateGetRfqMakerInstrumentSettings(params?: {}): Promise<implicitReturnType>;
+    privateGetRfqMmpConfig(params?: {}): Promise<implicitReturnType>;
+    privateGetRfqRfqs(params?: {}): Promise<implicitReturnType>;
+    privateGetRfqQuotes(params?: {}): Promise<implicitReturnType>;
+    privateGetRfqTrades(params?: {}): Promise<implicitReturnType>;
+    privateGetRfqPublicTrades(params?: {}): Promise<implicitReturnType>;
+    privateGetSprdOrder(params?: {}): Promise<implicitReturnType>;
+    privateGetSprdOrdersPending(params?: {}): Promise<implicitReturnType>;
+    privateGetSprdOrdersHistory(params?: {}): Promise<implicitReturnType>;
+    privateGetSprdOrdersHistoryArchive(params?: {}): Promise<implicitReturnType>;
+    privateGetSprdTrades(params?: {}): Promise<implicitReturnType>;
+    privateGetTradeOrder(params?: {}): Promise<implicitReturnType>;
+    privateGetTradeOrdersPending(params?: {}): Promise<implicitReturnType>;
+    privateGetTradeOrdersHistory(params?: {}): Promise<implicitReturnType>;
+    privateGetTradeOrdersHistoryArchive(params?: {}): Promise<implicitReturnType>;
+    privateGetTradeFills(params?: {}): Promise<implicitReturnType>;
+    privateGetTradeFillsHistory(params?: {}): Promise<implicitReturnType>;
+    privateGetTradeFillsArchive(params?: {}): Promise<implicitReturnType>;
+    privateGetTradeOrderAlgo(params?: {}): Promise<implicitReturnType>;
+    privateGetTradeOrdersAlgoPending(params?: {}): Promise<implicitReturnType>;
+    privateGetTradeOrdersAlgoHistory(params?: {}): Promise<implicitReturnType>;
+    privateGetTradeEasyConvertCurrencyList(params?: {}): Promise<implicitReturnType>;
+    privateGetTradeEasyConvertHistory(params?: {}): Promise<implicitReturnType>;
+    privateGetTradeOneClickRepayCurrencyList(params?: {}): Promise<implicitReturnType>;
+    privateGetTradeOneClickRepayHistory(params?: {}): Promise<implicitReturnType>;
+    privateGetTradeAccountRateLimit(params?: {}): Promise<implicitReturnType>;
+    privateGetAssetCurrencies(params?: {}): Promise<implicitReturnType>;
+    privateGetAssetBalances(params?: {}): Promise<implicitReturnType>;
+    privateGetAssetNonTradableAssets(params?: {}): Promise<implicitReturnType>;
+    privateGetAssetAssetValuation(params?: {}): Promise<implicitReturnType>;
+    privateGetAssetTransferState(params?: {}): Promise<implicitReturnType>;
+    privateGetAssetBills(params?: {}): Promise<implicitReturnType>;
+    privateGetAssetDepositLightning(params?: {}): Promise<implicitReturnType>;
+    privateGetAssetDepositAddress(params?: {}): Promise<implicitReturnType>;
+    privateGetAssetDepositHistory(params?: {}): Promise<implicitReturnType>;
+    privateGetAssetWithdrawalHistory(params?: {}): Promise<implicitReturnType>;
+    privateGetAssetDepositWithdrawStatus(params?: {}): Promise<implicitReturnType>;
+    privateGetAssetConvertCurrencies(params?: {}): Promise<implicitReturnType>;
+    privateGetAssetConvertCurrencyPair(params?: {}): Promise<implicitReturnType>;
+    privateGetAssetConvertHistory(params?: {}): Promise<implicitReturnType>;
+    privateGetAssetMonthlyStatement(params?: {}): Promise<implicitReturnType>;
+    privateGetAccountInstruments(params?: {}): Promise<implicitReturnType>;
+    privateGetAccountBalance(params?: {}): Promise<implicitReturnType>;
+    privateGetAccountPositions(params?: {}): Promise<implicitReturnType>;
+    privateGetAccountPositionsHistory(params?: {}): Promise<implicitReturnType>;
+    privateGetAccountAccountPositionRisk(params?: {}): Promise<implicitReturnType>;
+    privateGetAccountBills(params?: {}): Promise<implicitReturnType>;
+    privateGetAccountBillsArchive(params?: {}): Promise<implicitReturnType>;
+    privateGetAccountBillsHistoryArchive(params?: {}): Promise<implicitReturnType>;
+    privateGetAccountConfig(params?: {}): Promise<implicitReturnType>;
+    privateGetAccountMaxSize(params?: {}): Promise<implicitReturnType>;
+    privateGetAccountMaxAvailSize(params?: {}): Promise<implicitReturnType>;
+    privateGetAccountLeverageInfo(params?: {}): Promise<implicitReturnType>;
+    privateGetAccountAdjustLeverageInfo(params?: {}): Promise<implicitReturnType>;
+    privateGetAccountMaxLoan(params?: {}): Promise<implicitReturnType>;
+    privateGetAccountTradeFee(params?: {}): Promise<implicitReturnType>;
+    privateGetAccountInterestAccrued(params?: {}): Promise<implicitReturnType>;
+    privateGetAccountInterestRate(params?: {}): Promise<implicitReturnType>;
+    privateGetAccountMaxWithdrawal(params?: {}): Promise<implicitReturnType>;
+    privateGetAccountRiskState(params?: {}): Promise<implicitReturnType>;
+    privateGetAccountQuickMarginBorrowRepayHistory(params?: {}): Promise<implicitReturnType>;
+    privateGetAccountBorrowRepayHistory(params?: {}): Promise<implicitReturnType>;
+    privateGetAccountVipInterestAccrued(params?: {}): Promise<implicitReturnType>;
+    privateGetAccountVipInterestDeducted(params?: {}): Promise<implicitReturnType>;
+    privateGetAccountVipLoanOrderList(params?: {}): Promise<implicitReturnType>;
+    privateGetAccountVipLoanOrderDetail(params?: {}): Promise<implicitReturnType>;
+    privateGetAccountInterestLimits(params?: {}): Promise<implicitReturnType>;
+    privateGetAccountGreeks(params?: {}): Promise<implicitReturnType>;
+    privateGetAccountPositionTiers(params?: {}): Promise<implicitReturnType>;
+    privateGetAccountMmpConfig(params?: {}): Promise<implicitReturnType>;
+    privateGetAccountFixedLoanBorrowingLimit(params?: {}): Promise<implicitReturnType>;
+    privateGetAccountFixedLoanBorrowingQuote(params?: {}): Promise<implicitReturnType>;
+    privateGetAccountFixedLoanBorrowingOrdersList(params?: {}): Promise<implicitReturnType>;
+    privateGetAccountSpotManualBorrowRepay(params?: {}): Promise<implicitReturnType>;
+    privateGetAccountSetAutoRepay(params?: {}): Promise<implicitReturnType>;
+    privateGetAccountSpotBorrowRepayHistory(params?: {}): Promise<implicitReturnType>;
+    privateGetUsersSubaccountList(params?: {}): Promise<implicitReturnType>;
+    privateGetAccountSubaccountBalances(params?: {}): Promise<implicitReturnType>;
+    privateGetAssetSubaccountBalances(params?: {}): Promise<implicitReturnType>;
+    privateGetAccountSubaccountMaxWithdrawal(params?: {}): Promise<implicitReturnType>;
+    privateGetAssetSubaccountBills(params?: {}): Promise<implicitReturnType>;
+    privateGetAssetSubaccountManagedSubaccountBills(params?: {}): Promise<implicitReturnType>;
+    privateGetUsersEntrustSubaccountList(params?: {}): Promise<implicitReturnType>;
+    privateGetAccountSubaccountInterestLimits(params?: {}): Promise<implicitReturnType>;
+    privateGetTradingBotGridOrdersAlgoPending(params?: {}): Promise<implicitReturnType>;
+    privateGetTradingBotGridOrdersAlgoHistory(params?: {}): Promise<implicitReturnType>;
+    privateGetTradingBotGridOrdersAlgoDetails(params?: {}): Promise<implicitReturnType>;
+    privateGetTradingBotGridSubOrders(params?: {}): Promise<implicitReturnType>;
+    privateGetTradingBotGridPositions(params?: {}): Promise<implicitReturnType>;
+    privateGetTradingBotGridAiParam(params?: {}): Promise<implicitReturnType>;
+    privateGetTradingBotSignalSignals(params?: {}): Promise<implicitReturnType>;
+    privateGetTradingBotSignalOrdersAlgoDetails(params?: {}): Promise<implicitReturnType>;
+    privateGetTradingBotSignalOrdersAlgoHistory(params?: {}): Promise<implicitReturnType>;
+    privateGetTradingBotSignalPositions(params?: {}): Promise<implicitReturnType>;
+    privateGetTradingBotSignalPositionsHistory(params?: {}): Promise<implicitReturnType>;
+    privateGetTradingBotSignalSubOrders(params?: {}): Promise<implicitReturnType>;
+    privateGetTradingBotSignalEventHistory(params?: {}): Promise<implicitReturnType>;
+    privateGetTradingBotRecurringOrdersAlgoPending(params?: {}): Promise<implicitReturnType>;
+    privateGetTradingBotRecurringOrdersAlgoHistory(params?: {}): Promise<implicitReturnType>;
+    privateGetTradingBotRecurringOrdersAlgoDetails(params?: {}): Promise<implicitReturnType>;
+    privateGetTradingBotRecurringSubOrders(params?: {}): Promise<implicitReturnType>;
+    privateGetFinanceSavingsBalance(params?: {}): Promise<implicitReturnType>;
+    privateGetFinanceSavingsLendingHistory(params?: {}): Promise<implicitReturnType>;
+    privateGetFinanceStakingDefiOffers(params?: {}): Promise<implicitReturnType>;
+    privateGetFinanceStakingDefiOrdersActive(params?: {}): Promise<implicitReturnType>;
+    privateGetFinanceStakingDefiOrdersHistory(params?: {}): Promise<implicitReturnType>;
+    privateGetFinanceStakingDefiEthBalance(params?: {}): Promise<implicitReturnType>;
+    privateGetFinanceStakingDefiEthPurchaseRedeemHistory(params?: {}): Promise<implicitReturnType>;
+    privateGetFinanceStakingDefiEthProductInfo(params?: {}): Promise<implicitReturnType>;
+    privateGetFinanceStakingDefiSolBalance(params?: {}): Promise<implicitReturnType>;
+    privateGetFinanceStakingDefiSolPurchaseRedeemHistory(params?: {}): Promise<implicitReturnType>;
+    privateGetCopytradingCurrentSubpositions(params?: {}): Promise<implicitReturnType>;
+    privateGetCopytradingSubpositionsHistory(params?: {}): Promise<implicitReturnType>;
+    privateGetCopytradingInstruments(params?: {}): Promise<implicitReturnType>;
+    privateGetCopytradingProfitSharingDetails(params?: {}): Promise<implicitReturnType>;
+    privateGetCopytradingTotalProfitSharing(params?: {}): Promise<implicitReturnType>;
+    privateGetCopytradingUnrealizedProfitSharingDetails(params?: {}): Promise<implicitReturnType>;
+    privateGetCopytradingCopySettings(params?: {}): Promise<implicitReturnType>;
+    privateGetCopytradingBatchLeverageInfo(params?: {}): Promise<implicitReturnType>;
+    privateGetCopytradingCurrentLeadTraders(params?: {}): Promise<implicitReturnType>;
+    privateGetCopytradingLeadTradersHistory(params?: {}): Promise<implicitReturnType>;
+    privateGetBrokerNdInfo(params?: {}): Promise<implicitReturnType>;
+    privateGetBrokerNdSubaccountInfo(params?: {}): Promise<implicitReturnType>;
+    privateGetBrokerNdSubaccountApikey(params?: {}): Promise<implicitReturnType>;
+    privateGetAssetBrokerNdSubaccountDepositAddress(params?: {}): Promise<implicitReturnType>;
+    privateGetAssetBrokerNdSubaccountDepositHistory(params?: {}): Promise<implicitReturnType>;
+    privateGetAssetBrokerNdSubaccountWithdrawalHistory(params?: {}): Promise<implicitReturnType>;
+    privateGetBrokerNdRebateDaily(params?: {}): Promise<implicitReturnType>;
+    privateGetBrokerNdRebatePerOrders(params?: {}): Promise<implicitReturnType>;
+    privateGetFinanceSfpDcdOrder(params?: {}): Promise<implicitReturnType>;
+    privateGetFinanceSfpDcdOrders(params?: {}): Promise<implicitReturnType>;
+    privateGetBrokerFdRebatePerOrders(params?: {}): Promise<implicitReturnType>;
+    privateGetBrokerFdIfRebate(params?: {}): Promise<implicitReturnType>;
+    privateGetAffiliateInviteeDetail(params?: {}): Promise<implicitReturnType>;
+    privateGetUsersPartnerIfRebate(params?: {}): Promise<implicitReturnType>;
+    privateGetSupportAnnouncements(params?: {}): Promise<implicitReturnType>;
+    privatePostRfqCreateRfq(params?: {}): Promise<implicitReturnType>;
+    privatePostRfqCancelRfq(params?: {}): Promise<implicitReturnType>;
+    privatePostRfqCancelBatchRfqs(params?: {}): Promise<implicitReturnType>;
+    privatePostRfqCancelAllRfqs(params?: {}): Promise<implicitReturnType>;
+    privatePostRfqExecuteQuote(params?: {}): Promise<implicitReturnType>;
+    privatePostRfqMakerInstrumentSettings(params?: {}): Promise<implicitReturnType>;
+    privatePostRfqMmpReset(params?: {}): Promise<implicitReturnType>;
+    privatePostRfqMmpConfig(params?: {}): Promise<implicitReturnType>;
+    privatePostRfqCreateQuote(params?: {}): Promise<implicitReturnType>;
+    privatePostRfqCancelQuote(params?: {}): Promise<implicitReturnType>;
+    privatePostRfqCancelBatchQuotes(params?: {}): Promise<implicitReturnType>;
+    privatePostRfqCancelAllQuotes(params?: {}): Promise<implicitReturnType>;
+    privatePostSprdOrder(params?: {}): Promise<implicitReturnType>;
+    privatePostSprdCancelOrder(params?: {}): Promise<implicitReturnType>;
+    privatePostSprdMassCancel(params?: {}): Promise<implicitReturnType>;
+    privatePostSprdAmendOrder(params?: {}): Promise<implicitReturnType>;
+    privatePostSprdCancelAllAfter(params?: {}): Promise<implicitReturnType>;
+    privatePostTradeOrder(params?: {}): Promise<implicitReturnType>;
+    privatePostTradeBatchOrders(params?: {}): Promise<implicitReturnType>;
+    privatePostTradeCancelOrder(params?: {}): Promise<implicitReturnType>;
+    privatePostTradeCancelBatchOrders(params?: {}): Promise<implicitReturnType>;
+    privatePostTradeAmendOrder(params?: {}): Promise<implicitReturnType>;
+    privatePostTradeAmendBatchOrders(params?: {}): Promise<implicitReturnType>;
+    privatePostTradeClosePosition(params?: {}): Promise<implicitReturnType>;
+    privatePostTradeFillsArchive(params?: {}): Promise<implicitReturnType>;
+    privatePostTradeOrderAlgo(params?: {}): Promise<implicitReturnType>;
+    privatePostTradeCancelAlgos(params?: {}): Promise<implicitReturnType>;
+    privatePostTradeAmendAlgos(params?: {}): Promise<implicitReturnType>;
+    privatePostTradeCancelAdvanceAlgos(params?: {}): Promise<implicitReturnType>;
+    privatePostTradeEasyConvert(params?: {}): Promise<implicitReturnType>;
+    privatePostTradeOneClickRepay(params?: {}): Promise<implicitReturnType>;
+    privatePostTradeMassCancel(params?: {}): Promise<implicitReturnType>;
+    privatePostTradeCancelAllAfter(params?: {}): Promise<implicitReturnType>;
+    privatePostAssetTransfer(params?: {}): Promise<implicitReturnType>;
+    privatePostAssetWithdrawal(params?: {}): Promise<implicitReturnType>;
+    privatePostAssetWithdrawalLightning(params?: {}): Promise<implicitReturnType>;
+    privatePostAssetCancelWithdrawal(params?: {}): Promise<implicitReturnType>;
+    privatePostAssetConvertDustAssets(params?: {}): Promise<implicitReturnType>;
+    privatePostAssetConvertEstimateQuote(params?: {}): Promise<implicitReturnType>;
+    privatePostAssetConvertTrade(params?: {}): Promise<implicitReturnType>;
+    privatePostAssetMonthlyStatement(params?: {}): Promise<implicitReturnType>;
+    privatePostAccountSetPositionMode(params?: {}): Promise<implicitReturnType>;
+    privatePostAccountSetLeverage(params?: {}): Promise<implicitReturnType>;
+    privatePostAccountPositionMarginBalance(params?: {}): Promise<implicitReturnType>;
+    privatePostAccountSetGreeks(params?: {}): Promise<implicitReturnType>;
+    privatePostAccountSetIsolatedMode(params?: {}): Promise<implicitReturnType>;
+    privatePostAccountQuickMarginBorrowRepay(params?: {}): Promise<implicitReturnType>;
+    privatePostAccountBorrowRepay(params?: {}): Promise<implicitReturnType>;
+    privatePostAccountSimulatedMargin(params?: {}): Promise<implicitReturnType>;
+    privatePostAccountPositionBuilder(params?: {}): Promise<implicitReturnType>;
+    privatePostAccountSetRiskOffsetType(params?: {}): Promise<implicitReturnType>;
+    privatePostAccountActivateOption(params?: {}): Promise<implicitReturnType>;
+    privatePostAccountSetAutoLoan(params?: {}): Promise<implicitReturnType>;
+    privatePostAccountSetAccountLevel(params?: {}): Promise<implicitReturnType>;
+    privatePostAccountMmpReset(params?: {}): Promise<implicitReturnType>;
+    privatePostAccountMmpConfig(params?: {}): Promise<implicitReturnType>;
+    privatePostAccountFixedLoanBorrowingOrder(params?: {}): Promise<implicitReturnType>;
+    privatePostAccountFixedLoanAmendBorrowingOrder(params?: {}): Promise<implicitReturnType>;
+    privatePostAccountFixedLoanManualReborrow(params?: {}): Promise<implicitReturnType>;
+    privatePostAccountFixedLoanRepayBorrowingOrder(params?: {}): Promise<implicitReturnType>;
+    privatePostAccountBillsHistoryArchive(params?: {}): Promise<implicitReturnType>;
+    privatePostUsersSubaccountModifyApikey(params?: {}): Promise<implicitReturnType>;
+    privatePostAssetSubaccountTransfer(params?: {}): Promise<implicitReturnType>;
+    privatePostUsersSubaccountSetTransferOut(params?: {}): Promise<implicitReturnType>;
+    privatePostAccountSubaccountSetLoanAllocation(params?: {}): Promise<implicitReturnType>;
+    privatePostTradingBotGridOrderAlgo(params?: {}): Promise<implicitReturnType>;
+    privatePostTradingBotGridAmendOrderAlgo(params?: {}): Promise<implicitReturnType>;
+    privatePostTradingBotGridStopOrderAlgo(params?: {}): Promise<implicitReturnType>;
+    privatePostTradingBotGridClosePosition(params?: {}): Promise<implicitReturnType>;
+    privatePostTradingBotGridCancelCloseOrder(params?: {}): Promise<implicitReturnType>;
+    privatePostTradingBotGridOrderInstantTrigger(params?: {}): Promise<implicitReturnType>;
+    privatePostTradingBotGridWithdrawIncome(params?: {}): Promise<implicitReturnType>;
+    privatePostTradingBotGridComputeMarginBalance(params?: {}): Promise<implicitReturnType>;
+    privatePostTradingBotGridMarginBalance(params?: {}): Promise<implicitReturnType>;
+    privatePostTradingBotGridMinInvestment(params?: {}): Promise<implicitReturnType>;
+    privatePostTradingBotGridAdjustInvestment(params?: {}): Promise<implicitReturnType>;
+    privatePostTradingBotSignalCreateSignal(params?: {}): Promise<implicitReturnType>;
+    privatePostTradingBotSignalOrderAlgo(params?: {}): Promise<implicitReturnType>;
+    privatePostTradingBotSignalStopOrderAlgo(params?: {}): Promise<implicitReturnType>;
+    privatePostTradingBotSignalMarginBalance(params?: {}): Promise<implicitReturnType>;
+    privatePostTradingBotSignalAmendTPSL(params?: {}): Promise<implicitReturnType>;
+    privatePostTradingBotSignalSetInstruments(params?: {}): Promise<implicitReturnType>;
+    privatePostTradingBotSignalClosePosition(params?: {}): Promise<implicitReturnType>;
+    privatePostTradingBotSignalSubOrder(params?: {}): Promise<implicitReturnType>;
+    privatePostTradingBotSignalCancelSubOrder(params?: {}): Promise<implicitReturnType>;
+    privatePostTradingBotRecurringOrderAlgo(params?: {}): Promise<implicitReturnType>;
+    privatePostTradingBotRecurringAmendOrderAlgo(params?: {}): Promise<implicitReturnType>;
+    privatePostTradingBotRecurringStopOrderAlgo(params?: {}): Promise<implicitReturnType>;
+    privatePostFinanceSavingsPurchaseRedempt(params?: {}): Promise<implicitReturnType>;
+    privatePostFinanceSavingsSetLendingRate(params?: {}): Promise<implicitReturnType>;
+    privatePostFinanceStakingDefiPurchase(params?: {}): Promise<implicitReturnType>;
+    privatePostFinanceStakingDefiRedeem(params?: {}): Promise<implicitReturnType>;
+    privatePostFinanceStakingDefiCancel(params?: {}): Promise<implicitReturnType>;
+    privatePostFinanceStakingDefiEthPurchase(params?: {}): Promise<implicitReturnType>;
+    privatePostFinanceStakingDefiEthRedeem(params?: {}): Promise<implicitReturnType>;
+    privatePostFinanceStakingDefiSolPurchase(params?: {}): Promise<implicitReturnType>;
+    privatePostFinanceStakingDefiSolRedeem(params?: {}): Promise<implicitReturnType>;
+    privatePostCopytradingAlgoOrder(params?: {}): Promise<implicitReturnType>;
+    privatePostCopytradingCloseSubposition(params?: {}): Promise<implicitReturnType>;
+    privatePostCopytradingSetInstruments(params?: {}): Promise<implicitReturnType>;
+    privatePostCopytradingFirstCopySettings(params?: {}): Promise<implicitReturnType>;
+    privatePostCopytradingAmendCopySettings(params?: {}): Promise<implicitReturnType>;
+    privatePostCopytradingStopCopyTrading(params?: {}): Promise<implicitReturnType>;
+    privatePostCopytradingBatchSetLeverage(params?: {}): Promise<implicitReturnType>;
+    privatePostBrokerNdCreateSubaccount(params?: {}): Promise<implicitReturnType>;
+    privatePostBrokerNdDeleteSubaccount(params?: {}): Promise<implicitReturnType>;
+    privatePostBrokerNdSubaccountApikey(params?: {}): Promise<implicitReturnType>;
+    privatePostBrokerNdSubaccountModifyApikey(params?: {}): Promise<implicitReturnType>;
+    privatePostBrokerNdSubaccountDeleteApikey(params?: {}): Promise<implicitReturnType>;
+    privatePostBrokerNdSetSubaccountLevel(params?: {}): Promise<implicitReturnType>;
+    privatePostBrokerNdSetSubaccountFeeRate(params?: {}): Promise<implicitReturnType>;
+    privatePostBrokerNdSetSubaccountAssets(params?: {}): Promise<implicitReturnType>;
+    privatePostAssetBrokerNdSubaccountDepositAddress(params?: {}): Promise<implicitReturnType>;
+    privatePostAssetBrokerNdModifySubaccountDepositAddress(params?: {}): Promise<implicitReturnType>;
+    privatePostBrokerNdRebatePerOrders(params?: {}): Promise<implicitReturnType>;
+    privatePostFinanceSfpDcdQuote(params?: {}): Promise<implicitReturnType>;
+    privatePostFinanceSfpDcdOrder(params?: {}): Promise<implicitReturnType>;
+    privatePostBrokerNdReportSubaccountIp(params?: {}): Promise<implicitReturnType>;
+    privatePostBrokerFdRebatePerOrders(params?: {}): Promise<implicitReturnType>;
+}
+declare abstract class okx extends _okx {
+}
+export default okx;

package/js/src/abstract/myokx.js

@@ -0,0 +1,11 @@
+// ----------------------------------------------------------------------------
+
+// PLEASE DO NOT EDIT THIS FILE, IT IS GENERATED AND WILL BE OVERWRITTEN:
+// https://github.com/ccxt/ccxt/blob/master/CONTRIBUTING.md#how-to-contribute-code
+// EDIT THE CORRESPONDENT .ts FILE INSTEAD
+
+// -------------------------------------------------------------------------------
+import _okx from '../okx.js';
+class okx extends _okx {
+}
+export default okx;

package/js/src/ace.js

@@ -592,7 +592,7 @@ export default class ace extends Exchange {
             'postOnly': undefined,
             'side': side,
             'price': price,
-            'stopPrice': undefined,
+            'triggerPrice': undefined,
             'amount': amount,
             'cost': undefined,
             'average': average,

package/js/src/alpaca.js

@@ -1214,7 +1214,6 @@ export default class alpaca extends Exchange {
             'postOnly': undefined,
             'side': this.safeString(order, 'side'),
             'price': this.safeNumber(order, 'limit_price'),
-            'stopPrice': this.safeNumber(order, 'stop_price'),
             'triggerPrice': this.safeNumber(order, 'stop_price'),
             'cost': undefined,
             'average': this.safeNumber(order, 'filled_avg_price'),

package/js/src/ascendex.js

@@ -1421,7 +1421,6 @@ export default class ascendex extends Exchange {
             'reduceOnly': reduceOnly,
             'side': side,
             'price': price,
-            'stopPrice': triggerPrice,
             'triggerPrice': triggerPrice,
             'amount': amount,
             'cost': undefined,

package/js/src/base/Exchange.d.ts

@@ -1105,12 +1105,12 @@ export default class Exchange {
     createPostOnlyOrderWs(symbol: string, type: OrderType, side: OrderSide, amount: number, price?: Num, params?: {}): Promise<Order>;
     createReduceOnlyOrder(symbol: string, type: OrderType, side: OrderSide, amount: number, price?: Num, params?: {}): Promise<Order>;
     createReduceOnlyOrderWs(symbol: string, type: OrderType, side: OrderSide, amount: number, price?: Num, params?: {}): Promise<Order>;
-    createStopOrder(symbol: string, type: OrderType, side: OrderSide, amount: number, price?: Num, stopPrice?: Num, params?: {}): Promise<Order>;
-    createStopOrderWs(symbol: string, type: OrderType, side: OrderSide, amount: number, price?: Num, stopPrice?: Num, params?: {}): Promise<Order>;
-    createStopLimitOrder(symbol: string, side: OrderSide, amount: number, price: number, stopPrice: number, params?: {}): Promise<Order>;
-    createStopLimitOrderWs(symbol: string, side: OrderSide, amount: number, price: number, stopPrice: number, params?: {}): Promise<Order>;
-    createStopMarketOrder(symbol: string, side: OrderSide, amount: number, stopPrice: number, params?: {}): Promise<Order>;
-    createStopMarketOrderWs(symbol: string, side: OrderSide, amount: number, stopPrice: number, params?: {}): Promise<Order>;
+    createStopOrder(symbol: string, type: OrderType, side: OrderSide, amount: number, price?: Num, triggerPrice?: Num, params?: {}): Promise<Order>;
+    createStopOrderWs(symbol: string, type: OrderType, side: OrderSide, amount: number, price?: Num, triggerPrice?: Num, params?: {}): Promise<Order>;
+    createStopLimitOrder(symbol: string, side: OrderSide, amount: number, price: number, triggerPrice: number, params?: {}): Promise<Order>;
+    createStopLimitOrderWs(symbol: string, side: OrderSide, amount: number, price: number, triggerPrice: number, params?: {}): Promise<Order>;
+    createStopMarketOrder(symbol: string, side: OrderSide, amount: number, triggerPrice: number, params?: {}): Promise<Order>;
+    createStopMarketOrderWs(symbol: string, side: OrderSide, amount: number, triggerPrice: number, params?: {}): Promise<Order>;
     safeCurrencyCode(currencyId: Str, currency?: Currency): string;
     filterBySymbolSinceLimit(array: any, symbol?: Str, since?: Int, limit?: Int, tail?: boolean): any;
     filterByCurrencySinceLimit(array: any, code?: any, since?: Int, limit?: Int, tail?: boolean): any;

package/js/src/base/Exchange.js

@@ -4449,10 +4449,15 @@ export default class Exchange {
     }
     handleOptionAndParams2(params, methodName1, optionName1, optionName2, defaultValue = undefined) {
         let value = undefined;
-        [value, params] = this.handleOptionAndParams(params, methodName1, optionName1, defaultValue);
+        [value, params] = this.handleOptionAndParams(params, methodName1, optionName1);
+        if (value !== undefined) {
+            // omit optionName2 too from params
+            params = this.omit(params, optionName2);
+            return [value, params];
+        }
         // if still undefined, try optionName2
         let value2 = undefined;
-        [value2, params] = this.handleOptionAndParams(params, methodName1, optionName2, value);
+        [value2, params] = this.handleOptionAndParams(params, methodName1, optionName2, defaultValue);
         return [value2, params];
     }
     handleOption(methodName, optionName, defaultValue = undefined) {
@@ -5507,52 +5512,52 @@ export default class Exchange {
         const query = this.extend(params, { 'reduceOnly': true });
         return await this.createOrderWs(symbol, type, side, amount, price, query);
     }
-    async createStopOrder(symbol, type, side, amount, price = undefined, stopPrice = undefined, params = {}) {
+    async createStopOrder(symbol, type, side, amount, price = undefined, triggerPrice = undefined, params = {}) {
         if (!this.has['createStopOrder']) {
             throw new NotSupported(this.id + ' createStopOrder() is not supported yet');
         }
-        if (stopPrice === undefined) {
+        if (triggerPrice === undefined) {
             throw new ArgumentsRequired(this.id + ' create_stop_order() requires a stopPrice argument');
         }
-        const query = this.extend(params, { 'stopPrice': stopPrice });
+        const query = this.extend(params, { 'stopPrice': triggerPrice });
         return await this.createOrder(symbol, type, side, amount, price, query);
     }
-    async createStopOrderWs(symbol, type, side, amount, price = undefined, stopPrice = undefined, params = {}) {
+    async createStopOrderWs(symbol, type, side, amount, price = undefined, triggerPrice = undefined, params = {}) {
         if (!this.has['createStopOrderWs']) {
             throw new NotSupported(this.id + ' createStopOrderWs() is not supported yet');
         }
-        if (stopPrice === undefined) {
+        if (triggerPrice === undefined) {
             throw new ArgumentsRequired(this.id + ' createStopOrderWs() requires a stopPrice argument');
         }
-        const query = this.extend(params, { 'stopPrice': stopPrice });
+        const query = this.extend(params, { 'stopPrice': triggerPrice });
         return await this.createOrderWs(symbol, type, side, amount, price, query);
     }
-    async createStopLimitOrder(symbol, side, amount, price, stopPrice, params = {}) {
+    async createStopLimitOrder(symbol, side, amount, price, triggerPrice, params = {}) {
         if (!this.has['createStopLimitOrder']) {
             throw new NotSupported(this.id + ' createStopLimitOrder() is not supported yet');
         }
-        const query = this.extend(params, { 'stopPrice': stopPrice });
+        const query = this.extend(params, { 'stopPrice': triggerPrice });
         return await this.createOrder(symbol, 'limit', side, amount, price, query);
     }
-    async createStopLimitOrderWs(symbol, side, amount, price, stopPrice, params = {}) {
+    async createStopLimitOrderWs(symbol, side, amount, price, triggerPrice, params = {}) {
         if (!this.has['createStopLimitOrderWs']) {
             throw new NotSupported(this.id + ' createStopLimitOrderWs() is not supported yet');
         }
-        const query = this.extend(params, { 'stopPrice': stopPrice });
+        const query = this.extend(params, { 'stopPrice': triggerPrice });
         return await this.createOrderWs(symbol, 'limit', side, amount, price, query);
     }
-    async createStopMarketOrder(symbol, side, amount, stopPrice, params = {}) {
+    async createStopMarketOrder(symbol, side, amount, triggerPrice, params = {}) {
         if (!this.has['createStopMarketOrder']) {
             throw new NotSupported(this.id + ' createStopMarketOrder() is not supported yet');
         }
-        const query = this.extend(params, { 'stopPrice': stopPrice });
+        const query = this.extend(params, { 'stopPrice': triggerPrice });
         return await this.createOrder(symbol, 'market', side, amount, undefined, query);
     }
-    async createStopMarketOrderWs(symbol, side, amount, stopPrice, params = {}) {
+    async createStopMarketOrderWs(symbol, side, amount, triggerPrice, params = {}) {
         if (!this.has['createStopMarketOrderWs']) {
             throw new NotSupported(this.id + ' createStopMarketOrderWs() is not supported yet');
         }
-        const query = this.extend(params, { 'stopPrice': stopPrice });
+        const query = this.extend(params, { 'stopPrice': triggerPrice });
         return await this.createOrderWs(symbol, 'market', side, amount, undefined, query);
     }
     safeCurrencyCode(currencyId, currency = undefined) {

package/js/src/bigone.js

@@ -1378,7 +1378,6 @@ export default class bigone extends Exchange {
             'postOnly': this.safeBool(order, 'post_only'),
             'side': side,
             'price': price,
-            'stopPrice': triggerPrice,
             'triggerPrice': triggerPrice,
             'amount': amount,
             'cost': cost,

package/js/src/binance.js

@@ -637,6 +637,8 @@ export default class binance extends Exchange {
                         'portfolio/bnb-transfer': 150,
                         'portfolio/repay-futures-switch': 150,
                         'portfolio/repay-futures-negative-balance': 150,
+                        'portfolio/mint': 20,
+                        'portfolio/redeem': 20,
                         'lending/auto-invest/plan/add': 0.1,
                         'lending/auto-invest/plan/edit': 0.1,
                         'lending/auto-invest/plan/edit-status': 0.1,
@@ -965,6 +967,7 @@ export default class binance extends Exchange {
                         'block/order/orders': 5,
                         'block/order/execute': 5,
                         'block/user-trades': 5,
+                        'blockTrades': 5,
                     },
                     'post': {
                         'order': 1,

package/js/src/bingx.js

@@ -387,12 +387,26 @@ export default class bingx extends Exchange {
                             'get': {
                                 'uid': 1,
                                 'apiKey/query': 2,
+                                'account/apiPermissions': 5,
                             },
                             'post': {
                                 'innerTransfer/authorizeSubAccount': 1,
                             },
                         },
                     },
+                    'transfer': {
+                        'v1': {
+                            'private': {
+                                'get': {
+                                    'subAccount/asset/transferHistory': 1,
+                                },
+                                'post': {
+                                    'subAccount/transferAsset/supportCoins': 1,
+                                    'subAccount/transferAsset': 1,
+                                },
+                            },
+                        },
+                    },
                 },
                 'user': {
                     'auth': {
@@ -5601,6 +5615,9 @@ export default class bingx extends Exchange {
                 request['endTs'] = now;
             }
             if (market['spot']) {
+                if (limit !== undefined) {
+                    request['limit'] = limit; // default 500, maximum 1000
+                }
                 response = await this.spotV1PrivateGetTradeMyTrades(this.extend(request, params));
                 const data = this.safeDict(response, 'data', {});
                 fills = this.safeList(data, 'fills', []);
@@ -6429,23 +6446,29 @@ export default class bingx extends Exchange {
         };
     }
     sign(path, section = 'public', method = 'GET', params = {}, headers = undefined, body = undefined) {
-        const type = section[0];
-        const version = section[1];
-        const access = section[2];
+        let type = section[0];
+        let version = section[1];
+        let access = section[2];
         const isSandbox = this.safeBool(this.options, 'sandboxMode', false);
         if (isSandbox && (type !== 'swap')) {
             throw new NotSupported(this.id + ' does not have a testnet/sandbox URL for ' + type + ' endpoints');
         }
         let url = this.implodeHostname(this.urls['api'][type]);
-        if (type === 'spot' && version === 'v3') {
-            url += '/api';
-        }
-        else {
-            url += '/' + type;
-        }
-        url += '/' + version + '/';
         path = this.implodeParams(path, params);
-        url += path;
+        if (version === 'transfer') {
+            type = 'account/transfer';
+            version = section[2];
+            access = section[3];
+        }
+        if (path !== 'account/apiPermissions') {
+            if (type === 'spot' && version === 'v3') {
+                url += '/api';
+            }
+            else {
+                url += '/' + type;
+            }
+        }
+        url += '/' + version + '/' + path;
         params = this.omit(params, this.extractParams(path));
         params['timestamp'] = this.nonce();
         params = this.keysort(params);
@@ -6456,7 +6479,7 @@ export default class bingx extends Exchange {
         }
         else if (access === 'private') {
             this.checkRequiredCredentials();
-            const isJsonContentType = ((type === 'subAccount') && (method === 'POST'));
+            const isJsonContentType = (((type === 'subAccount') || (type === 'account/transfer')) && (method === 'POST'));
             const parsedParams = this.parseParams(params);
             const signature = this.hmac(this.encode(this.rawencode(parsedParams)), this.encode(this.secret), sha256);
             headers = {

package/js/src/bitfinex.d.ts

@@ -1,5 +1,5 @@
 import Exchange from './abstract/bitfinex.js';
-import type { TransferEntry, Int, OrderSide, OrderType, Trade, OHLCV, Order, FundingRateHistory, OrderBook, Str, Transaction, Ticker, Balances, Tickers, Strings, Currency, Market, OpenInterest, Liquidation, OrderRequest, Num, MarginModification, Currencies, TradingFees, Dict, LedgerEntry, FundingRate, FundingRates, DepositAddress } from './base/types.js';
+import type { TransferEntry, Int, OrderSide, OrderType, Trade, OHLCV, Order, FundingRateHistory, OrderBook, Str, Transaction, Ticker, Balances, Tickers, Strings, Currency, Market, OpenInterest, Liquidation, OrderRequest, Num, MarginModification, Currencies, TradingFees, Dict, LedgerEntry, FundingRate, FundingRates, DepositAddress, OpenInterests } from './base/types.js';
 /**
  * @class bitfinex
  * @augments Exchange
@@ -416,6 +416,16 @@ export default class bitfinex extends Exchange {
         previousFundingTimestamp: any;
         previousFundingDatetime: any;
     };
+    /**
+     * @method
+     * @name bitfinex#fetchOpenInterests
+     * @description Retrieves the open interest for a list of symbols
+     * @see https://docs.bitfinex.com/reference/rest-public-derivatives-status
+     * @param {string[]} [symbols] a list of unified CCXT market symbols
+     * @param {object} [params] exchange specific parameters
+     * @returns {object[]} a list of [open interest structures]{@link https://docs.ccxt.com/#/?id=open-interest-structure}
+     */
+    fetchOpenInterests(symbols?: Strings, params?: {}): Promise<OpenInterests>;
     /**
      * @method
      * @name bitfinex#fetchOpenInterest