import type { DshRemoteCapability, DshRemotePublishDirection, DshRemoteRealtimePayload, DshRemoteRealtimeTransport, DshRemoteRuntimeTarget, DshRemoteTrustedEventMetadata } from './types.js';
interface SocketEventLike {
    data?: unknown;
    code?: number;
}
export interface DshRemoteSocketLike {
    readonly readyState: number;
    readonly diagnosticRequestId?: string;
    send(data: string): void;
    close(code?: number, reason?: string): void;
    terminate(): void;
    subscribeHeartbeat(listener: () => void): () => void;
    addEventListener(type: 'open' | 'message' | 'error' | 'close', listener: (event: SocketEventLike) => void): void;
    removeEventListener(type: 'open' | 'message' | 'error' | 'close', listener: (event: SocketEventLike) => void): void;
}
export type DshRemoteSocketFactory = (input: {
    profileRef: string;
    clientRef: string;
    signal: AbortSignal;
}) => DshRemoteSocketLike | Promise<DshRemoteSocketLike>;
export interface DshRemoteFrameSizingInput {
    target: DshRemoteRuntimeTarget;
    commandId: string;
    direction: DshRemotePublishDirection;
    payload: DshRemoteRealtimePayload;
    senderRole: 'host' | 'controller';
}
/**
 * Mirrors jotmo-realtime's login-only channel.publish and channel.event
 * wrappers. Max-width sequence/timestamp values keep the check conservative.
 */
export declare function dshRemoteFrameByteLengths(input: DshRemoteFrameSizingInput): {
    publish: number;
    event: number;
};
export declare function assertDshRemoteFramesFit(input: DshRemoteFrameSizingInput): void;
/** Exact adapter for jotmo-realtime's login-only DSH Remote contract. */
export declare class ArkmeRemoteRealtimeTransport implements DshRemoteRealtimeTransport {
    private readonly createSocket;
    private readonly requestTimeoutMillis;
    private readonly options;
    private socket;
    private connectionGeneration;
    private serviceLeaseGeneration;
    private readonly waiters;
    private readonly channelListeners;
    private readonly disconnectListeners;
    private onMessage;
    private onClose;
    private onError;
    private stopHeartbeat;
    private livenessTimer;
    private lastReceivedAt;
    private lastChannelEventAt;
    private lastChannelSequence;
    private lastHeartbeatDiagnosticAt;
    private lifecycleGeneration;
    constructor(createSocket: DshRemoteSocketFactory, requestTimeoutMillis?: number, options?: {
        livenessTimeoutMillis?: number;
        now?: () => number;
        onDiagnostic?: (event: string, fields: Record<string, unknown>) => void;
    });
    connect(input: {
        profileRef: string;
        clientRef: string;
        signal: AbortSignal;
    }): Promise<void>;
    /** Revalidates after an OS resume without creating a second reconnect owner. */
    revalidate(): void;
    private touchLiveness;
    disconnect(): Promise<void>;
    subscribeDisconnect(listener: (error: Error) => void): () => void;
    registerHost(input: {
        runtimeRef: string;
        capabilities: DshRemoteCapability[];
        signal: AbortSignal;
    }): Promise<{
        serviceLeaseGeneration: number;
    }>;
    unregisterHost(signal?: AbortSignal): Promise<void>;
    subscribe(input: {
        target: DshRemoteRuntimeTarget;
        afterSequence?: number;
        onEvent: (payload: DshRemoteRealtimePayload, metadata: DshRemoteTrustedEventMetadata) => void;
        signal: AbortSignal;
    }): Promise<() => void>;
    publish(input: {
        target: DshRemoteRuntimeTarget;
        commandId: string;
        direction: DshRemotePublishDirection;
        payload: DshRemoteRealtimePayload;
        signal: AbortSignal;
    }): Promise<{
        sequence: number;
    }>;
    private request;
    private waitForRequest;
    private waitForType;
    private receive;
    private failConnection;
    private send;
    private diagnostic;
}
export {};
//# sourceMappingURL=realtime-transport.d.ts.map