hoffmation-base 1.1.39 → 1.1.41

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

@@ -17,6 +17,7 @@ export declare enum DeviceCapability {
     handleSensor = 15,
     batteryDriven = 16,
     tv = 17,
+    ledLamp = 18,
     bluetoothDetector = 101,
     trackableDevice = 102
 }

package/lib/server/devices/DeviceCapability.js

@@ -21,6 +21,7 @@ var DeviceCapability;
     DeviceCapability[DeviceCapability["handleSensor"] = 15] = "handleSensor";
     DeviceCapability[DeviceCapability["batteryDriven"] = 16] = "batteryDriven";
     DeviceCapability[DeviceCapability["tv"] = 17] = "tv";
+    DeviceCapability[DeviceCapability["ledLamp"] = 18] = "ledLamp";
     DeviceCapability[DeviceCapability["bluetoothDetector"] = 101] = "bluetoothDetector";
     DeviceCapability[DeviceCapability["trackableDevice"] = 102] = "trackableDevice";
 })(DeviceCapability = exports.DeviceCapability || (exports.DeviceCapability = {}));

package/lib/server/devices/baseDeviceInterfaces/iActuator.d.ts

@@ -1,8 +1,17 @@
 import { ActuatorSettings } from '../../../models';
 import { iRoomDevice } from './iRoomDevice';
 export interface iActuator extends iRoomDevice {
+    /**
+     * The settings for this Actuator primarily for controlling it's automatic actions
+     */
     settings: ActuatorSettings;
-    actuatorOn: boolean;
+    /**
+     * The state value of the device
+     */
+    readonly actuatorOn: boolean;
+    /**
+     * Persisting the current states of this device to the database
+     */
     persist(): void;
     /**
      * Controls the power state of this actuator

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

@@ -1,9 +1,24 @@
 import { TimeOfDay } from '../../../models';
 import { iActuator } from './iActuator';
 export interface iLamp extends iActuator {
-    lightOn: boolean;
-    setTimeBased(time: TimeOfDay, timeout: number, force: boolean): void;
-    toggleLight(time: TimeOfDay, force: boolean, calculateTime: boolean): void;
+    /**
+     * The state value of the device
+     */
+    readonly lightOn: boolean;
+    /**
+     * Set's the lamp based on lamp settings for the current time
+     * @param {TimeOfDay} time The time to use for calculation of desired state
+     * @param {number} timeout If > 0 this is the time after which the lamp reverts to its original state
+     * @param {boolean} force To indicate a higher priority than automatic actions (e.g. a user pressing a button)
+     */
+    setTimeBased(time: TimeOfDay, timeout?: number, force?: boolean): void;
+    /**
+     * Toggles the state of the lamp
+     * @param {TimeOfDay} time The time to use for calculation of desired state
+     * @param {boolean} force To indicate a higher priority than automatic actions (e.g. a user pressing a button)
+     * @param {boolean} calculateTime Alternative to "time", if set the time will be calculated by the lamps room and its settings
+     */
+    toggleLight(time?: TimeOfDay, force?: boolean, calculateTime?: boolean): void;
     /**
      * This function sets the light to a specific value
      * @param pValue The desired value

package/lib/server/devices/baseDeviceInterfaces/iLedRgbCct.d.ts

@@ -0,0 +1,24 @@
+/// <reference types="iobroker" />
+import { LedSettings, TimeOfDay } from '../../../models';
+import { iDimmableLamp } from './iDimmableLamp';
+export interface iLedRgbCct extends iDimmableLamp {
+    settings: LedSettings;
+    readonly color: string;
+    readonly colortemp: number;
+    update(idSplit: string[], state: ioBroker.State, initial: boolean): void;
+    /**
+     * @inheritDoc
+     */
+    setTimeBased(time: TimeOfDay, timeout?: number, force?: boolean): void;
+    /**
+     * @inheritDoc
+     * @param pValue
+     * @param timeout
+     * @param force
+     * @param brightness
+     * @param transitionTime
+     * @param {string} color The desired color in 6 digit hex Code
+     * @param {number} colorTemp The desired color Temperature (0 = more White)
+     */
+    setLight(pValue: boolean, timeout?: number, force?: boolean, brightness?: number, transitionTime?: number, color?: string, colorTemp?: number): void;
+}

package/lib/server/devices/baseDeviceInterfaces/iLedRgbCct.js

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

package/lib/server/devices/devices.js

@@ -124,7 +124,7 @@ class Devices {
             case 'IlluShutter':
                 d = new zigbee_1.ZigbeeIlluShutter(zigbeeInfo);
                 break;
-            case 'LedRGBCCT':
+            case 'IlluLedRGBCCT':
                 d = new zigbee_1.ZigbeeIlluLedRGBCCT(zigbeeInfo);
                 break;
             case 'SMaBiTMagnet':

package/lib/server/devices/groups/lampenGroup.d.ts

@@ -1,13 +1,13 @@
-import { ZigbeeIlluLedRGBCCT } from '../zigbee';
 import { BaseGroup } from './base-group';
 import { iActuator, iLamp } from '../baseDeviceInterfaces';
 import { TimeOfDay } from '../../../models';
 import { WledDevice } from '../wledDevice';
+import { iLedRgbCct } from '../baseDeviceInterfaces/iLedRgbCct';
 export declare class LampenGroup extends BaseGroup {
     constructor(roomName: string, lampenIds?: string[], steckerIds?: string[], ledIds?: string[], wledIds?: string[]);
     anyLightsOn(): boolean;
     getLampen(): iLamp[];
-    getLED(): ZigbeeIlluLedRGBCCT[];
+    getLED(): iLedRgbCct[];
     getWled(): WledDevice[];
     getStecker(): iActuator[];
     handleSunriseOff(): void;

package/lib/server/devices/groups/lampenGroup.js

@@ -43,7 +43,7 @@ class LampenGroup extends base_group_1.BaseGroup {
         return this.deviceCluster.getDevicesByType(device_cluster_type_1.DeviceClusterType.Lamps);
     }
     getLED() {
-        return this.deviceCluster.getIoBrokerDevicesByType(device_cluster_type_1.DeviceClusterType.LED);
+        return this.deviceCluster.getDevicesByType(device_cluster_type_1.DeviceClusterType.LED);
     }
     getWled() {
         return this.deviceCluster.getIoBrokerDevicesByType(device_cluster_type_1.DeviceClusterType.WLED);

package/lib/server/devices/zigbee/BaseDevices/index.d.ts

@@ -1,6 +1,8 @@
 export * from './ZigbeeActuator';
 export * from './zigbeeDevice';
+export * from './zigbeeDimmer';
 export * from './zigbeeHeater';
+export * from './zigbeeLedRGBCCT';
 export * from './zigbeeMagnetContact';
 export * from './zigbeeMotionSensor';
 export * from './zigbeeShutter';

package/lib/server/devices/zigbee/BaseDevices/index.js

@@ -16,7 +16,9 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./ZigbeeActuator"), exports);
 __exportStar(require("./zigbeeDevice"), exports);
+__exportStar(require("./zigbeeDimmer"), exports);
 __exportStar(require("./zigbeeHeater"), exports);
+__exportStar(require("./zigbeeLedRGBCCT"), exports);
 __exportStar(require("./zigbeeMagnetContact"), exports);
 __exportStar(require("./zigbeeMotionSensor"), exports);
 __exportStar(require("./zigbeeShutter"), exports);

package/lib/server/devices/zigbee/BaseDevices/zigbeeDimmer.d.ts

@@ -0,0 +1,43 @@
+/// <reference types="node" />
+/// <reference types="iobroker" />
+import { DimmerSettings, TimeOfDay } from '../../../../models';
+import { DeviceType } from '../../deviceType';
+import { ZigbeeDevice } from './index';
+import { IoBrokerDeviceInfo } from '../../IoBrokerDeviceInfo';
+import { iDimmableLamp } from '../../baseDeviceInterfaces/iDimmableLamp';
+export declare abstract class ZigbeeDimmer extends ZigbeeDevice implements iDimmableLamp {
+    queuedValue: boolean | null;
+    settings: DimmerSettings;
+    protected _brightness: number;
+    protected _lastPersist: number;
+    protected _lightOn: boolean;
+    protected _transitionTime: number;
+    protected _turnOffTime: number;
+    protected _turnOffTimeout: NodeJS.Timeout | undefined;
+    protected abstract readonly _stateIdBrightness: string;
+    protected abstract readonly _stateIdState: string;
+    protected abstract readonly _stateIdTransitionTime: string;
+    protected abstract readonly _stateNameBrightness: string;
+    protected abstract readonly _stateNameState: string;
+    protected abstract readonly _stateNameTransitionTime: string;
+    get lightOn(): boolean;
+    get brightness(): number;
+    get transitionTime(): number;
+    get actuatorOn(): boolean;
+    protected constructor(pInfo: IoBrokerDeviceInfo, deviceType: DeviceType);
+    update(idSplit: string[], state: ioBroker.State, initial?: boolean): void;
+    setTimeBased(time: TimeOfDay, timeout?: number, force?: boolean): void;
+    setActuator(pValue: boolean, timeout?: number, force?: boolean): void;
+    toggleActuator(force: boolean): boolean;
+    /**
+     * @inheritDoc
+     * @param pValue The desired value
+     * @param timeout If > 0 time at which this should be turned off again
+     * @param force if it is an user based action which should override automatic ones
+     * @param {number} brightness The desired brightness in percent
+     * @param {number} transitionTime The transition time for the brightness, to switch smoothly
+     */
+    setLight(pValue: boolean, timeout?: number, force?: boolean, brightness?: number, transitionTime?: number): void;
+    persist(): void;
+    toggleLight(time?: TimeOfDay, force?: boolean, calculateTime?: boolean): boolean;
+}

package/lib/server/devices/zigbee/BaseDevices/zigbeeDimmer.js

@@ -0,0 +1,167 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZigbeeDimmer = void 0;
+const models_1 = require("../../../../models");
+const services_1 = require("../../../services");
+const index_1 = require("./index");
+const DeviceCapability_1 = require("../../DeviceCapability");
+class ZigbeeDimmer extends index_1.ZigbeeDevice {
+    constructor(pInfo, deviceType) {
+        super(pInfo, deviceType);
+        this.queuedValue = null;
+        this.settings = new models_1.DimmerSettings();
+        this._brightness = 0;
+        this._lastPersist = 0;
+        this._lightOn = false;
+        this._transitionTime = 0;
+        this._turnOffTime = 0;
+        this._turnOffTimeout = undefined;
+        this.deviceCapabilities.push(DeviceCapability_1.DeviceCapability.lamp);
+        this.deviceCapabilities.push(DeviceCapability_1.DeviceCapability.dimmablelamp);
+    }
+    get lightOn() {
+        return this._lightOn;
+    }
+    get brightness() {
+        return this._brightness;
+    }
+    get transitionTime() {
+        return this._transitionTime;
+    }
+    get actuatorOn() {
+        return this.lightOn;
+    }
+    update(idSplit, state, initial = false) {
+        this.queuedValue = null;
+        this.log(models_1.LogLevel.DeepTrace, `Dimmer Update: ID: ${idSplit.join('.')} JSON: ${JSON.stringify(state)}`);
+        super.update(idSplit, state, initial, true);
+        switch (idSplit[3]) {
+            case this._stateNameState:
+                this.log(models_1.LogLevel.Trace, `Dimmer Update für ${this.info.customName} auf ${state.val}`);
+                this._lightOn = state.val;
+                this.persist();
+                break;
+            case this._stateNameBrightness:
+                this.log(models_1.LogLevel.Trace, `Dimmer Helligkeit Update für ${this.info.customName} auf ${state.val}`);
+                this._brightness = state.val;
+                this.persist();
+                break;
+            case this._stateNameTransitionTime:
+                this.log(models_1.LogLevel.Trace, `Dimmer Transition Time Update für ${this.info.customName} auf ${state.val}`);
+                this._transitionTime = state.val;
+                break;
+        }
+    }
+    setTimeBased(time, timeout = -1, force = false) {
+        switch (time) {
+            case models_1.TimeOfDay.Night:
+                this.setLight(true, timeout, force, this.settings.nightBrightness);
+                break;
+            case models_1.TimeOfDay.AfterSunset:
+                this.setLight(true, timeout, force, this.settings.dawnBrightness);
+                break;
+            case models_1.TimeOfDay.BeforeSunrise:
+                this.setLight(true, timeout, force, this.settings.duskBrightness);
+                break;
+            case models_1.TimeOfDay.Daylight:
+                this.setLight(true, timeout, force, this.settings.dayBrightness);
+                break;
+        }
+    }
+    setActuator(pValue, timeout, force) {
+        this.setLight(pValue, timeout, force);
+    }
+    toggleActuator(force) {
+        return this.toggleLight(undefined, force);
+    }
+    /**
+     * @inheritDoc
+     * @param pValue The desired value
+     * @param timeout If > 0 time at which this should be turned off again
+     * @param force if it is an user based action which should override automatic ones
+     * @param {number} brightness The desired brightness in percent
+     * @param {number} transitionTime The transition time for the brightness, to switch smoothly
+     */
+    setLight(pValue, timeout = -1, force = false, brightness = -1, transitionTime = -1) {
+        if (this._stateIdState === '') {
+            this.log(models_1.LogLevel.Error, `Keine State ID bekannt.`);
+            return;
+        }
+        if (!this.ioConn) {
+            this.log(models_1.LogLevel.Error, `Keine Connection bekannt.`);
+            return;
+        }
+        if (transitionTime > -1) {
+            this.ioConn.setState(this._stateIdTransitionTime, transitionTime, (err) => {
+                if (err) {
+                    this.log(models_1.LogLevel.Error, `Dimmer TransitionTime schalten ergab Fehler: ${err}`);
+                }
+            });
+        }
+        if (!force && services_1.Utils.nowMS() < this._turnOffTime) {
+            this.log(models_1.LogLevel.Debug, `Skip automatic command to ${pValue} as it is locked until ${new Date(this._turnOffTime).toLocaleTimeString()}`);
+            return;
+        }
+        if (pValue && brightness === -1 && this.brightness < 10) {
+            brightness = 10;
+        }
+        this.log(models_1.LogLevel.Debug, `Set Light Acutator to "${pValue}" with brightness ${brightness}`, services_1.LogDebugType.SetActuator);
+        this.setState(this._stateIdState, pValue);
+        this.queuedValue = pValue;
+        if (brightness > -1) {
+            if (brightness < this.settings.turnOnThreshhold) {
+                this.setState(this._stateIdBrightness, this.settings.turnOnThreshhold, () => {
+                    services_1.Utils.guardedTimeout(() => {
+                        this.log(models_1.LogLevel.Info, `Delayed reduced brightness on ${this.info.customName}`);
+                        this.setState(this._stateIdBrightness, brightness);
+                    }, 1000, this);
+                });
+            }
+            else {
+                this.setState(this._stateIdBrightness, brightness);
+            }
+        }
+        if (this._turnOffTimeout !== undefined) {
+            clearTimeout(this._turnOffTimeout);
+            this._turnOffTimeout = undefined;
+        }
+        if (timeout < 0 || !pValue) {
+            return;
+        }
+        this._turnOffTime = services_1.Utils.nowMS() + timeout;
+        this._turnOffTimeout = services_1.Utils.guardedTimeout(() => {
+            this.log(models_1.LogLevel.Debug, `Delayed Turnoff initiated`);
+            this._turnOffTimeout = undefined;
+            if (!this.room) {
+                this.setLight(false, -1, true);
+            }
+            else {
+                this.room.setLightTimeBased(true);
+            }
+        }, timeout, this);
+    }
+    persist() {
+        var _a;
+        const now = services_1.Utils.nowMS();
+        if (this._lastPersist + 1000 < now) {
+            return;
+        }
+        (_a = services_1.Utils.dbo) === null || _a === void 0 ? void 0 : _a.persistActuator(this);
+        this._lastPersist = now;
+    }
+    toggleLight(time, force = false, calculateTime = false) {
+        var _a;
+        const newVal = this.queuedValue !== null ? !this.queuedValue : !this.lightOn;
+        const timeout = newVal && force ? 30 * 60 * 1000 : -1;
+        if (newVal && time === undefined && calculateTime && this.room !== undefined) {
+            time = services_1.TimeCallbackService.dayType((_a = this.room) === null || _a === void 0 ? void 0 : _a.settings.lampOffset);
+        }
+        if (newVal && time !== undefined) {
+            this.setTimeBased(time, timeout, force);
+            return true;
+        }
+        this.setLight(newVal, timeout, force);
+        return newVal;
+    }
+}
+exports.ZigbeeDimmer = ZigbeeDimmer;

package/lib/server/devices/zigbee/BaseDevices/zigbeeLedRGBCCT.d.ts

@@ -0,0 +1,28 @@
+/// <reference types="iobroker" />
+import { DeviceType } from '../../deviceType';
+import { LedSettings, TimeOfDay } from '../../../../models';
+import { IoBrokerDeviceInfo } from '../../IoBrokerDeviceInfo';
+import { iLedRgbCct } from '../../baseDeviceInterfaces/iLedRgbCct';
+import { ZigbeeDimmer } from './zigbeeDimmer';
+export declare abstract class ZigbeeLedRGBCCT extends ZigbeeDimmer implements iLedRgbCct {
+    static DEFAULT_COLOR_WARM: string;
+    settings: LedSettings;
+    protected abstract readonly _stateIdColor: string;
+    protected abstract readonly _stateIdColorTemp: string;
+    protected abstract readonly _stateNameColor: string;
+    protected abstract readonly _stateNameColorTemp: string;
+    protected constructor(pInfo: IoBrokerDeviceInfo, deviceType: DeviceType);
+    protected _color: string;
+    get color(): string;
+    protected _colortemp: number;
+    get colortemp(): number;
+    update(idSplit: string[], state: ioBroker.State, initial?: boolean): void;
+    /**
+     * @inheritDoc
+     */
+    setTimeBased(time: TimeOfDay, timeout?: number, force?: boolean): void;
+    /**
+     * @inheritDoc
+     */
+    setLight(pValue: boolean, timeout?: number, force?: boolean, brightness?: number, transitionTime?: number, color?: string, colorTemp?: number): void;
+}

package/lib/server/devices/zigbee/BaseDevices/zigbeeLedRGBCCT.js

@@ -0,0 +1,103 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZigbeeLedRGBCCT = void 0;
+const models_1 = require("../../../../models");
+const DeviceCapability_1 = require("../../DeviceCapability");
+const zigbeeDimmer_1 = require("./zigbeeDimmer");
+class ZigbeeLedRGBCCT extends zigbeeDimmer_1.ZigbeeDimmer {
+    constructor(pInfo, deviceType) {
+        super(pInfo, deviceType);
+        this.settings = new models_1.LedSettings();
+        this._color = '#fcba32';
+        this._colortemp = 500;
+        this.deviceCapabilities.push(DeviceCapability_1.DeviceCapability.ledLamp);
+        // this.effectID = `${this.info.fullID}.effect`;
+    }
+    get color() {
+        return this._color;
+    }
+    get colortemp() {
+        return this._colortemp;
+    }
+    // private effectID: string = '';
+    update(idSplit, state, initial = false) {
+        this.log(models_1.LogLevel.DeepTrace, `LED Update: ID: ${idSplit.join('.')} JSON: ${JSON.stringify(state)}`);
+        super.update(idSplit, state, initial);
+        switch (idSplit[3]) {
+            case this._stateNameColor:
+                this.log(models_1.LogLevel.Trace, `LED Color Update für ${this.info.customName} auf ${state.val}`);
+                this._color = state.val;
+                break;
+            case this._stateNameColorTemp:
+                this.log(models_1.LogLevel.Trace, `LED Color Temp Update für ${this.info.customName} auf ${state.val}`);
+                this._colortemp = state.val;
+                break;
+        }
+    }
+    /**
+     * @inheritDoc
+     */
+    setTimeBased(time, timeout = -1, force = false) {
+        switch (time) {
+            case models_1.TimeOfDay.Night:
+                if (this.settings.nightOn) {
+                    this.setLight(true, timeout, force, this.settings.nightBrightness, undefined, this.settings.nightColor, this.settings.nightColorTemp);
+                }
+                break;
+            case models_1.TimeOfDay.AfterSunset:
+                if (this.settings.duskOn) {
+                    this.setLight(true, timeout, force, this.settings.duskBrightness, undefined, this.settings.duskColor, this.settings.duskColorTemp);
+                }
+                break;
+            case models_1.TimeOfDay.BeforeSunrise:
+                if (this.settings.dawnOn) {
+                    this.setLight(true, timeout, force, this.settings.dawnBrightness, undefined, this.settings.dawnColor, this.settings.dawnColorTemp);
+                }
+                break;
+            case models_1.TimeOfDay.Daylight:
+                if (this.settings.dayOn) {
+                    this.setLight(true, timeout, force, this.settings.dayBrightness, undefined, this.settings.dayColor, this.settings.dayColorTemp);
+                }
+                break;
+        }
+    }
+    /**
+     * @inheritDoc
+     */
+    setLight(pValue, timeout, force, brightness = -1, transitionTime, color = '', colorTemp = -1) {
+        if (this._stateIdState === '') {
+            this.log(models_1.LogLevel.Error, `Keine State ID bekannt.`);
+            return;
+        }
+        if (!this.ioConn) {
+            this.log(models_1.LogLevel.Error, `Keine Connection bekannt.`);
+            return;
+        }
+        if (pValue && brightness === -1 && this.brightness < 10) {
+            brightness = 10;
+        }
+        this.log(models_1.LogLevel.Debug, `LED Schalten An: ${pValue}\tHelligkeit: ${brightness}%\tFarbe: "${color}"\tColorTemperatur: ${colorTemp}`);
+        super.setLight(pValue, timeout, force, brightness, transitionTime);
+        if (color !== '') {
+            this.ioConn.setState(this._stateIdColor, color, (err) => {
+                if (err) {
+                    this.log(models_1.LogLevel.Error, `LED Farbe schalten ergab Fehler: ${err}`);
+                }
+            });
+        }
+        if (colorTemp > -1) {
+            this.ioConn.setState(this._stateIdColorTemp, colorTemp, (err) => {
+                if (err) {
+                    this.log(models_1.LogLevel.Error, `LED Farbwärme schalten ergab Fehler: ${err}`);
+                }
+            });
+        }
+        this.ioConn.setState(this._stateIdState, pValue, (err) => {
+            if (err) {
+                this.log(models_1.LogLevel.Error, `LED schalten ergab Fehler: ${err}`);
+            }
+        });
+    }
+}
+exports.ZigbeeLedRGBCCT = ZigbeeLedRGBCCT;
+ZigbeeLedRGBCCT.DEFAULT_COLOR_WARM = '#f2b200';

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

@@ -87,13 +87,9 @@ class ZigbeeEuroHeater extends BaseDevices_1.ZigbeeHeater {
             case 'spz_trv_mode':
                 this.log(models_1.LogLevel.Trace, `Euro Valve mode Update for ${this.info.customName} to "${state.val}"`);
                 this._mode = state.val;
-                if (!this.settings.seasonalTurnOffActive) {
-                    if (this.settings.controlByPid && this._mode == 2) {
-                        this.setMode(1);
-                    }
-                    else if (this._mode == 1) {
-                        this.setMode(2);
-                    }
+                const desiredMode = this.settings.controlByPid ? 1 : 2;
+                if (!this.settings.seasonalTurnOffActive && this._mode !== desiredMode) {
+                    this.setMode(desiredMode);
                 }
                 break;
             case 'target_temperature':

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

@@ -1,36 +1,11 @@
-/// <reference types="iobroker" />
-import { DimmerSettings, TimeOfDay } from '../../../models';
-import { DeviceType } from '../deviceType';
-import { ZigbeeDevice } from './BaseDevices';
+import { ZigbeeDimmer } from './BaseDevices';
 import { IoBrokerDeviceInfo } from '../IoBrokerDeviceInfo';
-import { iDimmableLamp } from '../baseDeviceInterfaces/iDimmableLamp';
-export declare class ZigbeeIlluDimmer extends ZigbeeDevice implements iDimmableLamp {
-    lightOn: boolean;
-    queuedValue: boolean | null;
-    brightness: number;
-    transitionTime: number;
-    settings: DimmerSettings;
-    protected readonly stateID: string;
-    protected readonly brightnessID: string;
-    protected readonly transitionID: string;
-    private _turnOffTimeout;
-    private turnOffTime;
-    private _lastPersist;
-    constructor(pInfo: IoBrokerDeviceInfo, deviceType?: DeviceType);
-    get actuatorOn(): boolean;
-    update(idSplit: string[], state: ioBroker.State, initial?: boolean): void;
-    setTimeBased(time: TimeOfDay, timeout?: number, force?: boolean): void;
-    setActuator(pValue: boolean, timeout?: number, force?: boolean): void;
-    toggleActuator(force: boolean): boolean;
-    /**
-     * @inheritDoc
-     * @param pValue The desired value
-     * @param timeout If > 0 time at which this should be turned off again
-     * @param force if it is an user based action which should override automatic ones
-     * @param {number} brightness The desired brightness in percent
-     * @param {number} transitionTime The transition time for the brightness, to switch smoothly
-     */
-    setLight(pValue: boolean, timeout?: number, force?: boolean, brightness?: number, transitionTime?: number): void;
-    persist(): void;
-    toggleLight(time?: TimeOfDay, force?: boolean, calculateTime?: boolean): boolean;
+export declare class ZigbeeIlluDimmer extends ZigbeeDimmer {
+    protected _stateNameBrightness: string;
+    protected _stateNameState: string;
+    protected _stateNameTransitionTime: string;
+    protected _stateIdBrightness: string;
+    protected _stateIdState: string;
+    protected _stateIdTransitionTime: string;
+    constructor(pInfo: IoBrokerDeviceInfo);
 }