hoffmation-base 3.0.3 → 3.1.1

package/lib/devices/CameraDevice.js

@@ -0,0 +1,258 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CameraDevice = void 0;
+const lodash_1 = __importDefault(require("lodash"));
+const settingsObjects_1 = require("../settingsObjects");
+const enums_1 = require("../enums");
+const models_1 = require("../models");
+const action_1 = require("../action");
+const DeviceInfo_1 = require("./DeviceInfo");
+const devices_1 = require("./devices");
+const services_1 = require("../services");
+const utils_1 = require("../utils");
+const api_1 = require("../api");
+const logging_1 = require("../logging");
+class CameraDevice {
+    constructor(name, roomName) {
+        var _a;
+        /** @inheritDoc */
+        this.settings = new settingsObjects_1.CameraSettings();
+        /** @inheritDoc */
+        this.deviceCapabilities = [enums_1.DeviceCapability.camera, enums_1.DeviceCapability.motionSensor];
+        /** @inheritDoc */
+        this.deviceType = enums_1.DeviceType.Camera;
+        /** @inheritDoc */
+        this.detectionsToday = 0;
+        this._lastMotion = 0;
+        this._initialized = false;
+        this._movementDetectedCallback = [];
+        this._lastImage = '';
+        this._personDetected = false;
+        this._dogDetected = false;
+        this._devicesBlockingAlarmMap = new Map();
+        this._movementDetected = false;
+        this._personDetectFallbackTimeout = null;
+        this._movementDetectFallbackTimeout = null;
+        this._dogDetectFallbackTimeout = null;
+        this.name = name;
+        this._info = new DeviceInfo_1.DeviceInfo();
+        this._info.fullName = `Camera ${roomName} ${name}`;
+        this._info.customName = `Camera ${name}`;
+        this._info.room = roomName;
+        this._info.allDevicesKey = `camera-${roomName}-${name}`;
+        devices_1.Devices.alLDevices[this._info.allDevicesKey] = this;
+        this.persistDeviceInfo();
+        this.loadDeviceSettings();
+        if (!services_1.Persistence.anyDboActive) {
+            this._initialized = true;
+        }
+        else {
+            (_a = services_1.Persistence.dbo) === null || _a === void 0 ? void 0 : _a.motionSensorTodayCount(this).then((todayCount) => {
+                var _a;
+                this.detectionsToday = (_a = todayCount.count) !== null && _a !== void 0 ? _a : 0;
+                this.log(enums_1.LogLevel.Debug, `Reinitialized movement counter with ${this.detectionsToday}`);
+                this._initialized = true;
+            }).catch((err) => {
+                var _a;
+                this.log(enums_1.LogLevel.Warn, `Failed to initialize movement counter, err ${(_a = err === null || err === void 0 ? void 0 : err.message) !== null && _a !== void 0 ? _a : err}`);
+            });
+        }
+    }
+    /** @inheritDoc */
+    get lastImage() {
+        return this._lastImage;
+    }
+    /** @inheritDoc */
+    get dogDetected() {
+        return this._dogDetected;
+    }
+    /** @inheritDoc */
+    get personDetected() {
+        return this._personDetected;
+    }
+    /** @inheritDoc */
+    get alarmBlockedByDevices() {
+        return this._devicesBlockingAlarmMap.size > 0;
+    }
+    /** @inheritDoc */
+    get movementDetected() {
+        return this._movementDetected;
+    }
+    /** @inheritDoc */
+    get info() {
+        return this._info;
+    }
+    /** @inheritDoc */
+    get timeSinceLastMotion() {
+        return Math.round((utils_1.Utils.nowMS() - this._lastMotion) / 1000);
+    }
+    /** @inheritDoc */
+    get customName() {
+        return this.info.customName;
+    }
+    /** @inheritDoc */
+    get id() {
+        var _a;
+        return (_a = this.info.allDevicesKey) !== null && _a !== void 0 ? _a : `camera-${this.info.room}-${this.info.customName}`;
+    }
+    /** @inheritDoc */
+    get room() {
+        return api_1.API.getRoom(this.info.room);
+    }
+    /** @inheritDoc */
+    addMovementCallback(pCallback) {
+        this._movementDetectedCallback.push(pCallback);
+    }
+    /** @inheritDoc */
+    blockForDevice(device, block) {
+        if (block) {
+            this._devicesBlockingAlarmMap.set(device.id, device);
+        }
+        else {
+            this._devicesBlockingAlarmMap.delete(device.id);
+        }
+        this.log(enums_1.LogLevel.Debug, `Handle device ${block ? 'block' : 'unblock'}, new blocking amount: ${this._devicesBlockingAlarmMap.size}`);
+    }
+    /** @inheritDoc */
+    persistMotionSensor() {
+        var _a;
+        (_a = services_1.Persistence.dbo) === null || _a === void 0 ? void 0 : _a.persistMotionSensor(this);
+    }
+    log(level, message, debugType = enums_1.LogDebugType.None) {
+        var _a, _b;
+        logging_1.ServerLogService.writeLog(level, `${this.name}: ${message}`, {
+            debugType: debugType,
+            room: (_b = (_a = this.room) === null || _a === void 0 ? void 0 : _a.roomName) !== null && _b !== void 0 ? _b : '',
+            deviceId: this.name,
+            deviceName: this.name,
+        });
+    }
+    toJSON() {
+        return utils_1.Utils.jsonFilter(lodash_1.default.omit(this, [
+            // To reduce Byte-size on cyclic update
+            '_lastImage',
+        ]));
+    }
+    persistDeviceInfo() {
+        utils_1.Utils.guardedTimeout(() => {
+            var _a;
+            (_a = services_1.Persistence.dbo) === null || _a === void 0 ? void 0 : _a.addDevice(this);
+        }, 5000, this);
+    }
+    loadDeviceSettings() {
+        var _a;
+        (_a = this.settings) === null || _a === void 0 ? void 0 : _a.initializeFromDb(this);
+    }
+    onNewMotionDetectedValue(newValue) {
+        if (this.settings.movementDetectionOnPersonOnly) {
+            return;
+        }
+        this.log(enums_1.LogLevel.Debug, `Update for "Motion" to value: ${newValue}`);
+        this.updateMovement(newValue);
+        if (newValue) {
+            this.resetMovementFallbackTimer();
+        }
+    }
+    onNewPersonDetectedValue(newValue) {
+        this.log(enums_1.LogLevel.Debug, `Update for PersonDetected to value: ${newValue}`);
+        if (newValue) {
+            this.log(enums_1.LogLevel.Info, 'Person Detected');
+            this.resetPersonDetectFallbackTimer();
+        }
+        this._personDetected = newValue;
+        if (this.settings.movementDetectionOnPersonOnly) {
+            this.updateMovement(newValue);
+        }
+    }
+    onNewImageSnapshot(image) {
+        this._lastImage = image;
+        utils_1.Utils.guardedTimeout(() => {
+            // Give Person Detected Update some time, as otherwise personDetected might still be false
+            if (this.settings.alertPersonOnTelegram && this._personDetected && !this.alarmBlockedByDevices) {
+                services_1.TelegramService.sendImage(`${this.name} detected Person`, new models_1.Base64Image(this._lastImage, 'person_alert'));
+            }
+        }, 1000);
+    }
+    onNewDogDetectionValue(newDogDetectionVal) {
+        if (newDogDetectionVal) {
+            this.log(enums_1.LogLevel.Info, 'Dog Detected');
+            this.resetDogDetectFallbackTimer();
+        }
+        this._dogDetected = newDogDetectionVal;
+        if (this.settings.movementDetectionOnDogsToo) {
+            this.updateMovement(newDogDetectionVal);
+        }
+    }
+    updateMovement(newState) {
+        if (!this._initialized && newState) {
+            this.log(enums_1.LogLevel.Trace, 'Movement recognized, but database initialization has not finished yet --> delay.');
+            utils_1.Utils.guardedTimeout(() => {
+                this.updateMovement(newState);
+            }, 1000, this);
+            return;
+        }
+        if (newState === this.movementDetected) {
+            this.log(enums_1.LogLevel.Debug, `Skip movement because state is already ${newState}`, enums_1.LogDebugType.SkipUnchangedMovementState);
+            return;
+        }
+        this._lastMotion = utils_1.Utils.nowMS();
+        this._movementDetected = newState;
+        this.persistMotionSensor();
+        this.log(enums_1.LogLevel.Debug, `New movement state: ${newState}`, enums_1.LogDebugType.NewMovementState);
+        if (newState) {
+            this.detectionsToday++;
+            this.log(enums_1.LogLevel.Trace, `This is movement no. ${this.detectionsToday}`);
+        }
+        for (const c of this._movementDetectedCallback) {
+            c(new action_1.MotionSensorAction(this));
+        }
+    }
+    resetPersonDetectFallbackTimer() {
+        if (this._personDetectFallbackTimeout !== null) {
+            clearTimeout(this._personDetectFallbackTimeout);
+            this._personDetectFallbackTimeout = null;
+        }
+        this._personDetectFallbackTimeout = utils_1.Utils.guardedTimeout(() => {
+            this._personDetectFallbackTimeout = null;
+            this._personDetected = false;
+            if (this.settings.movementDetectionOnPersonOnly) {
+                this.updateMovement(false);
+            }
+            this.resetPersonDetectedState();
+        }, 120000, this);
+    }
+    resetMovementFallbackTimer() {
+        if (this._movementDetectFallbackTimeout !== null) {
+            clearTimeout(this._movementDetectFallbackTimeout);
+            this._movementDetectFallbackTimeout = null;
+        }
+        this._movementDetectFallbackTimeout = utils_1.Utils.guardedTimeout(() => {
+            this._movementDetectFallbackTimeout = null;
+            if (!this._movementDetected) {
+                // Der Fallback wird nicht benötigt, da bereits das Movement zurückgesetzt wurde
+                return;
+            }
+            this._movementDetected = false;
+            this.updateMovement(false);
+            this.resetMovementDetectedState();
+        }, 120000, this);
+    }
+    resetDogDetectFallbackTimer() {
+        if (this._dogDetectFallbackTimeout !== null) {
+            clearTimeout(this._dogDetectFallbackTimeout);
+            this._dogDetectFallbackTimeout = null;
+        }
+        this._dogDetectFallbackTimeout = utils_1.Utils.guardedTimeout(() => {
+            this._dogDetectFallbackTimeout = null;
+            this._dogDetected = false;
+            if (this.settings.movementDetectionOnDogsToo) {
+                this.updateMovement(false);
+            }
+            this.resetDogDetectedState();
+        }, 120000, this);
+    }
+}
+exports.CameraDevice = CameraDevice;

package/lib/devices/DeviceInfo.d.ts

@@ -0,0 +1,19 @@
+import { iDeviceInfo } from '../interfaces';
+export declare class DeviceInfo implements iDeviceInfo {
+    /**
+     * The complete name of the device in a human readable format
+     */
+    fullName: string;
+    /**
+     * The roomname matching {@link iRoomBase.roomName}
+     */
+    room: string;
+    /**
+     * If present the key to access this device in {@link Devices.alLDevices}
+     */
+    allDevicesKey?: string;
+    private _customName?;
+    get customName(): string;
+    set customName(val: string);
+    toJSON(): Partial<DeviceInfo>;
+}

package/lib/devices/Griffe.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Griffe = void 0;
+const devices_1 = require("./devices");
+const enums_1 = require("../enums");
+class Griffe {
+    static getGriffPosition() {
+        const griffe = Griffe.getAllGriffe();
+        griffe.sort((a, b) => {
+            return b.position - a.position;
+        });
+        const response = ['These are the current handle positions:'];
+        for (const g of griffe) {
+            response.push(`${enums_1.WindowPosition[g.position]} Window: "${g.info.customName}"`);
+        }
+        return response.join('\n');
+    }
+    static getAllGriffe() {
+        const griffe = [];
+        for (const dID in devices_1.Devices.alLDevices) {
+            const d = devices_1.Devices.alLDevices[dID];
+            if (d.deviceType === enums_1.DeviceType.HmIpGriff) {
+                griffe.push(d);
+            }
+        }
+        return griffe;
+    }
+}
+exports.Griffe = Griffe;

package/lib/devices/Heizgruppen.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Heizgruppen = void 0;
+const devices_1 = require("./devices");
+const enums_1 = require("../enums");
+class Heizgruppen {
+    static getProblems() {
+        const groups = this.getAllGruppen();
+        const response = ['Dies sind die bestehenden Differenzen:'];
+        response.push('Raumname\t\tIst-Temperatur\t\tGerät');
+        for (const g of groups) {
+            const heizungen = g.getBelongingHeizungen();
+            const tempProblem = [`${g.info.room}\t\t${g.iTemperature}°C\t\t${g.info.customName}`];
+            let print = false;
+            for (const h of heizungen) {
+                if (h.iTemperature !== g.iTemperature) {
+                    print = true;
+                }
+                tempProblem.push(`${h.info.room}\t\t${h.iTemperature}°C\t\t${h.info.customName}`);
+            }
+            if (print) {
+                response.push(tempProblem.join('\n'));
+                response.push(' ');
+            }
+        }
+        return response.join('\n');
+    }
+    static getAllGruppen() {
+        const gruppen = [];
+        for (const dID in devices_1.Devices.alLDevices) {
+            const d = devices_1.Devices.alLDevices[dID];
+            if (d.deviceType === enums_1.DeviceType.HmIpHeizgruppe) {
+                gruppen.push(d);
+            }
+        }
+        return gruppen;
+    }
+    static getSpecificGroup(name) {
+        for (const dID in devices_1.Devices.alLDevices) {
+            const d = devices_1.Devices.alLDevices[dID];
+            if (d.deviceType === enums_1.DeviceType.HmIpHeizgruppe && d.info.customName === name) {
+                return d;
+            }
+        }
+        return undefined;
+    }
+}
+exports.Heizgruppen = Heizgruppen;

package/lib/devices/IoBrokerBaseDevice.d.ts

@@ -0,0 +1,81 @@
+import { iIoBrokerBaseDevice, iIOBrokerConnection, iJsonOmitKeys, iPersist, iRoomBase, iRoomDeviceAddingSettings } from '../interfaces';
+import { DeviceSettings } from '../settingsObjects';
+import { DeviceCapability, DeviceType, LogDebugType, LogLevel } from '../enums';
+import { IoBrokerDeviceInfo } from './IoBrokerDeviceInfo';
+export declare abstract class IoBrokerBaseDevice implements iJsonOmitKeys, iIoBrokerBaseDevice {
+    protected _info: IoBrokerDeviceInfo;
+    deviceType: DeviceType;
+    /** @inheritDoc */
+    readonly jsonOmitKeys: string[];
+    /**
+     * The settings for adding devices to Rooms
+     */
+    static roomAddingSettings: {
+        [id: string]: iRoomDeviceAddingSettings;
+    };
+    /**
+     * @inheritDoc
+     * @default undefined (no Settings)
+     */
+    settings: DeviceSettings | undefined;
+    private _room;
+    /** @inheritDoc */
+    readonly deviceCapabilities: DeviceCapability[];
+    protected _debounceStateDelay: number;
+    protected _lastWrite: number;
+    protected stateMap: Map<string, ioBroker.State>;
+    /** @inheritDoc */
+    get room(): iRoomBase;
+    protected get dbo(): iPersist | undefined;
+    /** @inheritDoc */
+    get customName(): string;
+    protected get anyDboActive(): boolean;
+    protected readonly individualStateCallbacks: Map<string, Array<(val: ioBroker.StateValue) => void>>;
+    protected constructor(_info: IoBrokerDeviceInfo, deviceType: DeviceType);
+    /** @inheritDoc */
+    get id(): string;
+    /**
+     * Getter info
+     * @returns The device info
+     */
+    get info(): IoBrokerDeviceInfo;
+    get ioConn(): iIOBrokerConnection | undefined;
+    static addRoom(shortName: string, settings: iRoomDeviceAddingSettings): void;
+    static checkMissing(): void;
+    /** @inheritDoc */
+    loadDeviceSettings(): void;
+    /**
+     * Allows to react on the state change of a given state with the passed cb
+     * @param stateName - Last part of the id e.g. "available" not "zigbee.0.00158d00053d3e4b.available"
+     * @param cb - Desired Callback Action, with passed ioBroker.StateValue
+     */
+    addIndividualStateCallback(stateName: string, cb: (val: ioBroker.StateValue) => void): void;
+    /**
+     * Returns whether a connection to ioBroker is established or not
+     * @param showError - If true, an error message will be written to the log if the connection is not established
+     * @returns Whether a connection exists
+     */
+    checkIoConnection(showError?: boolean): boolean;
+    /**
+     * Updates the state of a given data point
+     * @param {string[]} idSplit - ID of the data point
+     * @param {ioBroker.State} state - New state
+     * @param {boolean} initial - Whether this is during the initial update
+     * @param {boolean} pOverride - Whether the child class did override this method
+     */
+    abstract update(idSplit: string[], state: ioBroker.State, initial: boolean, pOverride: boolean): void;
+    log(level: LogLevel, message: string, logDebugType?: LogDebugType): void;
+    /** @inheritDoc */
+    toJSON(): Partial<IoBrokerBaseDevice>;
+    /** @inheritDoc */
+    persistDeviceInfo(): void;
+    addToCorrectRoom(): void;
+    /**
+     * Sets the state of a given data point and returns true if that was successful.
+     * @param pointId - Data point to write to
+     * @param state - Data to write
+     * @param onSuccess - Callback to run on successfully written data
+     * @param onError - Callback to run if an error has occurred during writing the data
+     */
+    setState(pointId: string, state: string | number | boolean | ioBroker.State | ioBroker.SettableState | null, onSuccess?: (() => void) | undefined, onError?: ((error: Error) => void) | undefined): void;
+}

package/lib/devices/IoBrokerBaseDevice.js

@@ -0,0 +1,199 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IoBrokerBaseDevice = void 0;
+const services_1 = require("../services");
+const enums_1 = require("../enums");
+const utils_1 = require("../utils");
+const api_1 = require("../api");
+const logging_1 = require("../logging");
+const ioBroker_1 = require("../ioBroker");
+class IoBrokerBaseDevice {
+    /** @inheritDoc */
+    get room() {
+        if (this._room === undefined) {
+            this._room = utils_1.Utils.guard(api_1.API.getRoom(this.info.room));
+        }
+        return this._room;
+    }
+    get dbo() {
+        return services_1.Persistence.dbo;
+    }
+    /** @inheritDoc */
+    get customName() {
+        return this.info.customName;
+    }
+    get anyDboActive() {
+        return services_1.Persistence.anyDboActive;
+    }
+    constructor(_info, deviceType) {
+        this._info = _info;
+        this.deviceType = deviceType;
+        /** @inheritDoc */
+        this.jsonOmitKeys = ['individualStateCallbacks'];
+        /**
+         * @inheritDoc
+         * @default undefined (no Settings)
+         */
+        this.settings = undefined;
+        this._room = undefined;
+        /** @inheritDoc */
+        this.deviceCapabilities = [];
+        // If configured > 0, this indicates the minimum time between state writes in ms
+        this._debounceStateDelay = 0;
+        this._lastWrite = 0;
+        this.stateMap = new Map();
+        this.individualStateCallbacks = new Map();
+        this.addToCorrectRoom();
+        this.persistDeviceInfo();
+        utils_1.Utils.guardedTimeout(this.loadDeviceSettings, 300, this);
+    }
+    /** @inheritDoc */
+    get id() {
+        const result = utils_1.Utils.guard(this.info.allDevicesKey);
+        if (result === '0' || result === '1') {
+            logging_1.ServerLogService.writeLog(enums_1.LogLevel.Warn, `Device "${this.info.fullName}" has an akward allDevicesKey of "${result}"`);
+        }
+        return result;
+    }
+    /**
+     * Getter info
+     * @returns The device info
+     */
+    get info() {
+        return this._info;
+    }
+    get ioConn() {
+        return ioBroker_1.ioBrokerMain.iOConnection;
+    }
+    static addRoom(shortName, settings) {
+        if (this.roomAddingSettings[shortName] !== undefined) {
+            logging_1.ServerLogService.writeLog(enums_1.LogLevel.Alert, `Es gibt bereits ein Registrat für Roomsetings für den Raumnamen "${shortName}"`);
+            return;
+        }
+        this.roomAddingSettings[shortName] = settings;
+    }
+    static checkMissing() {
+        for (const rName in this.roomAddingSettings) {
+            this.roomAddingSettings[rName].checkMissing();
+        }
+    }
+    /** @inheritDoc */
+    loadDeviceSettings() {
+        var _a;
+        (_a = this.settings) === null || _a === void 0 ? void 0 : _a.initializeFromDb(this);
+    }
+    /**
+     * Allows to react on the state change of a given state with the passed cb
+     * @param stateName - Last part of the id e.g. "available" not "zigbee.0.00158d00053d3e4b.available"
+     * @param cb - Desired Callback Action, with passed ioBroker.StateValue
+     */
+    addIndividualStateCallback(stateName, cb) {
+        let arr = this.individualStateCallbacks.get(stateName);
+        if (arr === undefined) {
+            arr = [cb];
+        }
+        else {
+            arr.push(cb);
+        }
+        this.individualStateCallbacks.set(stateName, arr);
+    }
+    /**
+     * Returns whether a connection to ioBroker is established or not
+     * @param showError - If true, an error message will be written to the log if the connection is not established
+     * @returns Whether a connection exists
+     */
+    checkIoConnection(showError = false) {
+        if (!this.ioConn && showError) {
+            logging_1.ServerLogService.writeLog(enums_1.LogLevel.Error, `No connection active for "${this.info.customName}".`);
+        }
+        return this.ioConn !== undefined;
+    }
+    log(level, message, logDebugType = enums_1.LogDebugType.None) {
+        logging_1.ServerLogService.writeLog(level, message, {
+            room: this.info.room,
+            deviceId: this.id,
+            deviceName: this.info.customName,
+            debugType: logDebugType,
+        });
+    }
+    /** @inheritDoc */
+    toJSON() {
+        return utils_1.Utils.jsonFilter(this, this.jsonOmitKeys, ['_room']);
+    }
+    /** @inheritDoc */
+    persistDeviceInfo() {
+        utils_1.Utils.guardedTimeout(() => {
+            var _a;
+            (_a = services_1.Persistence.dbo) === null || _a === void 0 ? void 0 : _a.addDevice(this);
+        }, 5000, this);
+    }
+    addToCorrectRoom() {
+        const settings = IoBrokerBaseDevice.roomAddingSettings[this.info.room];
+        if (settings !== undefined) {
+            if (settings.devices[this.deviceType] === undefined) {
+                logging_1.ServerLogService.missingRoomHandling(settings.RoomName, this.deviceType);
+                return;
+            }
+            const deviceSettings = settings.devices[this.deviceType][this.info.deviceRoomIndex];
+            if (deviceSettings === undefined) {
+                logging_1.ServerLogService.missingRoomIndexHandling(settings.RoomName, this.info.deviceRoomIndex, this.deviceType);
+                return;
+            }
+            if (deviceSettings.customName !== undefined) {
+                this.info.customName = deviceSettings.customName;
+            }
+            if (this.info.allDevicesKey === undefined) {
+                logging_1.ServerLogService.writeLog(enums_1.LogLevel.Error, `AllDevicesKey for Device "${this.info.fullName}"/"${this.info.fullID}" missing.`);
+                return;
+            }
+            const room = deviceSettings.setID(this.info.allDevicesKey);
+            if (room !== undefined) {
+                this._room = room;
+            }
+            deviceSettings.added = true;
+            logging_1.ServerLogService.addedDeviceToRoom(settings.RoomName, this.deviceType, this.info.deviceRoomIndex);
+            return;
+        }
+        logging_1.ServerLogService.writeLog(enums_1.LogLevel.Warn, `${this.info.room} is noch kein bekannter Raum`);
+    }
+    /**
+     * Sets the state of a given data point and returns true if that was successful.
+     * @param pointId - Data point to write to
+     * @param state - Data to write
+     * @param onSuccess - Callback to run on successfully written data
+     * @param onError - Callback to run if an error has occurred during writing the data
+     */
+    setState(pointId, state, onSuccess = undefined, onError = undefined) {
+        var _a;
+        if (!this.checkIoConnection(true)) {
+            return;
+        }
+        if (this._debounceStateDelay > 0 && utils_1.Utils.nowMS() - this._lastWrite < this._debounceStateDelay) {
+            utils_1.Utils.guardedTimeout(() => {
+                this.log(enums_1.LogLevel.Trace, `Debounced write for ${pointId} to ${state}`);
+                this.setState(pointId, state, onSuccess, onError);
+            }, this._debounceStateDelay, this);
+            return;
+        }
+        this._lastWrite = utils_1.Utils.nowMS();
+        (_a = this.ioConn) === null || _a === void 0 ? void 0 : _a.setState(pointId, state, (err) => {
+            if (err) {
+                if (onError) {
+                    onError(err);
+                }
+                else {
+                    this.log(enums_1.LogLevel.Error, `Error occured while setting state "${pointId}" to "${state}": ${err}`);
+                }
+                return;
+            }
+            if (onSuccess) {
+                onSuccess();
+            }
+        });
+    }
+}
+exports.IoBrokerBaseDevice = IoBrokerBaseDevice;
+/**
+ * The settings for adding devices to Rooms
+ */
+IoBrokerBaseDevice.roomAddingSettings = {};

package/lib/devices/IoBrokerDeviceInfo.d.ts

@@ -0,0 +1,25 @@
+import { iDeviceConfig } from '../interfaces/iDeviceConfig';
+import { DeviceInfo } from './DeviceInfo';
+import { iIoBrokerDeviceInfo } from '../interfaces';
+export declare class IoBrokerDeviceInfo extends DeviceInfo implements iIoBrokerDeviceInfo {
+    devID: string;
+    deviceType: string;
+    deviceRoomIndex: number;
+    type: 'device' | 'channel' | 'state';
+    fullID: string;
+    devConf: iDeviceConfig;
+    static idSplitter(id: string): string[];
+    private static replaceInvalidIdChars;
+    /**
+     * Extracts the relevant infos from the passed deviceConfig and combines them in a new Info object
+     * @param pDevConf - The device Config based on the extracted devices.json from ioBroker
+     * @param deviceId - The id of the device
+     * @param deviceType - The type of the device
+     * @param room - The room id of the device
+     * @param deviceRoomIndex - Index of this device in regards to the devicetype.
+     */
+    constructor(pDevConf: iDeviceConfig, deviceId: string, deviceType: string, room: string, deviceRoomIndex: number);
+    static byStateJsSplit(pDevConf: iDeviceConfig): IoBrokerDeviceInfo;
+    static byDeviceConfig(pDevConf: iDeviceConfig): IoBrokerDeviceInfo;
+    toJSON(): Partial<IoBrokerDeviceInfo>;
+}