doover-js 0.4.8 → 0.5.0-alpha.0

package/README.md

@@ -127,3 +127,34 @@ Reconnections automatically use the latest (potentially refreshed) token.
 `DooverClient` builds one shared `DooverAuth` instance and injects it into `RestClient`, `DooverDataProvider`, and `GatewayClient`. Token refreshes propagate everywhere automatically.
 
 `DooverDataProvider` preserves the older viewer-oriented interface. `DooverClient` exposes the broader API surface through subclients.
+
+## Migrating to 0.6.0
+
+`DooverDataProvider` (`client.viewer`) is deprecated in 0.5.0 and removed in 0.6.0. The replacements are subclients on `DooverClient`:
+
+| Viewer method | Replacement |
+|---|---|
+| `client.viewer.getMe()` | `client.users.getMe()` |
+| `client.viewer.getAgents(opts)` | `client.agents.listAgents(opts)` |
+| `client.viewer.getChannels(id, opts)` | `client.channels.listChannels(id, opts)` |
+| `client.viewer.getChannel(id)` | `client.channels.getChannel(id)` |
+| `client.viewer.createChannel(id, name, opts)` | `client.channels.putChannel(id, name, body)` |
+| `client.viewer.archiveChannel(id)` | `client.channels.archiveChannel(id)` |
+| `client.viewer.unarchiveChannel(id)` | `client.channels.unarchiveChannel(id)` |
+| `client.viewer.subscribeToChannel(id, msg, agg, upd?)` | `client.gateway.subscribeToChannel(channel, { onMessage, onAggregate, onMessageUpdate })` — returns an unsubscribe fn |
+| `client.viewer.unsubscribeFromChannel(id, cb)` | call the unsubscribe fn returned by `subscribeToChannel` |
+| `client.viewer.getAggregate(id)` | `const ch = await client.channels.getChannel(id); ch.aggregate ?? client.aggregates.getAggregate(id)` |
+| `client.viewer.updateAggregate(id, data, params)` | `client.aggregates.patchAggregate(id, data, params)` |
+| `client.viewer.putAggregate(id, data, params)` | `client.aggregates.putAggregate(id, data, params)` |
+| `client.viewer.getMessages(id, opts)` | `client.messages.listMessages(id, { ...opts, order: "asc" })` (omit `order` for raw newest-first server order) |
+| `client.viewer.deleteMessage(id, msgId)` | `client.messages.deleteMessage(id, msgId)` |
+| `client.viewer.sendMessage(id, data)` | `client.messages.postMessage(id, { data })` |
+| `client.viewer.sendRPC(id, req, opts)` | `client.rpc.send(id, req, opts)` |
+| `client.viewer.getChannelSubscriptions(id)` | `client.connections.getChannelSubscriptions(id)` |
+| `client.viewer.getAgentConnections(id)` | `client.connections.getAgentConnections(id)` |
+| `client.viewer.getIdentifierFromPath(p, s)` | `getIdentifierFromPath(p, s)` (free function — already exported) |
+| `client.viewer.getAgentInfo(id)` | **dropped, no replacement** — was a synthesized stub with no network call |
+
+`*Api` resource methods accept either positional arguments or a `ChannelIdentifier` / `{ agentId }` object on every call form.
+
+`client.rpc.send` adds optional `signal: AbortSignal` and `timeoutMs: number` and rejects with `DooverRpcError` (with `.status` and `.request`) instead of the bare status string.

package/dist/apis/_args.d.ts

@@ -0,0 +1,16 @@
+export interface ChannelIdentifierLike {
+    agentId: string;
+    channelName: string;
+}
+export interface AgentIdentifierLike {
+    agentId: string;
+}
+export declare function resolveChannelArgs<TOptions>(args: unknown[]): {
+    agentId: string;
+    channelName: string;
+    options?: TOptions;
+};
+export declare function resolveAgentArgs<TOptions>(args: unknown[]): {
+    agentId: string;
+    options?: TOptions;
+};

package/dist/apis/_args.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveChannelArgs = resolveChannelArgs;
+exports.resolveAgentArgs = resolveAgentArgs;
+function resolveChannelArgs(args) {
+    if (typeof args[0] === "string") {
+        return {
+            agentId: args[0],
+            channelName: args[1],
+            options: args[2],
+        };
+    }
+    const id = args[0];
+    return {
+        agentId: id.agentId,
+        channelName: id.channelName,
+        options: args[1],
+    };
+}
+function resolveAgentArgs(args) {
+    if (typeof args[0] === "string") {
+        return { agentId: args[0], options: args[1] };
+    }
+    const id = args[0];
+    return { agentId: id.agentId, options: args[1] };
+}

package/dist/apis/agents-api.d.ts

@@ -1,4 +1,5 @@
 import type { AgentAggregate, BatchMessagesResponse } from "../types/openapi";
+import type { AgentsResponse, GetAgentsOptions } from "../types/viewer";
 import type { RestClient } from "../http/rest-client";
 export interface MultiAgentMessagesParams {
     agent_id: string[];
@@ -13,7 +14,9 @@ export interface MultiAgentAggregatesParams {
 }
 export declare class AgentsApi {
     private readonly rest;
-    constructor(rest: RestClient);
+    private readonly controlApiUrl?;
+    constructor(rest: RestClient, controlApiUrl?: string | undefined);
+    listAgents(options?: GetAgentsOptions): Promise<AgentsResponse>;
     getMultiAgentMessages(channelName: string, params: MultiAgentMessagesParams): Promise<BatchMessagesResponse>;
     getMultiAgentAggregates(channelName: string, params: MultiAgentAggregatesParams): Promise<{
         results: AgentAggregate[];

package/dist/apis/agents-api.js

@@ -2,9 +2,147 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AgentsApi = void 0;
 const snowflake_1 = require("../utils/snowflake");
+function isPlainObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function buildUserDisplayName(rawUser) {
+    const source = isPlainObject(rawUser)
+        ? rawUser
+        : {};
+    const firstName = typeof source.first_name === "string" ? source.first_name.trim() : "";
+    const lastName = typeof source.last_name === "string" ? source.last_name.trim() : "";
+    const fullName = `${firstName} ${lastName}`.trim();
+    if (fullName !== "") {
+        return fullName;
+    }
+    if (typeof source.username === "string" && source.username !== "") {
+        return source.username;
+    }
+    if (typeof source.email === "string" && source.email !== "") {
+        return source.email;
+    }
+    if (typeof source.id === "string" && source.id !== "") {
+        return source.id;
+    }
+    return String(source.id ?? "");
+}
+function coerceExtraConfig(value) {
+    return isPlainObject(value) ? value : {};
+}
+function normalizeAgentEntry(rawAgent) {
+    const source = isPlainObject(rawAgent)
+        ? rawAgent
+        : {};
+    const fixedLocation = source.fixed_location;
+    const normalizedFixedLocation = isPlainObject(fixedLocation) &&
+        typeof fixedLocation.latitude === "number" &&
+        typeof fixedLocation.longitude === "number"
+        ? {
+            latitude: fixedLocation.latitude,
+            longitude: fixedLocation.longitude,
+        }
+        : { latitude: 0, longitude: 0 };
+    const faIcon = typeof source.fa_icon === "string" && source.fa_icon.length > 0
+        ? source.fa_icon
+        : "fa-solid fa-robot";
+    return {
+        ...source,
+        id: typeof source.id === "string" ? source.id : String(source.id ?? ""),
+        organisation: typeof source.organisation === "string" ? source.organisation : "",
+        name: typeof source.name === "string" ? source.name : "",
+        display_name: typeof source.display_name === "string" ? source.display_name : "",
+        archived: typeof source.archived === "boolean" ? source.archived : false,
+        group: typeof source.group === "string" ? source.group : "",
+        fa_icon: faIcon,
+        type: source.type === "device" ||
+            source.type === "dashboard" ||
+            source.type === "organisation" ||
+            source.type === "user"
+            ? source.type
+            : "device",
+        fixed_location: normalizedFixedLocation,
+        extra_config: coerceExtraConfig(source.extra_config),
+    };
+}
+function normalizeOrganisationEntry(rawOrganisation) {
+    const source = isPlainObject(rawOrganisation)
+        ? rawOrganisation
+        : {};
+    const name = typeof source.name === "string" ? source.name : "";
+    const rootGroup = isPlainObject(source.root_group) ? source.root_group : null;
+    const groupName = rootGroup && typeof rootGroup.name === "string" ? rootGroup.name : "";
+    return {
+        id: typeof source.id === "string" ? source.id : String(source.id ?? ""),
+        organisation: name,
+        name,
+        display_name: name,
+        archived: typeof source.archived === "boolean" ? source.archived : false,
+        group: groupName,
+        fa_icon: "fa-solid fa-building",
+        type: "organisation",
+        fixed_location: { latitude: 0, longitude: 0 },
+        extra_config: coerceExtraConfig(source.extra_config),
+    };
+}
+function normalizeUserEntry(rawUser) {
+    const source = isPlainObject(rawUser)
+        ? rawUser
+        : {};
+    const id = typeof source.id === "string" ? source.id : String(source.id ?? "");
+    const username = typeof source.username === "string" ? source.username : "";
+    const email = typeof source.email === "string" ? source.email : "";
+    const name = username !== "" ? username : email !== "" ? email : id;
+    return {
+        id,
+        organisation: "",
+        name,
+        display_name: buildUserDisplayName(source),
+        archived: false,
+        group: "",
+        fa_icon: "fa-solid fa-user",
+        type: "user",
+        fixed_location: { latitude: 0, longitude: 0 },
+        extra_config: coerceExtraConfig(source.custom_data),
+    };
+}
 class AgentsApi {
-    constructor(rest) {
+    constructor(rest, controlApiUrl) {
         this.rest = rest;
+        this.controlApiUrl = controlApiUrl;
+    }
+    async listAgents(options) {
+        const query = {};
+        if (options?.includeArchived)
+            query["include-archived"] = true;
+        if (options?.includeOrganisations)
+            query["include-organisations"] = true;
+        if (options?.includeUsers)
+            query["include-users"] = true;
+        const raw = await this.rest.request({
+            path: "/agents/",
+            baseUrl: this.controlApiUrl,
+            omitSharingHeader: true,
+            query: Object.keys(query).length > 0 ? query : undefined,
+        });
+        const rawAgents = Array.isArray(raw.agents) ? raw.agents : [];
+        const normalizedAgents = rawAgents.map(normalizeAgentEntry);
+        if (!options?.mergeIncludedAsAgents) {
+            return { ...raw, agents: normalizedAgents };
+        }
+        const merged = [...normalizedAgents];
+        if (options.includeOrganisations) {
+            const rawOrgs = Array.isArray(raw.organisations)
+                ? raw.organisations
+                : [];
+            for (const org of rawOrgs)
+                merged.push(normalizeOrganisationEntry(org));
+        }
+        if (options.includeUsers) {
+            const rawUsers = Array.isArray(raw.users) ? raw.users : [];
+            for (const user of rawUsers)
+                merged.push(normalizeUserEntry(user));
+        }
+        return { ...raw, agents: merged, results: merged, count: merged.length };
     }
     async getMultiAgentMessages(channelName, params) {
         const response = await this.rest.get(`/agents/channels/${channelName}/messages`, params);

package/dist/apis/aggregates-api.d.ts

@@ -8,8 +8,28 @@ export interface AggregateMutationParams {
 export declare class AggregatesApi {
     private readonly rest;
     constructor(rest: RestClient);
-    getAggregate(agentId: string, channelName: string): Promise<Aggregate<Record<string, import("..").JSONValue>>>;
-    putAggregate(agentId: string, channelName: string, body: Record<string, unknown> | FormData, params?: AggregateMutationParams): Promise<Aggregate<Record<string, import("..").JSONValue>>>;
-    patchAggregate(agentId: string, channelName: string, body: Record<string, unknown> | FormData, params?: AggregateMutationParams): Promise<Aggregate<Record<string, import("..").JSONValue>>>;
+    getAggregate(agentId: string, channelName: string): Promise<Aggregate>;
+    getAggregate(identifier: {
+        agentId: string;
+        channelName: string;
+    }): Promise<Aggregate>;
+    private _getAggregate;
+    putAggregate(agentId: string, channelName: string, body: Record<string, unknown> | FormData, params?: AggregateMutationParams): Promise<Aggregate>;
+    putAggregate(identifier: {
+        agentId: string;
+        channelName: string;
+    }, body: Record<string, unknown> | FormData, params?: AggregateMutationParams): Promise<Aggregate>;
+    private _putAggregate;
+    patchAggregate(agentId: string, channelName: string, body: Record<string, unknown> | FormData, params?: AggregateMutationParams): Promise<Aggregate>;
+    patchAggregate(identifier: {
+        agentId: string;
+        channelName: string;
+    }, body: Record<string, unknown> | FormData, params?: AggregateMutationParams): Promise<Aggregate>;
+    private _patchAggregate;
     getAggregateAttachment(agentId: string, channelName: string, attachmentId: string): Promise<Blob>;
+    getAggregateAttachment(identifier: {
+        agentId: string;
+        channelName: string;
+    }, attachmentId: string): Promise<Blob>;
+    private _getAggregateAttachment;
 }

package/dist/apis/aggregates-api.js

@@ -1,20 +1,49 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AggregatesApi = void 0;
+const _args_1 = require("./_args");
 class AggregatesApi {
     constructor(rest) {
         this.rest = rest;
     }
-    getAggregate(agentId, channelName) {
+    getAggregate(...args) {
+        const { agentId, channelName } = (0, _args_1.resolveChannelArgs)(args);
+        return this._getAggregate(agentId, channelName);
+    }
+    _getAggregate(agentId, channelName) {
         return this.rest.get(`/agents/${agentId}/channels/${channelName}/aggregate`);
     }
-    putAggregate(agentId, channelName, body, params) {
+    putAggregate(...args) {
+        if (typeof args[0] === "string") {
+            const [agentId, channelName, body, params] = args;
+            return this._putAggregate(agentId, channelName, body, params);
+        }
+        const id = args[0];
+        return this._putAggregate(id.agentId, id.channelName, args[1], args[2]);
+    }
+    _putAggregate(agentId, channelName, body, params) {
         return this.rest.put(`/agents/${agentId}/channels/${channelName}/aggregate`, body, params);
     }
-    patchAggregate(agentId, channelName, body, params) {
+    patchAggregate(...args) {
+        if (typeof args[0] === "string") {
+            const [agentId, channelName, body, params] = args;
+            return this._patchAggregate(agentId, channelName, body, params);
+        }
+        const id = args[0];
+        return this._patchAggregate(id.agentId, id.channelName, args[1], args[2]);
+    }
+    _patchAggregate(agentId, channelName, body, params) {
         return this.rest.patch(`/agents/${agentId}/channels/${channelName}/aggregate`, body, params);
     }
-    getAggregateAttachment(agentId, channelName, attachmentId) {
+    getAggregateAttachment(...args) {
+        if (typeof args[0] === "string") {
+            const [agentId, channelName, attachmentId] = args;
+            return this._getAggregateAttachment(agentId, channelName, attachmentId);
+        }
+        const id = args[0];
+        return this._getAggregateAttachment(id.agentId, id.channelName, args[1]);
+    }
+    _getAggregateAttachment(agentId, channelName, attachmentId) {
         return this.rest.get(`/agents/${agentId}/channels/${channelName}/aggregate/attachments/${attachmentId}`);
     }
 }

package/dist/apis/alarms-api.d.ts

@@ -4,9 +4,39 @@ export declare class AlarmsApi {
     private readonly rest;
     constructor(rest: RestClient);
     listAlarms(agentId: string, channelName: string): Promise<Alarm[]>;
+    listAlarms(identifier: {
+        agentId: string;
+        channelName: string;
+    }): Promise<Alarm[]>;
+    private _listAlarms;
     createAlarm(agentId: string, channelName: string, body: CreateAlarmRequest): Promise<Alarm>;
+    createAlarm(identifier: {
+        agentId: string;
+        channelName: string;
+    }, body: CreateAlarmRequest): Promise<Alarm>;
+    private _createAlarm;
     getAlarm(agentId: string, channelName: string, alarmId: string): Promise<Alarm>;
+    getAlarm(identifier: {
+        agentId: string;
+        channelName: string;
+    }, alarmId: string): Promise<Alarm>;
+    private _getAlarm;
     putAlarm(agentId: string, channelName: string, alarmId: string, body: CreateAlarmRequest): Promise<Alarm>;
+    putAlarm(identifier: {
+        agentId: string;
+        channelName: string;
+    }, alarmId: string, body: CreateAlarmRequest): Promise<Alarm>;
+    private _putAlarm;
     patchAlarm(agentId: string, channelName: string, alarmId: string, body: PatchAlarmRequest): Promise<Alarm>;
+    patchAlarm(identifier: {
+        agentId: string;
+        channelName: string;
+    }, alarmId: string, body: PatchAlarmRequest): Promise<Alarm>;
+    private _patchAlarm;
     deleteAlarm(agentId: string, channelName: string, alarmId: string): Promise<unknown>;
+    deleteAlarm(identifier: {
+        agentId: string;
+        channelName: string;
+    }, alarmId: string): Promise<unknown>;
+    private _deleteAlarm;
 }

package/dist/apis/alarms-api.js

@@ -1,26 +1,71 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AlarmsApi = void 0;
+const _args_1 = require("./_args");
 class AlarmsApi {
     constructor(rest) {
         this.rest = rest;
     }
-    listAlarms(agentId, channelName) {
+    listAlarms(...args) {
+        const { agentId, channelName } = (0, _args_1.resolveChannelArgs)(args);
+        return this._listAlarms(agentId, channelName);
+    }
+    _listAlarms(agentId, channelName) {
         return this.rest.get(`/agents/${agentId}/channels/${channelName}/alarms`);
     }
-    createAlarm(agentId, channelName, body) {
+    createAlarm(...args) {
+        if (typeof args[0] === "string") {
+            const [agentId, channelName, body] = args;
+            return this._createAlarm(agentId, channelName, body);
+        }
+        const id = args[0];
+        return this._createAlarm(id.agentId, id.channelName, args[1]);
+    }
+    _createAlarm(agentId, channelName, body) {
         return this.rest.post(`/agents/${agentId}/channels/${channelName}/alarms`, body);
     }
-    getAlarm(agentId, channelName, alarmId) {
+    getAlarm(...args) {
+        if (typeof args[0] === "string") {
+            const [agentId, channelName, alarmId] = args;
+            return this._getAlarm(agentId, channelName, alarmId);
+        }
+        const id = args[0];
+        return this._getAlarm(id.agentId, id.channelName, args[1]);
+    }
+    _getAlarm(agentId, channelName, alarmId) {
         return this.rest.get(`/agents/${agentId}/channels/${channelName}/alarms/${alarmId}`);
     }
-    putAlarm(agentId, channelName, alarmId, body) {
+    putAlarm(...args) {
+        if (typeof args[0] === "string") {
+            const [agentId, channelName, alarmId, body] = args;
+            return this._putAlarm(agentId, channelName, alarmId, body);
+        }
+        const id = args[0];
+        return this._putAlarm(id.agentId, id.channelName, args[1], args[2]);
+    }
+    _putAlarm(agentId, channelName, alarmId, body) {
         return this.rest.put(`/agents/${agentId}/channels/${channelName}/alarms/${alarmId}`, body);
     }
-    patchAlarm(agentId, channelName, alarmId, body) {
+    patchAlarm(...args) {
+        if (typeof args[0] === "string") {
+            const [agentId, channelName, alarmId, body] = args;
+            return this._patchAlarm(agentId, channelName, alarmId, body);
+        }
+        const id = args[0];
+        return this._patchAlarm(id.agentId, id.channelName, args[1], args[2]);
+    }
+    _patchAlarm(agentId, channelName, alarmId, body) {
         return this.rest.patch(`/agents/${agentId}/channels/${channelName}/alarms/${alarmId}`, body);
     }
-    deleteAlarm(agentId, channelName, alarmId) {
+    deleteAlarm(...args) {
+        if (typeof args[0] === "string") {
+            const [agentId, channelName, alarmId] = args;
+            return this._deleteAlarm(agentId, channelName, alarmId);
+        }
+        const id = args[0];
+        return this._deleteAlarm(id.agentId, id.channelName, args[1]);
+    }
+    _deleteAlarm(agentId, channelName, alarmId) {
         return this.rest.delete(`/agents/${agentId}/channels/${channelName}/alarms/${alarmId}`);
     }
 }

package/dist/apis/channels-api.d.ts

@@ -17,11 +17,48 @@ export interface DataSeriesParams {
 export declare class ChannelsApi {
     private readonly rest;
     constructor(rest: RestClient);
-    listChannels(agentId: string, options?: ListChannelsOptions): Promise<Channel<Record<string, import("..").JSONValue>>[]>;
-    getChannel(agentId: string, channelName: string, options?: GetChannelOptions): Promise<Channel<Record<string, import("..").JSONValue>>>;
+    listChannels(agentId: string, options?: ListChannelsOptions): Promise<Channel[]>;
+    listChannels(identifier: {
+        agentId: string;
+    }, options?: ListChannelsOptions): Promise<Channel[]>;
+    private _listChannels;
+    getChannel(agentId: string, channelName: string, options?: GetChannelOptions): Promise<Channel>;
+    getChannel(identifier: {
+        agentId: string;
+        channelName: string;
+    }, options?: GetChannelOptions): Promise<Channel>;
+    private _getChannel;
     createChannel(agentId: string, channelName: string, body: CreateChannelRequest): Promise<{
         id: string;
     }>;
-    putChannel(agentId: string, channelName: string, body: PutChannelRequest): Promise<Channel<Record<string, import("..").JSONValue>>>;
+    createChannel(identifier: {
+        agentId: string;
+        channelName: string;
+    }, body: CreateChannelRequest): Promise<{
+        id: string;
+    }>;
+    private _createChannel;
+    putChannel(agentId: string, channelName: string, body: PutChannelRequest): Promise<Channel>;
+    putChannel(identifier: {
+        agentId: string;
+        channelName: string;
+    }, body: PutChannelRequest): Promise<Channel>;
+    private _putChannel;
+    archiveChannel(agentId: string, channelName: string): Promise<unknown>;
+    archiveChannel(identifier: {
+        agentId: string;
+        channelName: string;
+    }): Promise<unknown>;
+    private _archiveChannel;
+    unarchiveChannel(agentId: string, channelName: string): Promise<unknown>;
+    unarchiveChannel(identifier: {
+        agentId: string;
+        channelName: string;
+    }): Promise<unknown>;
+    private _unarchiveChannel;
     listDataSeries(agentId: string, params: DataSeriesParams): Promise<DataSeries>;
+    listDataSeries(identifier: {
+        agentId: string;
+    }, params: DataSeriesParams): Promise<DataSeries>;
+    private _listDataSeries;
 }

package/dist/apis/channels-api.js

@@ -1,23 +1,68 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ChannelsApi = void 0;
+const _args_1 = require("./_args");
 class ChannelsApi {
     constructor(rest) {
         this.rest = rest;
     }
-    listChannels(agentId, options) {
+    listChannels(...args) {
+        const { agentId, options } = (0, _args_1.resolveAgentArgs)(args);
+        return this._listChannels(agentId, options);
+    }
+    _listChannels(agentId, options) {
         return this.rest.get(`/agents/${agentId}/channels`, options);
     }
-    getChannel(agentId, channelName, options) {
+    getChannel(...args) {
+        const { agentId, channelName, options } = (0, _args_1.resolveChannelArgs)(args);
+        return this._getChannel(agentId, channelName, options);
+    }
+    _getChannel(agentId, channelName, options) {
         return this.rest.get(`/agents/${agentId}/channels/${channelName}`, options);
     }
-    createChannel(agentId, channelName, body) {
+    createChannel(...args) {
+        if (typeof args[0] === "string") {
+            const [agentId, channelName, body] = args;
+            return this._createChannel(agentId, channelName, body);
+        }
+        const id = args[0];
+        const body = args[1];
+        return this._createChannel(id.agentId, id.channelName, body);
+    }
+    _createChannel(agentId, channelName, body) {
         return this.rest.post(`/agents/${agentId}/channels/${channelName}`, body);
     }
-    putChannel(agentId, channelName, body) {
+    putChannel(...args) {
+        if (typeof args[0] === "string") {
+            const [agentId, channelName, body] = args;
+            return this._putChannel(agentId, channelName, body);
+        }
+        const id = args[0];
+        const body = args[1];
+        return this._putChannel(id.agentId, id.channelName, body);
+    }
+    _putChannel(agentId, channelName, body) {
         return this.rest.put(`/agents/${agentId}/channels/${channelName}`, body);
     }
-    listDataSeries(agentId, params) {
+    archiveChannel(...args) {
+        const { agentId, channelName } = (0, _args_1.resolveChannelArgs)(args);
+        return this._archiveChannel(agentId, channelName);
+    }
+    _archiveChannel(agentId, channelName) {
+        return this.rest.post(`/agents/${agentId}/channels/${channelName}/archive`, {});
+    }
+    unarchiveChannel(...args) {
+        const { agentId, channelName } = (0, _args_1.resolveChannelArgs)(args);
+        return this._unarchiveChannel(agentId, channelName);
+    }
+    _unarchiveChannel(agentId, channelName) {
+        return this.rest.post(`/agents/${agentId}/channels/${channelName}/unarchive`, {});
+    }
+    listDataSeries(...args) {
+        const { agentId, options } = (0, _args_1.resolveAgentArgs)(args);
+        return this._listDataSeries(agentId, options);
+    }
+    _listDataSeries(agentId, params) {
         return this.rest.get(`/agents/${agentId}/data_series`, params);
     }
 }

package/dist/apis/connections-api.d.ts

@@ -16,14 +16,30 @@ export declare class ConnectionsApi {
     private readonly rest;
     constructor(rest: RestClient);
     getAgentConnections(agentId: string): Promise<ConnectionDetails[]>;
+    getAgentConnections(identifier: {
+        agentId: string;
+    }): Promise<ConnectionDetails[]>;
+    private _getAgentConnections;
     getAgentConnectionHistory(agentId: string, params: ConnectionHistoryParams): Promise<ConnectionDetails[]>;
+    getAgentConnectionHistory(identifier: {
+        agentId: string;
+    }, params: ConnectionHistoryParams): Promise<ConnectionDetails[]>;
+    private _getAgentConnectionHistory;
     getAgentSubscriptionHistory(agentId: string, params: SubscriptionHistoryParams): Promise<ConnectionSubscriptionLog[]>;
+    getAgentSubscriptionHistory(identifier: {
+        agentId: string;
+    }, params: SubscriptionHistoryParams): Promise<ConnectionSubscriptionLog[]>;
+    private _getAgentSubscriptionHistory;
     getConnection(connectionId: string): Promise<ConnectionDetails>;
     getChannelSubscriptions(agentId: string, channelName: string): Promise<ConnectionSubscription[]>;
-    /**
-     * Ask the server to push the latest state of all channels this agent
-     * owns to every active WSS connection. Used to recover from missed updates
-     * after a gap in connectivity.
-     */
+    getChannelSubscriptions(identifier: {
+        agentId: string;
+        channelName: string;
+    }): Promise<ConnectionSubscription[]>;
+    private _getChannelSubscriptions;
     syncConnection(agentId: string): Promise<unknown>;
+    syncConnection(identifier: {
+        agentId: string;
+    }): Promise<unknown>;
+    private _syncConnection;
 }