hoffmation-base 3.0.0-alpha.2 → 3.0.0-alpha.21

package/lib/server/services/api/api-service.js

@@ -12,8 +12,8 @@ const config_1 = require("../../config");
 class API {
     /**
      * Endpoint to end a scene manually (or early if it has automatic turn off)
-     * @param {string} deviceId
-     * @returns {Error | null}
+     * @param deviceId - The id of the scene to end
+     * @returns In case it failed the Error containing the reason
      */
     static endScene(deviceId) {
         const d = this.getDevice(deviceId);
@@ -29,8 +29,8 @@ class API {
     }
     /**
      * Gets the instance of an Ac Device identified by id
-     * @param {string} id
-     * @returns {OwnDaikinDevice | undefined}
+     * @param id - The device id of the AC
+     * @returns The instance of the AC Device or undefined if not found
      */
     static getAc(id) {
         const result = this.getDevice(id);
@@ -39,10 +39,12 @@ class API {
         }
         return result;
     }
+    // TODO: Missing Comment
     static getDevices() {
         // console.log(Util.inspect(Devices.alLDevices, false, 5));
         return devices_1.Devices.alLDevices;
     }
+    // TODO: Missing Comment
     static getDevice(id) {
         const d = devices_1.Devices.alLDevices[id];
         if (d === undefined) {
@@ -50,6 +52,7 @@ class API {
         }
         return devices_1.Devices.alLDevices[id];
     }
+    // TODO: Missing Comment
     static getGroup(id) {
         const g = room_service_1.RoomService.Groups.get(id);
         if (g === undefined) {
@@ -57,23 +60,27 @@ class API {
         }
         return g;
     }
+    // TODO: Missing Comment
     static getRooms() {
         // console.log(inspect(Object.fromEntries(RoomService.Rooms)));
         return room_service_1.RoomService.Rooms;
     }
+    // TODO: Missing Comment
     static getRoom(id) {
         return room_service_1.RoomService.Rooms.get(id);
     }
+    // TODO: Missing Comment
     static getLog() {
         return log_service_1.ServerLogService.getLog();
     }
     /**
      * Turns on/off one AC identified by it's id
-     * @param id The id of the device, if wrong false will be returned
-     * @param {boolean} desiredState
-     * @param {AcMode} desiredMode
-     * @param desiredTemperature
-     * @param forceTime The time in ms this should not change before automatic change is allowed again
+     * @param id - The id of the device, if wrong false will be returned
+     * @param desiredState - The desired state for the AC
+     * @param desiredMode - The desired mode for the AC
+     * @param desiredTemperature - The desired temperature for the AC in Celsius
+     * @param forceTime - The time in ms this should not change before automatic change is allowed again
+     * @returns True if the AC was found and the state was changed
      */
     static setAc(id, desiredState, desiredMode, desiredTemperature, forceTime = 60 * 60 * 1000) {
         const d = this.getAc(id);
@@ -99,7 +106,7 @@ class API {
     }
     /**
      * Turns on/off all AC´s in the home
-     * @param {boolean} desiredState
+     * @param desiredState - The desired state for all AC´s
      */
     static setAllAc(desiredState) {
         ac_1.DaikinService.setAll(desiredState, true);
@@ -107,12 +114,23 @@ class API {
     }
     /**
      * Changes the status of a given Lamp
-     * @param {string} deviceId The device Id of the lamp
-     * @param {boolean} state The desired new state
-     * @param timeout Desired time after which this should be reverted to normal state
-     * @returns {Error | null} In case it failed the Error containing the reason
+     * @param deviceId - The device Id of the lamp
+     * @param state - The desired new state
+     * @param timeout - Desired time after which this should be reverted to normal state
+     * @returns In case it failed the Error containing the reason
+     * @deprecated Use "API.lampSetLight" instead
+     * TODO: Remove deprecated API method
      */
     static setLamp(deviceId, state, timeout = 60 * 60 * 1000) {
+        return this.lampSetLight(deviceId, new models_1.LampSetLightCommand(models_1.CommandSource.API, state, '', timeout));
+    }
+    /**
+     * Changes the status of a given Lamp
+     * @param deviceId - The device Id of the lamp
+     * @param c - The command(stack) to perform on the lamp
+     * @returns In case it failed the Error containing the reason.
+     */
+    static lampSetLight(deviceId, c) {
         const d = this.getDevice(deviceId);
         if (d === undefined) {
             return new Error(`Device with ID ${deviceId} not found`);
@@ -120,18 +138,29 @@ class API {
         if (!d.deviceCapabilities.includes(DeviceCapability_1.DeviceCapability.lamp)) {
             return new Error(`Device with ID ${deviceId} is no Lamp`);
         }
-        d.log(models_1.LogLevel.Info, `API Call to set Lamp to ${state} for ${timeout}ms`);
-        d.setLight(new models_1.LampSetLightCommand(models_1.CommandSource.API, state, '', timeout));
+        d.log(models_1.LogLevel.Info, `Received LampSetLightCommand API call.`);
+        d.setLight(c);
         return null;
     }
     /**
      * Changes the status of a given actuator
-     * @param {string} deviceId The device Id of the actuator
-     * @param {boolean} state The desired new state
-     * @param timeout Desired time after which this should be reverted to automatic state
-     * @returns {Error | null} In case it failed the Error containing the reason
+     * @param deviceId - The device Id of the actuator
+     * @param state - The desired new state
+     * @param timeout - Desired time after which this should be reverted to automatic state
+     * @returns In case it failed the Error containing the reason
+     * @deprecated Use "API.actuatorSetState" instead
+     * TODO: Remove deprecated API method
      */
     static setActuator(deviceId, state, timeout = 60 * 60 * 1000) {
+        return this.actuatorSetState(deviceId, new models_1.ActuatorSetStateCommand(models_1.CommandSource.API, state, '', timeout));
+    }
+    /**
+     * Changes the status of a given actuator
+     * @param deviceId - The device Id of the actuator
+     * @param c - The command(stack) to perform on the actuator
+     * @returns In case it failed the Error containing the reason
+     */
+    static actuatorSetState(deviceId, c) {
         const d = this.getDevice(deviceId);
         if (d === undefined) {
             return new Error(`Device with ID ${deviceId} not found`);
@@ -139,20 +168,31 @@ class API {
         if (!d.deviceCapabilities.includes(DeviceCapability_1.DeviceCapability.actuator)) {
             return new Error(`Device with ID ${deviceId} is no actuator`);
         }
-        d.log(models_1.LogLevel.Info, `API Call to set Actuator to ${state} for ${timeout}ms`);
-        d.setActuator(new models_1.ActuatorSetStateCommand(models_1.CommandSource.API, state, '', timeout));
+        d.log(models_1.LogLevel.Info, `Received ActuatorSetStateCommand API call.`);
+        d.setActuator(c);
         return null;
     }
     /**
-     * Changes the status of a given actuator
-     * @param {string} deviceId The device Id of the actuator
-     * @param {boolean} state The desired new state
-     * @param timeout A chosen Timeout after which the light should be reset
-     * @param brightness The desired brightness
-     * @param transitionTime The transition time during turnOn/turnOff
-     * @returns {Error | null} In case it failed the Error containing the reason
+     * Changes the status of the given dimmer
+     * @param deviceId - The device Id of the actuator
+     * @param state - The desired new state
+     * @param timeout - A chosen Timeout after which the light should be reset
+     * @param brightness - The desired brightness
+     * @param transitionTime - The transition time during turnOn/turnOff
+     * @returns In case it failed the Error containing the reason
+     * @deprecated Use "API.dimmerSetLight" instead
+     * TODO: Remove deprecated API method
      */
     static setDimmer(deviceId, state, timeout, brightness, transitionTime) {
+        return this.dimmerSetLight(deviceId, new models_1.DimmerSetLightCommand(models_1.CommandSource.API, state, '', timeout, brightness, transitionTime));
+    }
+    /**
+     * Changes the status of the given dimmer
+     * @param deviceId - The device Id of the dimmable device.
+     * @param command - The command(stack) to perform on the dimmer
+     * @returns In case it failed the Error containing the reason.
+     */
+    static dimmerSetLight(deviceId, command) {
         const d = this.getDevice(deviceId);
         if (d === undefined) {
             return new Error(`Device with ID ${deviceId} not found`);
@@ -160,41 +200,64 @@ class API {
         if (!d.deviceCapabilities.includes(DeviceCapability_1.DeviceCapability.dimmablelamp)) {
             return new Error(`Device with ID ${deviceId} is no dimmablelamp`);
         }
-        d.log(models_1.LogLevel.Info, `API Call to set Dimmer to ${state} with brightness ${brightness} for ${timeout}ms`);
-        d.setLight(new models_1.DimmerSetLightCommand(models_1.CommandSource.API, state, '', timeout, brightness, transitionTime));
+        d.log(models_1.LogLevel.Info, `Received dimmerSetLight API call.`);
+        d.setLight(command);
         return null;
     }
     /**
-     * Changes the status of a given actuator
-     * @param {string} deviceId The device Id of the actuator
-     * @param {boolean} state The desired new state
-     * @param timeout A chosen Timeout after which the light should be reset
-     * @param brightness The desired brightness
-     * @param transitionTime The transition time during turnOn/turnOff
-     * @param {string} color The desired color in 6 digit hex Code
-     * @param {number} colorTemp The desired color Temperature (0 = more White)
-     * @returns {Error | null} In case it failed the Error containing the reason
+     * Changes the status of a given led-device
+     * @param deviceId - The device Id of the actuator
+     * @param state - The desired new state
+     * @param timeout - A chosen Timeout after which the light should be reset
+     * @param brightness - The desired brightness
+     * @param transitionTime - The transition time during turnOn/turnOff
+     * @param color - The desired color in 6 digit hex Code
+     * @param colorTemp - The desired color Temperature (0 = more White)
+     * @returns In case it failed the Error containing the reason
+     * @deprecated Use "API.ledSetLight" instead
+     * TODO: Remove deprecated API method
      */
     static setLedLamp(deviceId, state, timeout, brightness, transitionTime, color, colorTemp) {
+        return this.ledSetLight(deviceId, new models_1.LedSetLightCommand(models_1.CommandSource.API, state, '', timeout, brightness, transitionTime, color, colorTemp));
+    }
+    /**
+     * Changes the status of a given led-device
+     * @param deviceId - The device Id of the LED-Device
+     * @param command - The command(stack) to perform on the led-device
+     * @returns In case it failed the Error containing the reason
+     */
+    static ledSetLight(deviceId, command) {
         const d = this.getDevice(deviceId);
         if (d === undefined) {
             return new Error(`Device with ID ${deviceId} not found`);
         }
         if (!d.deviceCapabilities.includes(DeviceCapability_1.DeviceCapability.ledLamp)) {
-            return new Error(`Device with ID ${deviceId} is no dimmablelamp`);
+            return new Error(`Device with ID ${deviceId} is no LED`);
         }
-        d.log(models_1.LogLevel.Info, `API Call to set LED to ${state} with brightness ${brightness} and color ${color} for ${timeout}ms`);
-        d.setLight(new models_1.LedSetLightCommand(models_1.CommandSource.API, state, '', timeout, brightness, transitionTime, color, colorTemp));
+        d.log(models_1.LogLevel.Info, `Received ledSetLight API call.`);
+        d.setLight(command);
         return null;
     }
     /**
      * Changes the position of a given shutter
      * if needed this updates the window position as well
-     * @param {string} deviceId The device Id of the shutter
-     * @param {number} level The desired new level (0 being open, 100 being closed)
-     * @returns {Error | null} Error if there is no shutter with the given id
+     * @param deviceId - The device Id of the shutter
+     * @param level - The desired new level (0 being open, 100 being closed)
+     * @returns Error if there is no shutter with the given id
+     * @deprecated Use "API.shutterSetLevel" instead
+     * TODO: Remove deprecated API method
      */
     static setShutter(deviceId, level) {
+        return this.shutterSetLevel(deviceId, new models_1.ShutterSetLevelCommand(models_1.CommandSource.API, level));
+    }
+    /**
+     * Changes the position of a given shutter
+     * if needed this updates the window position as well
+     * @param deviceId - The device Id of the shutter
+     * @param command - The command(stack) to perform on the shutter
+     * @returns Error if there is no shutter with the given id
+     */
+    static shutterSetLevel(deviceId, command) {
         const d = this.getDevice(deviceId);
         if (d === undefined) {
             return new Error(`Device with ID ${deviceId} not found`);
@@ -204,14 +267,15 @@ class API {
         }
         if (d.window) {
             // otherwise it will be overridden shortly after
-            d.window.setDesiredPosition(new models_1.WindowSetDesiredPositionCommand(models_1.CommandSource.API, level));
+            d.window.setDesiredPosition(new models_1.WindowSetDesiredPositionCommand(command, command.level));
         }
         else {
-            d.setLevel(new models_1.ShutterSetLevelCommand(models_1.CommandSource.API, level));
+            d.setLevel(command);
         }
-        d.log(models_1.LogLevel.Info, `API Call to set Shutter to ${level}`);
+        d.log(models_1.LogLevel.Info, `Received shutterSetLevel API call.`);
         return null;
     }
+    // TODO: Missing Comment
     static speakOnDevice(deviceId, message, volume = 30) {
         const d = this.getDevice(deviceId);
         if (d === undefined) {
@@ -226,9 +290,9 @@ class API {
     }
     /**
      * Starts a specified scene
-     * @param {string} deviceId The targeted scene
-     * @param {number} turnOffTimeout If provided the time in ms after which the scene should end automatically
-     * @returns {Error | null} In case it failed the Error containing the reason
+     * @param deviceId - The targeted scene
+     * @param turnOffTimeout - If provided the time in ms after which the scene should end automatically
+     * @returns In case it failed the Error containing the reason
      */
     static startScene(deviceId, turnOffTimeout) {
         const d = this.getDevice(deviceId);
@@ -262,9 +326,9 @@ class API {
     }
     /**
      * Changes the settings of a given device
-     * @param {string} deviceId The id of the device to change the settings
-     * @param settings A partial settings object containing the wanted settings properties
-     * @returns {Error | null} In case it failed the Error containing the reason
+     * @param deviceId - The id of the device to change the settings
+     * @param settings - A partial settings object containing the wanted settings properties
+     * @returns In case it failed the Error containing the reason
      */
     static setDeviceSettings(deviceId, settings) {
         const d = this.getDevice(deviceId);
@@ -279,6 +343,7 @@ class API {
         d.settings.persist(d);
         return null;
     }
+    // TODO: Missing Comment
     static setGroupSettings(groupId, settings) {
         const g = this.getGroup(groupId);
         if (g === undefined) {
@@ -294,9 +359,9 @@ class API {
     }
     /**
      * Changes the settings of a given room
-     * @param {string} roomName The id of the Room to change the settings
-     * @param settings A partial settings object containing the wanted settings properties
-     * @returns {Error | null} In case it failed the Error containing the reason
+     * @param roomName - The id of the Room to change the settings
+     * @param settings - A partial settings object containing the wanted settings properties
+     * @returns In case it failed the Error containing the reason
      */
     static setRoomSettings(roomName, settings) {
         const r = this.getRoom(roomName);
@@ -308,6 +373,7 @@ class API {
         r.settings.settingsContainer.persist(r);
         return null;
     }
+    // TODO: Missing Comment
     static getLastCameraImage(deviceId) {
         const d = this.getDevice(deviceId);
         if (d === undefined) {
@@ -318,6 +384,7 @@ class API {
         }
         return d.lastImage;
     }
+    // TODO: Missing Comment
     static persistAllDeviceSettings() {
         var _a;
         log_service_1.ServerLogService.writeLog(models_1.LogLevel.Info, `API Call to persist all device settings`);
@@ -325,6 +392,7 @@ class API {
             (_a = device.settings) === null || _a === void 0 ? void 0 : _a.persist(device);
         }
     }
+    // TODO: Missing Comment
     static loadAllDeviceSettingsFromDb() {
         log_service_1.ServerLogService.writeLog(models_1.LogLevel.Info, `API Call to load all device settings`);
         for (const device of Object.values(devices_1.Devices.alLDevices)) {
@@ -333,10 +401,21 @@ class API {
     }
     /**
      * Lifts a previously started Block of automatic
-     * @param {string} deviceId The target device
-     * @returns {Error | null} In case it failed the Error containing the reason
+     * @param deviceId - The target device
+     * @returns In case it failed the Error containing the reason
+     * @deprecated Use "API.blockAutomaticLiftAutomaticBlock" instead
+     * TODO: Remove deprecated API method
      */
     static liftAutomaticBlock(deviceId) {
+        return this.blockAutomaticLiftAutomaticBlock(deviceId, new models_1.BlockAutomaticLiftBlockCommand(models_1.CommandSource.API));
+    }
+    /**
+     * Lifts a previously started Block of automatic
+     * @param deviceId - The target device
+     * @param command - The command to lift the automatic block
+     * @returns In case it failed the Error containing the reason
+     */
+    static blockAutomaticLiftAutomaticBlock(deviceId, command) {
         const d = this.getDevice(deviceId);
         if (d === undefined) {
             return new Error(`Device with ID ${deviceId} not found`);
@@ -344,18 +423,30 @@ class API {
         if (!d.deviceCapabilities.includes(DeviceCapability_1.DeviceCapability.blockAutomatic)) {
             return new Error(`Device with ID ${deviceId} is not capable of blocking automatic`);
         }
-        d.log(models_1.LogLevel.Info, `API Call to lift automatic block`);
-        d.blockAutomationHandler.liftAutomaticBlock();
+        d.log(models_1.LogLevel.Info, `Received API Call to lift automatic block.`);
+        d.blockAutomationHandler.liftAutomaticBlock(command);
         return null;
     }
     /**
      * Blocks the automatic of the given device for provided Duration
-     * @param {string} deviceId The target device
-     * @param {number} duration The duration in ms for which the device should remain in current state
-     * @param {CollisionSolving} onCollision The desired Collision Solving strategy, in case the automatic being blocked already
-     * @returns {Error | null} In case it failed the Error containing the reason
+     * @param deviceId - The target device
+     * @param duration - The duration in ms for which the device should remain in current state
+     * @param onCollision - The desired Collision Solving strategy, in case the automatic being blocked already
+     * @returns In case it failed the Error containing the reason
+     * @deprecated Use "API.blockAutomaticDisable" instead
+     * TODO: Remove deprecated API method
      */
     static blockAutomatic(deviceId, duration, onCollision) {
+        this.blockAutomaticSetBlock(deviceId, new models_1.BlockAutomaticCommand(models_1.CommandSource.API, duration, '', onCollision));
+        return null;
+    }
+    /**
+     * Blocks the automatic of the given device for provided Duration
+     * @param deviceId - The target device
+     * @param command - The command to block the automatic
+     * @returns In case it failed the Error containing the reason
+     */
+    static blockAutomaticSetBlock(deviceId, command) {
         const d = this.getDevice(deviceId);
         if (d === undefined) {
             return new Error(`Device with ID ${deviceId} not found`);
@@ -363,10 +454,11 @@ class API {
         if (!d.deviceCapabilities.includes(DeviceCapability_1.DeviceCapability.blockAutomatic)) {
             return new Error(`Device with ID ${deviceId} is not capable of blocking automatic`);
         }
-        d.log(models_1.LogLevel.Info, `API Call to block automatic for ${duration}ms with ${onCollision} on collision`);
-        d.blockAutomationHandler.disableAutomatic(duration, onCollision);
+        d.log(models_1.LogLevel.Info, `Received API Call to block automatic.`);
+        d.blockAutomationHandler.disableAutomatic(command);
         return null;
     }
+    // TODO: Missing Comment
     static pressButtonSwitch(deviceId, position, pressType) {
         const d = this.getDevice(deviceId);
         if (d === undefined) {

package/lib/server/services/blockAutomaticHandler.d.ts

@@ -1,17 +1,15 @@
-/// <reference types="node" />
-import { CollisionSolving, RestoreTargetAutomaticValueCommand } from '../../models';
+import { BlockAutomaticCommand, BlockAutomaticLiftBlockCommand, BlockAutomaticUntilCommand, RestoreTargetAutomaticValueCommand } from '../../models';
 export declare class BlockAutomaticHandler {
     private readonly _restoreAutomatic;
-    constructor(restoreAutomaticCb: (c: RestoreTargetAutomaticValueCommand) => void);
     private _automaticBlockedUntil;
+    private _restoreAutomaticStateTimeout;
+    constructor(restoreAutomaticCb: (c: RestoreTargetAutomaticValueCommand) => void);
     get automaticBlockedUntil(): Date;
     private set automaticBlockedUntil(value);
-    private _restoreAutomaticStateTimeout;
-    get restoreAutomaticStateTimeout(): NodeJS.Timeout | null;
     get automaticBlockActive(): boolean;
-    disableAutomatic(durationMS: number, onCollideAction?: CollisionSolving): void;
-    disableAutomaticUntil(targetDate: Date, onCollideAction?: CollisionSolving): void;
-    liftAutomaticBlock(): void;
+    disableAutomatic(c: BlockAutomaticCommand): void;
+    disableAutomaticUntil(c: BlockAutomaticUntilCommand): void;
+    liftAutomaticBlock(c: BlockAutomaticLiftBlockCommand): void;
     private updateRestoreTimeout;
     toJSON(): Partial<BlockAutomaticHandler>;
 }

package/lib/server/services/blockAutomaticHandler.js

@@ -18,35 +18,37 @@ class BlockAutomaticHandler {
     }
     set automaticBlockedUntil(target) {
         this._automaticBlockedUntil = target;
-        this.updateRestoreTimeout();
-    }
-    get restoreAutomaticStateTimeout() {
-        return this._restoreAutomaticStateTimeout;
     }
     get automaticBlockActive() {
         return this._automaticBlockedUntil > new Date();
     }
-    disableAutomatic(durationMS, onCollideAction = models_1.CollisionSolving.overrideIfGreater) {
-        this.disableAutomaticUntil(new Date(utils_1.Utils.nowMS() + durationMS), onCollideAction);
+    disableAutomatic(c) {
+        this.disableAutomaticUntil(new models_1.BlockAutomaticUntilCommand(c, new Date(utils_1.Utils.nowMS() + c.durationMS), '', c.onCollideAction));
     }
-    disableAutomaticUntil(targetDate, onCollideAction = models_1.CollisionSolving.overrideIfGreater) {
+    disableAutomaticUntil(c) {
         const now = new Date();
         if (this._automaticBlockedUntil > now &&
-            onCollideAction != models_1.CollisionSolving.override &&
-            (onCollideAction != models_1.CollisionSolving.overrideIfGreater || targetDate < this._automaticBlockedUntil)) {
+            c.onCollideAction != models_1.CollisionSolving.override &&
+            (c.onCollideAction != models_1.CollisionSolving.overrideIfGreater || c.targetDate < this._automaticBlockedUntil)) {
             return;
         }
-        this.automaticBlockedUntil = targetDate;
+        this.automaticBlockedUntil = c.targetDate;
+        this.updateRestoreTimeout(new models_1.RestoreTargetAutomaticValueCommand(c, 'Restore to automatic state after block.'));
     }
-    liftAutomaticBlock() {
+    liftAutomaticBlock(c) {
+        if (this._restoreAutomaticStateTimeout !== null) {
+            clearTimeout(this._restoreAutomaticStateTimeout);
+        }
+        this._restoreAutomaticStateTimeout = null;
         this.automaticBlockedUntil = new Date(0);
+        this._restoreAutomatic(new models_1.RestoreTargetAutomaticValueCommand(c));
     }
-    updateRestoreTimeout() {
+    updateRestoreTimeout(c) {
         if (this._restoreAutomaticStateTimeout !== null) {
             clearTimeout(this._restoreAutomaticStateTimeout);
         }
         this._restoreAutomaticStateTimeout = utils_1.Utils.guardedTimeout(() => {
-            this._restoreAutomatic(new models_1.RestoreTargetAutomaticValueCommand(models_1.CommandSource.Unknown, 'Automatic block restore timeout'));
+            this._restoreAutomatic(c);
         }, this._automaticBlockedUntil.getTime() - utils_1.Utils.nowMS() + 500, this);
     }
     toJSON() {

package/lib/server/services/dbo/iPersist.d.ts

@@ -2,26 +2,122 @@ import { ButtonPressType, iAcDevice, iActuator, iBaseDevice, iBatteryDevice, iBu
 import { CountToday, DesiredShutterPosition, EnergyCalculation, RoomBase, ShutterCalibration } from '../../../models';
 export interface iPersist {
     initialized: boolean;
+    /**
+     * Adds a room to the database
+     * @param {RoomBase} room - The room to add
+     */
     addRoom(room: RoomBase): void;
+    /**
+     * Adds a device to the database
+     * @param {iBaseDevice} device - The device to add
+     */
     addDevice(device: iBaseDevice): void;
+    /**
+     * Gets the count of the motion sensor today
+     * @param {iMotionSensor} device - The device to get the count for
+     * @returns {Promise<CountToday>} - The count of the motion sensor today
+     */
     motionSensorTodayCount(device: iMotionSensor): Promise<CountToday>;
+    /**
+     * Gets the last desired position of the shutter
+     * @param {iShutter} device - The device to get the last desired position for
+     * @returns {Promise<DesiredShutterPosition>} - The last desired position of the shutter
+     */
     getLastDesiredPosition(device: iShutter): Promise<DesiredShutterPosition>;
+    /**
+     * Gets the shutter calibration
+     * @param {iShutter} device - The device to get the shutter calibration for
+     * @returns {Promise<ShutterCalibration>} - The shutter calibration
+     */
     getShutterCalibration(device: iShutter): Promise<ShutterCalibration>;
+    /**
+     * Initializes the database-connection and prepares the database
+     * @returns {Promise<void>} - The promise that resolves when the database is initialized
+     */
     initialize(): Promise<void>;
+    /**
+     * Persists the shutter calibration
+     * @param {ShutterCalibration} data - The shutter calibration data to persist
+     */
     persistShutterCalibration(data: ShutterCalibration): void;
+    /**
+     * Persists data for an illumination sensor
+     * @param {iIlluminationSensor} device - The device to persist data for
+     */
     persistIlluminationSensor(device: iIlluminationSensor): void;
+    /**
+     * Persists data for an energy manager
+     * @param {EnergyCalculation} energyData - The energy data to persist
+     */
     persistEnergyManager(energyData: EnergyCalculation): void;
+    /**
+     * Persists data of an AC device
+     * @param {iAcDevice} device - The device to persist data for
+     */
     persistAC(device: iAcDevice): void;
+    /**
+     * Persists data of an actuator
+     * @param {iActuator} device - The device to persist data for
+     */
     persistActuator(device: iActuator): void;
+    /**
+     * Persists data of a heater
+     * @param {iHeater} device - The device to persist data for
+     */
     persistHeater(device: iHeater): void;
+    /**
+     * Persists data of a motion sensor
+     * @param {iMotionSensor} device - The device to persist data for
+     */
     persistMotionSensor(device: iMotionSensor): void;
+    /**
+     * Persists data of a button switch action
+     * @param {iButtonSwitch} device - The device to persist data for
+     * @param {ButtonPressType} pressType - The type of button press
+     * @param {string} buttonName - The name of the button
+     */
     persistSwitchInput(device: iButtonSwitch, pressType: ButtonPressType, buttonName: string): void;
+    /**
+     * Persists data of a shutter
+     * @param {iShutter} device - The device to persist data for
+     */
     persistShutter(device: iShutter): void;
+    /**
+     * Persists data of a temperature sensor
+     * @param {iTemperatureSensor} device - The device to persist data for
+     */
     persistTemperatureSensor(device: iTemperatureSensor): void;
+    /**
+     * Persists data of a humidity sensor
+     * @param {iHumiditySensor} device - The device to persist data for
+     */
     persistHumiditySensor(device: iHumiditySensor): void;
+    /**
+     * Persists data of a handle sensor
+     * @param {iHandleSensor} device - The device to persist data for
+     */
     persistHandleSensor(device: iHandleSensor): void;
+    /**
+     * Persists data of a battery device
+     * @param {iBatteryDevice} device - The device to persist data for
+     */
     persistBatteryDevice(device: iBatteryDevice): void;
+    /**
+     * Persists data of a Zigbee device
+     * @param {ZigbeeDevice} device - The device to persist data for
+     */
     persistZigbeeDevice(device: ZigbeeDevice): void;
+    /**
+     * Persists settings for the given id
+     * @param {string} id - The id to persist settings for
+     * @param {string} settings - The settings to persist (as JSON string)
+     * @param {string} customname - The custom name of the device/object
+     */
     persistSettings(id: string, settings: string, customname: string): void;
+    /**
+     * Loads settings for the given id
+     * @param {string} id - The id of the object/device to load settings for
+     * @returns {Promise<string | undefined>} - The settings as JSON string or undefined if not found
+     */
     loadSettings(id: string): Promise<string | undefined>;
 }