/// <reference types="bn.js" />
import { NodeList } from './NodeList';
import { BN, DLOBNode, DLOBNodeType, DriftClient, MarketType, MarketTypeStr, OraclePriceData, Order, OrderActionRecord, OrderRecord, PerpMarketAccount, PositionDirection, SlotSubscriber, SpotMarketAccount, StateAccount, TriggerOrderNode, UserMap } from '..';
import { PublicKey } from '@solana/web3.js';
import { DLOBOrders } from './DLOBOrders';
import { L2OrderBook, L2OrderBookGenerator, L3OrderBook } from './orderBookLevels';
export type MarketNodeLists = {
    restingLimit: {
        ask: NodeList<'restingLimit'>;
        bid: NodeList<'restingLimit'>;
    };
    floatingLimit: {
        ask: NodeList<'floatingLimit'>;
        bid: NodeList<'floatingLimit'>;
    };
    takingLimit: {
        ask: NodeList<'takingLimit'>;
        bid: NodeList<'takingLimit'>;
    };
    market: {
        ask: NodeList<'market'>;
        bid: NodeList<'market'>;
    };
    trigger: {
        above: NodeList<'trigger'>;
        below: NodeList<'trigger'>;
    };
};
type OrderBookCallback = () => void;
/**
 *  Receives a DLOBNode and is expected to return true if the node should
 *  be taken into account when generating, or false otherwise.
 *
 * Currently used in getRestingLimitBids and getRestingLimitAsks.
 */
export type DLOBFilterFcn = (node: DLOBNode) => boolean;
export type NodeToFill = {
    node: DLOBNode;
    makerNodes: DLOBNode[];
};
export type NodeToTrigger = {
    node: TriggerOrderNode;
};
export declare class DLOB {
    openOrders: Map<MarketTypeStr, Set<string>>;
    orderLists: Map<MarketTypeStr, Map<number, MarketNodeLists>>;
    maxSlotForRestingLimitOrders: number;
    initialized: boolean;
    constructor();
    private init;
    clear(): void;
    /**
     * initializes a new DLOB instance
     *
     * @returns a promise that resolves when the DLOB is initialized
     */
    initFromUserMap(userMap: UserMap, slot: number): Promise<boolean>;
    initFromOrders(dlobOrders: DLOBOrders, slot: number): boolean;
    handleOrderRecord(record: OrderRecord, slot: number): void;
    handleOrderActionRecord(record: OrderActionRecord, slot: number): void;
    insertOrder(order: Order, userAccount: string, slot: number, onInsert?: OrderBookCallback): void;
    addOrderList(marketType: MarketTypeStr, marketIndex: number): void;
    updateOrder(order: Order, userAccount: PublicKey, slot: number, cumulativeBaseAssetAmountFilled: BN, onUpdate?: OrderBookCallback): void;
    trigger(order: Order, userAccount: PublicKey, slot: number, onTrigger?: OrderBookCallback): void;
    delete(order: Order, userAccount: PublicKey, slot: number, onDelete?: OrderBookCallback): void;
    getListForOrder(order: Order, slot: number): NodeList<any> | undefined;
    updateRestingLimitOrders(slot: number): void;
    updateRestingLimitOrdersForMarketType(slot: number, marketTypeStr: MarketTypeStr): void;
    getOrder(orderId: number, userAccount: PublicKey): Order | undefined;
    findNodesToFill(marketIndex: number, fallbackBid: BN | undefined, fallbackAsk: BN | undefined, slot: number, ts: number, marketType: MarketType, oraclePriceData: OraclePriceData, stateAccount: StateAccount, marketAccount: PerpMarketAccount | SpotMarketAccount): NodeToFill[];
    getMakerRebate(marketType: MarketType, stateAccount: StateAccount, marketAccount: PerpMarketAccount | SpotMarketAccount): {
        makerRebateNumerator: number;
        makerRebateDenominator: number;
    };
    mergeNodesToFill(restingLimitOrderNodesToFill: NodeToFill[], takingOrderNodesToFill: NodeToFill[]): NodeToFill[];
    findRestingLimitOrderNodesToFill(marketIndex: number, slot: number, marketType: MarketType, oraclePriceData: OraclePriceData, isAmmPaused: boolean, minAuctionDuration: number, makerRebateNumerator: number, makerRebateDenominator: number, fallbackAsk: BN | undefined, fallbackBid: BN | undefined): NodeToFill[];
    findTakingNodesToFill(marketIndex: number, slot: number, marketType: MarketType, oraclePriceData: OraclePriceData, isAmmPaused: boolean, minAuctionDuration: number, fallbackAsk: BN | undefined, fallbackBid?: BN | undefined): NodeToFill[];
    findTakingNodesCrossingMakerNodes(marketIndex: number, slot: number, marketType: MarketType, oraclePriceData: OraclePriceData, takerNodeGenerator: Generator<DLOBNode>, makerNodeGeneratorFn: (marketIndex: number, slot: number, marketType: MarketType, oraclePriceData: OraclePriceData) => Generator<DLOBNode>, doesCross: (takerPrice: BN | undefined, makerPrice: BN) => boolean): NodeToFill[];
    findNodesCrossingFallbackLiquidity(marketType: MarketType, slot: number, oraclePriceData: OraclePriceData, nodeGenerator: Generator<DLOBNode>, doesCross: (nodePrice: BN | undefined) => boolean, minAuctionDuration: number): NodeToFill[];
    findExpiredNodesToFill(marketIndex: number, ts: number, marketType: MarketType): NodeToFill[];
    findJitAuctionNodesToFill(marketIndex: number, slot: number, oraclePriceData: OraclePriceData, marketType: MarketType): NodeToFill[];
    getTakingBids(marketIndex: number, marketType: MarketType, slot: number, oraclePriceData: OraclePriceData): Generator<DLOBNode>;
    getTakingAsks(marketIndex: number, marketType: MarketType, slot: number, oraclePriceData: OraclePriceData): Generator<DLOBNode>;
    private getBestNode;
    getRestingLimitAsks(marketIndex: number, slot: number, marketType: MarketType, oraclePriceData: OraclePriceData, filterFcn?: DLOBFilterFcn): Generator<DLOBNode>;
    getRestingLimitBids(marketIndex: number, slot: number, marketType: MarketType, oraclePriceData: OraclePriceData, filterFcn?: DLOBFilterFcn): Generator<DLOBNode>;
    getAsks(marketIndex: number, fallbackAsk: BN | undefined, slot: number, marketType: MarketType, oraclePriceData: OraclePriceData): Generator<DLOBNode>;
    getBids(marketIndex: number, fallbackBid: BN | undefined, slot: number, marketType: MarketType, oraclePriceData: OraclePriceData): Generator<DLOBNode>;
    findCrossingRestingLimitOrders(marketIndex: number, slot: number, marketType: MarketType, oraclePriceData: OraclePriceData): NodeToFill[];
    determineMakerAndTaker(askNode: DLOBNode, bidNode: DLOBNode): {
        takerNode: DLOBNode;
        makerNode: DLOBNode;
    } | undefined;
    getBestAsk(marketIndex: number, slot: number, marketType: MarketType, oraclePriceData: OraclePriceData): BN | undefined;
    getBestBid(marketIndex: number, slot: number, marketType: MarketType, oraclePriceData: OraclePriceData): BN | undefined;
    getStopLosses(marketIndex: number, marketType: MarketType, direction: PositionDirection): Generator<DLOBNode>;
    getStopLossMarkets(marketIndex: number, marketType: MarketType, direction: PositionDirection): Generator<DLOBNode>;
    getStopLossLimits(marketIndex: number, marketType: MarketType, direction: PositionDirection): Generator<DLOBNode>;
    getTakeProfits(marketIndex: number, marketType: MarketType, direction: PositionDirection): Generator<DLOBNode>;
    getTakeProfitMarkets(marketIndex: number, marketType: MarketType, direction: PositionDirection): Generator<DLOBNode>;
    getTakeProfitLimits(marketIndex: number, marketType: MarketType, direction: PositionDirection): Generator<DLOBNode>;
    findNodesToTrigger(marketIndex: number, slot: number, oraclePrice: BN, marketType: MarketType, stateAccount: StateAccount): NodeToTrigger[];
    printTop(driftClient: DriftClient, slotSubscriber: SlotSubscriber, marketIndex: number, marketType: MarketType): void;
    getDLOBOrders(): DLOBOrders;
    getNodeLists(): Generator<NodeList<DLOBNodeType>>;
    /**
     * Get an L2 view of the order book for a given market.
     *
     * @param marketIndex
     * @param marketType
     * @param slot
     * @param oraclePriceData
     * @param depth how many levels of the order book to return
     * @param fallbackL2Generators L2 generators for fallback liquidity e.g. vAMM {@link getVammL2Generator}, openbook {@link SerumSubscriber}
     */
    getL2({ marketIndex, marketType, slot, oraclePriceData, depth, fallbackL2Generators, }: {
        marketIndex: number;
        marketType: MarketType;
        slot: number;
        oraclePriceData: OraclePriceData;
        depth: number;
        fallbackL2Generators?: L2OrderBookGenerator[];
    }): L2OrderBook;
    /**
     * Get an L3 view of the order book for a given market. Does not include fallback liquidity sources
     *
     * @param marketIndex
     * @param marketType
     * @param slot
     * @param oraclePriceData
     */
    getL3({ marketIndex, marketType, slot, oraclePriceData, }: {
        marketIndex: number;
        marketType: MarketType;
        slot: number;
        oraclePriceData: OraclePriceData;
    }): L3OrderBook;
    private estimateFillExactBaseAmountInForSide;
    /**
     *
     * @param param.marketIndex the index of the market
     * @param param.marketType the type of the market
     * @param param.baseAmount the base amount in to estimate
     * @param param.orderDirection the direction of the trade
     * @param param.slot current slot for estimating dlob node price
     * @param param.oraclePriceData the oracle price data
     * @returns the estimated quote amount filled: QUOTE_PRECISION
     */
    estimateFillWithExactBaseAmount({ marketIndex, marketType, baseAmount, orderDirection, slot, oraclePriceData, }: {
        marketIndex: number;
        marketType: MarketType;
        baseAmount: BN;
        orderDirection: PositionDirection;
        slot: number;
        oraclePriceData: OraclePriceData;
    }): BN;
    getBestMakers({ marketIndex, marketType, direction, slot, oraclePriceData, numMakers, }: {
        marketIndex: number;
        marketType: MarketType;
        direction: PositionDirection;
        slot: number;
        oraclePriceData: OraclePriceData;
        numMakers: number;
    }): PublicKey[];
}
export {};