doover-js 0.11.0 → 0.13.0

package/dist/esm/types/viewer.d.ts

@@ -0,0 +1,122 @@
+import type { SourceProvenance } from "./provenance.js";
+import type { Aggregate, Channel, ConnectionDetails, MessageStructure } from "./common.js";
+export interface ChannelIdentifier {
+    agentId?: string;
+    channelName?: string;
+    error?: string;
+}
+export interface Agent {
+    id: string;
+    organisation: string;
+    name: string;
+    display_name: string;
+    archived: boolean;
+    group: string;
+    fa_icon: string;
+    type: "device" | "dashboard" | "organisation" | "user";
+    fixed_location: {
+        latitude: number;
+        longitude: number;
+    };
+    extra_config: Record<string, unknown>;
+    connection_determination?: "Online" | "Offline";
+    __source?: SourceProvenance;
+}
+export interface User {
+    id: string;
+    email?: string;
+    name?: string;
+    __source?: SourceProvenance;
+    [key: string]: unknown;
+}
+export interface Theme {
+    [key: string]: unknown;
+}
+export interface OrganisationDomain {
+    id: string;
+    hostname: string;
+    default: boolean;
+}
+export interface Organisation {
+    id: string;
+    name: string;
+    archived: boolean;
+    application_id: string;
+    domains: OrganisationDomain[];
+    root_group?: unknown;
+    retention_period?: number;
+    legacy_doover_api_key?: string | null;
+    llm_api_key?: string | null;
+    extra_config?: Record<string, unknown>;
+    theme?: Theme;
+    __source?: SourceProvenance;
+    [key: string]: unknown;
+}
+export interface CustomerSite {
+    id: string;
+    name: string;
+    application_id: string;
+    archived: boolean;
+    theme: Theme;
+}
+export interface PaginatedResponse<T> {
+    count: number;
+    results: T[];
+    next?: string | null;
+    previous?: string | null;
+    [key: string]: unknown;
+}
+export interface GetAgentsOptions {
+    includeArchived?: boolean;
+    includeOrganisations?: boolean;
+    includeUsers?: boolean;
+    /**
+     * When `true`, normalized organisations and users are appended into the
+     * canonical `agents` list (and mirrored to `results` / `count`). Defaults
+     * to `false`, which preserves the legacy behaviour of returning only the
+     * raw `agents` array.
+     */
+    mergeIncludedAsAgents?: boolean;
+}
+export interface AgentsResponse {
+    agents?: Agent[];
+    results?: Agent[];
+    count?: number;
+    [key: string]: unknown;
+}
+export interface SubscriptionDetails {
+    channel: {
+        agent_id: string;
+        name: string;
+    };
+    connection_id: string;
+    subscribed_at: number;
+}
+export interface ChannelsDataProvider<TIdentifier extends ChannelIdentifier = ChannelIdentifier> {
+    getMe: () => Promise<User>;
+    getAgents: (options?: GetAgentsOptions) => Promise<AgentsResponse>;
+    getChannels: (identifier: TIdentifier, options?: {
+        includeArchived?: boolean;
+    }) => Promise<Channel[] | undefined>;
+    createChannel: (identifier: TIdentifier, channelName: string, options?: {
+        is_private?: boolean;
+    }) => Promise<unknown>;
+    archiveChannel: (identifier: TIdentifier) => Promise<unknown>;
+    unarchiveChannel: (identifier: TIdentifier) => Promise<unknown>;
+    getChannel: (identifier: TIdentifier) => Promise<Channel | undefined>;
+    subscribeToChannel: (identifier: TIdentifier, callback: (identifier: ChannelIdentifier, message: MessageStructure) => void, aggregateCallback: (identifier: ChannelIdentifier, aggregate: Aggregate) => void) => Promise<void | undefined>;
+    unsubscribeFromChannel: (identifier: TIdentifier, callback: (identifier: ChannelIdentifier, message: MessageStructure) => void) => Promise<void | undefined>;
+    getAggregate: (identifier: TIdentifier) => Promise<Aggregate | undefined>;
+    getMessages: (identifier: TIdentifier, beforeId?: string) => Promise<MessageStructure[] | undefined>;
+    deleteMessage: (identifier: TIdentifier, messageId: string) => Promise<unknown>;
+    sendMessage: (identifier: TIdentifier, message: object) => Promise<MessageStructure>;
+    updateAggregate: (identifier: TIdentifier, message: object) => Promise<Aggregate>;
+    putAggregate: (identifier: TIdentifier, message: object) => Promise<Aggregate>;
+    getChannelSubscriptions: (identifier: TIdentifier) => Promise<SubscriptionDetails[]>;
+    getAgentConnections: (identifier: TIdentifier) => Promise<ConnectionDetails[]>;
+    getIdentifierFromPath: (path: string, searchParams: URLSearchParams) => {
+        identifier: TIdentifier;
+        aggregatePath?: string;
+    };
+    getAgentInfo: (agentId: string) => Promise<Agent | undefined>;
+}

package/dist/esm/utils/snowflake.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Snowflake id for a point in time, floored at the epoch.
+ *
+ * Ids are unsigned, so a pre-epoch time has no id to generate. Returning the
+ * negative arithmetic result produced a value the API rejects outright
+ * ("expected a snowflake id value"), failing the whole request; `0` is the
+ * oldest addressable id, which is what a caller reaching further back wants.
+ */
+export declare function generateSnowflakeIdAtTime(time: {
+    valueOf(): number;
+}): string;
+export declare function extractSnowflakeId(id: string): {
+    timestamp: number;
+    machineId: number;
+    sequence: number;
+};
+export declare function addTimestampToMessage<T extends {
+    id: string;
+}>(message: T): T & {
+    timestamp: number;
+};

package/dist/esm/utils/snowflake.js

@@ -0,0 +1,33 @@
+/** Doover's snowflake epoch: 2025-01-01T00:00:00Z. Nothing predates it. */
+const SNOWFLAKE_EPOCH_MS = 1735689600000;
+/**
+ * Snowflake id for a point in time, floored at the epoch.
+ *
+ * Ids are unsigned, so a pre-epoch time has no id to generate. Returning the
+ * negative arithmetic result produced a value the API rejects outright
+ * ("expected a snowflake id value"), failing the whole request; `0` is the
+ * oldest addressable id, which is what a caller reaching further back wants.
+ */
+export function generateSnowflakeIdAtTime(time) {
+    const offsetMs = time.valueOf() - SNOWFLAKE_EPOCH_MS;
+    if (Number.isNaN(offsetMs)) {
+        throw new TypeError("generateSnowflakeIdAtTime received an invalid time");
+    }
+    const bigId = BigInt(Math.max(0, offsetMs)) << 22n;
+    return bigId.toString();
+}
+export function extractSnowflakeId(id) {
+    const offset = 1735689600000n;
+    return {
+        timestamp: Number((BigInt(id) >> 22n) + offset),
+        machineId: Number((BigInt(id) >> 12n) & 1023n),
+        sequence: Number(BigInt(id) & 4095n),
+    };
+}
+export function addTimestampToMessage(message) {
+    const extracted = extractSnowflakeId(message.id);
+    return {
+        ...message,
+        timestamp: extracted.timestamp,
+    };
+}

package/dist/esm/viewer/doover-data-provider.d.ts

@@ -0,0 +1,90 @@
+import { AgentsApi } from "../apis/agents-api.js";
+import { AggregatesApi, type AggregateMutationParams } from "../apis/aggregates-api.js";
+import { ChannelsApi } from "../apis/channels-api.js";
+import { ConnectionsApi } from "../apis/connections-api.js";
+import { MessagesApi, type ListMessagesParams } from "../apis/messages-api.js";
+import type { DooverAuth } from "../auth/doover-auth.js";
+import { GatewayClient } from "../gateway/gateway-client.js";
+import { RestClient, type DooverClientConfig } from "../http/rest-client.js";
+import type { Aggregate, Channel, ConnectionDetails, JSONValue, MessageStructure, RpcRequest, RpcStatus } from "../types/common.js";
+import type { Agent, AgentsResponse, ChannelIdentifier, ChannelsDataProvider, GetAgentsOptions, SubscriptionDetails, User } from "../types/viewer.js";
+interface SubscriptionEntry {
+    messageCallback: (identifier: ChannelIdentifier, message: MessageStructure) => void;
+    aggregateCallback: (identifier: ChannelIdentifier, aggregate: Aggregate) => void;
+    /**
+     * `message` is the full post-update MessageStructure (server-side `.message`
+     * field). `request_data` is the diff of just-changed fields, or undefined
+     * if the server didn't provide one. Most consumers only need `message`.
+     */
+    messageUpdateCallback?: (identifier: ChannelIdentifier, message: MessageStructure, request_data?: JSONValue) => void;
+}
+/** @deprecated Use DooverClient subclients directly. Removed in 0.6.0. */
+export declare class DooverDataProvider implements ChannelsDataProvider<ChannelIdentifier> {
+    readonly rest: RestClient;
+    readonly gateway: GatewayClient;
+    readonly agentsApi: AgentsApi;
+    readonly channelsApi: ChannelsApi;
+    readonly messagesApi: MessagesApi;
+    readonly aggregatesApi: AggregatesApi;
+    readonly connectionsApi: ConnectionsApi;
+    private readonly controlApiUrl?;
+    private bridges;
+    private dispatcher?;
+    constructor(config: DooverClientConfig, auth?: DooverAuth);
+    constructor(injected: {
+        rest: RestClient;
+        gateway: GatewayClient;
+        controlApiUrl?: string;
+    });
+    /** @deprecated Use `client.users.getMe()` instead. Removed in 0.6.0. */
+    getMe(): Promise<User>;
+    /** @deprecated Use `client.agents.listAgents(opts)` instead. Removed in 0.6.0. */
+    getAgents(options?: GetAgentsOptions): Promise<AgentsResponse>;
+    /** @deprecated Use `client.channels.listChannels(id, opts)` instead. Removed in 0.6.0. */
+    getChannels(identifier: ChannelIdentifier, options?: {
+        includeArchived?: boolean;
+    }): Promise<Channel[] | undefined>;
+    /** @deprecated Use `client.channels.putChannel(id, name, body)` instead. Removed in 0.6.0. */
+    createChannel(identifier: ChannelIdentifier, channelName: string, options?: {
+        is_private?: boolean;
+    }): Promise<unknown>;
+    /** @deprecated Use `client.channels.archiveChannel(id)` instead. Removed in 0.6.0. */
+    archiveChannel(identifier: ChannelIdentifier): Promise<unknown>;
+    /** @deprecated Use `client.channels.unarchiveChannel(id)` instead. Removed in 0.6.0. */
+    unarchiveChannel(identifier: ChannelIdentifier): Promise<unknown>;
+    /** @deprecated Use `client.channels.getChannel(id)` instead. Removed in 0.6.0. */
+    getChannel(identifier: ChannelIdentifier): Promise<Channel | undefined>;
+    /** @deprecated Use `client.gateway.subscribeToChannel(channel, handlers)` instead. Removed in 0.6.0. */
+    subscribeToChannel(identifier: ChannelIdentifier, callback: SubscriptionEntry["messageCallback"], aggregateCallback: SubscriptionEntry["aggregateCallback"], messageUpdateCallback?: SubscriptionEntry["messageUpdateCallback"]): Promise<void>;
+    /** @deprecated Call the unsubscribe fn returned by `client.gateway.subscribeToChannel`. Removed in 0.6.0. */
+    unsubscribeFromChannel(_identifier: ChannelIdentifier, callback: SubscriptionEntry["messageCallback"]): Promise<void>;
+    /** @deprecated Compose `client.channels.getChannel(id).then(c => c.aggregate ?? client.aggregates.getAggregate(id))` instead. Removed in 0.6.0. */
+    getAggregate(identifier: ChannelIdentifier): Promise<Aggregate | undefined>;
+    /** @deprecated Use `client.messages.listMessages(id, { ...opts, order: "asc" })` instead. Removed in 0.6.0. */
+    getMessages(identifier: ChannelIdentifier, optionsOrBefore?: string | ListMessagesParams): Promise<MessageStructure[] | undefined>;
+    /** @deprecated Use `client.messages.deleteMessage(id, msgId)` instead. Removed in 0.6.0. */
+    deleteMessage(identifier: ChannelIdentifier, messageId: string): Promise<unknown>;
+    /** @deprecated Use `client.messages.postMessage(id, { data })` instead. Removed in 0.6.0. */
+    sendMessage(identifier: ChannelIdentifier, message: object): Promise<MessageStructure>;
+    /** @deprecated Use `client.rpc.send(id, req, opts)` instead. Removed in 0.6.0. */
+    sendRPC<TRequest = object, TResponse = object, TPending = undefined>(identifier: ChannelIdentifier, rpcRequest: RpcRequest<TRequest>, options?: {
+        onStatus?: (status: RpcStatus<TPending>) => void;
+    }): Promise<TResponse>;
+    /** @deprecated Use `client.aggregates.patchAggregate(id, data, params)` instead. Removed in 0.6.0. */
+    updateAggregate(identifier: ChannelIdentifier, message: object, params?: AggregateMutationParams): Promise<Aggregate>;
+    /** @deprecated Use `client.aggregates.putAggregate(id, data, params)` instead. Removed in 0.6.0. */
+    putAggregate(identifier: ChannelIdentifier, message: object, params?: AggregateMutationParams): Promise<Aggregate>;
+    /** @deprecated Use `client.connections.getChannelSubscriptions(id)` instead. Removed in 0.6.0. */
+    getChannelSubscriptions(identifier: ChannelIdentifier): Promise<SubscriptionDetails[]>;
+    /** @deprecated Use `client.connections.getAgentConnections(id)` instead. Removed in 0.6.0. */
+    getAgentConnections(identifier: ChannelIdentifier): Promise<ConnectionDetails[]>;
+    /** @deprecated Use the free function `getIdentifierFromPath(path, search)` instead. Removed in 0.6.0. */
+    getIdentifierFromPath(path: string, searchParams: URLSearchParams): {
+        identifier: ChannelIdentifier;
+        aggregatePath?: string;
+    };
+    /** @deprecated No replacement — this was a synthesized stub. Removed in 0.6.0. */
+    getAgentInfo(agentId: string): Promise<Agent | undefined>;
+    private requireChannel;
+}
+export {};

package/dist/esm/viewer/doover-data-provider.js

@@ -0,0 +1,189 @@
+import { AgentsApi } from "../apis/agents-api.js";
+import { AggregatesApi } from "../apis/aggregates-api.js";
+import { ChannelsApi } from "../apis/channels-api.js";
+import { ConnectionsApi } from "../apis/connections-api.js";
+import { MessagesApi } from "../apis/messages-api.js";
+import { UsersApi } from "../apis/users-api.js";
+import { GatewayClient } from "../gateway/gateway-client.js";
+import { DooverValidationError } from "../http/errors.js";
+import { RestClient } from "../http/rest-client.js";
+import { RpcDispatcher } from "../rpc/rpc-dispatcher.js";
+import { getIdentifierFromPath as parseIdentifierFromPath } from "./path-parsing.js";
+/** @deprecated Use DooverClient subclients directly. Removed in 0.6.0. */
+export class DooverDataProvider {
+    // implementation
+    constructor(configOrInjected, auth) {
+        this.bridges = new Map();
+        if ("rest" in configOrInjected && "gateway" in configOrInjected) {
+            this.rest = configOrInjected.rest;
+            this.gateway = configOrInjected.gateway;
+            this.controlApiUrl = configOrInjected.controlApiUrl;
+        }
+        else {
+            this.rest = new RestClient(configOrInjected, auth);
+            this.gateway = new GatewayClient(configOrInjected, auth);
+            this.controlApiUrl = configOrInjected.controlApiUrl;
+        }
+        this.agentsApi = new AgentsApi(this.rest, this.controlApiUrl);
+        this.channelsApi = new ChannelsApi(this.rest);
+        this.messagesApi = new MessagesApi(this.rest);
+        this.aggregatesApi = new AggregatesApi(this.rest);
+        this.connectionsApi = new ConnectionsApi(this.rest);
+    }
+    /** @deprecated Use `client.users.getMe()` instead. Removed in 0.6.0. */
+    getMe() {
+        return new UsersApi(this.rest, this.controlApiUrl).getMe();
+    }
+    /** @deprecated Use `client.agents.listAgents(opts)` instead. Removed in 0.6.0. */
+    async getAgents(options) {
+        return this.agentsApi.listAgents(options);
+    }
+    /** @deprecated Use `client.channels.listChannels(id, opts)` instead. Removed in 0.6.0. */
+    async getChannels(identifier, options) {
+        if (!identifier.agentId)
+            return undefined;
+        return this.channelsApi.listChannels(identifier.agentId, {
+            include_archived: options?.includeArchived,
+        });
+    }
+    /** @deprecated Use `client.channels.putChannel(id, name, body)` instead. Removed in 0.6.0. */
+    createChannel(identifier, channelName, options) {
+        if (!identifier.agentId) {
+            throw new DooverValidationError("Identifier must contain agentId");
+        }
+        return this.channelsApi.putChannel(identifier.agentId, channelName, {
+            is_private: options?.is_private ?? false,
+        });
+    }
+    /** @deprecated Use `client.channels.archiveChannel(id)` instead. Removed in 0.6.0. */
+    archiveChannel(identifier) {
+        const v = this.requireChannel(identifier);
+        return this.channelsApi.archiveChannel(v.agentId, v.channelName);
+    }
+    /** @deprecated Use `client.channels.unarchiveChannel(id)` instead. Removed in 0.6.0. */
+    unarchiveChannel(identifier) {
+        const v = this.requireChannel(identifier);
+        return this.channelsApi.unarchiveChannel(v.agentId, v.channelName);
+    }
+    /** @deprecated Use `client.channels.getChannel(id)` instead. Removed in 0.6.0. */
+    getChannel(identifier) {
+        if (!identifier.agentId || !identifier.channelName) {
+            return Promise.resolve(undefined);
+        }
+        return this.channelsApi.getChannel(identifier.agentId, identifier.channelName);
+    }
+    /** @deprecated Use `client.gateway.subscribeToChannel(channel, handlers)` instead. Removed in 0.6.0. */
+    async subscribeToChannel(identifier, callback, aggregateCallback, messageUpdateCallback) {
+        const validated = this.requireChannel(identifier);
+        const channel = { agent_id: validated.agentId, name: validated.channelName };
+        const off = this.gateway.subscribeToChannel(channel, {
+            onMessage: (msg) => callback(identifier, msg),
+            onAggregate: (agg) => aggregateCallback(identifier, agg),
+            onMessageUpdate: messageUpdateCallback
+                ? (msg, rd) => messageUpdateCallback(identifier, msg, rd)
+                : undefined,
+        });
+        this.bridges.set(callback, off);
+        await this.gateway.connect();
+    }
+    /** @deprecated Call the unsubscribe fn returned by `client.gateway.subscribeToChannel`. Removed in 0.6.0. */
+    async unsubscribeFromChannel(_identifier, callback) {
+        const off = this.bridges.get(callback);
+        if (!off) {
+            throw new DooverValidationError("Not Currently Subscribed to Channel");
+        }
+        off();
+        this.bridges.delete(callback);
+    }
+    /** @deprecated Compose `client.channels.getChannel(id).then(c => c.aggregate ?? client.aggregates.getAggregate(id))` instead. Removed in 0.6.0. */
+    async getAggregate(identifier) {
+        if (!identifier.agentId || !identifier.channelName)
+            return undefined;
+        const ch = await this.channelsApi.getChannel(identifier.agentId, identifier.channelName);
+        if (ch.aggregate)
+            return ch.aggregate;
+        return this.aggregatesApi.getAggregate(identifier.agentId, identifier.channelName);
+    }
+    /** @deprecated Use `client.messages.listMessages(id, { ...opts, order: "asc" })` instead. Removed in 0.6.0. */
+    async getMessages(identifier, optionsOrBefore) {
+        if (!identifier.agentId || !identifier.channelName)
+            return undefined;
+        const params = typeof optionsOrBefore === "string"
+            ? { before: optionsOrBefore }
+            : (optionsOrBefore ?? {});
+        return this.messagesApi.listMessages(identifier.agentId, identifier.channelName, {
+            ...params,
+            order: "asc",
+        });
+    }
+    /** @deprecated Use `client.messages.deleteMessage(id, msgId)` instead. Removed in 0.6.0. */
+    deleteMessage(identifier, messageId) {
+        const v = this.requireChannel(identifier);
+        return this.messagesApi.deleteMessage(v.agentId, v.channelName, messageId);
+    }
+    /** @deprecated Use `client.messages.postMessage(id, { data })` instead. Removed in 0.6.0. */
+    sendMessage(identifier, message) {
+        const v = this.requireChannel(identifier);
+        return this.messagesApi.postMessage(v.agentId, v.channelName, {
+            data: message,
+        });
+    }
+    /** @deprecated Use `client.rpc.send(id, req, opts)` instead. Removed in 0.6.0. */
+    sendRPC(identifier, rpcRequest, options) {
+        const v = this.requireChannel(identifier);
+        if (!this.dispatcher) {
+            this.dispatcher = new RpcDispatcher(this.gateway, this.messagesApi);
+        }
+        return this.dispatcher.send({ agentId: v.agentId, channelName: v.channelName }, rpcRequest, options);
+    }
+    /** @deprecated Use `client.aggregates.patchAggregate(id, data, params)` instead. Removed in 0.6.0. */
+    updateAggregate(identifier, message, params) {
+        const v = this.requireChannel(identifier);
+        return this.aggregatesApi.patchAggregate(v.agentId, v.channelName, message, params);
+    }
+    /** @deprecated Use `client.aggregates.putAggregate(id, data, params)` instead. Removed in 0.6.0. */
+    putAggregate(identifier, message, params) {
+        const v = this.requireChannel(identifier);
+        return this.aggregatesApi.putAggregate(v.agentId, v.channelName, message, params);
+    }
+    /** @deprecated Use `client.connections.getChannelSubscriptions(id)` instead. Removed in 0.6.0. */
+    getChannelSubscriptions(identifier) {
+        const v = this.requireChannel(identifier);
+        return this.connectionsApi.getChannelSubscriptions(v.agentId, v.channelName);
+    }
+    /** @deprecated Use `client.connections.getAgentConnections(id)` instead. Removed in 0.6.0. */
+    getAgentConnections(identifier) {
+        if (!identifier.agentId) {
+            return Promise.reject(new DooverValidationError("Invalid Identifier"));
+        }
+        return this.connectionsApi.getAgentConnections(identifier.agentId);
+    }
+    /** @deprecated Use the free function `getIdentifierFromPath(path, search)` instead. Removed in 0.6.0. */
+    getIdentifierFromPath(path, searchParams) {
+        return parseIdentifierFromPath(path, searchParams);
+    }
+    /** @deprecated No replacement — this was a synthesized stub. Removed in 0.6.0. */
+    getAgentInfo(agentId) {
+        return Promise.resolve({
+            id: agentId,
+            name: agentId,
+            display_name: agentId,
+            type: "device",
+            fa_icon: "fa-solid fa-robot",
+            organisation: "Organisation",
+            group: "group",
+            archived: false,
+            fixed_location: { latitude: 0, longitude: 0 },
+            extra_config: {},
+        });
+    }
+    requireChannel(identifier) {
+        if (!identifier.agentId || !identifier.channelName) {
+            throw new DooverValidationError("Identifier must contain agentId and channelName");
+        }
+        return {
+            agentId: identifier.agentId,
+            channelName: identifier.channelName,
+        };
+    }
+}

package/dist/esm/viewer/path-parsing.d.ts

@@ -0,0 +1,5 @@
+import type { ChannelIdentifier } from "../types/viewer.js";
+export declare function getIdentifierFromPath<TIdentifier extends ChannelIdentifier>(path: string, _searchParams: URLSearchParams): {
+    identifier: TIdentifier;
+    aggregatePath?: string;
+};

package/dist/esm/viewer/path-parsing.js

@@ -0,0 +1,35 @@
+export function getIdentifierFromPath(path, _searchParams) {
+    const cleaned = path.replace(/^\/+|\/+$/g, "");
+    const parts = cleaned ? cleaned.split("/") : [];
+    if (parts.length === 1) {
+        return {
+            identifier: {
+                agentId: parts[0],
+                channelName: undefined,
+            },
+        };
+    }
+    if (parts.length === 2) {
+        return {
+            identifier: {
+                agentId: parts[0],
+                channelName: parts[1],
+            },
+        };
+    }
+    if (parts.length > 2) {
+        return {
+            identifier: {
+                agentId: parts[0],
+                channelName: parts[1],
+            },
+            aggregatePath: parts.slice(2).join("/"),
+        };
+    }
+    return {
+        identifier: {
+            agentId: undefined,
+            channelName: undefined,
+        },
+    };
+}

package/dist/gateway/gateway-client.d.ts

@@ -1,8 +1,8 @@
-import type { DooverAuth } from "../auth/doover-auth";
-import type { DooverStatsCollector } from "../client/stats";
-import type { DooverClientConfig } from "../http/rest-client";
-import type { GatewayListenerMap, WebSocketSession } from "./types";
-import type { Aggregate, ChannelRef, JSONValue, MessageStructure } from "../types/common";
+import type { DooverAuth } from "../auth/doover-auth.js";
+import type { DooverStatsCollector } from "../client/stats.js";
+import type { DooverClientConfig } from "../http/rest-client.js";
+import type { GatewayListenerMap, WebSocketSession } from "./types.js";
+import type { Aggregate, ChannelRef, JSONValue, MessageStructure } from "../types/common.js";
 export type GatewayProvenanceHook = <T>(value: T, ctx: {
     event: string;
     sessionId?: string;

package/dist/gateway/gateway-client.js

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GatewayClient = void 0;
-const errors_1 = require("../http/errors");
-const snowflake_1 = require("../utils/snowflake");
+const errors_js_1 = require("../http/errors.js");
+const snowflake_js_1 = require("../utils/snowflake.js");
 const RECONNECT_BASE_MS = 1000;
 const RECONNECT_CAP_MS = 30000;
 /** Schemes a WebSocket can be opened on — it maps http(s) to ws(s) itself. */
@@ -347,10 +347,10 @@ class GatewayClient {
                 this.emit("channelSync", this.stamp(message.d, "channelSync"));
                 break;
             case "MessageCreate":
-                this.emit("messageCreate", this.stamp((0, snowflake_1.addTimestampToMessage)(message.d), "messageCreate"));
+                this.emit("messageCreate", this.stamp((0, snowflake_js_1.addTimestampToMessage)(message.d), "messageCreate"));
                 break;
             case "MessageUpdate":
-                this.emit("messageUpdate", this.stamp((0, snowflake_1.addTimestampToMessage)(message.d.message), "messageUpdate"), message.d.request_data);
+                this.emit("messageUpdate", this.stamp((0, snowflake_js_1.addTimestampToMessage)(message.d.message), "messageUpdate"), message.d.request_data);
                 break;
             case "AggregateUpdate":
                 this.emit("aggregateUpdate", this.stamp(message.d, "aggregateUpdate"));
@@ -402,7 +402,7 @@ class GatewayClient {
     }
     send(payload) {
         if (!this.socket || this.socket.readyState !== WebSocket.OPEN) {
-            throw new errors_1.DooverGatewayError("WebSocket is not connected");
+            throw new errors_js_1.DooverGatewayError("WebSocket is not connected");
         }
         this.socket.send(JSON.stringify(payload));
         this.stats?.recordGatewaySent();

package/dist/gateway/index.d.ts

@@ -0,0 +1,3 @@
+export { GatewayClient } from "./gateway-client.js";
+export type { ChannelHandlers } from "./gateway-client.js";
+export type * from "./types.js";

package/dist/gateway/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GatewayClient = void 0;
+var gateway_client_js_1 = require("./gateway-client.js");
+Object.defineProperty(exports, "GatewayClient", { enumerable: true, get: function () { return gateway_client_js_1.GatewayClient; } });

package/dist/gateway/types.d.ts

@@ -1,4 +1,4 @@
-import type { Aggregate, Alarm, ChannelRef, JSONValue, MessageStructure } from "../types/common";
+import type { Aggregate, Alarm, ChannelRef, JSONValue, MessageStructure } from "../types/common.js";
 export interface WebSocketSubscription {
     channel: ChannelRef;
     organisation_id?: string | null;

package/dist/http/index.d.ts

@@ -0,0 +1,3 @@
+export { RestClient } from "./rest-client.js";
+export type { DooverClientConfig, RequestOptions } from "./rest-client.js";
+export { DooverApiError, DooverGatewayError, DooverValidationError } from "./errors.js";

package/dist/http/index.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DooverValidationError = exports.DooverGatewayError = exports.DooverApiError = exports.RestClient = void 0;
+var rest_client_js_1 = require("./rest-client.js");
+Object.defineProperty(exports, "RestClient", { enumerable: true, get: function () { return rest_client_js_1.RestClient; } });
+var errors_js_1 = require("./errors.js");
+Object.defineProperty(exports, "DooverApiError", { enumerable: true, get: function () { return errors_js_1.DooverApiError; } });
+Object.defineProperty(exports, "DooverGatewayError", { enumerable: true, get: function () { return errors_js_1.DooverGatewayError; } });
+Object.defineProperty(exports, "DooverValidationError", { enumerable: true, get: function () { return errors_js_1.DooverValidationError; } });

package/dist/http/rest-client.d.ts

@@ -1,7 +1,9 @@
-import type { AuthConfig } from "../auth/build-auth";
-import type { DooverAuth } from "../auth/doover-auth";
-import type { DooverStatsCollector } from "../client/stats";
+import type { NetworkStatusSource } from "../client/network-status.js";
+import type { AuthConfig } from "../auth/build-auth.js";
+import type { DooverAuth } from "../auth/doover-auth.js";
+import type { DooverStatsCollector } from "../client/stats.js";
 export interface DooverClientConfig extends AuthConfig {
+    networkStatus?: NetworkStatusSource;
     dataRestUrl: string;
     controlApiUrl: string;
     dataWssUrl: string;

package/dist/http/rest-client.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RestClient = void 0;
-const errors_1 = require("./errors");
+const errors_js_1 = require("./errors.js");
 class RestClient {
     constructor(config, auth) {
         this.stats = null;
@@ -44,7 +44,7 @@ class RestClient {
             }
         }
         if (!response.ok) {
-            throw new errors_1.DooverApiError({
+            throw new errors_js_1.DooverApiError({
                 status: response.status,
                 body: payload,
                 url: request.url,