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

package/lib/server/services/ac/ac-device.d.ts

@@ -1,16 +1,19 @@
-import { DeviceInfo, DeviceType, iAcDevice, iExcessEnergyConsumer, iRoomDevice, iTemporaryDisableAutomatic } from '../../devices';
+import { DeviceCapability, DeviceInfo, DeviceType, iAcDevice, iExcessEnergyConsumer, iRoomDevice, iTemporaryDisableAutomatic } from '../../devices';
 import { AcSettings, ExcessEnergyConsumerSettings, LogLevel, RoomBase } from '../../../models';
 import { LogDebugType } from '../log-service';
 import { AcMode } from './ac-mode';
 import { AcDeviceType } from './acDeviceType';
-import { DeviceCapability } from '../../devices/DeviceCapability';
 import { BlockAutomaticHandler } from '../blockAutomaticHandler';
 export declare abstract class AcDevice implements iExcessEnergyConsumer, iRoomDevice, iAcDevice, iTemporaryDisableAutomatic {
     ip: string;
     acDeviceType: AcDeviceType;
+    /** @inheritDoc */
     currentConsumption: number;
+    /** @inheritDoc */
     settings: AcSettings;
+    /** @inheritDoc */
     deviceCapabilities: DeviceCapability[];
+    /** @inheritDoc */
     readonly blockAutomationHandler: BlockAutomaticHandler;
     protected _activatedByExcessEnergy: boolean;
     protected _desiredTemperatur: number;
@@ -18,44 +21,82 @@ export declare abstract class AcDevice implements iExcessEnergyConsumer, iRoomDe
     protected _room: RoomBase | undefined;
     protected _mode: AcMode;
     private _movementCallbackAdded;
+    /**
+     * Whether the AC is allowed to cool (depends on the season
+     * @returns {boolean} True if the AC is allowed to cool
+     */
+    get coolingAllowed(): boolean;
+    /**
+     * Whether the AC is allowed to heat (depends on the season and the settings)
+     * @returns {boolean} True if the AC is allowed to heat
+     */
+    get heatingAllowed(): boolean;
+    /** @inheritDoc */
     get temperature(): number;
+    /** @inheritDoc */
     get customName(): string;
+    /** @inheritDoc */
     get room(): RoomBase | undefined;
+    /** @inheritDoc */
     set room(room: RoomBase | undefined);
+    /** @inheritDoc */
     get mode(): AcMode;
     protected constructor(name: string, roomName: string, ip: string, acDeviceType: AcDeviceType);
+    /** @inheritDoc */
     get energySettings(): ExcessEnergyConsumerSettings;
     private _roomTemperature;
+    /** @inheritDoc */
     get roomTemperature(): number;
+    /** @inheritDoc */
     get info(): DeviceInfo;
     protected set roomTemperatur(val: number);
-    set info(info: DeviceInfo);
     abstract get deviceType(): DeviceType;
+    /**
+     * The name of this device
+     * @returns The human readable name of this device
+     */
     get name(): string;
+    /** @inheritDoc */
     get id(): string;
     abstract get on(): boolean;
+    /** @inheritDoc */
     restoreTargetAutomaticValue(): void;
+    /** @inheritDoc */
     isAvailableForExcessEnergy(): boolean;
+    /** @inheritDoc */
     calculateDesiredMode(): AcMode;
-    /**
-     * Disable automatic Turn-On and Turn-Off for given amount of ms.
-     * @param {number} timeout
-     */
-    deactivateAutomaticChange(timeout?: number): void;
     abstract setDesiredMode(mode: AcMode, writeToDevice: boolean, temp?: number): void;
     abstract turnOn(): void;
+    /** @inheritDoc */
     onTemperaturChange(newTemperatur: number): void;
+    /**
+     * Persists the current AC-Information to the database
+     */
     persist(): void;
+    /** @inheritDoc */
     turnOnForExcessEnergy(): void;
     abstract turnOff(): void;
+    /** @inheritDoc */
     turnOffDueToMissingEnergy(): void;
+    /**
+     * Sets the state of the AC
+     * TODO: Migrate to new command system
+     * @param mode - The desired mode
+     * @param desiredTemp - The desired temperature (if unset it will be calculated)
+     * @param forceTime - The time in ms to force the AC to stay in this state (default 1h)
+     */
     setState(mode: AcMode, desiredTemp?: number, forceTime?: number): void;
+    /** @inheritDoc */
     log(level: LogLevel, message: string, debugType?: LogDebugType): void;
+    /** @inheritDoc */
     wasActivatedByExcessEnergy(): boolean;
+    /** @inheritDoc */
     loadDeviceSettings(): void;
+    /** @inheritDoc */
     persistDeviceInfo(): void;
     protected automaticCheck(): void;
-    private onRoomFirstEnter;
+    private onRoomAnyMovement;
     private onRoomLastLeave;
+    /** @inheritDoc */
     toJSON(): Partial<AcDevice>;
 }

package/lib/server/services/ac/ac-device.js

@@ -10,38 +10,70 @@ const utils_1 = require("../utils");
 const log_service_1 = require("../log-service");
 const ac_mode_1 = require("./ac-mode");
 const lodash_1 = __importDefault(require("lodash"));
-const DeviceCapability_1 = require("../../devices/DeviceCapability");
 const settings_service_1 = require("../settings-service");
 const config_1 = require("../../config");
 const blockAutomaticHandler_1 = require("../blockAutomaticHandler");
+const weather_1 = require("../weather");
 class AcDevice {
+    /**
+     * Whether the AC is allowed to cool (depends on the season
+     * @returns {boolean} True if the AC is allowed to cool
+     */
+    get coolingAllowed() {
+        if (settings_service_1.SettingsService.heatMode !== config_1.HeatingMode.Summer) {
+            return false;
+        }
+        if (weather_1.WeatherService.active &&
+            weather_1.WeatherService.todayMaxTemp < this.settings.minOutdoorTempForCooling &&
+            weather_1.WeatherService.todayMaxTemp !== devices_1.UNDEFINED_TEMP_VALUE) {
+            // As it is quite cold outside there is no need to cool
+            return false;
+        }
+        return true;
+    }
+    /**
+     * Whether the AC is allowed to heat (depends on the season and the settings)
+     * @returns {boolean} True if the AC is allowed to heat
+     */
+    get heatingAllowed() {
+        return settings_service_1.SettingsService.heatMode !== config_1.HeatingMode.Summer && this.settings.heatingAllowed;
+    }
+    /** @inheritDoc */
     get temperature() {
         return this._roomTemperature;
     }
+    /** @inheritDoc */
     get customName() {
         return this.info.customName;
     }
+    /** @inheritDoc */
     get room() {
         return this._room;
     }
+    /** @inheritDoc */
     set room(room) {
         var _a, _b;
         this._room = room;
         if (room !== undefined && !this._movementCallbackAdded) {
             this._movementCallbackAdded = true;
-            (_a = room === null || room === void 0 ? void 0 : room.PraesenzGroup) === null || _a === void 0 ? void 0 : _a.addFirstEnterCallback(this.onRoomFirstEnter.bind(this));
+            // TODO: Maybe change to any Movement
+            (_a = room === null || room === void 0 ? void 0 : room.PraesenzGroup) === null || _a === void 0 ? void 0 : _a.addAnyMovementCallback(this.onRoomAnyMovement.bind(this));
             (_b = room === null || room === void 0 ? void 0 : room.PraesenzGroup) === null || _b === void 0 ? void 0 : _b.addLastLeftCallback(this.onRoomLastLeave.bind(this));
         }
     }
+    /** @inheritDoc */
     get mode() {
         return this._mode;
     }
     constructor(name, roomName, ip, acDeviceType) {
         this.ip = ip;
         this.acDeviceType = acDeviceType;
+        /** @inheritDoc */
         this.currentConsumption = -1;
+        /** @inheritDoc */
         this.settings = new models_1.AcSettings();
-        this.deviceCapabilities = [DeviceCapability_1.DeviceCapability.ac, DeviceCapability_1.DeviceCapability.blockAutomatic];
+        /** @inheritDoc */
+        this.deviceCapabilities = [devices_1.DeviceCapability.ac, devices_1.DeviceCapability.blockAutomatic];
         this._activatedByExcessEnergy = false;
         this._desiredTemperatur = devices_1.UNDEFINED_TEMP_VALUE;
         this._mode = ac_mode_1.AcMode.Off;
@@ -52,40 +84,48 @@ class AcDevice {
         this._info.customName = `${roomName} ${name}`;
         this._info.room = roomName;
         this._info.allDevicesKey = `ac-${roomName}-${name}`;
-        utils_1.Utils.guardedInterval(this.automaticCheck, 5 * 60 * 1000, this, true);
+        utils_1.Utils.guardedInterval(this.automaticCheck, 5 * 60 * 1000, this, false);
         utils_1.Utils.guardedInterval(this.persist, 15 * 60 * 1000, this, true);
         this.persistDeviceInfo();
         this.loadDeviceSettings();
-        this.blockAutomationHandler = new blockAutomaticHandler_1.BlockAutomaticHandler(this.restoreTargetAutomaticValue.bind(this));
+        this.blockAutomationHandler = new blockAutomaticHandler_1.BlockAutomaticHandler(this.restoreTargetAutomaticValue.bind(this), this.log.bind(this));
     }
+    /** @inheritDoc */
     get energySettings() {
         return this.settings.energySettings;
     }
+    /** @inheritDoc */
     get roomTemperature() {
         return this._roomTemperature;
     }
+    /** @inheritDoc */
     get info() {
         return this._info;
     }
     set roomTemperatur(val) {
         this._roomTemperature = val;
     }
-    set info(info) {
-        this._info = info;
-    }
+    /**
+     * The name of this device
+     * @returns The human readable name of this device
+     */
     get name() {
         return this.info.customName;
     }
+    /** @inheritDoc */
     get id() {
         var _a;
         return (_a = this.info.allDevicesKey) !== null && _a !== void 0 ? _a : `ac-${this.info.room}-${this.info.customName}`;
     }
+    /** @inheritDoc */
     restoreTargetAutomaticValue() {
-        this.log(models_1.LogLevel.Debug, `Restore Target Automatic value`);
+        this.log(models_1.LogLevel.Debug, 'Restore Target Automatic value');
         this.automaticCheck();
     }
+    /** @inheritDoc */
     isAvailableForExcessEnergy() {
-        if (this.settings.useOwnTemperatureAndAutomatic) {
+        var _a, _b, _c, _d;
+        if (this.settings.useAutomatic || (((_b = (_a = this.room) === null || _a === void 0 ? void 0 : _a.HeatGroup) === null || _b === void 0 ? void 0 : _b.settings.automaticMode) && this.settings.heatingAllowed)) {
             return false;
         }
         if (this.blockAutomationHandler.automaticBlockActive) {
@@ -94,48 +134,69 @@ class AcDevice {
         if (!utils_1.Utils.timeWithinBorders(this.settings.minimumHours, this.settings.minimumMinutes, this.settings.maximumHours, this.settings.maximumMinutes)) {
             return false;
         }
-        return this.calculateDesiredMode() !== ac_mode_1.AcMode.Off;
+        const desiredMode = this.calculateDesiredMode();
+        if (desiredMode === ac_mode_1.AcMode.Cooling &&
+            this.settings.noCoolingOnMovement &&
+            ((_d = (_c = this.room) === null || _c === void 0 ? void 0 : _c.PraesenzGroup) === null || _d === void 0 ? void 0 : _d.anyPresent(true))) {
+            return false;
+        }
+        return true;
     }
+    /** @inheritDoc */
     calculateDesiredMode() {
-        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
+        var _a, _b, _c, _d;
         const acOn = this.on;
-        this._desiredTemperatur = (_c = (_b = (_a = this.room) === null || _a === void 0 ? void 0 : _a.HeatGroup) === null || _b === void 0 ? void 0 : _b.desiredTemp) !== null && _c !== void 0 ? _c : 0;
+        const heatGroup = (_a = this.room) === null || _a === void 0 ? void 0 : _a.HeatGroup;
+        if (!heatGroup) {
+            this.log(models_1.LogLevel.Warn, "Can't calculate AC Mode as we have no heat group");
+            return ac_mode_1.AcMode.Off;
+        }
+        this._desiredTemperatur = heatGroup.desiredTemp;
         if (this.settings.manualDisabled) {
-            acOn && this.log(models_1.LogLevel.Info, `We should turn off now, as manual disable force is set.`);
+            if (acOn) {
+                this.log(models_1.LogLevel.Info, 'We should turn off now, as manual disable force is set.');
+            }
+            return ac_mode_1.AcMode.Off;
+        }
+        if ((_b = devices_1.Devices.energymanager) === null || _b === void 0 ? void 0 : _b.acBlocked) {
+            if (acOn) {
+                this.log(models_1.LogLevel.Info, 'We should turn off now, as energy-manager demands off.');
+            }
             return ac_mode_1.AcMode.Off;
         }
         // Check Turn Off Time
         if (!utils_1.Utils.timeWithinBorders(this.settings.minimumHours, this.settings.minimumMinutes, this.settings.maximumHours, this.settings.maximumMinutes)) {
-            acOn && this.log(models_1.LogLevel.Info, `We should turn off now, to respect night settings.`);
+            if (acOn) {
+                this.log(models_1.LogLevel.Info, 'We should turn off now, to respect night settings.');
+            }
             return ac_mode_1.AcMode.Off;
         }
-        const heatGroup = (_d = this.room) === null || _d === void 0 ? void 0 : _d.HeatGroup;
-        if (this.settings.useOwnTemperatureAndAutomatic) {
+        if (this.settings.useOwnTemperature) {
             // Device is in automatic mode so ignore energy and room temperature
-            if ((heatGroup === null || heatGroup === void 0 ? void 0 : heatGroup.settings.automaticMode) === false) {
+            if (this.settings.useAutomatic) {
                 return ac_mode_1.AcMode.Auto;
             }
-            if (settings_service_1.SettingsService.heatMode !== config_1.HeatingMode.Sommer && this.settings.heatingAllowed) {
+            if (this.heatingAllowed) {
                 return ac_mode_1.AcMode.Heating;
             }
-            if (!this.settings.noCoolingOnMovement || ((_f = (_e = this.room) === null || _e === void 0 ? void 0 : _e.PraesenzGroup) === null || _f === void 0 ? void 0 : _f.anyPresent()) !== true) {
+            else if (this.coolingAllowed) {
                 return ac_mode_1.AcMode.Cooling;
             }
             return ac_mode_1.AcMode.Off;
         }
         const temp = this.roomTemperature;
         if (temp === undefined || temp === devices_1.UNDEFINED_TEMP_VALUE) {
-            this.log(models_1.LogLevel.Warn, `Can't calculate AC Mode as we have no room temperature`);
+            this.log(models_1.LogLevel.Warn, "Can't calculate AC Mode as we have no room temperature");
             return ac_mode_1.AcMode.Off;
         }
         if (!heatGroup) {
-            this.log(models_1.LogLevel.Warn, `Can't calculate AC Mode as we have no heat group`);
+            this.log(models_1.LogLevel.Warn, "Can't calculate AC Mode as we have no heat group");
             return ac_mode_1.AcMode.Off;
         }
         let threshold = acOn ? 0.5 : 1.5;
         let thresholdHeating = acOn ? 0.5 : 1.5;
         let desiredMode = ac_mode_1.AcMode.Off;
-        const excessEnergy = (_h = (_g = devices_1.Devices.energymanager) === null || _g === void 0 ? void 0 : _g.excessEnergy) !== null && _h !== void 0 ? _h : -1;
+        const excessEnergy = (_d = (_c = devices_1.Devices.energymanager) === null || _c === void 0 ? void 0 : _c.excessEnergy) !== null && _d !== void 0 ? _d : -1;
         if ((acOn ? 200 : 1000) < excessEnergy) {
             // As there is plenty of energy to spare we plan to overshoot the target by 1 degree
             threshold = -0.5;
@@ -144,13 +205,10 @@ class AcDevice {
         const targetTemp = heatGroup.desiredTemp;
         const coolUntil = targetTemp + threshold;
         const heatUntil = targetTemp - thresholdHeating;
-        if (temp > coolUntil && settings_service_1.SettingsService.heatMode === config_1.HeatingMode.Sommer) {
+        if (temp > coolUntil && this.coolingAllowed) {
             desiredMode = ac_mode_1.AcMode.Cooling;
-            if (this.settings.noCoolingOnMovement && ((_k = (_j = this.room) === null || _j === void 0 ? void 0 : _j.PraesenzGroup) === null || _k === void 0 ? void 0 : _k.anyPresent()) === true) {
-                return ac_mode_1.AcMode.Off;
-            }
         }
-        else if (temp < heatUntil && this.settings.heatingAllowed && settings_service_1.SettingsService.heatMode === config_1.HeatingMode.Winter) {
+        else if (temp < heatUntil && this.heatingAllowed) {
             desiredMode = ac_mode_1.AcMode.Heating;
         }
         if (acOn ? desiredMode === ac_mode_1.AcMode.Off : desiredMode !== ac_mode_1.AcMode.Off) {
@@ -158,16 +216,13 @@ class AcDevice {
         }
         return desiredMode;
     }
-    /**
-     * Disable automatic Turn-On and Turn-Off for given amount of ms.
-     * @param {number} timeout
-     */
-    deactivateAutomaticChange(timeout = 60 * 60 * 1000) {
-        this.blockAutomationHandler.disableAutomatic(timeout);
-    }
+    /** @inheritDoc */
     onTemperaturChange(newTemperatur) {
         this.roomTemperatur = newTemperatur;
     }
+    /**
+     * Persists the current AC-Information to the database
+     */
     persist() {
         var _a;
         if (!utils_1.Utils.anyDboActive || this.on === undefined) {
@@ -175,19 +230,35 @@ class AcDevice {
         }
         (_a = utils_1.Utils.dbo) === null || _a === void 0 ? void 0 : _a.persistAC(this);
     }
+    /** @inheritDoc */
     turnOnForExcessEnergy() {
+        var _a, _b;
         if (this.blockAutomationHandler.automaticBlockActive) {
             return;
         }
         this._activatedByExcessEnergy = true;
+        const desiredMode = this.calculateDesiredMode();
+        if (desiredMode === ac_mode_1.AcMode.Cooling &&
+            this.settings.noCoolingOnMovement &&
+            ((_b = (_a = this.room) === null || _a === void 0 ? void 0 : _a.PraesenzGroup) === null || _b === void 0 ? void 0 : _b.anyPresent(true))) {
+            return;
+        }
         this.setDesiredMode(this.calculateDesiredMode(), false);
         this.turnOn();
     }
+    /** @inheritDoc */
     turnOffDueToMissingEnergy() {
         this.turnOff();
     }
+    /**
+     * Sets the state of the AC
+     * TODO: Migrate to new command system
+     * @param mode - The desired mode
+     * @param desiredTemp - The desired temperature (if unset it will be calculated)
+     * @param forceTime - The time in ms to force the AC to stay in this state (default 1h)
+     */
     setState(mode, desiredTemp, forceTime = 60 * 60 * 1000) {
-        this.blockAutomationHandler.disableAutomatic(forceTime);
+        this.blockAutomationHandler.disableAutomatic(new models_1.BlockAutomaticCommand(models_1.CommandSource.Unknown, forceTime));
         this._mode = mode;
         if (mode == ac_mode_1.AcMode.Off) {
             this.turnOff();
@@ -196,6 +267,7 @@ class AcDevice {
         this.setDesiredMode(mode, false, desiredTemp);
         this.turnOn();
     }
+    /** @inheritDoc */
     log(level, message, debugType = log_service_1.LogDebugType.None) {
         var _a, _b;
         log_service_1.ServerLogService.writeLog(level, `${this.name}: ${message}`, {
@@ -205,12 +277,15 @@ class AcDevice {
             deviceName: this.name,
         });
     }
+    /** @inheritDoc */
     wasActivatedByExcessEnergy() {
         return this._activatedByExcessEnergy;
     }
+    /** @inheritDoc */
     loadDeviceSettings() {
         this.settings.initializeFromDb(this);
     }
+    /** @inheritDoc */
     persistDeviceInfo() {
         utils_1.Utils.guardedTimeout(() => {
             var _a;
@@ -218,6 +293,7 @@ class AcDevice {
         }, 5000, this);
     }
     automaticCheck() {
+        var _a, _b;
         if (this.blockAutomationHandler.automaticBlockActive) {
             // We aren't allowed to turn on or off anyway --> exit
             return;
@@ -228,26 +304,30 @@ class AcDevice {
             return;
         }
         this.setDesiredMode(desiredMode, false);
-        if (desiredMode == ac_mode_1.AcMode.Off) {
+        if (desiredMode == ac_mode_1.AcMode.Off ||
+            (desiredMode === ac_mode_1.AcMode.Cooling &&
+                this.settings.noCoolingOnMovement &&
+                ((_b = (_a = this.room) === null || _a === void 0 ? void 0 : _a.PraesenzGroup) === null || _b === void 0 ? void 0 : _b.anyPresent(true)))) {
             this.turnOff();
             return;
         }
         this.turnOn();
     }
-    onRoomFirstEnter() {
+    onRoomAnyMovement(_action) {
         if (!this.settings.noCoolingOnMovement || !this.on || this.mode === ac_mode_1.AcMode.Heating) {
             return;
         }
-        this.log(models_1.LogLevel.Info, `Someone entered the room. Turning off AC`);
+        this.log(models_1.LogLevel.Info, 'Something moved in the room. Turning off AC');
         this.turnOff();
     }
-    onRoomLastLeave() {
+    onRoomLastLeave(action) {
         if (!this.settings.noCoolingOnMovement) {
             return;
         }
-        this.log(models_1.LogLevel.Info, `Last person left the room. Checking if we should turn on AC`);
+        this.log(models_1.LogLevel.Info, `Last person left the room (${action.reasonTrace}). Checking if we should turn on AC`);
         this.restoreTargetAutomaticValue();
     }
+    /** @inheritDoc */
     toJSON() {
         // eslint-disable-next-line
         const result = lodash_1.default.omit(this, ['room', '_room']);

package/lib/server/services/ac/daikin-service.js

@@ -41,14 +41,14 @@ class DaikinService {
             DaikinService.setAll(true);
             Telegram_1.TelegramService.sendMessage([m.chat.id], 'Command executed');
             return true;
-        }, `Turns all Ac's on without changing any settings`));
+        }, "Turns all Ac's on without changing any settings"));
         Telegram_1.TelegramService.addMessageCallback(new Telegram_1.TelegramMessageCallback('AcOff', /\/ac_off/, async (m) => {
             if (m.from === undefined)
                 return false;
             DaikinService.setAll(false, true);
             Telegram_1.TelegramService.sendMessage([m.chat.id], 'Command executed');
             return true;
-        }, `Turns all Ac's off without changing any settings`));
+        }, "Turns all Ac's off without changing any settings"));
         return new Promise((res, _rej) => {
             var _a, _b;
             this._daikinManager = new daikin_controller_1.DaikinManager({
@@ -68,6 +68,7 @@ class DaikinService {
             });
         });
     }
+    // TODO: Migrate to new command system
     static setAll(on, force = false) {
         if (!this.isInitialized) {
             return;
@@ -81,7 +82,7 @@ class DaikinService {
                 dev.turnOff();
             }
             if (force) {
-                dev.deactivateAutomaticChange(180 * 60 * 1000);
+                dev.blockAutomationHandler.disableAutomatic(new models_1.BlockAutomaticCommand(models_1.CommandSource.Unknown, 180 * 60 * 1000));
             }
         }
     }

package/lib/server/services/ac/own-ac-devices.d.ts

@@ -1,5 +1,8 @@
 import { AcDevice } from './ac-device';
 export declare class OwnAcDevices {
+    /**
+     * A dict containing the AC-Devices
+     */
     static ownDevices: {
         [name: string]: AcDevice;
     };

package/lib/server/services/ac/own-ac-devices.js

@@ -12,4 +12,7 @@ class OwnAcDevices {
     }
 }
 exports.OwnAcDevices = OwnAcDevices;
+/**
+ * A dict containing the AC-Devices
+ */
 OwnAcDevices.ownDevices = {};

package/lib/server/services/ac/own-daikin-device.d.ts

@@ -5,22 +5,47 @@ import { DeviceType } from '../../devices';
 export declare class OwnDaikinDevice extends AcDevice {
     private _device;
     private _mac;
+    /**
+     * The desired state of the device
+     */
     desiredState: boolean;
+    /**
+     * The desired humidity-state of the device
+     * @default 'AUTO'
+     */
     desiredHum: number | 'AUTO';
+    /**
+     * The desired mode of the device
+     * @default Mode.COLD
+     */
     desiredMode: number;
+    /** @inheritDoc */
     deviceType: DeviceType;
     private _on;
     constructor(name: string, roomName: string, ip: string, _device: DaikinAC | undefined, _mac?: string | undefined);
     get device(): DaikinAC | undefined;
+    /** @inheritDoc */
     get on(): boolean;
     set device(device: DaikinAC | undefined);
+    /** @inheritDoc */
     setDesiredMode(mode: AcMode, writeToDevice?: boolean, desiredTemp?: number): void;
+    /** @inheritDoc */
     turnOn(): void;
+    /** @inheritDoc */
     turnOff(): void;
     protected automaticCheck(): void;
     private setDesiredInfo;
     private updateInfo;
+    /**
+     * Handles the situation when the device is unreachable, attempts to reconnect and log the outcome.
+     *
+     * This function logs a warning message indicating that the device is unreachable,
+     * then attempts to reconnect using the `DaikinService.reconnect` method.
+     * If the reconnection is successful, it sets the desired information and schedules a timeout of 5000ms.
+     * If the reconnection fails, it logs an error message with the reason for the failure.
+     */
     private handleDeviceUnreach;
     private handleParamNg;
+    /** @inheritDoc */
     toJSON(): Partial<OwnDaikinDevice>;
 }