/// <reference types="node" />
import { IncomingMessage } from "http";
export type SocketMessage<MessageType = unknown, HeadersType = Record<string, unknown>> = {
    type: string;
    payload: MessageType;
    headers?: HeadersType;
};
export interface AbstractSocket {
    connect(options: {
        auth?: unknown;
        [key: string]: unknown;
    }): Promise<void>;
    disconnect(): Promise<void>;
    send(message: string | ArrayBuffer): void;
    on(event: "open" | "message" | "close" | "error" | string, handler: (data: any) => void): void;
}
export interface AbstractSocketServer<SocketType = AbstractSocket> {
    onConnection(onConnection: (client: SocketType, req: IncomingMessage) => void): void;
    send(client: SocketType, message: string): void;
    isClientConnected(client: SocketType): boolean;
    ping(client: SocketType): void;
    close(): void;
}
export interface AuthorizationStrategy {
    applyAuthorization(options: any): any;
}
export interface SocketClientOptions<MessageType, HeadersType> {
    url: string;
    authorizationStrategy?: AuthorizationStrategy;
    heartbeatInterval?: number;
    maxRate?: number;
    reconnect?: {
        retries: number;
        delay: number;
    };
    parser?: (data: any) => SocketMessage<MessageType, HeadersType>;
    onError?: (error: Error) => void;
    onClose?: () => void;
    onOpen?: () => void;
}
export interface SocketServerOptions {
    port: number;
    heartbeatInterval?: number;
    rateLimit?: number;
    onConnection?: (clientId: string) => void;
    onDisconnection?: (clientId: string) => void;
    onError?: (clientId: string, error: Error) => void;
    onMessage?: (clientId: string, message: SocketMessage) => void;
}
export interface SocketEventHandler<MessageType, HeadersType> {
    onMessage(message: SocketMessage<MessageType, HeadersType>): void;
    onError(error: Error, message?: SocketMessage<MessageType, HeadersType>): void;
}