import { ReconnectingWebSocket } from "@iam4x/reconnecting-websocket";
import type { HyperLiquidWorker } from "./hl.worker";
import type { HLAction, HLPostPlaceOrdersResponse, HLUserAccount, HLUserFillEvent, HLUserOrder } from "./hl.types";
import { type Account, type Order, type PlaceOrderOpts, type PlacePositionStopOpts, type Position, type UpdateOrderOpts } from "../../types/lib.types";
type Data = {
    id: number;
    action: HLAction;
};
export declare class HyperLiquidWsPrivate {
    parent: HyperLiquidWorker;
    account: Account;
    ws: ReconnectingWebSocket | null;
    interval: NodeJS.Timeout | null;
    isStopped: boolean;
    isListening: boolean;
    pendingRequests: Map<number, (data: any) => void>;
    queue: {
        payload: Data;
        consume: number;
    }[];
    isProcessing: boolean;
    rateLimit: number;
    queueInterval: number;
    get memory(): import("../../types/lib.types").ExchangeAccountMemory;
    constructor({ parent, account, }: {
        parent: HyperLiquidWorker;
        account: Account;
    });
    listenWebsocket: () => void;
    startListening: () => void;
    onOpen: () => void;
    onMessage: (event: MessageEvent) => void;
    onUserFills: (fills: HLUserFillEvent[]) => void;
    onWebData2: ({ clearinghouseState, openOrders, }: {
        openOrders: HLUserOrder[];
        clearinghouseState: HLUserAccount;
    }) => void;
    ping: () => void;
    placePositionStop: ({ position, stop, priority, }: {
        position: Position;
        stop: PlacePositionStopOpts;
        priority?: boolean;
    }) => Promise<HLPostPlaceOrdersResponse>;
    placeOrders: ({ orders, priority, }: {
        orders: PlaceOrderOpts[];
        priority?: boolean;
    }) => Promise<(string | number)[]>;
    cancelOrders: ({ orders, priority, }: {
        orders: Order[];
        priority?: boolean;
    }) => Promise<unknown>;
    updateOrders: ({ updates, priority, }: {
        updates: UpdateOrderOpts[];
        priority?: boolean;
    }) => Promise<unknown>;
    setLeverage: ({ symbol, leverage, priority, }: {
        symbol: string;
        leverage: number;
        priority?: boolean;
    }) => Promise<unknown>;
    onClose: () => void;
    enqueueSend: ({ payload, consume, priority, }: {
        payload: Data;
        consume?: number;
        priority?: boolean;
    }) => void;
    processQueue: () => Promise<void>;
    send: (data: Record<string, any>) => void;
    subscribe: (subscription: Record<string, string> & {
        type: string;
    }) => void;
    stop: () => void;
}
export {};