import type { FastTradingApi } from "../lib/fast-trading-api.lib";
import type { Account, Position, Candle, ChaseOpts, ExchangeConfig, FetchOHLCVParams, OrderBook, PlaceOrderOpts, StoreMemory, Timeframe, TWAPOpts, UpdateOrderOpts, PlacePositionStopOpts } from "../types/lib.types";
import type { ObjectChangeCommand, ObjectPaths } from "../types/misc.types";
export declare class BaseExchange {
    name: string;
    config: ExchangeConfig;
    parent: FastTradingApi;
    worker: Worker;
    workerReady: boolean;
    pendingRequests: Map<string, (data: any) => void>;
    ohlcvListeners: Map<string, (data: Candle) => void>;
    orderBookListeners: Map<string, (data: OrderBook) => void>;
    constructor({ name, config, parent, createWorker, }: {
        name: string;
        config: ExchangeConfig;
        parent: FastTradingApi;
        createWorker: () => Worker;
    });
    start: () => Promise<unknown>;
    stop: () => void;
    addAccounts: (accounts: Account[]) => Promise<unknown>;
    removeAccount: (accountId: string) => Promise<unknown>;
    fetchOHLCV(params: FetchOHLCVParams): Promise<Candle[]>;
    placePositionStop({ position, stop, priority, }: {
        position: Position;
        stop: PlacePositionStopOpts;
        priority?: boolean;
    }): Promise<unknown>;
    placeOrders({ orders, accountId, priority, }: {
        orders: PlaceOrderOpts[];
        accountId: string;
        priority?: boolean;
    }): Promise<string[]>;
    updateOrders({ updates, accountId, priority, }: {
        updates: UpdateOrderOpts[];
        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>;
    listenOHLCV({ symbol, timeframe, callback, }: {
        symbol: string;
        timeframe: Timeframe;
        callback: (candle: Candle) => void;
    }): void;
    unlistenOHLCV({ symbol, timeframe, }: {
        symbol: string;
        timeframe: Timeframe;
    }): void;
    listenOrderBook({ symbol, callback, }: {
        symbol: string;
        callback: (orderBook: OrderBook) => void;
    }): void;
    unlistenOrderBook(symbol: string): void;
    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>;
    dispatchWorker<T>(message: Record<string, any>): Promise<T>;
    waitForWorkerReady: () => Promise<void>;
    onWorkerMessage: <P extends ObjectPaths<StoreMemory>>({ data, }: MessageEvent<{
        type: "ready";
    } | {
        type: "update";
        changes: ObjectChangeCommand<StoreMemory, P>[];
    } | {
        type: "response";
        requestId: string;
        data: any;
    } | {
        type: "log";
        message: string;
    } | {
        type: "error";
        error: Error;
    } | {
        type: "candle";
        candle: Candle;
    } | {
        type: "orderBook";
        symbol: string;
        orderBook: OrderBook;
    }>) => void;
    handleResponse: ({ requestId, data }: {
        requestId: string;
        data: any;
    }) => void;
    handleCandle: (candle: Candle) => void;
    handleOrderBook: ({ symbol, orderBook, }: {
        symbol: string;
        orderBook: OrderBook;
    }) => void;
}