ccxt 4.5.82 → 4.5.83

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

@@ -68,7 +68,7 @@ export declare class BaseExchange {
     fetchIsNative: boolean;
     undiciModule: any;
     zlibModule: any;
-    httpStatusTexts: any;
+    httpStatusTexts: Dict;
     fetchDispatcher: any;
     validateServerSsl: boolean;
     validateClientSsl: boolean;
@@ -84,7 +84,7 @@ export declare class BaseExchange {
     token: string;
     twofa: string;
     accountId: string;
-    balance: any;
+    balance: Dict;
     liquidations: any;
     orderbooks: Dictionary<Ob>;
     tickers: Dictionary<Ticker>;
@@ -332,9 +332,9 @@ export declare class BaseExchange {
     loadHttpProxyAgent(): Promise<any>;
     getHttpAgentIfNeeded(url: any): any;
     addFetchCache(data: any): void;
-    getFetchCache(): Dictionary<any>[];
-    isBinaryMessage(msg: any): msg is ArrayBuffer | Uint8Array<ArrayBufferLike>;
-    stringToBinary(content: any): Uint8Array<ArrayBufferLike>;
+    getFetchCache(): Dict[];
+    isBinaryMessage(msg: any): boolean;
+    stringToBinary(content: any): Uint8Array;
     binaryToString(binary: any): string;
     decodeProtoMsg(data: any): any;
     /**
@@ -443,7 +443,7 @@ export declare class BaseExchange {
     handleRestResponse(response: any, url: any, method?: string, requestHeaders?: any, requestBody?: any): any;
     onRestResponse(statusCode: any, statusText: any, url: any, method: any, responseHeaders: any, responseBody: any, requestHeaders: any, requestBody: any): any;
     onJsonResponse(responseBody: any): any;
-    loadMarketsHelper(reload?: boolean, params?: {}): Promise<Dictionary<Market>>;
+    loadMarketsHelper(reload?: boolean, params?: Dict): Promise<Dictionary<Market>>;
     /**
      * @method
      * @name Exchange#loadMarkets
@@ -459,10 +459,10 @@ export declare class BaseExchange {
      *          If an error occurs during the loading or preparation of the markets, the promise is rejected with the error.
      */
     loadMarkets(reload?: boolean, params?: object): Promise<Dictionary<Market>>;
-    fetchCurrencies(params?: {}): Promise<Currencies>;
-    fetchCurrenciesWs(params?: {}): Promise<Currencies>;
-    fetchMarkets(params?: {}): Promise<Market[]>;
-    fetchMarketsWs(params?: {}): Promise<Market[]>;
+    fetchCurrencies(params?: Dict): Promise<Currencies>;
+    fetchCurrenciesWs(params?: Dict): Promise<Currencies>;
+    fetchMarkets(params?: Dict): Promise<Market[]>;
+    fetchMarketsWs(params?: Dict): Promise<Market[]>;
     checkRequiredDependencies(): void;
     parseNumber(value: any, d?: Num): number;
     checkOrderArguments(market: any, type: any, side: any, amount: any, price: any, params: any): void;
@@ -494,8 +494,8 @@ export declare class BaseExchange {
     isDictionary(value: any): boolean;
     exceptionMessage(exc: any, includeStack?: boolean): string;
     fixStringifiedJsonMembers(content: string): string;
-    ethAbiEncode(types: any, args: any): Uint8Array<ArrayBufferLike>;
-    ethEncodeStructuredData(domain: any, messageTypes: any, messageData: any): Uint8Array<ArrayBufferLike>;
+    ethAbiEncode(types: any, args: any): Uint8Array;
+    ethEncodeStructuredData(domain: any, messageTypes: any, messageData: any): Uint8Array;
     ethGetAddressFromPrivateKey(privateKey: string): string;
     retrieveStarkAccount(signature: any, accountClassHash: any, accountProxyClassHash: any): {
         privateKey: string;
@@ -507,8 +507,8 @@ export declare class BaseExchange {
     extendedStarknetSign(msgHash: any, pri: any): string;
     extendedStarknetGetSelectorFromName(name: any): string;
     extendedStarknetComputePoseidonHashOnElements(data: any): string;
-    getZKContractSignatureObj(seed: any, params?: {}): Promise<any>;
-    getZKTransferSignatureObj(seed: any, params?: {}): Promise<any>;
+    getZKContractSignatureObj(seed: any, params?: Dict): Promise<any>;
+    getZKTransferSignatureObj(seed: any, params?: Dict): Promise<any>;
     loadDydxProtos(): Promise<void>;
     toDydxLong(numStr: Str): object;
     retrieveDydxCredentials(privateKey: Str): object;
@@ -573,7 +573,7 @@ export declare class BaseExchange {
     handleDeltasWithKeys(bookSide: any, deltas: any, priceKey?: IndexType, amountKey?: IndexType, countOrIdKey?: IndexType): void;
     getCacheIndex(orderbook: any, deltas: any): number;
     arraysConcat(arraysOfArrays: any[]): any[];
-    findTimeframe(timeframe: any, timeframes?: NullableDict): string | undefined;
+    findTimeframe(timeframe: any, timeframes?: NullableDict): Str;
     checkProxyUrlSettings(url?: Str, method?: Str, headers?: any, body?: any): Str;
     urlEncoderForProxyUrl(targetUrl: string): string;
     checkProxySettings(url?: Str, method?: Str, headers?: any, body?: any): Str[];
@@ -581,7 +581,7 @@ export declare class BaseExchange {
     checkConflictingProxies(proxyAgentSet: any, proxyUrlSet: any): void;
     checkAddress(address?: Str): Str;
     findMessageHashes(client: any, element: string): string[];
-    filterByLimit(array: Dict[], limit?: Int, key?: IndexType, fromStart?: boolean): any;
+    filterByLimit(array: any[], limit?: Int, key?: IndexType, fromStart?: boolean): any;
     filterBySinceLimit(array: object[] | undefined, since?: Int, limit?: Int, key?: IndexType, tail?: boolean): any;
     filterByValueSinceLimit(array: object[], field: IndexType, value?: any, since?: Int, limit?: Int, key?: string, tail?: boolean): any;
     /**
@@ -598,28 +598,28 @@ export declare class BaseExchange {
      * @param {boolean} [enable] true if demo trading should be enabled, false otherwise
      */
     enableDemoTrading(enable: boolean): void;
-    sign(path: any, api?: any, method?: string, params?: {}, headers?: NullableDict, body?: Str): Dict;
-    fetchAccounts(params?: {}): Promise<Account[]>;
-    watchLiquidations(symbol: string, since?: Int, limit?: Int, params?: {}): Promise<Liquidation[]>;
-    watchLiquidationsForSymbols(symbols: string[], since?: Int, limit?: Int, params?: {}): Promise<Liquidation[]>;
-    watchMyLiquidations(symbol: string, since?: Int, limit?: Int, params?: {}): Promise<Liquidation[]>;
-    watchMyLiquidationsForSymbols(symbols: string[], since?: Int, limit?: Int, params?: {}): Promise<Liquidation[]>;
-    unWatchOrders(symbol?: Str, params?: {}): Promise<any>;
-    unWatchTrades(symbol: string, params?: {}): Promise<any>;
-    unWatchTradesForSymbols(symbols: string[], params?: {}): Promise<any>;
-    watchOHLCVForSymbols(symbolsAndTimeframes: string[][], since?: Int, limit?: Int, params?: {}): Promise<Dictionary<Dictionary<OHLCV[]>>>;
-    unWatchOHLCVForSymbols(symbolsAndTimeframes: string[][], params?: {}): Promise<any>;
-    unWatchOrderBookForSymbols(symbols: string[], params?: {}): Promise<any>;
-    unWatchPositions(symbols?: Strings, params?: {}): Promise<any>;
-    unWatchTicker(symbol: string, params?: {}): Promise<any>;
-    unWatchMarkPrice(symbol: string, params?: {}): Promise<any>;
-    unWatchMarkPrices(symbols?: Strings, params?: {}): Promise<any>;
-    fetchDepositAddresses(codes?: Strings, params?: {}): Promise<DepositAddress[]>;
-    fetchMarginMode(symbol: string, params?: {}): Promise<MarginMode>;
-    fetchMarginModes(symbols?: Strings, params?: {}): Promise<MarginModes>;
-    unWatchOrderBook(symbol: string, params?: {}): Promise<any>;
-    fetchTime(params?: {}): Promise<Int>;
-    fetchTradingLimits(symbols?: Strings, params?: {}): Promise<Dict>;
+    sign(path: any, api?: any, method?: string, params?: Dict, headers?: NullableDict, body?: Str): Dict;
+    fetchAccounts(params?: Dict): Promise<Account[]>;
+    watchLiquidations(symbol: string, since?: Int, limit?: Int, params?: Dict): Promise<Liquidation[]>;
+    watchLiquidationsForSymbols(symbols: string[], since?: Int, limit?: Int, params?: Dict): Promise<Liquidation[]>;
+    watchMyLiquidations(symbol: string, since?: Int, limit?: Int, params?: Dict): Promise<Liquidation[]>;
+    watchMyLiquidationsForSymbols(symbols: string[], since?: Int, limit?: Int, params?: Dict): Promise<Liquidation[]>;
+    unWatchOrders(symbol?: Str, params?: Dict): Promise<any>;
+    unWatchTrades(symbol: string, params?: Dict): Promise<any>;
+    unWatchTradesForSymbols(symbols: string[], params?: Dict): Promise<any>;
+    watchOHLCVForSymbols(symbolsAndTimeframes: string[][], since?: Int, limit?: Int, params?: Dict): Promise<Dictionary<Dictionary<OHLCV[]>>>;
+    unWatchOHLCVForSymbols(symbolsAndTimeframes: string[][], params?: Dict): Promise<any>;
+    unWatchOrderBookForSymbols(symbols: string[], params?: Dict): Promise<any>;
+    unWatchPositions(symbols?: Strings, params?: Dict): Promise<any>;
+    unWatchTicker(symbol: string, params?: Dict): Promise<any>;
+    unWatchMarkPrice(symbol: string, params?: Dict): Promise<any>;
+    unWatchMarkPrices(symbols?: Strings, params?: Dict): Promise<any>;
+    fetchDepositAddresses(codes?: Strings, params?: Dict): Promise<DepositAddress[]>;
+    fetchMarginMode(symbol: string, params?: Dict): Promise<MarginMode>;
+    fetchMarginModes(symbols?: Strings, params?: Dict): Promise<MarginModes>;
+    unWatchOrderBook(symbol: string, params?: Dict): Promise<any>;
+    fetchTime(params?: Dict): Promise<Int>;
+    fetchTradingLimits(symbols?: Strings, params?: Dict): Promise<Dict>;
     parseCurrency(rawCurrency: Dict): Currency;
     parseCurrencies(rawCurrencies: any): Currencies;
     parseMarket(market: Dict): Market;
@@ -632,10 +632,10 @@ export declare class BaseExchange {
     parseAccount(account: Dict): Account;
     parseLedgerEntry(item: Dict, currency?: Currency): LedgerEntry;
     parseOrder(order: Dict, market?: Market): Order;
-    fetchCrossBorrowRates(params?: {}): Promise<CrossBorrowRates>;
-    fetchIsolatedBorrowRates(params?: {}): Promise<IsolatedBorrowRates>;
+    fetchCrossBorrowRates(params?: Dict): Promise<CrossBorrowRates>;
+    fetchIsolatedBorrowRates(params?: Dict): Promise<IsolatedBorrowRates>;
     parseMarketLeverageTiers(info: any, market?: Market): LeverageTier[];
-    fetchLeverageTiers(symbols?: Strings, params?: {}): Promise<LeverageTiers>;
+    fetchLeverageTiers(symbols?: Strings, params?: Dict): Promise<LeverageTiers>;
     parsePosition(position: Dict, market?: Market): Position;
     parseFundingRateHistory(info: any, market?: Market): FundingRateHistory;
     parseBorrowInterest(info: Dict, market?: Market): BorrowInterest;
@@ -644,31 +644,31 @@ export declare class BaseExchange {
     parseWsOrder(order: Dict, market?: Market): Order;
     parseWsOrderTrade(trade: Dict, market?: Market): Trade;
     parseWsOHLCV(ohlcv: any, market?: Market): OHLCV;
-    fetchFundingRates(symbols?: Strings, params?: {}): Promise<FundingRates>;
-    fetchFundingIntervals(symbols?: Strings, params?: {}): Promise<FundingRates>;
-    watchFundingRate(symbol: string, params?: {}): Promise<FundingRate>;
-    watchFundingRates(symbols?: Strings, params?: {}): Promise<FundingRates>;
-    unWatchFundingRates(symbols?: Strings, params?: {}): Promise<any>;
-    watchFundingRatesForSymbols(symbols: string[], params?: {}): Promise<FundingRates>;
-    transfer(code: string, amount: number, fromAccount: string, toAccount: string, params?: {}): Promise<TransferEntry>;
-    withdraw(code: string, amount: number, address: string, tag?: Str, params?: {}): Promise<Transaction>;
-    createDepositAddress(code: string, params?: {}): Promise<DepositAddress>;
-    setLeverage(leverage: int, symbol?: Str, params?: {}): Promise<{}>;
-    fetchLeverage(symbol: string, params?: {}): Promise<Leverage>;
-    fetchLeverages(symbols?: Strings, params?: {}): Promise<Leverages>;
-    setPositionMode(hedged: boolean, symbol?: Str, params?: {}): Promise<{}>;
-    addMargin(symbol: string, amount: number, params?: {}): Promise<MarginModification>;
-    reduceMargin(symbol: string, amount: number, params?: {}): Promise<MarginModification>;
-    setMargin(symbol: string, amount: number, params?: {}): Promise<MarginModification>;
-    fetchLongShortRatio(symbol: string, timeframe?: Str, params?: {}): Promise<LongShortRatio>;
-    fetchLongShortRatioHistory(symbol?: Str, timeframe?: Str, since?: Int, limit?: Int, params?: {}): Promise<LongShortRatio[]>;
-    fetchMarginAdjustmentHistory(symbol?: Str, type?: Str, since?: Num, limit?: Num, params?: {}): Promise<MarginModification[]>;
-    setMarginMode(marginMode: string, symbol?: Str, params?: {}): Promise<{}>;
-    fetchDepositAddressesByNetwork(code: string, params?: {}): Promise<DepositAddresses>;
-    fetchOpenInterestHistory(symbol: string, timeframe?: string, since?: Int, limit?: Int, params?: {}): Promise<OpenInterest[]>;
-    fetchOpenInterests(symbols?: Strings, params?: {}): Promise<OpenInterests>;
+    fetchFundingRates(symbols?: Strings, params?: Dict): Promise<FundingRates>;
+    fetchFundingIntervals(symbols?: Strings, params?: Dict): Promise<FundingRates>;
+    watchFundingRate(symbol: string, params?: Dict): Promise<FundingRate>;
+    watchFundingRates(symbols?: Strings, params?: Dict): Promise<FundingRates>;
+    unWatchFundingRates(symbols?: Strings, params?: Dict): Promise<any>;
+    watchFundingRatesForSymbols(symbols: string[], params?: Dict): Promise<FundingRates>;
+    transfer(code: string, amount: number, fromAccount: string, toAccount: string, params?: Dict): Promise<TransferEntry>;
+    withdraw(code: string, amount: number, address: string, tag?: Str, params?: Dict): Promise<Transaction>;
+    createDepositAddress(code: string, params?: Dict): Promise<DepositAddress>;
+    setLeverage(leverage: int, symbol?: Str, params?: Dict): Promise<{}>;
+    fetchLeverage(symbol: string, params?: Dict): Promise<Leverage>;
+    fetchLeverages(symbols?: Strings, params?: Dict): Promise<Leverages>;
+    setPositionMode(hedged: boolean, symbol?: Str, params?: Dict): Promise<{}>;
+    addMargin(symbol: string, amount: number, params?: Dict): Promise<MarginModification>;
+    reduceMargin(symbol: string, amount: number, params?: Dict): Promise<MarginModification>;
+    setMargin(symbol: string, amount: number, params?: Dict): Promise<MarginModification>;
+    fetchLongShortRatio(symbol: string, timeframe?: Str, params?: Dict): Promise<LongShortRatio>;
+    fetchLongShortRatioHistory(symbol?: Str, timeframe?: Str, since?: Int, limit?: Int, params?: Dict): Promise<LongShortRatio[]>;
+    fetchMarginAdjustmentHistory(symbol?: Str, type?: Str, since?: Num, limit?: Num, params?: Dict): Promise<MarginModification[]>;
+    setMarginMode(marginMode: string, symbol?: Str, params?: Dict): Promise<{}>;
+    fetchDepositAddressesByNetwork(code: string, params?: Dict): Promise<DepositAddresses>;
+    fetchOpenInterestHistory(symbol: string, timeframe?: string, since?: Int, limit?: Int, params?: Dict): Promise<OpenInterest[]>;
+    fetchOpenInterests(symbols?: Strings, params?: Dict): Promise<OpenInterests>;
     signIn(params?: {}): Promise<{}>;
-    fetchPaymentMethods(params?: {}): Promise<{}>;
+    fetchPaymentMethods(params?: Dict): Promise<{}>;
     parseToInt(number: any): number;
     parseToNumeric(number: any): number;
     isRoundNumber(value: number): boolean;
@@ -678,7 +678,7 @@ export declare class BaseExchange {
     afterConstruct(): void;
     initRestRateLimiter(): void;
     featuresGenerator(): void;
-    featuresMapper(initialFeatures: any, marketType: Str, subType?: Str): any;
+    featuresMapper(initialFeatures: Dict, marketType: Str, subType?: Str): any;
     featureValue(symbol: string, methodName?: Str, paramName?: Str, defaultValue?: any): any;
     featureValueByType(marketType: string, subType: Str, methodName?: Str, paramName?: Str, defaultValue?: any): any;
     orderbookChecksumMessage(symbol: Str): string;
@@ -712,23 +712,7 @@ export declare class BaseExchange {
             ARBNOVA: string;
         };
     };
-    safeLedgerEntry(entry: object, currency?: Currency): {
-        id: Str;
-        timestamp: Int;
-        datetime: string | undefined;
-        direction: Str;
-        account: Str;
-        referenceId: Str;
-        referenceAccount: Str;
-        type: Str;
-        currency: string;
-        amount: number;
-        before: number;
-        after: number;
-        status: Str;
-        fee: any;
-        info: Dictionary<any>;
-    };
+    safeLedgerEntry(entry: object, currency?: Currency): LedgerEntry;
     safeCurrencyStructure(currency: Dict): CurrencyInterface;
     safeMarketStructure(market?: NullableDict): Market;
     setMarkets(markets: any, currencies?: undefined): Dictionary<Market>;
@@ -736,14 +720,14 @@ export declare class BaseExchange {
     getDescribeForExtendedWsExchange(currentRestInstance: any, parentRestInstance: any, wsBaseDescribe: Dictionary<any>): any;
     safeBalance(balance: Dict): Balances;
     safeOrder(order: Dict, market?: Market): Order;
-    parseOrders(orders: Dict | Dict[] | undefined, market?: Market, since?: Int, limit?: Int, params?: {}): Order[];
-    calculateFeeWithRate(symbol: string, type: string, side: string, amount: number, price: number, takerOrMaker?: string, feeRate?: Num, params?: {}): {
+    parseOrders(orders: Dict | Dict[] | undefined, market?: Market, since?: Int, limit?: Int, params?: Dict): Order[];
+    calculateFeeWithRate(symbol: string, type: string, side: string, amount: number, price: number, takerOrMaker?: string, feeRate?: Num, params?: Dict): {
         type: string;
         currency: any;
         rate: number;
         cost: number;
     };
-    calculateFee(symbol: string, type: string, side: string, amount: number, price: number, takerOrMaker?: string, params?: {}): {
+    calculateFee(symbol: string, type: string, side: string, amount: number, price: number, takerOrMaker?: string, params?: Dict): {
         type: string;
         currency: any;
         rate: number;
@@ -760,18 +744,18 @@ export declare class BaseExchange {
     stringToBase16(str: any): string;
     reduceFeesByCurrency(fees: any): any[];
     safeTicker(ticker: Dict, market?: Market): Ticker;
-    fetchBorrowRate(code: string, amount: number, params?: {}): Promise<{}>;
-    repayCrossMargin(code: string, amount: number, params?: {}): Promise<MarginLoan>;
-    repayIsolatedMargin(symbol: string, code: string, amount: number, params?: {}): Promise<MarginLoan>;
-    borrowCrossMargin(code: string, amount: number, params?: {}): Promise<MarginLoan>;
-    borrowIsolatedMargin(symbol: string, code: string, amount: number, params?: {}): Promise<MarginLoan>;
-    borrowMargin(code: string, amount: number, symbol?: Str, params?: {}): Promise<MarginLoan>;
-    repayMargin(code: string, amount: number, symbol?: Str, params?: {}): Promise<MarginLoan>;
-    fetchOHLCV(symbol: string, timeframe?: string, since?: Int, limit?: Int, params?: {}): Promise<OHLCV[]>;
-    fetchSpotOHLCV(symbol: string, timeframe?: string, since?: Int, limit?: Int, params?: {}): Promise<OHLCV[]>;
-    fetchContractOHLCV(symbol: string, timeframe?: string, since?: Int, limit?: Int, params?: {}): Promise<OHLCV[]>;
-    fetchOHLCVWs(symbol: string, timeframe?: string, since?: Int, limit?: Int, params?: {}): Promise<OHLCV[]>;
-    watchOHLCV(symbol: string, timeframe?: string, since?: Int, limit?: Int, params?: {}): Promise<OHLCV[]>;
+    fetchBorrowRate(code: string, amount: number, params?: Dict): Promise<{}>;
+    repayCrossMargin(code: string, amount: number, params?: Dict): Promise<MarginLoan>;
+    repayIsolatedMargin(symbol: string, code: string, amount: number, params?: Dict): Promise<MarginLoan>;
+    borrowCrossMargin(code: string, amount: number, params?: Dict): Promise<MarginLoan>;
+    borrowIsolatedMargin(symbol: string, code: string, amount: number, params?: Dict): Promise<MarginLoan>;
+    borrowMargin(code: string, amount: number, symbol?: Str, params?: Dict): Promise<MarginLoan>;
+    repayMargin(code: string, amount: number, symbol?: Str, params?: Dict): Promise<MarginLoan>;
+    fetchOHLCV(symbol: string, timeframe?: string, since?: Int, limit?: Int, params?: Dict): Promise<OHLCV[]>;
+    fetchSpotOHLCV(symbol: string, timeframe?: string, since?: Int, limit?: Int, params?: Dict): Promise<OHLCV[]>;
+    fetchContractOHLCV(symbol: string, timeframe?: string, since?: Int, limit?: Int, params?: Dict): Promise<OHLCV[]>;
+    fetchOHLCVWs(symbol: string, timeframe?: string, since?: Int, limit?: Int, params?: Dict): Promise<OHLCV[]>;
+    watchOHLCV(symbol: string, timeframe?: string, since?: Int, limit?: Int, params?: Dict): Promise<OHLCV[]>;
     convertTradingViewToOHLCV(ohlcvs: number[][], timestamp?: string, open?: string, high?: string, low?: string, close?: string, volume?: string, ms?: boolean): OHLCV[];
     convertOHLCVToTradingView(ohlcvs: number[][], timestamp?: string, open?: string, high?: string, low?: string, close?: string, volume?: string, ms?: boolean): Dict;
     fetchWebEndpoint(method: any, endpointMethod: any, returnAsJson: any, startRegex?: Str, endRegex?: Str): Promise<any>;
@@ -783,7 +767,7 @@ export declare class BaseExchange {
     marketSymbols(symbols: Strings, type: Str | undefined, allowEmpty: false, sameTypeOnly?: boolean, sameSubTypeOnly?: boolean): string[];
     marketSymbols(symbols: string[], type?: Str, allowEmpty?: boolean, sameTypeOnly?: boolean, sameSubTypeOnly?: boolean): string[];
     marketSymbols(symbols?: Strings, type?: Str, allowEmpty?: boolean, sameTypeOnly?: boolean, sameSubTypeOnly?: boolean): Strings;
-    marketCodes(codes?: Strings): string[] | undefined;
+    marketCodes(codes?: Strings): Strings;
     parseOrderBookBidsAsks(bidasks: any, priceKey?: IndexType, amountKey?: IndexType, countOrIdKey?: IndexType): Num[][];
     filterByKey(objects: any, key: IndexType, value?: Str): any;
     filterBySymbol(objects: any, symbol?: Str): any;
@@ -821,18 +805,18 @@ export declare class BaseExchange {
     parseOrderBook(orderbook: object | undefined, symbol: Str, timestamp?: Int, bidsKey?: string, asksKey?: string, priceKey?: IndexType, amountKey?: IndexType, countOrIdKey?: IndexType): OrderBook;
     parseOHLCVs(ohlcvs: object[] | undefined, market?: any, timeframe?: string, since?: Int, limit?: Int, tail?: Bool): OHLCV[];
     parseLeverageTiers(response: any, symbols?: Strings, marketIdKey?: Str): LeverageTiers;
-    loadTradingLimits(symbols?: Strings, reload?: boolean, params?: {}): Promise<Dictionary<any> | undefined>;
+    loadTradingLimits(symbols?: Strings, reload?: boolean, params?: Dict): Promise<Dict | undefined>;
     safePosition(position: Dict): Position;
-    parsePositions(positions: List, symbols?: Strings, params?: {}): Position[];
+    parsePositions(positions: List, symbols?: Strings, params?: Dict): Position[];
     parseADLRank(info: Dict, market?: Market): ADL;
-    parseADLRanks(ranks: List, symbols?: Strings, params?: {}): ADL[];
-    parseAccounts(accounts: List, params?: {}): Account[];
-    parseTradesHelper(isWs: boolean, trades: List, market?: Market, since?: Int, limit?: Int, params?: {}): Trade[];
-    parseTrades(trades: List, market?: Market, since?: Int, limit?: Int, params?: {}): Trade[];
-    parseWsTrades(trades: List, market?: Market, since?: Int, limit?: Int, params?: {}): Trade[];
-    parseTransactions(transactions: List, currency?: Currency, since?: Int, limit?: Int, params?: {}): Transaction[];
-    parseTransfers(transfers: List, currency?: Currency, since?: Int, limit?: Int, params?: {}): TransferEntry[];
-    parseLedger(data: any, currency?: Currency, since?: Int, limit?: Int, params?: {}): LedgerEntry[];
+    parseADLRanks(ranks: List, symbols?: Strings, params?: Dict): ADL[];
+    parseAccounts(accounts: List, params?: Dict): Account[];
+    parseTradesHelper(isWs: boolean, trades: List, market?: Market, since?: Int, limit?: Int, params?: Dict): Trade[];
+    parseTrades(trades: List, market?: Market, since?: Int, limit?: Int, params?: Dict): Trade[];
+    parseWsTrades(trades: List, market?: Market, since?: Int, limit?: Int, params?: Dict): Trade[];
+    parseTransactions(transactions: List, currency?: Currency, since?: Int, limit?: Int, params?: Dict): Transaction[];
+    parseTransfers(transfers: List, currency?: Currency, since?: Int, limit?: Int, params?: Dict): TransferEntry[];
+    parseLedger(data: any, currency?: Currency, since?: Int, limit?: Int, params?: Dict): LedgerEntry[];
     nonce(): number;
     /**
      * @method
@@ -868,89 +852,89 @@ export declare class BaseExchange {
     getSymbolsForMarketType(marketType?: Str, subType?: Str, symbolWithActiveStatus?: boolean, symbolWithUnknownStatus?: boolean): string[];
     filterByArray(objects: any, key: IndexType, values?: any, indexed?: boolean): any;
     filterOutByArray(objects: any, key: IndexType, values?: any, indexed?: boolean): any;
-    fetch2(path: any, api?: any, method?: string, params?: {}, headers?: any, body?: any, config?: {}): Promise<any>;
-    request(path: any, api?: any, method?: string, params?: {}, headers?: any, body?: any, config?: {}): Promise<any>;
-    loadAccounts(reload?: boolean, params?: {}): Promise<Account[]>;
+    fetch2(path: any, api?: any, method?: string, params?: Dict, headers?: any, body?: any, config?: {}): Promise<any>;
+    request(path: any, api?: any, method?: string, params?: Dict, headers?: any, body?: any, config?: {}): Promise<any>;
+    loadAccounts(reload?: boolean, params?: Dict): Promise<Account[]>;
     buildOHLCVC(trades: Trade[], timeframe?: string, since?: number, limit?: number): OHLCVC[];
     parseTradingViewOHLCV(ohlcvs: any, market?: Market, timeframe?: string, since?: Int, limit?: Int): OHLCV[];
-    fetchBorrowInterest(code?: Str, symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<BorrowInterest[]>;
-    fetchLedger(code?: Str, since?: Int, limit?: Int, params?: {}): Promise<LedgerEntry[]>;
-    fetchLedgerEntry(id: string, code?: Str, params?: {}): Promise<LedgerEntry>;
+    fetchBorrowInterest(code?: Str, symbol?: Str, since?: Int, limit?: Int, params?: Dict): Promise<BorrowInterest[]>;
+    fetchLedger(code?: Str, since?: Int, limit?: Int, params?: Dict): Promise<LedgerEntry[]>;
+    fetchLedgerEntry(id: string, code?: Str, params?: Dict): Promise<LedgerEntry>;
     parseOrderBookBidAsk(bidask: any, priceKey?: IndexType, amountKey?: IndexType, countOrIdKey?: IndexType): Num[];
     safeCurrency(currencyId: Str, currency?: Currency): CurrencyInterface;
     safeMarket(marketId?: Str, market?: Market, delimiter?: Str, marketType?: Str): MarketInterface;
     marketOrNull(symbol?: Str): Market;
     checkRequiredCredentials(error?: boolean): boolean;
     oath(): string;
-    fetchBalance(params?: {}): Promise<Balances>;
-    fetchBalanceWs(params?: {}): Promise<Balances>;
+    fetchBalance(params?: Dict): Promise<Balances>;
+    fetchBalanceWs(params?: Dict): Promise<Balances>;
     parseBalance(response: any): Balances;
-    watchBalance(params?: {}): Promise<Balances>;
-    fetchPartialBalance(part: any, params?: {}): Promise<Balance>;
-    fetchFreeBalance(params?: {}): Promise<Balance>;
-    fetchUsedBalance(params?: {}): Promise<Balance>;
-    fetchTotalBalance(params?: {}): Promise<Balance>;
-    fetchStatus(params?: {}): Promise<Status>;
-    fetchTransactionFee(code: string, params?: {}): Promise<{}>;
-    fetchTransactionFees(codes?: Strings, params?: {}): Promise<{}>;
-    fetchDepositWithdrawFees(codes?: Strings, params?: {}): Promise<DepositWithdrawFees>;
-    fetchDepositWithdrawFee(code: string, params?: {}): Promise<DepositWithdrawFee>;
+    watchBalance(params?: Dict): Promise<Balances>;
+    fetchPartialBalance(part: any, params?: Dict): Promise<Balance>;
+    fetchFreeBalance(params?: Dict): Promise<Balance>;
+    fetchUsedBalance(params?: Dict): Promise<Balance>;
+    fetchTotalBalance(params?: Dict): Promise<Balance>;
+    fetchStatus(params?: Dict): Promise<Status>;
+    fetchTransactionFee(code: string, params?: Dict): Promise<{}>;
+    fetchTransactionFees(codes?: Strings, params?: Dict): Promise<{}>;
+    fetchDepositWithdrawFees(codes?: Strings, params?: Dict): Promise<DepositWithdrawFees>;
+    fetchDepositWithdrawFee(code: string, params?: Dict): Promise<DepositWithdrawFee>;
     getSupportedMapping(key: any, mapping?: Dict): any;
     fetchCrossBorrowRate(code: string, params?: {}): Promise<CrossBorrowRate>;
-    fetchIsolatedBorrowRate(symbol: string, params?: {}): Promise<IsolatedBorrowRate>;
+    fetchIsolatedBorrowRate(symbol: string, params?: Dict): Promise<IsolatedBorrowRate>;
     requireValue<T>(value: T | undefined, message?: Str): T;
     handleOptionAndParams<T>(params: object, methodName: string, optionName: string, defaultValue: T): [T, Dict];
     handleOptionAndParams(params: object, methodName: Str, optionName: string, defaultValue?: any): [any, Dict];
     handleOptionAndParams2<T>(params: object, methodName1: string, optionName1: string, optionName2: string, defaultValue: T): [T, Dict];
     handleOptionAndParams2(params: object, methodName1: string, optionName1: string, optionName2: string, defaultValue?: any): [any, Dict];
     handleOption(methodName: string, optionName: string, defaultValue?: any): any;
-    handleMarketTypeAndParams(methodName: string, market?: Market, params?: {}, defaultValue?: any): [string, Dict];
-    handleSubTypeAndParams(methodName: string, market?: Market, params?: {}, defaultValue?: any): [SubType, Dict];
-    handleMarginModeAndParams(methodName: string, params?: {}, defaultValue?: any): [any, Dict];
+    handleMarketTypeAndParams(methodName: string, market?: Market, params?: Dict, defaultValue?: any): [string, Dict];
+    handleSubTypeAndParams(methodName: string, market?: Market, params?: Dict, defaultValue?: any): [SubType, Dict];
+    handleMarginModeAndParams(methodName: string, params?: Dict, defaultValue?: any): [any, Dict];
     throwExactlyMatchedException(exact: any, string: any, message: any): void;
     throwBroadlyMatchedException(broad: any, string: any, message: any): void;
-    findBroadlyMatchedKey(broad: any, string: any): string | undefined;
+    findBroadlyMatchedKey(broad: any, string: any): Str;
     handleErrors(statusCode: int, statusText: string, url: string, method: string, responseHeaders: Dict, responseBody: string, response: any, requestHeaders: any, requestBody: any): undefined;
     calculateRateLimiterCost(api: any, method: any, path: any, params: any, config?: {}): any;
-    fetchSpotTickers(symbols?: Strings, params?: {}): Promise<Tickers>;
-    fetchContractTickers(symbols?: Strings, params?: {}): Promise<Tickers>;
-    fetchOrderBooks(symbols?: Strings, limit?: Int, params?: {}): Promise<OrderBooks>;
-    unWatchTickers(symbols?: Strings, params?: {}): Promise<any>;
-    unWatchFundingRate(symbol: string, params?: {}): Promise<any>;
-    createTwapOrder(symbol: string, side: OrderSide, amount: number, duration: number, params?: {}): Promise<Order>;
-    createConvertTrade(id: string, fromCode: string, toCode: string, amount?: Num, params?: {}): Promise<Conversion>;
-    fetchConvertTrade(id: string, code?: Str, params?: {}): Promise<Conversion>;
-    fetchConvertTradeHistory(code?: Str, since?: Int, limit?: Int, params?: {}): Promise<Conversion[]>;
-    fetchPositionMode(symbol?: Str, params?: {}): Promise<PositionModeInfo>;
-    fetchADLRank(symbol: string, params?: {}): Promise<ADL>;
-    fetchPositionsADLRank(symbols?: Strings, params?: {}): Promise<ADL[]>;
-    fetchPositionADLRank(symbol: string, params?: {}): Promise<ADL>;
+    fetchSpotTickers(symbols?: Strings, params?: Dict): Promise<Tickers>;
+    fetchContractTickers(symbols?: Strings, params?: Dict): Promise<Tickers>;
+    fetchOrderBooks(symbols?: Strings, limit?: Int, params?: Dict): Promise<OrderBooks>;
+    unWatchTickers(symbols?: Strings, params?: Dict): Promise<any>;
+    unWatchFundingRate(symbol: string, params?: Dict): Promise<any>;
+    createTwapOrder(symbol: string, side: OrderSide, amount: number, duration: number, params?: Dict): Promise<Order>;
+    createConvertTrade(id: string, fromCode: string, toCode: string, amount?: Num, params?: Dict): Promise<Conversion>;
+    fetchConvertTrade(id: string, code?: Str, params?: Dict): Promise<Conversion>;
+    fetchConvertTradeHistory(code?: Str, since?: Int, limit?: Int, params?: Dict): Promise<Conversion[]>;
+    fetchPositionMode(symbol?: Str, params?: Dict): Promise<PositionModeInfo>;
+    fetchADLRank(symbol: string, params?: Dict): Promise<ADL>;
+    fetchPositionsADLRank(symbols?: Strings, params?: Dict): Promise<ADL[]>;
+    fetchPositionADLRank(symbol: string, params?: Dict): Promise<ADL>;
     setTakeProfitAndStopLossParams(symbol: string, type: OrderType, side: OrderSide, amount: number, price?: Num, takeProfit?: Num, stopLoss?: Num, params?: Dict): Dict;
-    createSpotOrders(orders: OrderRequest[], params?: {}): Promise<Order[]>;
-    createContractOrders(orders: OrderRequest[], params?: {}): Promise<Order[]>;
-    cancelSpotOrder(id: string, symbol?: Str, params?: {}): Promise<Order>;
-    cancelContractOrder(id: string, symbol?: Str, params?: {}): Promise<Order>;
-    cancelAllSpotOrders(symbol?: Str, params?: {}): Promise<Order[]>;
-    cancelAllContractOrders(symbol?: Str, params?: {}): Promise<Order[]>;
-    cancelAllOrdersAfter(timeout: Int, params?: {}): Promise<{}>;
-    cancelOrdersForSymbols(orders: CancellationRequest[], params?: {}): Promise<Order[]>;
-    fetchMyLiquidations(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<Liquidation[]>;
-    fetchLiquidations(symbol: string, since?: Int, limit?: Int, params?: {}): Promise<Liquidation[]>;
-    fetchGreeks(symbol: string, params?: {}): Promise<Greeks>;
-    fetchAllGreeks(symbols?: Strings, params?: {}): Promise<AllGreeks>;
-    fetchOptionChain(code: string, params?: {}): Promise<OptionChain>;
-    fetchOption(symbol: string, params?: {}): Promise<Option>;
-    fetchConvertQuote(fromCode: string, toCode: string, amount?: Num, params?: {}): Promise<Conversion>;
-    fetchDepositsWithdrawals(code?: Str, since?: Int, limit?: Int, params?: {}): Promise<Transaction[]>;
-    fetchDeposits(code?: Str, since?: Int, limit?: Int, params?: {}): Promise<Transaction[]>;
-    fetchWithdrawals(code?: Str, since?: Int, limit?: Int, params?: {}): Promise<Transaction[]>;
-    fetchDepositsWs(code?: Str, since?: Int, limit?: Int, params?: {}): Promise<Transaction[]>;
-    fetchWithdrawalsWs(code?: Str, since?: Int, limit?: Int, params?: {}): Promise<Transaction[]>;
-    fetchFundingRateHistory(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<FundingRateHistory[]>;
-    fetchFundingHistory(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<FundingHistory[]>;
+    createSpotOrders(orders: OrderRequest[], params?: Dict): Promise<Order[]>;
+    createContractOrders(orders: OrderRequest[], params?: Dict): Promise<Order[]>;
+    cancelSpotOrder(id: string, symbol?: Str, params?: Dict): Promise<Order>;
+    cancelContractOrder(id: string, symbol?: Str, params?: Dict): Promise<Order>;
+    cancelAllSpotOrders(symbol?: Str, params?: Dict): Promise<Order[]>;
+    cancelAllContractOrders(symbol?: Str, params?: Dict): Promise<Order[]>;
+    cancelAllOrdersAfter(timeout: Int, params?: Dict): Promise<{}>;
+    cancelOrdersForSymbols(orders: CancellationRequest[], params?: Dict): Promise<Order[]>;
+    fetchMyLiquidations(symbol?: Str, since?: Int, limit?: Int, params?: Dict): Promise<Liquidation[]>;
+    fetchLiquidations(symbol: string, since?: Int, limit?: Int, params?: Dict): Promise<Liquidation[]>;
+    fetchGreeks(symbol: string, params?: Dict): Promise<Greeks>;
+    fetchAllGreeks(symbols?: Strings, params?: Dict): Promise<AllGreeks>;
+    fetchOptionChain(code: string, params?: Dict): Promise<OptionChain>;
+    fetchOption(symbol: string, params?: Dict): Promise<Option>;
+    fetchConvertQuote(fromCode: string, toCode: string, amount?: Num, params?: Dict): Promise<Conversion>;
+    fetchDepositsWithdrawals(code?: Str, since?: Int, limit?: Int, params?: Dict): Promise<Transaction[]>;
+    fetchDeposits(code?: Str, since?: Int, limit?: Int, params?: Dict): Promise<Transaction[]>;
+    fetchWithdrawals(code?: Str, since?: Int, limit?: Int, params?: Dict): Promise<Transaction[]>;
+    fetchDepositsWs(code?: Str, since?: Int, limit?: Int, params?: Dict): Promise<Transaction[]>;
+    fetchWithdrawalsWs(code?: Str, since?: Int, limit?: Int, params?: Dict): Promise<Transaction[]>;
+    fetchFundingRateHistory(symbol?: Str, since?: Int, limit?: Int, params?: Dict): Promise<FundingRateHistory[]>;
+    fetchFundingHistory(symbol?: Str, since?: Int, limit?: Int, params?: Dict): Promise<FundingHistory[]>;
     parseLastPrice(price: any, market?: Market): LastPrice;
-    fetchDepositAddress(code: string, params?: {}): Promise<DepositAddress>;
-    fetchContractDepositAddress(code: string, params?: {}): Promise<DepositAddress>;
+    fetchDepositAddress(code: string, params?: Dict): Promise<DepositAddress>;
+    fetchContractDepositAddress(code: string, params?: Dict): Promise<DepositAddress>;
     account(): BalanceAccount;
     /**
      * @ignore
@@ -968,30 +952,30 @@ export declare class BaseExchange {
     createExpiredOptionMarket(symbol: string): MarketInterface;
     isLeveragedCurrency(currencyCode: any, checkBaseCoin?: Bool, existingCurrencies?: NullableDict): boolean;
     handleWithdrawTagAndParams(tag: any, params: any): any;
-    costToPrecision(symbol: Str, cost: any): string | undefined;
+    costToPrecision(symbol: Str, cost: any): Str;
     priceToPrecision(symbol: Str, price: any): Str;
-    amountToPrecision(symbol: Str, amount: any): string | undefined;
-    feeToPrecision(symbol: Str, fee: any): string | undefined;
-    currencyToPrecision(code: Str, fee: any, networkCode?: Str): string | undefined;
-    forceString(value: any): string | undefined;
+    amountToPrecision(symbol: Str, amount: any): Str;
+    feeToPrecision(symbol: Str, fee: any): Str;
+    currencyToPrecision(code: Str, fee: any, networkCode?: Str): Str;
+    forceString(value: any): Str;
     isTickPrecision(): boolean;
     isDecimalPrecision(): boolean;
     isSignificantPrecision(): boolean;
     safeNumber(obj: any, key: NullableIndexType, defaultNumber?: Num): Num;
     safeNumberN(obj: object, arr: NullableIndexType[], defaultNumber?: Num): Num;
-    parsePrecision(precision?: string): string | undefined;
-    integerPrecisionToAmount(precision: Str): string | undefined;
-    loadTimeDifference(params?: {}): Promise<any>;
+    parsePrecision(precision?: string): Str;
+    integerPrecisionToAmount(precision: Str): Str;
+    loadTimeDifference(params?: Dict): Promise<any>;
     implodeHostname(url: string): string;
-    fetchMarketLeverageTiers(symbol: string, params?: {}): Promise<LeverageTier[]>;
-    createSubAccount(name: string, params?: {}): Promise<{}>;
+    fetchMarketLeverageTiers(symbol: string, params?: Dict): Promise<LeverageTier[]>;
+    createSubAccount(name: string, params?: Dict): Promise<{}>;
     safeCurrencyCode(currencyId: Str, currency?: Currency): Str;
     filterBySymbolSinceLimit(array: any, symbol?: Str, since?: Int, limit?: Int, tail?: boolean): any;
     filterByCurrencySinceLimit(array: any, code?: Str, since?: Int, limit?: Int, tail?: boolean): any;
     filterBySymbolsSinceLimit(array: any, symbols?: Strings, since?: Int, limit?: Int, tail?: boolean): any;
-    parseLastPrices(pricesData: any, symbols?: Strings, params?: {}): LastPrices;
-    parseTickers(tickers: any, symbols?: Strings, params?: {}): Tickers;
-    parseDepositAddresses(addresses: any, codes?: Strings, indexed?: boolean, params?: {}): DepositAddress[];
+    parseLastPrices(pricesData: any, symbols?: Strings, params?: Dict): LastPrices;
+    parseTickers(tickers: any, symbols?: Strings, params?: Dict): Tickers;
+    parseDepositAddresses(addresses: any, codes?: Strings, indexed?: boolean, params?: Dict): DepositAddress[];
     parseBorrowInterests(response: any, market?: Market): BorrowInterest[];
     parseBorrowRate(info: any, currency?: Currency): Dict;
     parseBorrowRateHistory(response: any, code: Str, since: Int, limit: Int): any;
@@ -1006,21 +990,21 @@ export declare class BaseExchange {
     handleTriggerDirectionAndParams(params: any, exchangeSpecificKey?: Str, allowEmpty?: Bool): any[];
     handleTriggerAndParams(params: any): any[];
     isTriggerOrder(params: any): any[];
-    isPostOnly(isMarketOrder: boolean, exchangeSpecificParam: any, params?: {}): boolean;
+    isPostOnly(isMarketOrder: boolean, exchangeSpecificParam: any, params?: Dict): boolean;
     handlePostOnly(isMarketOrder: boolean, exchangeSpecificPostOnlyOption: boolean, params?: any): any[];
-    fetchLastPrices(symbols?: Strings, params?: {}): Promise<LastPrices>;
-    fetchTradingFees(params?: {}): Promise<TradingFees>;
-    fetchTradingFeesWs(params?: {}): Promise<TradingFees>;
-    fetchConvertCurrencies(params?: {}): Promise<Currencies>;
+    fetchLastPrices(symbols?: Strings, params?: Dict): Promise<LastPrices>;
+    fetchTradingFees(params?: Dict): Promise<TradingFees>;
+    fetchTradingFeesWs(params?: Dict): Promise<TradingFees>;
+    fetchConvertCurrencies(params?: Dict): Promise<Currencies>;
     parseOpenInterest(interest: any, market?: Market): OpenInterest;
     parseOpenInterests(response: any, symbols?: Strings): OpenInterests;
     parseOpenInterestsHistory(response: any, market?: Market, since?: Int, limit?: Int): OpenInterest[];
-    fetchFundingRate(symbol: string, params?: {}): Promise<FundingRate>;
-    fetchFundingInterval(symbol: string, params?: {}): Promise<FundingRate>;
-    fetchMarkOHLCV(symbol: string, timeframe?: string, since?: Int, limit?: Int, params?: {}): Promise<OHLCV[]>;
-    fetchIndexOHLCV(symbol: string, timeframe?: string, since?: Int, limit?: Int, params?: {}): Promise<OHLCV[]>;
-    fetchPremiumIndexOHLCV(symbol: string, timeframe?: string, since?: Int, limit?: Int, params?: {}): Promise<OHLCV[]>;
-    handleTimeInForce(params?: {}): string | undefined;
+    fetchFundingRate(symbol: string, params?: Dict): Promise<FundingRate>;
+    fetchFundingInterval(symbol: string, params?: Dict): Promise<FundingRate>;
+    fetchMarkOHLCV(symbol: string, timeframe?: string, since?: Int, limit?: Int, params?: Dict): Promise<OHLCV[]>;
+    fetchIndexOHLCV(symbol: string, timeframe?: string, since?: Int, limit?: Int, params?: Dict): Promise<OHLCV[]>;
+    fetchPremiumIndexOHLCV(symbol: string, timeframe?: string, since?: Int, limit?: Int, params?: Dict): Promise<OHLCV[]>;
+    handleTimeInForce(params?: Dict): Str;
     convertTypeToAccount(account: any): any;
     checkRequiredArgument(methodName: string, argument: any, argumentName: any, options?: string[]): void;
     checkRequiredMarginArgument(methodName: string, symbol: Str, marginMode: string): void;
@@ -1033,15 +1017,15 @@ export declare class BaseExchange {
     getMarketFromSymbols(symbols: string[]): MarketInterface;
     getMarketFromSymbols(symbols?: Strings): Market;
     parseWsOHLCVs(ohlcvs: object[], market?: any, timeframe?: string, since?: Int, limit?: Int): OHLCV[];
-    fetchTransactions(code?: Str, since?: Int, limit?: Int, params?: {}): Promise<Transaction[]>;
+    fetchTransactions(code?: Str, since?: Int, limit?: Int, params?: Dict): Promise<Transaction[]>;
     filterByArrayPositions(objects: any, key: IndexType, values?: any, indexed?: boolean): Position[];
     filterByArrayTickers(objects: any, key: IndexType, values?: any, indexed?: boolean): Dictionary<Ticker>;
     filterByArrayADLRanks(objects: any, key: IndexType, values?: any, indexed?: boolean): ADL[];
     createOHLCVObject(symbol: string, timeframe: string, data: any): Dictionary<Dictionary<OHLCV[]>>;
-    handleMaxEntriesPerRequestAndParams(method: string, maxEntriesPerRequest?: Int, params?: {}): [Int, any];
+    handleMaxEntriesPerRequestAndParams(method: string, maxEntriesPerRequest?: Int, params?: Dict): [Int, any];
     fetchPaginatedCallDynamic(method: string, symbol?: Str, since?: Int, limit?: Int, params?: Dict, maxEntriesPerRequest?: Int, removeRepeated?: boolean): Promise<any>;
-    safeDeterministicCall(method: string, symbol?: Str, since?: Int, limit?: Int, timeframe?: Str, params?: {}): Promise<any>;
-    fetchPaginatedCallDeterministic(method: string, symbol?: Str, since?: Int, limit?: Int, timeframe?: Str, params?: {}, maxEntriesPerRequest?: Int): Promise<any>;
+    safeDeterministicCall(method: string, symbol?: Str, since?: Int, limit?: Int, timeframe?: Str, params?: Dict): Promise<any>;
+    fetchPaginatedCallDeterministic(method: string, symbol?: Str, since?: Int, limit?: Int, timeframe?: Str, params?: Dict, maxEntriesPerRequest?: Int): Promise<any>;
     fetchPaginatedCallCursor(method: string, symbol?: Str | Strings, since?: Int, limit?: Int, params?: Dict, cursorReceived?: Str, cursorSent?: Str, cursorIncrement?: Int, maxEntriesPerRequest?: Int): Promise<any>;
     fetchPaginatedCallIncremental(method: string, symbol?: Str, since?: Int, limit?: Int, params?: Dict, pageKey?: Str, maxEntriesPerRequest?: Int): Promise<any>;
     sortCursorPaginatedResult(result: any): any;
@@ -1053,14 +1037,14 @@ export declare class BaseExchange {
     parseLiquidation(liquidation: any, market?: Market): Liquidation;
     parseLiquidations(liquidations: Dict[], market?: Market, since?: Int, limit?: Int): Liquidation[];
     parseGreeks(greeks: Dict, market?: Market): Greeks;
-    parseAllGreeks(greeks: any, symbols?: Strings, params?: {}): AllGreeks;
+    parseAllGreeks(greeks: any, symbols?: Strings, params?: Dict): AllGreeks;
     parseOption(chain: Dict, currency?: Currency, market?: Market): Option;
     parseOptionChain(response: object[], currencyKey?: Str, symbolKey?: Str): OptionChain;
     parseMarginModes(response: object[], symbols?: Strings, symbolKey?: Str, marketType?: MarketType | undefined): MarginModes;
     parseMarginMode(marginMode: Dict, market?: Market): MarginMode;
     parseLeverages(response: object[], symbols?: Strings, symbolKey?: Str, marketType?: MarketType | undefined): Leverages;
     parseLeverage(leverage: Dict, market?: Market): Leverage;
-    parseConversions(conversions: List, code?: Str, fromCurrencyKey?: Str, toCurrencyKey?: Str, since?: Int, limit?: Int, params?: {}): Conversion[];
+    parseConversions(conversions: List, code?: Str, fromCurrencyKey?: Str, toCurrencyKey?: Str, since?: Int, limit?: Int, params?: Dict): Conversion[];
     parseConversion(conversion: Dict, fromCurrency?: Currency, toCurrency?: Currency): Conversion;
     convertExpireDate(date: Str): Str;
     convertExpireDateToMarketIdDate(date: Str): Str;
@@ -1068,97 +1052,97 @@ export declare class BaseExchange {
     loadMarketsAndSignIn(): Promise<void>;
     parseMarginModification(data: Dict, market?: Market): MarginModification;
     parseMarginModifications(response: object[] | undefined, symbols?: Strings, symbolKey?: Str, marketType?: MarketType | undefined): MarginModification[];
-    fetchTransfer(id: string, code?: Str, params?: {}): Promise<TransferEntry>;
-    fetchTransfers(code?: Str, since?: Int, limit?: Int, params?: {}): Promise<TransferEntry[]>;
-    unWatchOHLCV(symbol: string, timeframe?: string, params?: {}): Promise<any>;
-    withdrawWs(code: string, amount: number, address: string, tag?: Str, params?: {}): Promise<Transaction>;
-    unWatchMyTrades(symbol?: Str, params?: {}): Promise<any>;
-    fetchOrdersByStatusWs(status: string, symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<Order[]>;
-    unWatchBidsAsks(symbols?: Strings, params?: {}): Promise<any>;
+    fetchTransfer(id: string, code?: Str, params?: Dict): Promise<TransferEntry>;
+    fetchTransfers(code?: Str, since?: Int, limit?: Int, params?: Dict): Promise<TransferEntry[]>;
+    unWatchOHLCV(symbol: string, timeframe?: string, params?: Dict): Promise<any>;
+    withdrawWs(code: string, amount: number, address: string, tag?: Str, params?: Dict): Promise<Transaction>;
+    unWatchMyTrades(symbol?: Str, params?: Dict): Promise<any>;
+    fetchOrdersByStatusWs(status: string, symbol?: Str, since?: Int, limit?: Int, params?: Dict): Promise<Order[]>;
+    unWatchBidsAsks(symbols?: Strings, params?: Dict): Promise<any>;
     cleanUnsubscription(client: any, subHash: Str, unsubHash: Str, subHashIsPrefix?: boolean): void;
     cleanCache(subscription: Dict | undefined): void;
     timeframeFromMilliseconds(ms: number): string;
-    isUTAEnabled(params?: {}): Promise<boolean>;
+    isUTAEnabled(params?: Dict): Promise<boolean>;
 }
 export default class Exchange extends BaseExchange {
-    closePosition(symbol: string, side?: OrderSide, params?: {}): Promise<Order>;
-    closeAllPositions(params?: {}): Promise<Position[]>;
-    editOrders(orders: OrderRequest[], params?: {}): Promise<Order[]>;
-    fetchCanceledAndClosedOrders(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<Order[]>;
-    fetchPositionHistory(symbol: string, since?: Int, limit?: Int, params?: {}): Promise<Position[]>;
-    fetchPositionsHistory(symbols?: Strings, since?: Int, limit?: Int, params?: {}): Promise<Position[]>;
-    fetchPositionsRisk(symbols?: Strings, params?: {}): Promise<Position[]>;
-    fetchPositionsForSymbol(symbol: string, params?: {}): Promise<Position[]>;
-    fetchPositionsForSymbolWs(symbol: string, params?: {}): Promise<Position[]>;
-    watchPosition(symbol?: Str, params?: {}): Promise<Position>;
-    watchMyTradesForSymbols(symbols: string[], since?: Int, limit?: Int, params?: {}): Promise<Trade[]>;
-    watchTradesForSymbols(symbols: string[], since?: Int, limit?: Int, params?: {}): Promise<Trade[]>;
-    fetchBidsAsks(symbols?: Strings, params?: {}): Promise<Tickers>;
-    fetchMarkPrice(symbol: string, params?: {}): Promise<Ticker>;
-    fetchMarkPrices(symbols?: Strings, params?: {}): Promise<Tickers>;
-    watchBidsAsks(symbols?: Strings, params?: {}): Promise<Tickers>;
-    watchMarkPrice(symbol: string, params?: {}): Promise<Ticker>;
-    watchMarkPrices(symbols?: Strings, params?: {}): Promise<Tickers>;
-    fetchL3OrderBook(symbol: string, limit?: Int, params?: {}): Promise<OrderBook>;
-    watchOrderBookForSymbols(symbols: string[], limit?: Int, params?: {}): Promise<OrderBook>;
-    watchOrdersForSymbols(symbols: string[], since?: Int, limit?: Int, params?: {}): Promise<Order[]>;
-    cancelAllOrdersWs(symbol?: Str, params?: {}): Promise<Order[]>;
-    cancelOrderWs(id: string, symbol?: Str, params?: {}): Promise<Order>;
-    cancelOrdersWs(ids: string[], symbol?: Str, params?: {}): Promise<Order[]>;
-    createLimitBuyOrderWs(symbol: string, amount: number, price: number, params?: {}): Promise<Order>;
-    createLimitOrderWs(symbol: string, side: OrderSide, amount: number, price: number, params?: {}): Promise<Order>;
-    createLimitSellOrderWs(symbol: string, amount: number, price: number, params?: {}): Promise<Order>;
-    createMarketBuyOrderWs(symbol: string, amount: number, params?: {}): Promise<Order>;
-    createMarketOrderWithCostWs(symbol: string, side: OrderSide, cost: number, params?: {}): Promise<Order>;
-    createMarketOrderWs(symbol: string, side: OrderSide, amount: number, price?: Num, params?: {}): Promise<Order>;
-    createMarketSellOrderWs(symbol: string, amount: number, params?: {}): Promise<Order>;
-    createOrderWithTakeProfitAndStopLossWs(symbol: string, type: OrderType, side: OrderSide, amount: number, price?: Num, takeProfit?: Num, stopLoss?: Num, params?: {}): Promise<Order>;
-    createOrderWs(symbol: string, type: OrderType, side: OrderSide, amount: number, price?: Num, params?: {}): Promise<Order>;
-    createOrdersWs(orders: OrderRequest[], params?: {}): Promise<Order[]>;
-    createPostOnlyOrderWs(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>;
-    createStopLimitOrderWs(symbol: string, side: OrderSide, amount: number, price: number, triggerPrice: number, params?: {}): Promise<Order>;
-    createStopLossOrderWs(symbol: string, type: OrderType, side: OrderSide, amount: number, price?: Num, stopLossPrice?: Num, params?: {}): Promise<Order>;
-    createStopMarketOrderWs(symbol: string, side: OrderSide, amount: number, triggerPrice: number, params?: {}): Promise<Order>;
-    createStopOrderWs(symbol: string, type: OrderType, side: OrderSide, amount: number, price?: Num, triggerPrice?: Num, params?: {}): Promise<Order>;
-    createTakeProfitOrderWs(symbol: string, type: OrderType, side: OrderSide, amount: number, price?: Num, takeProfitPrice?: Num, params?: {}): Promise<Order>;
+    closePosition(symbol: string, side?: OrderSide, params?: Dict): Promise<Order>;
+    closeAllPositions(params?: Dict): Promise<Position[]>;
+    editOrders(orders: OrderRequest[], params?: Dict): Promise<Order[]>;
+    fetchCanceledAndClosedOrders(symbol?: Str, since?: Int, limit?: Int, params?: Dict): Promise<Order[]>;
+    fetchPositionHistory(symbol: string, since?: Int, limit?: Int, params?: Dict): Promise<Position[]>;
+    fetchPositionsHistory(symbols?: Strings, since?: Int, limit?: Int, params?: Dict): Promise<Position[]>;
+    fetchPositionsRisk(symbols?: Strings, params?: Dict): Promise<Position[]>;
+    fetchPositionsForSymbol(symbol: string, params?: Dict): Promise<Position[]>;
+    fetchPositionsForSymbolWs(symbol: string, params?: Dict): Promise<Position[]>;
+    watchPosition(symbol?: Str, params?: Dict): Promise<Position>;
+    watchMyTradesForSymbols(symbols: string[], since?: Int, limit?: Int, params?: Dict): Promise<Trade[]>;
+    watchTradesForSymbols(symbols: string[], since?: Int, limit?: Int, params?: Dict): Promise<Trade[]>;
+    fetchBidsAsks(symbols?: Strings, params?: Dict): Promise<Tickers>;
+    fetchMarkPrice(symbol: string, params?: Dict): Promise<Ticker>;
+    fetchMarkPrices(symbols?: Strings, params?: Dict): Promise<Tickers>;
+    watchBidsAsks(symbols?: Strings, params?: Dict): Promise<Tickers>;
+    watchMarkPrice(symbol: string, params?: Dict): Promise<Ticker>;
+    watchMarkPrices(symbols?: Strings, params?: Dict): Promise<Tickers>;
+    fetchL3OrderBook(symbol: string, limit?: Int, params?: Dict): Promise<OrderBook>;
+    watchOrderBookForSymbols(symbols: string[], limit?: Int, params?: Dict): Promise<OrderBook>;
+    watchOrdersForSymbols(symbols: string[], since?: Int, limit?: Int, params?: Dict): Promise<Order[]>;
+    cancelAllOrdersWs(symbol?: Str, params?: Dict): Promise<Order[]>;
+    cancelOrderWs(id: string, symbol?: Str, params?: Dict): Promise<Order>;
+    cancelOrdersWs(ids: string[], symbol?: Str, params?: Dict): Promise<Order[]>;
+    createLimitBuyOrderWs(symbol: string, amount: number, price: number, params?: Dict): Promise<Order>;
+    createLimitOrderWs(symbol: string, side: OrderSide, amount: number, price: number, params?: Dict): Promise<Order>;
+    createLimitSellOrderWs(symbol: string, amount: number, price: number, params?: Dict): Promise<Order>;
+    createMarketBuyOrderWs(symbol: string, amount: number, params?: Dict): Promise<Order>;
+    createMarketOrderWithCostWs(symbol: string, side: OrderSide, cost: number, params?: Dict): Promise<Order>;
+    createMarketOrderWs(symbol: string, side: OrderSide, amount: number, price?: Num, params?: Dict): Promise<Order>;
+    createMarketSellOrderWs(symbol: string, amount: number, params?: Dict): Promise<Order>;
+    createOrderWithTakeProfitAndStopLossWs(symbol: string, type: OrderType, side: OrderSide, amount: number, price?: Num, takeProfit?: Num, stopLoss?: Num, params?: Dict): Promise<Order>;
+    createOrderWs(symbol: string, type: OrderType, side: OrderSide, amount: number, price?: Num, params?: Dict): Promise<Order>;
+    createOrdersWs(orders: OrderRequest[], params?: Dict): Promise<Order[]>;
+    createPostOnlyOrderWs(symbol: string, type: OrderType, side: OrderSide, amount: number, price?: Num, params?: Dict): Promise<Order>;
+    createReduceOnlyOrderWs(symbol: string, type: OrderType, side: OrderSide, amount: number, price?: Num, params?: Dict): Promise<Order>;
+    createStopLimitOrderWs(symbol: string, side: OrderSide, amount: number, price: number, triggerPrice: number, params?: Dict): Promise<Order>;
+    createStopLossOrderWs(symbol: string, type: OrderType, side: OrderSide, amount: number, price?: Num, stopLossPrice?: Num, params?: Dict): Promise<Order>;
+    createStopMarketOrderWs(symbol: string, side: OrderSide, amount: number, triggerPrice: number, params?: Dict): Promise<Order>;
+    createStopOrderWs(symbol: string, type: OrderType, side: OrderSide, amount: number, price?: Num, triggerPrice?: Num, params?: Dict): Promise<Order>;
+    createTakeProfitOrderWs(symbol: string, type: OrderType, side: OrderSide, amount: number, price?: Num, takeProfitPrice?: Num, params?: Dict): Promise<Order>;
     createTrailingAmountOrderWs(symbol: string, type: OrderType, side: OrderSide, amount: number, price?: Num, trailingAmount?: Num, trailingTriggerPrice?: Num, params?: Dict): Promise<Order>;
     createTrailingPercentOrderWs(symbol: string, type: OrderType, side: OrderSide, amount: number, price?: Num, trailingPercent?: Num, trailingTriggerPrice?: Num, params?: Dict): Promise<Order>;
-    createTriggerOrderWs(symbol: string, type: OrderType, side: OrderSide, amount: number, price?: Num, triggerPrice?: Num, params?: {}): Promise<Order>;
-    editOrderWs(id: string, symbol: string, type: OrderType, side: OrderSide, amount?: Num, price?: Num, params?: {}): Promise<Order>;
-    fetchClosedOrdersWs(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<Order[]>;
-    fetchMyTradesWs(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<Trade[]>;
-    fetchOpenOrdersWs(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<Order[]>;
-    fetchOrderBookWs(symbol: string, limit?: Int, params?: {}): Promise<OrderBook>;
-    fetchOrderWs(id: string, symbol?: Str, params?: {}): Promise<Order>;
-    fetchOrdersWs(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<Order[]>;
-    fetchPositionWs(symbol: string, params?: {}): Promise<Position[]>;
-    fetchPositionsWs(symbols?: Strings, params?: {}): Promise<Position[]>;
-    fetchTickerWs(symbol: string, params?: {}): Promise<Ticker>;
-    fetchTickersWs(symbols?: Strings, params?: {}): Promise<Tickers>;
-    fetchTradesWs(symbol: string, since?: Int, limit?: Int, params?: {}): Promise<Trade[]>;
+    createTriggerOrderWs(symbol: string, type: OrderType, side: OrderSide, amount: number, price?: Num, triggerPrice?: Num, params?: Dict): Promise<Order>;
+    editOrderWs(id: string, symbol: string, type: OrderType, side: OrderSide, amount?: Num, price?: Num, params?: Dict): Promise<Order>;
+    fetchClosedOrdersWs(symbol?: Str, since?: Int, limit?: Int, params?: Dict): Promise<Order[]>;
+    fetchMyTradesWs(symbol?: Str, since?: Int, limit?: Int, params?: Dict): Promise<Trade[]>;
+    fetchOpenOrdersWs(symbol?: Str, since?: Int, limit?: Int, params?: Dict): Promise<Order[]>;
+    fetchOrderBookWs(symbol: string, limit?: Int, params?: Dict): Promise<OrderBook>;
+    fetchOrderWs(id: string, symbol?: Str, params?: Dict): Promise<Order>;
+    fetchOrdersWs(symbol?: Str, since?: Int, limit?: Int, params?: Dict): Promise<Order[]>;
+    fetchPositionWs(symbol: string, params?: Dict): Promise<Position[]>;
+    fetchPositionsWs(symbols?: Strings, params?: Dict): Promise<Position[]>;
+    fetchTickerWs(symbol: string, params?: Dict): Promise<Ticker>;
+    fetchTickersWs(symbols?: Strings, params?: Dict): Promise<Tickers>;
+    fetchTradesWs(symbol: string, since?: Int, limit?: Int, params?: Dict): Promise<Trade[]>;
     loadOrderBook(client: any, messageHash: string, symbol: string, limit?: Int, params?: {}): Promise<void>;
-    fetchTrades(symbol: string, since?: Int, limit?: Int, params?: {}): Promise<Trade[]>;
-    watchTrades(symbol: string, since?: Int, limit?: Int, params?: {}): Promise<Trade[]>;
-    fetchOrderBook(symbol: string, limit?: Int, params?: {}): Promise<OrderBook>;
-    fetchRestOrderBookSafe(symbol: any, limit?: Int, params?: {}): Promise<OrderBook | undefined>;
-    watchOrderBook(symbol: string, limit?: Int, params?: {}): Promise<OrderBook>;
-    fetchOpenInterest(symbol: string, params?: {}): Promise<OpenInterest>;
-    fetchL2OrderBook(symbol: string, limit?: Int, params?: {}): Promise<any>;
-    editLimitBuyOrder(id: string, symbol: string, amount: number, price?: Num, params?: {}): Promise<Order>;
-    editLimitSellOrder(id: string, symbol: string, amount: number, price?: Num, params?: {}): Promise<Order>;
-    editLimitOrder(id: string, symbol: string, side: OrderSide, amount: number, price?: Num, params?: {}): Promise<Order>;
-    editOrder(id: string, symbol: string, type: OrderType, side: OrderSide, amount?: Num, price?: Num, params?: {}): Promise<Order>;
-    editOrderWithClientOrderId(clientOrderId: string, symbol: string, type: OrderType, side: OrderSide, amount?: Num, price?: Num, params?: {}): Promise<Order>;
-    fetchPosition(symbol: string, params?: {}): Promise<Position>;
-    watchPositions(symbols?: Strings, since?: Int, limit?: Int, params?: {}): Promise<Position[]>;
-    watchPositionForSymbols(symbols?: Strings, since?: Int, limit?: Int, params?: {}): Promise<Position[]>;
-    fetchPositions(symbols?: Strings, params?: {}): Promise<Position[]>;
-    fetchTicker(symbol: string, params?: {}): Promise<Ticker>;
-    watchTicker(symbol: string, params?: {}): Promise<Ticker>;
-    fetchTickers(symbols?: Strings, params?: {}): Promise<Tickers>;
-    watchTickers(symbols?: Strings, params?: {}): Promise<Tickers>;
-    fetchOrder(id: string, symbol?: Str, params?: {}): Promise<Order>;
+    fetchTrades(symbol: string, since?: Int, limit?: Int, params?: Dict): Promise<Trade[]>;
+    watchTrades(symbol: string, since?: Int, limit?: Int, params?: Dict): Promise<Trade[]>;
+    fetchOrderBook(symbol: string, limit?: Int, params?: Dict): Promise<OrderBook>;
+    fetchRestOrderBookSafe(symbol: any, limit?: Int, params?: Dict): Promise<OrderBook | undefined>;
+    watchOrderBook(symbol: string, limit?: Int, params?: Dict): Promise<OrderBook>;
+    fetchOpenInterest(symbol: string, params?: Dict): Promise<OpenInterest>;
+    fetchL2OrderBook(symbol: string, limit?: Int, params?: Dict): Promise<any>;
+    editLimitBuyOrder(id: string, symbol: string, amount: number, price?: Num, params?: Dict): Promise<Order>;
+    editLimitSellOrder(id: string, symbol: string, amount: number, price?: Num, params?: Dict): Promise<Order>;
+    editLimitOrder(id: string, symbol: string, side: OrderSide, amount: number, price?: Num, params?: Dict): Promise<Order>;
+    editOrder(id: string, symbol: string, type: OrderType, side: OrderSide, amount?: Num, price?: Num, params?: Dict): Promise<Order>;
+    editOrderWithClientOrderId(clientOrderId: string, symbol: string, type: OrderType, side: OrderSide, amount?: Num, price?: Num, params?: Dict): Promise<Order>;
+    fetchPosition(symbol: string, params?: Dict): Promise<Position>;
+    watchPositions(symbols?: Strings, since?: Int, limit?: Int, params?: Dict): Promise<Position[]>;
+    watchPositionForSymbols(symbols?: Strings, since?: Int, limit?: Int, params?: Dict): Promise<Position[]>;
+    fetchPositions(symbols?: Strings, params?: Dict): Promise<Position[]>;
+    fetchTicker(symbol: string, params?: Dict): Promise<Ticker>;
+    watchTicker(symbol: string, params?: Dict): Promise<Ticker>;
+    fetchTickers(symbols?: Strings, params?: Dict): Promise<Tickers>;
+    watchTickers(symbols?: Strings, params?: Dict): Promise<Tickers>;
+    fetchOrder(id: string, symbol?: Str, params?: Dict): Promise<Order>;
     /**
      * @method
      * @name fetchOrderWithClientOrderId
@@ -1168,21 +1152,21 @@ export default class Exchange extends BaseExchange {
      * @param {object} [params] extra parameters specific to the exchange API endpoint
      * @returns {object} an [order structure]{@link https://docs.ccxt.com/?id=order-structure}
      */
-    fetchOrderWithClientOrderId(clientOrderId: string, symbol?: Str, params?: {}): Promise<Order>;
-    fetchOrderStatus(id: string, symbol?: Str, params?: {}): Promise<Str>;
-    fetchUnifiedOrder(order: any, params?: {}): Promise<Order>;
-    createOrder(symbol: string, type: OrderType, side: OrderSide, amount: number, price?: Num, params?: {}): Promise<Order>;
+    fetchOrderWithClientOrderId(clientOrderId: string, symbol?: Str, params?: Dict): Promise<Order>;
+    fetchOrderStatus(id: string, symbol?: Str, params?: Dict): Promise<Str>;
+    fetchUnifiedOrder(order: any, params?: Dict): Promise<Order>;
+    createOrder(symbol: string, type: OrderType, side: OrderSide, amount: number, price?: Num, params?: Dict): Promise<Order>;
     createTrailingAmountOrder(symbol: string, type: OrderType, side: OrderSide, amount: number, price?: Num, trailingAmount?: Num, trailingTriggerPrice?: Num, params?: Dict): Promise<Order>;
     createTrailingPercentOrder(symbol: string, type: OrderType, side: OrderSide, amount: number, price?: Num, trailingPercent?: Num, trailingTriggerPrice?: Num, params?: Dict): Promise<Order>;
-    createMarketOrderWithCost(symbol: string, side: OrderSide, cost: number, params?: {}): Promise<Order>;
-    createMarketBuyOrderWithCost(symbol: string, cost: number, params?: {}): Promise<Order>;
-    createMarketSellOrderWithCost(symbol: string, cost: number, params?: {}): Promise<Order>;
-    createTriggerOrder(symbol: string, type: OrderType, side: OrderSide, amount: number, price?: Num, triggerPrice?: Num, params?: {}): Promise<Order>;
-    createStopLossOrder(symbol: string, type: OrderType, side: OrderSide, amount: number, price?: Num, stopLossPrice?: Num, params?: {}): Promise<Order>;
-    createTakeProfitOrder(symbol: string, type: OrderType, side: OrderSide, amount: number, price?: Num, takeProfitPrice?: Num, params?: {}): Promise<Order>;
-    createOrderWithTakeProfitAndStopLoss(symbol: string, type: OrderType, side: OrderSide, amount: number, price?: Num, takeProfit?: Num, stopLoss?: Num, params?: {}): Promise<Order>;
-    createOrders(orders: OrderRequest[], params?: {}): Promise<Order[]>;
-    cancelOrder(id: string, symbol?: Str, params?: {}): Promise<Order>;
+    createMarketOrderWithCost(symbol: string, side: OrderSide, cost: number, params?: Dict): Promise<Order>;
+    createMarketBuyOrderWithCost(symbol: string, cost: number, params?: Dict): Promise<Order>;
+    createMarketSellOrderWithCost(symbol: string, cost: number, params?: Dict): Promise<Order>;
+    createTriggerOrder(symbol: string, type: OrderType, side: OrderSide, amount: number, price?: Num, triggerPrice?: Num, params?: Dict): Promise<Order>;
+    createStopLossOrder(symbol: string, type: OrderType, side: OrderSide, amount: number, price?: Num, stopLossPrice?: Num, params?: Dict): Promise<Order>;
+    createTakeProfitOrder(symbol: string, type: OrderType, side: OrderSide, amount: number, price?: Num, takeProfitPrice?: Num, params?: Dict): Promise<Order>;
+    createOrderWithTakeProfitAndStopLoss(symbol: string, type: OrderType, side: OrderSide, amount: number, price?: Num, takeProfit?: Num, stopLoss?: Num, params?: Dict): Promise<Order>;
+    createOrders(orders: OrderRequest[], params?: Dict): Promise<Order[]>;
+    cancelOrder(id: string, symbol?: Str, params?: Dict): Promise<Order>;
     /**
      * @method
      * @name cancelOrderWithClientOrderId
@@ -1192,8 +1176,8 @@ export default class Exchange extends BaseExchange {
      * @param {object} [params] extra parameters specific to the exchange API endpoint
      * @returns {object} an [order structure]{@link https://docs.ccxt.com/?id=order-structure}
      */
-    cancelOrderWithClientOrderId(clientOrderId: string, symbol?: Str, params?: {}): Promise<Order>;
-    cancelOrders(ids: string[], symbol?: Str, params?: {}): Promise<Order[]>;
+    cancelOrderWithClientOrderId(clientOrderId: string, symbol?: Str, params?: Dict): Promise<Order>;
+    cancelOrders(ids: string[], symbol?: Str, params?: Dict): Promise<Order[]>;
     /**
      * @method
      * @name cancelOrdersWithClientOrderIds
@@ -1203,28 +1187,28 @@ export default class Exchange extends BaseExchange {
      * @param {object} [params] extra parameters specific to the exchange API endpoint
      * @returns {object} an [order structure]{@link https://docs.ccxt.com/?id=order-structure}
      */
-    cancelOrdersWithClientOrderIds(clientOrderIds: string[], symbol?: Str, params?: {}): Promise<Order[]>;
-    cancelAllOrders(symbol?: Str, params?: {}): Promise<Order[]>;
-    cancelUnifiedOrder(order: Order, params?: {}): Promise<Order>;
-    fetchOrders(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<Order[]>;
-    fetchOrderTrades(id: string, symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<Trade[]>;
-    watchOrders(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<Order[]>;
-    fetchOpenOrders(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<Order[]>;
-    fetchClosedOrders(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<Order[]>;
-    fetchCanceledOrders(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<Order[]>;
-    fetchMyTrades(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<Trade[]>;
-    watchMyTrades(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<Trade[]>;
-    createLimitOrder(symbol: string, side: OrderSide, amount: number, price: number, params?: {}): Promise<Order>;
-    createMarketOrder(symbol: string, side: OrderSide, amount: number, price?: Num, params?: {}): Promise<Order>;
-    createLimitBuyOrder(symbol: string, amount: number, price: number, params?: {}): Promise<Order>;
-    createLimitSellOrder(symbol: string, amount: number, price: number, params?: {}): Promise<Order>;
-    createMarketBuyOrder(symbol: string, amount: number, params?: {}): Promise<Order>;
-    createMarketSellOrder(symbol: string, amount: number, params?: {}): Promise<Order>;
-    createPostOnlyOrder(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>;
-    createStopOrder(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>;
-    createStopMarketOrder(symbol: string, side: OrderSide, amount: number, triggerPrice: number, params?: {}): Promise<Order>;
-    fetchTradingFee(symbol: string, params?: {}): Promise<TradingFeeInterface>;
+    cancelOrdersWithClientOrderIds(clientOrderIds: string[], symbol?: Str, params?: Dict): Promise<Order[]>;
+    cancelAllOrders(symbol?: Str, params?: Dict): Promise<Order[]>;
+    cancelUnifiedOrder(order: Order, params?: Dict): Promise<Order>;
+    fetchOrders(symbol?: Str, since?: Int, limit?: Int, params?: Dict): Promise<Order[]>;
+    fetchOrderTrades(id: string, symbol?: Str, since?: Int, limit?: Int, params?: Dict): Promise<Trade[]>;
+    watchOrders(symbol?: Str, since?: Int, limit?: Int, params?: Dict): Promise<Order[]>;
+    fetchOpenOrders(symbol?: Str, since?: Int, limit?: Int, params?: Dict): Promise<Order[]>;
+    fetchClosedOrders(symbol?: Str, since?: Int, limit?: Int, params?: Dict): Promise<Order[]>;
+    fetchCanceledOrders(symbol?: Str, since?: Int, limit?: Int, params?: Dict): Promise<Order[]>;
+    fetchMyTrades(symbol?: Str, since?: Int, limit?: Int, params?: Dict): Promise<Trade[]>;
+    watchMyTrades(symbol?: Str, since?: Int, limit?: Int, params?: Dict): Promise<Trade[]>;
+    createLimitOrder(symbol: string, side: OrderSide, amount: number, price: number, params?: Dict): Promise<Order>;
+    createMarketOrder(symbol: string, side: OrderSide, amount: number, price?: Num, params?: Dict): Promise<Order>;
+    createLimitBuyOrder(symbol: string, amount: number, price: number, params?: Dict): Promise<Order>;
+    createLimitSellOrder(symbol: string, amount: number, price: number, params?: Dict): Promise<Order>;
+    createMarketBuyOrder(symbol: string, amount: number, params?: Dict): Promise<Order>;
+    createMarketSellOrder(symbol: string, amount: number, params?: Dict): Promise<Order>;
+    createPostOnlyOrder(symbol: string, type: OrderType, side: OrderSide, amount: number, price?: Num, params?: Dict): Promise<Order>;
+    createReduceOnlyOrder(symbol: string, type: OrderType, side: OrderSide, amount: number, price?: Num, params?: Dict): Promise<Order>;
+    createStopOrder(symbol: string, type: OrderType, side: OrderSide, amount: number, price?: Num, triggerPrice?: Num, params?: Dict): Promise<Order>;
+    createStopLimitOrder(symbol: string, side: OrderSide, amount: number, price: number, triggerPrice: number, params?: Dict): Promise<Order>;
+    createStopMarketOrder(symbol: string, side: OrderSide, amount: number, triggerPrice: number, params?: Dict): Promise<Order>;
+    fetchTradingFee(symbol: string, params?: Dict): Promise<TradingFeeInterface>;
 }
 export { Exchange, };