import { DestroyRef, Signal } from '@angular/core';
import { Observable } from 'rxjs';

interface WebSocketClientConfig {
    url: string;
    protocols?: string | string[];
    /** Initial reconnect delay in ms. Set to 0 or omit to disable automatic reconnection. */
    reconnectInterval?: number;
    /** Max number of reconnect attempts. Defaults to 0 (disabled). */
    maxReconnectAttempts?: number;
    /** Hard cap for reconnect delay in ms. Defaults to 30_000. */
    maxReconnectDelay?: number;
    /** Heartbeat interval in ms. */
    heartbeatInterval?: number;
    /** Payload sent on every heartbeat tick. */
    heartbeatMessage?: unknown;
}
interface WebSocketMessage<T = unknown> {
    id?: string;
    type: string;
    data: T;
    correlationId?: string;
    timestamp?: number;
}
type WebSocketState = 'idle' | 'connecting' | 'open' | 'closing' | 'closed' | 'reconnecting';
interface WebSocketStatus {
    readonly state: WebSocketState;
    readonly reconnectAttempts: number;
    readonly error: string | null;
}
interface WebSocketRequestOptions {
    timeout?: number;
}
/**
 * Client for managing WebSocket connections off-main-thread running in a Web Worker.
 */
declare class WorkerWebSocketClient {
    private readonly worker;
    private readonly config;
    private readonly connectionId;
    private readonly _status;
    private readonly _messages$;
    private readonly pendingRequests;
    private readonly listener;
    private disposed;
    constructor(worker: Worker | MessagePort, config: WebSocketClientConfig, destroyRef?: DestroyRef);
    get status(): Signal<WebSocketStatus>;
    get messages$(): Observable<WebSocketMessage>;
    messagesByType<T = unknown>(type: string): Observable<WebSocketMessage<T>>;
    send<T>(message: WebSocketMessage<T>): void;
    sendRaw(data: string): void;
    request<TRes = unknown, TReq = unknown>(type: string, data: TReq, opts?: WebSocketRequestOptions): Promise<TRes>;
    close(): void;
    private connect;
    private handleIncoming;
    private rejectAllPending;
    private updateStatus;
    private generateId;
}

interface SseClientConfig {
    url: string;
    withCredentials?: boolean;
    /** List of custom event names to listen to. */
    events?: string[];
}
interface SseMessage<T = unknown> {
    id: string | null;
    event: string;
    data: T;
    lastEventId: string | null;
}
type SseState = 'idle' | 'connecting' | 'open' | 'closed';
interface SseStatus {
    readonly state: SseState;
    readonly error: string | null;
}
/**
 * Client for managing Server-Sent Events (SSE) connections off-main-thread running in a Web Worker.
 */
declare class WorkerSseClient {
    private readonly worker;
    private readonly config;
    private readonly connectionId;
    private readonly _status;
    private readonly _events$;
    private readonly listener;
    private disposed;
    constructor(worker: Worker | MessagePort, config: SseClientConfig, destroyRef?: DestroyRef);
    get status(): Signal<SseStatus>;
    get events$(): Observable<SseMessage>;
    close(): void;
    private connect;
    private parseData;
    private updateStatus;
    private generateId;
}

/**
 * Worker-side message handler that attaches listeners to manage WebSocket and SSE connections.
 * Call this inside your web worker file.
 *
 * @param globalScope The worker global scope (defaults to `self`).
 */
declare function attachRealtimeWorker(globalScope?: any): void;

export { WorkerSseClient, WorkerWebSocketClient, attachRealtimeWorker };
export type { SseClientConfig, SseMessage, SseState, SseStatus, WebSocketClientConfig, WebSocketMessage, WebSocketRequestOptions, WebSocketState, WebSocketStatus };