type WsProxyDirection = "client_to_upstream" | "upstream_to_client";
type WsProxyEventType = "proxy_started" | "proxy_stopped" | "client_connected" | "upstream_connected" | "message" | "tunnel_closed" | "error";
interface WsProxyEventBase {
    type: WsProxyEventType;
    timestamp: number;
    connectionId?: number;
}
export interface WsProxyStartedEvent extends WsProxyEventBase {
    type: "proxy_started";
    host: string;
    port: number;
    url: string;
    reason?: string;
}
export interface WsProxyStoppedEvent extends WsProxyEventBase {
    type: "proxy_stopped";
    reason?: string;
}
export interface WsProxyClientConnectedEvent extends WsProxyEventBase {
    type: "client_connected";
    connectionId: number;
    path: string;
    remoteAddress: string;
}
export interface WsProxyUpstreamConnectedEvent extends WsProxyEventBase {
    type: "upstream_connected";
    connectionId: number;
    upstreamUrl: string;
}
export interface WsProxyMessageEvent extends WsProxyEventBase {
    type: "message";
    connectionId: number;
    direction: WsProxyDirection;
    isBinary: boolean;
    byteLength: number;
    rawData: Buffer | string;
    messageSeq: number;
}
export interface WsProxyTunnelClosedEvent extends WsProxyEventBase {
    type: "tunnel_closed";
    connectionId: number;
    reason: string;
    source: "client" | "upstream" | "proxy";
}
export interface WsProxyErrorEvent extends WsProxyEventBase {
    type: "error";
    error: Error;
    stage: string;
    sourceEventType?: WsProxyEventType;
    details?: string;
}
export type WsProxyEvent = WsProxyStartedEvent | WsProxyStoppedEvent | WsProxyClientConnectedEvent | WsProxyUpstreamConnectedEvent | WsProxyMessageEvent | WsProxyTunnelClosedEvent | WsProxyErrorEvent;
export interface WsProxyControl {
    restart(opts?: {
        downtimeMs?: number;
        reason?: string;
    }): Promise<void>;
    stop(reason?: string): Promise<void>;
    isRunning(): boolean;
}
export type WsProxyEventHandler = (event: WsProxyEvent, control: WsProxyControl) => void | Promise<void>;
export interface WsFailoverProxyOptions {
    host: string;
    port: number;
    onEvent?: WsProxyEventHandler;
}
export declare class WsFailoverProxy {
    private readonly _listenHost;
    private readonly _requestedPort;
    private _lockedPort;
    private readonly _onEvent?;
    private readonly _control;
    private _httpServer;
    private _wsServer;
    private _running;
    private _nextConnectionId;
    private _lifecycleChain;
    private readonly _tunnels;
    private readonly _eventLog;
    constructor(options: WsFailoverProxyOptions);
    static create(options: WsFailoverProxyOptions): Promise<WsFailoverProxy>;
    start(reason?: string): Promise<void>;
    stop(reason?: string): Promise<void>;
    restart(opts?: {
        downtimeMs?: number;
        reason?: string;
    }): Promise<void>;
    isRunning(): boolean;
    getPort(): number;
    getHost(): string;
    getUrl(): string;
    getEventLog(): WsProxyEvent[];
    private enqueueLifecycle;
    private startInternal;
    private stopInternal;
    private handleClientRequest;
    private connectUpstream;
    private handleClientMessage;
    private handleUpstreamMessage;
    private flushPendingFrames;
    private closeTunnel;
    private isConnected;
    private emitMessageEvent;
    private emitError;
    private emitEvent;
    private safeCloseConnection;
}
export {};
//# sourceMappingURL=wsFailoverProxy.d.ts.map