@aeroswarm/client 0.1.11 → 0.1.13

package/dist/sdk/index.d.ts

@@ -1,582 +1,3 @@
-import { CurrentTrack, SourceStatus, AeroConnectionStatus, AeroRecoverableError, Bbox } from '@aeroswarm/core/types';
-import * as _trpc_client from '@trpc/client';
-import '@aeroswarm/core/utils';
-
-type WsEncoding = "json" | "msgpack";
-interface SubscribeOptions {
-    bbox?: [number, number, number, number];
-    /** Scope the stream to tracks stamped with this ICAO airport code, e.g. "WARR" */
-    airportId?: string;
-    source?: "fused" | "normalized";
-    minConfidence?: number;
-    maxTracks?: number;
-    mode?: "delta" | "full";
-    maxUpdateHz?: number;
-    encoding?: WsEncoding;
-    staleAfterMs?: number;
-    removeAfterMs?: number;
-}
-interface TrackCallbacks {
-    onTrackUpdate?: (track: CurrentTrack) => void;
-    onTrackRemoved?: (event: {
-        trackId: string;
-        reason: string;
-    }) => void;
-    onSnapshot?: (tracks: CurrentTrack[]) => void;
-    onSourceStatus?: (event: {
-        sourceId: string;
-        status: SourceStatus;
-    }) => void;
-    onStatusChange?: (status: AeroConnectionStatus) => void;
-    onError?: (err: AeroRecoverableError) => void;
-    onDegraded?: (reason: string) => void;
-}
-declare class AeroWsClient {
-    private readonly url;
-    private readonly token;
-    private readonly maxReconnectDelay;
-    private readonly heartbeatTimeoutMs;
-    private ws;
-    private attempt;
-    private stopped;
-    private lastSubscribe;
-    private callbacks;
-    private lastSeq;
-    private lastHeartbeat;
-    private heartbeatTimer;
-    private status;
-    constructor(url: string, token: string, maxReconnectDelay?: number, heartbeatTimeoutMs?: number);
-    connect(opts: SubscribeOptions, callbacks: TrackCallbacks): void;
-    updateFilter(opts: Partial<Pick<SubscribeOptions, 'bbox' | 'minConfidence' | 'maxUpdateHz' | 'maxTracks'>>): void;
-    disconnect(): void;
-    getStatus(): AeroConnectionStatus;
-    private _setStatus;
-    private _connect;
-    private _handleRaw;
-    private _requestSnapshot;
-    private _resetHeartbeatTimer;
-    private _clearHeartbeatTimer;
-    private _scheduleReconnect;
-}
-
-/**
- * Server-paced WS replay client for `/ws/tracks/replay`.
- *
- * The server streams historical `fused_tracks` events at `speed`× real
- * time (paced server-side against a wall-clock anchor), so the client
- * receives replay frames exactly like live traffic: a `snapshot`
- * envelope with the state at `from`, then `track.updated` /
- * `track.removed` envelopes, plus `replay.progress` heartbeats and a
- * final `replay.done`.
- *
- * The wire protocol is plain JSON, so consumers that don't use this SDK
- * can speak it manually:
- *
- *   → connect  wss://host/ws/tracks/replay?token=TOKEN[&airportId=WARR][&sessionId=ID]
- *   → send     { "type": "replay.start",  "from": ISO, "to": ISO, "speed": 2 }
- *   → send     { "type": "replay.pause" } · { "type": "replay.resume" }
- *   → send     { "type": "replay.seek",   "at": ISO }
- *   → send     { "type": "replay.stop" }
- *   ← recv     { "type": "snapshot",        "payload": { "tracks": [...], "sessionId": ID } }
- *   ← recv     { "type": "track.updated",   "payload": { "track": {...} } }
- *   ← recv     { "type": "track.removed",   "payload": { "trackId": ID, "reason": "dropped" } }
- *   ← recv     { "type": "replay.progress", "payload": { "at": ISO, "pct": 0-100, "sessionId": ID } }
- *   ← recv     { "type": "replay.done",     "payload": { "sessionId": ID } }
- *
- * Reconnecting with the same `sessionId` (within 1 h) resumes a replay
- * from its last saved position.
- */
-interface ReplayStreamOptions {
-    from: Date | string;
-    to: Date | string;
-    /** Playback speed multiplier (1 = realtime). Default 1. */
-    speed?: number;
-    /** Which airport to replay. Federated airports (with a historyEndpoint)
-     *  are resolved by AeroSwarm.replay.stream to their own backend; against
-     *  AeroSwarm's own endpoint this is a row filter on the local DB. */
-    airportId?: string;
-    /** Resume a previous session instead of starting fresh. */
-    sessionId?: string;
-}
-interface ReplayProgress {
-    /** Replay-time position (ISO timestamp) */
-    at: string;
-    /** 0–100 within the requested range */
-    pct: number;
-    sessionId: string;
-}
-interface ReplayCallbacks {
-    /** State at `from` — arrives once per start/seek. */
-    onSnapshot?: (tracks: CurrentTrack[], sessionId: string) => void;
-    onTrackUpdate?: (track: CurrentTrack) => void;
-    onTrackRemoved?: (event: {
-        trackId: string;
-        reason: string;
-    }) => void;
-    onProgress?: (progress: ReplayProgress) => void;
-    onDone?: (sessionId: string) => void;
-    onError?: (error: Error) => void;
-}
-interface ReplayHandle {
-    readonly sessionId: string | null;
-    pause(): void;
-    resume(): void;
-    /** Jump to a replay-time position; the server restarts the paced stream there. */
-    seek(at: Date | string): void;
-    /** End the replay and close the socket. */
-    stop(): void;
-}
-declare class AeroReplayClient {
-    private readonly wsBase;
-    private readonly token;
-    /** Default "/ws/tracks/replay" (AeroSwarm's own endpoint). A federated
-     *  airport backend running @aeroswarm/replay-server's default mount
-     *  uses "/replay" instead — see AeroSwarm.replay.stream's endpoint
-     *  resolution. */
-    private readonly wsPath;
-    constructor(wsBase: string, token: string, 
-    /** Default "/ws/tracks/replay" (AeroSwarm's own endpoint). A federated
-     *  airport backend running @aeroswarm/replay-server's default mount
-     *  uses "/replay" instead — see AeroSwarm.replay.stream's endpoint
-     *  resolution. */
-    wsPath?: string);
-    /** Open a replay stream. Returns a handle for transport control. */
-    stream(opts: ReplayStreamOptions, callbacks: ReplayCallbacks): ReplayHandle;
-}
-
-declare function createAeroTrpcClient(endpoint: string, token: string): _trpc_client.TRPCClient<any>;
-type AeroTrpcClient = ReturnType<typeof createAeroTrpcClient>;
-
-interface SourceRow {
-    id: string;
-    name: string;
-    type: string;
-    sourceToken: string;
-    createdAt: string;
-    /** Airport this source's data belongs to. When set, anything that
-     *  authenticates with this source's token (WS live/replay, tRPC calls)
-     *  is scoped to this airport automatically. */
-    airportId?: string | null;
-}
-declare class AeroRestClient {
-    private readonly endpoint;
-    private readonly token;
-    constructor(endpoint: string, token: string);
-    private req;
-    createSource(body: Record<string, unknown>): Promise<{
-        ok: boolean;
-        data: {
-            sourceId: string;
-            sourceToken: string;
-            airportId?: string | null;
-        };
-    }>;
-    listSources(): Promise<{
-        ok: boolean;
-        data: {
-            sources: SourceRow[];
-        };
-    }>;
-    deleteSource(id: string): Promise<{
-        ok: boolean;
-    }>;
-    createWebhook(body: {
-        url: string;
-        events: string[];
-        secret?: string;
-    }): Promise<{
-        webhookId: string;
-    }>;
-    getTracksCurrent(params?: {
-        bbox?: [number, number, number, number];
-        minConfidence?: number;
-    }): Promise<{
-        tracks: unknown[];
-        count: number;
-    }>;
-    health(): Promise<{
-        status: string;
-    }>;
-}
-
-declare class AeroGraphQLClient {
-    private readonly endpoint;
-    private readonly token;
-    constructor(endpoint: string, token: string);
-    query<T = unknown>(query: string, variables?: Record<string, unknown>): Promise<T>;
-}
-
-type Listener<T> = (payload: T) => void;
-declare class TypedEmitter<T extends Record<string, unknown>> {
-    private listeners;
-    on<K extends keyof T>(event: K, fn: Listener<T[K]>): () => void;
-    emit<K extends keyof T>(event: K, payload: T[K]): void;
-}
-declare class TrackCache extends TypedEmitter<{
-    update: CurrentTrack;
-    removed: {
-        trackId: string;
-    };
-    snapshot: CurrentTrack[];
-    status: AeroConnectionStatus;
-    degraded: {
-        reason: string;
-    };
-    error: AeroRecoverableError;
-    "source.status": {
-        sourceId: string;
-        status: SourceStatus;
-    };
-}> {
-    private tracks;
-    applyUpdate(track: CurrentTrack): void;
-    applyRemoved(ev: {
-        trackId: string;
-    }): void;
-    applySnapshot(tracks: CurrentTrack[]): void;
-    getAll(): CurrentTrack[];
-    get(id: string): CurrentTrack | undefined;
-    get size(): number;
-    clear(): void;
-    getRenderable(): (CurrentTrack & {
-        lat: number;
-        lon: number;
-    })[];
-}
-
-interface AeroSwarmOptions {
-    endpoint: string;
-    token: string;
-    wsEndpoint?: string;
-    reconnect?: boolean;
-    maxReconnectDelay?: number;
-    encoding?: "json" | "msgpack";
-    staleAfterMs?: number;
-    removeAfterMs?: number;
-    onTokenExpired?: () => Promise<string>;
-}
-interface UseAeroTracksResult {
-    tracks: CurrentTrack[];
-    status: AeroConnectionStatus;
-    sourceStatus: Record<string, string>;
-    lastUpdateAt: number | null;
-    error: AeroRecoverableError | null;
-}
-interface TrackHistoryPoint {
-    t: number;
-    lat: number | null;
-    lon: number | null;
-    altFt: number | null;
-    speedKt: number | null;
-    headingDeg: number | null;
-}
-interface DayAvailability {
-    day: string;
-    eventCount: number;
-    trackCount: number;
-    firstAt: string | null;
-    lastAt: string | null;
-}
-declare class AeroSwarm {
-    private readonly opts;
-    readonly trpc: AeroTrpcClient;
-    readonly rest: AeroRestClient;
-    readonly graphql: AeroGraphQLClient;
-    readonly cache: TrackCache;
-    private readonly wsClient;
-    private _status;
-    private _lastUpdateAt;
-    private _error;
-    private _sourceStatus;
-    private airportsCache;
-    private static readonly AIRPORTS_CACHE_TTL_MS;
-    /** Resolves which base URL (if any) should serve a federated call.
-     *  Returns null to mean "use AeroSwarm's own endpoint" — the normal,
-     *  unfederated path, which is also what a lookup failure falls back to
-     *  (a broken airports.list() call must never brick replay/history for
-     *  everyone else). */
-    private resolveHistoryEndpoint;
-    private federatedFetch;
-    constructor(opts: AeroSwarmOptions);
-    readonly tracks: {
-        subscribe: (opts: SubscribeOptions, callbacks: TrackCallbacks) => (() => void);
-        updateFilter: (opts: Partial<SubscribeOptions>) => void;
-        stream: (opts: SubscribeOptions) => AsyncIterable<CurrentTrack>;
-        snapshot: (input?: {
-            airportId?: string;
-            bbox?: Bbox;
-            source?: "fused" | "normalized";
-            minConfidence?: number;
-            limit?: number;
-            offset?: number;
-        }) => any;
-        /** Persisted position history for one track. If the airport has a
-         *  `historyEndpoint` (or `endpoint` is passed explicitly), this calls
-         *  that backend's `@aeroswarm/replay-server` instead of AeroSwarm's
-         *  own local database — see docs/development/federation/003-*.md. */
-        history: (input: {
-            trackId: string;
-            airportId?: string;
-            limit?: number;
-            endpoint?: string;
-        }) => Promise<TrackHistoryPoint[]>;
-    };
-    readonly sources: {
-        /** Registers a source and returns its token, tied to `airportId` — a
-         *  source is a sensor physically at one airport, so this is required.
-         *  Anything that later authenticates with the returned token (WS
-         *  live/replay, tRPC calls) is scoped to that airport automatically,
-         *  with no need to keep passing `airportId` on every subsequent call.
-         *  For access spanning multiple airports, use the viewer/dashboard
-         *  token instead — it's never auto-scoped. */
-        create: (body: {
-            name: string;
-            airportId: string;
-            sourceType?: string;
-            location?: {
-                lat: number;
-                lon: number;
-            };
-            config?: Record<string, unknown>;
-        }) => Promise<{
-            ok: boolean;
-            data: {
-                sourceId: string;
-                sourceToken: string;
-                airportId?: string | null;
-            };
-        }>;
-        health: (sourceId: string) => any;
-        list: (input?: {
-            airportId?: string;
-        }) => any;
-        /** Reassigning `airportId` (including to `null` to clear it) re-caches
-         *  the source's token immediately, so the new scoping takes effect
-         *  without waiting out the token cache's TTL. */
-        update: (input: {
-            id: string;
-            name?: string;
-            airportId?: string | null;
-            location?: {
-                lat: number;
-                lon: number;
-            };
-            config?: Record<string, unknown>;
-        }) => any;
-        delete: (id: string) => any;
-    };
-    /** Airport registry (multi-airport tenancy). */
-    readonly airports: {
-        list: () => Promise<{
-            airports: {
-                id: string;
-                name: string;
-                city: string | null;
-                lat: number;
-                lon: number;
-                bbox: [number, number, number, number];
-                timezone: string;
-                /** Set = this airport serves its own replay/history (federated —
-                 *  see docs/development/federation/003-*.md); `replay.*`/
-                 *  `tracks.history` calls for it connect there directly instead of
-                 *  AeroSwarm's own endpoint. null = AeroSwarm serves it (default). */
-                historyEndpoint: string | null;
-            }[];
-        }>;
-        create: (input: {
-            id: string;
-            name: string;
-            city?: string;
-            lat: number;
-            lon: number;
-            bbox: [number, number, number, number];
-            timezone?: string;
-            historyEndpoint?: string;
-        }) => Promise<{
-            ok: boolean;
-            id: string;
-        }>;
-        update: (input: {
-            id: string;
-            name?: string;
-            city?: string;
-            lat?: number;
-            lon?: number;
-            bbox?: [number, number, number, number];
-            timezone?: string;
-            /** null clears it (reverts to AeroSwarm's own replay); omit to leave unchanged. */
-            historyEndpoint?: string | null;
-        }) => Promise<{
-            ok: boolean;
-        }>;
-        delete: (input: {
-            id: string;
-        }) => Promise<{
-            ok: boolean;
-        }>;
-        /** Surface geometry (runway/taxiway/apron GeoJSON) for the map. */
-        surface: (input: {
-            id: string;
-        }) => Promise<{
-            surface: unknown | null;
-        }>;
-        setSurface: (input: {
-            id: string;
-            surface: Record<string, unknown>;
-        }) => Promise<{
-            ok: boolean;
-        }>;
-    };
-    readonly replay: {
-        /** Data-availability calendar: which days have recorded tracks.
-         *  Use this to populate/validate replay date pickers — days not in
-         *  the list have no data. Federates to the airport's own backend when
-         *  it has a `historyEndpoint` (or `endpoint` is passed explicitly) —
-         *  see docs/development/federation/003-*.md. */
-        days: (input?: {
-            airportId?: string;
-            lookbackDays?: number;
-            endpoint?: string;
-        }) => Promise<{
-            days: DayAvailability[];
-        }>;
-        range: (input: {
-            from: string;
-            to: string;
-            airportId?: string;
-            endpoint?: string;
-        }) => Promise<{
-            earliest: string | null;
-            latest: string | null;
-            eventCount: number;
-            trackCount: number;
-            from: string;
-            to: string;
-        }>;
-        /** Server-paced WS playback: streams historical tracks at `speed`× in
-         *  the same envelope format as the live stream. Returns a transport
-         *  handle (pause/resume/seek/stop) — a Promise, since resolving which
-         *  backend serves this airport (see docs/development/federation/003-*.md)
-         *  is async. See `AeroReplayClient` for the raw wire protocol if you
-         *  want to speak WS manually instead. */
-        stream: (opts: ReplayStreamOptions & {
-            endpoint?: string;
-        }, callbacks: ReplayCallbacks) => Promise<ReplayHandle>;
-    };
-    /** Movement analytics: takeoffs/landings per hour + peak hour, recorded
-     *  by the pipeline's movement detector. */
-    readonly analytics: {
-        movements: (input?: {
-            airportId?: string;
-            day?: string;
-        }) => Promise<{
-            day: string;
-            hours: {
-                hour: string;
-                takeoffs: number;
-                landings: number;
-            }[];
-            totals: {
-                takeoffs: number;
-                landings: number;
-            };
-            peak: {
-                hour: string;
-                count: number;
-            } | null;
-        }>;
-    };
-    /** Route conformance: pre-defined ground routes + live track clearances.
-     *  Assign a route to a track and the safety engine can detect when it
-     *  strays beyond the route's corridor. */
-    readonly routes: {
-        list: (input?: {
-            airportId?: string;
-        }) => Promise<{
-            routes: {
-                routeId: string;
-                airportId: string;
-                name: string;
-                kind: string;
-                points: [number, number][];
-                maxDeviationM: number;
-                enabled: boolean;
-            }[];
-        }>;
-        create: (input: {
-            airportId: string;
-            name: string;
-            kind?: "taxi" | "departure" | "arrival";
-            points: [number, number][];
-            maxDeviationM?: number;
-        }) => Promise<{
-            id: string;
-        }>;
-        delete: (input: {
-            id: string;
-        }) => Promise<{
-            ok: boolean;
-        }>;
-        assign: (input: {
-            trackId: string;
-            routeId: string;
-        }) => Promise<{
-            ok: boolean;
-        }>;
-        unassign: (input: {
-            trackId: string;
-        }) => Promise<{
-            ok: boolean;
-        }>;
-        assignments: () => Promise<{
-            assignments: {
-                trackId: string;
-                routeId: string;
-                assignedAt: number;
-            }[];
-        }>;
-    };
-    readonly webhooks: {
-        list: () => any;
-        create: (body: {
-            url: string;
-            events: string[];
-            secret?: string;
-        }) => Promise<{
-            ok: boolean;
-            webhookId: string;
-        }>;
-        delete: (input: {
-            id: string;
-        }) => any;
-    };
-    readonly system: {
-        stats: () => any;
-        infraHealth: () => any;
-        ingestHistory: () => any;
-        getConfig: () => Promise<{
-            key: string;
-            value: string;
-            updatedAt: string;
-        }[]>;
-        setConfig: (input: {
-            key: string;
-            value: string;
-        }) => Promise<{
-            ok: boolean;
-        }>;
-        clearTable: (input: {
-            table: "fused_tracks" | "source_health";
-            mode: "all" | "range";
-            from?: string;
-            to?: string;
-        }) => any;
-    };
-    getStatus(): AeroConnectionStatus;
-    getLastUpdateAt(): number | null;
-    getError(): AeroRecoverableError | null;
-    getSourceStatus(): Record<string, string>;
-    disconnect(): void;
-}
-
-export { AeroReplayClient, AeroSwarm, type AeroSwarmOptions, AeroWsClient, type DayAvailability, type ReplayCallbacks, type ReplayHandle, type ReplayProgress, type ReplayStreamOptions, type SourceRow, type SubscribeOptions, TrackCache, type TrackCallbacks, type TrackHistoryPoint, type UseAeroTracksResult };
+import '@aeroswarm/core/types';
+export { A as AeroReplayClient, a as AeroSwarm, b as AeroSwarmOptions, c as AeroWsClient, d as AftnMessageRow, D as DayAvailability, F as FlightPlanRow, g as LiveTrackCallbacks, R as ReplayCallbacks, h as ReplayHandle, i as ReplayProgress, j as ReplayStreamOptions, S as SourceRow, k as StreamMeta, l as SubscribeOptions, T as TrackCache, m as TrackCallbacks, n as TrackHistoryPoint, U as UseAeroTracksResult } from '../index-BXiTmKdS.js';
+import '@trpc/client';