doover-js 0.10.0 → 0.11.0

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

@@ -3,6 +3,12 @@ import type { Alarm, CreateAlarmRequest, PatchAlarmRequest } from "../types/open
 export declare class AlarmsApi {
     private readonly rest;
     constructor(rest: RestClient);
+    /** Every alarm on every channel of an agent the caller can see. */
+    listAgentAlarms(agentId: string): Promise<Alarm[]>;
+    listAgentAlarms(identifier: {
+        agentId: string;
+    }): Promise<Alarm[]>;
+    private _listAgentAlarms;
     listAlarms(agentId: string, channelName: string): Promise<Alarm[]>;
     listAlarms(identifier: {
         agentId: string;

package/dist/apis/alarms-api.js

@@ -6,6 +6,13 @@ class AlarmsApi {
     constructor(rest) {
         this.rest = rest;
     }
+    listAgentAlarms(...args) {
+        const { agentId } = (0, _args_1.resolveAgentArgs)(args);
+        return this._listAgentAlarms(agentId);
+    }
+    _listAgentAlarms(agentId) {
+        return this.rest.get(`/agents/${agentId}/alarms`);
+    }
     listAlarms(...args) {
         const { agentId, channelName } = (0, _args_1.resolveChannelArgs)(args);
         return this._listAlarms(agentId, channelName);

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

@@ -1,5 +1,5 @@
 import type { RestClient } from "../http/rest-client";
-import type { CreateEndpointRequest, CreateNotificationSubscriptionRequest, NotificationDataResponse, NotificationEndpoint, NotificationEndpointsResponse, NotificationSubscribersResponse, NotificationSubscriptionCreateResponse, NotificationSubscriptionsResponse, UpdateEndpointRequest, UpdateMeWebPushEndpointRequest, UpdateNotificationSubscriptionRequest } from "../types/openapi";
+import type { CreateEndpointRequest, CreateNotificationSubscriptionRequest, NotificationDataResponse, NotificationEndpoint, NotificationEndpointSummariesResponse, NotificationEndpointsResponse, NotificationSubscribersResponse, NotificationSubscriptionCreateResponse, NotificationSubscriptionsResponse, UpdateEndpointRequest, UpdateMeWebPushEndpointRequest, UpdateNotificationSubscriptionRequest } from "../types/openapi";
 export declare class NotificationsApi {
     private readonly rest;
     constructor(rest: RestClient);
@@ -13,6 +13,16 @@ export declare class NotificationsApi {
         agentId: string;
     }, name?: string): Promise<NotificationEndpointsResponse>;
     private _getAgentNotificationEndpoints;
+    /**
+     * Delivery readiness for each endpoint, without addresses or credentials.
+     * Readable with either notification-read or manage-subscriptions rights, so
+     * a delegated subscription manager can list endpoints it can't otherwise see.
+     */
+    getAgentNotificationEndpointSummaries(agentId: string): Promise<NotificationEndpointSummariesResponse>;
+    getAgentNotificationEndpointSummaries(identifier: {
+        agentId: string;
+    }): Promise<NotificationEndpointSummariesResponse>;
+    private _getAgentNotificationEndpointSummaries;
     createNotificationEndpoint(agentId: string, body: CreateEndpointRequest): Promise<NotificationEndpoint>;
     createNotificationEndpoint(identifier: {
         agentId: string;
@@ -48,6 +58,15 @@ export declare class NotificationsApi {
         agentId: string;
     }, subscribed_to?: string): Promise<NotificationSubscriptionsResponse>;
     private _getAgentDefaultNotificationSubscriptions;
+    /**
+     * Update every default subscription this subscriber holds on `subscribedTo`
+     * at once. Omitted fields keep their current value.
+     */
+    updateDefaultNotificationSubscription(agentId: string, subscribedTo: string, body: UpdateNotificationSubscriptionRequest): Promise<unknown>;
+    updateDefaultNotificationSubscription(identifier: {
+        agentId: string;
+    }, subscribedTo: string, body: UpdateNotificationSubscriptionRequest): Promise<unknown>;
+    private _updateDefaultNotificationSubscription;
     deleteDefaultNotificationSubscription(agentId: string, subscribedTo: string): Promise<unknown>;
     deleteDefaultNotificationSubscription(identifier: {
         agentId: string;

package/dist/apis/notifications-api.js

@@ -23,6 +23,13 @@ class NotificationsApi {
     _getAgentNotificationEndpoints(agentId, name) {
         return this.rest.get(`/agents/${agentId}/notifications/endpoints`, { name });
     }
+    getAgentNotificationEndpointSummaries(...args) {
+        const { agentId } = (0, _args_1.resolveAgentArgs)(args);
+        return this._getAgentNotificationEndpointSummaries(agentId);
+    }
+    _getAgentNotificationEndpointSummaries(agentId) {
+        return this.rest.get(`/agents/${agentId}/notifications/endpoints/summary`);
+    }
     createNotificationEndpoint(...args) {
         if (typeof args[0] === "string") {
             return this._createNotificationEndpoint(args[0], args[1]);
@@ -93,6 +100,16 @@ class NotificationsApi {
     _getAgentDefaultNotificationSubscriptions(agentId, subscribed_to) {
         return this.rest.get(`/agents/${agentId}/notifications/subscriptions/default`, { subscribed_to });
     }
+    updateDefaultNotificationSubscription(...args) {
+        if (typeof args[0] === "string") {
+            return this._updateDefaultNotificationSubscription(args[0], args[1], args[2]);
+        }
+        const id = args[0];
+        return this._updateDefaultNotificationSubscription(id.agentId, args[1], args[2]);
+    }
+    _updateDefaultNotificationSubscription(agentId, subscribedTo, body) {
+        return this.rest.patch(`/agents/${agentId}/notifications/subscriptions/default/${subscribedTo}`, body);
+    }
     deleteDefaultNotificationSubscription(...args) {
         if (typeof args[0] === "string") {
             return this._deleteDefaultNotificationSubscription(args[0], args[1]);

package/dist/client/multiplex-client.js

@@ -9,6 +9,7 @@ const multiplex_gateway_1 = require("./multiplex-gateway");
 /** "<subclient>.<method>" → spec. Drives the generic non-core facades. */
 const NONCORE_METHODS = {
     // alarms
+    "alarms.listAgentAlarms": { cap: "alarms.read", kind: "read-fanout-first", agentScoped: true },
     "alarms.listAlarms": { cap: "alarms.read", kind: "read-fanout-first", agentScoped: true },
     "alarms.getAlarm": { cap: "alarms.read", kind: "read-fanout-first", agentScoped: true },
     "alarms.createAlarm": { cap: "alarms.write", kind: "write-route", agentScoped: true },
@@ -25,6 +26,7 @@ const NONCORE_METHODS = {
     // notifications (reads)
     "notifications.getAgentNotifications": { cap: "notifications.read", kind: "read-fanout-first", agentScoped: true },
     "notifications.getAgentNotificationEndpoints": { cap: "notifications.read", kind: "read-fanout-first", agentScoped: true },
+    "notifications.getAgentNotificationEndpointSummaries": { cap: "notifications.read", kind: "read-fanout-first", agentScoped: true },
     "notifications.getAgentNotificationSubscriptions": { cap: "notifications.read", kind: "read-fanout-first", agentScoped: true },
     "notifications.getAgentDefaultNotificationSubscriptions": { cap: "notifications.read", kind: "read-fanout-first", agentScoped: true },
     "notifications.getAgentNotificationSubscribers": { cap: "notifications.read", kind: "read-fanout-first", agentScoped: true },
@@ -35,6 +37,7 @@ const NONCORE_METHODS = {
     "notifications.deleteNotificationEndpoint": { cap: "notifications.write", kind: "write-route", agentScoped: true },
     "notifications.testNotificationEndpoint": { cap: "notifications.write", kind: "write-route", agentScoped: true },
     "notifications.createNotificationSubscription": { cap: "notifications.write", kind: "write-route", agentScoped: true },
+    "notifications.updateDefaultNotificationSubscription": { cap: "notifications.write", kind: "write-route", agentScoped: true },
     "notifications.deleteDefaultNotificationSubscription": { cap: "notifications.write", kind: "write-route", agentScoped: true },
     "notifications.updateNotificationSubscription": { cap: "notifications.write", kind: "write-route", agentScoped: true },
     "notifications.deleteNotificationSubscription": { cap: "notifications.write", kind: "write-route", agentScoped: true },

package/dist/gateway/gateway-client.js

@@ -5,6 +5,40 @@ const errors_1 = require("../http/errors");
 const snowflake_1 = require("../utils/snowflake");
 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. */
+const ALLOWED_WSS_PROTOCOLS = new Set(["ws:", "wss:", "http:", "https:"]);
+/**
+ * Reject a `dataWssUrl` that cannot address a gateway.
+ *
+ * An empty or relative value is the dangerous case, because nothing rejects it
+ * on its own: the WebSocket constructor resolves a relative URL against the
+ * document and maps https to wss, so in a browser `new WebSocket("")` silently
+ * points the gateway at whatever page is open. That page answers the upgrade
+ * with its own HTML and a 200, the browser reports "the server did not accept
+ * the WebSocket handshake", and the client retries against it forever — a loop
+ * that looks like a server problem and never names the real cause. It reached
+ * a kiosk panel that way, from a client built with `dataWssUrl: ""` because the
+ * build it was bundled into defined no env for it.
+ *
+ * Absolute http(s) is allowed as well as ws(s), since the WebSocket
+ * constructor maps those itself and existing configs rely on it.
+ */
+function assertAbsoluteWssUrl(url) {
+    if (typeof url !== "string" || url.trim() === "") {
+        throw new Error("dataWssUrl is empty, so a gateway connection would resolve against the " +
+            "current page rather than a gateway; set it to an absolute ws(s):// URL");
+    }
+    let parsed;
+    try {
+        parsed = new URL(url);
+    }
+    catch {
+        throw new Error(`dataWssUrl must be an absolute ws(s):// URL, not the relative value ${JSON.stringify(url)}`);
+    }
+    if (!ALLOWED_WSS_PROTOCOLS.has(parsed.protocol)) {
+        throw new Error(`dataWssUrl must be ws(s):// or http(s)://, not ${parsed.protocol}//`);
+    }
+}
 class GatewayClient {
     constructor(config, auth) {
         this.config = config;
@@ -90,6 +124,10 @@ class GatewayClient {
         }
     }
     async openSocket() {
+        // Before auth, before any socket: a URL that cannot address a gateway is a
+        // configuration fault, and finding out now costs one error instead of an
+        // endless handshake failure that reads like a broken server.
+        assertAbsoluteWssUrl(this.config.dataWssUrl);
         if (this.auth) {
             await this.auth.ensureReady();
         }

package/dist/test/apis.test.js

@@ -290,10 +290,23 @@ function setupRest(responseFactory) {
         await alarms.createAlarm("a1", "c1", { name: "a", key: "x", operator: "gt", value: 1 });
         await alarms.getAlarm("a1", "c1", "alarm");
         await alarms.putAlarm("a1", "c1", "alarm", { name: "a", key: "x", operator: "gt", value: 1 });
+        // A rate alarm states its condition with rate_threshold/rate_window_ms and
+        // must leave `value` unset.
+        await alarms.createAlarm("a1", "c1", {
+            name: "rising",
+            key: "level",
+            operator: "gt",
+            rate_threshold: 0.05,
+            rate_window_ms: 600000,
+            topic_name: "level-rising",
+            notification_policy: "opt-in",
+            messages: { alarm: { notify: true, text: "Level rising fast" } },
+        });
         await alarms.patchAlarm("a1", "c1", "alarm", { enabled: false });
+        await alarms.patchAlarm("a1", "c1", "alarm", { messages: { ok: { notify: false } } });
         await alarms.deleteAlarm("a1", "c1", "alarm");
         (0, chai_1.expect)(await aggregateBlob.text()).to.equal("agg");
-        (0, chai_1.expect)(fetchMock.callCount).to.equal(10);
+        (0, chai_1.expect)(fetchMock.callCount).to.equal(12);
     });
     (0, mocha_1.it)("covers connections and notifications methods", async () => {
         const { rest, fetchMock } = setupRest(() => (0, helpers_1.createJsonResponse)({ subscriptions: [], endpoints: [], subscribers: [] }));
@@ -312,6 +325,7 @@ function setupRest(responseFactory) {
         (0, chai_1.expect)(syncCall.args[1].method).to.equal("POST");
         await notifications.getAgentNotifications("a1");
         await notifications.getAgentNotificationEndpoints("a1", "browser");
+        await notifications.getAgentNotificationEndpointSummaries("a1");
         await notifications.createNotificationEndpoint("a1", {
             name: "browser",
             type: 3,
@@ -328,6 +342,11 @@ function setupRest(responseFactory) {
             topic_filter: ["*"],
         });
         await notifications.getAgentDefaultNotificationSubscriptions("a1", "a2");
+        await notifications.updateDefaultNotificationSubscription("a1", "a2", {
+            severity: 5,
+            topic_filter: ["^dev/alarms/default/[^/]+/triggered$"],
+            topic_filter_mode: "regex",
+        });
         await notifications.deleteDefaultNotificationSubscription("a1", "a2");
         await notifications.updateNotificationSubscription("a1", "s1", { severity: 4 });
         await notifications.deleteNotificationSubscription("a1", "s1");
@@ -340,7 +359,15 @@ function setupRest(responseFactory) {
             expires_at: 1,
         });
         await notifications.getWebPushPublicKey();
-        (0, chai_1.expect)(fetchMock.callCount).to.equal(21);
+        const summaryCall = fetchMock
+            .getCalls()
+            .find((call) => call.args[0].endsWith("/agents/a1/notifications/endpoints/summary"));
+        (0, chai_1.expect)(summaryCall).to.not.equal(undefined);
+        const defaultPatch = fetchMock
+            .getCalls()
+            .find((call) => call.args[0].endsWith("/agents/a1/notifications/subscriptions/default/a2") && call.args[1].method === "PATCH");
+        (0, chai_1.expect)(defaultPatch).to.not.equal(undefined);
+        (0, chai_1.expect)(fetchMock.callCount).to.equal(23);
     });
     (0, mocha_1.it)("covers permissions, processors, and turn methods", async () => {
         const { rest, fetchMock } = setupRest(() => (0, helpers_1.createJsonResponse)({ db: { agent_id: "a1", is_superuser: false, resources: [] } }));

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

@@ -393,4 +393,82 @@ class RejectingAuth extends doover_auth_1.DooverAuth {
         (0, chai_1.expect)(helpers_1.MockWebSocket.instances.length).to.equal(11);
         randomStub.restore();
     });
+    (0, mocha_1.describe)("an unusable dataWssUrl", () => {
+        // A relative or empty value is resolved against the document by the
+        // WebSocket constructor, so the gateway silently points at whatever page
+        // is open, gets that page's HTML and a 200 back, and retries against it
+        // forever. Refusing it names the cause once instead.
+        (0, mocha_1.it)("refuses an empty one rather than resolving against the page", async () => {
+            const client = new gateway_client_1.GatewayClient({
+                dataRestUrl: "https://api.example.com",
+                controlApiUrl: "https://control.example.com",
+                dataWssUrl: "",
+                organisationId: null,
+                sharing: "none",
+                impersonateUserStorageKey: "doover:test",
+            });
+            await (0, chai_1.expect)(client.connect()).to.be.rejectedWith(/dataWssUrl is empty/);
+            (0, chai_1.expect)(helpers_1.MockWebSocket.instances).to.have.length(0);
+        });
+        (0, mocha_1.it)("refuses a relative one", async () => {
+            const client = new gateway_client_1.GatewayClient({
+                dataRestUrl: "https://api.example.com",
+                controlApiUrl: "https://control.example.com",
+                dataWssUrl: "/widget/some_widget?app_key=k",
+                organisationId: null,
+                sharing: "none",
+                impersonateUserStorageKey: "doover:test",
+            });
+            await (0, chai_1.expect)(client.connect()).to.be.rejectedWith(/not the relative value/);
+            (0, chai_1.expect)(helpers_1.MockWebSocket.instances).to.have.length(0);
+        });
+        (0, mocha_1.it)("refuses a scheme a WebSocket cannot be opened on", async () => {
+            const client = new gateway_client_1.GatewayClient({
+                dataRestUrl: "https://api.example.com",
+                controlApiUrl: "https://control.example.com",
+                dataWssUrl: "file:///etc/hosts",
+                organisationId: null,
+                sharing: "none",
+                impersonateUserStorageKey: "doover:test",
+            });
+            await (0, chai_1.expect)(client.connect()).to.be.rejectedWith(/must be ws\(s\):\/\/ or http\(s\)/);
+            (0, chai_1.expect)(helpers_1.MockWebSocket.instances).to.have.length(0);
+        });
+        (0, mocha_1.it)("reports it through wssError once when a subscribe connects in the background", async () => {
+            // `subscribe` is fire-and-forget, so the fault has to surface as an event
+            // rather than a rejected promise nobody holds — and only once, because
+            // reconnects are scheduled on socket close and no socket was ever opened.
+            const client = new gateway_client_1.GatewayClient({
+                dataRestUrl: "https://api.example.com",
+                controlApiUrl: "https://control.example.com",
+                dataWssUrl: "",
+                organisationId: null,
+                sharing: "none",
+                impersonateUserStorageKey: "doover:test",
+            });
+            const errors = [];
+            client.on("wssError", (event) => errors.push(String(event.message)));
+            client.subscribe({ agent_id: "111", name: "tag_values" });
+            // The rejection travels connect -> openSocket -> catch, which is several
+            // microtasks; draining them is not the same as advancing fake timers.
+            for (let tick = 0; tick < 5; tick += 1)
+                await Promise.resolve();
+            (0, chai_1.expect)(errors).to.have.length(1);
+            (0, chai_1.expect)(errors[0]).to.match(/dataWssUrl is empty/);
+            (0, chai_1.expect)(helpers_1.MockWebSocket.instances).to.have.length(0);
+        });
+        (0, mocha_1.it)("still accepts an absolute http(s) URL, which WebSocket maps itself", async () => {
+            const client = new gateway_client_1.GatewayClient({
+                dataRestUrl: "https://api.example.com",
+                controlApiUrl: "https://control.example.com",
+                dataWssUrl: "https://ws.example.com/gateway",
+                organisationId: null,
+                sharing: "none",
+                impersonateUserStorageKey: "doover:test",
+            });
+            await client.connect();
+            (0, chai_1.expect)(helpers_1.MockWebSocket.instances).to.have.length(1);
+            (0, chai_1.expect)(helpers_1.MockWebSocket.instances[0].url).to.equal("https://ws.example.com/gateway");
+        });
+    });
 });

package/dist/types/common.d.ts

@@ -48,6 +48,10 @@ export interface Alarm {
     id: string;
     name: string;
     description: string;
+    /** Channel the alarm lives on — set on every alarm the REST API returns. */
+    channel_name?: string;
+    topic_name?: string;
+    notification_policy?: "default" | "opt-in";
     enabled: boolean;
     key: string;
     operator: AlarmOperator;
@@ -56,8 +60,29 @@ export interface Alarm {
     expiry_mins: number | null;
     entered_state_ts: number;
     alarm_pending_ms: number | null;
+    rate_threshold?: number | null;
+    rate_window_ms?: number | null;
+    rate_baseline_value?: number | null;
+    rate_baseline_ts?: number | null;
+    messages?: AlarmMessages | null;
     __source?: SourceProvenance;
 }
+/**
+ * Per-transition notification override. `notify` and `text` are independent:
+ * turning notifications off keeps whatever wording was set, and `text: null`
+ * means "use the auto-generated message".
+ */
+export interface AlarmStateMessage {
+    notify?: boolean;
+    text?: string | null;
+}
+/** Notification overrides keyed by the state being entered. */
+export interface AlarmMessages {
+    alarm?: AlarmStateMessage;
+    ok?: AlarmStateMessage;
+    pending?: AlarmStateMessage;
+    no_data?: AlarmStateMessage;
+}
 export type AlarmOperator = "eq" | "ge" | "gt" | "le" | "lt";
 export type AlarmState = "NoData" | "OK" | "Alarm" | "AlarmPending";
 export interface ConnectionSubscription {
@@ -84,6 +109,12 @@ export interface ConnectionDetails {
     subscriptions: ConnectionSubscription[];
     __source?: SourceProvenance;
 }
+/**
+ * How a subscription's `topic_filter` entries are matched. `exact` is literal
+ * (and the server's default when the field is absent); `regex` matches each
+ * expression against the whole canonical topic. Entries are ORed either way.
+ */
+export type NotificationTopicFilterMode = "exact" | "regex";
 export interface NotificationSubscriptionEndpoint {
     id: string;
     name: string;
@@ -95,6 +126,7 @@ export interface NotificationSubscription {
     subscribed_to: string;
     severity: number;
     topic_filter: string[];
+    topic_filter_mode: NotificationTopicFilterMode;
     endpoints: NotificationSubscriptionEndpoint[];
     __source?: SourceProvenance;
 }
@@ -108,6 +140,21 @@ export interface NotificationEndpoint {
     default: boolean;
     __source?: SourceProvenance;
 }
+/**
+ * Delivery readiness for an endpoint, without its destination address or
+ * `extra_data` — the one endpoint listing a delegated subscription manager is
+ * allowed to see.
+ */
+export interface NotificationEndpointSummary {
+    id: string;
+    type: number;
+    priority: number | null;
+    name: string;
+    display_name: string | null;
+    default: boolean;
+    ready: boolean;
+    __source?: SourceProvenance;
+}
 export interface ResourcePermission {
     permission_id: string;
     permission: string;

package/dist/types/openapi.d.ts

@@ -1,5 +1,5 @@
-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, };
+import type { AgentAggregate, AgentPermission, Alarm, AlarmMessages, AlarmStateMessage, Aggregate, Channel, ConnectionDetails, ConnectionSubscription, ConnectionSubscriptionLog, DataSeries, MessageStructure, NotificationEndpoint, NotificationEndpointSummary, NotificationSubscription, NotificationTopicFilterMode, ResourcePermission, TurnCredential } from "./common";
+export type { AgentAggregate, AgentPermission, Alarm, AlarmMessages, AlarmStateMessage, Aggregate, Channel, ConnectionDetails, ConnectionSubscription, ConnectionSubscriptionLog, DataSeries, MessageStructure, NotificationEndpoint, NotificationEndpointSummary, NotificationSubscription, NotificationTopicFilterMode, ResourcePermission, TurnCredential, };
 export interface BatchMessagesResponse {
     results: MessageStructure[];
     count: number;
@@ -41,6 +41,9 @@ export interface NotificationDataResponse {
 export interface NotificationEndpointsResponse {
     endpoints: NotificationEndpoint[];
 }
+export interface NotificationEndpointSummariesResponse {
+    endpoints: NotificationEndpointSummary[];
+}
 export interface NotificationSubscriptionsResponse {
     subscriptions: NotificationSubscription[];
 }
@@ -101,10 +104,30 @@ export interface CreateAlarmRequest {
     enabled?: boolean;
     key: string;
     operator: Alarm["operator"];
-    value: unknown;
+    /**
+     * The threshold to compare against. Required for a threshold alarm, and
+     * must be left out entirely for a rate alarm — which states its condition
+     * with `rate_threshold` instead.
+     */
+    value?: unknown;
     expiry_mins?: number | null;
     alarm_pending_ms?: number | null;
-}
+    /** Stable slug used in notification topics. Derived from `name` if absent. */
+    topic_name?: string;
+    notification_policy?: Alarm["notification_policy"];
+    /**
+     * Units per second, judged over at least `rate_window_ms`. Setting the pair
+     * makes this a rate-of-change alarm; they must be set together.
+     */
+    rate_threshold?: number | null;
+    rate_window_ms?: number | null;
+    messages?: AlarmMessages | null;
+}
+/**
+ * Every field is optional; each is merged rather than replaced. `messages` is
+ * merged state by state and field by field, so `{messages: {ok: {notify:
+ * false}}}` leaves the stored text alone, and an explicit `null` clears.
+ */
 export interface PatchAlarmRequest extends Partial<CreateAlarmRequest> {
 }
 export interface CreateEndpointRequest {
@@ -124,10 +147,13 @@ export interface CreateNotificationSubscriptionRequest {
     endpoint_id?: string | null;
     severity: number;
     topic_filter: string[];
+    /** Defaults to `exact` server-side when absent. */
+    topic_filter_mode?: NotificationTopicFilterMode;
 }
 export interface UpdateNotificationSubscriptionRequest {
     severity?: number;
     topic_filter?: string[];
+    topic_filter_mode?: NotificationTopicFilterMode;
 }
 export interface UpdateMeWebPushEndpointRequest {
     old_endpoint: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "doover-js",
-  "version": "0.10.0",
+  "version": "0.11.0",
   "description": "TypeScript client for Doover.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",