doover-js 0.5.4 → 0.6.0

package/README.md

@@ -122,8 +122,154 @@ const client = new DooverClient({
 
 Reconnections automatically use the latest (potentially refreshed) token.
 
+## Multi-source data (`DataClient`)
+
+### The `DataClient` contract
+
+`DooverClient` now implements the `DataClient` interface — the shared contract for every client type in this library. Any hook or provider that previously accepted a `DooverClient` now accepts any `DataClient`.
+
+```ts
+import type { DataClient } from "doover-js";
+
+function useMyData(client: DataClient) {
+  return client.channels.listChannels("my-agent");
+}
+```
+
+### Capability model
+
+Each client advertises what it can do via `getCapabilities()` and the `supports(cap)` helper. Calling an unsupported method throws `UnsupportedCapabilityError`.
+
+```ts
+import { UnsupportedCapabilityError } from "doover-js";
+
+if (client.supports("aggregates.write")) {
+  await client.aggregates.putAggregate(channelId, data);
+} else {
+  console.warn("Client does not support aggregate writes");
+}
+```
+
+### `LocalAgentClient` — LAN / direct access
+
+Connect directly to a local Doover agent without cloud auth:
+
+```ts
+import { LocalAgentClient } from "doover-js";
+
+const local = new LocalAgentClient({
+  baseUrl: "http://192.168.0.7:49100",
+  sourceId: "local:192.168.0.7:49100", // stable id for cache keys
+});
+const channels = await local.channels.listChannels("my-agent");
+```
+
+`LocalAgentClient` exposes a narrowed capability set — reads for agents, channels, messages, aggregates, and the gateway are supported; cloud-only operations (alarms, notifications, permissions, etc.) are not.
+
+### `MultiplexClient` — fan-out reads, routed writes
+
+`MultiplexClient` manages a registry of named sources (cloud or local) and fans reads out across all active sources, merging the results. Writes are routed to the single source that owns the target agent.
+
+```ts
+import { MultiplexClient, LocalAgentClient, getDooverClient } from "doover-js";
+
+const mux = new MultiplexClient({
+  factory: (d) =>
+    d.kind === "cloud"
+      ? getDooverClient({ /* cloud config */ })
+      : new LocalAgentClient({ baseUrl: `http://${(d.params as any).host}:${(d.params as any).port}`, sourceId: d.id }),
+  register: [{ id: "cloud", kind: "cloud" }],
+  enable: ["cloud"],
+});
+mux.setActiveSources(["cloud", { id: "local:192.168.0.7:49100", kind: "local", params: { host: "192.168.0.7", port: 49100 } }]);
+const channels = await mux.channels.listChannels("dev7"); // merged cloud + local
+mux.on("conflict", (c) => console.warn("source disagreement", c));
+```
+
+Use `getLastConflicts()` to inspect the most recent per-key disagreements between sources after a read.
+
+### `__source` provenance
+
+Every datum returned by any `DataClient` carries a `__source` field (type `SourceProvenance`) recording which client returned it, when, and via which transport.
+
+```ts
+const ch = await client.channels.getChannel("my-channel");
+console.log(ch.__source?.client.id); // e.g. "cloud" or "local:192.168.0.7:49100"
+```
+
+### React: hooks, `DooverProvider`, and `useClientStatus`
+
+`DooverProvider` accepts any `DataClient`:
+
+```tsx
+import { DooverProvider } from "doover-js/react";
+import { MultiplexClient } from "doover-js";
+
+<DooverProvider client={mux}>
+  <App />
+</DooverProvider>
+```
+
+All data hooks gained an optional `sources?: string[]` prop that restricts fan-out to specific sources:
+
+```tsx
+const { data } = useChannelAggregate(channelId, { sources: ["local:192.168.0.7:49100"] });
+```
+
+The new `useClientStatus()` hook surfaces the connection status of every registered source:
+
+```tsx
+import { useClientStatus } from "doover-js/react";
+
+const statuses = useClientStatus();
+// statuses is DataClientStatus[] — one entry per registered source
+```
+
+`useConnectionState` is soft-deprecated in favour of `useClientStatus`. It still works and remains exported, but new code should prefer `useClientStatus`.
+
 ## Architecture
 
 `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.
+
+## 0.5.0-alpha.1
+
+- **`DataClient` contract + capability model** — `DooverClient` now implements the `DataClient` interface. Every client type advertises its capability set; unsupported calls throw `UnsupportedCapabilityError`. `AmbiguousWriteError` is raised when a `MultiplexClient` write has more than one candidate source. (Additive, no breaking changes.)
+- **`__source` provenance** — every datum carries a `__source: SourceProvenance` field recording which client returned it, when, and via which transport.
+- **`LocalAgentClient`** — new client for direct LAN connections to a local Doover agent (no cloud auth required).
+- **`MultiplexClient`** — new client that manages a registry of named sources, fans reads out across all active sources, merges results, and routes writes to the owning source.
+- **React `sources` option** — all data hooks accept `sources?: string[]` to restrict fan-out to specific sources; query keys are source-dimensioned.
+- **`useClientStatus()`** — new react hook that surfaces `DataClientStatus` for each registered source.
+- **`useConnectionState` soft-deprecated** — still exported and working; prefer `useClientStatus` for new code.
+
+## 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[];
@@ -28,7 +29,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>;
     /**
      * Batch-fetch aggregates for many agents. Auto-chunks `agent_id` so each

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;
 }