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

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

@@ -11,6 +11,7 @@ import type { RpcProtocol, UserDefinedInterface } from '../interfaces/table.js';
 import type { ParamsetDescription } from '../paramset/description.js';
 import type { Paramset, ParamsetWrite, RpcWriteValue } from '../rpc/values.js';
 import type { LanguageChoice } from '../data/types.js';
+import type { MetaDocument, MetaEnum, MetaImportMode, MetaNodePatch } from '../meta/types.js';
 /** Any value an interface process returns: XML-RPC / BIN-RPC scalars, arrays and structs. */
 export type RpcValue = boolean | number | string | RpcValue[] | {
     [key: string]: RpcValue;
@@ -37,7 +38,42 @@ export interface ConnectionConfig {
     };
     /** ReGa is optional (D-2): names come from ReGa when present, else from the local store. */
     rega: boolean;
-    /** Address and ports the interface processes call back to; `0` picks free ports. */
+    /**
+     * D-40: where names, rooms and functions come from.
+     *
+     * `auto` (the default, and what every existing profile means) probes
+     * `GET /api/meta/v1/version` on the configured host once per connect: an openccu-lite box
+     * answers and its store is used, a CCU answers 404 and nothing changes. `local` never probes
+     * and keeps everything in this profile; `occulite` insists on the box and says so when it is
+     * not there, which is what a user behind a proxy that swallows the probe needs.
+     *
+     * `rega` (task 27) is the CCU's own rooms and functions through ReGaHSS: `auto` picks it when
+     * there is no box and ReGa (switched on with `rega` above) answered, so a CCU gets the same
+     * editing UI the box has, on ReGa's own objects. A box either has ReGa or the metadata API,
+     * never both.
+     */
+    metaProvider?: MetaProviderChoice;
+    /**
+     * The API token for the metadata store, for an installation that is **not** on the box.
+     *
+     * Created on the box's Users page (`olt_…`, role `user` reads, `admin` also writes) and stored
+     * like any other credential here. On the box itself this stays empty: the addon reads the local
+     * token from `/usr/local/etc/occulite/local-token` for reads and uses the session of whoever
+     * opened the page for writes.
+     */
+    metaToken?: string;
+    /**
+     * The box's base URL, when it is not `http(s)://<host>`.
+     *
+     * For a reverse proxy on another port and for the integration tests. Empty means "derive it
+     * from `host`, `tls` and `local`", which is what every real installation wants.
+     */
+    metaUrl?: string;
+    /**
+     * Address and ports the interface processes call back to. A port of `0` is "none configured":
+     * the host's default port where it has one (the CCU addon's fixed pair, task 35), a free port
+     * from the kernel everywhere else.
+     */
     callback: {
         ip: string;
         xmlrpcPort: number;
@@ -90,7 +126,99 @@ export interface AppConfig {
     localAddresses: string[];
     /** CCUs found by UDP discovery (host names or addresses with what answered). */
     discovered: DiscoveredCcu[];
+    /**
+     * Task 35 (D-43): the callback ports this host takes while `connection.callback` says `0`. Only
+     * the CCU addon has them; absent, a `0` is a free port. A property of the host, never written
+     * to the profile, so the settings dialog can say what `0` means without changing what it saves.
+     */
+    callbackDefaultPorts?: {
+        xmlrpc: number;
+        binrpc: number;
+    };
+    /**
+     * Task 38: the callback fields the host was started with (`HMM_CALLBACK_*` or `--callback-*`).
+     * Such a value wins over the profile's, the backend never saves another one over it, and the
+     * settings dialog shows it read-only with the option that set it ({@link CALLBACK_PIN_OPTIONS}).
+     * Absent where the host pins nothing.
+     */
+    callbackPinned?: CallbackPins;
+    /**
+     * Task 38: the host runs in a container and its callback servers listen beyond the loopback,
+     * so the ports the interfaces are told only work when they are published unchanged. The
+     * interface popup says so beside each callback URL. Absent everywhere else.
+     */
+    publishCallbackPorts?: boolean;
+}
+/**
+ * B-53 (#162, #165): why the automatic callback address is the one it is.
+ *
+ * - `loopback`: the interface processes are on this machine (`local`, or a CCU at `127.x`);
+ * - `subnet`: the address of this machine in the CCU's own network;
+ * - `route`: no address shares the CCU's network, so the one the operating system sends from
+ *   towards the CCU (a routed CCU, a VPN);
+ * - `first`: neither could be found out (no CCU configured, a name that does not resolve), so the
+ *   first address of this machine that is not link-local - the only rule there was until beta.18.
+ */
+export type CallbackAutoReason = 'loopback' | 'subnet' | 'route' | 'first';
+/** B-53: one address of this machine, as the settings dialog offers it. */
+export interface CallbackAddressCandidate {
+    address: string;
+    /** In the CCU's network (its `address/netmask` holds the CCU); always false while the CCU's address is unknown. */
+    inSubnet: boolean;
+    /** `169.254.0.0/16`: never chosen automatically unless the CCU is there too. */
+    linkLocal?: boolean;
 }
+/**
+ * B-53: what `config.callbackAddresses` answers - the address the backend takes when none is set,
+ * and every address of this machine with whether it is in the CCU's network.
+ */
+export interface CallbackAddressInfo {
+    /** The CCU host it was worked out for. */
+    host: string;
+    /** That host's IPv4 address; absent when it could not be resolved (or no host is set). */
+    hostAddress?: string;
+    auto: {
+        address: string;
+        reason: CallbackAutoReason;
+    };
+    /** The machine's IPv4 addresses in the operating system's order, the loopback last. */
+    addresses: CallbackAddressCandidate[];
+    /**
+     * The host takes a set address as it is, even one that is not on this machine: it was set at
+     * start (task 38) or the host runs in a container, where the Docker host's address is the right
+     * one. The dialog then warns about nothing.
+     */
+    keepsConfigured?: boolean;
+}
+/**
+ * B-53: a set callback address that does not fit. `notLocal`: it is no address of this machine
+ * any more (another lease, another network), so the automatic one is used instead. `otherNetwork`:
+ * it is one, but neither in the CCU's network nor the one this machine sends from towards the CCU;
+ * it is used as set, and the CCU may well not reach it.
+ */
+export interface CallbackWarning {
+    address: string;
+    reason: 'notLocal' | 'otherNetwork';
+    /** The address the automatic choice would take (and, for `notLocal`, takes). */
+    auto: string;
+}
+/** Task 38: which of `connection.callback`'s fields the host set at start. */
+export interface CallbackPins {
+    ip?: boolean;
+    xmlrpcPort?: boolean;
+    binrpcPort?: boolean;
+}
+/**
+ * Task 38: the environment variable and command-line option behind each callback field, for the
+ * settings dialog's read-only hint and the backend's log lines - one table, so the two cannot name
+ * different options.
+ */
+export declare const CALLBACK_PIN_OPTIONS: Readonly<Record<keyof CallbackPins, {
+    env: string;
+    cli: string;
+}>>;
+/** Task 38: `HMM_CALLBACK_XMLRPC_PORT / --callback-xmlrpc-port`, as the hint and the log write it. */
+export declare function callbackPinOption(field: keyof CallbackPins): string;
 export interface DiscoveredCcu {
     address: string;
     name?: string;
@@ -126,6 +254,13 @@ export interface InterfaceState {
      * retrying every 15 s, and the UI shows "not present" rather than a connection error.
      */
     absent?: boolean;
+    /**
+     * B-28: the interface did not answer in time - its `init` or the port probe timed out, or its
+     * host has no route. Not the same as {@link absent}: the process may well be there, only slow or
+     * away for a moment (a CCU-Jack, a remote CUxD). It stays configured and shown, the watchdog tries
+     * it again, and the UI says "not answering" and offers to try at once. Present only when true.
+     */
+    unreachable?: boolean;
     /**
      * `init` has been sent and the first `listDevices` / service-message sweep after it is still
      * running. The UI shows "subscribing" for as long as this is true: `hmipserver` re-sends every
@@ -138,6 +273,26 @@ export interface InterfaceState {
      * next session that connects subscribes again. Never set in Electron.
      */
     idle?: boolean;
+    /**
+     * Task 38: the URL this interface was told to call back on in its last `init` -
+     * `http://<callback ip>:<port>` for XML-RPC, `xmlrpc_bin://…` for BIN-RPC. Absent for an
+     * interface that takes no `init`, and while its callback server could not be opened.
+     */
+    callbackUrl?: string;
+    /**
+     * Task 38: the fixed callback port of this interface's protocol could not be opened, so it is
+     * not subscribed. `inUse` is the common case - another process holds the port - and there is no
+     * free port instead: a fixed port is the one that was published or opened in a firewall.
+     */
+    callbackFailure?: {
+        port: number;
+        inUse: boolean;
+    };
+    /**
+     * B-53: the callback address set in the settings does not fit this machine or the CCU's
+     * network. The interface popup shows it with a one-click switch to the automatic address.
+     */
+    callbackWarning?: CallbackWarning;
 }
 /**
  * Issue #26: how often a device went unreachable, kept per CCU across restarts.
@@ -191,6 +346,73 @@ export interface RegaState {
 }
 /** Friendly names: address -> name (devices and channels), from ReGa or the local store. */
 export type NameMap = Record<string, string>;
+/** D-40: which metadata provider a profile asks for; `rega` since task 27. */
+export type MetaProviderChoice = 'auto' | 'local' | 'occulite' | 'rega';
+/** The values of {@link MetaProviderChoice} as a runtime list, for validation and a select. */
+export declare const META_PROVIDERS: readonly MetaProviderChoice[];
+/**
+ * D-40: which store the names, rooms and functions come from, and whether it can be written.
+ *
+ * Shown next to the ReGa indicator, and for the same reason: a user has to be able to see where the
+ * name in the grid came from before they wonder why renaming it did not change anything in the
+ * other application.
+ */
+export interface MetaState {
+    /**
+     * `local` is this profile's own store, `occulite` an openccu-lite box, `rega` the CCU's own
+     * rooms and functions through ReGaHSS (task 27).
+     */
+    provider: 'local' | 'occulite' | 'rega';
+    /** For `occulite` and `rega`: the other side answered. Always true for `local`. */
+    reachable: boolean;
+    /**
+     * Writes are accepted.
+     *
+     * False on a box whose credential only has the `user` role - the local token of an addon, or a
+     * read-only API token - which is a normal state and not an error: the names are shown, the
+     * rename button says why it cannot be used.
+     */
+    writable: boolean;
+    /** The store's revision; `0` for a fresh one. */
+    revision: number;
+    /** How many devices and channels the store knows. */
+    objects: number;
+    /** `occulited 0.1.0`, from `/api/meta/v1/version`. */
+    implementation?: string;
+    /**
+     * The provider's taxonomies are flat lists: no node below another, no new taxonomy. The
+     * editing UI (task 25) hides "add below" and "move" then and says so. Absent means trees.
+     */
+    flat?: boolean;
+    /** The base URL the provider talks to, for the settings dialog and the log. */
+    url?: string;
+    error?: string;
+}
+/**
+ * One device or channel as the UI shows it: the name, the paths it is a member of, and those paths
+ * as the arrays of names every consumer of ReGa's rooms and functions has always been given.
+ *
+ * Keyed by **ref** (`<interface>.<address>`), not by address: the metadata store's identity is the
+ * ref, and two interfaces may in principle report the same address. `makeRef(interfaceName,
+ * address)` builds one.
+ */
+export interface MetaObjectView {
+    name: string;
+    /** Node paths, e.g. `room/eg/wohnzimmer`. */
+    enums: string[];
+    /** The names of the `room` nodes it belongs to, in tree order. */
+    rooms: string[];
+    /** The same for `function`. */
+    functions: string[];
+    /** The box says the address is no longer reported by any interface. */
+    orphaned?: boolean;
+}
+/** Everything the UI needs about the store in one answer: the state, the trees and the objects. */
+export interface MetaSnapshot {
+    state: MetaState;
+    enums: Record<string, MetaEnum>;
+    objects: Record<string, MetaObjectView>;
+}
 export interface LinkRecord {
     SENDER: string;
     RECEIVER: string;
@@ -311,7 +533,22 @@ export interface RepairConfigResult {
     /** The BidCos recovery that was called, if any. */
     bidcosRecovery?: 'clearConfigCache' | 'restoreConfigToDevice';
 }
-export interface WriteLogEntry {
+/**
+ * Task 48: who asked for an RPC call. `console` is the RPC console, `ui` any other action of a
+ * user session (a tab's refresh, a paramset write, pairing), `background` the backend on its own
+ * - `init` and de-init, the keep-alive `ping`, the polls and sweeps after an event or a connect.
+ */
+export type RpcOrigin = 'console' | 'ui' | 'background';
+export declare const RPC_ORIGINS: readonly RpcOrigin[];
+/**
+ * One outgoing RPC call, as the RPC log keeps it (task 48: every call, not only the writes).
+ *
+ * The parameters are what went on the wire, verbatim - a `putParamset` in `CONFIG_PENDING` is
+ * traced from them - except the keys of `changeKey`, `setTempKey` and a whitelist, which are
+ * logged as `***`. A result over the log's size cap is kept as a preview string and `resultBytes`
+ * says how big the whole answer was.
+ */
+export interface RpcLogEntry {
     id: number;
     timestamp: number;
     interfaceName: string;
@@ -319,8 +556,11 @@ export interface WriteLogEntry {
     params: RpcValue[];
     ok: boolean;
     result?: RpcValue;
+    /** Set when `result` is a preview of an answer too big for the log: the size of the whole answer, in bytes. */
+    resultBytes?: number;
     error?: string;
     durationMs: number;
+    origin: RpcOrigin;
 }
 export interface InstallModeOptions {
     /** Seconds; the interface's default when omitted. */
@@ -332,8 +572,13 @@ export interface InstallModeOptions {
         sgtin: string;
         key: string;
     };
-    /** HmIP: whether the key mode is "KEY" or "SGTIN". */
-    hmipKeyMode?: 'KEY' | 'SGTIN';
+    /**
+     * HmIP: how the device is admitted. `KEY` whitelists the SGTIN with its key (the only way that
+     * works offline), `SGTIN` whitelists the SGTIN and takes the key from eQ-3's key server, and
+     * `ANY` (task 28) admits whatever device in factory state asks to join: `setInstallMode(true,
+     * seconds)` with exactly two arguments, `hmipKey` ignored.
+     */
+    hmipKeyMode?: 'KEY' | 'SGTIN' | 'ANY';
     /** BidCos: temporary key for `setTempKey`. */
     tempKey?: string;
     /** Restrict to a device address (BidCos `setInstallMode` with address). */
@@ -364,6 +609,19 @@ export interface SessionInfo {
     /** ReGa `UserLevel()`; `0` when ReGa reported none. */
     level: number;
 }
+/** What a save does besides storing the connection - `config.set`'s optional second argument. */
+export interface ConfigSetOptions {
+    /**
+     * Task 34 (#147, D-42): the answer to the question the settings dialog asks when
+     * `autoAckStickyUnreach` is switched on - acknowledge the `STICKY_UNREACH` messages that are
+     * already in the list as well, not only the ones that appear afterwards.
+     *
+     * It counts only on the save that switches the option from off to on, and only for the CCU the
+     * list belongs to (a save that also changes the host acknowledges nothing). Each message gets
+     * exactly the write of `serviceMessages.ack`; HmIP messages are left alone.
+     */
+    acknowledgeExisting?: boolean;
+}
 /**
  * Request methods: `params` is the positional tuple the UI sends, `result` what it receives.
  * Every method rejects with `ApiError` on failure; RPC faults keep their `faultCode`. Methods
@@ -376,7 +634,7 @@ export interface ApiMethods {
     };
     /** Persist and reconnect. */
     'config.set': {
-        params: [connection: ConnectionConfig];
+        params: [connection: ConnectionConfig, options?: ConfigSetOptions];
         result: AppConfig;
     };
     'config.discover': {
@@ -387,6 +645,14 @@ export interface ApiMethods {
         params: [];
         result: null;
     };
+    /**
+     * B-53: the automatic callback address and this machine's addresses, worked out for `host` -
+     * the one being typed into the settings dialog - or the configured CCU when it is absent.
+     */
+    'config.callbackAddresses': {
+        params: [host?: string];
+        result: CallbackAddressInfo;
+    };
     'interfaces.list': {
         params: [];
         result: InterfaceState[];
@@ -500,6 +766,107 @@ export interface ApiMethods {
         }>];
         result: NameMap;
     };
+    'meta.state': {
+        params: [];
+        result: MetaState;
+    };
+    /** The state, the trees and every object in one answer; what the UI asks for on connect. */
+    'meta.get': {
+        params: [];
+        result: MetaSnapshot;
+    };
+    /** Every taxonomy with its tree. */
+    'meta.enums': {
+        params: [];
+        result: Record<string, MetaEnum>;
+    };
+    /** Every device and channel the store knows, keyed by ref. */
+    'meta.objects': {
+        params: [];
+        result: Record<string, MetaObjectView>;
+    };
+    /** The membership of one object: the complete list of paths it should have afterwards. */
+    'meta.setMembership': {
+        params: [entries: Array<{
+            ref: string;
+            paths: string[];
+        }>];
+        result: null;
+    };
+    /**
+     * The interaction that matters: select rows in the grid, assign them to a room.
+     *
+     * `on: false` takes them out of it again. One revision for the whole selection, so a consumer
+     * of the change stream sees one change and not forty.
+     */
+    'meta.assign': {
+        params: [refs: string[], path: string, on: boolean];
+        result: null;
+    };
+    /** A new taxonomy beside `room` and `function`. */
+    'meta.enum.create': {
+        params: [id: string, name: Record<string, string>];
+        result: null;
+    };
+    'meta.enum.update': {
+        params: [id: string, name: Record<string, string>];
+        result: null;
+    };
+    /** Refused while it has members unless `detach` is true; the UI lists them first. */
+    'meta.enum.delete': {
+        params: [id: string, detach?: boolean];
+        result: null;
+    };
+    /**
+     * A node - a room, a floor, a function. The id is derived from the name and is stable
+     * afterwards; the answer is the path the node got.
+     */
+    'meta.node.create': {
+        params: [
+            enumId: string,
+            /**
+             * The parent node's path, or **absent** for a node at the root of the taxonomy.
+             *
+             * Absent and not `null`: the backend turns a `null` parameter into `undefined` because
+             * the two transports disagree about which of them an omitted argument becomes
+             * (`JSON.stringify` writes `null`, structured clone keeps `undefined`), so no method of
+             * this contract may give `null` a meaning of its own.
+             */
+            parent: string | undefined,
+            name: string,
+            options?: {
+                icon?: string;
+                position?: number;
+            }
+        ];
+        result: string;
+    };
+    'meta.node.update': {
+        params: [path: string, patch: MetaNodePatch];
+        result: null;
+    };
+    'meta.node.delete': {
+        params: [path: string, detach?: boolean];
+        result: null;
+    };
+    /**
+     * Reads the store again and answers with its state. The box has a change stream and never
+     * needs this; ReGa has none, so a room made in the WebUI shows up here only after a refresh -
+     * on connect, after every write of our own, and when the user asks (task 27).
+     */
+    'meta.refresh': {
+        params: [];
+        result: MetaState;
+    };
+    /** The whole document, for a backup or a move between installations. */
+    'meta.export': {
+        params: [];
+        result: MetaDocument;
+    };
+    'meta.import': {
+        params: [document: unknown, mode?: MetaImportMode];
+        result: null;
+    };
     'paramset.get': {
         params: [interfaceName: string, address: string, paramset: string];
         result: Paramset;
@@ -611,6 +978,18 @@ export interface ApiMethods {
         params: [interfaceName?: string];
         result: ServiceMessage[];
     };
+    /**
+     * Issue #146: asks the interface processes again and answers with the fresh list.
+     *
+     * {@link 'serviceMessages.list'} reads the backend's cache, which is filled by the events and
+     * by a poll every five minutes - so the refresh button of the tab returned the same list it
+     * already showed and looked like a button without a function. This is the call that makes the
+     * round trip: `getServiceMessages` per BidCos interface, the `:0` sweep on HmIP.
+     */
+    'serviceMessages.refresh': {
+        params: [interfaceName?: string];
+        result: ServiceMessage[];
+    };
     /** Acknowledge by writing the datapoint (STICKY_UNREACH etc.). */
     'serviceMessages.ack': {
         params: [interfaceName: string, address: string, datapoint: string];
@@ -643,11 +1022,12 @@ export interface ApiMethods {
         params: [interfaceName?: string];
         result: number;
     };
-    'writeLog.list': {
+    /** Task 48: the RPC log - every outgoing call of the session, oldest first, the newest `limit` of them. */
+    'rpcLog.list': {
         params: [limit?: number];
-        result: WriteLogEntry[];
+        result: RpcLogEntry[];
     };
-    'writeLog.clear': {
+    'rpcLog.clear': {
         params: [];
         result: null;
     };
@@ -680,9 +1060,16 @@ export interface ApiEvents {
         addresses: string[];
     };
     'names.changed': NameMap;
+    /** D-40: the provider, its reachability and whether it takes writes. */
+    'meta.changed': MetaState;
+    /** D-40: a taxonomy or a node was created, renamed, moved or deleted. */
+    'meta.enums.changed': Record<string, MetaEnum>;
+    /** D-40: an object's name or membership changed - on the box, possibly by somebody else. */
+    'meta.objects.changed': Record<string, MetaObjectView>;
     'rpc.event': EventRecord;
     'serviceMessages.changed': ServiceMessage[];
-    'writeLog.appended': WriteLogEntry;
+    /** Task 48: one more outgoing call is finished and in the log. */
+    'rpcLog.appended': RpcLogEntry;
     /** Progress of a bulk write: done of total, last result. */
     'write.progress': {
         done: number;
@@ -738,6 +1125,6 @@ export type ApiFrame = {
     n: ApiEventName;
     d: unknown;
 };
-/** The ten event names of {@link ApiEvents}, in the order the contract declares them. */
+/** Every event name of {@link ApiEvents}, in the order the contract declares them. */
 export declare const API_EVENT_NAMES: readonly ApiEventName[];
 //# sourceMappingURL=types.d.ts.map

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

@@ -6,6 +6,24 @@
  * Rules: extend with new methods, events and optional fields; never rename or repurpose existing
  * ones. Parameters are positional tuples so that both transports can forward them verbatim.
  */
+/**
+ * Task 38: the environment variable and command-line option behind each callback field, for the
+ * settings dialog's read-only hint and the backend's log lines - one table, so the two cannot name
+ * different options.
+ */
+export const CALLBACK_PIN_OPTIONS = Object.freeze({
+    ip: { env: 'HMM_CALLBACK_IP', cli: '--callback-ip' },
+    xmlrpcPort: { env: 'HMM_CALLBACK_XMLRPC_PORT', cli: '--callback-xmlrpc-port' },
+    binrpcPort: { env: 'HMM_CALLBACK_BINRPC_PORT', cli: '--callback-binrpc-port' },
+});
+/** Task 38: `HMM_CALLBACK_XMLRPC_PORT / --callback-xmlrpc-port`, as the hint and the log write it. */
+export function callbackPinOption(field) {
+    const { env, cli } = CALLBACK_PIN_OPTIONS[field];
+    return `${env} / ${cli}`;
+}
+/** The values of {@link MetaProviderChoice} as a runtime list, for validation and a select. */
+export const META_PROVIDERS = Object.freeze(['auto', 'local', 'occulite', 'rega']);
+export const RPC_ORIGINS = Object.freeze(['console', 'ui', 'background']);
 /**
  * Every event of {@link ApiEvents} as a runtime value, because a type has none.
  *
@@ -19,14 +37,17 @@ const API_EVENT_FLAGS = {
     'rega.changed': true,
     'devices.changed': true,
     'names.changed': true,
+    'meta.changed': true,
+    'meta.enums.changed': true,
+    'meta.objects.changed': true,
     'rpc.event': true,
     'serviceMessages.changed': true,
-    'writeLog.appended': true,
+    'rpcLog.appended': true,
     'write.progress': true,
     'unreach.changed': true,
     'config.changed': true,
     notice: true,
 };
-/** The ten event names of {@link ApiEvents}, in the order the contract declares them. */
+/** Every event name of {@link ApiEvents}, in the order the contract declares them. */
 export const API_EVENT_NAMES = Object.freeze(Object.keys(API_EVENT_FLAGS));
 //# sourceMappingURL=types.js.map

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

@@ -4,7 +4,7 @@
  * The core never reads a file. Tests use this implementation, the Electron host and the web host
  * bring their own (IPC and fetch), and the pipeline of task 9 writes the files all three read.
  */
-import type { CrossValidationRule, DataManifest, DataSource, DeviceIcons, Language, MasterMetadata, OptionPreset, ReceiverProfiles, ReceiverTypeAliases, Translations } from './types.js';
+import type { CrossValidationRule, DataManifest, DataSource, DeviceIcons, Language, MasterMetadata, OptionPreset, ReceiverProfiles, ReceiverTypeAliases, TimeSelectorOption, Translations } from './types.js';
 /** Everything a {@link MemoryDataSource} can hold; every part is optional and defaults to empty. */
 export interface MemoryData {
     readonly manifest?: DataManifest;
@@ -16,6 +16,7 @@ export interface MemoryData {
     readonly crossValidations?: readonly CrossValidationRule[];
     readonly translations?: Partial<Record<Language, Translations>>;
     readonly deviceIcons?: DeviceIcons;
+    readonly timeSelectors?: Readonly<Record<string, TimeSelectorOption[]>>;
 }
 /** A `DataSource` over data that is already in memory. */
 export declare class MemoryDataSource implements DataSource {
@@ -29,5 +30,6 @@ export declare class MemoryDataSource implements DataSource {
     crossValidations(): Promise<CrossValidationRule[]>;
     translations(language: Language): Promise<Translations | undefined>;
     deviceIcons(): Promise<DeviceIcons>;
+    timeSelectors(): Promise<Record<string, TimeSelectorOption[]>>;
 }
 //# sourceMappingURL=memory.d.ts.map

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

@@ -34,5 +34,8 @@ export class MemoryDataSource {
     deviceIcons() {
         return Promise.resolve({ ...this.#data.deviceIcons });
     }
+    timeSelectors() {
+        return Promise.resolve({ ...this.#data.timeSelectors });
+    }
 }
 //# sourceMappingURL=memory.js.map