hoffmation-base 3.0.0-alpha.9 → 3.0.0-alpha.90

package/lib/server/devices/sharedFunctions/humiditySensor.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HumiditySensor = void 0;
+const services_1 = require("../../services");
+const models_1 = require("../../../models");
+const baseDeviceInterfaces_1 = require("../baseDeviceInterfaces");
+class HumiditySensor {
+    constructor(_device) {
+        this._device = _device;
+        /** @inheritDoc */
+        this.jsonOmitKeys = ['_device'];
+        this._humidityCallbacks = [];
+        this._humidity = baseDeviceInterfaces_1.UNDEFINED_TEMP_VALUE;
+        this._persistHumiditySensorInterval = services_1.Utils.guardedInterval(() => {
+            this.persist();
+        }, 5 * 60 * 1000, this, false);
+    }
+    get humidity() {
+        return this._humidity;
+    }
+    set humidity(val) {
+        this._humidity = val;
+        for (const cb of this._humidityCallbacks) {
+            cb(new models_1.HumiditySensorChangeAction(this._device, val));
+        }
+    }
+    dispose() {
+        if (this._persistHumiditySensorInterval) {
+            clearInterval(this._persistHumiditySensorInterval);
+        }
+    }
+    persist() {
+        var _a;
+        (_a = services_1.Utils.dbo) === null || _a === void 0 ? void 0 : _a.persistHumiditySensor(this._device);
+    }
+    addHumidityCallback(pCallback) {
+        this._humidityCallbacks.push(pCallback);
+        if (this._humidity > 0) {
+            pCallback(new models_1.HumiditySensorChangeAction(this._device, this._humidity));
+        }
+    }
+    toJSON() {
+        return services_1.Utils.jsonFilter(this, this.jsonOmitKeys);
+    }
+}
+exports.HumiditySensor = HumiditySensor;

package/lib/server/devices/sharedFunctions/index.d.ts

@@ -1 +1,5 @@
+export * from './battery';
+export * from './handleSensor';
+export * from './humiditySensor';
 export * from './lampUtils';
+export * from './temperatureSensor';

package/lib/server/devices/sharedFunctions/index.js

@@ -14,4 +14,8 @@ 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 });
+__exportStar(require("./battery"), exports);
+__exportStar(require("./handleSensor"), exports);
+__exportStar(require("./humiditySensor"), exports);
 __exportStar(require("./lampUtils"), exports);
+__exportStar(require("./temperatureSensor"), exports);

package/lib/server/devices/sharedFunctions/lampUtils.d.ts

@@ -1,11 +1,20 @@
 import { iActuator, iLamp } from '../baseDeviceInterfaces';
-import { ActuatorSetStateCommand, LampSetTimeBasedCommand, LampToggleLightCommand } from '../../../models';
+import { ActuatorSetStateCommand, DimmerSetLightCommand, LampSetTimeBasedCommand, LampToggleLightCommand } from '../../../models';
+import { iDimmableLamp } from '../baseDeviceInterfaces/iDimmableLamp';
 export declare class LampUtils {
+    private static stromStossContinueTimeouts;
     static stromStossOn(actuator: iActuator): void;
     static setTimeBased(device: iLamp, c: LampSetTimeBasedCommand): void;
     static checkUnBlock(device: iActuator, command: ActuatorSetStateCommand): boolean;
     static toggleLight(device: iLamp, c: LampToggleLightCommand): boolean;
     static checkBlockActive(device: iActuator, c: ActuatorSetStateCommand): boolean;
-    static checkUnchanged(device: iActuator, c: ActuatorSetStateCommand): boolean;
+    /**
+     * Check if the dimmer is already in the desired state thus allowing to skip this command
+     * @param {iDimmableLamp} device - The device to check
+     * @param {DimmerSetLightCommand} c - The command to check
+     * @returns {boolean} - True if the command can be skipped
+     */
+    static canDimmerChangeBeSkipped(device: iDimmableLamp, c: DimmerSetLightCommand): boolean;
+    static canActuatorChangeBeSkipped(device: iActuator, c: ActuatorSetStateCommand, noLog?: boolean): boolean;
     static setActuator(device: iActuator, c: ActuatorSetStateCommand): void;
 }

package/lib/server/devices/sharedFunctions/lampUtils.js

@@ -5,81 +5,135 @@ const services_1 = require("../../services");
 const models_1 = require("../../../models");
 class LampUtils {
     static stromStossOn(actuator) {
+        if (!LampUtils.stromStossContinueTimeouts.has(actuator.id)) {
+            LampUtils.stromStossContinueTimeouts.set(actuator.id, services_1.Utils.guardedTimeout(() => {
+                var _a, _b;
+                LampUtils.stromStossContinueTimeouts.delete(actuator.id);
+                if ((_b = (_a = actuator.room) === null || _a === void 0 ? void 0 : _a.PraesenzGroup) === null || _b === void 0 ? void 0 : _b.anyPresent(true)) {
+                    actuator.setActuator(new models_1.ActuatorSetStateCommand(models_1.CommandSource.Automatic, true, 'StromStoss On due to Presence', null));
+                }
+            }, actuator.settings.stromStossResendTime * 1000, this));
+        }
         services_1.Utils.guardedTimeout(() => {
-            var _a, _b;
-            if ((_b = (_a = actuator.room) === null || _a === void 0 ? void 0 : _a.PraesenzGroup) === null || _b === void 0 ? void 0 : _b.anyPresent()) {
-                actuator.setActuator(new models_1.ActuatorSetStateCommand(models_1.CommandSource.Force, true, 'StromStoss On due to Presence'));
-            }
-        }, actuator.settings.stromStossResendTime * 1000, this);
-        services_1.Utils.guardedTimeout(() => {
-            actuator.setActuator(new models_1.ActuatorSetStateCommand(models_1.CommandSource.Force, false, 'StromStoss Off'));
+            actuator.setActuator(new models_1.ActuatorSetStateCommand(models_1.CommandSource.Force, false, 'StromStoss Off', null));
         }, 3000, this);
     }
     static setTimeBased(device, c) {
-        if ((c.time === models_1.TimeOfDay.Night && device.settings.nightOn) ||
+        if (c.isManual ||
+            (c.time === models_1.TimeOfDay.Daylight && device.settings.dayOn) ||
+            (c.time === models_1.TimeOfDay.Night && device.settings.nightOn) ||
             (c.time === models_1.TimeOfDay.BeforeSunrise && device.settings.dawnOn) ||
             (c.time === models_1.TimeOfDay.AfterSunset && device.settings.duskOn)) {
-            device.setLight(new models_1.LampSetLightCommand(c, true, `SetLight due to TimeBased ${c.time}`, c.timeout));
+            device.setLight(new models_1.LampSetLightCommand(c, true, `SetLight due to TimeBased ${models_1.TimeOfDay[c.time]}`, c.disableAutomaticCommand));
         }
     }
     static checkUnBlock(device, command) {
         let dontBlock = false;
+        if (command.containsType(models_1.CommandType.ActuatorRestoreTargetAutomaticValueCommand)) {
+            // We are restoring the automatic value, so we don't want to block the device
+            return true;
+        }
         if (command.isForceAction &&
             device.settings.resetToAutomaticOnForceOffAfterForceOn &&
             !command.on &&
             device.blockAutomationHandler.automaticBlockActive) {
             dontBlock = true;
-            device.log(models_1.LogLevel.Debug, `Reset Automatic Block as we are turning off manually after a force on`);
-            device.blockAutomationHandler.liftAutomaticBlock();
+            const liftCommand = new models_1.BlockAutomaticLiftBlockCommand(command, 'Reset Automatic Block as we are turning off manually after a force on');
+            liftCommand.overrideCommandSource = models_1.CommandSource.Automatic;
+            device.blockAutomationHandler.liftAutomaticBlock(liftCommand);
         }
         return dontBlock;
     }
     static toggleLight(device, c) {
         var _a;
-        const newVal = device.queuedValue !== null ? !device.queuedValue : !device.lightOn;
-        const timeout = newVal && c.isForceAction ? 30 * 60 * 1000 : -1;
+        const newVal = device.queuedValue !== null ? !device.queuedValue : !device.actuatorOn;
         if (newVal && c.time === undefined && c.calculateTime && device.room !== undefined) {
             c.time = services_1.TimeCallbackService.dayType((_a = device.room) === null || _a === void 0 ? void 0 : _a.settings.lampOffset);
         }
         if (newVal && c.time !== undefined) {
-            device.setTimeBased(new models_1.LampSetTimeBasedCommand(c, c.time, 'SetLight Due to toggle Light', timeout));
+            device.setTimeBased(new models_1.LampSetTimeBasedCommand(c, c.time, '', c.isForceAction ? undefined : null));
             return true;
         }
-        device.setLight(new models_1.LampSetLightCommand(c, newVal, 'SetLight Due to toggle Light', timeout));
+        device.setLight(new models_1.LampSetLightCommand(c, newVal, '', c.isForceAction ? undefined : null));
         return newVal;
     }
     static checkBlockActive(device, c) {
         if (!c.isForceAction && device.blockAutomationHandler.automaticBlockActive) {
-            device.log(models_1.LogLevel.Debug, `Skip command to ${c.on} as it is locked until ${new Date(device.blockAutomationHandler.automaticBlockedUntil).toLocaleTimeString()}; command Log: ${c.logMessage}`);
+            device.log(models_1.LogLevel.Debug, `Skip command to ${c.on} as it is locked until ${new Date(device.blockAutomationHandler.automaticBlockedUntil).toLocaleTimeString('de-DE')}; command Log: ${c.logMessage}`);
             device.targetAutomaticState = c.on;
             return true;
         }
         return false;
     }
-    static checkUnchanged(device, c) {
-        if (!c.isForceAction && c.on === device.actuatorOn && device.queuedValue === null) {
-            device.log(models_1.LogLevel.DeepTrace, `Skip light command as it is already ${c.on}`, services_1.LogDebugType.SkipUnchangedActuatorCommand);
-            return true;
+    /**
+     * Check if the dimmer is already in the desired state thus allowing to skip this command
+     * @param {iDimmableLamp} device - The device to check
+     * @param {DimmerSetLightCommand} c - The command to check
+     * @returns {boolean} - True if the command can be skipped
+     */
+    static canDimmerChangeBeSkipped(device, c) {
+        if (c.isForceAction) {
+            return false;
         }
-        return false;
+        if (!this.canActuatorChangeBeSkipped(device, c, true)) {
+            return false;
+        }
+        if (c.brightness !== device.brightness) {
+            return false;
+        }
+        device.log(models_1.LogLevel.DeepTrace, `Light command can be skipped as the device is already in desired state: ${c.logMessage}`, services_1.LogDebugType.SkipUnchangedActuatorCommand);
+        return true;
+    }
+    static canActuatorChangeBeSkipped(device, c, noLog = false) {
+        if (c.isForceAction) {
+            return false;
+        }
+        if ((device.queuedValue === null && device.actuatorOn !== c.on) ||
+            (device.queuedValue !== null && c.on === device.queuedValue)) {
+            return false;
+        }
+        if (!noLog) {
+            device.log(models_1.LogLevel.DeepTrace, `Light command can be skipped as device is already in desired state; command: ${c.logMessage}`, services_1.LogDebugType.SkipUnchangedActuatorCommand);
+        }
+        return true;
     }
     static setActuator(device, c) {
+        if (device.settings.isStromStoss &&
+            c.on &&
+            c.containsType(models_1.CommandType.ActuatorRestoreTargetAutomaticValueCommand)) {
+            // Don't restore automatic state on Strommstoss-Relais as this might result in a loop.
+            return;
+        }
         const dontBlock = LampUtils.checkUnBlock(device, c);
         if (LampUtils.checkBlockActive(device, c)) {
             return;
         }
-        if (LampUtils.checkUnchanged(device, c)) {
+        if (c.isAutomaticAction) {
+            // Preserve the target state for the automatic handler, as
+            device.targetAutomaticState = c.on;
+        }
+        if (LampUtils.canActuatorChangeBeSkipped(device, c)) {
             return;
         }
         device.queuedValue = c.on;
         device.writeActuatorStateToDevice(new models_1.ActuatorWriteStateToDeviceCommand(c, c.on));
         if (device.settings.isStromStoss && c.on) {
-            c.timeout = 3000;
+            c.disableAutomaticCommand = new models_1.BlockAutomaticCommand(c, 3000, 'StromStoss Off');
             LampUtils.stromStossOn(device);
         }
-        if (c.timeout > -1 && !dontBlock) {
-            device.blockAutomationHandler.disableAutomatic(c.timeout, models_1.CollisionSolving.overrideIfGreater);
+        if (dontBlock || c.disableAutomaticCommand === null) {
+            return;
+        }
+        if (dontBlock) {
+            return;
+        }
+        if (c.disableAutomaticCommand === undefined && c.isForceAction) {
+            c.disableAutomaticCommand = models_1.BlockAutomaticCommand.fromDeviceSettings(c, device.settings);
+        }
+        if (c.disableAutomaticCommand) {
+            device.blockAutomationHandler.disableAutomatic(c.disableAutomaticCommand);
         }
     }
 }
 exports.LampUtils = LampUtils;
+LampUtils.stromStossContinueTimeouts = new Map();

package/lib/server/devices/sharedFunctions/temperatureSensor.d.ts

@@ -0,0 +1,31 @@
+import { TemperatureSensorChangeAction } from '../../../models';
+import { iTemperatureSensor } from '../baseDeviceInterfaces';
+import { iJsonOmitKeys } from '../../../models/iJsonOmitKeys';
+export declare class TemperatureSensor implements iJsonOmitKeys {
+    private readonly _device;
+    /** @inheritDoc */
+    readonly jsonOmitKeys: string[];
+    /**
+     * The current room temperature as a number in Celsius
+     */
+    roomTemperature: number;
+    /**
+     * The interval to persist the temperature sensor information
+     */
+    private readonly _persistTemperatureSensorInterval;
+    private _temperature;
+    private _temperaturCallbacks;
+    constructor(_device: iTemperatureSensor);
+    set temperature(val: number);
+    /**
+     * Persists the current temperature sensor information to the database
+     */
+    persist(): void;
+    /**
+     * Adds a callback to be called when the temperature changes
+     * @param pCallback - The callback to be called
+     */
+    addTempChangeCallback(pCallback: (action: TemperatureSensorChangeAction) => void): void;
+    dispose(): void;
+    toJSON(): Partial<TemperatureSensor>;
+}

package/lib/server/devices/sharedFunctions/temperatureSensor.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TemperatureSensor = void 0;
+const services_1 = require("../../services");
+const models_1 = require("../../../models");
+const baseDeviceInterfaces_1 = require("../baseDeviceInterfaces");
+class TemperatureSensor {
+    constructor(_device) {
+        this._device = _device;
+        /** @inheritDoc */
+        this.jsonOmitKeys = ['_device'];
+        /**
+         * The current room temperature as a number in Celsius
+         */
+        this.roomTemperature = baseDeviceInterfaces_1.UNDEFINED_TEMP_VALUE;
+        /**
+         * The interval to persist the temperature sensor information
+         */
+        this._persistTemperatureSensorInterval = services_1.Utils.guardedInterval(() => {
+            this.persist();
+        }, 5 * 60 * 1000, this, false);
+        this._temperature = baseDeviceInterfaces_1.UNDEFINED_TEMP_VALUE;
+        this._temperaturCallbacks = [];
+    }
+    set temperature(val) {
+        this._temperature = val;
+        for (const cb of this._temperaturCallbacks) {
+            cb(new models_1.TemperatureSensorChangeAction(this._device, val));
+        }
+    }
+    /**
+     * Persists the current temperature sensor information to the database
+     */
+    persist() {
+        var _a;
+        (_a = services_1.Utils.dbo) === null || _a === void 0 ? void 0 : _a.persistTemperatureSensor(this._device);
+    }
+    /**
+     * Adds a callback to be called when the temperature changes
+     * @param pCallback - The callback to be called
+     */
+    addTempChangeCallback(pCallback) {
+        this._temperaturCallbacks.push(pCallback);
+        if (this._temperature > baseDeviceInterfaces_1.UNDEFINED_TEMP_VALUE) {
+            pCallback(new models_1.TemperatureSensorChangeAction(this._device, this._temperature));
+        }
+    }
+    dispose() {
+        if (this._persistTemperatureSensorInterval) {
+            clearInterval(this._persistTemperatureSensorInterval);
+        }
+    }
+    toJSON() {
+        return services_1.Utils.jsonFilter(this, this.jsonOmitKeys);
+    }
+}
+exports.TemperatureSensor = TemperatureSensor;

package/lib/server/devices/shelly/index.d.ts

@@ -1,2 +1,3 @@
 export { ShellyDevice } from './shellyDevice';
 export { ShellyTrv } from './shellyTrv';
+export { ShellyActuator } from './shellyActuator';

package/lib/server/devices/shelly/index.js

@@ -1,7 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ShellyTrv = exports.ShellyDevice = void 0;
+exports.ShellyActuator = exports.ShellyTrv = exports.ShellyDevice = void 0;
 var shellyDevice_1 = require("./shellyDevice");
 Object.defineProperty(exports, "ShellyDevice", { enumerable: true, get: function () { return shellyDevice_1.ShellyDevice; } });
 var shellyTrv_1 = require("./shellyTrv");
 Object.defineProperty(exports, "ShellyTrv", { enumerable: true, get: function () { return shellyTrv_1.ShellyTrv; } });
+var shellyActuator_1 = require("./shellyActuator");
+Object.defineProperty(exports, "ShellyActuator", { enumerable: true, get: function () { return shellyActuator_1.ShellyActuator; } });

package/lib/server/devices/shelly/shellyActuator.d.ts

@@ -0,0 +1,33 @@
+import { ShellyDevice } from './shellyDevice';
+import { iActuator } from '../baseDeviceInterfaces';
+import { BlockAutomaticHandler } from '../../services/blockAutomaticHandler';
+import { ActuatorSetStateCommand, ActuatorSettings, ActuatorToggleCommand, ActuatorWriteStateToDeviceCommand, RestoreTargetAutomaticValueCommand } from '../../../models';
+import { IoBrokerDeviceInfo } from '../IoBrokerDeviceInfo';
+export declare class ShellyActuator extends ShellyDevice implements iActuator {
+    /** @inheritDoc */
+    readonly blockAutomationHandler: BlockAutomaticHandler;
+    /** @inheritDoc */
+    targetAutomaticState: boolean;
+    /** @inheritDoc */
+    settings: ActuatorSettings;
+    /** @inheritDoc */
+    queuedValue: boolean | null;
+    private _lastPersist;
+    private readonly _actuatorOnStateId;
+    private _actuatorOn;
+    constructor(pInfo: IoBrokerDeviceInfo);
+    /** @inheritDoc */
+    get actuatorOn(): boolean;
+    /** @inheritDoc */
+    restoreTargetAutomaticValue(c: RestoreTargetAutomaticValueCommand): void;
+    /** @inheritDoc */
+    update(idSplit: string[], state: ioBroker.State, initial?: boolean, handledByChildObject?: boolean): void;
+    /** @inheritDoc */
+    setActuator(command: ActuatorSetStateCommand): void;
+    /** @inheritDoc */
+    persist(): void;
+    /** @inheritDoc */
+    toggleActuator(command: ActuatorToggleCommand): boolean;
+    /** @inheritDoc */
+    writeActuatorStateToDevice(c: ActuatorWriteStateToDeviceCommand): void;
+}

package/lib/server/devices/shelly/shellyActuator.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ShellyActuator = void 0;
+const shellyDevice_1 = require("./shellyDevice");
+const blockAutomaticHandler_1 = require("../../services/blockAutomaticHandler");
+const models_1 = require("../../../models");
+const deviceType_1 = require("../deviceType");
+const DeviceCapability_1 = require("../DeviceCapability");
+const sharedFunctions_1 = require("../sharedFunctions");
+const services_1 = require("../../services");
+class ShellyActuator extends shellyDevice_1.ShellyDevice {
+    constructor(pInfo) {
+        super(pInfo, deviceType_1.DeviceType.ShellyActuator);
+        /** @inheritDoc */
+        this.targetAutomaticState = false;
+        /** @inheritDoc */
+        this.settings = new models_1.ActuatorSettings();
+        /** @inheritDoc */
+        this.queuedValue = null;
+        this._lastPersist = 0;
+        this._actuatorOn = false;
+        this.deviceCapabilities.push(DeviceCapability_1.DeviceCapability.actuator);
+        this.deviceCapabilities.push(DeviceCapability_1.DeviceCapability.blockAutomatic);
+        this._actuatorOnStateId = `${this.info.fullID}.Relay0.Switch`;
+        this.blockAutomationHandler = new blockAutomaticHandler_1.BlockAutomaticHandler(this.restoreTargetAutomaticValue.bind(this), this.log.bind(this));
+    }
+    /** @inheritDoc */
+    get actuatorOn() {
+        return this._actuatorOn;
+    }
+    /** @inheritDoc */
+    restoreTargetAutomaticValue(c) {
+        this.setActuator(new models_1.ActuatorSetStateCommand(c, this.targetAutomaticState));
+    }
+    /** @inheritDoc */
+    update(idSplit, state, initial = false, handledByChildObject = false) {
+        if (!handledByChildObject) {
+            this.log(models_1.LogLevel.DeepTrace, `Aktuator Update: ID: ${idSplit.join('.')} JSON: ${JSON.stringify(state)}`);
+        }
+        this.queuedValue = null;
+        super.update(idSplit, state, initial, true);
+        if (idSplit[3] === 'Relay0') {
+            if (idSplit[4] === 'Switch') {
+                this._actuatorOn = state.val;
+                if (!initial) {
+                    this.persist();
+                }
+            }
+        }
+    }
+    /** @inheritDoc */
+    setActuator(command) {
+        if (this._actuatorOnStateId === '') {
+            this.log(models_1.LogLevel.Error, 'Keine Switch ID bekannt.');
+            return;
+        }
+        sharedFunctions_1.LampUtils.setActuator(this, command);
+    }
+    /** @inheritDoc */
+    persist() {
+        var _a;
+        const now = services_1.Utils.nowMS();
+        if (this._lastPersist + 1000 > now) {
+            return;
+        }
+        (_a = services_1.Utils.dbo) === null || _a === void 0 ? void 0 : _a.persistActuator(this);
+        this._lastPersist = now;
+    }
+    /** @inheritDoc */
+    toggleActuator(command) {
+        const newVal = this.queuedValue !== null ? !this.queuedValue : !this._actuatorOn;
+        const setStateCommand = models_1.ActuatorSetStateCommand.byActuatorAndToggleCommand(this, command);
+        this.setActuator(setStateCommand);
+        return newVal;
+    }
+    /** @inheritDoc */
+    writeActuatorStateToDevice(c) {
+        this.log(models_1.LogLevel.Debug, c.logMessage, services_1.LogDebugType.SetActuator);
+        this.setState(this._actuatorOnStateId, c.stateValue, undefined, (err) => {
+            this.log(models_1.LogLevel.Error, `Lampe schalten ergab Fehler: ${err}`);
+        });
+    }
+}
+exports.ShellyActuator = ShellyActuator;

package/lib/server/devices/shelly/shellyDevice.d.ts

@@ -5,8 +5,9 @@ import { DeviceType } from '../deviceType';
 export declare class ShellyDevice extends IoBrokerBaseDevice implements iDisposable {
     private _lastUpdate;
     get lastUpdate(): Date;
-    stateMap: Map<string, ioBroker.State>;
     constructor(pInfo: IoBrokerDeviceInfo, pType: DeviceType);
+    /** @inheritDoc */
     update(idSplit: string[], state: ioBroker.State, initial?: boolean, pOverride?: boolean): void;
+    /** @inheritDoc */
     dispose(): void;
 }

package/lib/server/devices/shelly/shellyDevice.js

@@ -10,8 +10,8 @@ class ShellyDevice extends IoBrokerBaseDevice_1.IoBrokerBaseDevice {
     constructor(pInfo, pType) {
         super(pInfo, pType);
         this._lastUpdate = new Date(0);
-        this.stateMap = new Map();
     }
+    /** @inheritDoc */
     update(idSplit, state, initial = false, pOverride = false) {
         this.log(models_1.LogLevel.DeepTrace, `Shelly: ${initial ? 'Initiales ' : ''}Update: ID: ${idSplit.join('.')} JSON: ${JSON.stringify(state)}`);
         if (!pOverride) {
@@ -29,6 +29,7 @@ class ShellyDevice extends IoBrokerBaseDevice_1.IoBrokerBaseDevice {
             }
         }
     }
+    /** @inheritDoc */
     dispose() {
         // Nothing yet
     }

package/lib/server/devices/shelly/shellyTrv.d.ts

@@ -1,16 +1,18 @@
-/// <reference types="node" />
 import { ShellyDevice } from './shellyDevice';
-import { iHeater } from '../baseDeviceInterfaces';
+import { iBatteryDevice, iHeater } from '../baseDeviceInterfaces';
 import { HeaterSettings } from '../../../models';
 import { IoBrokerDeviceInfo } from '../IoBrokerDeviceInfo';
-export declare class ShellyTrv extends ShellyDevice implements iHeater {
+import { Battery } from '../sharedFunctions';
+export declare class ShellyTrv extends ShellyDevice implements iHeater, iBatteryDevice {
+    /** @inheritDoc */
+    readonly battery: Battery;
+    /** @inheritDoc */
     settings: HeaterSettings;
-    get lastBatteryPersist(): number;
+    /** @inheritDoc */
     readonly persistHeaterInterval: NodeJS.Timeout;
-    get battery(): number;
-    get minimumLevel(): number;
+    protected _seasonTurnOff: boolean;
+    protected _roomTemperature: number;
     private _automaticMode;
-    private _battery;
     private _iAutomaticInterval;
     private _initialSeasonCheckDone;
     private _lastRecalc;
@@ -22,7 +24,6 @@ export declare class ShellyTrv extends ShellyDevice implements iHeater {
     private _desiredTemperatur;
     private _useExternalTemperatureEnabled;
     private _pidController;
-    private _lastBatteryPersist;
     private readonly _minumumLevelId;
     private readonly _setAutomaticModeId;
     private readonly _setExternalTempId;
@@ -30,30 +31,37 @@ export declare class ShellyTrv extends ShellyDevice implements iHeater {
     private readonly _setPointTemperaturID;
     private readonly _valvePosId;
     constructor(pInfo: IoBrokerDeviceInfo);
-    protected _seasonTurnOff: boolean;
+    /** @inheritDoc */
+    get batteryLevel(): number;
+    get minimumLevel(): number;
+    /** @inheritDoc */
     get seasonTurnOff(): boolean;
+    /** @inheritDoc */
     set seasonTurnOff(value: boolean);
+    /** @inheritDoc */
     get desiredTemperature(): number;
+    /** @inheritDoc */
     set desiredTemperature(val: number);
-    protected _humidity: number;
-    get humidity(): number;
-    get sLevel(): string;
+    /** @inheritDoc */
     get iLevel(): number;
-    get sTemperatur(): string;
+    /** @inheritDoc */
     get iTemperature(): number;
-    protected _roomTemperature: number;
+    /** @inheritDoc */
     get roomTemperature(): number;
-    set roomTemperatur(val: number);
+    private set roomTemperatur(value);
+    /** @inheritDoc */
     checkAutomaticChange(): void;
-    stopAutomaticCheck(): void;
+    /** @inheritDoc */
     onTemperaturChange(newTemperatur: number): void;
+    /** @inheritDoc */
     persistHeater(): void;
+    /** @inheritDoc */
     update(idSplit: string[], state: ioBroker.State, initial?: boolean): void;
+    /** @inheritDoc */
+    dispose(): void;
     protected getNextPidLevel(): number;
     private checkSeasonTurnOff;
-    persistBatteryDevice(): void;
-    dispose(): void;
-    recalcLevel(): void;
+    private recalcLevel;
     private setMode;
     private setExternalTemperature;
     private setExternalTemperatureEnabled;