/**
 * TracedSocket for WebSocket connections with OpenTelemetry tracing.
 *
 * This is a generic implementation that can be used across services.
 * Server-specific behavior (like error handling) is injected via callbacks.
 */
import { IncomingHttpHeaders } from "http";
import { ISocket, ISocketClient, MethodHandler, RequestContextBase, SocketMessage, SocketError, MethodHandlers, GenericMiddleware, SocketTimeouts } from "@superblocksteam/shared";
/**
 * PinoLogger interface compatible with pino.
 */
interface PinoLogger {
    error: (obj: object, msg?: string) => void;
    info: (obj: object, msg?: string) => void;
    warn: (obj: object, msg?: string) => void;
}
/**
 * WebSocket interface (subset of isomorphic-ws).
 */
interface WebSocketLike {
    readonly readyState: number;
    close(code?: number, reason?: string): void;
    send(data: string | ArrayBuffer): void;
    addEventListener(type: string, listener: (event: unknown) => void): void;
    removeEventListener(type: string, listener: (event: unknown) => void): void;
}
/**
 * Configuration options for TracedSocket.
 */
export interface TracedSocketConfig {
    /** Request headers from the WebSocket upgrade request */
    requestHeaders: IncomingHttpHeaders;
    /** Optional error handler to get HTTP status from errors */
    getResponseMetaByError?: (error: Error, logger: PinoLogger) => {
        status: number;
        message: string;
    };
}
/**
 * Socket options passed to ISocket.
 */
export interface TracedSocketOptions {
    onClose: (event: {
        code: number;
        reason: string;
    }) => void;
    timeouts?: SocketTimeouts;
    logger?: {
        error: (message?: string) => void;
        info: (message?: string) => void;
        warn: (message?: string) => void;
    };
}
/**
 * TracedSocket extends ISocket to add OpenTelemetry tracing capabilities.
 *
 * It manages spans for WebSocket handler calls to provide detailed tracing information.
 */
export declare class TracedSocket<ImplementedMethods, CallableMethods, RequestContext extends RequestContextBase> extends ISocket<ImplementedMethods, CallableMethods, RequestContext> {
    private activeSpanByRequestId;
    private middlewareSpanByReqId;
    private lastActiveSpan;
    private readonly requestHeaders;
    private readonly tracer;
    private readonly setHttpStatusFromError;
    constructor(ws: WebSocketLike, requestHandlers: MethodHandlers<ImplementedMethods, CallableMethods, RequestContext>, globalMiddlewares: GenericMiddleware<CallableMethods, RequestContext>[], config: TracedSocketConfig, options: TracedSocketOptions);
    protected callHandler<Params, Result, CallableMethodsInner, RequestContextInner extends RequestContextBase>(handler: MethodHandler<Params, Result, CallableMethodsInner, RequestContextInner>, params: Params, ctx: RequestContextInner, client: ISocketClient<CallableMethodsInner>, next: () => Promise<Result>): Promise<Result>;
    protected handleMessage(message: SocketMessage): Promise<void>;
    request<Params, Result>(method: string, params: Params, authorization?: string): Promise<Result>;
    protected respond<Result>(requestId: number, result: Result): void;
    protected respondError(requestId: number, error: SocketError, exception?: Error): void;
    private addEvent;
    close(reason?: string): void;
}
export {};
//# sourceMappingURL=traced-socket.d.ts.map