import type { RemoteLink } from './remotelink';
import type { PathSeriesResult, SnapshotsQuery, SnapshotsResult, TrackResult, VoyageListResult, PhaseListResult, RollupsResult, VoyageStatsResult, FuelPathsView, AisFeed, HealthResult } from './contract';
export declare const FRAME_EVERY_MS = 2000;
export declare const STILL_FRAME_EVERY_MS = 60000;
export declare const REPORTING_STALE_MS: number;
export declare const PING_EVERY_MS = 25000;
export interface LiveSocket {
    send(data: string): void;
    close(code?: number, reason?: string): void;
    terminate(): void;
    onOpen(cb: () => void): void;
    onMessage(cb: (data: string) => void): void;
    onClose(cb: (code: number) => void): void;
    onError(cb: (err: unknown) => void): void;
    onRefused(cb: (status: number) => void): void;
}
export interface LiveStatus {
    connected: boolean;
    lastFrameTs: number | null;
    failures: number;
    rejected: boolean;
    unentitled: boolean;
    lastError: string | null;
}
export interface LiveDeps {
    relayUrl: string;
    getRemote: () => RemoteLink | undefined;
    frame: () => unknown;
    seal: (frame: unknown) => {
        mode: 'sealed';
        frame: unknown;
    } | {
        mode: 'blocked';
    };
    openAsk?: (envelope: unknown) => {
        id: string;
        plaintext: string;
    } | undefined;
    sealAnswer: (payload: unknown, id: string) => {
        mode: 'sealed';
        frame: unknown;
    } | {
        mode: 'blocked';
    };
    onHistoryQuery?: (path: string, query: SnapshotsQuery) => Promise<PathSeriesResult>;
    onSnapshotsQuery?: (query: SnapshotsQuery) => Promise<SnapshotsResult>;
    onVoyagesQuery?: (limit: number) => Promise<VoyageListResult>;
    onTrackQuery?: (voyageId: number) => Promise<TrackResult>;
    onPhasesQuery?: (limit: number) => Promise<PhaseListResult>;
    onRollupsQuery?: (from: number, to: number) => Promise<RollupsResult>;
    onStatsQuery?: () => Promise<VoyageStatsResult>;
    onFuelQuery?: () => Promise<FuelPathsView>;
    onAisQuery?: (maxNm?: number, limit?: number) => Promise<AisFeed>;
    onHealthQuery?: () => Promise<HealthResult>;
    onWatching?: () => void;
    debug: (msg: string) => void;
    connect?: (url: string, token: string) => LiveSocket;
    frameEveryMs?: number;
    pingEveryMs?: number;
}
export declare class LiveUplink {
    private readonly deps;
    private sock;
    private connected;
    private stopped;
    private gen;
    private frameTimer;
    private pingTimer;
    private redialTimer;
    private awaitingPong;
    private failures;
    private lastFrameTs;
    private lastSog;
    private rejected;
    private unentitled;
    private lastError;
    private readonly fixedFrameMs;
    private readonly pingEveryMs;
    constructor(deps: LiveDeps);
    start(): void;
    stop(): void;
    healthy(): boolean;
    reporting(): boolean;
    status(): LiveStatus;
    reset(): void;
    private dial;
    private kill;
    private dispatch;
    private openSealedAsk;
    private sendFrame;
    private scheduleFrame;
    private nextFrameDelayMs;
    private handleHistory;
    private handleSnapshots;
    private handleVoyages;
    private handleTrack;
    private handlePhases;
    private handleMore;
    private failedRead;
    private refuse;
    private reply;
    private keepalive;
    private closed;
    private failed;
    private backoffMs;
    private redial;
    private clearTimers;
}
type MoreType = 'rollups' | 'stats' | 'fuel' | 'ais' | 'health';
export declare function rpcEnvelope(data: string): {
    type: 'history' | 'snapshots' | 'voyages' | 'track' | 'phases' | MoreType;
    id: string;
} | null;
export declare function isWatchingNote(data: string): boolean;
export {};