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

package/node_modules/@homematic-manager/core/dist/data/types.d.ts

@@ -44,7 +44,58 @@ export interface LinkProfile {
     description: Localized;
     /** Parameters this profile sets or restricts; everything else keeps its current value. */
     params: Record<string, ProfileConstraint>;
+    /**
+     * Task 62 (D-54): the controls the CCU's own easy mode draws for this profile, in its order,
+     * extracted from the WebUI's easymode TCL. Absent where the extraction found no form; the
+     * dialog then shows every parameter.
+     */
+    controls?: EasyControl[];
 }
+/**
+ * One control of the CCU easy mode's form of a profile (task 62). `requires` lists parameters the
+ * WebUI checks with `info exists` before drawing it; `label` is the WebUI's own row text where it
+ * could be resolved, otherwise the dialog uses the parameter's name.
+ */
+export type EasyControl = {
+    /**
+     * One duration over `<prefix>_BASE` / `<prefix>_FACTOR` (a link's `SHORT_ON_TIME`) or
+     * `<prefix>_UNIT` / `<prefix>_VALUE` (an HmIP MASTER parameter such as `EVENT_DELAY`).
+     */
+    kind: 'time';
+    prefix: string;
+    /** The preset list, a key of the time selector file (`timeOnOff`, `rampOnOff`, ...). */
+    selector: string;
+    label?: Localized;
+    requires?: string[];
+} | {
+    kind: 'param';
+    param: string;
+    /** Further parameters the WebUI writes the same value to (`SHORT_ON_LEVEL|LONG_ON_LEVEL`). */
+    also?: string[];
+    /** The WebUI's option set for the combo box, an `OptionPreset.id`. */
+    option?: string;
+    label?: Localized;
+    requires?: string[];
+} | {
+    /** One choice among `LinkSenderMetadata.subsets`, by id. */
+    kind: 'subset';
+    subsets: number[];
+    label?: Localized;
+    /** The choices' names, in the order of `subsets`. */
+    names?: Array<Localized | null>;
+    requires?: string[];
+};
+/**
+ * One entry of a time selector: a duration in seconds, or `notActive` (0), `permanent` (the pair's
+ * maximum) or `enterValue` (show the raw base and factor).
+ */
+export type TimeSelectorOption = ({
+    seconds: number;
+} | {
+    special: 'notActive' | 'permanent' | 'enterValue';
+}) & {
+    label?: Localized;
+};
 /**
  * One group of link parameters the WebUI offers as a preset value, e.g. "switch on immediately"
  * versus "switch on after the ramp": picking `optionValue` writes `values` to `params`.
@@ -94,6 +145,11 @@ export interface MasterMetadata {
         labelKey?: string;
         parameters: string[];
     }>;
+    /**
+     * Task 63 (D-55): the controls the CCU's own MASTER form draws for this channel type, in its
+     * order, extracted from the WebUI like `LinkProfile.controls`. Absent where there is no form.
+     */
+    controls?: EasyControl[];
 }
 export interface OptionPresetEntry {
     /** Literal label such as `5s`; `labelKey` refers to `Translations.uiLabels`. */
@@ -171,6 +227,8 @@ export interface DataSource {
     crossValidations(): Promise<CrossValidationRule[]>;
     translations(language: Language): Promise<Translations | undefined>;
     deviceIcons(): Promise<DeviceIcons>;
+    /** Task 62: the presets of each easy-mode time selector type; empty when the file is missing. */
+    timeSelectors(): Promise<Record<string, TimeSelectorOption[]>>;
 }
 /**
  * File layout the pipeline writes under `data/dist/` and every `DataSource` reads:
@@ -183,6 +241,7 @@ export interface DataSource {
  *   cross-validations.json             CrossValidationRule[]
  *   translations/<language>.json       Translations
  *   device-icons.json                  DeviceIcons
+ *   easymode-time-selectors.json       {source, types: Record<type, TimeSelectorOption[]>}
  */
 export declare const DATA_FILES: {
     readonly manifest: "manifest.json";
@@ -193,5 +252,6 @@ export declare const DATA_FILES: {
     readonly crossValidations: "cross-validations.json";
     readonly translations: (language: Language) => string;
     readonly deviceIcons: "device-icons.json";
+    readonly timeSelectors: "easymode-time-selectors.json";
 };
 //# sourceMappingURL=types.d.ts.map

package/node_modules/@homematic-manager/core/dist/data/types.js

@@ -18,6 +18,7 @@
  *   cross-validations.json             CrossValidationRule[]
  *   translations/<language>.json       Translations
  *   device-icons.json                  DeviceIcons
+ *   easymode-time-selectors.json       {source, types: Record<type, TimeSelectorOption[]>}
  */
 export const DATA_FILES = {
     manifest: 'manifest.json',
@@ -28,5 +29,6 @@ export const DATA_FILES = {
     crossValidations: 'cross-validations.json',
     translations: (language) => `translations/${language}.json`,
     deviceIcons: 'device-icons.json',
+    timeSelectors: 'easymode-time-selectors.json',
 };
 //# sourceMappingURL=types.js.map

package/node_modules/@homematic-manager/core/dist/devices/index.d.ts

@@ -40,6 +40,18 @@ export interface DeviceDescription {
     readonly INDEX?: number;
     readonly SUBTYPE?: string;
 }
+/**
+ * One value of a list field as a list of strings: an array keeps its string entries, a string
+ * becomes its whitespace- or comma-separated words (`"MASTER VALUES"` is two paramsets, `"MASTER"`
+ * is one), and anything else - a number, an object, null - is nothing.
+ */
+export declare function asStringList(value: unknown): string[] | undefined;
+/**
+ * A description as it arrives from an interface process, with its list fields made into lists
+ * (#143). Everything else is passed through untouched: what a field means is the interface's
+ * business, only its *shape* is ours, and only where the UI iterates over it.
+ */
+export declare function normaliseDescription(entry: DeviceDescription): DeviceDescription;
 /** `FLAGS` bits of a device description. */
 export declare const DEVICE_FLAGS: {
     readonly VISIBLE: 1;
@@ -72,6 +84,13 @@ export declare const RX_MODES: {
  * by itself and one that does not (task 6).
  */
 export declare function decodeRxMode(rxMode: number | undefined): string[];
+/**
+ * Is roaming on for this device? rfd reports `ROAMING` as `1`/`0` over BIN-RPC and as a boolean
+ * over XML-RPC, so both spellings mean yes.
+ */
+export declare function isRoaming(device: {
+    readonly ROAMING?: boolean | number | undefined;
+}): boolean;
 /** `DIRECTION` of a channel. */
 export declare const DIRECTIONS: readonly ["NONE", "SENDER", "RECEIVER"];
 /** Decodes `DIRECTION`; anything unexpected is `NONE`, as the 2.x grid did. */

package/node_modules/@homematic-manager/core/dist/devices/index.js

@@ -7,6 +7,52 @@
  * is one immutable index built once per `listDevices` answer.
  */
 import { compareAddresses, MAINTENANCE_CHANNEL, tryParseAddress } from '../address/address.js';
+/**
+ * The fields of a description that are lists of strings. What an interface process actually sends
+ * for them is not guaranteed: the CCU's group process (`VirtualDevices`) answers `PARAMSETS` as a
+ * plain string on some boxes, and a `?? []` guard does not catch that - `.filter` on a string
+ * throws, and in a reactive grid one throw takes the whole page down (#143: the device list stayed
+ * on "Loading Homematic Manager..." while the count beside it said 31).
+ */
+const LIST_FIELDS = ['CHILDREN', 'PARAMSETS', 'TEAM_CHANNELS'];
+/**
+ * One value of a list field as a list of strings: an array keeps its string entries, a string
+ * becomes its whitespace- or comma-separated words (`"MASTER VALUES"` is two paramsets, `"MASTER"`
+ * is one), and anything else - a number, an object, null - is nothing.
+ */
+export function asStringList(value) {
+    if (Array.isArray(value)) {
+        return value.filter((entry) => typeof entry === 'string');
+    }
+    if (typeof value === 'string') {
+        const words = value.split(/[\s,]+/).filter((word) => word !== '');
+        return words.length > 0 ? words : [];
+    }
+    return undefined;
+}
+/**
+ * A description as it arrives from an interface process, with its list fields made into lists
+ * (#143). Everything else is passed through untouched: what a field means is the interface's
+ * business, only its *shape* is ours, and only where the UI iterates over it.
+ */
+export function normaliseDescription(entry) {
+    let patch;
+    for (const field of LIST_FIELDS) {
+        const value = entry[field];
+        if (value === undefined || Array.isArray(value)) {
+            continue;
+        }
+        const list = asStringList(value);
+        patch ??= {};
+        if (list === undefined) {
+            patch[field] = undefined;
+        }
+        else {
+            patch[field] = list;
+        }
+    }
+    return patch === undefined ? entry : { ...entry, ...patch };
+}
 /** `FLAGS` bits of a device description. */
 export const DEVICE_FLAGS = {
     VISIBLE: 1,
@@ -55,6 +101,13 @@ export function decodeRxMode(rxMode) {
     }
     return names;
 }
+/**
+ * Is roaming on for this device? rfd reports `ROAMING` as `1`/`0` over BIN-RPC and as a boolean
+ * over XML-RPC, so both spellings mean yes.
+ */
+export function isRoaming(device) {
+    return device.ROAMING === true || device.ROAMING === 1;
+}
 /** `DIRECTION` of a channel. */
 export const DIRECTIONS = ['NONE', 'SENDER', 'RECEIVER'];
 /** Decodes `DIRECTION`; anything unexpected is `NONE`, as the 2.x grid did. */

package/node_modules/@homematic-manager/core/dist/easymodes/engine.d.ts

@@ -11,7 +11,7 @@
  * parameters, which of them only make sense with a certain value of another one, the typical
  * values for a delay or a level, and rules between parameters.
  */
-import type { DataSource, LinkProfile, LinkSenderMetadata, OptionPreset } from '../data/types.js';
+import type { DataSource, EasyControl, LinkProfile, LinkSenderMetadata, OptionPreset } from '../data/types.js';
 import { type ParameterDescription, type ParamsetDescription } from '../paramset/description.js';
 import type { Paramset, ParamsetValue } from '../rpc/values.js';
 /** The parameter the CCU stores the chosen profile in, inside the receiver's LINK paramset. */
@@ -57,6 +57,8 @@ export interface MasterView {
     /** In display order: the metadata's order first, then the rest by `TAB_ORDER`. */
     readonly parameters: readonly MasterParameterView[];
     readonly problems: readonly CrossValidationProblem[];
+    /** Task 63: the CCU's MASTER form of the channel type, where the data has one. */
+    readonly controls?: readonly EasyControl[];
 }
 /** Reads the easy-mode data through a `DataSource` and answers the dialogs' questions. */
 export declare class EasyModeEngine {

package/node_modules/@homematic-manager/core/dist/easymodes/engine.js

@@ -144,6 +144,7 @@ export class EasyModeEngine {
         return {
             channelType,
             parameters,
+            ...(metadata?.controls ? { controls: metadata.controls } : {}),
             problems: rules
                 .filter((rule) => appliesTo(rule, description))
                 .filter((rule) => !holds(rule, values))

package/node_modules/@homematic-manager/core/dist/easymodes/form.d.ts

@@ -0,0 +1,43 @@
+import type { EasyControl, LinkParameterSubset, LinkProfile, Localized } from '../data/types.js';
+import type { ParamsetDescription } from '../paramset/description.js';
+import { type DurationPair } from '../paramset/time.js';
+/**
+ * Tasks 62 and 63 (D-54, D-55): the CCU easy mode's form, for one device.
+ *
+ * The extracted controls - a link profile's (`LinkProfile.controls`) or a channel type's MASTER
+ * form (`MasterMetadata.controls`) - are the union of every branch the WebUI's Tcl can take. What
+ * a device actually shows depends on its description: a control whose parameter, time pair or
+ * `requires` the description lacks is not on its form - the colour selector of an optical-signal
+ * device on a plain dimmer, say.
+ */
+export type EasyFormControl = {
+    kind: 'time';
+    pair: DurationPair;
+    selector: string;
+    label?: Localized;
+} | {
+    kind: 'param';
+    param: string;
+    also: string[];
+    option?: string;
+    label?: Localized;
+} | {
+    kind: 'subset';
+    subsets: number[];
+    names?: Array<Localized | null>;
+    label?: Localized;
+};
+/**
+ * The form of a list of controls on this device, in the WebUI's order; `undefined` when there are
+ * none or nothing of them applies, which is the dialogs' cue to show every parameter.
+ */
+export declare function easyFormOf(controls: readonly EasyControl[] | undefined, description: ParamsetDescription): EasyFormControl[] | undefined;
+/** A link profile's form on this device (task 62). */
+export declare function easyForm(profile: LinkProfile | undefined, description: ParamsetDescription): EasyFormControl[] | undefined;
+/**
+ * Every parameter the form edits: both halves of each time pair, each combo box's parameter and
+ * the ones it writes along, and the members of the offered subsets. The expert view highlights
+ * exactly these rows.
+ */
+export declare function easyFormParams(form: readonly EasyFormControl[] | undefined, subsets?: readonly LinkParameterSubset[]): Set<string>;
+//# sourceMappingURL=form.d.ts.map

package/node_modules/@homematic-manager/core/dist/easymodes/form.js

@@ -0,0 +1,84 @@
+import { findDurationPairs } from '../paramset/time.js';
+function withLabel(control, label) {
+    return label === undefined ? control : { ...control, label };
+}
+/**
+ * The form of a list of controls on this device, in the WebUI's order; `undefined` when there are
+ * none or nothing of them applies, which is the dialogs' cue to show every parameter.
+ */
+export function easyFormOf(controls, description) {
+    // a time control names the pair by its prefix: `SHORT_ON_TIME` for `SHORT_ON_TIME_BASE`, and
+    // `EVENT_DELAY` for `EVENT_DELAY_UNIT` - both are among the description's duration pairs
+    const pairs = new Map(findDurationPairs(description).map((pair) => [pair.unitParam, pair]));
+    const form = [];
+    for (const control of controls ?? []) {
+        if (!(control.requires ?? []).every((param) => param in description)) {
+            continue;
+        }
+        switch (control.kind) {
+            case 'time': {
+                const pair = pairs.get(`${control.prefix}_BASE`) ?? pairs.get(`${control.prefix}_UNIT`);
+                if (pair) {
+                    form.push(withLabel({ kind: 'time', pair, selector: control.selector }, control.label));
+                }
+                break;
+            }
+            case 'param': {
+                if (control.param in description) {
+                    const also = (control.also ?? []).filter((param) => param in description);
+                    const entry = {
+                        kind: 'param',
+                        param: control.param,
+                        also,
+                        ...(control.option === undefined ? {} : { option: control.option }),
+                    };
+                    form.push(withLabel(entry, control.label));
+                }
+                break;
+            }
+            case 'subset': {
+                const entry = {
+                    kind: 'subset',
+                    subsets: control.subsets,
+                    ...(control.names === undefined ? {} : { names: control.names }),
+                };
+                form.push(withLabel(entry, control.label));
+                break;
+            }
+        }
+    }
+    return form.length > 0 ? form : undefined;
+}
+/** A link profile's form on this device (task 62). */
+export function easyForm(profile, description) {
+    return easyFormOf(profile?.controls, description);
+}
+/**
+ * Every parameter the form edits: both halves of each time pair, each combo box's parameter and
+ * the ones it writes along, and the members of the offered subsets. The expert view highlights
+ * exactly these rows.
+ */
+export function easyFormParams(form, subsets = []) {
+    const params = new Set();
+    for (const control of form ?? []) {
+        if (control.kind === 'time') {
+            params.add(control.pair.unitParam);
+            params.add(control.pair.countParam);
+        }
+        else if (control.kind === 'param') {
+            params.add(control.param);
+            for (const param of control.also)
+                params.add(param);
+        }
+        else {
+            for (const subset of subsets) {
+                if (control.subsets.includes(subset.id)) {
+                    for (const param of subset.params)
+                        params.add(param);
+                }
+            }
+        }
+    }
+    return params;
+}
+//# sourceMappingURL=form.js.map

package/node_modules/@homematic-manager/core/dist/i18n/messages.js

@@ -297,6 +297,22 @@ export const MESSAGES = {
         de: 'Über Homematic Manager',
         en: 'about Homematic Manager',
     },
+    'Saving and reconnecting…': {
+        de: 'Wird gespeichert, die Verbindung wird neu aufgebaut…',
+        en: 'Saving and reconnecting…',
+    },
+    'This tab could not be drawn.': {
+        de: 'Dieser Reiter konnte nicht gezeichnet werden.',
+        en: 'This tab could not be drawn.',
+    },
+    'Try again': {
+        de: 'Erneut versuchen',
+        en: 'Try again',
+    },
+    'The device list could not be read - press Refresh to try again': {
+        de: 'Die Geräteliste konnte nicht gelesen werden - mit Aktualisieren erneut versuchen',
+        en: 'The device list could not be read - press Refresh to try again',
+    },
     'Loading Homematic Manager...': {
         de: 'Lade Homematic Manager...',
         en: 'Loading Homematic Manager...',
@@ -391,6 +407,51 @@ export const MESSAGES = {
         de: 'Schreibe {paramset} von {address}',
         en: 'Writing {paramset} of {address}',
     },
+    // The RPC log drawer (task 22; every outgoing call and its origin since task 48).
+    'RPC log': {
+        de: 'RPC-Protokoll',
+        en: 'RPC log',
+    },
+    'No RPC calls yet': {
+        de: 'Noch keine RPC-Aufrufe',
+        en: 'No RPC calls yet',
+    },
+    'in progress': {
+        de: 'läuft',
+        en: 'in progress',
+    },
+    Clear: {
+        de: 'Leeren',
+        en: 'Clear',
+    },
+    Close: {
+        de: 'Schließen',
+        en: 'Close',
+    },
+    'Resize the RPC log': {
+        de: 'Größe des RPC-Protokolls ändern',
+        en: 'Resize the RPC log',
+    },
+    'Hide background calls': {
+        de: 'Hintergrundaufrufe ausblenden',
+        en: 'Hide background calls',
+    },
+    'Open in console': {
+        de: 'In der Konsole öffnen',
+        en: 'Open in console',
+    },
+    'Origin: console': {
+        de: 'Konsole',
+        en: 'console',
+    },
+    'Origin: UI': {
+        de: 'UI',
+        en: 'UI',
+    },
+    'Origin: background': {
+        de: 'Hintergrund',
+        en: 'background',
+    },
 };
 /** The keys the catalogue knows, for the completeness test and for tooling. */
 export const MESSAGE_KEYS = Object.keys(MESSAGES);

package/node_modules/@homematic-manager/core/dist/index.d.ts

@@ -16,6 +16,7 @@ export * from './devices/index.js';
 export * from './links/roles.js';
 export * from './rpc/values.js';
 export * from './rpc/methods.js';
+export * from './rpc/text.js';
 export * from './paramset/description.js';
 export * from './paramset/units.js';
 export * from './paramset/time.js';
@@ -24,9 +25,11 @@ export * from './paramset/validate.js';
 export * from './paramset/diff.js';
 export * from './paramset/multiApply.js';
 export * from './easymodes/engine.js';
+export * from './easymodes/form.js';
 export * from './serviceMessages/index.js';
 export * from './rssi/index.js';
 export * from './events/ringBuffer.js';
+export * from './meta/index.js';
 export * from './i18n/messages.js';
 export * from './i18n/translate.js';
 export * from './i18n/lookup.js';

package/node_modules/@homematic-manager/core/dist/index.js

@@ -19,6 +19,7 @@ export * from './links/roles.js';
 // Values and the write path (task 6)
 export * from './rpc/values.js';
 export * from './rpc/methods.js';
+export * from './rpc/text.js';
 export * from './paramset/description.js';
 export * from './paramset/units.js';
 export * from './paramset/time.js';
@@ -28,10 +29,13 @@ export * from './paramset/diff.js';
 export * from './paramset/multiApply.js';
 // Easy modes and the MASTER metadata layer
 export * from './easymodes/engine.js';
+export * from './easymodes/form.js';
 // State the tabs show
 export * from './serviceMessages/index.js';
 export * from './rssi/index.js';
 export * from './events/ringBuffer.js';
+// The openccu-lite metadata store (task 24): names, rooms and functions as data
+export * from './meta/index.js';
 // Texts
 export * from './i18n/messages.js';
 export * from './i18n/translate.js';

package/node_modules/@homematic-manager/core/dist/interfaces/table.d.ts

@@ -53,11 +53,20 @@ export interface InterfaceDefinition {
      * re-`init`, which on an idle CCU addon was the only thing in the log. **HmIP-RF** does not
      * have the method either - hmipserver reports neither `rssiInfo` nor `getServiceMessages`, so
      * its service messages are read out of the `VALUES` paramset of every `:0` channel instead.
+     * **CUxD** has no such method either (B-26, #158): it answers `unknown.method name` and writes a
+     * warning into the CCU's syslog for every call.
      *
-     * Omitted means yes. A user-defined interface is unknown territory and is therefore tried
-     * once; the backend remembers a method-not-found or an unparseable answer for that session.
+     * Omitted means yes. A user-defined interface is unknown territory: the backend looks the
+     * method up in its `system.listMethods` where it has one, and otherwise tries it once and
+     * remembers a method-not-found or an unparseable answer for that session.
      */
     readonly serviceMessages?: boolean;
+    /**
+     * Has an install mode: devices can be paired to it (task 28). Omitted means yes. The CCU's
+     * group process behind **VirtualDevices** and **CUxD** create their devices themselves and
+     * have nothing to pair, so the Devices tab's "Pair device" is disabled there.
+     */
+    readonly installMode?: boolean;
     /** A fixed `init` identity string; only CUxD has one (it matches on the literal `CUxD`). */
     readonly ident?: string;
 }
@@ -110,6 +119,7 @@ export declare const INTERFACES: {
         readonly init: true;
         readonly ping: false;
         readonly serviceMessages: false;
+        readonly installMode: false;
     };
     readonly CUxD: {
         readonly name: "CUxD";
@@ -118,6 +128,8 @@ export declare const INTERFACES: {
         readonly init: true;
         readonly ping: true;
         readonly ident: "CUxD";
+        readonly serviceMessages: false;
+        readonly installMode: false;
     };
 };
 /** Name of a built-in interface. */
@@ -174,6 +186,9 @@ export interface ResolvedInterface {
  * | `protocol` | `xmlrpc` |
  * | `path` | `/RPC3` |
  *
+ * and its name has to be in `ConnectionConfig.interfaces` as well, like any interface that is to be
+ * connected - the settings dialog ticks a newly added one there by itself.
+ *
  * No code is needed for it, which is why there is none: the only thing #135 wanted that was missing
  * is a `path`, and a user-defined interface has had one since task 4.
  */
@@ -192,6 +207,12 @@ export interface UserDefinedInterface {
 export declare function isKnownInterface(name: string): name is InterfaceName;
 /** The built-in definition, or `undefined` for a name the table does not know. */
 export declare function interfaceDefinition(name: string): InterfaceDefinition | undefined;
+/**
+ * Whether devices can be paired to an interface of this type (task 28). Only a built-in interface
+ * that says it has no install mode is refused; a user-defined one - Homegear, a bare rfd - and a
+ * type that is not known yet get the pairing dialog, and the process behind them has the last word.
+ */
+export declare function canPairDevices(type: string): boolean;
 /**
  * The identity string passed to `init(url, ident)` and sent back with every callback, which is how
  * the callback server tells the interfaces apart. `hmm_<name>` for everything except CUxD, which

package/node_modules/@homematic-manager/core/dist/interfaces/table.js

@@ -66,6 +66,8 @@ export const INTERFACES = {
         ping: false,
         // ... and it has no getServiceMessages either: it answers that one with invalid XML-RPC
         serviceMessages: false,
+        // groups are made by the CCU, not paired (task 28)
+        installMode: false,
     },
     CUxD: {
         name: 'CUxD',
@@ -75,6 +77,12 @@ export const INTERFACES = {
         ping: true,
         // CUxD matches the init identity against the literal string, `hmm_CUxD` is ignored
         ident: 'CUxD',
+        // no getServiceMessages: CUxD answers `getServiceMessages: unknown.method name` (-1) and logs
+        // `called unknown request method 'getServiceMessages'` as daemon.warn for every call - with
+        // the five-minute poll, a warning in the CCU's syslog every five minutes (B-26, #158)
+        serviceMessages: false,
+        // its devices are created in its own configuration, not paired (task 28)
+        installMode: false,
     },
 };
 /** The built-in interfaces in table order. */
@@ -93,6 +101,14 @@ export function isKnownInterface(name) {
 export function interfaceDefinition(name) {
     return isKnownInterface(name) ? INTERFACES[name] : undefined;
 }
+/**
+ * Whether devices can be paired to an interface of this type (task 28). Only a built-in interface
+ * that says it has no install mode is refused; a user-defined one - Homegear, a bare rfd - and a
+ * type that is not known yet get the pairing dialog, and the process behind them has the last word.
+ */
+export function canPairDevices(type) {
+    return interfaceDefinition(type)?.installMode !== false;
+}
 /**
  * The identity string passed to `init(url, ident)` and sent back with every callback, which is how
  * the callback server tells the interfaces apart. `hmm_<name>` for everything except CUxD, which
@@ -170,7 +186,8 @@ export function resolveUserDefinedInterface(definition) {
         ping: true,
         pingTimeoutSeconds: DEFAULT_PING_TIMEOUT_SECONDS,
         dutyCycle: false,
-        // tried once: what a hand-configured process implements is not knowable from here
+        // what a hand-configured process implements is not knowable from here; the backend asks its
+        // `system.listMethods`, or tries the method once
         serviceMessages: true,
     };
 }

package/node_modules/@homematic-manager/core/dist/meta/document.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Reading, validating and comparing a whole metadata document.
+ *
+ * A document arrives from three places - the box's `/snapshot`, a file this application wrote
+ * itself, and an import a user picked - and all three go through here. The rule of the format is
+ * that a document is validated **as a whole and rejected entirely** on the first error, because
+ * half an import is worse than none: the enums an object refers to have to exist, and that is not
+ * a property of any single entry.
+ *
+ * Every refusal is a {@link MetaError} with the code the specification names, so an import dialog
+ * can say "room/nowhere does not exist" rather than "invalid".
+ */
+import { MetaError, type MetaDocument, type MetaEnum, type MetaNode, type MetaObject } from './types.js';
+/**
+ * One object, checked and brought into the shape the store keeps.
+ *
+ * `enums` and `meta` always exist afterwards; `orphaned` only when it is true, which is what
+ * `occulited` serialises and therefore what a byte comparison of two documents needs.
+ */
+export declare function normaliseObject(raw: unknown): MetaObject;
+/** The `enums` array: strings that look like paths, without duplicates. Existence is checked later. */
+export declare function normaliseEnumList(raw: unknown): readonly string[];
+/**
+ * The `meta` block: one key per consumer namespace, any JSON below it.
+ *
+ * The store never interprets what is in there - that is the point of the namespace - so the only
+ * rules are the spelling of the key and the size of the whole block.
+ */
+export declare function normaliseMeta(raw: unknown): Readonly<Record<string, unknown>>;
+/** One node and its subtree, checked. Sibling ids are unique; depth is checked by the caller. */
+export declare function normaliseNode(raw: unknown): MetaNode;
+/** A list of siblings: every one checked, no id twice. */
+export declare function normaliseNodes(raw: unknown): readonly MetaNode[];
+/** One enum: a localised name with at least `en`, and its tree. */
+export declare function normaliseEnum(id: string, raw: unknown): MetaEnum;
+/**
+ * The localised name of an enum.
+ *
+ * `en` is required: it is the fallback every consumer falls back to, and an enum that has only a
+ * German name is unreadable in an English UI - the corpus refuses exactly that with `invalid-name`.
+ */
+export declare function normaliseEnumName(raw: unknown): Readonly<Record<string, string>>;
+/**
+ * A whole document, validated and normalised - the one entry point for anything untrusted.
+ *
+ * The order of the checks is the order of the specification's error codes: the format version
+ * first (a newer store is not something to guess at), then the enums, then the objects against the
+ * paths the enums define.
+ */
+export declare function parseDocument(raw: unknown): MetaDocument;
+/** Every node path of every enum - what an object's `enums` entries are checked against. */
+export declare function knownPaths(enums: Readonly<Record<string, MetaEnum>>): Set<string>;
+/**
+ * A document as JSON with its keys sorted, which is how two of them are compared.
+ *
+ * The format says key order is not significant and that a writer should sort for stable diffs, so
+ * sorting is both the comparison and the file this application writes. It is also the answer to
+ * "did this import change anything": an import whose result equals the document is not a revision.
+ */
+export declare function documentJson(document: MetaDocument, space?: number): string;
+/** Do two documents hold the same data? `revision` is not part of the answer. */
+export declare function documentEquals(a: MetaDocument, b: MetaDocument): boolean;
+/**
+ * A document out of anything, never throwing: a broken file becomes an empty store.
+ *
+ * The format says a reader that finds the document unparsable falls back to the `.bak` and reports
+ * that it did, never starts empty silently - so the caller gets the error and decides. This is the
+ * "and then what" for a caller that has already tried both files.
+ */
+export declare function parseDocumentOrEmpty(raw: unknown, onError?: (error: MetaError) => void): MetaDocument;
+//# sourceMappingURL=document.d.ts.map