import type { BaseExchange } from "../exchanges/base.exchange";
import { type FastTradingApiOptions, type FetchOHLCVParams, type Store, ExchangeName, type Account, type Position, type Candle, type PlaceOrderOpts, type Timeframe, type Order, type OrderBook, type TWAPOpts, type ChaseOpts, type ExchangeConfig, type PlacePositionStopOpts } from "../types/lib.types";
export declare class FastTradingApi {
    store: Store;
    accounts: Account[];
    config: Record<ExchangeName, ExchangeConfig>;
    exchanges: Partial<Record<ExchangeName, BaseExchange>>;
    listeners: {
        [key: string]: ((...args: any[]) => void)[];
    };
    constructor({ accounts, config, store }: FastTradingApiOptions);
    start(): Promise<void>;
    stop(): Promise<void>;
    addAccounts(accounts: Account[]): Promise<void>;
    removeAccount(accountId: string): Promise<void>;
    fetchOHLCV({ exchangeName, params, }: {
        exchangeName: ExchangeName;
        params: FetchOHLCVParams;
    }): Promise<Candle[]>;
    listenOHLCV({ exchangeName, symbol, timeframe, callback, }: {
        exchangeName: ExchangeName;
        symbol: string;
        timeframe: Timeframe;
        callback: (candle: Candle) => void;
    }): void;
    unlistenOHLCV({ exchangeName, symbol, timeframe, }: {
        exchangeName: ExchangeName;
        symbol: string;
        timeframe: Timeframe;
    }): void;
    listenOrderBook({ exchangeName, symbol, callback, }: {
        exchangeName: ExchangeName;
        symbol: string;
        callback: (orderBook: OrderBook) => void;
    }): void;
    unlistenOrderBook({ exchangeName, symbol, }: {
        exchangeName: ExchangeName;
        symbol: string;
    }): void;
    placePositionStop({ position, stop, priority, }: {
        position: Position;
        stop: PlacePositionStopOpts;
        priority?: boolean;
    }): Promise<unknown>;
    placeOrder({ order, accountId, priority, }: {
        order: PlaceOrderOpts;
        accountId: string;
        priority?: boolean;
    }): Promise<string[]>;
    placeOrders({ orders, accountId, priority, }: {
        orders: PlaceOrderOpts[];
        accountId: string;
        priority?: boolean;
    }): Promise<string[]>;
    updateOrder({ order, update, priority, }: {
        order: Order;
        update: {
            amount: number;
        } | {
            price: number;
        };
        priority?: boolean;
    }): Promise<unknown[]>;
    updateOrders({ updates, priority, }: {
        updates: {
            order: Order;
            update: {
                amount: number;
            } | {
                price: number;
            };
        }[];
        priority?: boolean;
    }): Promise<unknown[]>;
    cancelOrder({ orderId, accountId, priority, }: {
        orderId: string | number;
        accountId: string;
        priority?: boolean;
    }): Promise<unknown>;
    cancelOrders({ orderIds, accountId, priority, }: {
        orderIds: Array<string | number>;
        accountId: string;
        priority?: boolean;
    }): Promise<unknown>;
    cancelSymbolOrders({ symbol, accountId, priority, }: {
        symbol: string;
        accountId: string;
        priority?: boolean;
    }): Promise<unknown>;
    cancelAllOrders({ accountId, priority, }: {
        accountId: string;
        priority?: boolean;
    }): Promise<unknown>;
    fetchPositionMetadata({ accountId, symbol, }: {
        accountId: string;
        symbol: string;
    }): Promise<{
        leverage: number;
        isHedged: boolean;
    }>;
    setLeverage({ accountId, symbol, leverage, }: {
        accountId: string;
        symbol: string;
        leverage: number;
    }): Promise<boolean>;
    startTwap({ accountId, twap }: {
        accountId: string;
        twap: TWAPOpts;
    }): Promise<unknown>;
    pauseTwap({ accountId, twapId }: {
        accountId: string;
        twapId: string;
    }): Promise<unknown>;
    resumeTwap({ accountId, twapId }: {
        accountId: string;
        twapId: string;
    }): Promise<unknown>;
    stopTwap({ accountId, twapId }: {
        accountId: string;
        twapId: string;
    }): Promise<unknown>;
    startChase({ accountId, chase }: {
        accountId: string;
        chase: ChaseOpts;
    }): Promise<unknown>;
    stopChase({ accountId, chaseId }: {
        accountId: string;
        chaseId: string;
    }): Promise<unknown>;
    getExchange(exchangeName: ExchangeName): BaseExchange;
    getAccountExchange(accountId: string): BaseExchange;
    on(event: "log" | "error", listener: (message: string) => void): void;
    emit(event: "log" | "error", ...args: any[]): void;
}