hoffmation-base 3.0.3 → 3.1.0

package/lib/index.js

@@ -14,13 +14,30 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.HoffmationBase = exports.HoffmationInitializationObject = void 0;
-const server_1 = require("./server");
-const models_1 = require("./models");
-const dachs_1 = require("./server/devices/dachs");
+exports.SettingsServiceInstance = exports.HoffmationBase = exports.HoffmationInitializationObject = void 0;
 require("@iobroker/types");
-__exportStar(require("./models/index"), exports);
-__exportStar(require("./server/index"), exports);
+const settings_service_1 = require("./settings-service");
+const logging_1 = require("./logging");
+const enums_1 = require("./enums");
+const services_1 = require("./services");
+const ioBroker_1 = require("./ioBroker");
+const devices_1 = require("./devices");
+const utils_1 = require("./utils");
+const weather_1 = require("./services/weather");
+const i18n_1 = require("./i18n");
+__exportStar(require("./enums"), exports);
+__exportStar(require("./action"), exports);
+__exportStar(require("./command"), exports);
+__exportStar(require("./interfaces"), exports);
+__exportStar(require("./settings-service"), exports);
+__exportStar(require("./ioBroker"), exports);
+__exportStar(require("./models"), exports);
+__exportStar(require("./logging"), exports);
+__exportStar(require("./server"), exports);
+__exportStar(require("./services"), exports);
+__exportStar(require("./utils"), exports);
+__exportStar(require("./settingsObjects"), exports);
+__exportStar(require("./devices"), exports);
 __exportStar(require("./liquid-pid"), exports);
 class HoffmationInitializationObject {
     constructor(config) {
@@ -30,104 +47,113 @@ class HoffmationInitializationObject {
 exports.HoffmationInitializationObject = HoffmationInitializationObject;
 class HoffmationBase {
     static async initializeBeforeIoBroker(initObject) {
-        var _a;
-        server_1.SettingsService.initialize(initObject.config);
-        server_1.Res.initialize(initObject.config.translationSettings);
+        var _a, _b;
+        settings_service_1.SettingsService.initialize(initObject.config);
+        i18n_1.Res.initialize(initObject.config.translationSettings);
         if (initObject.config.logSettings) {
-            server_1.ServerLogService.initialize(initObject.config.logSettings);
+            logging_1.ServerLogService.initialize(initObject.config.logSettings, settings_service_1.SettingsService.instance);
         }
-        server_1.ServerLogService.writeLog(models_1.LogLevel.Info, 'Hoffmation-Base Startup');
+        logging_1.ServerLogService.writeLog(enums_1.LogLevel.Info, 'Hoffmation-Base Startup');
         if (initObject.config.persistence) {
             if (initObject.config.persistence.postgreSql) {
-                server_1.Utils.dbo = new server_1.PostgreSqlPersist(initObject.config.persistence.postgreSql);
+                services_1.Persistence.dbo = new services_1.PostgreSqlPersist(initObject.config.persistence.postgreSql);
             }
-            await ((_a = server_1.Utils.dbo) === null || _a === void 0 ? void 0 : _a.initialize());
+            await ((_a = services_1.Persistence.dbo) === null || _a === void 0 ? void 0 : _a.initialize());
         }
-        if (server_1.SettingsService.settings.mp3Server) {
-            server_1.ServerLogService.writeLog(models_1.LogLevel.Info, 'Mp3Server settings detected --> initializing');
-            new server_1.MP3Server(server_1.SettingsService.settings.mp3Server);
+        if (settings_service_1.SettingsService.settings.mp3Server) {
+            logging_1.ServerLogService.writeLog(enums_1.LogLevel.Info, 'Mp3Server settings detected --> initializing');
+            new services_1.MP3Server(settings_service_1.SettingsService.settings.mp3Server);
         }
-        if (server_1.SettingsService.settings.telegram) {
-            server_1.ServerLogService.writeLog(models_1.LogLevel.Info, 'Telegram settings detected --> initializing');
-            server_1.TelegramService.initialize(server_1.SettingsService.settings.telegram);
+        if (settings_service_1.SettingsService.settings.telegram) {
+            logging_1.ServerLogService.writeLog(enums_1.LogLevel.Info, 'Telegram settings detected --> initializing');
+            services_1.TelegramService.initialize(settings_service_1.SettingsService.settings.telegram);
         }
-        if (server_1.SettingsService.settings.tibber) {
-            server_1.ServerLogService.writeLog(models_1.LogLevel.Info, 'Tibber settings detected --> initializing');
-            server_1.TibberService.initialize(server_1.SettingsService.settings.tibber);
+        if (settings_service_1.SettingsService.settings.tibber) {
+            logging_1.ServerLogService.writeLog(enums_1.LogLevel.Info, 'Tibber settings detected --> initializing');
+            services_1.TibberService.initialize(settings_service_1.SettingsService.settings.tibber);
         }
-        if (server_1.SettingsService.settings.polly) {
-            server_1.ServerLogService.writeLog(models_1.LogLevel.Info, 'Amazon Polly settings detected --> initializing');
-            server_1.PollyService.initialize(server_1.SettingsService.settings.polly);
+        if (settings_service_1.SettingsService.settings.polly) {
+            logging_1.ServerLogService.writeLog(enums_1.LogLevel.Info, 'Amazon Polly settings detected --> initializing');
+            services_1.PollyService.initialize(settings_service_1.SettingsService.settings.polly);
         }
-        if (server_1.SettingsService.settings.asusConfig) {
-            server_1.ServerLogService.writeLog(models_1.LogLevel.Info, 'Asus Router settings detected --> initializing');
-            new server_1.AsusRouter(server_1.SettingsService.settings.asusConfig);
+        if (settings_service_1.SettingsService.settings.asusConfig) {
+            logging_1.ServerLogService.writeLog(enums_1.LogLevel.Info, 'Asus Router settings detected --> initializing');
+            new services_1.AsusRouter(settings_service_1.SettingsService.settings.asusConfig);
         }
-        else if (server_1.SettingsService.settings.unifiSettings) {
-            server_1.ServerLogService.writeLog(models_1.LogLevel.Info, 'Unifi Router settings detected --> initializing');
-            new server_1.UnifiRouter(server_1.SettingsService.settings.unifiSettings);
+        else if ((_b = settings_service_1.SettingsService.settings.unifiSettings) === null || _b === void 0 ? void 0 : _b.loginOptions) {
+            logging_1.ServerLogService.writeLog(enums_1.LogLevel.Info, 'Unifi Router settings detected --> initializing');
+            new services_1.UnifiRouter(settings_service_1.SettingsService.settings.unifiSettings.loginOptions);
         }
-        server_1.TimeCallbackService.init();
-        server_1.ServerLogService.writeLog(models_1.LogLevel.Info, 'Hoffmation-Base First Initializations finished');
+        utils_1.Utils.guardedFunction(() => {
+            var _a;
+            if ((_a = settings_service_1.SettingsService.settings.unifiSettings) === null || _a === void 0 ? void 0 : _a.nvrOptions) {
+                logging_1.ServerLogService.writeLog(enums_1.LogLevel.Info, 'Unifi Protect settings detected --> initializing');
+                devices_1.Devices.unifiProtect = new devices_1.UnifiProtect(settings_service_1.SettingsService.settings.unifiSettings.nvrOptions);
+            }
+        }, this);
+        services_1.TimeCallbackService.init();
+        logging_1.ServerLogService.writeLog(enums_1.LogLevel.Info, 'Hoffmation-Base First Initializations finished');
     }
     static initializePostRoomCreationBeforeIoBroker() {
-        server_1.ServerLogService.writeLog(models_1.LogLevel.Info, 'Hoffmation-Base Post Room Creation');
-        server_1.ServerLogService.writeLog(models_1.LogLevel.Info, 'Hoffmation-Base Post Room Creation finished');
+        logging_1.ServerLogService.writeLog(enums_1.LogLevel.Info, 'Hoffmation-Base Post Room Creation');
+        logging_1.ServerLogService.writeLog(enums_1.LogLevel.Info, 'Hoffmation-Base Post Room Creation finished');
     }
     static initializePostIoBroker(defaultMuellSonos) {
         var _a, _b;
-        server_1.ServerLogService.writeLog(models_1.LogLevel.Info, 'Hoffmation-Base Post ioBrokerInitializations');
-        server_1.Trilateration.initialize();
-        if (server_1.SettingsService.TelegramActive)
-            server_1.TelegramCommands.initialize();
-        if ((_a = server_1.SettingsService.settings.sonos) === null || _a === void 0 ? void 0 : _a.active) {
-            server_1.SonosService.addOwnDevices(server_1.OwnSonosDevices.ownDevices);
-            server_1.SonosService.initialize();
+        logging_1.ServerLogService.writeLog(enums_1.LogLevel.Info, 'Hoffmation-Base Post ioBrokerInitializations');
+        devices_1.Trilateration.initialize();
+        if (settings_service_1.SettingsService.TelegramActive)
+            services_1.TelegramCommands.initialize();
+        if ((_a = settings_service_1.SettingsService.settings.sonos) === null || _a === void 0 ? void 0 : _a.active) {
+            services_1.SonosService.addOwnDevices(services_1.OwnSonosDevices.ownDevices);
+            services_1.SonosService.initialize();
         }
-        if (server_1.SettingsService.settings.goveeSettings) {
-            server_1.GooveeService.addOwnDevices(server_1.OwnGoveeDevices.ownDevices);
-            server_1.GooveeService.initialize(server_1.SettingsService.settings.goveeSettings);
+        if (settings_service_1.SettingsService.settings.goveeSettings) {
+            devices_1.GooveeService.addOwnDevices(devices_1.OwnGoveeDevices.ownDevices);
+            devices_1.GooveeService.initialize(settings_service_1.SettingsService.settings.goveeSettings);
         }
-        if ((_b = server_1.SettingsService.settings.daikin) === null || _b === void 0 ? void 0 : _b.active) {
-            server_1.DaikinService.addOwnDevices(server_1.OwnAcDevices.ownDevices);
-            server_1.DaikinService.initialize();
+        if ((_b = settings_service_1.SettingsService.settings.daikin) === null || _b === void 0 ? void 0 : _b.active) {
+            services_1.DaikinService.addOwnDevices(services_1.OwnAcDevices.ownDevices);
+            services_1.DaikinService.initialize();
         }
-        server_1.Utils.guardedNewThread(() => {
-            if (server_1.SettingsService.settings.muell) {
-                server_1.ServerLogService.writeLog(models_1.LogLevel.Info, 'Muell settings detected --> initializing');
-                server_1.MuellService.intialize(server_1.SettingsService.settings.muell, defaultMuellSonos);
+        utils_1.Utils.guardedNewThread(() => {
+            if (settings_service_1.SettingsService.settings.muell) {
+                logging_1.ServerLogService.writeLog(enums_1.LogLevel.Info, 'Muell settings detected --> initializing');
+                services_1.MuellService.intialize(settings_service_1.SettingsService.settings.muell, defaultMuellSonos);
             }
         });
-        server_1.Utils.guardedNewThread(() => {
-            server_1.ServerLogService.writeLog(models_1.LogLevel.Info, 'News settings detected --> initializing');
-            server_1.NewsService.initialize(server_1.SettingsService.settings.news);
+        utils_1.Utils.guardedNewThread(() => {
+            logging_1.ServerLogService.writeLog(enums_1.LogLevel.Info, 'News settings detected --> initializing');
+            services_1.NewsService.initialize(settings_service_1.SettingsService.settings.news);
         });
-        server_1.Utils.guardedNewThread(() => {
-            if (server_1.SettingsService.settings.weather) {
-                server_1.ServerLogService.writeLog(models_1.LogLevel.Info, 'Weather settings detected --> initializing');
-                server_1.WeatherService.initialize(server_1.SettingsService.settings.weather);
+        utils_1.Utils.guardedNewThread(() => {
+            if (settings_service_1.SettingsService.settings.weather) {
+                logging_1.ServerLogService.writeLog(enums_1.LogLevel.Info, 'Weather settings detected --> initializing');
+                weather_1.WeatherService.initialize(settings_service_1.SettingsService.settings.weather);
             }
         });
-        server_1.Utils.guardedNewThread(() => {
-            if (server_1.SettingsService.settings.victron) {
-                server_1.ServerLogService.writeLog(models_1.LogLevel.Info, 'Victron settings detected --> initializing');
-                server_1.VictronService.initialize(server_1.SettingsService.settings.victron);
+        utils_1.Utils.guardedNewThread(() => {
+            if (settings_service_1.SettingsService.settings.victron) {
+                logging_1.ServerLogService.writeLog(enums_1.LogLevel.Info, 'Victron settings detected --> initializing');
+                devices_1.VictronService.initialize(settings_service_1.SettingsService.settings.victron);
             }
         });
-        server_1.Utils.guardedNewThread(() => {
-            if (server_1.SettingsService.settings.dachs !== undefined) {
-                server_1.ServerLogService.writeLog(models_1.LogLevel.Info, 'Dachs settings detected --> initializing');
-                server_1.Devices.dachs = new dachs_1.Dachs(server_1.SettingsService.settings.dachs);
+        utils_1.Utils.guardedNewThread(() => {
+            if (settings_service_1.SettingsService.settings.dachs !== undefined) {
+                logging_1.ServerLogService.writeLog(enums_1.LogLevel.Info, 'Dachs settings detected --> initializing');
+                devices_1.Devices.dachs = new devices_1.Dachs(settings_service_1.SettingsService.settings.dachs);
             }
         });
-        if (server_1.SettingsService.TelegramActive)
-            server_1.TelegramService.publishCommands();
-        server_1.ServerLogService.writeLog(models_1.LogLevel.Info, 'Hoffmation-Base Post ioBrokerInitializations finished');
+        if (settings_service_1.SettingsService.TelegramActive)
+            services_1.TelegramService.publishCommands();
+        logging_1.ServerLogService.writeLog(enums_1.LogLevel.Info, 'Hoffmation-Base Post ioBrokerInitializations finished');
     }
     static startIoBroker(_devices) {
-        server_1.ServerLogService.writeLog(models_1.LogLevel.Info, 'Hoffmation-Base: Starting ioBroker Connection');
-        this.ioMain = new server_1.ioBrokerMain(new server_1.DeviceUpdater());
-        server_1.ServerLogService.writeLog(models_1.LogLevel.Info, 'Hoffmation-Base: ioBroker Connection established');
+        logging_1.ServerLogService.writeLog(enums_1.LogLevel.Info, 'Hoffmation-Base: Starting ioBroker Connection');
+        this.ioMain = new ioBroker_1.ioBrokerMain(new devices_1.DeviceUpdater());
+        logging_1.ServerLogService.writeLog(enums_1.LogLevel.Info, 'Hoffmation-Base: ioBroker Connection established');
     }
 }
 exports.HoffmationBase = HoffmationBase;
+var settings_service_instance_1 = require("./settings-service-instance");
+Object.defineProperty(exports, "SettingsServiceInstance", { enumerable: true, get: function () { return settings_service_instance_1.SettingsServiceInstance; } });

package/lib/interfaces/IDesiredShutterPosition.d.ts

@@ -0,0 +1,9 @@
+/**
+ *
+ */
+export interface iDesiredShutterPosition {
+    /**
+     *
+     */
+    desiredPosition: number;
+}

package/lib/interfaces/IIoBrokerDeviceInfo.d.ts

@@ -0,0 +1,35 @@
+import { iDeviceConfig } from './iDeviceConfig';
+import { iDeviceInfo } from './iDeviceInfo';
+/**
+ *
+ */
+export interface iIoBrokerDeviceInfo extends iDeviceInfo {
+    /**
+     *
+     */
+    devID: string;
+    /**
+     *
+     */
+    deviceType: string;
+    /**
+     *
+     */
+    deviceRoomIndex: number;
+    /**
+     *
+     */
+    type: 'device' | 'channel' | 'state';
+    /**
+     *
+     */
+    fullID: string;
+    /**
+     *
+     */
+    devConf: iDeviceConfig;
+    /**
+     *
+     */
+    toJSON(): Partial<iIoBrokerDeviceInfo>;
+}

package/lib/interfaces/IRessourceObject.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Interface to allow for translation of strings to the different languages thus, allowing the ressources to be outsourced to a json file.
+ */
+export interface iRessourceObject {
+    /**
+     * German translation
+     */
+    de?: string;
+    /**
+     * English translation
+     */
+    en: string;
+}

package/lib/interfaces/ITimeCallback.d.ts

@@ -0,0 +1,60 @@
+import { TimeCallbackType } from '../enums';
+import { iSunTimeOffsets } from './iSunTimeOffsets';
+/**
+ *
+ */
+export interface ITimeCallback {
+    /**
+     *
+     */
+    readonly calculationSunrise: Date;
+    /**
+     *
+     */
+    lastDone: Date;
+    /**
+     * The calculated date when this callback should be fired next
+     * @warning This might have not yet been recalculated
+     */
+    nextToDo?: Date;
+    /**
+     *
+     */
+    readonly calculationSunset: Date;
+    /**
+     *
+     */
+    name: string;
+    /**
+     *
+     */
+    type: TimeCallbackType;
+    /**
+     *
+     */
+    minuteOffset: number;
+    /**
+     *
+     */
+    hours?: number;
+    /**
+     *
+     */
+    minutes?: number;
+    /**
+     *
+     */
+    sunTimeOffset?: iSunTimeOffsets;
+    /**
+     *
+     */
+    cloudOffset?: number;
+    /**
+     *
+     */
+    recalcNextToDo(now: Date): void;
+    /**
+     *
+     */
+    perform(now: Date): void;
+}

package/lib/interfaces/baseDevices/IZigbeeDevice.d.ts

@@ -0,0 +1,21 @@
+/**
+ *
+ */
+export interface iZigbeeDevice {
+    /**
+     *
+     */
+    readonly available: boolean;
+    /**
+     *
+     */
+    readonly linkQuality: number;
+    /**
+     *
+     */
+    readonly lastUpdate: Date;
+    /**
+     *
+     */
+    readonly id: string;
+}

package/lib/interfaces/baseDevices/iAcDevice.d.ts

@@ -0,0 +1,64 @@
+import { iAcSettings } from '../deviceSettings';
+import { iBaseDevice } from './iBaseDevice';
+import { AcMode } from '../../enums';
+/**
+ * Interface for normal air-conditioning devices
+ *
+ * For devices with {@link DeviceCapability.ac} capability.
+ * TODO: Migrate to new Command-Based System
+ * TODO: Extend from iActuator
+ */
+export interface iAcDevice extends iBaseDevice {
+    /**
+     *
+     */
+    heatingAllowed: boolean;
+    /**
+     * The settings of the air-conditioning device
+     */
+    settings: iAcSettings;
+    /**
+     * Whether the air-conditioning device is currently on
+     */
+    readonly on: boolean;
+    /**
+     * The temperature of the room where this device is located
+     */
+    readonly roomTemperature: number;
+    /**
+     * The current temperature of the air-conditioning device in degrees Celsius
+     */
+    readonly temperature: number;
+    /**
+     * The current state of the air-conditioning device
+     */
+    readonly mode: AcMode;
+    /**
+     * This function should be called to inform the air-conditioning device about a change of the room temperature
+     * @param newTemperatur - The new temperature of the room in degrees Celsius
+     */
+    onTemperaturChange(newTemperatur: number): void;
+    /**
+     * Updates the desired mode of the air-conditioning device and writes it to the device if desired
+     * @param mode - The new desired mode
+     * @param writeToDevice - Whether to write the new mode to the device
+     */
+    setDesiredMode(mode: AcMode, writeToDevice: boolean): void;
+    /**
+     * Turns the air-conditioning device on without changing the settings
+     */
+    turnOn(): void;
+    /**
+     * Turns the air-conditioning device off
+     */
+    turnOff(): void;
+    /**
+     * Calculates the desired mode based on the current settings and the room temperature
+     * @returns The desired mode
+     */
+    calculateDesiredMode(): AcMode;
+    /**
+     *
+     */
+    setState(desiredMode: AcMode, desiredTemperature: number | undefined, forceTime: number): void;
+}

package/lib/interfaces/baseDevices/iActuator.d.ts

@@ -0,0 +1,49 @@
+import { ActuatorSetStateCommand, ActuatorToggleCommand, ActuatorWriteStateToDeviceCommand } from '../../command';
+import { iRoomDevice } from './iRoomDevice';
+import { iTemporaryDisableAutomatic } from './iTemporaryDisableAutomatic';
+import { iActuatorSettings } from '../deviceSettings';
+/**
+ * Interface for Actuators.
+ * An actuator can be any device whos primary function is to be on or off e.g a light, an outlet, a fan, etc.
+ *
+ * For devices with {@link DeviceCapability.actuator} capability.
+ */
+export interface iActuator extends iRoomDevice, iTemporaryDisableAutomatic {
+    /**
+     * The settings for this Actuator primarily for controlling its automatic actions
+     */
+    settings: iActuatorSettings;
+    /**
+     * The target automatic state of the device.
+     * This is used to store the state the device should be in to fall back to it after automatic was blocked e.g. by a user.
+     */
+    targetAutomaticState: boolean;
+    /**
+     * The state value of the device
+     */
+    readonly actuatorOn: boolean;
+    /**
+     * Queued value for the actuator
+     */
+    queuedValue: boolean | null;
+    /**
+     * Persisting the current states of this device to the database
+     */
+    persist(): void;
+    /**
+     * Controls the power state of this actuator
+     * Accessible in API
+     * @param command
+     */
+    setActuator(command: ActuatorSetStateCommand): void;
+    /**
+     * Toggles the power state of this actuator
+     * @param command
+     */
+    toggleActuator(command: ActuatorToggleCommand): boolean;
+    /**
+     * Writes the desired actuator state to the device
+     * @param command
+     */
+    writeActuatorStateToDevice(command: ActuatorWriteStateToDeviceCommand): void;
+}

package/lib/interfaces/baseDevices/iBaseDevice.d.ts

@@ -0,0 +1,38 @@
+import { iIdHolder } from '../iIdHolder';
+import { iDeviceSettings } from '../deviceSettings';
+import { DeviceCapability, DeviceType } from '../../enums';
+import { iDeviceInfo } from '../iDeviceInfo';
+/**
+ * This is the main interface for all devices as it ensures certain base functionality.
+ */
+export interface iBaseDevice extends iIdHolder {
+    /**
+     * The settings of the device which are overridden by the specific device implementation
+     */
+    readonly settings: iDeviceSettings | undefined;
+    /**
+     * The hardware-type of the device.
+     */
+    deviceType: DeviceType;
+    /**
+     * Some basic information about the device (mainly its name, id, room, etc.)
+     */
+    readonly info: iDeviceInfo;
+    /**
+     * The capabilities of the device thus referencing other interfaces which then can be used to treat devices regardless of their hardware-type.
+     */
+    readonly deviceCapabilities: DeviceCapability[];
+    /**
+     * This method writes the device Info to the configured persistence layer, to ensure having foreign keys for all other persisted data.
+     */
+    persistDeviceInfo(): void;
+    /**
+     * This method loads the device settings from the configured persistence layer.
+     * Whilst this is normally used during startup, it can be called at any time to refresh the settings in case of manual changes within the database.
+     */
+    loadDeviceSettings(): void;
+    /**
+     * This mainly enforces all devices to have a toJSON method to ensure a consistent way of serializing devices.
+     */
+    toJSON(): Partial<iBaseDevice>;
+}

package/lib/interfaces/baseDevices/iBattery.d.ts

@@ -0,0 +1,26 @@
+import { BatteryLevelChangeAction } from '../../action';
+import { iBatteryDevice } from './iBatteryDevice';
+/**
+ *
+ */
+export interface iBattery {
+    /**
+     *
+     */
+    level: number;
+    /** @inheritDoc */
+    persist(): void;
+    /**
+     * Checks whether the battery level did change and if so fires the callbacks
+     */
+    checkForChange(): void;
+    /**
+     * Adds a callback for when the battery-level has Changed.
+     * @param pCallback - Function that accepts the new state as parameter
+     */
+    addBatteryLevelCallback(pCallback: (action: BatteryLevelChangeAction) => void): void;
+    /**
+     *
+     */
+    toJSON(): Partial<iBatteryDevice>;
+}

package/lib/interfaces/baseDevices/iBatteryDevice.d.ts

@@ -0,0 +1,18 @@
+import { iBaseDevice } from './iBaseDevice';
+import { iBattery } from './iBattery';
+/**
+ * Interface for Battery Devices.
+ * A battery device can be any device that is powered by a battery e.g. a remote, a sensor, etc.
+ *
+ * For devices with {@link DeviceCapability.battery} capability.
+ */
+export interface iBatteryDevice extends iBaseDevice {
+    /**
+     * Common battery handling like persisting
+     */
+    readonly battery: iBattery;
+    /**
+     * The battery status of the device in percentage (0 empty - 100 full)
+     */
+    readonly batteryLevel: number;
+}

package/lib/interfaces/baseDevices/iBluetoothDetector.d.ts

@@ -0,0 +1,34 @@
+import { iRoomDevice } from './iRoomDevice';
+import { iTrilaterationBasePoint } from '../iTrilaterationBasePoint';
+import { iProximityCallback } from '../iProximityCallback';
+/**
+ * Interface for Bluetooth detector devices, providing proximity information for tracked devices
+ *
+ * For devices with {@link DeviceCapability.bluetoothDetector} capability.
+ */
+export interface iBluetoothDetector extends iRoomDevice {
+    /**
+     * The position of the device to allow for trilateration-calculations
+     */
+    position: iTrilaterationBasePoint;
+    /**
+     * Add callback to react on a specified device entering/leaving a given zone
+     * @param cb
+     */
+    addProximityCallback(cb: iProximityCallback): void;
+    /**
+     * Gets the distance of a currently present device
+     * @param deviceName - The mapped Device name
+     * @param maxAge - The maximum age in seconds to still respect that device
+     * @returns Distance in meters or undefined if currently not present
+     */
+    distanceOfDevice(deviceName: string, maxAge: number): number | undefined;
+    /**
+     * Check if a device is currently present and below the given Distance
+     * @param deviceName - The mapped Device name
+     * @param maxDistance - The maximum distance in meters
+     * @param maxAge - The maximum age in seconds to still respect that device
+     * @returns
+     */
+    isDevicePresent(deviceName: string, maxDistance: number, maxAge: number): boolean;
+}

package/lib/interfaces/baseDevices/iButton.d.ts

@@ -0,0 +1,39 @@
+import { ButtonPressType } from '../../enums';
+import { iButtonCapabilities } from '../iButtonCapabilities';
+/**
+ *
+ */
+export interface iButton {
+    /**
+     *
+     */
+    name: string;
+    /**
+     *
+     */
+    buttonCapabilities: iButtonCapabilities;
+    /**
+     *
+     */
+    addCb(buttonType: ButtonPressType, pCallback: (pValue: boolean) => void, description: string): void;
+    /**
+     *
+     */
+    isPressActive(type: ButtonPressType): boolean;
+    /**
+     *
+     */
+    getDescription(): string;
+    /**
+     *
+     */
+    updateState(type: ButtonPressType, pValue: boolean): void;
+    /**
+     *
+     */
+    toJSON(): Partial<iButton>;
+    /**
+     *
+     */
+    press(pressType: ButtonPressType): Error | null;
+}