import type { CloseEvent, ErrorEvent, MessageEvent, Event } from "ws";
import * as WS from "ws";
import { WsMessage } from "../api/ws";
import { WsRegisterServiceMessage } from "../api/ws/daemon";
export type EventType = "open" | "message" | "error" | "close";
export type WsEvent = Event | MessageEvent | ErrorEvent | CloseEvent;
export type EventListener<T = WsEvent> = (ev: T) => unknown;
type EventListenerOf<T> = T extends "open" ? EventListener<Event> : T extends "message" ? EventListener<MessageEvent> : T extends "error" ? EventListener<ErrorEvent> : T extends "close" ? EventListener<CloseEvent> : never;
export type MessageListener<D extends WsMessage> = (msg: D) => unknown;
export interface RetryOptions {
    maxAttempts?: number;
    initialDelay?: number;
    maxDelay?: number;
    backoffMultiplier?: number;
}
export interface ConnectOptions {
    timeoutMs?: number;
    autoReconnect?: boolean;
    retryOptions?: RetryOptions;
}
export declare function getDaemon(serviceName?: string): Daemon;
declare class Daemon {
    protected _socket: WS | null;
    protected _connectedUrl: string;
    protected _responseQueue: {
        [request_id: string]: {
            resolver: (value: unknown) => void;
            rejecter: (error: unknown) => void;
            timeout: NodeJS.Timeout;
        };
    };
    protected _openEventListeners: Array<(e: Event) => unknown>;
    protected _messageEventListeners: Array<(e: MessageEvent) => unknown>;
    protected _errorEventListeners: Array<(e: ErrorEvent) => unknown>;
    protected _closeEventListeners: Array<(e: CloseEvent) => unknown>;
    protected _messageListeners: Record<string, Array<(e: WsMessage) => unknown>>;
    protected _closing: boolean;
    protected _onClosePromise: (() => unknown) | undefined;
    protected _subscriptions: string[];
    protected _serviceName: string;
    protected _autoReconnect: boolean;
    protected _retryOptions: Required<RetryOptions>;
    protected _timeoutMs: number;
    protected _reconnectAttempts: number;
    protected _reconnectTimer: NodeJS.Timeout | null;
    protected _lastConnectionUrl: string;
    protected _isReconnecting: boolean;
    get connected(): boolean;
    get closing(): boolean;
    constructor(serviceName?: string);
    protected onRejection(e: unknown): null;
    /**
     * Connect to local daemon via websocket.
     * @param daemonServerURL - The websocket URL to connect to. If not provided, uses config values.
     * @param options - Connection options including timeout, reconnect settings, and retry settings
     */
    connect(daemonServerURL?: string, options?: ConnectOptions): Promise<boolean>;
    close(): Promise<unknown>;
    sendMessage<M = unknown>(destination: string, command: string, data?: Record<string, unknown>, timeoutMs?: number): Promise<M>;
    createMessageTemplate(command: string, destination: string, data: Record<string, unknown>): {
        command: string;
        data: Record<string, unknown>;
        ack: boolean;
        origin: string;
        destination: string;
        request_id: string;
    };
    subscribe<T extends WsRegisterServiceMessage>(service: string): Promise<T>;
    addEventListener<T extends EventType>(type: T, listener: EventListenerOf<T>): void;
    removeEventListener<T extends EventType>(type: T, listener: EventListenerOf<T>): void;
    clearAllEventListeners(): void;
    /**
     * Add listener for message
     * @param {string} origin - Can be chia_farmer, chia_full_node, chia_wallet, etc.
     * @param listener - Triggered when a message arrives.
     */
    addMessageListener<D extends WsMessage>(origin: string | undefined, listener: MessageListener<D>): () => void;
    removeMessageListener<D extends WsMessage>(origin: string, listener: MessageListener<D>): void;
    clearAllMessageListeners(): void;
    protected onOpen(event: Event, url: string): Promise<WsRegisterServiceMessage>;
    protected onError(error: ErrorEvent): void;
    protected onMessage(event: MessageEvent): void;
    protected onClose(event: CloseEvent): void;
    protected onPing(): void;
    protected onPong(): void;
    protected _attemptReconnection(previousSubscriptions: string[]): void;
}
export type TDaemon = InstanceType<typeof Daemon>;
export {};