hap-nodejs 0.12.3-beta.26 → 0.12.3-beta.28

package/dist/lib/controller/AdaptiveLightingController.js

@@ -1,17 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AdaptiveLightingController = exports.AdaptiveLightingControllerEvents = exports.AdaptiveLightingControllerMode = void 0;
-const tslib_1 = require("tslib");
-const assert_1 = tslib_1.__importDefault(require("assert"));
-const color_utils_1 = require("../util/color-utils");
-const hapStatusError_1 = require("../util/hapStatusError");
-const time_1 = require("../util/time");
-const uuid = tslib_1.__importStar(require("../util/uuid"));
-const debug_1 = tslib_1.__importDefault(require("debug"));
-const events_1 = require("events");
-const Characteristic_1 = require("../Characteristic");
-const tlv = tslib_1.__importStar(require("../util/tlv"));
-const debug = (0, debug_1.default)("HAP-NodeJS:Controller:TransitionControl");
+var tslib_1 = require("tslib");
+var assert_1 = tslib_1.__importDefault(require("assert"));
+var color_utils_1 = require("../util/color-utils");
+var hapStatusError_1 = require("../util/hapStatusError");
+var time_1 = require("../util/time");
+var uuid = tslib_1.__importStar(require("../util/uuid"));
+var debug_1 = tslib_1.__importDefault(require("debug"));
+var events_1 = require("events");
+var Characteristic_1 = require("../Characteristic");
+var tlv = tslib_1.__importStar(require("../util/tlv"));
+var debug = (0, debug_1.default)("HAP-NodeJS:Controller:TransitionControl");
 var SupportedCharacteristicValueTransitionConfigurationsTypes;
 (function (SupportedCharacteristicValueTransitionConfigurationsTypes) {
     SupportedCharacteristicValueTransitionConfigurationsTypes[SupportedCharacteristicValueTransitionConfigurationsTypes["SUPPORTED_TRANSITION_CONFIGURATION"] = 1] = "SUPPORTED_TRANSITION_CONFIGURATION";
@@ -112,7 +112,7 @@ var AdaptiveLightingControllerEvents;
 (function (AdaptiveLightingControllerEvents) {
     /**
      * This event is called once a HomeKit controller enables Adaptive Lighting
-     * or a HomeHub sends an updated transition schedule for the next 24 hours.
+     * or a HomeHub sends a updated transition schedule for the next 24 hours.
      * This is also called on startup when AdaptiveLighting was previously enabled.
      */
     AdaptiveLightingControllerEvents["UPDATE"] = "update";
@@ -222,28 +222,8 @@ var AdaptiveLightingControllerEvents;
  *  @group Adaptive Lighting
  */
 // eslint-disable-next-line @typescript-eslint/no-unsafe-declaration-merging
-class AdaptiveLightingController extends events_1.EventEmitter {
-    stateChangeDelegate;
-    lightbulb;
-    mode;
-    customTemperatureAdjustment;
-    adjustmentFactorChangedListener;
-    characteristicManualWrittenChangeListener;
-    supportedTransitionConfiguration;
-    transitionControl;
-    activeTransitionCount;
-    colorTemperatureCharacteristic;
-    brightnessCharacteristic;
-    saturationCharacteristic;
-    hueCharacteristic;
-    activeTransition;
-    didRunFirstInitializationStep = false;
-    updateTimeout;
-    lastTransitionPointInfo;
-    lastEventNotificationSent = 0;
-    lastNotifiedTemperatureValue = 0;
-    lastNotifiedSaturationValue = 0;
-    lastNotifiedHueValue = 0;
+var AdaptiveLightingController = /** @class */ (function (_super) {
+    tslib_1.__extends(AdaptiveLightingController, _super);
     /**
      * Creates a new instance of the AdaptiveLightingController.
      * Refer to the {@link AdaptiveLightingController} documentation on how to use it.
@@ -251,29 +231,36 @@ class AdaptiveLightingController extends events_1.EventEmitter {
      * @param service - The lightbulb to which Adaptive Lighting support should be added.
      * @param options - Optional options to define the operating mode (automatic vs manual).
      */
-    constructor(service, options) {
-        super();
-        this.lightbulb = service;
-        this.mode = options?.controllerMode ?? 1 /* AdaptiveLightingControllerMode.AUTOMATIC */;
-        this.customTemperatureAdjustment = options?.customTemperatureAdjustment ?? 0;
-        (0, assert_1.default)(this.lightbulb.testCharacteristic(Characteristic_1.Characteristic.ColorTemperature), "Lightbulb must have the ColorTemperature characteristic added!");
-        (0, assert_1.default)(this.lightbulb.testCharacteristic(Characteristic_1.Characteristic.Brightness), "Lightbulb must have the Brightness characteristic added!");
-        this.adjustmentFactorChangedListener = this.handleAdjustmentFactorChanged.bind(this);
-        this.characteristicManualWrittenChangeListener = this.handleCharacteristicManualWritten.bind(this);
+    function AdaptiveLightingController(service, options) {
+        var _a, _b;
+        var _this = _super.call(this) || this;
+        _this.didRunFirstInitializationStep = false;
+        _this.lastEventNotificationSent = 0;
+        _this.lastNotifiedTemperatureValue = 0;
+        _this.lastNotifiedSaturationValue = 0;
+        _this.lastNotifiedHueValue = 0;
+        _this.lightbulb = service;
+        _this.mode = (_a = options === null || options === void 0 ? void 0 : options.controllerMode) !== null && _a !== void 0 ? _a : 1 /* AdaptiveLightingControllerMode.AUTOMATIC */;
+        _this.customTemperatureAdjustment = (_b = options === null || options === void 0 ? void 0 : options.customTemperatureAdjustment) !== null && _b !== void 0 ? _b : 0;
+        (0, assert_1.default)(_this.lightbulb.testCharacteristic(Characteristic_1.Characteristic.ColorTemperature), "Lightbulb must have the ColorTemperature characteristic added!");
+        (0, assert_1.default)(_this.lightbulb.testCharacteristic(Characteristic_1.Characteristic.Brightness), "Lightbulb must have the Brightness characteristic added!");
+        _this.adjustmentFactorChangedListener = _this.handleAdjustmentFactorChanged.bind(_this);
+        _this.characteristicManualWrittenChangeListener = _this.handleCharacteristicManualWritten.bind(_this);
+        return _this;
     }
     /**
      * @private
      */
-    controllerId() {
+    AdaptiveLightingController.prototype.controllerId = function () {
         return "characteristic-transition" /* DefaultControllerType.CHARACTERISTIC_TRANSITION */ + "-" + this.lightbulb.getServiceId();
-    }
+    };
     // ----------- PUBLIC API START -----------
     /**
      * Returns if a Adaptive Lighting transition is currently active.
      */
-    isAdaptiveLightingActive() {
+    AdaptiveLightingController.prototype.isAdaptiveLightingActive = function () {
         return !!this.activeTransition;
-    }
+    };
     /**
      * This method can be called to manually disable the current active Adaptive Lighting transition.
      * When using {@link AdaptiveLightingControllerMode.AUTOMATIC} you won't need to call this method.
@@ -281,18 +268,23 @@ class AdaptiveLightingController extends events_1.EventEmitter {
      * This is the case when the user manually changes the value of Hue, Saturation or ColorTemperature characteristics
      * (or if any of those values is changed by physical interaction with the lightbulb).
      */
-    disableAdaptiveLighting() {
+    AdaptiveLightingController.prototype.disableAdaptiveLighting = function () {
+        var _a;
         if (this.updateTimeout) {
             clearTimeout(this.updateTimeout);
             this.updateTimeout = undefined;
         }
         if (this.activeTransition) {
-            this.colorTemperatureCharacteristic?.removeListener("change" /* CharacteristicEventTypes.CHANGE */, this.characteristicManualWrittenChangeListener);
-            this.brightnessCharacteristic?.removeListener("change" /* CharacteristicEventTypes.CHANGE */, this.adjustmentFactorChangedListener);
-            this.hueCharacteristic?.removeListener("change" /* CharacteristicEventTypes.CHANGE */, this.characteristicManualWrittenChangeListener);
-            this.saturationCharacteristic?.removeListener("change" /* CharacteristicEventTypes.CHANGE */, this.characteristicManualWrittenChangeListener);
+            this.colorTemperatureCharacteristic.removeListener("change" /* CharacteristicEventTypes.CHANGE */, this.characteristicManualWrittenChangeListener);
+            this.brightnessCharacteristic.removeListener("change" /* CharacteristicEventTypes.CHANGE */, this.adjustmentFactorChangedListener);
+            if (this.hueCharacteristic) {
+                this.hueCharacteristic.removeListener("change" /* CharacteristicEventTypes.CHANGE */, this.characteristicManualWrittenChangeListener);
+            }
+            if (this.saturationCharacteristic) {
+                this.saturationCharacteristic.removeListener("change" /* CharacteristicEventTypes.CHANGE */, this.characteristicManualWrittenChangeListener);
+            }
             this.activeTransition = undefined;
-            this.stateChangeDelegate?.();
+            (_a = this.stateChangeDelegate) === null || _a === void 0 ? void 0 : _a.call(this);
         }
         this.colorTemperatureCharacteristic = undefined;
         this.brightnessCharacteristic = undefined;
@@ -304,20 +296,20 @@ class AdaptiveLightingController extends events_1.EventEmitter {
         this.lastNotifiedSaturationValue = 0;
         this.lastNotifiedHueValue = 0;
         this.didRunFirstInitializationStep = false;
-        this.activeTransitionCount?.sendEventNotification(0);
+        this.activeTransitionCount.sendEventNotification(0);
         debug("[%s] Disabling adaptive lighting", this.lightbulb.displayName);
-    }
+    };
     /**
      * Returns the time where the current transition curve was started in epoch time millis.
      * A transition curves is active for 24 hours typically and is renewed every 24 hours by a HomeHub.
      * Additionally see {@link getAdaptiveLightingTimeOffset}.
      */
-    getAdaptiveLightingStartTimeOfTransition() {
+    AdaptiveLightingController.prototype.getAdaptiveLightingStartTimeOfTransition = function () {
         if (!this.activeTransition) {
             throw new Error("There is no active transition!");
         }
         return this.activeTransition.transitionStartMillis;
-    }
+    };
     /**
      * It is not necessarily given, that we have the same time (or rather the correct time) as the HomeKit controller
      * who set up the transition schedule.
@@ -326,24 +318,24 @@ class AdaptiveLightingController extends events_1.EventEmitter {
      * So in the case were we actually have a correct local time, it most likely will be positive (due to network latency).
      * But of course it can also be negative.
      */
-    getAdaptiveLightingTimeOffset() {
+    AdaptiveLightingController.prototype.getAdaptiveLightingTimeOffset = function () {
         if (!this.activeTransition) {
             throw new Error("There is no active transition!");
         }
         return this.activeTransition.timeMillisOffset;
-    }
-    getAdaptiveLightingTransitionCurve() {
+    };
+    AdaptiveLightingController.prototype.getAdaptiveLightingTransitionCurve = function () {
         if (!this.activeTransition) {
             throw new Error("There is no active transition!");
         }
         return this.activeTransition.transitionCurve;
-    }
-    getAdaptiveLightingBrightnessMultiplierRange() {
+    };
+    AdaptiveLightingController.prototype.getAdaptiveLightingBrightnessMultiplierRange = function () {
         if (!this.activeTransition) {
             throw new Error("There is no active transition!");
         }
         return this.activeTransition.brightnessAdjustmentRange;
-    }
+    };
     /**
      * This method returns the interval (in milliseconds) in which the light should update its internal color temperature
      * (aka changes it physical color).
@@ -351,12 +343,12 @@ class AdaptiveLightingController extends events_1.EventEmitter {
      *
      * Typically this evaluates to 60000 milliseconds (60 seconds).
      */
-    getAdaptiveLightingUpdateInterval() {
+    AdaptiveLightingController.prototype.getAdaptiveLightingUpdateInterval = function () {
         if (!this.activeTransition) {
             throw new Error("There is no active transition!");
         }
         return this.activeTransition.updateInterval;
-    }
+    };
     /**
      * Returns the minimum interval threshold (in milliseconds) a accessory may notify HomeKit controllers about a new
      * color temperature value via event notifications (what happens when you call {@link Characteristic.updateValue}).
@@ -364,47 +356,36 @@ class AdaptiveLightingController extends events_1.EventEmitter {
      *
      * Typically this evaluates to 600000 milliseconds (10 minutes).
      */
-    getAdaptiveLightingNotifyIntervalThreshold() {
+    AdaptiveLightingController.prototype.getAdaptiveLightingNotifyIntervalThreshold = function () {
         if (!this.activeTransition) {
             throw new Error("There is no active transition!");
         }
         return this.activeTransition.notifyIntervalThreshold;
-    }
+    };
     // ----------- PUBLIC API END -----------
-    handleActiveTransitionUpdated(calledFromDeserializer = false) {
-        if (this.activeTransitionCount) {
-            if (!calledFromDeserializer) {
-                this.activeTransitionCount.sendEventNotification(1);
-            }
-            else {
-                this.activeTransitionCount.value = 1;
-            }
+    AdaptiveLightingController.prototype.handleActiveTransitionUpdated = function (calledFromDeserializer) {
+        var _a;
+        if (calledFromDeserializer === void 0) { calledFromDeserializer = false; }
+        if (!calledFromDeserializer) {
+            this.activeTransitionCount.sendEventNotification(1);
+        }
+        else {
+            this.activeTransitionCount.value = 1;
         }
         if (this.mode === 1 /* AdaptiveLightingControllerMode.AUTOMATIC */) {
             this.scheduleNextUpdate();
         }
         else if (this.mode === 2 /* AdaptiveLightingControllerMode.MANUAL */) {
-            if (!this.activeTransition) {
-                throw new Error("There is no active transition!");
-            }
-            const update = {
-                transitionStartMillis: this.activeTransition.transitionStartMillis,
-                timeMillisOffset: this.activeTransition.timeMillisOffset,
-                transitionCurve: this.activeTransition.transitionCurve,
-                brightnessAdjustmentRange: this.activeTransition.brightnessAdjustmentRange,
-                updateInterval: this.activeTransition.updateInterval,
-                notifyIntervalThreshold: this.activeTransition.notifyIntervalThreshold,
-            };
-            this.emit("update" /* AdaptiveLightingControllerEvents.UPDATE */, update);
+            this.emit("update" /* AdaptiveLightingControllerEvents.UPDATE */);
         }
         else {
             throw new Error("Unsupported adaptive lighting controller mode: " + this.mode);
         }
         if (!calledFromDeserializer) {
-            this.stateChangeDelegate?.();
+            (_a = this.stateChangeDelegate) === null || _a === void 0 ? void 0 : _a.call(this);
         }
-    }
-    handleAdaptiveLightingEnabled() {
+    };
+    AdaptiveLightingController.prototype.handleAdaptiveLightingEnabled = function () {
         if (!this.activeTransition) {
             throw new Error("There is no active transition!");
         }
@@ -420,14 +401,15 @@ class AdaptiveLightingController extends events_1.EventEmitter {
             this.saturationCharacteristic = this.lightbulb.getCharacteristic(Characteristic_1.Characteristic.Saturation)
                 .on("change" /* CharacteristicEventTypes.CHANGE */, this.characteristicManualWrittenChangeListener);
         }
-    }
-    handleAdaptiveLightingDisabled() {
+    };
+    AdaptiveLightingController.prototype.handleAdaptiveLightingDisabled = function () {
         if (this.mode === 2 /* AdaptiveLightingControllerMode.MANUAL */ && this.activeTransition) { // only emit the event if a transition is actually enabled
             this.emit("disable" /* AdaptiveLightingControllerEvents.DISABLED */);
         }
         this.disableAdaptiveLighting();
-    }
-    handleAdjustmentFactorChanged(change) {
+    };
+    AdaptiveLightingController.prototype.handleAdjustmentFactorChanged = function (change) {
+        var _this = this;
         if (change.newValue === change.oldValue) {
             return;
         }
@@ -444,24 +426,24 @@ class AdaptiveLightingController extends events_1.EventEmitter {
             // if the reason is a read request, we expect that Hue/Saturation are also read
             // thus we postpone our update to ColorTemperature a bit.
             // It doesn't ensure that those race conditions do not happen anymore, but with a 1s delay it reduces the possibility by a bit
-            setTimeout(() => {
-                if (!this.activeTransition) {
+            setTimeout(function () {
+                if (!_this.activeTransition) {
                     return; // was disabled in the mean time
                 }
-                this.scheduleNextUpdate(true);
+                _this.scheduleNextUpdate(true);
             }, 1000).unref();
         }
         else {
             this.scheduleNextUpdate(true); // run a dry scheduleNextUpdate to adjust the colorTemperature using the new brightness value
         }
-    }
+    };
     /**
      * This method is called when a change happens to the Hue/Saturation or ColorTemperature characteristic.
      * When such a write happens (caused by the user changing the color/temperature) Adaptive Lighting must be disabled.
      *
      * @param change
      */
-    handleCharacteristicManualWritten(change) {
+    AdaptiveLightingController.prototype.handleCharacteristicManualWritten = function (change) {
         if (change.reason === "write" /* ChangeReason.WRITE */ && !(isAdaptiveLightingContext(change.context) && change.context.controller === this)) {
             // we ignore write request which are the result of calls made to updateValue or sendEventNotification
             // or the result of a changed value returned by a read handler
@@ -469,27 +451,28 @@ class AdaptiveLightingController extends events_1.EventEmitter {
             debug("[%s] Received a manual write to an characteristic (newValue: %d, oldValue: %d, reason: %s). Thus disabling adaptive lighting!", this.lightbulb.displayName, change.newValue, change.oldValue, change.reason);
             this.disableAdaptiveLighting();
         }
-    }
+    };
     /**
      * Retrieve the {@link AdaptiveLightingTransitionPoint} for the current timestamp.
      * Returns undefined if the current transition schedule reached its end.
      */
-    getCurrentAdaptiveLightingTransitionPoint() {
+    AdaptiveLightingController.prototype.getCurrentAdaptiveLightingTransitionPoint = function () {
+        var _a, _b, _c, _d, _e;
         if (!this.activeTransition) {
             throw new Error("Cannot calculate current transition point if no transition is active!");
         }
         // adjustedNow is the now() date corrected to the time of the initiating controller
-        const adjustedNow = Date.now() - this.activeTransition.timeMillisOffset;
+        var adjustedNow = Date.now() - this.activeTransition.timeMillisOffset;
         // "offset" since the start of the transition schedule
-        const offset = adjustedNow - this.activeTransition.transitionStartMillis;
-        let i = this.lastTransitionPointInfo?.curveIndex ?? 0;
-        let lowerBoundTimeOffset = this.lastTransitionPointInfo?.lowerBoundTimeOffset ?? 0; // time offset to the lowerBound transition entry
-        let lowerBound = undefined;
-        let upperBound = undefined;
+        var offset = adjustedNow - this.activeTransition.transitionStartMillis;
+        var i = (_b = (_a = this.lastTransitionPointInfo) === null || _a === void 0 ? void 0 : _a.curveIndex) !== null && _b !== void 0 ? _b : 0;
+        var lowerBoundTimeOffset = (_d = (_c = this.lastTransitionPointInfo) === null || _c === void 0 ? void 0 : _c.lowerBoundTimeOffset) !== null && _d !== void 0 ? _d : 0; // time offset to the lowerBound transition entry
+        var lowerBound = undefined;
+        var upperBound = undefined;
         for (; i + 1 < this.activeTransition.transitionCurve.length; i++) {
-            const lowerBound0 = this.activeTransition.transitionCurve[i];
-            const upperBound0 = this.activeTransition.transitionCurve[i + 1];
-            const lowerBoundDuration = lowerBound0.duration ?? 0;
+            var lowerBound0 = this.activeTransition.transitionCurve[i];
+            var upperBound0 = this.activeTransition.transitionCurve[i + 1];
+            var lowerBoundDuration = (_e = lowerBound0.duration) !== null && _e !== void 0 ? _e : 0;
             lowerBoundTimeOffset += lowerBound0.transitionTime;
             if (offset >= lowerBoundTimeOffset) {
                 if (offset <= lowerBoundTimeOffset + lowerBoundDuration + upperBound0.transitionTime) {
@@ -524,8 +507,11 @@ class AdaptiveLightingController extends events_1.EventEmitter {
             lowerBound: lowerBound,
             upperBound: upperBound,
         };
-    }
-    scheduleNextUpdate(dryRun = false) {
+    };
+    AdaptiveLightingController.prototype.scheduleNextUpdate = function (dryRun) {
+        var _this = this;
+        var _a, _b, _c, _d, _e;
+        if (dryRun === void 0) { dryRun = false; }
         if (!this.activeTransition) {
             throw new Error("tried scheduling transition when no transition was active!");
         }
@@ -536,7 +522,7 @@ class AdaptiveLightingController extends events_1.EventEmitter {
             this.didRunFirstInitializationStep = true;
             this.handleAdaptiveLightingEnabled();
         }
-        const transitionPoint = this.getCurrentAdaptiveLightingTransitionPoint();
+        var transitionPoint = this.getCurrentAdaptiveLightingTransitionPoint();
         if (!transitionPoint) {
             debug("[%s] Reached end of transition curve!", this.lightbulb.displayName);
             if (!dryRun) {
@@ -545,30 +531,30 @@ class AdaptiveLightingController extends events_1.EventEmitter {
             }
             return;
         }
-        const lowerBound = transitionPoint.lowerBound;
-        const upperBound = transitionPoint.upperBound;
-        let interpolatedTemperature;
-        let interpolatedAdjustmentFactor;
+        var lowerBound = transitionPoint.lowerBound;
+        var upperBound = transitionPoint.upperBound;
+        var interpolatedTemperature;
+        var interpolatedAdjustmentFactor;
         if (lowerBound.duration && transitionPoint.transitionOffset <= lowerBound.duration) {
             interpolatedTemperature = lowerBound.temperature;
             interpolatedAdjustmentFactor = lowerBound.brightnessAdjustmentFactor;
         }
         else {
-            const timePercentage = (transitionPoint.transitionOffset - (lowerBound.duration ?? 0)) / upperBound.transitionTime;
+            var timePercentage = (transitionPoint.transitionOffset - ((_a = lowerBound.duration) !== null && _a !== void 0 ? _a : 0)) / upperBound.transitionTime;
             interpolatedTemperature = lowerBound.temperature + (upperBound.temperature - lowerBound.temperature) * timePercentage;
             interpolatedAdjustmentFactor = lowerBound.brightnessAdjustmentFactor
                 + (upperBound.brightnessAdjustmentFactor - lowerBound.brightnessAdjustmentFactor) * timePercentage;
         }
-        const adjustmentMultiplier = Math.max(this.activeTransition.brightnessAdjustmentRange.minBrightnessValue, Math.min(this.activeTransition.brightnessAdjustmentRange.maxBrightnessValue, this.brightnessCharacteristic?.value));
-        let temperature = Math.round(interpolatedTemperature + interpolatedAdjustmentFactor * adjustmentMultiplier);
+        var adjustmentMultiplier = Math.max(this.activeTransition.brightnessAdjustmentRange.minBrightnessValue, Math.min(this.activeTransition.brightnessAdjustmentRange.maxBrightnessValue, this.brightnessCharacteristic.value));
+        var temperature = Math.round(interpolatedTemperature + interpolatedAdjustmentFactor * adjustmentMultiplier);
         // apply any manually applied temperature adjustments
         temperature += this.customTemperatureAdjustment;
-        const min = this.colorTemperatureCharacteristic?.props.minValue ?? 140;
-        const max = this.colorTemperatureCharacteristic?.props.maxValue ?? 500;
+        var min = (_c = (_b = this.colorTemperatureCharacteristic) === null || _b === void 0 ? void 0 : _b.props.minValue) !== null && _c !== void 0 ? _c : 140;
+        var max = (_e = (_d = this.colorTemperatureCharacteristic) === null || _d === void 0 ? void 0 : _d.props.maxValue) !== null && _e !== void 0 ? _e : 500;
         temperature = Math.max(min, Math.min(max, temperature));
-        const color = color_utils_1.ColorUtils.colorTemperatureToHueAndSaturation(temperature);
+        var color = color_utils_1.ColorUtils.colorTemperatureToHueAndSaturation(temperature);
         debug("[%s] Next temperature value is %d (for brightness %d adj: %s)", this.lightbulb.displayName, temperature, adjustmentMultiplier, this.customTemperatureAdjustment);
-        const context = {
+        var context = {
             controller: this,
             omitEventUpdate: true,
         };
@@ -593,8 +579,8 @@ class AdaptiveLightingController extends events_1.EventEmitter {
         if (this.hueCharacteristic) {
             this.hueCharacteristic.value = color.hue;
         }
-        this.colorTemperatureCharacteristic?.handleSetRequest(temperature, undefined, context).catch(reason => {
-            debug("[%s] Failed to next adaptive lighting transition point: %d", this.lightbulb.displayName, reason);
+        this.colorTemperatureCharacteristic.handleSetRequest(temperature, undefined, context).catch(function (reason) {
+            debug("[%s] Failed to next adaptive lighting transition point: %d", _this.lightbulb.displayName, reason);
         });
         if (!this.activeTransition) {
             console.warn("[" + this.lightbulb.displayName + "] Adaptive Lighting was probably disable my mistake by some call in " +
@@ -602,15 +588,15 @@ class AdaptiveLightingController extends events_1.EventEmitter {
                 "Please check that you don't call setValue/setCharacteristic on the Hue, Saturation or ColorTemperature characteristic!");
             return;
         }
-        const now = Date.now();
+        var now = Date.now();
         if (!dryRun && now - this.lastEventNotificationSent >= this.activeTransition.notifyIntervalThreshold) {
             debug("[%s] Sending event notifications for current transition!", this.lightbulb.displayName);
             this.lastEventNotificationSent = now;
-            const eventContext = {
+            var eventContext = {
                 controller: this,
             };
             if (this.lastNotifiedTemperatureValue !== temperature) {
-                this.colorTemperatureCharacteristic?.sendEventNotification(temperature, eventContext);
+                this.colorTemperatureCharacteristic.sendEventNotification(temperature, eventContext);
                 this.lastNotifiedTemperatureValue = temperature;
             }
             if (this.saturationCharacteristic && this.lastNotifiedSaturationValue !== color.saturation) {
@@ -625,24 +611,25 @@ class AdaptiveLightingController extends events_1.EventEmitter {
         if (!dryRun) {
             this.updateTimeout = setTimeout(this.scheduleNextUpdate.bind(this), this.activeTransition.updateInterval);
         }
-    }
+    };
     /**
      * @private
      */
-    constructServices() {
+    AdaptiveLightingController.prototype.constructServices = function () {
         return {};
-    }
+    };
     /**
      * @private
      */
     // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    initWithServices(serviceMap) {
+    AdaptiveLightingController.prototype.initWithServices = function (serviceMap) {
         // do nothing
-    }
+    };
     /**
      * @private
      */
-    configureServices() {
+    AdaptiveLightingController.prototype.configureServices = function () {
+        var _this = this;
         this.supportedTransitionConfiguration = this.lightbulb.getCharacteristic(Characteristic_1.Characteristic.SupportedCharacteristicValueTransitionConfiguration);
         this.transitionControl = this.lightbulb.getCharacteristic(Characteristic_1.Characteristic.CharacteristicValueTransitionControl)
             .updateValue("");
@@ -651,25 +638,25 @@ class AdaptiveLightingController extends events_1.EventEmitter {
         this.supportedTransitionConfiguration
             .onGet(this.handleSupportedTransitionConfigurationRead.bind(this));
         this.transitionControl
-            .onGet(() => {
-            return this.buildTransitionControlResponseBuffer().toString("base64");
+            .onGet(function () {
+            return _this.buildTransitionControlResponseBuffer().toString("base64");
         })
-            .onSet(value => {
+            .onSet(function (value) {
             try {
-                return this.handleTransitionControlWrite(value);
+                return _this.handleTransitionControlWrite(value);
             }
             catch (error) {
-                console.warn(`[%s] DEBUG: '${value}'`);
+                console.warn("[%s] DEBUG: '".concat(value, "'"));
                 console.warn("[%s] Encountered error on CharacteristicValueTransitionControl characteristic: " + error.stack);
-                this.disableAdaptiveLighting();
+                _this.disableAdaptiveLighting();
                 throw new hapStatusError_1.HapStatusError(-70402 /* HAPStatus.SERVICE_COMMUNICATION_FAILURE */);
             }
         });
-    }
+    };
     /**
      * @private
      */
-    handleControllerRemoved() {
+    AdaptiveLightingController.prototype.handleControllerRemoved = function () {
         this.lightbulb.removeCharacteristic(this.supportedTransitionConfiguration);
         this.lightbulb.removeCharacteristic(this.transitionControl);
         this.lightbulb.removeCharacteristic(this.activeTransitionCount);
@@ -677,28 +664,28 @@ class AdaptiveLightingController extends events_1.EventEmitter {
         this.transitionControl = undefined;
         this.activeTransitionCount = undefined;
         this.removeAllListeners();
-    }
+    };
     /**
      * @private
      */
-    handleFactoryReset() {
+    AdaptiveLightingController.prototype.handleFactoryReset = function () {
         this.handleAdaptiveLightingDisabled();
-    }
+    };
     /**
      * @private
      */
-    serialize() {
+    AdaptiveLightingController.prototype.serialize = function () {
         if (!this.activeTransition) {
             return undefined;
         }
         return {
             activeTransition: this.activeTransition,
         };
-    }
+    };
     /**
      * @private
      */
-    deserialize(serialized) {
+    AdaptiveLightingController.prototype.deserialize = function (serialized) {
         this.activeTransition = serialized.activeTransition;
         // Data migrations from beta builds
         if (!this.activeTransition.transitionId) {
@@ -711,145 +698,158 @@ class AdaptiveLightingController extends events_1.EventEmitter {
             this.activeTransition.timeMillisOffset = 0;
         }
         this.handleActiveTransitionUpdated(true);
-    }
+    };
     /**
      * @private
      */
-    setupStateChangeDelegate(delegate) {
+    AdaptiveLightingController.prototype.setupStateChangeDelegate = function (delegate) {
         this.stateChangeDelegate = delegate;
-    }
-    handleSupportedTransitionConfigurationRead() {
-        const brightnessIID = this.lightbulb?.getCharacteristic(Characteristic_1.Characteristic.Brightness).iid;
-        const temperatureIID = this.lightbulb?.getCharacteristic(Characteristic_1.Characteristic.ColorTemperature).iid;
+    };
+    AdaptiveLightingController.prototype.handleSupportedTransitionConfigurationRead = function () {
+        var brightnessIID = this.lightbulb.getCharacteristic(Characteristic_1.Characteristic.Brightness).iid;
+        var temperatureIID = this.lightbulb.getCharacteristic(Characteristic_1.Characteristic.ColorTemperature).iid;
         (0, assert_1.default)(brightnessIID, "iid for brightness characteristic is undefined");
         (0, assert_1.default)(temperatureIID, "iid for temperature characteristic is undefined");
         return tlv.encode(1 /* SupportedCharacteristicValueTransitionConfigurationsTypes.SUPPORTED_TRANSITION_CONFIGURATION */, [
             tlv.encode(1 /* SupportedValueTransitionConfigurationTypes.CHARACTERISTIC_IID */, tlv.writeVariableUIntLE(brightnessIID), 2 /* SupportedValueTransitionConfigurationTypes.TRANSITION_TYPE */, 1 /* TransitionType.BRIGHTNESS */),
             tlv.encode(1 /* SupportedValueTransitionConfigurationTypes.CHARACTERISTIC_IID */, tlv.writeVariableUIntLE(temperatureIID), 2 /* SupportedValueTransitionConfigurationTypes.TRANSITION_TYPE */, 2 /* TransitionType.COLOR_TEMPERATURE */),
         ]).toString("base64");
-    }
-    buildTransitionControlResponseBuffer(time) {
+    };
+    AdaptiveLightingController.prototype.buildTransitionControlResponseBuffer = function (time) {
         if (!this.activeTransition) {
             return Buffer.alloc(0);
         }
-        const active = this.activeTransition;
-        const timeSinceStart = time ?? (Date.now() - active.timeMillisOffset - active.transitionStartMillis);
-        const timeSinceStartBuffer = tlv.writeVariableUIntLE(timeSinceStart);
-        let parameters = tlv.encode(1 /* ValueTransitionParametersTypes.TRANSITION_ID */, uuid.write(active.transitionId), 2 /* ValueTransitionParametersTypes.START_TIME */, Buffer.from(active.transitionStartBuffer, "hex"));
+        var active = this.activeTransition;
+        var timeSinceStart = time !== null && time !== void 0 ? time : (Date.now() - active.timeMillisOffset - active.transitionStartMillis);
+        var timeSinceStartBuffer = tlv.writeVariableUIntLE(timeSinceStart);
+        var parameters = tlv.encode(1 /* ValueTransitionParametersTypes.TRANSITION_ID */, uuid.write(active.transitionId), 2 /* ValueTransitionParametersTypes.START_TIME */, Buffer.from(active.transitionStartBuffer, "hex"));
         if (active.id3) {
             parameters = Buffer.concat([
                 parameters,
                 tlv.encode(3 /* ValueTransitionParametersTypes.UNKNOWN_3 */, Buffer.from(active.id3, "hex")),
             ]);
         }
-        const status = tlv.encode(1 /* ValueTransitionConfigurationStatusTypes.CHARACTERISTIC_IID */, tlv.writeVariableUIntLE(active.iid), 2 /* ValueTransitionConfigurationStatusTypes.TRANSITION_PARAMETERS */, parameters, 3 /* ValueTransitionConfigurationStatusTypes.TIME_SINCE_START */, timeSinceStartBuffer);
+        var status = tlv.encode(1 /* ValueTransitionConfigurationStatusTypes.CHARACTERISTIC_IID */, tlv.writeVariableUIntLE(active.iid), 2 /* ValueTransitionConfigurationStatusTypes.TRANSITION_PARAMETERS */, parameters, 3 /* ValueTransitionConfigurationStatusTypes.TIME_SINCE_START */, timeSinceStartBuffer);
         return tlv.encode(1 /* ValueTransitionConfigurationResponseTypes.VALUE_CONFIGURATION_STATUS */, status);
-    }
-    handleTransitionControlWrite(value) {
+    };
+    AdaptiveLightingController.prototype.handleTransitionControlWrite = function (value) {
         if (typeof value !== "string") {
             throw new hapStatusError_1.HapStatusError(-70410 /* HAPStatus.INVALID_VALUE_IN_REQUEST */);
         }
-        const tlvData = tlv.decode(Buffer.from(value, "base64"));
-        const responseBuffers = [];
-        const readTransition = tlvData[1 /* TransitionControlTypes.READ_CURRENT_VALUE_TRANSITION_CONFIGURATION */];
+        var tlvData = tlv.decode(Buffer.from(value, "base64"));
+        var responseBuffers = [];
+        var readTransition = tlvData[1 /* TransitionControlTypes.READ_CURRENT_VALUE_TRANSITION_CONFIGURATION */];
         if (readTransition) {
-            const readTransitionResponse = this.handleTransitionControlReadTransition(readTransition);
+            var readTransitionResponse = this.handleTransitionControlReadTransition(readTransition);
             if (readTransitionResponse) {
                 responseBuffers.push(readTransitionResponse);
             }
         }
-        const updateTransition = tlvData[2 /* TransitionControlTypes.UPDATE_VALUE_TRANSITION_CONFIGURATION */];
+        var updateTransition = tlvData[2 /* TransitionControlTypes.UPDATE_VALUE_TRANSITION_CONFIGURATION */];
         if (updateTransition) {
-            const updateTransitionResponse = this.handleTransitionControlUpdateTransition(updateTransition);
+            var updateTransitionResponse = this.handleTransitionControlUpdateTransition(updateTransition);
             if (updateTransitionResponse) {
                 responseBuffers.push(updateTransitionResponse);
             }
         }
         return Buffer.concat(responseBuffers).toString("base64");
-    }
-    handleTransitionControlReadTransition(buffer) {
-        const readTransition = tlv.decode(buffer);
-        const iid = tlv.readVariableUIntLE(readTransition[1 /* ReadValueTransitionConfiguration.CHARACTERISTIC_IID */]);
+    };
+    AdaptiveLightingController.prototype.handleTransitionControlReadTransition = function (buffer) {
+        var readTransition = tlv.decode(buffer);
+        var iid = tlv.readVariableUIntLE(readTransition[1 /* ReadValueTransitionConfiguration.CHARACTERISTIC_IID */]);
         if (this.activeTransition) {
             if (this.activeTransition.iid !== iid) {
                 console.warn("[" + this.lightbulb.displayName + "] iid of current adaptive lighting transition (" + this.activeTransition.iid
                     + ") doesn't match the requested one " + iid);
                 throw new hapStatusError_1.HapStatusError(-70410 /* HAPStatus.INVALID_VALUE_IN_REQUEST */);
             }
-            let parameters = tlv.encode(1 /* ValueTransitionParametersTypes.TRANSITION_ID */, uuid.write(this.activeTransition.transitionId), 2 /* ValueTransitionParametersTypes.START_TIME */, Buffer.from(this.activeTransition.transitionStartBuffer, "hex"));
+            var parameters = tlv.encode(1 /* ValueTransitionParametersTypes.TRANSITION_ID */, uuid.write(this.activeTransition.transitionId), 2 /* ValueTransitionParametersTypes.START_TIME */, Buffer.from(this.activeTransition.transitionStartBuffer, "hex"));
             if (this.activeTransition.id3) {
                 parameters = Buffer.concat([
                     parameters,
                     tlv.encode(3 /* ValueTransitionParametersTypes.UNKNOWN_3 */, Buffer.from(this.activeTransition.id3, "hex")),
                 ]);
             }
-            return tlv.encode(1 /* TransitionControlTypes.READ_CURRENT_VALUE_TRANSITION_CONFIGURATION */, tlv.encode(1 /* ValueTransitionConfigurationTypes.CHARACTERISTIC_IID */, tlv.writeVariableUIntLE(this.activeTransition.iid), 2 /* ValueTransitionConfigurationTypes.TRANSITION_PARAMETERS */, parameters, 3 /* ValueTransitionConfigurationTypes.UNKNOWN_3 */, 1, 5 /* ValueTransitionConfigurationTypes.TRANSITION_CURVE_CONFIGURATION */, tlv.encode(1 /* TransitionCurveConfigurationTypes.TRANSITION_ENTRY */, this.activeTransition.transitionCurve.map((entry, index, array) => {
-                const duration = array[index - 1]?.duration ?? 0; // we store stuff differently :sweat_smile:
+            return tlv.encode(1 /* TransitionControlTypes.READ_CURRENT_VALUE_TRANSITION_CONFIGURATION */, tlv.encode(1 /* ValueTransitionConfigurationTypes.CHARACTERISTIC_IID */, tlv.writeVariableUIntLE(this.activeTransition.iid), 2 /* ValueTransitionConfigurationTypes.TRANSITION_PARAMETERS */, parameters, 3 /* ValueTransitionConfigurationTypes.UNKNOWN_3 */, 1, 5 /* ValueTransitionConfigurationTypes.TRANSITION_CURVE_CONFIGURATION */, tlv.encode(1 /* TransitionCurveConfigurationTypes.TRANSITION_ENTRY */, this.activeTransition.transitionCurve.map(function (entry, index, array) {
+                var _a, _b;
+                var duration = (_b = (_a = array[index - 1]) === null || _a === void 0 ? void 0 : _a.duration) !== null && _b !== void 0 ? _b : 0; // we store stuff differently :sweat_smile:
                 return tlv.encode(1 /* TransitionEntryTypes.ADJUSTMENT_FACTOR */, tlv.writeFloat32LE(entry.brightnessAdjustmentFactor), 2 /* TransitionEntryTypes.VALUE */, tlv.writeFloat32LE(entry.temperature), 3 /* TransitionEntryTypes.TRANSITION_OFFSET */, tlv.writeVariableUIntLE(entry.transitionTime), 4 /* TransitionEntryTypes.DURATION */, tlv.writeVariableUIntLE(duration));
             }), 2 /* TransitionCurveConfigurationTypes.ADJUSTMENT_CHARACTERISTIC_IID */, tlv.writeVariableUIntLE(this.activeTransition.brightnessCharacteristicIID), 3 /* TransitionCurveConfigurationTypes.ADJUSTMENT_MULTIPLIER_RANGE */, tlv.encode(1 /* TransitionAdjustmentMultiplierRange.MINIMUM_ADJUSTMENT_MULTIPLIER */, tlv.writeUInt32(this.activeTransition.brightnessAdjustmentRange.minBrightnessValue), 2 /* TransitionAdjustmentMultiplierRange.MAXIMUM_ADJUSTMENT_MULTIPLIER */, tlv.writeUInt32(this.activeTransition.brightnessAdjustmentRange.maxBrightnessValue))), 6 /* ValueTransitionConfigurationTypes.UPDATE_INTERVAL */, tlv.writeVariableUIntLE(this.activeTransition.updateInterval), 8 /* ValueTransitionConfigurationTypes.NOTIFY_INTERVAL_THRESHOLD */, tlv.writeVariableUIntLE(this.activeTransition.notifyIntervalThreshold)));
         }
         else {
             return undefined; // returns empty string
         }
-    }
-    handleTransitionControlUpdateTransition(buffer) {
-        const updateTransition = tlv.decode(buffer);
-        const transitionConfiguration = tlv.decode(updateTransition[1 /* UpdateValueTransitionConfigurationsTypes.VALUE_TRANSITION_CONFIGURATION */]);
-        const iid = tlv.readVariableUIntLE(transitionConfiguration[1 /* ValueTransitionConfigurationTypes.CHARACTERISTIC_IID */]);
+    };
+    AdaptiveLightingController.prototype.handleTransitionControlUpdateTransition = function (buffer) {
+        var e_1, _a;
+        var _b, _c;
+        var updateTransition = tlv.decode(buffer);
+        var transitionConfiguration = tlv.decode(updateTransition[1 /* UpdateValueTransitionConfigurationsTypes.VALUE_TRANSITION_CONFIGURATION */]);
+        var iid = tlv.readVariableUIntLE(transitionConfiguration[1 /* ValueTransitionConfigurationTypes.CHARACTERISTIC_IID */]);
         if (!this.lightbulb.getCharacteristicByIID(iid)) {
             throw new hapStatusError_1.HapStatusError(-70410 /* HAPStatus.INVALID_VALUE_IN_REQUEST */);
         }
-        const param3 = transitionConfiguration[3 /* ValueTransitionConfigurationTypes.UNKNOWN_3 */]?.readUInt8(0); // when present it is always 1
+        var param3 = (_b = transitionConfiguration[3 /* ValueTransitionConfigurationTypes.UNKNOWN_3 */]) === null || _b === void 0 ? void 0 : _b.readUInt8(0); // when present it is always 1
         if (!param3) { // if HomeKit just sends the iid, we consider that as "disable adaptive lighting" (assumption)
             this.handleAdaptiveLightingDisabled();
             return tlv.encode(2 /* TransitionControlTypes.UPDATE_VALUE_TRANSITION_CONFIGURATION */, Buffer.alloc(0));
         }
-        const parametersTLV = tlv.decode(transitionConfiguration[2 /* ValueTransitionConfigurationTypes.TRANSITION_PARAMETERS */]);
-        const curveConfiguration = tlv.decodeWithLists(transitionConfiguration[5 /* ValueTransitionConfigurationTypes.TRANSITION_CURVE_CONFIGURATION */]);
-        const updateInterval = transitionConfiguration[6 /* ValueTransitionConfigurationTypes.UPDATE_INTERVAL */]?.readUInt16LE(0);
-        const notifyIntervalThreshold = transitionConfiguration[8 /* ValueTransitionConfigurationTypes.NOTIFY_INTERVAL_THRESHOLD */].readUInt32LE(0);
-        const transitionId = parametersTLV[1 /* ValueTransitionParametersTypes.TRANSITION_ID */];
-        const startTime = parametersTLV[2 /* ValueTransitionParametersTypes.START_TIME */];
-        const id3 = parametersTLV[3 /* ValueTransitionParametersTypes.UNKNOWN_3 */]; // this may be undefined
-        const startTimeMillis = (0, time_1.epochMillisFromMillisSince2001_01_01Buffer)(startTime);
-        const timeMillisOffset = Date.now() - startTimeMillis;
-        const transitionCurve = [];
-        let previous = undefined;
-        const transitions = curveConfiguration[1 /* TransitionCurveConfigurationTypes.TRANSITION_ENTRY */];
-        for (const entry of transitions) {
-            const tlvEntry = tlv.decode(entry);
-            const adjustmentFactor = tlvEntry[1 /* TransitionEntryTypes.ADJUSTMENT_FACTOR */].readFloatLE(0);
-            const value = tlvEntry[2 /* TransitionEntryTypes.VALUE */].readFloatLE(0);
-            const transitionOffset = tlv.readVariableUIntLE(tlvEntry[3 /* TransitionEntryTypes.TRANSITION_OFFSET */]);
-            const duration = tlvEntry[4 /* TransitionEntryTypes.DURATION */] ? tlv.readVariableUIntLE(tlvEntry[4 /* TransitionEntryTypes.DURATION */]) : undefined;
-            if (previous) {
-                previous.duration = duration;
+        var parametersTLV = tlv.decode(transitionConfiguration[2 /* ValueTransitionConfigurationTypes.TRANSITION_PARAMETERS */]);
+        var curveConfiguration = tlv.decodeWithLists(transitionConfiguration[5 /* ValueTransitionConfigurationTypes.TRANSITION_CURVE_CONFIGURATION */]);
+        var updateInterval = (_c = transitionConfiguration[6 /* ValueTransitionConfigurationTypes.UPDATE_INTERVAL */]) === null || _c === void 0 ? void 0 : _c.readUInt16LE(0);
+        var notifyIntervalThreshold = transitionConfiguration[8 /* ValueTransitionConfigurationTypes.NOTIFY_INTERVAL_THRESHOLD */].readUInt32LE(0);
+        var transitionId = parametersTLV[1 /* ValueTransitionParametersTypes.TRANSITION_ID */];
+        var startTime = parametersTLV[2 /* ValueTransitionParametersTypes.START_TIME */];
+        var id3 = parametersTLV[3 /* ValueTransitionParametersTypes.UNKNOWN_3 */]; // this may be undefined
+        var startTimeMillis = (0, time_1.epochMillisFromMillisSince2001_01_01Buffer)(startTime);
+        var timeMillisOffset = Date.now() - startTimeMillis;
+        var transitionCurve = [];
+        var previous = undefined;
+        var transitions = curveConfiguration[1 /* TransitionCurveConfigurationTypes.TRANSITION_ENTRY */];
+        try {
+            for (var transitions_1 = tslib_1.__values(transitions), transitions_1_1 = transitions_1.next(); !transitions_1_1.done; transitions_1_1 = transitions_1.next()) {
+                var entry = transitions_1_1.value;
+                var tlvEntry = tlv.decode(entry);
+                var adjustmentFactor = tlvEntry[1 /* TransitionEntryTypes.ADJUSTMENT_FACTOR */].readFloatLE(0);
+                var value = tlvEntry[2 /* TransitionEntryTypes.VALUE */].readFloatLE(0);
+                var transitionOffset = tlv.readVariableUIntLE(tlvEntry[3 /* TransitionEntryTypes.TRANSITION_OFFSET */]);
+                var duration = tlvEntry[4 /* TransitionEntryTypes.DURATION */] ? tlv.readVariableUIntLE(tlvEntry[4 /* TransitionEntryTypes.DURATION */]) : undefined;
+                if (previous) {
+                    previous.duration = duration;
+                }
+                previous = {
+                    temperature: value,
+                    brightnessAdjustmentFactor: adjustmentFactor,
+                    transitionTime: transitionOffset,
+                };
+                transitionCurve.push(previous);
             }
-            previous = {
-                temperature: value,
-                brightnessAdjustmentFactor: adjustmentFactor,
-                transitionTime: transitionOffset,
-            };
-            transitionCurve.push(previous);
         }
-        const adjustmentIID = tlv.readVariableUIntLE(curveConfiguration[2 /* TransitionCurveConfigurationTypes.ADJUSTMENT_CHARACTERISTIC_IID */]);
-        const adjustmentMultiplierRange = tlv.decode(curveConfiguration[3 /* TransitionCurveConfigurationTypes.ADJUSTMENT_MULTIPLIER_RANGE */]);
-        const minAdjustmentMultiplier = adjustmentMultiplierRange[1 /* TransitionAdjustmentMultiplierRange.MINIMUM_ADJUSTMENT_MULTIPLIER */].readUInt32LE(0);
-        const maxAdjustmentMultiplier = adjustmentMultiplierRange[2 /* TransitionAdjustmentMultiplierRange.MAXIMUM_ADJUSTMENT_MULTIPLIER */].readUInt32LE(0);
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (transitions_1_1 && !transitions_1_1.done && (_a = transitions_1.return)) _a.call(transitions_1);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        var adjustmentIID = tlv.readVariableUIntLE(curveConfiguration[2 /* TransitionCurveConfigurationTypes.ADJUSTMENT_CHARACTERISTIC_IID */]);
+        var adjustmentMultiplierRange = tlv.decode(curveConfiguration[3 /* TransitionCurveConfigurationTypes.ADJUSTMENT_MULTIPLIER_RANGE */]);
+        var minAdjustmentMultiplier = adjustmentMultiplierRange[1 /* TransitionAdjustmentMultiplierRange.MINIMUM_ADJUSTMENT_MULTIPLIER */].readUInt32LE(0);
+        var maxAdjustmentMultiplier = adjustmentMultiplierRange[2 /* TransitionAdjustmentMultiplierRange.MAXIMUM_ADJUSTMENT_MULTIPLIER */].readUInt32LE(0);
         this.activeTransition = {
             iid: iid,
             transitionStartMillis: startTimeMillis,
             timeMillisOffset: timeMillisOffset,
             transitionId: uuid.unparse(transitionId),
             transitionStartBuffer: startTime.toString("hex"),
-            id3: id3?.toString("hex"),
+            id3: id3 === null || id3 === void 0 ? void 0 : id3.toString("hex"),
             brightnessCharacteristicIID: adjustmentIID,
             brightnessAdjustmentRange: {
                 minBrightnessValue: minAdjustmentMultiplier,
                 maxBrightnessValue: maxAdjustmentMultiplier,
             },
             transitionCurve: transitionCurve,
-            updateInterval: updateInterval ?? 60000,
+            updateInterval: updateInterval !== null && updateInterval !== void 0 ? updateInterval : 60000,
             notifyIntervalThreshold: notifyIntervalThreshold,
         };
         if (this.updateTimeout) {
@@ -862,7 +862,8 @@ class AdaptiveLightingController extends events_1.EventEmitter {
         }
         this.handleActiveTransitionUpdated();
         return tlv.encode(2 /* TransitionControlTypes.UPDATE_VALUE_TRANSITION_CONFIGURATION */, this.buildTransitionControlResponseBuffer(0));
-    }
-}
+    };
+    return AdaptiveLightingController;
+}(events_1.EventEmitter));
 exports.AdaptiveLightingController = AdaptiveLightingController;
 //# sourceMappingURL=AdaptiveLightingController.js.map