hoffmation-base 3.0.0-alpha.5 → 3.0.0-alpha.50

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()) {
+                    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/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,14 +1,15 @@
 /// <reference types="node" />
 import { ShellyDevice } from './shellyDevice';
-import { iHeater } from '../baseDeviceInterfaces';
-import { HeaterSettings } from '../../../models';
+import { iBatteryDevice, iHeater } from '../baseDeviceInterfaces';
+import { BatteryLevelChangeAction, HeaterSettings } from '../../../models';
 import { IoBrokerDeviceInfo } from '../IoBrokerDeviceInfo';
-export declare class ShellyTrv extends ShellyDevice implements iHeater {
+export declare class ShellyTrv extends ShellyDevice implements iHeater, iBatteryDevice {
+    /** @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;
@@ -29,34 +30,53 @@ export declare class ShellyTrv extends ShellyDevice implements iHeater {
     private readonly _setEnableExternalTempId;
     private readonly _setPointTemperaturID;
     private readonly _valvePosId;
+    private _lastBatteryLevel;
+    private _batteryLevelCallbacks;
     constructor(pInfo: IoBrokerDeviceInfo);
-    protected _seasonTurnOff: boolean;
+    /** @inheritDoc */
+    get lastBatteryPersist(): number;
+    /** @inheritDoc */
+    get battery(): 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 */
+    addBatteryLevelCallback(pCallback: (action: BatteryLevelChangeAction) => void): void;
+    /** @inheritDoc */
     checkAutomaticChange(): void;
-    stopAutomaticCheck(): void;
+    /** @inheritDoc */
     onTemperaturChange(newTemperatur: number): void;
+    /** @inheritDoc */
     persistHeater(): void;
+    /** @inheritDoc */
     update(idSplit: string[], state: ioBroker.State, initial?: boolean): void;
-    protected getNextPidLevel(): number;
-    private checkSeasonTurnOff;
+    /** @inheritDoc */
     persistBatteryDevice(): void;
+    /** @inheritDoc */
     dispose(): void;
-    recalcLevel(): void;
+    protected getNextPidLevel(): number;
+    private checkSeasonTurnOff;
+    private recalcLevel;
     private setMode;
     private setExternalTemperature;
     private setExternalTemperatureEnabled;
     private setValve;
     private setMinimumLevel;
+    /**
+     * Checks whether the battery level did change and if so fires the callbacks
+     */
+    private checkForBatteryChange;
 }

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

@@ -9,21 +9,16 @@ const liquid_pid_1 = require("../../../liquid-pid");
 const deviceType_1 = require("../deviceType");
 const DeviceCapability_1 = require("../DeviceCapability");
 class ShellyTrv extends shellyDevice_1.ShellyDevice {
-    get lastBatteryPersist() {
-        return this._lastBatteryPersist;
-    }
-    get battery() {
-        return this._battery;
-    }
-    get minimumLevel() {
-        return this._minimumValveLevel;
-    }
     constructor(pInfo) {
         super(pInfo, deviceType_1.DeviceType.ShellyTrv);
+        /** @inheritDoc */
         this.settings = new models_1.HeaterSettings();
+        /** @inheritDoc */
         this.persistHeaterInterval = services_1.Utils.guardedInterval(() => {
             this.persistHeater();
         }, 5 * 60 * 1000, this, false);
+        this._seasonTurnOff = false;
+        this._roomTemperature = baseDeviceInterfaces_1.UNDEFINED_TEMP_VALUE;
         this._automaticMode = false;
         this._battery = -99;
         this._initialSeasonCheckDone = false;
@@ -46,9 +41,8 @@ class ShellyTrv extends shellyDevice_1.ShellyDevice {
             Kd: 9, // PID: Kd in 1/1000
         });
         this._lastBatteryPersist = 0;
-        this._seasonTurnOff = false;
-        this._humidity = 0;
-        this._roomTemperature = baseDeviceInterfaces_1.UNDEFINED_TEMP_VALUE;
+        this._lastBatteryLevel = -1;
+        this._batteryLevelCallbacks = [];
         this.deviceCapabilities.push(DeviceCapability_1.DeviceCapability.heater);
         this.deviceCapabilities.push(DeviceCapability_1.DeviceCapability.batteryDriven);
         this._setAutomaticModeId = `${this.info.fullID}.tmp.automaticTemperatureControl`;
@@ -62,9 +56,22 @@ class ShellyTrv extends shellyDevice_1.ShellyDevice {
             this.checkSeasonTurnOff();
         }, 0, 2, 0));
     }
+    /** @inheritDoc */
+    get lastBatteryPersist() {
+        return this._lastBatteryPersist;
+    }
+    /** @inheritDoc */
+    get battery() {
+        return this._battery;
+    }
+    get minimumLevel() {
+        return this._minimumValveLevel;
+    }
+    /** @inheritDoc */
     get seasonTurnOff() {
         return this._seasonTurnOff;
     }
+    /** @inheritDoc */
     set seasonTurnOff(value) {
         this._seasonTurnOff = value;
         if (value) {
@@ -74,9 +81,11 @@ class ShellyTrv extends shellyDevice_1.ShellyDevice {
         }
         this.setMode(!this.settings.controlByPid);
     }
+    /** @inheritDoc */
     get desiredTemperature() {
         return this._desiredTemperatur;
     }
+    /** @inheritDoc */
     set desiredTemperature(val) {
         this._desiredTemperatur = val;
         if (this._targetTempVal === val) {
@@ -88,18 +97,11 @@ class ShellyTrv extends shellyDevice_1.ShellyDevice {
             this.log(models_1.LogLevel.Error, `Temperaturänderung ergab Fehler ${err}.`);
         });
     }
-    get humidity() {
-        return this._humidity;
-    }
-    get sLevel() {
-        return `${this._level * 100}%`;
-    }
+    /** @inheritDoc */
     get iLevel() {
         return this._level;
     }
-    get sTemperatur() {
-        return `${this.iTemperature}°C`;
-    }
+    /** @inheritDoc */
     get iTemperature() {
         if (this.settings.useOwnTemperatur) {
             return this._temperatur;
@@ -108,6 +110,7 @@ class ShellyTrv extends shellyDevice_1.ShellyDevice {
             return this._roomTemperature;
         }
     }
+    /** @inheritDoc */
     get roomTemperature() {
         return this._roomTemperature;
     }
@@ -121,6 +124,11 @@ class ShellyTrv extends shellyDevice_1.ShellyDevice {
             this.recalcLevel();
         }
     }
+    /** @inheritDoc */
+    addBatteryLevelCallback(pCallback) {
+        this._batteryLevelCallbacks.push(pCallback);
+    }
+    /** @inheritDoc */
     checkAutomaticChange() {
         var _a;
         if (!this._initialSeasonCheckDone) {
@@ -156,19 +164,16 @@ class ShellyTrv extends shellyDevice_1.ShellyDevice {
             this.desiredTemperature = targetTemperature;
         }
     }
-    stopAutomaticCheck() {
-        if (this._iAutomaticInterval !== undefined) {
-            clearInterval(this._iAutomaticInterval);
-            this._iAutomaticInterval = undefined;
-        }
-    }
+    /** @inheritDoc */
     onTemperaturChange(newTemperatur) {
         this.roomTemperatur = newTemperatur;
     }
+    /** @inheritDoc */
     persistHeater() {
         var _a;
         (_a = services_1.Utils.dbo) === null || _a === void 0 ? void 0 : _a.persistHeater(this);
     }
+    /** @inheritDoc */
     update(idSplit, state, initial = false) {
         if (idSplit[3] === 'tmp' && idSplit[4] === 'valvePosition') {
             this.log(models_1.LogLevel.Trace, `Valve position update for ${this.info.customName} to "${state.val}"`);
@@ -195,30 +200,15 @@ class ShellyTrv extends shellyDevice_1.ShellyDevice {
         }
         else if (idSplit[3] === 'bat' && idSplit[4] === 'value') {
             this._battery = state.val;
+            this.checkForBatteryChange();
             this.persistBatteryDevice();
             if (this._battery < 20) {
-                this.log(models_1.LogLevel.Warn, `Das Shelly Gerät hat unter 20% Batterie.`);
+                this.log(models_1.LogLevel.Warn, 'Das Shelly Gerät hat unter 20% Batterie.');
             }
         }
         super.update(idSplit, state, initial, true);
     }
-    getNextPidLevel() {
-        if (this.seasonTurnOff || this._roomTemperature < 0) {
-            return 0;
-        }
-        this._pidController.setPoint(this.desiredTemperature);
-        const newValue = this._pidController.calculate(this._roomTemperature);
-        this.log(models_1.LogLevel.Debug, `New PID Value ${newValue}% (cTemp: ${this._roomTemperature}, dTemp: ${this.desiredTemperature})`);
-        return newValue;
-    }
-    checkSeasonTurnOff() {
-        const desiredState = services_1.Utils.beetweenDays(new Date(), this.settings.seasonTurnOffDay, this.settings.seasonTurnOnDay);
-        if (desiredState !== this.seasonTurnOff || !this._initialSeasonCheckDone) {
-            this.log(models_1.LogLevel.Info, `Switching Seasonal Heating --> New seasonTurnOff: ${desiredState}`);
-            this.seasonTurnOff = desiredState;
-        }
-        this._initialSeasonCheckDone = true;
-    }
+    /** @inheritDoc */
     persistBatteryDevice() {
         var _a;
         const now = services_1.Utils.nowMS();
@@ -228,6 +218,7 @@ class ShellyTrv extends shellyDevice_1.ShellyDevice {
         (_a = services_1.Utils.dbo) === null || _a === void 0 ? void 0 : _a.persistBatteryDevice(this);
         this._lastBatteryPersist = now;
     }
+    /** @inheritDoc */
     dispose() {
         if (this.persistHeaterInterval) {
             clearInterval(this.persistHeaterInterval);
@@ -238,6 +229,23 @@ class ShellyTrv extends shellyDevice_1.ShellyDevice {
         }
         super.dispose();
     }
+    getNextPidLevel() {
+        if (this.seasonTurnOff || this._roomTemperature < 0) {
+            return 0;
+        }
+        this._pidController.setPoint(this.desiredTemperature);
+        const newValue = this._pidController.calculate(this._roomTemperature);
+        this.log(models_1.LogLevel.Debug, `New PID Value ${newValue}% (cTemp: ${this._roomTemperature}, dTemp: ${this.desiredTemperature})`);
+        return newValue;
+    }
+    checkSeasonTurnOff() {
+        const desiredState = services_1.Utils.beetweenDays(new Date(), this.settings.seasonTurnOffDay, this.settings.seasonTurnOnDay);
+        if (desiredState !== this.seasonTurnOff || !this._initialSeasonCheckDone) {
+            this.log(models_1.LogLevel.Info, `Switching Seasonal Heating --> New seasonTurnOff: ${desiredState}`);
+            this.seasonTurnOff = desiredState;
+        }
+        this._initialSeasonCheckDone = true;
+    }
     recalcLevel() {
         if (this.settings.useOwnTemperatur || this.seasonTurnOff || !this.settings.controlByPid) {
             return;
@@ -274,5 +282,18 @@ class ShellyTrv extends shellyDevice_1.ShellyDevice {
     setMinimumLevel(pidForcedMinimum) {
         this.setState(this._minumumLevelId, pidForcedMinimum);
     }
+    /**
+     * Checks whether the battery level did change and if so fires the callbacks
+     */
+    checkForBatteryChange() {
+        const newLevel = this.battery;
+        if (newLevel == -1 || newLevel == this._lastBatteryLevel) {
+            return;
+        }
+        for (const cb of this._batteryLevelCallbacks) {
+            cb(new models_1.BatteryLevelChangeAction(this));
+        }
+        this._lastBatteryLevel = newLevel;
+    }
 }
 exports.ShellyTrv = ShellyTrv;

package/lib/server/devices/tuya/tuyaDevice.d.ts

@@ -5,8 +5,9 @@ import { DeviceType } from '../deviceType';
 export declare class TuyaDevice 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/tuya/tuyaDevice.js

@@ -10,8 +10,8 @@ class TuyaDevice 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, `Tuya: ${initial ? 'Initiales ' : ''}Update: ID: ${idSplit.join('.')} JSON: ${JSON.stringify(state)}`);
         if (!pOverride) {
@@ -29,6 +29,7 @@ class TuyaDevice extends IoBrokerBaseDevice_1.IoBrokerBaseDevice {
             }
         }
     }
+    /** @inheritDoc */
     dispose() {
         // Nothing yet
     }

package/lib/server/devices/tuya/tuyaGarageOpener.d.ts

@@ -3,6 +3,7 @@ import { GarageDoorOpenerSettings } from '../../../models';
 import { IoBrokerDeviceInfo } from '../IoBrokerDeviceInfo';
 import { iGarageDoorOpener } from '../baseDeviceInterfaces';
 export declare class TuyaGarageOpener extends TuyaDevice implements iGarageDoorOpener {
+    /** @inheritDoc */
     settings: GarageDoorOpenerSettings;
     private readonly _switchId;
     private readonly _doorContactId;
@@ -10,9 +11,11 @@ export declare class TuyaGarageOpener extends TuyaDevice implements iGarageDoorO
     private _switchState;
     get isClosed(): boolean;
     constructor(pInfo: IoBrokerDeviceInfo);
+    /** @inheritDoc */
     update(idSplit: string[], state: ioBroker.State, initial?: boolean): void;
     open(): void;
     close(): void;
     trigger(): void;
+    /** @inheritDoc */
     dispose(): void;
 }

package/lib/server/devices/tuya/tuyaGarageOpener.js

@@ -11,6 +11,7 @@ class TuyaGarageOpener extends tuyaDevice_1.TuyaDevice {
     }
     constructor(pInfo) {
         super(pInfo, deviceType_1.DeviceType.TuyaGarageDoorOpener);
+        /** @inheritDoc */
         this.settings = new models_1.GarageDoorOpenerSettings();
         this._isClosed = true;
         this._switchState = false;
@@ -18,6 +19,7 @@ class TuyaGarageOpener extends tuyaDevice_1.TuyaDevice {
         this._switchId = `${this.info.fullID}.1`;
         this._doorContactId = `${this.info.fullID}.3`;
     }
+    /** @inheritDoc */
     update(idSplit, state, initial = false) {
         const fullId = idSplit.join('.');
         switch (fullId) {
@@ -59,6 +61,7 @@ class TuyaGarageOpener extends tuyaDevice_1.TuyaDevice {
     trigger() {
         this.setState(this._switchId, !this._switchState);
     }
+    /** @inheritDoc */
     dispose() {
         super.dispose();
     }

package/lib/server/devices/tv/samsungTv.d.ts

@@ -1,6 +1,7 @@
 import { TvDevice } from './tvDevice';
 import { DeviceType } from '../deviceType';
 export declare class SamsungTv extends TvDevice {
+    /** @inheritDoc */
     deviceType: DeviceType;
     private _device;
     constructor(name: string, roomName: string, ip: string, mac: string, token: string);

package/lib/server/devices/tv/samsungTv.js

@@ -32,6 +32,7 @@ const models_1 = require("../../../models");
 class SamsungTv extends tvDevice_1.TvDevice {
     constructor(name, roomName, ip, mac, token) {
         super(name, roomName, ip, tvDeviceType_1.TvDeviceType.Samsung);
+        /** @inheritDoc */
         this.deviceType = deviceType_1.DeviceType.SamsungTv;
         this._on = false;
         this._device = new samsung_tv_control_1.default({

package/lib/server/devices/tv/tvDevice.d.ts

@@ -7,13 +7,19 @@ import { TvDeviceType } from './tvDeviceType';
 export declare abstract class TvDevice implements iTvDevice {
     ip: string;
     tvDeviceType: TvDeviceType;
+    /** @inheritDoc */
     settings: TvSettings;
+    /**
+     * @inheritDoc
+     */
     room: RoomBase | undefined;
+    /**
+     * @inheritDoc
+     */
     deviceCapabilities: DeviceCapability[];
     protected constructor(name: string, roomName: string, ip: string, tvDeviceType: TvDeviceType);
     protected _info: DeviceInfo;
     get info(): DeviceInfo;
-    set info(info: DeviceInfo);
     abstract get deviceType(): DeviceType;
     get name(): string;
     get id(): string;

package/lib/server/devices/tv/tvDevice.js

@@ -13,7 +13,11 @@ class TvDevice {
     constructor(name, roomName, ip, tvDeviceType) {
         this.ip = ip;
         this.tvDeviceType = tvDeviceType;
+        /** @inheritDoc */
         this.settings = new models_1.TvSettings();
+        /**
+         * @inheritDoc
+         */
         this.deviceCapabilities = [DeviceCapability_1.DeviceCapability.tv];
         this._info = new devices_1.DeviceInfo();
         this._info.fullName = `TV ${name}`;
@@ -27,9 +31,6 @@ class TvDevice {
     get info() {
         return this._info;
     }
-    set info(info) {
-        this._info = info;
-    }
     get name() {
         return this.info.customName;
     }