hoffmation-base 0.1.14 → 0.1.18

package/lib/server/devices/hmIPDevices/hmIpPraezenz.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HmIpPraezenz = void 0;
+const hmIpDevice_1 = require("./hmIpDevice");
+const hmIpDeviceType_1 = require("./hmIpDeviceType");
+const logLevel_1 = require("../../../models/logLevel");
+const log_service_1 = require("../../services/log-service");
+const persist_1 = require("../../services/dbo/persist");
+const utils_1 = require("../../services/utils/utils");
+const CurrentIlluminationDataPoint_1 = require("../../../models/persistence/CurrentIlluminationDataPoint");
+class HmIpPraezenz extends hmIpDevice_1.HmIPDevice {
+    constructor(pInfo) {
+        super(pInfo, hmIpDeviceType_1.HmIpDeviceType.HmIpPraezenz);
+        this.excludeFromNightAlarm = false;
+        this.presenceDetected = false;
+        this._detectionsToday = 0;
+        this._presenceDetectedCallback = [];
+        // private presenceStateID: string;
+        this.initialized = false;
+        this._currentIllumination = -1;
+        // this.presenceStateID = `${this.info.fullID}.1.${HmIpPraezenz.PRESENCE_DETECTION}`;
+        persist_1.Persist.getCount(this).then((todayCount) => {
+            this.detectionsToday = todayCount.counter;
+            log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Debug, `Präsenzcounter "${this.info.customName}" vorinitialisiert mit ${this.detectionsToday}`);
+            this.initialized = true;
+        });
+    }
+    get detectionsToday() {
+        return this._detectionsToday;
+    }
+    set detectionsToday(pVal) {
+        const oldVal = this._detectionsToday;
+        this._detectionsToday = pVal;
+        persist_1.Persist.persistTodayCount(this, pVal, oldVal);
+    }
+    get currentIllumination() {
+        return this._currentIllumination;
+    }
+    set currentIllumination(value) {
+        var _a, _b;
+        this._currentIllumination = value;
+        persist_1.Persist.persistCurrentIllumination(new CurrentIlluminationDataPoint_1.CurrentIlluminationDataPoint(this.info.room, this.info.devID, value, new Date(), (_b = (_a = this.room) === null || _a === void 0 ? void 0 : _a.LampenGroup.anyLightsOwn()) !== null && _b !== void 0 ? _b : false));
+    }
+    addPresenceCallback(pCallback) {
+        this._presenceDetectedCallback.push(pCallback);
+    }
+    update(idSplit, state, initial = false) {
+        log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Trace, `Präzens Update: JSON: ${JSON.stringify(state)}ID: ${idSplit.join('.')}`);
+        super.update(idSplit, state, initial, true);
+        if (idSplit[3] !== '1') {
+            // Nur die Infos in Kanal 1 sind relevant
+            return;
+        }
+        switch (idSplit[4]) {
+            case HmIpPraezenz.PRESENCE_DETECTION:
+                this.updatePresence(state.val);
+                break;
+            case HmIpPraezenz.CURRENT_ILLUMINATION:
+                this.currentIllumination = state.val;
+                break;
+        }
+    }
+    updatePresence(pVal) {
+        if (!this.initialized && pVal) {
+            log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Debug, `Präsenz für "${this.info.customName}" erkannt aber die Initialisierung aus der DB ist noch nicht erfolgt --> verzögern`);
+            utils_1.Utils.guardedTimeout(() => {
+                this.updatePresence(pVal);
+            }, 1000, this);
+            return;
+        }
+        if (pVal === this.presenceDetected) {
+            log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Debug, `Überspringe Präsenz für "${this.info.customName}" da bereits der Wert ${pVal} vorliegt`);
+            return;
+        }
+        this.presenceDetected = pVal;
+        log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Debug, `Neuer Präsenzstatus Wert für "${this.info.customName}": ${pVal}`);
+        if (pVal) {
+            this.detectionsToday++;
+            log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Trace, `Dies ist die ${this.detectionsToday} Bewegung für "${this.info.customName}"`);
+        }
+        for (const c of this._presenceDetectedCallback) {
+            c(pVal);
+        }
+    }
+}
+exports.HmIpPraezenz = HmIpPraezenz;
+HmIpPraezenz.PRESENCE_DETECTION = 'PRESENCE_DETECTION_STATE';
+// private static ILLUMINATION_DURING_MOVEMENT: string = 'CURRENT_ILLUMINATION';
+HmIpPraezenz.CURRENT_ILLUMINATION = 'ILLUMINATION';

package/lib/server/devices/hmIPDevices/hmIpRoll.d.ts

@@ -0,0 +1,22 @@
+/// <reference types="iobroker" />
+import { Fenster } from './Fenster';
+import { HmIPDevice } from './hmIpDevice';
+import { DeviceInfo } from '../DeviceInfo';
+export declare class HmIpRoll extends HmIPDevice {
+    get currentLevel(): number;
+    set currentLevel(value: number);
+    get desiredFensterLevel(): number;
+    private _currentLevel;
+    private _setLevelSwitchID;
+    private _fenster?;
+    private _firstCommandRecieved;
+    private _setLevel;
+    private _setLevelTime;
+    set Fenster(value: Fenster);
+    constructor(pInfo: DeviceInfo);
+    update(idSplit: string[], state: ioBroker.State, initial?: boolean): void;
+    setLevel(pPosition: number, initial?: boolean, skipOpenWarning?: boolean): void;
+    down(initial?: boolean): void;
+    middle(): void;
+    up(initial?: boolean): void;
+}

package/lib/server/devices/hmIPDevices/hmIpRoll.js

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HmIpRoll = void 0;
+const logLevel_1 = require("../../../models/logLevel");
+const FensterPosition_1 = require("./FensterPosition");
+const hmIpDevice_1 = require("./hmIpDevice");
+const hmIpDeviceType_1 = require("./hmIpDeviceType");
+const log_service_1 = require("../../services/log-service");
+const utils_1 = require("../../services/utils/utils");
+class HmIpRoll extends hmIpDevice_1.HmIPDevice {
+    constructor(pInfo) {
+        super(pInfo, hmIpDeviceType_1.HmIpDeviceType.HmIpRoll);
+        this._currentLevel = -1;
+        this._firstCommandRecieved = false;
+        this._setLevel = -1;
+        this._setLevelTime = -1;
+        this._setLevelSwitchID = `${this.info.fullID}.4.LEVEL`;
+    }
+    get currentLevel() {
+        if (this._setLevel !== -1 && this._currentLevel !== this._setLevel) {
+            return this._setLevel;
+        }
+        return this._currentLevel;
+    }
+    set currentLevel(value) {
+        if (value !== this._setLevel && utils_1.Utils.nowMS() - this._setLevelTime < 60 * 10000) {
+            value = this._setLevel;
+        }
+        if (value !== this._currentLevel && this._fenster) {
+            utils_1.Utils.guardedNewThread(() => {
+                var _a;
+                (_a = this._fenster) === null || _a === void 0 ? void 0 : _a.rolloPositionChange(value);
+            }, this);
+        }
+        this._currentLevel = value;
+    }
+    get desiredFensterLevel() {
+        if (this._fenster === undefined) {
+            return -1;
+        }
+        return this._fenster.desiredPosition;
+    }
+    set Fenster(value) {
+        this._fenster = value;
+    }
+    update(idSplit, state, initial = false) {
+        log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.DeepTrace, `Rollo Update für "${this.info.customName}": ID: ${idSplit.join('.')} JSON: ${JSON.stringify(state)}`);
+        super.update(idSplit, state, initial, true);
+        switch (idSplit[3]) {
+            case '3':
+                if (idSplit[4] === 'LEVEL') {
+                    this.currentLevel = state.val;
+                }
+                break;
+        }
+    }
+    setLevel(pPosition, initial = false, skipOpenWarning = false) {
+        if (!this._firstCommandRecieved && !initial) {
+            this._firstCommandRecieved = true;
+        }
+        if (this._firstCommandRecieved && initial) {
+            log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Debug, `Skipped initial Rollo "${this.info.customName}" to ${pPosition} as we recieved a command already`);
+            return;
+        }
+        if (this.currentLevel === pPosition) {
+            log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Debug, `Skip Rollo command for "${this.info.customName}" to Position ${pPosition} as this is the current one`);
+            return;
+        }
+        if (this._setLevelSwitchID === '') {
+            console.error(`Keine Switch ID für "${this.info.customName}" bekannt.`);
+            return;
+        }
+        if (!this.ioConn) {
+            console.error(`Keine Connection für "${this.info.customName}" bekannt.`);
+            return;
+        }
+        if (this._fenster !== undefined) {
+            if (this._fenster.griffeInPosition(FensterPosition_1.FensterPosition.offen) > 0 && pPosition < 100) {
+                if (!skipOpenWarning) {
+                    log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Alert, `Fahre Rollo "${this.info.customName}" nicht runter, weil das Fenster offen ist!`);
+                }
+                return;
+            }
+            if (this._fenster.griffeInPosition(FensterPosition_1.FensterPosition.kipp) > 0 && pPosition < 50) {
+                pPosition = 50;
+                if (!skipOpenWarning) {
+                    log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Alert, `Fahre Rollo "${this.info.customName}" nicht runter, weil das Fenster auf Kipp ist!`);
+                }
+            }
+        }
+        this._setLevel = pPosition;
+        log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Debug, `Fahre Rollo "${this.info.customName}" auf Position ${pPosition}`);
+        this.ioConn.setState(this._setLevelSwitchID, pPosition);
+    }
+    down(initial = false) {
+        this.setLevel(0, initial);
+    }
+    middle() {
+        this.setLevel(50);
+    }
+    up(initial = false) {
+        this.setLevel(100, initial);
+    }
+}
+exports.HmIpRoll = HmIpRoll;

package/lib/server/devices/hmIPDevices/hmIpTaster.d.ts

@@ -0,0 +1,13 @@
+/// <reference types="iobroker" />
+import { HmIPDevice } from './hmIpDevice';
+import { DeviceInfo } from '../DeviceInfo';
+import { Taste } from '../taste';
+import { iTaster } from '../iTaster';
+export declare class HmIpTaster extends HmIPDevice implements iTaster {
+    tasten: {
+        [id: string]: Taste;
+    };
+    constructor(pInfo: DeviceInfo);
+    update(idSplit: string[], state: ioBroker.State, initial?: boolean): void;
+    getTastenAssignment(): string;
+}

package/lib/server/devices/hmIPDevices/hmIpTaster.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HmIpTaster = void 0;
+const hmIpDevice_1 = require("./hmIpDevice");
+const hmIpDeviceType_1 = require("./hmIpDeviceType");
+const taste_1 = require("../taste");
+const logLevel_1 = require("../../../models/logLevel");
+const log_service_1 = require("../../services/log-service");
+class HmIpTaster extends hmIpDevice_1.HmIPDevice {
+    constructor(pInfo) {
+        super(pInfo, hmIpDeviceType_1.HmIpDeviceType.HmIpTaster);
+        this.tasten = {
+            ObenLinks: new taste_1.Taste(1),
+            ObenRechts: new taste_1.Taste(2),
+            MitteLinks: new taste_1.Taste(3),
+            MitteRechts: new taste_1.Taste(4),
+            UntenLinks: new taste_1.Taste(5),
+            UntenRechts: new taste_1.Taste(6),
+        };
+    }
+    update(idSplit, state, initial = false) {
+        log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Trace, `Taster Update: JSON: ${JSON.stringify(state)}ID: ${idSplit.join('.')}`);
+        super.update(idSplit, state, initial, true);
+        let cTaste = undefined;
+        switch (idSplit[3]) {
+            case '1':
+                cTaste = this.tasten.ObenLinks;
+                break;
+            case '2':
+                cTaste = this.tasten.ObenRechts;
+                break;
+            case '3':
+                cTaste = this.tasten.MitteLinks;
+                break;
+            case '4':
+                cTaste = this.tasten.MitteRechts;
+                break;
+            case '5':
+                cTaste = this.tasten.UntenLinks;
+                break;
+            case '6':
+                cTaste = this.tasten.UntenRechts;
+                break;
+        }
+        if (cTaste === undefined) {
+            return;
+        }
+        switch (idSplit[4]) {
+            case 'PRESS_SHORT':
+                if (!initial) {
+                    // Tasten beim Starten ignorieren
+                    cTaste.updateShort(state.val);
+                }
+                break;
+            case 'PRESS_LONG':
+                if (!initial) {
+                    // Tasten beim Starten ignorieren
+                    cTaste.updateLong(state.val);
+                }
+                break;
+        }
+    }
+    getTastenAssignment() {
+        const result = [`Button: ${this.info.customName}`];
+        for (const tastenName in this.tasten) {
+            const desc = this.tasten[tastenName].getDescription();
+            if (desc === '') {
+                continue;
+            }
+            result.push(`Button "${tastenName}":`);
+            result.push(desc);
+            result.push('');
+        }
+        result.push('____________');
+        return result.join('\n');
+    }
+}
+exports.HmIpTaster = HmIpTaster;

package/lib/server/devices/hmIPDevices/hmIpTherm.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="iobroker" />
+import { HmIPDevice } from './hmIpDevice';
+import { DeviceInfo } from '../DeviceInfo';
+export declare class HmIpTherm extends HmIPDevice {
+    constructor(pInfo: DeviceInfo);
+    update(idSplit: string[], state: ioBroker.State, initial?: boolean): void;
+}

package/lib/server/devices/hmIPDevices/hmIpTherm.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HmIpTherm = void 0;
+const hmIpDevice_1 = require("./hmIpDevice");
+const hmIpDeviceType_1 = require("./hmIpDeviceType");
+const logLevel_1 = require("../../../models/logLevel");
+const log_service_1 = require("../../services/log-service");
+class HmIpTherm extends hmIpDevice_1.HmIPDevice {
+    constructor(pInfo) {
+        super(pInfo, hmIpDeviceType_1.HmIpDeviceType.HmIpTherm);
+    }
+    update(idSplit, state, initial = false) {
+        log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Trace, `Thermostat "${this.info.customName}" Update: ID: ${idSplit.join('.')} JSON: ${JSON.stringify(state)}`);
+        super.update(idSplit, state, initial, true);
+    }
+}
+exports.HmIpTherm = HmIpTherm;

package/lib/server/devices/hmIPDevices/hmIpTuer.d.ts

@@ -0,0 +1,16 @@
+/// <reference types="iobroker" />
+import { HmIPDevice } from './hmIpDevice';
+import { DeviceInfo } from '../DeviceInfo';
+import { TuerPosition } from './TuerPosition';
+export declare class HmIpTuer extends HmIPDevice {
+    position: TuerPosition;
+    private _closedCallback;
+    private _offenCallback;
+    private _iOpen;
+    private minutesOpen;
+    constructor(pInfo: DeviceInfo);
+    addOffenCallback(pCallback: (pValue: boolean) => void): void;
+    addClosedCallback(pCallback: (pValue: boolean) => void): void;
+    update(idSplit: string[], state: ioBroker.State, initial?: boolean): void;
+    updatePosition(pValue: TuerPosition): void;
+}

package/lib/server/devices/hmIPDevices/hmIpTuer.js

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HmIpTuer = void 0;
+const hmIpDevice_1 = require("./hmIpDevice");
+const hmIpDeviceType_1 = require("./hmIpDeviceType");
+const logLevel_1 = require("../../../models/logLevel");
+const log_service_1 = require("../../services/log-service");
+const TuerPosition_1 = require("./TuerPosition");
+const sonos_service_1 = require("../../services/Sonos/sonos-service");
+const telegram_service_1 = require("../../services/Telegram/telegram-service");
+const utils_1 = require("../../services/utils/utils");
+class HmIpTuer extends hmIpDevice_1.HmIPDevice {
+    constructor(pInfo) {
+        super(pInfo, hmIpDeviceType_1.HmIpDeviceType.HmIpTuer);
+        this.position = TuerPosition_1.TuerPosition.geschlossen;
+        this._closedCallback = [];
+        this._offenCallback = [];
+        this.minutesOpen = 0;
+    }
+    addOffenCallback(pCallback) {
+        this._offenCallback.push(pCallback);
+    }
+    addClosedCallback(pCallback) {
+        this._closedCallback.push(pCallback);
+    }
+    update(idSplit, state, initial = false) {
+        log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.DeepTrace, `Tuer Update: JSON: ${JSON.stringify(state)}ID: ${idSplit.join('.')}`);
+        super.update(idSplit, state, initial, true);
+        switch (idSplit[3]) {
+            case '1':
+                if (idSplit[4] === 'STATE') {
+                    if (initial) {
+                        this.position = TuerPosition_1.TuerPosition.geschlossen;
+                        return;
+                    }
+                    this.updatePosition(state.val);
+                }
+                break;
+        }
+    }
+    updatePosition(pValue) {
+        if (pValue === this.position) {
+            return;
+        }
+        log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Trace, `Update Tür "${this.info.customName}"\nauf Position "${TuerPosition_1.TuerPosition[pValue]}"`);
+        this.position = pValue;
+        for (const c1 of this._closedCallback) {
+            c1(pValue === 0);
+        }
+        for (const c2 of this._offenCallback) {
+            c2(pValue === 1);
+        }
+        if (pValue === TuerPosition_1.TuerPosition.geschlossen) {
+            if (this._iOpen !== undefined) {
+                clearInterval(this._iOpen);
+                let message = `Die Haustür ist nun nach ${this.minutesOpen} Minuten wieder zu!`;
+                if (this.minutesOpen === 0) {
+                    message = 'Die Haustür ist wieder zu.';
+                }
+                // const message: string = `Die Tür mit dem Namen "${this.info.customName}" wurde nach ${this.minutesOpen} Minuten geschlossen!`;
+                log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Info, message);
+                telegram_service_1.TelegramService.inform(message);
+                this.minutesOpen = 0;
+                this._iOpen = undefined;
+            }
+            return;
+        }
+        else if (this._iOpen === undefined) {
+            const message = `Die Haustür wurde geöffnet!`;
+            //const message: string = `Die Tür mit dem Namen "${this.info.customName}" wurde geöfnet!`
+            telegram_service_1.TelegramService.inform(message);
+            sonos_service_1.SonosService.speakOnAll(message, 40);
+            this._iOpen = utils_1.Utils.guardedInterval(() => {
+                this.minutesOpen++;
+                const message = `Tuer: "${this.info.customName}" seit ${this.minutesOpen} Minuten auf Position ${TuerPosition_1.TuerPosition[this.position]}`;
+                switch (this.minutesOpen) {
+                    case 2:
+                    case 5:
+                    case 10:
+                    case 20:
+                    case 45:
+                    case 60:
+                        log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Info, message);
+                        telegram_service_1.TelegramService.inform(message);
+                        break;
+                    default:
+                        log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Trace, message);
+                        break;
+                }
+            }, 60000, this);
+        }
+    }
+}
+exports.HmIpTuer = HmIpTuer;

package/lib/server/devices/hmIPDevices/hmIpWippe.d.ts

@@ -0,0 +1,12 @@
+/// <reference types="iobroker" />
+import { HmIPDevice } from './hmIpDevice';
+import { DeviceInfo } from '../DeviceInfo';
+import { Taste } from '../taste';
+export declare class HmIpWippe extends HmIPDevice {
+    tasten: {
+        Unten: Taste;
+        Oben: Taste;
+    };
+    constructor(pInfo: DeviceInfo);
+    update(idSplit: string[], state: ioBroker.State, initial?: boolean): void;
+}

package/lib/server/devices/hmIPDevices/hmIpWippe.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HmIpWippe = void 0;
+const hmIpDevice_1 = require("./hmIpDevice");
+const hmIpDeviceType_1 = require("./hmIpDeviceType");
+const taste_1 = require("../taste");
+const logLevel_1 = require("../../../models/logLevel");
+const log_service_1 = require("../../services/log-service");
+class HmIpWippe extends hmIpDevice_1.HmIPDevice {
+    constructor(pInfo) {
+        super(pInfo, hmIpDeviceType_1.HmIpDeviceType.HmIpWippe);
+        this.tasten = {
+            Unten: new taste_1.Taste(1),
+            Oben: new taste_1.Taste(2),
+        };
+    }
+    update(idSplit, state, initial = false) {
+        log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Trace, `Wippe Update: JSON: ${JSON.stringify(state)}ID: ${idSplit.join('.')}`);
+        super.update(idSplit, state, initial, true);
+        let cTaste = undefined;
+        switch (idSplit[3]) {
+            case '1':
+                cTaste = this.tasten.Unten;
+                break;
+            case '2':
+                cTaste = this.tasten.Oben;
+                break;
+        }
+        if (cTaste === undefined) {
+            return;
+        }
+        switch (idSplit[4]) {
+            case 'PRESS_SHORT':
+                if (!initial) {
+                    // Tasten beim Starten ignorieren
+                    log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Debug, `Tasten Update initial für "${this.info.customName}" ignoriert`);
+                    cTaste.updateShort(state.val);
+                }
+                break;
+            case 'PRESS_LONG':
+                if (!initial) {
+                    // Tasten beim Starten ignorieren
+                    log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Debug, `Tasten Update initial für "${this.info.customName}" ignoriert`);
+                    cTaste.updateLong(state.val);
+                }
+                break;
+        }
+    }
+}
+exports.HmIpWippe = HmIpWippe;

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

@@ -0,0 +1,16 @@
+export * from './Fenster';
+export * from './hmIpRoll';
+export * from './hmIpTuer';
+export * from './hmIpGriff';
+export * from './hmIpLampe';
+export * from './hmIpTherm';
+export * from './hmIpWippe';
+export * from './hmIpDevice';
+export * from './hmIpTaster';
+export * from './hmIpHeizung';
+export * from './hmIpBewegung';
+export * from './hmIpPraezenz';
+export * from './TuerPosition';
+export * from './hmIpDeviceType';
+export * from './hmIpHeizgruppe';
+export * from './FensterPosition';

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

@@ -0,0 +1,28 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./Fenster"), exports);
+__exportStar(require("./hmIpRoll"), exports);
+__exportStar(require("./hmIpTuer"), exports);
+__exportStar(require("./hmIpGriff"), exports);
+__exportStar(require("./hmIpLampe"), exports);
+__exportStar(require("./hmIpTherm"), exports);
+__exportStar(require("./hmIpWippe"), exports);
+__exportStar(require("./hmIpDevice"), exports);
+__exportStar(require("./hmIpTaster"), exports);
+__exportStar(require("./hmIpHeizung"), exports);
+__exportStar(require("./hmIpBewegung"), exports);
+__exportStar(require("./hmIpPraezenz"), exports);
+__exportStar(require("./TuerPosition"), exports);
+__exportStar(require("./hmIpDeviceType"), exports);
+__exportStar(require("./hmIpHeizgruppe"), exports);
+__exportStar(require("./FensterPosition"), exports);

package/lib/server/devices/iDeviceUpdater.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="iobroker" />
+export interface IDeviceUpdater {
+    updateState(id: string, state: ioBroker.State, initial?: boolean): void;
+    updateObject(pId: string, pObj: ioBroker.Object): void;
+}

package/lib/server/devices/iDeviceUpdater.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/{server/devices/iIlluminationSensor.ts → lib/server/devices/iIlluminationSensor.d.ts}

@@ -1,3 +1,3 @@
 export interface iIlluminationSensor {
-  currentIllumination: number;
+    currentIllumination: number;
 }

package/lib/server/devices/iIlluminationSensor.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/server/devices/iIoBrokerDevice.d.ts

@@ -0,0 +1,30 @@
+/// <reference types="iobroker" />
+import { DeviceInfo } from './DeviceInfo';
+import { IOBrokerConnection } from '../ioBroker/connection';
+export declare abstract class ioBrokerBaseDevice {
+    private _info;
+    private _ioConnection?;
+    protected constructor(_info: DeviceInfo);
+    /**
+     * Getter info
+     * @return {TradFriInfo}
+     */
+    get info(): DeviceInfo;
+    /**
+     * Setter info
+     * @param {TradFriInfo} value
+     */
+    set info(value: DeviceInfo);
+    /**
+     * Getter ioConn
+     * @return {IOBrokerConnection}
+     */
+    get ioConn(): IOBrokerConnection | undefined;
+    /**
+     * Setter ioConn
+     * @param {IOBrokerConnection} value
+     */
+    set ioConn(value: IOBrokerConnection | undefined);
+    protected abstract addToCorrectRoom(): void;
+    protected abstract update(idSplit: string[], state: ioBroker.State, initial: boolean, pOverride: boolean): void;
+}

package/lib/server/devices/iIoBrokerDevice.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ioBrokerBaseDevice = void 0;
+class ioBrokerBaseDevice {
+    constructor(_info) {
+        this._info = _info;
+    }
+    /**
+     * Getter info
+     * @return {TradFriInfo}
+     */
+    get info() {
+        return this._info;
+    }
+    /**
+     * Setter info
+     * @param {TradFriInfo} value
+     */
+    set info(value) {
+        this._info = value;
+    }
+    /**
+     * Getter ioConn
+     * @return {IOBrokerConnection}
+     */
+    get ioConn() {
+        return this._ioConnection;
+    }
+    /**
+     * Setter ioConn
+     * @param {IOBrokerConnection} value
+     */
+    set ioConn(value) {
+        this._ioConnection = value;
+    }
+}
+exports.ioBrokerBaseDevice = ioBrokerBaseDevice;

package/lib/server/devices/iLamp.d.ts

@@ -0,0 +1,8 @@
+import { RoomBase } from '../../models/rooms/RoomBase';
+import { ActuatorSettings } from '../../models/actuatorSettings';
+export interface iLamp {
+    settings: ActuatorSettings;
+    lightOn: boolean;
+    room: RoomBase | undefined;
+    setLight(pValue: boolean, timeout: number, force: boolean): void;
+}

package/lib/server/devices/iLamp.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });