import * as api from '../../api';
import { OrderToBeCreated, TradingOrder, TradingPosition } from '../types';
import calculateSizeFromString from './calculateSizeFromString';
import calculateLiquidationPrice from './calculateLiquidationPrice';
import createOrderFromDraft from './createOrderFromDraft';
import limitOrder from './limitOrder';
import marketOrder from './marketOrder';
import stopLimitOrder from './stopLimitOrder';
import stopMarketOrder from './stopMarketOrder';
import closePosition from './closePosition';
import cancelAllOrders from './cancelAllOrders';
import cancelOrder from './cancelOrder';
import updateDrafts from './updateDrafts';
import getPseudoPosition from './getPseudoPosition';
import eventOrderUpdate from './eventOrderUpdate';
import eventAccountUpdate from './eventAccountUpdate';
import updateLeverage from './updateLeverage';
import loadPositionTrades from './loadPositionTrades';
import '../altamoon.d';
export default class Trading {
    #private;
    openPositions: TradingPosition[];
    allSymbolsPositionRisk: Record<string, api.FuturesPositionRisk>;
    openOrders: TradingOrder[];
    ordersToBeCreated: OrderToBeCreated[];
    currentSymbolAllOrders: api.FuturesOrder[];
    currentSymbolMaxLeverage: number;
    currentSymbolLeverage: number;
    isCurrentSymbolMarginTypeIsolated: boolean;
    positionsKey?: string;
    ordersKey?: string;
    limitBuyPrice: number | null;
    shouldShowLimitBuyPriceLine: boolean;
    limitSellPrice: number | null;
    shouldShowLimitSellPriceLine: boolean;
    stopBuyPrice: number | null;
    shouldShowStopBuyDraftPriceLine: boolean;
    stopSellPrice: number | null;
    shouldShowStopSellDraftPriceLine: boolean;
    currentSymbolPseudoPosition: TradingPosition | null;
    /**
     * The object contains actual lastPrices for symbols that are currently listened.
     * In other words prices of symbols of current open positions and orders
     */
    listenedLastPrices: Record<string, number>;
    /**
     * We need to store canceled order IDs because WebSocket and REST API can return different data.
     * For example, REST request is made before order is closed, WebSocket reacts immediately,
     * but the REST request returns outdated data
    */
    canceledOrderIds: string[];
    store: altamoon.RootStore;
    leverageChangeRequestsCount: number;
    constructor(store: altamoon.RootStore);
    marketOrder: (args_0: {
        side: api.OrderSide;
        quantity: number;
        symbol: string;
        reduceOnly?: boolean | undefined;
    }) => ReturnType<typeof marketOrder>;
    limitOrder: (args_0: {
        side: api.OrderSide;
        quantity: number;
        price: number;
        symbol: string;
        reduceOnly?: boolean | undefined;
        postOnly?: boolean | undefined;
        newClientOrderId?: string | undefined;
        shouldHideDraft?: boolean | undefined;
    }) => ReturnType<typeof limitOrder>;
    stopMarketOrder: (args_0: {
        side: api.OrderSide;
        quantity: number;
        symbol: string;
        stopPrice: number;
        reduceOnly?: boolean | undefined;
    }) => ReturnType<typeof stopMarketOrder>;
    stopLimitOrder: (args_0: {
        side: api.OrderSide;
        quantity: number;
        price: number;
        stopPrice: number;
        symbol: string;
        reduceOnly?: boolean | undefined;
        postOnly?: boolean | undefined;
        newClientOrderId?: string | undefined;
    }) => ReturnType<typeof stopLimitOrder>;
    createOrderFromDraft: (args_0: {
        buyDraftPrice: number | null;
        sellDraftPrice: number | null;
        stopBuyDraftPrice: number | null;
        stopSellDraftPrice: number | null;
        newClientOrderId: string;
    }, args_1: api.OrderSide) => ReturnType<typeof createOrderFromDraft>;
    closePosition: (symbol: string, amt?: number | undefined) => ReturnType<typeof closePosition>;
    cancelOrder: (symbol: string, origClientOrderId: string) => ReturnType<typeof cancelOrder>;
    cancelAllOrders: (symbol: string) => ReturnType<typeof cancelAllOrders>;
    updateDrafts: (args_0: {
        buyDraftPrice: number | null;
        sellDraftPrice: number | null;
        stopBuyDraftPrice: number | null;
        stopSellDraftPrice: number | null;
    }) => ReturnType<typeof updateDrafts>;
    eventOrderUpdate: (o: api.UserDataEventOrderUpdateData, updateTime: number) => ReturnType<typeof eventOrderUpdate>;
    eventAccountUpdate: (a: api.UserDataEventAccountUpdateData) => ReturnType<typeof eventAccountUpdate>;
    calculateSizeFromString: (args_0: string, args_1: string, args_2?: {
        leverage?: number | undefined;
        isPercentMode?: boolean | undefined;
    } | undefined) => ReturnType<typeof calculateSizeFromString>;
    calculateLiquidationPrice: (position: Parameters<typeof calculateLiquidationPrice>[1], options?: {
        side: api.OrderSide;
    } | undefined) => ReturnType<typeof calculateLiquidationPrice>;
    getPseudoPosition: (args_0?: {
        side?: api.OrderSide | undefined;
        price?: number | undefined;
    } | undefined) => ReturnType<typeof getPseudoPosition>;
    updateLeverage: () => ReturnType<typeof updateLeverage>;
    loadPositionTrades: (symbol: string) => ReturnType<typeof loadPositionTrades>;
    loadPositions: import("lodash").DebouncedFunc<() => Promise<void>>;
    loadOrders: import("lodash").DebouncedFunc<() => Promise<void>>;
    getFeeRate: (type: 'maker' | 'taker') => number;
    adjustPositionMargin: (symbol: string, amount: number, type: 'ADD' | 'REMOVE') => Promise<null | unknown>;
    calculateQuantity: ({ symbol, price, size, }: {
        symbol: string;
        price: number;
        size: number;
    }) => number;
    /**
     * Updates order arrows on the chart
     */
    loadAllOrders: () => Promise<void>;
    getMarginAdjustmentInfo: (position?: TradingPosition | undefined) => {
        addable: number;
        removable: number;
    };
}
//# sourceMappingURL=index.d.ts.map