import type { Signal } from '../core/signal';
export type SocketStatus = 'connecting' | 'open' | 'closed' | 'reconnecting';
export interface SocketOptions {
    /** Enable auto-reconnect on disconnect (default: true). */
    reconnect?: boolean;
    /** Initial reconnect delay in ms (default: 1000). */
    reconnectDelay?: number;
    /** Max reconnect delay in ms, for exponential backoff (default: 30000). */
    reconnectMaxDelay?: number;
    /** Max reconnect attempts before giving up (default: Infinity). */
    reconnectAttempts?: number;
    /** WebSocket sub-protocols. */
    protocols?: string | string[];
    /**
     * JWT for a secured (@secured) Tina4 WebSocket route. A browser's
     * `new WebSocket()` cannot set an Authorization header, so the token is sent
     * as the `bearer` sub-protocol (`Sec-WebSocket-Protocol: bearer, <jwt>`) — the
     * transport Tina4's server reads (it echoes `bearer` back on accept). Re-sent
     * automatically on every reconnect. Leave unset for public routes.
     */
    token?: string;
}
export type MessageHandler = (data: unknown) => void;
export type OpenHandler = () => void;
export type CloseHandler = (code: number, reason: string) => void;
export type ErrorHandler = (error: Event) => void;
type EventMap = {
    message: MessageHandler;
    open: OpenHandler;
    close: CloseHandler;
    error: ErrorHandler;
};
export interface ManagedSocket {
    /** Reactive connection status. */
    readonly status: Signal<SocketStatus>;
    /** Reactive boolean — true when status is 'open'. */
    readonly connected: Signal<boolean>;
    /** Reactive — last received message (parsed JSON or raw string). */
    readonly lastMessage: Signal<unknown>;
    /** Reactive — last error event, or null. */
    readonly error: Signal<Event | null>;
    /** Number of reconnect attempts so far. */
    readonly reconnectCount: Signal<number>;
    /** Send data. Objects are JSON.stringify'd automatically. */
    send(data: unknown): void;
    /** Listen for events. Returns unsubscribe function. */
    on<K extends keyof EventMap>(event: K, handler: EventMap[K]): () => void;
    /** Pipe messages into a signal via a reducer. */
    pipe<T>(target: Signal<T>, reducer: (message: unknown, current: T) => T): () => void;
    /** Close the connection and stop reconnecting. */
    close(code?: number, reason?: string): void;
}
declare function createSocket(url: string, options?: SocketOptions): ManagedSocket;
export declare const ws: {
    connect: typeof createSocket;
};
export {};
//# sourceMappingURL=ws.d.ts.map