hoffmation-base 3.0.0-alpha.8 → 3.0.0-alpha.81

package/lib/server/devices/zigbee/zigbeeOsramDimmer.d.ts

@@ -5,7 +5,7 @@ export declare class ZigbeeOsramDimmer extends ZigbeeDimmer {
     protected _stateNameState: string;
     protected _stateNameTransitionTime: string;
     protected _stateIdBrightness: string;
-    protected _stateIdState: string;
+    protected _actuatorOnStateIdState: string;
     protected _stateIdTransitionTime: string;
     constructor(pInfo: IoBrokerDeviceInfo);
 }

package/lib/server/devices/zigbee/zigbeeOsramDimmer.js

@@ -9,7 +9,7 @@ class ZigbeeOsramDimmer extends BaseDevices_1.ZigbeeDimmer {
         this._stateNameBrightness = 'brightness';
         this._stateNameState = 'state';
         this._stateNameTransitionTime = 'transition_time';
-        this._stateIdState = `${this.info.fullID}.state`;
+        this._actuatorOnStateIdState = `${this.info.fullID}.state`;
         this._stateIdBrightness = `${this.info.fullID}.brightness`;
         this._stateIdTransitionTime = `${this.info.fullID}.transition_time`;
     }

package/lib/server/devices/zigbee/zigbeeSMaBiTMagnetContact.d.ts

@@ -2,5 +2,6 @@ import { ZigbeeMagnetContact } from './BaseDevices';
 import { IoBrokerDeviceInfo } from '../IoBrokerDeviceInfo';
 export declare class ZigbeeSMaBiTMagnetContact extends ZigbeeMagnetContact {
     constructor(pInfo: IoBrokerDeviceInfo);
+    /** @inheritDoc */
     update(idSplit: string[], state: ioBroker.State, initial?: boolean): void;
 }

package/lib/server/devices/zigbee/zigbeeSMaBiTMagnetContact.js

@@ -9,6 +9,7 @@ class ZigbeeSMaBiTMagnetContact extends BaseDevices_1.ZigbeeMagnetContact {
     constructor(pInfo) {
         super(pInfo, deviceType_1.DeviceType.ZigbeeSMaBiTMagnetContact);
     }
+    /** @inheritDoc */
     update(idSplit, state, initial = false) {
         this.log(models_1.LogLevel.DeepTrace, `Magnet Contact Update: JSON: ${JSON.stringify(state)}ID: ${idSplit.join('.')}`);
         super.update(idSplit, state, initial, true);

package/lib/server/devices/zigbee/zigbeeSonoffMotion.d.ts

@@ -2,5 +2,6 @@ import { ZigbeeMotionSensor } from './BaseDevices';
 import { IoBrokerDeviceInfo } from '../IoBrokerDeviceInfo';
 export declare class ZigbeeSonoffMotion extends ZigbeeMotionSensor {
     constructor(pInfo: IoBrokerDeviceInfo);
+    /** @inheritDoc */
     update(idSplit: string[], state: ioBroker.State, initial?: boolean): void;
 }

package/lib/server/devices/zigbee/zigbeeSonoffMotion.js

@@ -9,6 +9,7 @@ class ZigbeeSonoffMotion extends BaseDevices_1.ZigbeeMotionSensor {
         super(pInfo, deviceType_1.DeviceType.ZigbeeSonoffMotion);
         this._needsMovementResetFallback = false;
     }
+    /** @inheritDoc */
     update(idSplit, state, initial = false) {
         this.log(models_1.LogLevel.DeepTrace, `Motion update: ID: ${idSplit.join('.')} JSON: ${JSON.stringify(state)}`);
         super.update(idSplit, state, initial, true);

package/lib/server/devices/zigbee/zigbeeSonoffTemp.d.ts

@@ -1,33 +1,58 @@
-/// <reference types="node" />
 import { ZigbeeDevice } from './BaseDevices';
 import { iBatteryDevice, iHumiditySensor, iTemperatureSensor } from '../baseDeviceInterfaces';
 import { IoBrokerDeviceInfo } from '../IoBrokerDeviceInfo';
+import { BatteryLevelChangeAction, HumiditySensorChangeAction, TemperatureSensorChangeAction } from '../../../models';
 export declare class ZigbeeSonoffTemp extends ZigbeeDevice implements iTemperatureSensor, iHumiditySensor, iBatteryDevice {
-    private _battery;
-    private _lastBatteryPersist;
-    get lastBatteryPersist(): number;
+    /** @inheritDoc */
     readonly persistTemperatureSensorInterval: NodeJS.Timeout;
+    /** @inheritDoc */
     readonly persistHumiditySensorInterval: NodeJS.Timeout;
-    get battery(): number;
+    private _battery;
+    private _lastBatteryPersist;
     private _humidityCallbacks;
     private _temperaturCallbacks;
-    constructor(pInfo: IoBrokerDeviceInfo);
     private _humidity;
     private _roomTemperature;
+    private _temperature;
+    private _lastBatteryLevel;
+    private _batteryLevelCallbacks;
+    constructor(pInfo: IoBrokerDeviceInfo);
+    /** @inheritDoc */
+    get lastBatteryPersist(): number;
+    /** @inheritDoc */
+    get battery(): number;
+    /** @inheritDoc */
     get roomTemperature(): number;
+    /** @inheritDoc */
     set roomTemperature(value: number);
+    /** @inheritDoc */
     get humidity(): number;
     private set humidity(value);
+    /** @inheritDoc */
     get iTemperature(): number;
+    /** @inheritDoc */
     get sTemperature(): string;
-    private _temperature;
     private set temperature(value);
+    /** @inheritDoc */
+    addBatteryLevelCallback(pCallback: (action: BatteryLevelChangeAction) => void): void;
+    /** @inheritDoc */
     update(idSplit: string[], state: ioBroker.State, initial?: boolean): void;
-    addHumidityCallback(pCallback: (pValue: number) => void): void;
-    addTempChangeCallback(pCallback: (pValue: number) => void): void;
+    /** @inheritDoc */
+    addHumidityCallback(pCallback: (action: HumiditySensorChangeAction) => void): void;
+    /** @inheritDoc */
+    addTempChangeCallback(pCallback: (action: TemperatureSensorChangeAction) => void): void;
+    /** @inheritDoc */
     onTemperaturChange(newTemperatur: number): void;
+    /** @inheritDoc */
     persistTemperaturSensor(): void;
+    /** @inheritDoc */
     persistHumiditySensor(): void;
+    /** @inheritDoc */
     persistBatteryDevice(): void;
+    /** @inheritDoc */
     dispose(): void;
+    /**
+     * Checks whether the battery level did change and if so fires the callbacks
+     */
+    private checkForBatteryChange;
 }

package/lib/server/devices/zigbee/zigbeeSonoffTemp.js

@@ -8,66 +8,83 @@ const DeviceCapability_1 = require("../DeviceCapability");
 const models_1 = require("../../../models");
 const services_1 = require("../../services");
 class ZigbeeSonoffTemp extends BaseDevices_1.ZigbeeDevice {
-    get lastBatteryPersist() {
-        return this._lastBatteryPersist;
-    }
-    get battery() {
-        return this._battery;
-    }
     constructor(pInfo) {
         super(pInfo, deviceType_1.DeviceType.ZigbeeSonoffTemp);
-        this._battery = -99;
-        this._lastBatteryPersist = 0;
+        /** @inheritDoc */
         this.persistTemperatureSensorInterval = services_1.Utils.guardedInterval(() => {
             this.persistTemperaturSensor();
         }, 5 * 60 * 1000, this, false);
+        /** @inheritDoc */
         this.persistHumiditySensorInterval = services_1.Utils.guardedInterval(() => {
             this.persistHumiditySensor();
         }, 5 * 60 * 1000, this, false);
+        this._battery = -99;
+        this._lastBatteryPersist = 0;
         this._humidityCallbacks = [];
         this._temperaturCallbacks = [];
         this._humidity = baseDeviceInterfaces_1.UNDEFINED_TEMP_VALUE;
         this._roomTemperature = baseDeviceInterfaces_1.UNDEFINED_TEMP_VALUE;
         this._temperature = baseDeviceInterfaces_1.UNDEFINED_TEMP_VALUE;
+        this._lastBatteryLevel = -1;
+        this._batteryLevelCallbacks = [];
         this.deviceCapabilities.push(DeviceCapability_1.DeviceCapability.temperatureSensor);
         this.deviceCapabilities.push(DeviceCapability_1.DeviceCapability.humiditySensor);
         this.deviceCapabilities.push(DeviceCapability_1.DeviceCapability.batteryDriven);
     }
+    /** @inheritDoc */
+    get lastBatteryPersist() {
+        return this._lastBatteryPersist;
+    }
+    /** @inheritDoc */
+    get battery() {
+        return this._battery;
+    }
+    /** @inheritDoc */
     get roomTemperature() {
         return this._roomTemperature;
     }
+    /** @inheritDoc */
     set roomTemperature(value) {
         this._roomTemperature = value;
     }
+    /** @inheritDoc */
     get humidity() {
         return this._humidity;
     }
     set humidity(val) {
         this._humidity = val;
         for (const cb of this._humidityCallbacks) {
-            cb(val);
+            cb(new models_1.HumiditySensorChangeAction(this, val));
         }
     }
+    /** @inheritDoc */
     get iTemperature() {
         return this._temperature;
     }
+    /** @inheritDoc */
     get sTemperature() {
         return `${this._temperature}°C`;
     }
     set temperature(val) {
         this._temperature = val;
         for (const cb of this._temperaturCallbacks) {
-            cb(val);
+            cb(new models_1.TemperatureSensorChangeAction(this, val));
         }
     }
+    /** @inheritDoc */
+    addBatteryLevelCallback(pCallback) {
+        this._batteryLevelCallbacks.push(pCallback);
+    }
+    /** @inheritDoc */
     update(idSplit, state, initial = false) {
         super.update(idSplit, state, initial, true);
         switch (idSplit[3]) {
             case 'battery':
                 this._battery = state.val;
+                this.checkForBatteryChange();
                 this.persistBatteryDevice();
                 if (this._battery < 20) {
-                    this.log(models_1.LogLevel.Warn, `Das Zigbee Gerät hat unter 20% Batterie.`);
+                    this.log(models_1.LogLevel.Warn, 'Das Zigbee Gerät hat unter 20% Batterie.');
                 }
                 break;
             case 'humidity':
@@ -78,29 +95,35 @@ class ZigbeeSonoffTemp extends BaseDevices_1.ZigbeeDevice {
                 break;
         }
     }
+    /** @inheritDoc */
     addHumidityCallback(pCallback) {
         this._humidityCallbacks.push(pCallback);
         if (this._humidity > 0) {
-            pCallback(this._humidity);
+            pCallback(new models_1.HumiditySensorChangeAction(this, this._humidity));
         }
     }
+    /** @inheritDoc */
     addTempChangeCallback(pCallback) {
         this._temperaturCallbacks.push(pCallback);
         if (this._temperature > baseDeviceInterfaces_1.UNDEFINED_TEMP_VALUE) {
-            pCallback(this._temperature);
+            pCallback(new models_1.TemperatureSensorChangeAction(this, this._temperature));
         }
     }
+    /** @inheritDoc */
     onTemperaturChange(newTemperatur) {
         this.roomTemperature = newTemperatur;
     }
+    /** @inheritDoc */
     persistTemperaturSensor() {
         var _a;
         (_a = services_1.Utils.dbo) === null || _a === void 0 ? void 0 : _a.persistTemperatureSensor(this);
     }
+    /** @inheritDoc */
     persistHumiditySensor() {
         var _a;
         (_a = services_1.Utils.dbo) === null || _a === void 0 ? void 0 : _a.persistHumiditySensor(this);
     }
+    /** @inheritDoc */
     persistBatteryDevice() {
         var _a;
         const now = services_1.Utils.nowMS();
@@ -110,6 +133,7 @@ class ZigbeeSonoffTemp extends BaseDevices_1.ZigbeeDevice {
         (_a = services_1.Utils.dbo) === null || _a === void 0 ? void 0 : _a.persistBatteryDevice(this);
         this._lastBatteryPersist = now;
     }
+    /** @inheritDoc */
     dispose() {
         if (this.persistTemperatureSensorInterval) {
             clearInterval(this.persistTemperatureSensorInterval);
@@ -119,5 +143,18 @@ class ZigbeeSonoffTemp extends BaseDevices_1.ZigbeeDevice {
         }
         super.dispose();
     }
+    /**
+     * 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.ZigbeeSonoffTemp = ZigbeeSonoffTemp;

package/lib/server/devices/zigbee/zigbeeTuyaValve.d.ts

@@ -1,18 +1,25 @@
 import { ZigbeeHeater } from './BaseDevices';
 import { IoBrokerDeviceInfo } from '../IoBrokerDeviceInfo';
 export declare class ZigbeeTuyaValve extends ZigbeeHeater {
-    private _setLocalTempCalibrationId;
+    private readonly _setLocalTempCalibrationId;
     private _targetTempVal;
     private _localTempVal;
     private _localDiffTempVal;
     private _setModeId;
     private _mode;
+    /**
+     * Creates an instance of {@link DeviceType.ZigbeeTuyaValve}.
+     * @param pInfo - Device creation information
+     */
     constructor(pInfo: IoBrokerDeviceInfo);
+    /** @inheritDoc */
     set seasonTurnOff(value: boolean);
-    get roomTemperatur(): number;
-    set roomTemperatur(value: number);
+    /** @inheritDoc */
     set desiredTemperature(val: number);
+    /** @inheritDoc */
+    protected set roomTemperatur(value: number);
     private get tempDiff();
+    /** @inheritDoc */
     update(idSplit: string[], state: ioBroker.State, initial?: boolean): void;
     private checkTempDiff;
     private setLocalDiff;

package/lib/server/devices/zigbee/zigbeeTuyaValve.js

@@ -7,6 +7,10 @@ const baseDeviceInterfaces_1 = require("../baseDeviceInterfaces");
 const models_1 = require("../../../models");
 const services_1 = require("../../services");
 class ZigbeeTuyaValve extends BaseDevices_1.ZigbeeHeater {
+    /**
+     * Creates an instance of {@link DeviceType.ZigbeeTuyaValve}.
+     * @param pInfo - Device creation information
+     */
     constructor(pInfo) {
         super(pInfo, deviceType_1.DeviceType.ZigbeeTuyaValve);
         this._targetTempVal = baseDeviceInterfaces_1.UNDEFINED_TEMP_VALUE;
@@ -17,13 +21,17 @@ class ZigbeeTuyaValve extends BaseDevices_1.ZigbeeHeater {
         this._setLocalTempCalibrationId = `${this.info.fullID}.local_temp_calibration`;
         this._setModeId = `${this.info.fullID}.mode`;
     }
+    /** @inheritDoc */
     set seasonTurnOff(value) {
         this._seasonTurnOff = value;
         this.setMode(value ? 'off' : 'auto');
     }
-    get roomTemperatur() {
-        return this._roomTemperature;
+    /** @inheritDoc */
+    set desiredTemperature(val) {
+        this._desiredTemperatur = val;
+        this.checkTempDiff();
     }
+    /** @inheritDoc */
     set roomTemperatur(value) {
         this._roomTemperature = value;
         if (this.settings.useOwnTemperatur) {
@@ -31,13 +39,10 @@ class ZigbeeTuyaValve extends BaseDevices_1.ZigbeeHeater {
         }
         this.checkTempDiff();
     }
-    set desiredTemperature(val) {
-        this._desiredTemperatur = val;
-        this.checkTempDiff();
-    }
     get tempDiff() {
         return this._targetTempVal - (this._localTempVal + this._localDiffTempVal);
     }
+    /** @inheritDoc */
     update(idSplit, state, initial = false) {
         switch (idSplit[3]) {
             case 'valve_position':

package/lib/server/devices/zigbee/zigbeeUbisysActuator.d.ts

@@ -4,8 +4,15 @@ import { IoBrokerDeviceInfo } from '../IoBrokerDeviceInfo';
 import { iLoadMeter } from '../baseDeviceInterfaces/iLoadMeter';
 export declare class ZigbeeUbisysActuator extends ZigbeeActuator implements iLoadMeter {
     private _loadPower;
+    protected readonly _actuatorOnStateIdState: string;
+    /**
+     * Creates an instance of {@link DeviceType.ZigbeeUbisysActuator} or a derived class like {@link ZigbeeUbisysLampe}
+     * @param pInfo - Device creation information
+     * @param deviceType - The device type (if not {@link DeviceType.ZigbeeUbisysActuator})
+     */
     constructor(pInfo: IoBrokerDeviceInfo, deviceType?: DeviceType);
-    get isActuatorOn(): boolean;
+    /** @inheritDoc */
     get loadPower(): number;
-    update(idSplit: string[], state: ioBroker.State, initial?: boolean, handledByChildObject?: boolean): void;
+    /** @inheritDoc */
+    update(idSplit: string[], state: ioBroker.State, initial?: boolean): void;
 }

package/lib/server/devices/zigbee/zigbeeUbisysActuator.js

@@ -6,21 +6,23 @@ const models_1 = require("../../../models");
 const deviceType_1 = require("../deviceType");
 const DeviceCapability_1 = require("../DeviceCapability");
 class ZigbeeUbisysActuator extends BaseDevices_1.ZigbeeActuator {
+    /**
+     * Creates an instance of {@link DeviceType.ZigbeeUbisysActuator} or a derived class like {@link ZigbeeUbisysLampe}
+     * @param pInfo - Device creation information
+     * @param deviceType - The device type (if not {@link DeviceType.ZigbeeUbisysActuator})
+     */
     constructor(pInfo, deviceType = deviceType_1.DeviceType.ZigbeeUbisysActuator) {
-        super(pInfo, deviceType, `${pInfo.fullID}.state`);
+        super(pInfo, deviceType);
         this._loadPower = 0;
         this.deviceCapabilities.push(DeviceCapability_1.DeviceCapability.loadMetering);
+        this._actuatorOnStateIdState = `${pInfo.fullID}.state`;
     }
-    get isActuatorOn() {
-        return this.actuatorOn;
-    }
+    /** @inheritDoc */
     get loadPower() {
         return this._loadPower;
     }
-    update(idSplit, state, initial = false, handledByChildObject = false) {
-        if (!handledByChildObject) {
-            this.log(models_1.LogLevel.DeepTrace, `Aktuator Update: ID: ${idSplit.join('.')} JSON: ${JSON.stringify(state)}`);
-        }
+    /** @inheritDoc */
+    update(idSplit, state, initial = false) {
         switch (idSplit[3]) {
             case 'load_power':
                 const newLoadPower = state.val;

package/lib/server/devices/zigbee/zigbeeUbisysLampe.d.ts

@@ -1,14 +1,13 @@
-import { LampSetLightCommand, LampSetTimeBasedCommand, LampToggleLightCommand } from '../../../models';
 import { iLamp } from '../baseDeviceInterfaces';
 import { IoBrokerDeviceInfo } from '../IoBrokerDeviceInfo';
-import { ZigbeeUbisysActuator } from './zigbeeUbisysActuator';
-export declare class ZigbeeUbisysLampe extends ZigbeeUbisysActuator implements iLamp {
+import { ZigbeeLamp } from './BaseDevices';
+import { iLoadMeter } from '../baseDeviceInterfaces/iLoadMeter';
+export declare class ZigbeeUbisysLampe extends ZigbeeLamp implements iLamp, iLoadMeter {
+    protected readonly _actuatorOnStateIdState: string;
+    private _loadPower;
     constructor(pInfo: IoBrokerDeviceInfo);
-    get lightOn(): boolean;
+    /** @inheritDoc */
+    get loadPower(): number;
+    /** @inheritDoc */
     update(idSplit: string[], state: ioBroker.State, initial?: boolean): void;
-    /** @inheritdoc */
-    setLight(c: LampSetLightCommand): void;
-    toggleLight(c: LampToggleLightCommand): boolean;
-    setTimeBased(c: LampSetTimeBasedCommand): void;
-    persist(): void;
 }

package/lib/server/devices/zigbee/zigbeeUbisysLampe.js

@@ -3,39 +3,29 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ZigbeeUbisysLampe = void 0;
 const deviceType_1 = require("../deviceType");
 const models_1 = require("../../../models");
-const services_1 = require("../../services");
+const BaseDevices_1 = require("./BaseDevices");
 const DeviceCapability_1 = require("../DeviceCapability");
-const zigbeeUbisysActuator_1 = require("./zigbeeUbisysActuator");
-const sharedFunctions_1 = require("../sharedFunctions");
-class ZigbeeUbisysLampe extends zigbeeUbisysActuator_1.ZigbeeUbisysActuator {
+class ZigbeeUbisysLampe extends BaseDevices_1.ZigbeeLamp {
     constructor(pInfo) {
         super(pInfo, deviceType_1.DeviceType.ZigbeeUbisysLampe);
-        this.deviceCapabilities.push(DeviceCapability_1.DeviceCapability.lamp);
+        this._loadPower = 0;
+        this.deviceCapabilities.push(DeviceCapability_1.DeviceCapability.loadMetering);
+        this._actuatorOnStateIdState = `${pInfo.fullID}.state`;
     }
-    get lightOn() {
-        return super.isActuatorOn;
+    /** @inheritDoc */
+    get loadPower() {
+        return this._loadPower;
     }
+    /** @inheritDoc */
     update(idSplit, state, initial = false) {
-        super.update(idSplit, state, initial, true);
         switch (idSplit[3]) {
-            case 'state':
-                this.log(models_1.LogLevel.Trace, `Lampen Update für ${this.info.customName} auf ${state.val}`);
+            case 'load_power':
+                const newLoadPower = state.val;
+                this.log(Math.abs(newLoadPower - this._loadPower) > 0.25 ? models_1.LogLevel.Trace : models_1.LogLevel.DeepTrace, `Outlet update, new current load power: ${state.val}`);
+                this._loadPower = newLoadPower;
                 break;
         }
-    }
-    /** @inheritdoc */
-    setLight(c) {
-        super.setActuator(c);
-    }
-    toggleLight(c) {
-        return sharedFunctions_1.LampUtils.toggleLight(this, c);
-    }
-    setTimeBased(c) {
-        sharedFunctions_1.LampUtils.setTimeBased(this, c);
-    }
-    persist() {
-        var _a;
-        (_a = services_1.Utils.dbo) === null || _a === void 0 ? void 0 : _a.persistActuator(this);
+        super.update(idSplit, state, initial, true);
     }
 }
 exports.ZigbeeUbisysLampe = ZigbeeUbisysLampe;

package/lib/server/devices/zigbee/zigbeeUbisysShutter.d.ts

@@ -3,6 +3,7 @@ import { IoBrokerDeviceInfo } from '../IoBrokerDeviceInfo';
 export declare class ZigbeeUbisysShutter extends ZigbeeShutter {
     private readonly _positionStateId;
     constructor(pInfo: IoBrokerDeviceInfo);
+    /** @inheritDoc */
     update(idSplit: string[], state: ioBroker.State, initial?: boolean): void;
     protected moveToPosition(pPosition: number): void;
 }

package/lib/server/devices/zigbee/zigbeeUbisysShutter.js

@@ -10,11 +10,12 @@ class ZigbeeUbisysShutter extends BaseDevices_1.ZigbeeShutter {
         this._positionStateId = `${this.info.fullID}.position`;
         // this.presenceStateID = `${this.info.fullID}.1.${HmIpPraezenz.PRESENCE_DETECTION}`;
     }
+    /** @inheritDoc */
     update(idSplit, state, initial = false) {
         switch (idSplit[3]) {
             case 'position':
                 this.log(models_1.LogLevel.Trace, `Shutter Update for ${this.info.customName} to "${state.val}"`);
-                this.currentLevel = state.val;
+                this.setCurrentLevel(state.val, initial);
                 break;
         }
         super.update(idSplit, state, initial, true);

package/lib/server/ioBroker/connection.d.ts

@@ -1,5 +1,3 @@
-/// <reference types="node" />
-/// <reference types="node" />
 import { IncomingMessage } from 'http';
 import { iDisposable } from '../services';
 import { ConnectionCallbacks } from '../../models';
@@ -32,79 +30,79 @@ export declare class IOBrokerConnection implements iDisposable {
     private _isExecutedInBrowser;
     /**
      * Getter isExecutedInBrowser
-     * @return {boolean }
+     * @returns
      */
     get isExecutedInBrowser(): boolean;
     private _enums?;
     /**
      * Getter enums
-     * @return {unknown}
+     * @returns
      */
     get enums(): Record<string, ioBroker.EnumObject> | undefined;
     /**
      * Setter enums
-     * @param {unknown} value
+     * @param value
      */
     set enums(value: Record<string, ioBroker.EnumObject> | undefined);
     private _isAuthDone;
     /**
      * Getter isAuthDone
-     * @return {boolean }
+     * @returns
      */
     get isAuthDone(): boolean;
     private _namespace;
     /**
      * Getter namespace
-     * @return {string }
+     * @returns
      */
     get namespace(): string;
     /**
      * Setter namespace
-     * @param {string } value
+     * @param value
      */
     set namespace(value: string);
     private _objects?;
     /**
      * Getter objects
-     * @return {unknown}
+     * @returns
      */
     get objects(): Record<string, ioBroker.Object> | undefined;
     /**
      * Setter objects
-     * @param {unknown} value
+     * @param value
      */
     set objects(value: Record<string, ioBroker.Object> | undefined);
     private _type;
     /**
      * Getter type
-     * @return {string }
+     * @returns
      */
     get type(): string;
     /**
      * Setter type
-     * @param {string } value
+     * @param value
      */
     set type(value: string);
     private _timeout;
     /**
      * Getter timeout
-     * @return {number }
+     * @returns
      */
     get timeout(): number;
     /**
      * Setter timeout
-     * @param {number } value
+     * @param value
      */
     set timeout(value: number);
     private _user;
     /**
      * Getter user
-     * @return {unknown}
+     * @returns
      */
     get user(): string;
     /**
      * Setter user
-     * @param {unknown} value
+     * @param value
      */
     set user(value: string);
     reconnect(pConnOptions: unknown): void;
@@ -113,7 +111,7 @@ export declare class IOBrokerConnection implements iDisposable {
     readFile(filename: string, callback: ioBroker.ReadFileCallback, isRemote: boolean): void;
     getMimeType(ext: string): string;
     readFile64(filename: string, callback: unknown, isRemote: boolean): void;
-    writeFile(filename: string, data: unknown | string, mode: number, callback: ioBroker.ErrnoCallback, ...args: unknown[]): void;
+    writeFile(filename: string, data: unknown | string, mode: number, callback: ioBroker.ErrnoCallback, ..._args: unknown[]): void;
     writeFile64(filename: string, data: string, callback: ioBroker.ErrnoCallback): void;
     readDir(dirname: string, callback: ioBroker.ReadDirCallback): void;
     mkdir(dirname: string, callback: ioBroker.ErrnoCallback): void;
@@ -123,16 +121,16 @@ export declare class IOBrokerConnection implements iDisposable {
     sendTo(instance: string, command: string, payload: ioBroker.MessagePayload, callback: ioBroker.MessageCallback | ioBroker.MessageCallbackInfo): void;
     getStates(idPattern: string | undefined, callback: ioBroker.GetStatesCallback): void;
     getObjects(useCache: boolean, callback: ioBroker.GetObjectsCallback): void;
-    getChildren(id: string, useCache: boolean, callback: (err?: Error | null, children?: string[]) => void, ...args: unknown[]): void;
+    getChildren(id: string, useCache: boolean, callback: (err?: Error | null, children?: string[]) => void, ..._args: unknown[]): void;
     getObject(id: string, useCache: boolean, callback: ioBroker.GetObjectCallback): void;
     getSyncTime(): Date;
-    addObject(objId: unknown, obj: unknown, callback: unknown): void;
+    addObject(_objId: unknown, _obj: unknown, _callback: unknown): void;
     delObject(objId: string): void;
     httpGet(url: string, callback: (res: IncomingMessage | Error) => void): void;
     logError(errorText: string): void;
     authenticate(user: string, password: string, salt: string): void;
-    getConfig(useCache: boolean, callback: (error: Error | null, conf?: Record<string, any>) => void, ...args: unknown[]): void;
-    sendCommand(instance: string, command: string, data: string | number | boolean | unknown[] | Record<string, any> | null, ack?: boolean): void;
+    getConfig(useCache: boolean, callback: (error: Error | null, conf?: Record<string, unknown>) => void, ..._args: unknown[]): void;
+    sendCommand(instance: string, command: string, data: string | number | boolean | unknown[] | Record<string, unknown> | null, ack?: boolean): void;
     readProjects(callback: (err?: NodeJS.ErrnoException | null, objects?: Array<{
         name: string;
         readOnly: undefined | boolean;
@@ -142,7 +140,7 @@ export declare class IOBrokerConnection implements iDisposable {
     clearCache(): void;
     getHistory(id: string, options: ioBroker.GetHistoryOptions & {
         timeout?: number;
-    }, callback: ioBroker.GetHistoryCallback, ...args: unknown[]): void;
+    }, callback: ioBroker.GetHistoryCallback, ..._args: unknown[]): void;
     private _checkConnection;
     private _monitor;
     private _onAuth;
@@ -150,5 +148,6 @@ export declare class IOBrokerConnection implements iDisposable {
     private _fillChildren;
     private _queueCmdIfRequired;
     private _detectViews;
+    /** @inheritDoc */
     dispose(): void;
 }