hap-nodejs 1.1.1-beta.5 → 1.1.1-beta.7

package/dist/lib/controller/AdaptiveLightingController.js

@@ -1,50 +1,47 @@
-import assert from 'node:assert';
-import { Buffer } from 'node:buffer';
-import { EventEmitter } from 'node:events';
-import createDebug from 'debug';
-import { Characteristic } from '../Characteristic.js';
-import { ColorUtils } from '../util/color-utils.js';
-import { HapStatusError } from '../util/hapStatusError.js';
-import { epochMillisFromMillisSince2001_01_01Buffer } from '../util/time.js';
-import { decode, decodeWithLists, encode, readVariableUIntLE, writeFloat32LE, writeUInt32, writeVariableUIntLE, } from '../util/tlv.js';
-import { unparse, write } from '../util/uuid.js';
-const debug = createDebug('HAP-NodeJS:Controller:TransitionControl');
-// eslint-disable-next-line no-restricted-syntax
+"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 SupportedCharacteristicValueTransitionConfigurationsTypes;
 (function (SupportedCharacteristicValueTransitionConfigurationsTypes) {
     SupportedCharacteristicValueTransitionConfigurationsTypes[SupportedCharacteristicValueTransitionConfigurationsTypes["SUPPORTED_TRANSITION_CONFIGURATION"] = 1] = "SUPPORTED_TRANSITION_CONFIGURATION";
 })(SupportedCharacteristicValueTransitionConfigurationsTypes || (SupportedCharacteristicValueTransitionConfigurationsTypes = {}));
-// eslint-disable-next-line no-restricted-syntax
 var SupportedValueTransitionConfigurationTypes;
 (function (SupportedValueTransitionConfigurationTypes) {
     SupportedValueTransitionConfigurationTypes[SupportedValueTransitionConfigurationTypes["CHARACTERISTIC_IID"] = 1] = "CHARACTERISTIC_IID";
     SupportedValueTransitionConfigurationTypes[SupportedValueTransitionConfigurationTypes["TRANSITION_TYPE"] = 2] = "TRANSITION_TYPE";
 })(SupportedValueTransitionConfigurationTypes || (SupportedValueTransitionConfigurationTypes = {}));
-// eslint-disable-next-line no-restricted-syntax
 var TransitionType;
 (function (TransitionType) {
     TransitionType[TransitionType["BRIGHTNESS"] = 1] = "BRIGHTNESS";
     TransitionType[TransitionType["COLOR_TEMPERATURE"] = 2] = "COLOR_TEMPERATURE";
 })(TransitionType || (TransitionType = {}));
-// eslint-disable-next-line no-restricted-syntax
 var TransitionControlTypes;
 (function (TransitionControlTypes) {
     TransitionControlTypes[TransitionControlTypes["READ_CURRENT_VALUE_TRANSITION_CONFIGURATION"] = 1] = "READ_CURRENT_VALUE_TRANSITION_CONFIGURATION";
     TransitionControlTypes[TransitionControlTypes["UPDATE_VALUE_TRANSITION_CONFIGURATION"] = 2] = "UPDATE_VALUE_TRANSITION_CONFIGURATION";
 })(TransitionControlTypes || (TransitionControlTypes = {}));
-// eslint-disable-next-line no-restricted-syntax
 var ReadValueTransitionConfiguration;
 (function (ReadValueTransitionConfiguration) {
     ReadValueTransitionConfiguration[ReadValueTransitionConfiguration["CHARACTERISTIC_IID"] = 1] = "CHARACTERISTIC_IID";
 })(ReadValueTransitionConfiguration || (ReadValueTransitionConfiguration = {}));
-// eslint-disable-next-line no-restricted-syntax
 var UpdateValueTransitionConfigurationsTypes;
 (function (UpdateValueTransitionConfigurationsTypes) {
     UpdateValueTransitionConfigurationsTypes[UpdateValueTransitionConfigurationsTypes["VALUE_TRANSITION_CONFIGURATION"] = 1] = "VALUE_TRANSITION_CONFIGURATION";
 })(UpdateValueTransitionConfigurationsTypes || (UpdateValueTransitionConfigurationsTypes = {}));
-// eslint-disable-next-line no-restricted-syntax
 var ValueTransitionConfigurationTypes;
 (function (ValueTransitionConfigurationTypes) {
+    // noinspection JSUnusedGlobalSymbols
     ValueTransitionConfigurationTypes[ValueTransitionConfigurationTypes["CHARACTERISTIC_IID"] = 1] = "CHARACTERISTIC_IID";
     ValueTransitionConfigurationTypes[ValueTransitionConfigurationTypes["TRANSITION_PARAMETERS"] = 2] = "TRANSITION_PARAMETERS";
     ValueTransitionConfigurationTypes[ValueTransitionConfigurationTypes["UNKNOWN_3"] = 3] = "UNKNOWN_3";
@@ -54,21 +51,18 @@ var ValueTransitionConfigurationTypes;
     ValueTransitionConfigurationTypes[ValueTransitionConfigurationTypes["UNKNOWN_7"] = 7] = "UNKNOWN_7";
     ValueTransitionConfigurationTypes[ValueTransitionConfigurationTypes["NOTIFY_INTERVAL_THRESHOLD"] = 8] = "NOTIFY_INTERVAL_THRESHOLD";
 })(ValueTransitionConfigurationTypes || (ValueTransitionConfigurationTypes = {}));
-// eslint-disable-next-line no-restricted-syntax
 var ValueTransitionParametersTypes;
 (function (ValueTransitionParametersTypes) {
     ValueTransitionParametersTypes[ValueTransitionParametersTypes["TRANSITION_ID"] = 1] = "TRANSITION_ID";
     ValueTransitionParametersTypes[ValueTransitionParametersTypes["START_TIME"] = 2] = "START_TIME";
     ValueTransitionParametersTypes[ValueTransitionParametersTypes["UNKNOWN_3"] = 3] = "UNKNOWN_3";
 })(ValueTransitionParametersTypes || (ValueTransitionParametersTypes = {}));
-// eslint-disable-next-line no-restricted-syntax
 var TransitionCurveConfigurationTypes;
 (function (TransitionCurveConfigurationTypes) {
     TransitionCurveConfigurationTypes[TransitionCurveConfigurationTypes["TRANSITION_ENTRY"] = 1] = "TRANSITION_ENTRY";
     TransitionCurveConfigurationTypes[TransitionCurveConfigurationTypes["ADJUSTMENT_CHARACTERISTIC_IID"] = 2] = "ADJUSTMENT_CHARACTERISTIC_IID";
     TransitionCurveConfigurationTypes[TransitionCurveConfigurationTypes["ADJUSTMENT_MULTIPLIER_RANGE"] = 3] = "ADJUSTMENT_MULTIPLIER_RANGE";
 })(TransitionCurveConfigurationTypes || (TransitionCurveConfigurationTypes = {}));
-// eslint-disable-next-line no-restricted-syntax
 var TransitionEntryTypes;
 (function (TransitionEntryTypes) {
     TransitionEntryTypes[TransitionEntryTypes["ADJUSTMENT_FACTOR"] = 1] = "ADJUSTMENT_FACTOR";
@@ -76,33 +70,30 @@ var TransitionEntryTypes;
     TransitionEntryTypes[TransitionEntryTypes["TRANSITION_OFFSET"] = 3] = "TRANSITION_OFFSET";
     TransitionEntryTypes[TransitionEntryTypes["DURATION"] = 4] = "DURATION";
 })(TransitionEntryTypes || (TransitionEntryTypes = {}));
-// eslint-disable-next-line no-restricted-syntax
 var TransitionAdjustmentMultiplierRange;
 (function (TransitionAdjustmentMultiplierRange) {
     TransitionAdjustmentMultiplierRange[TransitionAdjustmentMultiplierRange["MINIMUM_ADJUSTMENT_MULTIPLIER"] = 1] = "MINIMUM_ADJUSTMENT_MULTIPLIER";
     TransitionAdjustmentMultiplierRange[TransitionAdjustmentMultiplierRange["MAXIMUM_ADJUSTMENT_MULTIPLIER"] = 2] = "MAXIMUM_ADJUSTMENT_MULTIPLIER";
 })(TransitionAdjustmentMultiplierRange || (TransitionAdjustmentMultiplierRange = {}));
-// eslint-disable-next-line no-restricted-syntax
 var ValueTransitionConfigurationResponseTypes;
 (function (ValueTransitionConfigurationResponseTypes) {
     ValueTransitionConfigurationResponseTypes[ValueTransitionConfigurationResponseTypes["VALUE_CONFIGURATION_STATUS"] = 1] = "VALUE_CONFIGURATION_STATUS";
 })(ValueTransitionConfigurationResponseTypes || (ValueTransitionConfigurationResponseTypes = {}));
-// eslint-disable-next-line no-restricted-syntax
 var ValueTransitionConfigurationStatusTypes;
 (function (ValueTransitionConfigurationStatusTypes) {
     ValueTransitionConfigurationStatusTypes[ValueTransitionConfigurationStatusTypes["CHARACTERISTIC_IID"] = 1] = "CHARACTERISTIC_IID";
     ValueTransitionConfigurationStatusTypes[ValueTransitionConfigurationStatusTypes["TRANSITION_PARAMETERS"] = 2] = "TRANSITION_PARAMETERS";
     ValueTransitionConfigurationStatusTypes[ValueTransitionConfigurationStatusTypes["TIME_SINCE_START"] = 3] = "TIME_SINCE_START";
 })(ValueTransitionConfigurationStatusTypes || (ValueTransitionConfigurationStatusTypes = {}));
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
 function isAdaptiveLightingContext(context) {
-    return context && 'controller' in context;
+    return context && "controller" in context;
 }
 /**
  * Defines in which mode the {@link AdaptiveLightingController} will operate in.
  * @group Adaptive Lighting
  */
-// eslint-disable-next-line no-restricted-syntax
-export var AdaptiveLightingControllerMode;
+var AdaptiveLightingControllerMode;
 (function (AdaptiveLightingControllerMode) {
     /**
      * In automatic mode pretty much everything from setup to transition scheduling is done by the controller.
@@ -113,12 +104,11 @@ export var AdaptiveLightingControllerMode;
      * This is useful for lights which natively support transitions.
      */
     AdaptiveLightingControllerMode[AdaptiveLightingControllerMode["MANUAL"] = 2] = "MANUAL";
-})(AdaptiveLightingControllerMode || (AdaptiveLightingControllerMode = {}));
+})(AdaptiveLightingControllerMode || (exports.AdaptiveLightingControllerMode = AdaptiveLightingControllerMode = {}));
 /**
  * @group Adaptive Lighting
  */
-// eslint-disable-next-line no-restricted-syntax
-export var AdaptiveLightingControllerEvents;
+var AdaptiveLightingControllerEvents;
 (function (AdaptiveLightingControllerEvents) {
     /**
      * This event is called once a HomeKit controller enables Adaptive Lighting
@@ -132,7 +122,7 @@ export var AdaptiveLightingControllerEvents;
      * The current transition will still be associated with the controller object when this event is called.
      */
     AdaptiveLightingControllerEvents["DISABLED"] = "disable";
-})(AdaptiveLightingControllerEvents || (AdaptiveLightingControllerEvents = {}));
+})(AdaptiveLightingControllerEvents || (exports.AdaptiveLightingControllerEvents = AdaptiveLightingControllerEvents = {}));
 /**
  * This class allows adding Adaptive Lighting support to Lightbulb services.
  * The Lightbulb service MUST have the {@link Characteristic.ColorTemperature} characteristic AND
@@ -146,7 +136,7 @@ export var AdaptiveLightingControllerEvents;
  *  (updating the schedule according to your current day/night situation).
  *  Once enabled the lightbulb will execute the provided transitions. The color temperature value set is always
  *  dependent on the current brightness value. Meaning brighter light will be colder and darker light will be warmer.
- *  HomeKit considers Adaptive Lighting to be disabled as soon a 'write' happens to either the
+ *  HomeKit considers Adaptive Lighting to be disabled as soon a write happens to either the
  *  Hue/Saturation or the ColorTemperature characteristics.
  *  The AdaptiveLighting state must persist across reboots.
  *
@@ -163,10 +153,10 @@ export var AdaptiveLightingControllerEvents;
  *
  * <b>AUTOMATIC (Default mode):</b>
  *
- *  This is the easiest mode to set up and needs less to no work form your side for AdaptiveLighting to work.
+ *  This is the easiest mode to setup and needs less to no work form your side for AdaptiveLighting to work.
  *  The AdaptiveLightingController will go through setup procedure with HomeKit and automatically update
  *  the color temperature characteristic base on the current transition schedule.
- *  It is also adjusting the color temperature when a 'write' to the brightness characteristic happens.
+ *  It is also adjusting the color temperature when a write to the brightness characteristic happens.
  *  Additionally, it will also handle turning off AdaptiveLighting, when it detects a write happening to the
  *  ColorTemperature, Hue or Saturation characteristic (though it can only detect writes coming from HomeKit and
  *  can't detect changes done to the physical devices directly! See below).
@@ -188,12 +178,12 @@ export var AdaptiveLightingControllerEvents;
  *   - When using Hue/Saturation:
  *    When using Hue/Saturation in combination with the ColorTemperature characteristic you need to update the
  *    respective other in a particular way depending on if being in "color mode" or "color temperature mode".
- *    When a 'write' happens to Hue/Saturation characteristic in is advised to set the internal value of the
+ *    When a write happens to Hue/Saturation characteristic in is advised to set the internal value of the
  *    ColorTemperature to the minimal (NOT RAISING an event).
- *    When a 'write' happens to the ColorTemperature characteristic just MUST convert to a proper representation
+ *    When a write happens to the ColorTemperature characteristic just MUST convert to a proper representation
  *    in hue and saturation values, with RAISING an event.
  *    As noted above you MUST NOT call the {@link Characteristic.setValue} method for this, as this will be considered
- *    a 'write' to the characteristic and will turn off AdaptiveLighting. Instead, you should use
+ *    a write to the characteristic and will turn off AdaptiveLighting. Instead, you should use
  *    {@link Characteristic.updateValue} for this.
  *    You can and SHOULD use the supplied utility method {@link ColorUtils.colorTemperatureToHueAndSaturation}
  *    for converting mired to hue and saturation values.
@@ -211,7 +201,7 @@ export var AdaptiveLightingControllerEvents;
  *  are only sent in the defined interval threshold, adjust the color temperature when brightness is changed
  *  and signal that Adaptive Lighting should be disabled if ColorTemperature, Hue or Saturation is changed manually.
  *
- *  First step is to set up an event handler for the {@link AdaptiveLightingControllerEvents.UPDATE}, which is called
+ *  First step is to setup up an event handler for the {@link AdaptiveLightingControllerEvents.UPDATE}, which is called
  *  when AdaptiveLighting is enabled, the HomeHub updates the schedule for the next 24 hours or AdaptiveLighting
  *  is restored from disk on startup.
  *  In the event handler you can get the current schedule via {@link AdaptiveLightingController.getAdaptiveLightingTransitionCurve},
@@ -225,14 +215,14 @@ export var AdaptiveLightingControllerEvents;
  *  the color temperature when the brightness of the lightbulb changes (see {@link AdaptiveLightingTransitionCurveEntry.brightnessAdjustmentFactor}),
  *  and signal when AdaptiveLighting got disabled by calling {@link AdaptiveLightingController.disableAdaptiveLighting}
  *  when ColorTemperature, Hue or Saturation where changed manually.
- *  Lastly you should set up an event handler for the {@link AdaptiveLightingControllerEvents.DISABLED} event.
+ *  Lastly you should set up a event handler for the {@link AdaptiveLightingControllerEvents.DISABLED} event.
  *  In yet unknown circumstances HomeKit may also send a dedicated disable command via the control point characteristic.
  *  Be prepared to handle that.
  *
  *  @group Adaptive Lighting
  */
-// eslint-disable-next-line ts/no-unsafe-declaration-merging
-export class AdaptiveLightingController extends EventEmitter {
+// eslint-disable-next-line @typescript-eslint/no-unsafe-declaration-merging
+class AdaptiveLightingController extends events_1.EventEmitter {
     stateChangeDelegate;
     lightbulb;
     mode;
@@ -266,8 +256,8 @@ export class AdaptiveLightingController extends EventEmitter {
         this.lightbulb = service;
         this.mode = options?.controllerMode ?? 1 /* AdaptiveLightingControllerMode.AUTOMATIC */;
         this.customTemperatureAdjustment = options?.customTemperatureAdjustment ?? 0;
-        assert(this.lightbulb.testCharacteristic(Characteristic.ColorTemperature), 'Lightbulb must have the ColorTemperature characteristic added!');
-        assert(this.lightbulb.testCharacteristic(Characteristic.Brightness), 'Lightbulb must have the Brightness characteristic added!');
+        (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);
     }
@@ -275,11 +265,11 @@ export class AdaptiveLightingController extends EventEmitter {
      * @private
      */
     controllerId() {
-        return `${"characteristic-transition" /* DefaultControllerType.CHARACTERISTIC_TRANSITION */}-${this.lightbulb.getServiceId()}`;
+        return "characteristic-transition" /* DefaultControllerType.CHARACTERISTIC_TRANSITION */ + "-" + this.lightbulb.getServiceId();
     }
     // ----------- PUBLIC API START -----------
     /**
-     * Returns if an Adaptive Lighting transition is currently active.
+     * Returns if a Adaptive Lighting transition is currently active.
      */
     isAdaptiveLightingActive() {
         return !!this.activeTransition;
@@ -315,68 +305,68 @@ export class AdaptiveLightingController extends EventEmitter {
         this.lastNotifiedHueValue = 0;
         this.didRunFirstInitializationStep = false;
         this.activeTransitionCount?.sendEventNotification(0);
-        debug('[%s] Disabling adaptive lighting', this.lightbulb.displayName);
+        debug("[%s] Disabling adaptive lighting", this.lightbulb.displayName);
     }
     /**
-     * Returns the time when the current transition curve was started in epoch time millis.
+     * 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}.
+     * Additionally see {@link getAdaptiveLightingTimeOffset}.
      */
     getAdaptiveLightingStartTimeOfTransition() {
         if (!this.activeTransition) {
-            throw new Error('There is no active transition!');
+            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.
-     * Thus, we record the delta between our current time and the time send with the setup request.
+     * Thus we record the delta between our current time and the the time send with the setup request.
      * <code>timeOffset</code> is defined as <code>Date.now() - getAdaptiveLightingStartTimeOfTransition();</code>.
      * 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() {
         if (!this.activeTransition) {
-            throw new Error('There is no active transition!');
+            throw new Error("There is no active transition!");
         }
         return this.activeTransition.timeMillisOffset;
     }
     getAdaptiveLightingTransitionCurve() {
         if (!this.activeTransition) {
-            throw new Error('There is no active transition!');
+            throw new Error("There is no active transition!");
         }
         return this.activeTransition.transitionCurve;
     }
     getAdaptiveLightingBrightnessMultiplierRange() {
         if (!this.activeTransition) {
-            throw new Error('There is no active transition!');
+            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).
-     * A lightbulb should ideally change this also when turned off in oder to have a smooth transition when turning the light on.
+     * A lightbulb should ideally change this also when turned of in oder to have a smooth transition when turning the light on.
      *
-     * Typically, this evaluates to 60000 milliseconds (60 seconds).
+     * Typically this evaluates to 60000 milliseconds (60 seconds).
      */
     getAdaptiveLightingUpdateInterval() {
         if (!this.activeTransition) {
-            throw new Error('There is no active transition!');
+            throw new Error("There is no active transition!");
         }
         return this.activeTransition.updateInterval;
     }
     /**
-     * Returns the minimum interval threshold (in milliseconds) an accessory may notify HomeKit controllers about a new
+     * 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}).
      * Meaning the accessory should only send event notifications to subscribed HomeKit controllers at the specified interval.
      *
-     * Typically, this evaluates to 600000 milliseconds (10 minutes).
+     * Typically this evaluates to 600000 milliseconds (10 minutes).
      */
     getAdaptiveLightingNotifyIntervalThreshold() {
         if (!this.activeTransition) {
-            throw new Error('There is no active transition!');
+            throw new Error("There is no active transition!");
         }
         return this.activeTransition.notifyIntervalThreshold;
     }
@@ -395,7 +385,7 @@ export class AdaptiveLightingController extends EventEmitter {
         }
         else if (this.mode === 2 /* AdaptiveLightingControllerMode.MANUAL */) {
             if (!this.activeTransition) {
-                throw new Error('There is no active transition!');
+                throw new Error("There is no active transition!");
             }
             const update = {
                 transitionStartMillis: this.activeTransition.transitionStartMillis,
@@ -408,7 +398,7 @@ export class AdaptiveLightingController extends EventEmitter {
             this.emit("update" /* AdaptiveLightingControllerEvents.UPDATE */, update);
         }
         else {
-            throw new Error(`Unsupported adaptive lighting controller mode: ${this.mode}`);
+            throw new Error("Unsupported adaptive lighting controller mode: " + this.mode);
         }
         if (!calledFromDeserializer) {
             this.stateChangeDelegate?.();
@@ -416,18 +406,18 @@ export class AdaptiveLightingController extends EventEmitter {
     }
     handleAdaptiveLightingEnabled() {
         if (!this.activeTransition) {
-            throw new Error('There is no active transition!');
+            throw new Error("There is no active transition!");
         }
-        this.colorTemperatureCharacteristic = this.lightbulb.getCharacteristic(Characteristic.ColorTemperature);
-        this.brightnessCharacteristic = this.lightbulb.getCharacteristic(Characteristic.Brightness);
+        this.colorTemperatureCharacteristic = this.lightbulb.getCharacteristic(Characteristic_1.Characteristic.ColorTemperature);
+        this.brightnessCharacteristic = this.lightbulb.getCharacteristic(Characteristic_1.Characteristic.Brightness);
         this.colorTemperatureCharacteristic.on("change" /* CharacteristicEventTypes.CHANGE */, this.characteristicManualWrittenChangeListener);
         this.brightnessCharacteristic.on("change" /* CharacteristicEventTypes.CHANGE */, this.adjustmentFactorChangedListener);
-        if (this.lightbulb.testCharacteristic(Characteristic.Hue)) {
-            this.hueCharacteristic = this.lightbulb.getCharacteristic(Characteristic.Hue)
+        if (this.lightbulb.testCharacteristic(Characteristic_1.Characteristic.Hue)) {
+            this.hueCharacteristic = this.lightbulb.getCharacteristic(Characteristic_1.Characteristic.Hue)
                 .on("change" /* CharacteristicEventTypes.CHANGE */, this.characteristicManualWrittenChangeListener);
         }
-        if (this.lightbulb.testCharacteristic(Characteristic.Saturation)) {
-            this.saturationCharacteristic = this.lightbulb.getCharacteristic(Characteristic.Saturation)
+        if (this.lightbulb.testCharacteristic(Characteristic_1.Characteristic.Saturation)) {
+            this.saturationCharacteristic = this.lightbulb.getCharacteristic(Characteristic_1.Characteristic.Saturation)
                 .on("change" /* CharacteristicEventTypes.CHANGE */, this.characteristicManualWrittenChangeListener);
         }
     }
@@ -444,8 +434,8 @@ export class AdaptiveLightingController extends EventEmitter {
         // consider the following scenario:
         // a HomeKit controller queries the light (meaning e.g. Brightness, Hue and Saturation characteristics).
         // As of the implementation of the light the brightness characteristic get handler returns first
-        // (and returns a value different from the cached value).
-        // This change handler gets called, and we will update the color temperature accordingly
+        // (and returns a value different than the cached value).
+        // This change handler gets called and we will update the color temperature accordingly
         // (which also adjusts the internal cached values for Hue and Saturation).
         // After some short time the Hue or Saturation get handler return with the last known value to the plugin.
         // As those values now differ from the cached values (we already updated) we get a call to handleCharacteristicManualWritten
@@ -456,7 +446,7 @@ export class AdaptiveLightingController extends EventEmitter {
             // 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) {
-                    return; // was disabled in the meantime
+                    return; // was disabled in the mean time
                 }
                 this.scheduleNextUpdate(true);
             }, 1000).unref();
@@ -467,7 +457,7 @@ export class AdaptiveLightingController extends EventEmitter {
     }
     /**
      * 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.
+     * When such a write happens (caused by the user changing the color/temperature) Adaptive Lighting must be disabled.
      *
      * @param change
      */
@@ -476,7 +466,7 @@ export class AdaptiveLightingController extends EventEmitter {
             // 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
             // or the change was done by the controller itself
-            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);
+            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();
         }
     }
@@ -486,7 +476,7 @@ export class AdaptiveLightingController extends EventEmitter {
      */
     getCurrentAdaptiveLightingTransitionPoint() {
         if (!this.activeTransition) {
-            throw new Error('Cannot calculate current transition point if no transition is active!');
+            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;
@@ -494,8 +484,8 @@ export class AdaptiveLightingController extends EventEmitter {
         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;
-        let upperBound;
+        let lowerBound = undefined;
+        let upperBound = undefined;
         for (; i + 1 < this.activeTransition.transitionCurve.length; i++) {
             const lowerBound0 = this.activeTransition.transitionCurve[i];
             const upperBound0 = this.activeTransition.transitionCurve[i + 1];
@@ -511,7 +501,7 @@ export class AdaptiveLightingController extends EventEmitter {
             else if (this.lastTransitionPointInfo) {
                 // if we reached here the entry in the transitionCurve we are searching for is somewhere before current i.
                 // This can only happen when we have a faulty lastTransitionPointInfo (otherwise we would start from i=0).
-                // Thus, we try again by searching from i=0
+                // Thus we try again by searching from i=0
                 this.lastTransitionPointInfo = undefined;
                 return this.getCurrentAdaptiveLightingTransitionPoint();
             }
@@ -525,19 +515,19 @@ export class AdaptiveLightingController extends EventEmitter {
             curveIndex: i,
             // we need to subtract lowerBound.transitionTime. When we start the loop above
             // with a saved transition point, we will always add lowerBound.transitionTime as first step.
-            // Otherwise, our calculations are simply wrong.
+            // Otherwise our calculations are simply wrong.
             lowerBoundTimeOffset: lowerBoundTimeOffset - lowerBound.transitionTime,
         };
         return {
-            lowerBoundTimeOffset,
+            lowerBoundTimeOffset: lowerBoundTimeOffset,
             transitionOffset: offset - lowerBoundTimeOffset,
-            lowerBound,
-            upperBound,
+            lowerBound: lowerBound,
+            upperBound: upperBound,
         };
     }
     scheduleNextUpdate(dryRun = false) {
         if (!this.activeTransition) {
-            throw new Error('tried scheduling transition when no transition was active!');
+            throw new Error("tried scheduling transition when no transition was active!");
         }
         if (!dryRun) {
             this.updateTimeout = undefined;
@@ -548,7 +538,7 @@ export class AdaptiveLightingController extends EventEmitter {
         }
         const transitionPoint = this.getCurrentAdaptiveLightingTransitionPoint();
         if (!transitionPoint) {
-            debug('[%s] Reached end of transition curve!', this.lightbulb.displayName);
+            debug("[%s] Reached end of transition curve!", this.lightbulb.displayName);
             if (!dryRun) {
                 // the transition schedule is only for 24 hours, we reached the end?
                 this.disableAdaptiveLighting();
@@ -576,8 +566,8 @@ export class AdaptiveLightingController extends EventEmitter {
         const min = this.colorTemperatureCharacteristic?.props.minValue ?? 140;
         const max = this.colorTemperatureCharacteristic?.props.maxValue ?? 500;
         temperature = Math.max(min, Math.min(max, temperature));
-        const color = ColorUtils.colorTemperatureToHueAndSaturation(temperature);
-        debug('[%s] Next temperature value is %d (for brightness %d adj: %s)', this.lightbulb.displayName, temperature, adjustmentMultiplier, this.customTemperatureAdjustment);
+        const 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 = {
             controller: this,
             omitEventUpdate: true,
@@ -585,8 +575,8 @@ export class AdaptiveLightingController extends EventEmitter {
         /*
          * We set saturation and hue values BEFORE we call the ColorTemperature SET handler (via setValue).
          * First thought was so the API user could get the values in the SET handler of the color temperature characteristic.
-         * Do this is probably not really elegant because this would only work when Adaptive Lighting is turned on
-         * and the accessory MUST in any case update the Hue/Saturation values on a ColorTemperature write
+         * Do this is probably not really elegant cause this would only work when Adaptive Lighting is turned on
+         * an the accessory MUST in any case update the Hue/Saturation values on a ColorTemperature write
          * (obviously only if Hue/Saturation characteristics are added to the service).
          *
          * The clever thing about this though is that, that it prevents notifications from being sent for Hue and Saturation
@@ -603,18 +593,18 @@ export class AdaptiveLightingController extends 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(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 `
-                + `the SET handler of the ColorTemperature characteristic! `
-                + `Please check that you don't call setValue/setCharacteristic on the Hue, Saturation or ColorTemperature characteristic!`);
+            console.warn("[" + this.lightbulb.displayName + "] Adaptive Lighting was probably disable my mistake by some call in " +
+                "the SET handler of the ColorTemperature characteristic! " +
+                "Please check that you don't call setValue/setCharacteristic on the Hue, Saturation or ColorTemperature characteristic!");
             return;
         }
         const now = Date.now();
         if (!dryRun && now - this.lastEventNotificationSent >= this.activeTransition.notifyIntervalThreshold) {
-            debug('[%s] Sending event notifications for current transition!', this.lightbulb.displayName);
+            debug("[%s] Sending event notifications for current transition!", this.lightbulb.displayName);
             this.lastEventNotificationSent = now;
             const eventContext = {
                 controller: this,
@@ -645,7 +635,7 @@ export class AdaptiveLightingController extends EventEmitter {
     /**
      * @private
      */
-    // eslint-disable-next-line unused-imports/no-unused-vars
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
     initWithServices(serviceMap) {
         // do nothing
     }
@@ -653,26 +643,26 @@ export class AdaptiveLightingController extends EventEmitter {
      * @private
      */
     configureServices() {
-        this.supportedTransitionConfiguration = this.lightbulb.getCharacteristic(Characteristic.SupportedCharacteristicValueTransitionConfiguration);
-        this.transitionControl = this.lightbulb.getCharacteristic(Characteristic.CharacteristicValueTransitionControl)
-            .updateValue('');
-        this.activeTransitionCount = this.lightbulb.getCharacteristic(Characteristic.CharacteristicValueActiveTransitionCount)
+        this.supportedTransitionConfiguration = this.lightbulb.getCharacteristic(Characteristic_1.Characteristic.SupportedCharacteristicValueTransitionConfiguration);
+        this.transitionControl = this.lightbulb.getCharacteristic(Characteristic_1.Characteristic.CharacteristicValueTransitionControl)
+            .updateValue("");
+        this.activeTransitionCount = this.lightbulb.getCharacteristic(Characteristic_1.Characteristic.CharacteristicValueActiveTransitionCount)
             .updateValue(0);
         this.supportedTransitionConfiguration
             .onGet(this.handleSupportedTransitionConfigurationRead.bind(this));
         this.transitionControl
             .onGet(() => {
-            return this.buildTransitionControlResponseBuffer().toString('base64');
+            return this.buildTransitionControlResponseBuffer().toString("base64");
         })
-            .onSet((value) => {
+            .onSet(value => {
             try {
                 return this.handleTransitionControlWrite(value);
             }
             catch (error) {
                 console.warn(`[%s] DEBUG: '${value}'`);
-                console.warn(`[%s] Encountered error on CharacteristicValueTransitionControl characteristic: ${error.stack}`);
+                console.warn("[%s] Encountered error on CharacteristicValueTransitionControl characteristic: " + error.stack);
                 this.disableAdaptiveLighting();
-                throw new HapStatusError(-70402 /* HAPStatus.SERVICE_COMMUNICATION_FAILURE */);
+                throw new hapStatusError_1.HapStatusError(-70402 /* HAPStatus.SERVICE_COMMUNICATION_FAILURE */);
             }
         });
     }
@@ -712,9 +702,9 @@ export class AdaptiveLightingController extends EventEmitter {
         this.activeTransition = serialized.activeTransition;
         // Data migrations from beta builds
         if (!this.activeTransition.transitionId) {
-            // @ts-expect-error - data migration from beta builds
+            // @ts-expect-error: data migration from beta builds
             this.activeTransition.transitionId = this.activeTransition.id1;
-            // @ts-expect-error - data migration from beta builds
+            // @ts-expect-error: data migration from beta builds
             delete this.activeTransition.id1;
         }
         if (!this.activeTransition.timeMillisOffset) { // compatibility to data produced by early betas
@@ -729,14 +719,14 @@ export class AdaptiveLightingController extends EventEmitter {
         this.stateChangeDelegate = delegate;
     }
     handleSupportedTransitionConfigurationRead() {
-        const brightnessIID = this.lightbulb?.getCharacteristic(Characteristic.Brightness).iid;
-        const temperatureIID = this.lightbulb?.getCharacteristic(Characteristic.ColorTemperature).iid;
-        assert(brightnessIID, 'iid for brightness characteristic is undefined');
-        assert(temperatureIID, 'iid for temperature characteristic is undefined');
-        return encode(1 /* SupportedCharacteristicValueTransitionConfigurationsTypes.SUPPORTED_TRANSITION_CONFIGURATION */, [
-            encode(1 /* SupportedValueTransitionConfigurationTypes.CHARACTERISTIC_IID */, writeVariableUIntLE(brightnessIID), 2 /* SupportedValueTransitionConfigurationTypes.TRANSITION_TYPE */, 1 /* TransitionType.BRIGHTNESS */),
-            encode(1 /* SupportedValueTransitionConfigurationTypes.CHARACTERISTIC_IID */, writeVariableUIntLE(temperatureIID), 2 /* SupportedValueTransitionConfigurationTypes.TRANSITION_TYPE */, 2 /* TransitionType.COLOR_TEMPERATURE */),
-        ]).toString('base64');
+        const brightnessIID = this.lightbulb?.getCharacteristic(Characteristic_1.Characteristic.Brightness).iid;
+        const 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) {
         if (!this.activeTransition) {
@@ -744,22 +734,22 @@ export class AdaptiveLightingController extends EventEmitter {
         }
         const active = this.activeTransition;
         const timeSinceStart = time ?? (Date.now() - active.timeMillisOffset - active.transitionStartMillis);
-        const timeSinceStartBuffer = writeVariableUIntLE(timeSinceStart);
-        let parameters = encode(1 /* ValueTransitionParametersTypes.TRANSITION_ID */, write(active.transitionId), 2 /* ValueTransitionParametersTypes.START_TIME */, Buffer.from(active.transitionStartBuffer, 'hex'));
+        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"));
         if (active.id3) {
             parameters = Buffer.concat([
                 parameters,
-                encode(3 /* ValueTransitionParametersTypes.UNKNOWN_3 */, Buffer.from(active.id3, 'hex')),
+                tlv.encode(3 /* ValueTransitionParametersTypes.UNKNOWN_3 */, Buffer.from(active.id3, "hex")),
             ]);
         }
-        const status = encode(1 /* ValueTransitionConfigurationStatusTypes.CHARACTERISTIC_IID */, writeVariableUIntLE(active.iid), 2 /* ValueTransitionConfigurationStatusTypes.TRANSITION_PARAMETERS */, parameters, 3 /* ValueTransitionConfigurationStatusTypes.TIME_SINCE_START */, timeSinceStartBuffer);
-        return encode(1 /* ValueTransitionConfigurationResponseTypes.VALUE_CONFIGURATION_STATUS */, status);
+        const 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) {
-        if (typeof value !== 'string') {
-            throw new HapStatusError(-70410 /* HAPStatus.INVALID_VALUE_IN_REQUEST */);
+        if (typeof value !== "string") {
+            throw new hapStatusError_1.HapStatusError(-70410 /* HAPStatus.INVALID_VALUE_IN_REQUEST */);
         }
-        const tlvData = decode(Buffer.from(value, 'base64'));
+        const tlvData = tlv.decode(Buffer.from(value, "base64"));
         const responseBuffers = [];
         const readTransition = tlvData[1 /* TransitionControlTypes.READ_CURRENT_VALUE_TRANSITION_CONFIGURATION */];
         if (readTransition) {
@@ -775,62 +765,63 @@ export class AdaptiveLightingController extends EventEmitter {
                 responseBuffers.push(updateTransitionResponse);
             }
         }
-        return Buffer.concat(responseBuffers).toString('base64');
+        return Buffer.concat(responseBuffers).toString("base64");
     }
     handleTransitionControlReadTransition(buffer) {
-        const readTransition = decode(buffer);
-        const iid = readVariableUIntLE(readTransition[1 /* ReadValueTransitionConfiguration.CHARACTERISTIC_IID */]);
+        const readTransition = tlv.decode(buffer);
+        const 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(-70410 /* HAPStatus.INVALID_VALUE_IN_REQUEST */);
+                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 = encode(1 /* ValueTransitionParametersTypes.TRANSITION_ID */, write(this.activeTransition.transitionId), 2 /* ValueTransitionParametersTypes.START_TIME */, Buffer.from(this.activeTransition.transitionStartBuffer, 'hex'));
+            let 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,
-                    encode(3 /* ValueTransitionParametersTypes.UNKNOWN_3 */, Buffer.from(this.activeTransition.id3, 'hex')),
+                    tlv.encode(3 /* ValueTransitionParametersTypes.UNKNOWN_3 */, Buffer.from(this.activeTransition.id3, "hex")),
                 ]);
             }
-            return encode(1 /* TransitionControlTypes.READ_CURRENT_VALUE_TRANSITION_CONFIGURATION */, encode(1 /* ValueTransitionConfigurationTypes.CHARACTERISTIC_IID */, writeVariableUIntLE(this.activeTransition.iid), 2 /* ValueTransitionConfigurationTypes.TRANSITION_PARAMETERS */, parameters, 3 /* ValueTransitionConfigurationTypes.UNKNOWN_3 */, 1, 5 /* ValueTransitionConfigurationTypes.TRANSITION_CURVE_CONFIGURATION */, encode(1 /* TransitionCurveConfigurationTypes.TRANSITION_ENTRY */, this.activeTransition.transitionCurve.map((entry, index, array) => {
+            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 encode(1 /* TransitionEntryTypes.ADJUSTMENT_FACTOR */, writeFloat32LE(entry.brightnessAdjustmentFactor), 2 /* TransitionEntryTypes.VALUE */, writeFloat32LE(entry.temperature), 3 /* TransitionEntryTypes.TRANSITION_OFFSET */, writeVariableUIntLE(entry.transitionTime), 4 /* TransitionEntryTypes.DURATION */, writeVariableUIntLE(duration));
-            }), 2 /* TransitionCurveConfigurationTypes.ADJUSTMENT_CHARACTERISTIC_IID */, writeVariableUIntLE(this.activeTransition.brightnessCharacteristicIID), 3 /* TransitionCurveConfigurationTypes.ADJUSTMENT_MULTIPLIER_RANGE */, encode(1 /* TransitionAdjustmentMultiplierRange.MINIMUM_ADJUSTMENT_MULTIPLIER */, writeUInt32(this.activeTransition.brightnessAdjustmentRange.minBrightnessValue), 2 /* TransitionAdjustmentMultiplierRange.MAXIMUM_ADJUSTMENT_MULTIPLIER */, writeUInt32(this.activeTransition.brightnessAdjustmentRange.maxBrightnessValue))), 6 /* ValueTransitionConfigurationTypes.UPDATE_INTERVAL */, writeVariableUIntLE(this.activeTransition.updateInterval), 8 /* ValueTransitionConfigurationTypes.NOTIFY_INTERVAL_THRESHOLD */, writeVariableUIntLE(this.activeTransition.notifyIntervalThreshold)));
+                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 = decode(buffer);
-        const transitionConfiguration = decode(updateTransition[1 /* UpdateValueTransitionConfigurationsTypes.VALUE_TRANSITION_CONFIGURATION */]);
-        const iid = readVariableUIntLE(transitionConfiguration[1 /* ValueTransitionConfigurationTypes.CHARACTERISTIC_IID */]);
+        const updateTransition = tlv.decode(buffer);
+        const transitionConfiguration = tlv.decode(updateTransition[1 /* UpdateValueTransitionConfigurationsTypes.VALUE_TRANSITION_CONFIGURATION */]);
+        const iid = tlv.readVariableUIntLE(transitionConfiguration[1 /* ValueTransitionConfigurationTypes.CHARACTERISTIC_IID */]);
         if (!this.lightbulb.getCharacteristicByIID(iid)) {
-            throw new HapStatusError(-70410 /* HAPStatus.INVALID_VALUE_IN_REQUEST */);
+            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
         if (!param3) { // if HomeKit just sends the iid, we consider that as "disable adaptive lighting" (assumption)
             this.handleAdaptiveLightingDisabled();
-            return encode(2 /* TransitionControlTypes.UPDATE_VALUE_TRANSITION_CONFIGURATION */, Buffer.alloc(0));
+            return tlv.encode(2 /* TransitionControlTypes.UPDATE_VALUE_TRANSITION_CONFIGURATION */, Buffer.alloc(0));
         }
-        const parametersTLV = decode(transitionConfiguration[2 /* ValueTransitionConfigurationTypes.TRANSITION_PARAMETERS */]);
-        const curveConfiguration = decodeWithLists(transitionConfiguration[5 /* ValueTransitionConfigurationTypes.TRANSITION_CURVE_CONFIGURATION */]);
+        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 = epochMillisFromMillisSince2001_01_01Buffer(startTime);
+        const startTimeMillis = (0, time_1.epochMillisFromMillisSince2001_01_01Buffer)(startTime);
         const timeMillisOffset = Date.now() - startTimeMillis;
         const transitionCurve = [];
-        let previous;
+        let previous = undefined;
         const transitions = curveConfiguration[1 /* TransitionCurveConfigurationTypes.TRANSITION_ENTRY */];
         for (const entry of transitions) {
-            const tlvEntry = decode(entry);
+            const tlvEntry = tlv.decode(entry);
             const adjustmentFactor = tlvEntry[1 /* TransitionEntryTypes.ADJUSTMENT_FACTOR */].readFloatLE(0);
             const value = tlvEntry[2 /* TransitionEntryTypes.VALUE */].readFloatLE(0);
-            const transitionOffset = readVariableUIntLE(tlvEntry[3 /* TransitionEntryTypes.TRANSITION_OFFSET */]);
-            const duration = tlvEntry[4 /* TransitionEntryTypes.DURATION */] ? readVariableUIntLE(tlvEntry[4 /* TransitionEntryTypes.DURATION */]) : undefined;
+            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;
             }
@@ -841,36 +832,37 @@ export class AdaptiveLightingController extends EventEmitter {
             };
             transitionCurve.push(previous);
         }
-        const adjustmentIID = readVariableUIntLE(curveConfiguration[2 /* TransitionCurveConfigurationTypes.ADJUSTMENT_CHARACTERISTIC_IID */]);
-        const adjustmentMultiplierRange = decode(curveConfiguration[3 /* TransitionCurveConfigurationTypes.ADJUSTMENT_MULTIPLIER_RANGE */]);
+        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);
         this.activeTransition = {
-            iid,
+            iid: iid,
             transitionStartMillis: startTimeMillis,
-            timeMillisOffset,
-            transitionId: unparse(transitionId),
-            transitionStartBuffer: startTime.toString('hex'),
-            id3: id3?.toString('hex'),
+            timeMillisOffset: timeMillisOffset,
+            transitionId: uuid.unparse(transitionId),
+            transitionStartBuffer: startTime.toString("hex"),
+            id3: id3?.toString("hex"),
             brightnessCharacteristicIID: adjustmentIID,
             brightnessAdjustmentRange: {
                 minBrightnessValue: minAdjustmentMultiplier,
                 maxBrightnessValue: maxAdjustmentMultiplier,
             },
-            transitionCurve,
+            transitionCurve: transitionCurve,
             updateInterval: updateInterval ?? 60000,
-            notifyIntervalThreshold,
+            notifyIntervalThreshold: notifyIntervalThreshold,
         };
         if (this.updateTimeout) {
             clearTimeout(this.updateTimeout);
             this.updateTimeout = undefined;
-            debug('[%s] Adaptive lighting was renewed.', this.lightbulb.displayName);
+            debug("[%s] Adaptive lighting was renewed.", this.lightbulb.displayName);
         }
         else {
-            debug('[%s] Adaptive lighting was enabled.', this.lightbulb.displayName);
+            debug("[%s] Adaptive lighting was enabled.", this.lightbulb.displayName);
         }
         this.handleActiveTransitionUpdated();
-        return encode(2 /* TransitionControlTypes.UPDATE_VALUE_TRANSITION_CONFIGURATION */, this.buildTransitionControlResponseBuffer(0));
+        return tlv.encode(2 /* TransitionControlTypes.UPDATE_VALUE_TRANSITION_CONFIGURATION */, this.buildTransitionControlResponseBuffer(0));
     }
 }
+exports.AdaptiveLightingController = AdaptiveLightingController;
 //# sourceMappingURL=AdaptiveLightingController.js.map