doover-js 0.1.0

package/dist/test/rest-client.test.js

@@ -0,0 +1,115 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const chai_1 = require("chai");
+const chai_as_promised_1 = __importDefault(require("chai-as-promised"));
+const mocha_1 = require("mocha");
+const rest_client_1 = require("../http/rest-client");
+const helpers_1 = require("./helpers");
+(0, chai_1.use)(chai_as_promised_1.default);
+(0, mocha_1.describe)("RestClient", () => {
+    (0, mocha_1.beforeEach)(() => {
+        (0, helpers_1.installSessionStorageMock)();
+    });
+    (0, mocha_1.it)("adds query params and compatibility headers", async () => {
+        sessionStorage.setItem("impersonate_user_id", "user-2");
+        const fetchMock = (0, helpers_1.createFetchMock)();
+        const client = new rest_client_1.RestClient({
+            dataRestUrl: "https://api.example.com",
+            controlApiUrl: "https://control.example.com",
+            dataWssUrl: "wss://ws.example.com",
+            organisationId: "org-1",
+            fetchImpl: fetchMock,
+        });
+        await client.get("/items", { tag: ["a", "b"], enabled: true });
+        (0, chai_1.expect)(fetchMock.callCount).to.equal(1);
+        const [url, init] = fetchMock.getCall(0).args;
+        (0, chai_1.expect)(url).to.equal("https://api.example.com/items?tag=a&tag=b&enabled=true");
+        (0, chai_1.expect)(init?.credentials).to.equal("include");
+        const headers = init?.headers;
+        (0, chai_1.expect)(headers.get("X-Doover-Sharing")).to.equal("internal");
+        (0, chai_1.expect)(headers.get("X-Doover-Organisation")).to.equal("org-1");
+        (0, chai_1.expect)(headers.get("X-Doover-Assume")).to.equal("user-2");
+    });
+    (0, mocha_1.it)("serializes JSON request bodies", async () => {
+        const fetchMock = (0, helpers_1.createFetchMock)();
+        const client = new rest_client_1.RestClient({
+            dataRestUrl: "https://api.example.com",
+            controlApiUrl: "https://control.example.com",
+            dataWssUrl: "wss://ws.example.com",
+            fetchImpl: fetchMock,
+        });
+        await client.post("/items", { name: "alpha" });
+        const [, init] = fetchMock.getCall(0).args;
+        (0, chai_1.expect)(init?.method).to.equal("POST");
+        (0, chai_1.expect)(init?.body).to.equal(JSON.stringify({ name: "alpha" }));
+        const headers = init?.headers;
+        (0, chai_1.expect)(headers.get("Content-Type")).to.equal("application/json");
+    });
+    (0, mocha_1.it)("passes through FormData bodies without forcing JSON content type", async () => {
+        const fetchMock = (0, helpers_1.createFetchMock)();
+        const client = new rest_client_1.RestClient({
+            dataRestUrl: "https://api.example.com",
+            controlApiUrl: "https://control.example.com",
+            dataWssUrl: "wss://ws.example.com",
+            fetchImpl: fetchMock,
+        });
+        const formData = new FormData();
+        formData.set("a", "1");
+        await client.post("/upload", formData);
+        const [, init] = fetchMock.getCall(0).args;
+        (0, chai_1.expect)(init?.body).to.equal(formData);
+        const headers = init?.headers;
+        (0, chai_1.expect)(headers.get("Content-Type")).to.equal(null);
+    });
+    (0, mocha_1.it)("parses blob responses for attachments", async () => {
+        const fetchMock = (0, helpers_1.createFetchMock)(() => (0, helpers_1.createBlobResponse)("hello"));
+        const client = new rest_client_1.RestClient({
+            dataRestUrl: "https://api.example.com",
+            controlApiUrl: "https://control.example.com",
+            dataWssUrl: "wss://ws.example.com",
+            fetchImpl: fetchMock,
+        });
+        const blob = await client.get("/blob");
+        (0, chai_1.expect)(blob).to.be.instanceOf(Blob);
+        (0, chai_1.expect)(await blob.text()).to.equal("hello");
+    });
+    (0, mocha_1.it)("returns undefined for empty 204 responses", async () => {
+        const fetchMock = (0, helpers_1.createFetchMock)(() => new Response(null, { status: 204 }));
+        const client = new rest_client_1.RestClient({
+            dataRestUrl: "https://api.example.com",
+            controlApiUrl: "https://control.example.com",
+            dataWssUrl: "wss://ws.example.com",
+            fetchImpl: fetchMock,
+        });
+        await (0, chai_1.expect)(client.delete("/items/1")).to.eventually.equal(undefined);
+    });
+    (0, mocha_1.it)("throws a DooverApiError on non-2xx responses", async () => {
+        const fetchMock = (0, helpers_1.createFetchMock)(() => (0, helpers_1.createJsonResponse)({ message: "bad request" }, { status: 400 }));
+        const client = new rest_client_1.RestClient({
+            dataRestUrl: "https://api.example.com",
+            controlApiUrl: "https://control.example.com",
+            dataWssUrl: "wss://ws.example.com",
+            fetchImpl: fetchMock,
+        });
+        await (0, chai_1.expect)(client.get("/broken")).to.be.rejected.then((error) => {
+            (0, chai_1.expect)(error.name).to.equal("DooverApiError");
+            (0, chai_1.expect)(error.status).to.equal(400);
+            (0, chai_1.expect)(error.message).to.equal("bad request");
+            (0, chai_1.expect)(error.url).to.equal("https://api.example.com/broken");
+            (0, chai_1.expect)(error.method).to.equal("GET");
+        });
+    });
+    (0, mocha_1.it)("returns text bodies when the response is not JSON", async () => {
+        const fetchMock = (0, helpers_1.createFetchMock)(() => (0, helpers_1.createTextResponse)("plain text"));
+        const client = new rest_client_1.RestClient({
+            dataRestUrl: "https://api.example.com",
+            controlApiUrl: "https://control.example.com",
+            dataWssUrl: "wss://ws.example.com",
+            fetchImpl: fetchMock,
+        });
+        await (0, chai_1.expect)(client.get("/text")).to.eventually.equal("plain text");
+    });
+});

package/dist/test/utils.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/test/utils.test.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const chai_1 = require("chai");
+const mocha_1 = require("mocha");
+const snowflake_1 = require("../utils/snowflake");
+const path_parsing_1 = require("../viewer/path-parsing");
+(0, mocha_1.describe)("snowflake utilities", () => {
+    (0, mocha_1.it)("generates and extracts timestamps consistently", () => {
+        const date = new Date("2026-01-02T03:04:05.000Z");
+        const id = (0, snowflake_1.generateSnowflakeIdAtTime)(date);
+        const extracted = (0, snowflake_1.extractSnowflakeId)(id);
+        (0, chai_1.expect)(extracted.timestamp).to.equal(date.getTime());
+        (0, chai_1.expect)(id).to.match(/^\d+$/);
+    });
+    (0, mocha_1.it)("adds a second-based timestamp to messages", () => {
+        const date = new Date("2026-01-02T03:04:05.000Z");
+        const id = (0, snowflake_1.generateSnowflakeIdAtTime)(date);
+        const message = (0, snowflake_1.addTimestampToMessage)({
+            id,
+            author_id: "user",
+            channel: { agent_id: "agent", name: "channel" },
+            data: {},
+            attachments: [],
+        });
+        (0, chai_1.expect)(message.timestamp).to.equal(date.getTime() / 1000);
+    });
+});
+(0, mocha_1.describe)("path parsing", () => {
+    (0, mocha_1.it)("parses agent-only paths", () => {
+        (0, chai_1.expect)((0, path_parsing_1.getIdentifierFromPath)("agent-1", new URLSearchParams())).to.deep.equal({
+            identifier: {
+                agentId: "agent-1",
+                channelName: undefined,
+            },
+        });
+    });
+    (0, mocha_1.it)("parses channel paths with aggregate tails", () => {
+        (0, chai_1.expect)((0, path_parsing_1.getIdentifierFromPath)("/agent-1/channel-1/path/to/value", new URLSearchParams())).to.deep.equal({
+            identifier: {
+                agentId: "agent-1",
+                channelName: "channel-1",
+            },
+            aggregatePath: "path/to/value",
+        });
+    });
+    (0, mocha_1.it)("returns an empty identifier for an empty path", () => {
+        (0, chai_1.expect)((0, path_parsing_1.getIdentifierFromPath)("/", new URLSearchParams())).to.deep.equal({
+            identifier: {
+                agentId: undefined,
+                channelName: undefined,
+            },
+        });
+    });
+});

package/dist/types/common.d.ts

@@ -0,0 +1,130 @@
+export type JSONPrimitive = null | boolean | number | string;
+export type JSONValue = JSONPrimitive | JSONValue[] | {
+    [key: string]: JSONValue;
+};
+export interface Attachment {
+    url: string;
+    content_type: string | null;
+    filename: string;
+    size: number;
+}
+export interface ChannelRef {
+    agent_id: string;
+    name: string;
+}
+export interface Aggregate<TData = Record<string, JSONValue>> {
+    data: TData;
+    attachments: Attachment[];
+    last_updated?: number | null;
+}
+export interface MessageAttachment extends Attachment {
+}
+export interface MessageStructure<TData = JSONValue> {
+    data: TData;
+    attachments: MessageAttachment[];
+    id: string;
+    author_id: string;
+    channel: ChannelRef;
+    timestamp: number;
+    record_log?: boolean;
+}
+export interface Channel<TAgg = Record<string, JSONValue>> {
+    aggregate?: Aggregate<TAgg>;
+    is_private: boolean;
+    id?: string;
+    name: string;
+    owner_id: string;
+    alarms_enabled?: boolean;
+    aggregate_schema?: Record<string, JSONValue> | null;
+    message_schema?: Record<string, JSONValue> | null;
+    daily_message_summaries?: unknown[];
+    alarms?: Alarm[];
+}
+export interface Alarm {
+    id: string;
+    name: string;
+    description: string;
+    enabled: boolean;
+    key: string;
+    operator: AlarmOperator;
+    value: JSONValue;
+    state: AlarmState;
+    expiry_mins: number | null;
+    entered_state_ts: number;
+}
+export type AlarmOperator = "eq" | "ge" | "gt" | "le" | "lt";
+export type AlarmState = "NoData" | "OK" | "Alarm";
+export interface ConnectionSubscription {
+    channel: ChannelRef;
+    subscribed_at: number;
+    connection_id: string;
+}
+export interface ConnectionSubscriptionLog {
+    channel: ChannelRef;
+    subscribed_at?: number | null;
+    unsubscribed_at?: number | null;
+    connection_id: string;
+}
+export interface ConnectionDetails {
+    address: string;
+    agent_id: string;
+    default_session: boolean;
+    session_id: string;
+    last_ping?: number | null;
+    latency?: number | null;
+    status: number;
+    subscriptions: ConnectionSubscription[];
+}
+export interface NotificationSubscriptionEndpoint {
+    id: string;
+    name: string;
+    default: boolean;
+}
+export interface NotificationSubscription {
+    id: string;
+    subscriber: string;
+    subscribed_to: string;
+    severity: number;
+    topic_filter: string[];
+    endpoints: NotificationSubscriptionEndpoint[];
+}
+export interface NotificationEndpoint {
+    id: string;
+    agent_id: string;
+    type: number;
+    priority: number | null;
+    extra_data: Record<string, JSONValue>;
+    name: string;
+    default: boolean;
+}
+export interface ResourcePermission {
+    permission_id: string;
+    permission: string;
+}
+export interface AgentPermission {
+    agent_id: string;
+    is_superuser: boolean;
+    resources: ResourcePermission[];
+    last_updated?: number | null;
+}
+export interface TurnCredential {
+    username: string;
+    credential: string;
+    ttl: number;
+    expires_at: number;
+    uris: string[];
+}
+export interface AgentAggregate<TData = Record<string, JSONValue>> {
+    agent_id: string;
+    data: TData;
+    attachments: Attachment[];
+    last_updated?: number | null;
+}
+export interface DataSeriesResult {
+    value: JSONValue;
+    message_id: string;
+}
+export interface DataSeries {
+    count: number;
+    results: DataSeriesResult[];
+}

package/dist/types/common.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/openapi.d.ts

@@ -0,0 +1,144 @@
+import type { AgentAggregate, AgentPermission, Alarm, Aggregate, Channel, ConnectionDetails, ConnectionSubscription, ConnectionSubscriptionLog, DataSeries, MessageStructure, NotificationEndpoint, NotificationSubscription, ResourcePermission, TurnCredential } from "./common";
+export type { AgentAggregate, AgentPermission, Alarm, Aggregate, Channel, ConnectionDetails, ConnectionSubscription, ConnectionSubscriptionLog, DataSeries, MessageStructure, NotificationEndpoint, NotificationSubscription, ResourcePermission, TurnCredential, };
+export interface BatchMessagesResponse {
+    results: MessageStructure[];
+    count: number;
+    next?: string;
+}
+export interface BatchAggregatesResponse {
+    results: AgentAggregate[];
+    count: number;
+}
+export interface NotificationDataResponse {
+    subscriptions: NotificationSubscription[];
+    subscribers: NotificationSubscription[];
+    endpoints: NotificationEndpoint[];
+}
+export interface NotificationEndpointsResponse {
+    endpoints: NotificationEndpoint[];
+}
+export interface NotificationSubscriptionsResponse {
+    subscriptions: NotificationSubscription[];
+}
+export interface NotificationSubscribersResponse {
+    subscribers: NotificationSubscription[];
+}
+export interface NotificationSubscriptionCreateResponse {
+    subscriptions: Array<{
+        id: string;
+        endpoint_id: string;
+    }>;
+}
+export interface PermissionDebugResponse {
+    cache?: AgentPermission | null;
+    db: AgentPermission;
+}
+export interface ScheduleInfo {
+    [key: string]: unknown;
+}
+export interface ProcessorSubscriptionInfo {
+    [key: string]: unknown;
+}
+export interface IngestionEndpointInfo {
+    [key: string]: unknown;
+}
+export interface SubscriptionInfo {
+    agent_id: string;
+    organisation_id: string;
+    app_key: string;
+    deployment_config: Record<string, unknown>;
+    ui_state: Record<string, unknown>;
+    ui_cmds: Record<string, unknown>;
+    tag_values: Record<string, unknown>;
+    connection_data: Record<string, unknown>;
+    token: string;
+}
+export interface SuccessListResponse<T = string> {
+    success: T[];
+}
+export interface CreateChannelRequest {
+    is_private?: boolean;
+    message_schema?: Record<string, unknown> | null;
+    aggregate_schema?: Record<string, unknown> | null;
+}
+export interface PutChannelRequest extends CreateChannelRequest {
+    is_private: boolean;
+}
+export interface CreateMessageRequest {
+    data: Record<string, unknown>;
+    ts?: number;
+}
+export interface UpdateMessageRequest {
+    data: Record<string, unknown>;
+}
+export interface CreateAlarmRequest {
+    name: string;
+    description?: string;
+    enabled?: boolean;
+    key: string;
+    operator: Alarm["operator"];
+    value: unknown;
+    expiry_mins?: number | null;
+}
+export interface PatchAlarmRequest extends Partial<CreateAlarmRequest> {
+}
+export interface CreateEndpointRequest {
+    name: string;
+    priority?: number | null;
+    type: number;
+    extra_data: Record<string, unknown>;
+    default: boolean;
+}
+export interface UpdateEndpointRequest {
+    extra_data?: Record<string, unknown> | null;
+    priority?: number | null;
+    name?: string;
+}
+export interface CreateNotificationSubscriptionRequest {
+    subscribe_to: string;
+    endpoint_id?: string | null;
+    severity: number;
+    topic_filter: string[];
+}
+export interface UpdateNotificationSubscriptionRequest {
+    severity?: number;
+    topic_filter?: string[];
+}
+export interface UpdateMeWebPushEndpointRequest {
+    old_endpoint: string;
+    endpoint: string;
+    key_p256dh: string;
+    key_auth: string;
+    expires_at: number;
+}
+export interface SyncPermissionRequest {
+    agent_permissions: AgentPermission[];
+}
+export interface PutScheduleRequest {
+    app_key: string;
+    is_org?: boolean | null;
+    permissions: ResourcePermission[];
+}
+export interface PutSubscriptionRequest {
+    subscription_arn: string;
+    app_key: string;
+    is_org?: boolean | null;
+    permissions: ResourcePermission[];
+}
+export interface CreateIngestionRequest {
+    lambda_arn: string;
+    cidr_ranges: string[];
+    signing_key?: string | null;
+    signing_key_hash_header?: string | null;
+    throttle_limit: number;
+    never_replace_token?: boolean;
+    mini_token?: boolean;
+    is_org?: boolean | null;
+    app_key: string;
+    permissions: ResourcePermission[];
+}
+export interface TurnTokenRequest {
+    role: "client" | "device";
+    device_id?: string;
+    camera_name: string;
+}

package/dist/types/openapi.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/viewer.d.ts

@@ -0,0 +1,70 @@
+import type { Aggregate, Channel, ConnectionDetails, MessageStructure } from "./common";
+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";
+    fixed_location: {
+        latitude: number;
+        longitude: number;
+    };
+    extra_config: Record<string, unknown>;
+    connection_determination?: "Online" | "Offline";
+}
+export interface User {
+    id: string;
+    email?: string;
+    name?: string;
+    [key: string]: unknown;
+}
+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: () => 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/types/viewer.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/utils/snowflake.d.ts

@@ -0,0 +1,13 @@
+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/utils/snowflake.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateSnowflakeIdAtTime = generateSnowflakeIdAtTime;
+exports.extractSnowflakeId = extractSnowflakeId;
+exports.addTimestampToMessage = addTimestampToMessage;
+function generateSnowflakeIdAtTime(time) {
+    const offset = 1735689600000;
+    const bigTime = BigInt(time.valueOf() - offset);
+    const bigId = bigTime << 22n;
+    return bigId.toString();
+}
+function extractSnowflakeId(id) {
+    const offset = 1735689600000n;
+    return {
+        timestamp: Number((BigInt(id) >> 22n) + offset),
+        machineId: Number((BigInt(id) >> 12n) & 1023n),
+        sequence: Number(BigInt(id) & 4095n),
+    };
+}
+function addTimestampToMessage(message) {
+    const extracted = extractSnowflakeId(message.id);
+    return {
+        ...message,
+        timestamp: extracted.timestamp / 1000,
+    };
+}

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

@@ -0,0 +1,55 @@
+import { AgentsApi } from "../apis/agents-api";
+import { AggregatesApi } from "../apis/aggregates-api";
+import { ChannelsApi } from "../apis/channels-api";
+import { ConnectionsApi } from "../apis/connections-api";
+import { MessagesApi } from "../apis/messages-api";
+import { GatewayClient } from "../gateway/gateway-client";
+import { RestClient, type DooverClientConfig } from "../http/rest-client";
+import type { Aggregate, Channel, ConnectionDetails, MessageStructure } from "../types/common";
+import type { Agent, AgentsResponse, ChannelIdentifier, ChannelsDataProvider, SubscriptionDetails, User } from "../types/viewer";
+interface SubscriptionEntry {
+    messageCallback: (identifier: ChannelIdentifier, message: MessageStructure) => void;
+    aggregateCallback: (identifier: ChannelIdentifier, aggregate: Aggregate) => void;
+}
+export declare class DooverDataProvider implements ChannelsDataProvider<ChannelIdentifier> {
+    private readonly config;
+    readonly rest: RestClient;
+    readonly gateway: GatewayClient;
+    readonly agentsApi: AgentsApi;
+    readonly channelsApi: ChannelsApi;
+    readonly messagesApi: MessagesApi;
+    readonly aggregatesApi: AggregatesApi;
+    readonly connectionsApi: ConnectionsApi;
+    private readonly subscriptions;
+    constructor(config: DooverClientConfig);
+    getMe(): Promise<User>;
+    getAgents(): Promise<AgentsResponse>;
+    getChannels(identifier: ChannelIdentifier, options?: {
+        includeArchived?: boolean;
+    }): Promise<Channel[] | undefined>;
+    createChannel(identifier: ChannelIdentifier, channelName: string, options?: {
+        is_private?: boolean;
+    }): Promise<unknown>;
+    archiveChannel(identifier: ChannelIdentifier): Promise<unknown>;
+    unarchiveChannel(identifier: ChannelIdentifier): Promise<unknown>;
+    getChannel(identifier: ChannelIdentifier): Promise<Channel | undefined>;
+    subscribeToChannel(identifier: ChannelIdentifier, callback: SubscriptionEntry["messageCallback"], aggregateCallback: SubscriptionEntry["aggregateCallback"]): Promise<void>;
+    unsubscribeFromChannel(identifier: ChannelIdentifier, callback: SubscriptionEntry["messageCallback"]): Promise<void>;
+    getAggregate(identifier: ChannelIdentifier): Promise<Aggregate | undefined>;
+    getMessages(identifier: ChannelIdentifier, beforeId?: string): Promise<MessageStructure[] | undefined>;
+    deleteMessage(identifier: ChannelIdentifier, messageId: string): Promise<unknown>;
+    sendMessage(identifier: ChannelIdentifier, message: object): Promise<MessageStructure>;
+    updateAggregate(identifier: ChannelIdentifier, message: object): Promise<Aggregate>;
+    putAggregate(identifier: ChannelIdentifier, message: object): Promise<Aggregate>;
+    getChannelSubscriptions(identifier: ChannelIdentifier): Promise<SubscriptionDetails[]>;
+    getAgentConnections(identifier: ChannelIdentifier): Promise<ConnectionDetails[]>;
+    getIdentifierFromPath(path: string, searchParams: URLSearchParams): {
+        identifier: ChannelIdentifier;
+        aggregatePath?: string;
+    };
+    getAgentInfo(agentId: string): Promise<Agent | undefined>;
+    private requireChannel;
+    private channelKey;
+    private toIdentifier;
+}
+export {};