homematic-manager 3.0.0-beta.21 → 3.0.0-beta.22

package/README.md

@@ -85,9 +85,11 @@ subscribes again with one `init` per interface. That page sees the interfaces ma
 until their first `listDevices` sweep is through, because `hmipserver` re-sends every device on
 `init` (occu#45).
 
-`--idle-unsubscribe <duration>` / `HMM_IDLE_UNSUBSCRIBE` changes the grace period (`5m`, `300s`,
-`90`), and `0` switches it off. It is on by default for every server install type - npm, Docker and
-the CCU addon all run unattended for days. The Electron app never does this: its in-process
+The time also runs from the start when no page is opened after it (B-70). The settings dialog
+offers it (*Unsubscribe when idle*: the default, 15 minutes to 4 hours, or never), saved in the
+profile. `--idle-unsubscribe <duration>` / `HMM_IDLE_UNSUBSCRIBE` sets it at start instead (`5m`,
+`300s`, `90`, `0` for never) and then wins over the dialog, which shows it read-only. It is on by
+default for every server install type - npm, Docker and the CCU addon all run unattended for days. The Electron app never does this: its in-process
 transport reports no sessions at all, so nothing there can ever be counted as idle.
 
 What is **not** replayed after a resubscribe are the events and service messages of the idle

package/dist/cli.js

@@ -118,8 +118,13 @@ export async function runCli(options = {}) {
         log.info(`development mode: everything but the api is proxied to ${parsed.uiDevServer}`);
     }
     if (!parsed.demo) {
+        // B-70: a time given at start is the one in force; without it the settings dialog's time
+        // (saved in the profile) replaces the default, and the backend logs nothing more about it
         log.info(parsed.idleUnsubscribeMs > 0
-            ? `idle unsubscribe after ${String(Math.round(parsed.idleUnsubscribeMs / 1000))} s without an open page`
+            ? `idle unsubscribe after ${String(Math.round(parsed.idleUnsubscribeMs / 1000))} s without an open page` +
+                (parsed.idleUnsubscribePinned
+                    ? ', set at start'
+                    : ' unless the settings dialog chose another time')
             : 'idle unsubscribe is off: the interfaces stay subscribed with no page open');
     }
     const exit = options.exit ?? ((code) => process.exit(code));
@@ -177,6 +182,7 @@ function startHost(values, log, version) {
             ? {}
             : { callbackBinrpcDefaultPort: values.callbackBinrpcDefaultPort }),
         idleUnsubscribeMs: values.idleUnsubscribeMs,
+        ...(values.idleUnsubscribePinned ? { idleUnsubscribePinned: true } : {}),
     });
 }
 /** Was this file started, or only imported? The tests and `dev.ts` import it. */

package/dist/options.d.ts

@@ -244,6 +244,11 @@ export interface WebOptions {
     readonly demo: boolean;
     /** D-31, in milliseconds; `0` disables the idle unsubscribe. */
     readonly idleUnsubscribeMs: number;
+    /**
+     * B-70: `--idle-unsubscribe` or `HMM_IDLE_UNSUBSCRIBE` was given. Then it wins over the time the
+     * settings dialog saves; without it the five minutes are only the default the dialog changes.
+     */
+    readonly idleUnsubscribePinned: boolean;
     readonly logLevel: LogLevel;
     readonly help: boolean;
     readonly version: boolean;

package/dist/options.js

@@ -346,6 +346,7 @@ export function parseOptions(argv, env = process.env) {
         inContainer: boolean('in-container') ?? false,
         demo: boolean('demo'),
         idleUnsubscribeMs: parseDuration(string('idle-unsubscribe'), '--idle-unsubscribe'),
+        idleUnsubscribePinned: raw['idle-unsubscribe'] !== undefined,
         logLevel: isLogLevel(logLevel) ? logLevel : 'info',
         help: boolean('help') ?? false,
         version: boolean('version') ?? false,

package/dist/server.d.ts

@@ -92,6 +92,8 @@ export interface WebHostOptions {
      * interface processes. `0` (the default here; the CLI's default is five minutes) is off.
      */
     readonly idleUnsubscribeMs?: number;
+    /** B-70: `idleUnsubscribeMs` was given at start and wins over the settings dialog's time. */
+    readonly idleUnsubscribePinned?: boolean;
     /** `http://127.0.0.1:5173` - proxy everything that is not the API to a vite dev server. */
     readonly uiDevServer?: string | undefined;
     /** The token clients have to present. Generated when auth is on and none is given. */

package/dist/server.js

@@ -128,6 +128,7 @@ export async function createWebHost(options = {}) {
             // reports them, and Electron's in-process transport reports none - so an Electron
             // window can never be idled out however the backend is configured.
             ...(options.idleUnsubscribeMs === undefined ? {} : { idleUnsubscribeMs: options.idleUnsubscribeMs }),
+            ...(options.idleUnsubscribePinned === true ? { idleUnsubscribePinned: true } : {}),
             ...(defaultCallbackPorts === undefined ? {} : { defaultCallbackPorts }),
             ...(pinnedCallback === undefined ? {} : { pinnedCallback }),
             ...(options.inContainer === true ? { inContainer: true } : {}),

package/node_modules/@homematic-manager/backend/dist/api/backend.d.ts

@@ -62,8 +62,16 @@ export interface BackendOptions extends Omit<ConfigStoreOptions, 'version'> {
      * `0` or omitted turns it off, which is the Electron case: `InProcessTransport` never reports
      * a session, so the count is always zero and a grace period would unsubscribe a running window.
      * Only a transport that really counts sessions - `ApiWebSocketServer` - may switch this on.
+     *
+     * B-70: given at all, this is the host's default, and the profile's `idleUnsubscribeMs`
+     * replaces it unless {@link idleUnsubscribePinned} says the host was started with it.
      */
     readonly idleUnsubscribeMs?: number;
+    /**
+     * B-70: `idleUnsubscribeMs` was set when the host was started (`HMM_IDLE_UNSUBSCRIBE`,
+     * `--idle-unsubscribe`, the addon's settings page) and wins over the profile.
+     */
+    readonly idleUnsubscribePinned?: boolean;
     readonly hmipSweepDelayMs?: number;
     readonly cacheWriteDelayMs?: number;
     readonly now?: () => number;

package/node_modules/@homematic-manager/backend/dist/api/backend.js

@@ -23,8 +23,11 @@ import { DataFileServer } from '../data/files.js';
 import { installModeCalls } from '../devices/installMode.js';
 import { discoverCcus } from '../discovery/discover.js';
 import { BackendError, configError, connectionError, errorMessage, internalError, isMethodUnsupported, validationError, } from '../errors.js';
-import { InterfaceManager, LOOPBACK_IP, callbackBindHost, firstBidcosInterfaceAddress, } from '../interfaces/manager.js';
-import { MetaService } from '../meta/service.js';
+import { DEFAULT_IDLE_UNSUBSCRIBE_MS, InterfaceManager, LOOPBACK_IP, callbackBindHost, firstBidcosInterfaceAddress, } from '../interfaces/manager.js';
+import { HeatingGroupsClient } from '../groups/client.js';
+import { DETECT_TIMEOUT_MS, MetaApiClient } from '../meta/client.js';
+import { MetaService, hostBaseUrl } from '../meta/service.js';
+import { createSystemFetch } from '../meta/systemFetch.js';
 import { RegaService } from '../rega/client.js';
 import { listDevicesAnswer } from '../rpc/server.js';
 import { ApiEventEmitter } from '../util/emitter.js';
@@ -241,8 +244,35 @@ export class Backend {
             }
             return;
         }
-        const grace = this.#options.idleUnsubscribeMs ?? 0;
-        if (grace <= 0 || this.#stopped) {
+        this.#armIdleTimer();
+    }
+    /**
+     * B-70 (D-31): the grace period in force - the host's pinned value, else the profile's, else the
+     * host's default. `0` when the host never goes idle (Electron) or the choice is "never".
+     */
+    #idleGraceMs() {
+        const host = this.#options.idleUnsubscribeMs;
+        if (host === undefined) {
+            return 0;
+        }
+        if (this.#options.idleUnsubscribePinned === true) {
+            return host;
+        }
+        return this.#config.connection.idleUnsubscribeMs ?? host;
+    }
+    /**
+     * Starts the grace period when there is no session. Called when the count drops to zero and -
+     * B-70 - when a connection has just been made with nobody looking: an addon nobody opens after
+     * its start used to stay subscribed for good, because only a count *dropping* to zero started
+     * the timer, and a count that never rose never dropped.
+     */
+    #armIdleTimer() {
+        if (this.#idleTimer !== undefined) {
+            clearTimeout(this.#idleTimer);
+            this.#idleTimer = undefined;
+        }
+        const grace = this.#idleGraceMs();
+        if (grace <= 0 || this.#stopped || this.#sessions > 0) {
             return;
         }
         const timer = setTimeout(() => {
@@ -389,11 +419,35 @@ export class Backend {
                 await meta.refresh();
                 return meta.state();
             }
+            case 'meta.pairing': {
+                // task 66: no store yet, or a store that is not the system's, is "nothing to say"
+                await this.#metaReady?.catch(() => undefined);
+                return (await this.#meta?.hmipPairing()) ?? null;
+            }
             case 'meta.export':
                 return (await this.#requireMeta()).document();
             case 'meta.import':
                 await (await this.#requireMeta()).import(p[0], params[1] ?? 'replace');
                 return null;
+            case 'groups.state':
+                return this.#groupsState();
+            case 'groups.list':
+                return (await this.#requireGroups()).list();
+            case 'groups.types':
+                return (await this.#requireGroups()).types();
+            case 'groups.get':
+                return (await this.#requireGroups()).get(p[0]);
+            case 'groups.create':
+                return (await this.#requireGroups()).create(p[0], p[1], p[2]);
+            case 'groups.update':
+                // `undefined` keeps a field, so these two are read from `params`, like `meta.node.create`'s -
+                // and a `null`, which is what the WebSocket makes of an omitted argument, means the same
+                return (await this.#requireGroups()).update(p[0], {
+                    name: params[1] ?? undefined,
+                    members: params[2] ?? undefined,
+                });
+            case 'groups.delete':
+                return (await this.#requireGroups()).remove(p[0]);
             case 'paramset.get':
                 return this.#getParamset(p[0], p[1], p[2]);
             case 'paramset.description':
@@ -531,6 +585,8 @@ export class Backend {
                 ? {}
                 : { defaultCallbackPorts: this.#options.defaultCallbackPorts }),
             ...(this.#config.callbackPins === undefined ? {} : { callbackPins: this.#config.callbackPins }),
+            // B-69: read at every watchdog round - the cache is replaced when the host changes
+            listsDevices: (interfaceName) => this.#caches.devices.size(interfaceName) > 0,
             ...(this.#options.rpcTimeoutMs === undefined ? {} : { rpcTimeoutMs: this.#options.rpcTimeoutMs }),
             ...(this.#options.watchdogIntervalMs === undefined
                 ? {}
@@ -542,9 +598,30 @@ export class Backend {
             ...this.#options.interfaceManagerOptions,
         });
         this.#manager = manager;
+        // B-62: is the host an openccu-lite system? Asked alongside the interface start, so that a
+        // host which swallows the packet holds up the names, never the interfaces (D-40's rule).
+        const hostProbe = this.#probeHost(connection);
+        try {
+            await manager.start();
+        }
+        catch (error) {
+            this.#manager = undefined;
+            this.#notice('error', errorMessage(error));
+            return;
+        }
+        const probe = await hostProbe;
+        const hostVersion = probe.answer;
+        if (this.#manager !== manager) {
+            // disconnected while the host was being asked
+            return;
+        }
         this.#rega = (this.#options.createRega ?? ((options) => new RegaService(options)))({
             host: connection.host,
             enabled: connection.rega,
+            // B-62: an openccu-lite system has no ReGaHSS. Nothing is called and nothing is logged;
+            // the state says why, and the profile's own switch is left as it is - the same profile
+            // moved to a CCU has ReGa again.
+            ...(hostVersion === undefined ? {} : { reason: 'openccu-lite' }),
             tls: connection.tls,
             auth: connection.auth,
             // ReGa's client takes a language for the WebUI placeholder translation, which is off
@@ -562,20 +639,42 @@ export class Backend {
             },
             ...this.#options.regaOptions,
         });
-        try {
-            await manager.start();
-        }
-        catch (error) {
-            this.#manager = undefined;
-            this.#notice('error', errorMessage(error));
-            return;
-        }
         if (await this.#rega.refreshNames()) {
             this.#caches.saveNames();
             this.events.emit('names.changed', this.#caches.names.all());
         }
-        this.#metaReady = this.#startMeta(connection);
+        this.#metaReady = this.#startMeta(connection, probe);
         this.#startServiceMessagePolling();
+        // B-70: counted from the start (or the reconnect of a save) when no page is open
+        this.#armIdleTimer();
+    }
+    /**
+     * B-62: whether the connection's own host is an openccu-lite system - decided from what exists,
+     * openccu-lite's own rule (D-40): `GET /api/meta/v1/version` on the host itself answers
+     * `{"api":"meta",…}` there and 404 or HTML on a CCU. Never `metaUrl`, which names the store and
+     * may be another system. Never throws; a host that is off is "not openccu-lite" for this
+     * connect, and its ReGa is asked as before.
+     */
+    async #probeHost(connection) {
+        const baseUrl = hostBaseUrl(connection);
+        if (baseUrl === '') {
+            return { answer: undefined };
+        }
+        const client = new MetaApiClient({ baseUrl, fetch: this.#systemFetch(connection) });
+        // B-67: the redirect to https:// is followed, and a certificate nothing trusts is said
+        const found = await client.detect(this.#options.metaOptions?.detectTimeoutMs ?? DETECT_TIMEOUT_MS);
+        return {
+            answer: found.version,
+            baseUrl: found.baseUrl,
+            ...(found.certificate === undefined ? {} : { certificate: found.certificate }),
+        };
+    }
+    /**
+     * B-67: the `fetch` for the system's own APIs - with the certificates the profile trusts. The
+     * tests inject theirs through `metaOptions.fetch`, which wins.
+     */
+    #systemFetch(connection) {
+        return this.#options.metaOptions?.fetch ?? createSystemFetch(connection.systemTrust);
     }
     async #disconnect() {
         this.#clearTimers();
@@ -599,7 +698,7 @@ export class Backend {
      * connect. Before that the store's names are still applied - they are keyed by ref, and the
      * address half of a ref never needs an interface to be readable.
      */
-    async #startMeta(connection) {
+    async #startMeta(connection, hostProbe) {
         try {
             const meta = await MetaService.create({
                 connection,
@@ -607,9 +706,11 @@ export class Backend {
                 cacheDir: this.#config.cacheDir,
                 names: this.#caches.names,
                 interfaceOf: (address) => this.#interfaceOf(address),
+                hostProbe,
                 // task 27: ReGa as the store of rooms and functions on a CCU. Read through the
-                // service that is current at call time - a reconnect replaces it.
-                rega: this.#rega === undefined || !connection.rega
+                // service that is current at call time - a reconnect replaces it. Off by the
+                // profile or by the host (B-62): no ReGa store either way.
+                rega: this.#rega === undefined || !this.#rega.state.enabled
                     ? undefined
                     : {
                         available: this.#rega.available,
@@ -624,6 +725,7 @@ export class Backend {
                 onNotice: (level, message) => {
                     this.#notice(level, message);
                 },
+                fetch: this.#systemFetch(connection),
                 ...this.#options.metaOptions,
             });
             if (this.#stopped) {
@@ -840,7 +942,8 @@ export class Backend {
         return null;
     }
     #recordDeviceEvent(interfaceName, method, payload) {
-        this.#manager?.noteEvent(interfaceName);
+        // B-56: a device callback shows that the interface calls us, not that its events reach us
+        this.#manager?.noteEvent(interfaceName, 'device');
         const record = { timestamp: this.#now(), interfaceName, method, payload };
         this.#caches.events.push(record);
         this.events.emit('rpc.event', record);
@@ -880,11 +983,21 @@ export class Backend {
         // Task 38: a container whose callback servers listen on the loopback only has nothing to publish
         const bindHost = this.#options.callbackHost ?? callbackBindHost(config.connection);
         const publish = this.#options.inContainer === true && bindHost !== LOOPBACK_IP;
+        const idle = this.#options.idleUnsubscribeMs;
         return {
             ...config,
             ...(ports === undefined ? {} : { callbackDefaultPorts: { xmlrpc: ports.xmlrpc, binrpc: ports.binrpc } }),
             ...(pins === undefined ? {} : { callbackPinned: { ...pins } }),
             ...(publish ? { publishCallbackPorts: true } : {}),
+            // B-70: only a host that goes idle offers the time; the default of an unpinned host is
+            // D-31's five minutes, whatever it was started with, so "the default" means one thing
+            ...(idle === undefined
+                ? {}
+                : {
+                    idleUnsubscribe: this.#options.idleUnsubscribePinned === true
+                        ? { defaultMs: DEFAULT_IDLE_UNSUBSCRIBE_MS, pinnedMs: idle }
+                        : { defaultMs: idle },
+                }),
         };
     }
     async #setConfig(connection, options) {
@@ -1118,6 +1231,43 @@ export class Backend {
         }
         return this.#meta;
     }
+    /*
+     * the heating groups of openccu-lite (task 57)
+     */
+    /**
+     * The client for the box's groups API, or `undefined` where there is no box. Built per call: it
+     * is a handful of closures over the store's URL and credential, and the credential changes
+     * when the person's session arrives (`noteMetaSession`).
+     */
+    async #groupsClient() {
+        await this.#metaReady?.catch(() => undefined);
+        const meta = this.#meta;
+        const baseUrl = meta?.boxUrl;
+        if (meta === undefined || baseUrl === undefined) {
+            return undefined;
+        }
+        return new HeatingGroupsClient({
+            baseUrl,
+            credential: () => meta.boxCredential(),
+            // B-67: the same trust as the store's, on the https:// URL the detection found
+            fetch: this.#systemFetch(this.#config.connection),
+        });
+    }
+    /** `groups.state`: no box is an answer, not an error - it is what every CCU says. */
+    async #groupsState() {
+        const client = await this.#groupsClient();
+        if (client === undefined) {
+            return { available: false, reason: 'no-box' };
+        }
+        return client.probe();
+    }
+    async #requireGroups() {
+        const client = await this.#groupsClient();
+        if (client === undefined) {
+            throw configError('heating groups are edited on openccu-lite only: this connection is not to such a system');
+        }
+        return client;
+    }
     /*
      * paramsets
      */
@@ -1624,6 +1774,13 @@ export const API_METHOD_NAMES = [
     'devices.replaceable',
     'names.get',
     'names.set',
+    'groups.state',
+    'groups.list',
+    'groups.types',
+    'groups.get',
+    'groups.create',
+    'groups.update',
+    'groups.delete',
     'meta.state',
     'meta.get',
     'meta.enums',
@@ -1637,6 +1794,7 @@ export const API_METHOD_NAMES = [
     'meta.node.update',
     'meta.node.delete',
     'meta.refresh',
+    'meta.pairing',
     'meta.export',
     'meta.import',
     'paramset.get',

package/node_modules/@homematic-manager/backend/dist/config/defaults.js

@@ -112,10 +112,51 @@ export function normaliseConnection(input) {
         ...(metaProvider === undefined ? {} : { metaProvider }),
         ...(metaToken === '' ? {} : { metaToken }),
         ...(metaUrl === '' ? {} : { metaUrl }),
+        // B-70: a time the profile chose, or nothing - the host's default then applies
+        ...(typeof raw.idleUnsubscribeMs === 'number' &&
+            Number.isFinite(raw.idleUnsubscribeMs) &&
+            raw.idleUnsubscribeMs >= 0
+            ? { idleUnsubscribeMs: Math.round(raw.idleUnsubscribeMs) }
+            : {}),
+        ...systemTrustOf(raw.systemTrust),
     };
     const auth = normaliseAuth(raw.auth);
     return auth === undefined ? connection : { ...connection, auth };
 }
+/**
+ * B-67: the certificates the profile trusts on the system. A fingerprint is 32 bytes of hex in
+ * any spelling, stored as `AB:CD:…`; a CA is kept only as a PEM certificate. Nothing else, and
+ * nothing twice - this is what decides whose certificate the app believes.
+ */
+function systemTrustOf(value) {
+    if (typeof value !== 'object' || value === null) {
+        return {};
+    }
+    const raw = value;
+    const certificates = [
+        ...new Set((Array.isArray(raw['certificates']) ? raw['certificates'] : [])
+            .filter((entry) => typeof entry === 'string')
+            .map((entry) => entry.replace(/[^0-9a-f]/gi, '').toUpperCase())
+            .filter((hex) => hex.length === 64)
+            .map((hex) => hex.match(/.{2}/g)?.join(':') ?? '')),
+    ];
+    const cas = [
+        ...new Set((Array.isArray(raw['cas']) ? raw['cas'] : [])
+            .filter((entry) => typeof entry === 'string')
+            .map((entry) => entry.trim())
+            .filter((pem) => /^-----BEGIN CERTIFICATE-----[\s\S]+-----END CERTIFICATE-----$/.test(pem))
+            .map((pem) => `${pem}\n`)),
+    ];
+    if (certificates.length === 0 && cas.length === 0) {
+        return {};
+    }
+    return {
+        systemTrust: {
+            ...(certificates.length === 0 ? {} : { certificates }),
+            ...(cas.length === 0 ? {} : { cas }),
+        },
+    };
+}
 function normaliseAuth(value) {
     if (typeof value !== 'object' || value === null) {
         return undefined;

package/node_modules/@homematic-manager/backend/dist/groups/client.d.ts

@@ -0,0 +1,76 @@
+/**
+ * Task 57: the HTTP client for openccu-lite's heating groups - `/api/system/v1/groups`.
+ *
+ * The heating groups (the `VirtualDevices` group devices `INT000000N`) are the group process's,
+ * and that process has no RPC method to create one, change its members or delete it: the CCU's
+ * WebUI does all of that through the process's own HTTP pages, behind a WebUI session. On
+ * openccu-lite the box's `occulited` is the one client of those pages and offers them as a plain
+ * JSON API with the box's own login - the one this application already has for the metadata store
+ * (D-40). This client speaks that API and nothing else; on a CCU it is never built.
+ *
+ * Like the metadata client: `fetch` and `AbortSignal` only, a typed answer or a thrown
+ * {@link BackendError} whose `kind` says what the UI should make of it. The box's error body
+ * (`{error, message}`) is kept, because its message is the one worth showing - "there is no group
+ * 7", "members: hmipserver's device ids, as GET /groups/types lists them".
+ */
+import type { HeatingGroupChange, HeatingGroupDetail, HeatingGroupList, HeatingGroupMember, HeatingGroupType, HeatingGroupsState } from '@homematic-manager/core';
+import { BackendError } from '../errors.js';
+/**
+ * How long a call may take. A change makes the box's group process configure direct links, and the
+ * box itself waits up to thirty seconds for that process before it answers `502`; this has to
+ * outlast it, or the UI reports a timeout for a change that went through.
+ */
+export declare const GROUPS_TIMEOUT_MS = 45000;
+export interface HeatingGroupsClientOptions {
+    /** `http://ccu` or `http://127.0.0.1` - scheme and authority, no path. */
+    readonly baseUrl: string;
+    /**
+     * The credential every call goes out with. Reads need the box's `system:read`, changes
+     * `system:write`: the person's session on the box, or the API token off it. Never the addon's
+     * local token by choice - it reads metadata and nothing else, and the box answers 403.
+     */
+    readonly credential: () => string | undefined;
+    readonly timeoutMs?: number;
+    /** Injected by the tests. */
+    readonly fetch?: typeof globalThis.fetch;
+}
+/** The box refused or could not answer; `status` and `code` are what it said. */
+export declare class HeatingGroupsApiError extends BackendError {
+    readonly status: number;
+    /** The API's error word: `unknown-group`, `invalid`, `unsupported`, `hmipserver`, `forbidden`. */
+    readonly code: string;
+    constructor(status: number, code: string, message: string);
+}
+export declare class HeatingGroupsClient {
+    #private;
+    constructor(options: HeatingGroupsClientOptions);
+    get baseUrl(): string;
+    /**
+     * Does this box have the groups API, and may this credential read it? One `GET /groups`; the
+     * answer's status is the whole result. Never throws: the state is what the UI decides the tab by.
+     */
+    probe(): Promise<HeatingGroupsState>;
+    /**
+     * `GET /groups`, then each group once for its members - the list itself names none, and a
+     * grid of groups without their members would say nothing. A group whose detail fails (deleted
+     * between the two calls) is listed without members rather than failing the list.
+     */
+    list(): Promise<HeatingGroupList>;
+    /** `GET /groups/types` - what a new group can be, and what each type could take now. */
+    types(): Promise<HeatingGroupType[]>;
+    /** `GET /groups/{id}`. */
+    get(id: number): Promise<HeatingGroupDetail>;
+    /** `POST /groups` - the box's `create` then `save`, and the metadata side effects in one go. */
+    create(name: string, type: string, members: readonly string[]): Promise<HeatingGroupChange>;
+    /**
+     * `PUT /groups/{id}` - the name and the members as a whole; a field left out keeps its value.
+     * Adding and removing is this call with the new list, exactly as the WebUI saved it.
+     */
+    update(id: number, change: {
+        readonly name?: string | undefined;
+        readonly members?: readonly string[] | undefined;
+    }): Promise<HeatingGroupChange>;
+    /** `DELETE /groups/{id}` - answers with the former members, whose group membership is gone. */
+    remove(id: number): Promise<HeatingGroupMember[]>;
+}
+//# sourceMappingURL=client.d.ts.map