hap-nodejs 1.0.0-alpha.23 → 1.0.0-alpha.24

package/dist/lib/Characteristic.js

@@ -1,18 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Characteristic = exports.CharacteristicEventTypes = exports.ChangeReason = exports.Access = exports.Perms = exports.Units = exports.Formats = void 0;
-var tslib_1 = require("tslib");
-var assert_1 = tslib_1.__importDefault(require("assert"));
-var debug_1 = tslib_1.__importDefault(require("debug"));
-var events_1 = require("events");
-var HAPServer_1 = require("./HAPServer");
-var clone_1 = require("./util/clone");
-var hapStatusError_1 = require("./util/hapStatusError");
-var once_1 = require("./util/once");
-var request_util_1 = require("./util/request-util");
-var uuid_1 = require("./util/uuid");
-var checkName_1 = require("./util/checkName");
-var debug = (0, debug_1.default)("HAP-NodeJS:Characteristic");
+const tslib_1 = require("tslib");
+const assert_1 = tslib_1.__importDefault(require("assert"));
+const debug_1 = tslib_1.__importDefault(require("debug"));
+const events_1 = require("events");
+const HAPServer_1 = require("./HAPServer");
+const clone_1 = require("./util/clone");
+const hapStatusError_1 = require("./util/hapStatusError");
+const once_1 = require("./util/once");
+const request_util_1 = require("./util/request-util");
+const uuid_1 = require("./util/uuid");
+const checkName_1 = require("./util/checkName");
+const debug = (0, debug_1.default)("HAP-NodeJS:Characteristic");
 /**
  * @group Characteristic
  */
@@ -182,88 +182,50 @@ var CharacteristicEventTypes;
 /**
  * @group Characteristic
  */
-var ValidValuesIterable = /** @class */ (function () {
-    function ValidValuesIterable(props) {
+class ValidValuesIterable {
+    props;
+    constructor(props) {
         (0, assert_1.default)((0, request_util_1.isNumericFormat)(props.format), "Cannot instantiate valid values iterable when format is not numeric. Found " + props.format);
         this.props = props;
     }
-    ValidValuesIterable.prototype[Symbol.iterator] = function () {
-        var _a, _b, value, e_1_1, min, max, stepValue, i;
-        var e_1, _c;
-        return tslib_1.__generator(this, function (_d) {
-            switch (_d.label) {
-                case 0:
-                    if (!this.props.validValues) return [3 /*break*/, 9];
-                    _d.label = 1;
-                case 1:
-                    _d.trys.push([1, 6, 7, 8]);
-                    _a = tslib_1.__values(this.props.validValues), _b = _a.next();
-                    _d.label = 2;
-                case 2:
-                    if (!!_b.done) return [3 /*break*/, 5];
-                    value = _b.value;
-                    return [4 /*yield*/, value];
-                case 3:
-                    _d.sent();
-                    _d.label = 4;
-                case 4:
-                    _b = _a.next();
-                    return [3 /*break*/, 2];
-                case 5: return [3 /*break*/, 8];
-                case 6:
-                    e_1_1 = _d.sent();
-                    e_1 = { error: e_1_1 };
-                    return [3 /*break*/, 8];
-                case 7:
-                    try {
-                        if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
-                    }
-                    finally { if (e_1) throw e_1.error; }
-                    return [7 /*endfinally*/];
-                case 8: return [3 /*break*/, 13];
-                case 9:
-                    min = 0;
-                    max = void 0;
-                    stepValue = 1;
-                    if (this.props.validValueRanges) {
-                        min = this.props.validValueRanges[0];
-                        max = this.props.validValueRanges[1];
-                    }
-                    else if (this.props.minValue != null && this.props.maxValue != null) {
-                        min = this.props.minValue;
-                        max = this.props.maxValue;
-                        if (this.props.minStep != null) {
-                            stepValue = this.props.minStep;
-                        }
-                    }
-                    else if ((0, request_util_1.isUnsignedNumericFormat)(this.props.format)) {
-                        max = (0, request_util_1.numericUpperBound)(this.props.format);
-                    }
-                    else {
-                        throw new Error("Could not find valid iterator strategy for props: " + JSON.stringify(this.props));
-                    }
-                    i = min;
-                    _d.label = 10;
-                case 10:
-                    if (!(i <= max)) return [3 /*break*/, 13];
-                    return [4 /*yield*/, i];
-                case 11:
-                    _d.sent();
-                    _d.label = 12;
-                case 12:
-                    i += stepValue;
-                    return [3 /*break*/, 10];
-                case 13: return [2 /*return*/];
+    *[Symbol.iterator]() {
+        if (this.props.validValues) {
+            for (const value of this.props.validValues) {
+                yield value;
             }
-        });
-    };
-    return ValidValuesIterable;
-}());
-var numberPattern = /^-?\d+$/;
+        }
+        else {
+            let min = 0; // default is zero for all the uint types
+            let max;
+            let stepValue = 1;
+            if (this.props.validValueRanges) {
+                min = this.props.validValueRanges[0];
+                max = this.props.validValueRanges[1];
+            }
+            else if (this.props.minValue != null && this.props.maxValue != null) {
+                min = this.props.minValue;
+                max = this.props.maxValue;
+                if (this.props.minStep != null) {
+                    stepValue = this.props.minStep;
+                }
+            }
+            else if ((0, request_util_1.isUnsignedNumericFormat)(this.props.format)) {
+                max = (0, request_util_1.numericUpperBound)(this.props.format);
+            }
+            else {
+                throw new Error("Could not find valid iterator strategy for props: " + JSON.stringify(this.props));
+            }
+            for (let i = min; i <= max; i += stepValue) {
+                yield i;
+            }
+        }
+    }
+}
+const numberPattern = /^-?\d+$/;
 function extractHAPStatusFromError(error) {
-    var errorValue = -70402 /* HAPStatus.SERVICE_COMMUNICATION_FAILURE */;
+    let errorValue = -70402 /* HAPStatus.SERVICE_COMMUNICATION_FAILURE */;
     if (numberPattern.test(error.message)) {
-        var value = parseInt(error.message, 10);
+        const value = parseInt(error.message, 10);
         if ((0, HAPServer_1.IsKnownHAPStatusError)(value)) {
             errorValue = value;
         }
@@ -305,30 +267,1028 @@ function minWithUndefined(a, b) {
  * @group Characteristic
  */
 // eslint-disable-next-line @typescript-eslint/no-unsafe-declaration-merging
-var Characteristic = /** @class */ (function (_super) {
-    tslib_1.__extends(Characteristic, _super);
-    function Characteristic(displayName, UUID, props) {
-        var _this = _super.call(this) || this;
-        _this.iid = null;
-        _this.value = null;
-        /**
-         * @deprecated replaced by {@link statusCode}
-         * @private
-         */
-        _this.status = null;
-        /**
-         * @private
-         */
-        _this.statusCode = 0 /* HAPStatus.SUCCESS */;
-        _this.subscriptions = 0;
-        _this.displayName = displayName;
-        _this.UUID = UUID;
-        _this.props = {
+class Characteristic extends events_1.EventEmitter {
+    /**
+     * @deprecated Please use the Formats const enum above.
+     */
+    // @ts-expect-error: forceConsistentCasingInFileNames compiler option
+    static Formats = Formats;
+    /**
+     * @deprecated Please use the Units const enum above.
+     */
+    // @ts-expect-error: forceConsistentCasingInFileNames compiler option
+    static Units = Units;
+    /**
+     * @deprecated Please use the Perms const enum above.
+     */
+    // @ts-expect-error: forceConsistentCasingInFileNames compiler option
+    static Perms = Perms;
+    // Pattern below is for automatic detection of the section of defined characteristics. Used by the generator
+    // -=-=-=-=-=-=-=-=-=-=-=-=-=-=-
+    /**
+     * @group Characteristic Definitions
+     */
+    static AccessCodeControlPoint;
+    /**
+     * @group Characteristic Definitions
+     */
+    static AccessCodeSupportedConfiguration;
+    /**
+     * @group Characteristic Definitions
+     */
+    static AccessControlLevel;
+    /**
+     * @group Characteristic Definitions
+     */
+    static AccessoryFlags;
+    /**
+     * @group Characteristic Definitions
+     */
+    static AccessoryIdentifier;
+    /**
+     * @group Characteristic Definitions
+     */
+    static Active;
+    /**
+     * @group Characteristic Definitions
+     */
+    static ActiveIdentifier;
+    /**
+     * @group Characteristic Definitions
+     */
+    static ActivityInterval;
+    /**
+     * @group Characteristic Definitions
+     */
+    static AdministratorOnlyAccess;
+    /**
+     * @group Characteristic Definitions
+     */
+    static AirParticulateDensity;
+    /**
+     * @group Characteristic Definitions
+     */
+    static AirParticulateSize;
+    /**
+     * @group Characteristic Definitions
+     */
+    static AirPlayEnable;
+    /**
+     * @group Characteristic Definitions
+     */
+    static AirQuality;
+    /**
+     * @group Characteristic Definitions
+     */
+    static AppMatchingIdentifier;
+    /**
+     * @group Characteristic Definitions
+     */
+    static AssetUpdateReadiness;
+    /**
+     * @group Characteristic Definitions
+     */
+    static AudioFeedback;
+    /**
+     * @group Characteristic Definitions
+     */
+    static BatteryLevel;
+    /**
+     * @group Characteristic Definitions
+     */
+    static Brightness;
+    /**
+     * @group Characteristic Definitions
+     */
+    static ButtonEvent;
+    /**
+     * @group Characteristic Definitions
+     */
+    static CameraOperatingModeIndicator;
+    /**
+     * @group Characteristic Definitions
+     */
+    static CarbonDioxideDetected;
+    /**
+     * @group Characteristic Definitions
+     */
+    static CarbonDioxideLevel;
+    /**
+     * @group Characteristic Definitions
+     */
+    static CarbonDioxidePeakLevel;
+    /**
+     * @group Characteristic Definitions
+     */
+    static CarbonMonoxideDetected;
+    /**
+     * @group Characteristic Definitions
+     */
+    static CarbonMonoxideLevel;
+    /**
+     * @group Characteristic Definitions
+     */
+    static CarbonMonoxidePeakLevel;
+    /**
+     * @group Characteristic Definitions
+     */
+    static CCAEnergyDetectThreshold;
+    /**
+     * @group Characteristic Definitions
+     */
+    static CCASignalDetectThreshold;
+    /**
+     * @group Characteristic Definitions
+     */
+    static CharacteristicValueActiveTransitionCount;
+    /**
+     * @group Characteristic Definitions
+     */
+    static CharacteristicValueTransitionControl;
+    /**
+     * @group Characteristic Definitions
+     */
+    static ChargingState;
+    /**
+     * @group Characteristic Definitions
+     */
+    static ClosedCaptions;
+    /**
+     * @group Characteristic Definitions
+     */
+    static ColorTemperature;
+    /**
+     * @group Characteristic Definitions
+     */
+    static ConfigurationState;
+    /**
+     * @group Characteristic Definitions
+     */
+    static ConfiguredName;
+    /**
+     * @group Characteristic Definitions
+     */
+    static ContactSensorState;
+    /**
+     * @group Characteristic Definitions
+     */
+    static CoolingThresholdTemperature;
+    /**
+     * @group Characteristic Definitions
+     */
+    static CryptoHash;
+    /**
+     * @group Characteristic Definitions
+     */
+    static CurrentAirPurifierState;
+    /**
+     * @group Characteristic Definitions
+     */
+    static CurrentAmbientLightLevel;
+    /**
+     * @group Characteristic Definitions
+     */
+    static CurrentDoorState;
+    /**
+     * @group Characteristic Definitions
+     */
+    static CurrentFanState;
+    /**
+     * @group Characteristic Definitions
+     */
+    static CurrentHeaterCoolerState;
+    /**
+     * @group Characteristic Definitions
+     */
+    static CurrentHeatingCoolingState;
+    /**
+     * @group Characteristic Definitions
+     */
+    static CurrentHorizontalTiltAngle;
+    /**
+     * @group Characteristic Definitions
+     */
+    static CurrentHumidifierDehumidifierState;
+    /**
+     * @group Characteristic Definitions
+     */
+    static CurrentMediaState;
+    /**
+     * @group Characteristic Definitions
+     */
+    static CurrentPosition;
+    /**
+     * @group Characteristic Definitions
+     */
+    static CurrentRelativeHumidity;
+    /**
+     * @group Characteristic Definitions
+     */
+    static CurrentSlatState;
+    /**
+     * @group Characteristic Definitions
+     */
+    static CurrentTemperature;
+    /**
+     * @group Characteristic Definitions
+     */
+    static CurrentTiltAngle;
+    /**
+     * @group Characteristic Definitions
+     */
+    static CurrentTransport;
+    /**
+     * @group Characteristic Definitions
+     */
+    static CurrentVerticalTiltAngle;
+    /**
+     * @group Characteristic Definitions
+     */
+    static CurrentVisibilityState;
+    /**
+     * @group Characteristic Definitions
+     */
+    static DataStreamHAPTransport;
+    /**
+     * @group Characteristic Definitions
+     */
+    static DataStreamHAPTransportInterrupt;
+    /**
+     * @group Characteristic Definitions
+     */
+    static DiagonalFieldOfView;
+    /**
+     * @group Characteristic Definitions
+     */
+    static DigitalZoom;
+    /**
+     * @group Characteristic Definitions
+     */
+    static DisplayOrder;
+    /**
+     * @group Characteristic Definitions
+     */
+    static EventRetransmissionMaximum;
+    /**
+     * @group Characteristic Definitions
+     */
+    static EventSnapshotsActive;
+    /**
+     * @group Characteristic Definitions
+     */
+    static EventTransmissionCounters;
+    /**
+     * @group Characteristic Definitions
+     */
+    static FilterChangeIndication;
+    /**
+     * @group Characteristic Definitions
+     */
+    static FilterLifeLevel;
+    /**
+     * @group Characteristic Definitions
+     */
+    static FirmwareRevision;
+    /**
+     * @group Characteristic Definitions
+     */
+    static FirmwareUpdateReadiness;
+    /**
+     * @group Characteristic Definitions
+     */
+    static FirmwareUpdateStatus;
+    /**
+     * @group Characteristic Definitions
+     */
+    static HardwareFinish;
+    /**
+     * @group Characteristic Definitions
+     */
+    static HardwareRevision;
+    /**
+     * @group Characteristic Definitions
+     */
+    static HeartBeat;
+    /**
+     * @group Characteristic Definitions
+     */
+    static HeatingThresholdTemperature;
+    /**
+     * @group Characteristic Definitions
+     */
+    static HoldPosition;
+    /**
+     * @group Characteristic Definitions
+     */
+    static HomeKitCameraActive;
+    /**
+     * @group Characteristic Definitions
+     */
+    static Hue;
+    /**
+     * @group Characteristic Definitions
+     */
+    static Identifier;
+    /**
+     * @group Characteristic Definitions
+     */
+    static Identify;
+    /**
+     * @group Characteristic Definitions
+     */
+    static ImageMirroring;
+    /**
+     * @group Characteristic Definitions
+     */
+    static ImageRotation;
+    /**
+     * @group Characteristic Definitions
+     */
+    static InputDeviceType;
+    /**
+     * @group Characteristic Definitions
+     */
+    static InputSourceType;
+    /**
+     * @group Characteristic Definitions
+     */
+    static InUse;
+    /**
+     * @group Characteristic Definitions
+     */
+    static IsConfigured;
+    /**
+     * @group Characteristic Definitions
+     */
+    static LeakDetected;
+    /**
+     * @group Characteristic Definitions
+     */
+    static ListPairings;
+    /**
+     * @group Characteristic Definitions
+     */
+    static LockControlPoint;
+    /**
+     * @group Characteristic Definitions
+     */
+    static LockCurrentState;
+    /**
+     * @group Characteristic Definitions
+     */
+    static LockLastKnownAction;
+    /**
+     * @group Characteristic Definitions
+     */
+    static LockManagementAutoSecurityTimeout;
+    /**
+     * @group Characteristic Definitions
+     */
+    static LockPhysicalControls;
+    /**
+     * @group Characteristic Definitions
+     */
+    static LockTargetState;
+    /**
+     * @group Characteristic Definitions
+     */
+    static Logs;
+    /**
+     * @group Characteristic Definitions
+     */
+    static MACRetransmissionMaximum;
+    /**
+     * @group Characteristic Definitions
+     */
+    static MACTransmissionCounters;
+    /**
+     * @group Characteristic Definitions
+     */
+    static ManagedNetworkEnable;
+    /**
+     * @group Characteristic Definitions
+     */
+    static ManuallyDisabled;
+    /**
+     * @group Characteristic Definitions
+     */
+    static Manufacturer;
+    /**
+     * @group Characteristic Definitions
+     */
+    static MatterFirmwareRevisionNumber;
+    /**
+     * @group Characteristic Definitions
+     */
+    static MatterFirmwareUpdateStatus;
+    /**
+     * @group Characteristic Definitions
+     */
+    static MaximumTransmitPower;
+    /**
+     * @group Characteristic Definitions
+     */
+    static MetricsBufferFullState;
+    /**
+     * @group Characteristic Definitions
+     */
+    static Model;
+    /**
+     * @group Characteristic Definitions
+     */
+    static MotionDetected;
+    /**
+     * @group Characteristic Definitions
+     */
+    static MultifunctionButton;
+    /**
+     * @group Characteristic Definitions
+     */
+    static Mute;
+    /**
+     * @group Characteristic Definitions
+     */
+    static Name;
+    /**
+     * @group Characteristic Definitions
+     */
+    static NetworkAccessViolationControl;
+    /**
+     * @group Characteristic Definitions
+     */
+    static NetworkClientProfileControl;
+    /**
+     * @group Characteristic Definitions
+     */
+    static NetworkClientStatusControl;
+    /**
+     * @group Characteristic Definitions
+     */
+    static NFCAccessControlPoint;
+    /**
+     * @group Characteristic Definitions
+     */
+    static NFCAccessSupportedConfiguration;
+    /**
+     * @group Characteristic Definitions
+     */
+    static NightVision;
+    /**
+     * @group Characteristic Definitions
+     */
+    static NitrogenDioxideDensity;
+    /**
+     * @group Characteristic Definitions
+     */
+    static ObstructionDetected;
+    /**
+     * @group Characteristic Definitions
+     */
+    static OccupancyDetected;
+    /**
+     * @group Characteristic Definitions
+     */
+    static On;
+    /**
+     * @group Characteristic Definitions
+     */
+    static OperatingStateResponse;
+    /**
+     * @group Characteristic Definitions
+     */
+    static OpticalZoom;
+    /**
+     * @group Characteristic Definitions
+     */
+    static OutletInUse;
+    /**
+     * @group Characteristic Definitions
+     */
+    static OzoneDensity;
+    /**
+     * @group Characteristic Definitions
+     */
+    static PairingFeatures;
+    /**
+     * @group Characteristic Definitions
+     */
+    static PairSetup;
+    /**
+     * @group Characteristic Definitions
+     */
+    static PairVerify;
+    /**
+     * @group Characteristic Definitions
+     */
+    static PasswordSetting;
+    /**
+     * @group Characteristic Definitions
+     */
+    static PeriodicSnapshotsActive;
+    /**
+     * @group Characteristic Definitions
+     */
+    static PictureMode;
+    /**
+     * @group Characteristic Definitions
+     */
+    static Ping;
+    /**
+     * @group Characteristic Definitions
+     */
+    static PM10Density;
+    /**
+     * @group Characteristic Definitions
+     */
+    static PM2_5Density;
+    /**
+     * @group Characteristic Definitions
+     */
+    static PositionState;
+    /**
+     * @group Characteristic Definitions
+     */
+    static PowerModeSelection;
+    /**
+     * @group Characteristic Definitions
+     */
+    static ProductData;
+    /**
+     * @group Characteristic Definitions
+     */
+    static ProgrammableSwitchEvent;
+    /**
+     * @group Characteristic Definitions
+     */
+    static ProgrammableSwitchOutputState;
+    /**
+     * @group Characteristic Definitions
+     */
+    static ProgramMode;
+    /**
+     * @group Characteristic Definitions
+     */
+    static ReceivedSignalStrengthIndication;
+    /**
+     * @group Characteristic Definitions
+     */
+    static ReceiverSensitivity;
+    /**
+     * @group Characteristic Definitions
+     */
+    static RecordingAudioActive;
+    /**
+     * @group Characteristic Definitions
+     */
+    static RelativeHumidityDehumidifierThreshold;
+    /**
+     * @group Characteristic Definitions
+     */
+    static RelativeHumidityHumidifierThreshold;
+    /**
+     * @group Characteristic Definitions
+     */
+    static RemainingDuration;
+    /**
+     * @group Characteristic Definitions
+     */
+    static RemoteKey;
+    /**
+     * @group Characteristic Definitions
+     */
+    static ResetFilterIndication;
+    /**
+     * @group Characteristic Definitions
+     */
+    static RotationDirection;
+    /**
+     * @group Characteristic Definitions
+     */
+    static RotationSpeed;
+    /**
+     * @group Characteristic Definitions
+     */
+    static RouterStatus;
+    /**
+     * @group Characteristic Definitions
+     */
+    static Saturation;
+    /**
+     * @group Characteristic Definitions
+     */
+    static SecuritySystemAlarmType;
+    /**
+     * @group Characteristic Definitions
+     */
+    static SecuritySystemCurrentState;
+    /**
+     * @group Characteristic Definitions
+     */
+    static SecuritySystemTargetState;
+    /**
+     * @group Characteristic Definitions
+     */
+    static SelectedAudioStreamConfiguration;
+    /**
+     * @group Characteristic Definitions
+     */
+    static SelectedCameraRecordingConfiguration;
+    /**
+     * @group Characteristic Definitions
+     */
+    static SelectedDiagnosticsModes;
+    /**
+     * @group Characteristic Definitions
+     */
+    static SelectedRTPStreamConfiguration;
+    /**
+     * @group Characteristic Definitions
+     */
+    static SelectedSleepConfiguration;
+    /**
+     * @group Characteristic Definitions
+     */
+    static SerialNumber;
+    /**
+     * @group Characteristic Definitions
+     */
+    static ServiceLabelIndex;
+    /**
+     * @group Characteristic Definitions
+     */
+    static ServiceLabelNamespace;
+    /**
+     * @group Characteristic Definitions
+     */
+    static SetDuration;
+    /**
+     * @group Characteristic Definitions
+     */
+    static SetupDataStreamTransport;
+    /**
+     * @group Characteristic Definitions
+     */
+    static SetupEndpoints;
+    /**
+     * @group Characteristic Definitions
+     */
+    static SetupTransferTransport;
+    /**
+     * @group Characteristic Definitions
+     */
+    static SignalToNoiseRatio;
+    /**
+     * @group Characteristic Definitions
+     */
+    static SiriEnable;
+    /**
+     * @group Characteristic Definitions
+     */
+    static SiriEndpointSessionStatus;
+    /**
+     * @group Characteristic Definitions
+     */
+    static SiriEngineVersion;
+    /**
+     * @group Characteristic Definitions
+     */
+    static SiriInputType;
+    /**
+     * @group Characteristic Definitions
+     */
+    static SiriLightOnUse;
+    /**
+     * @group Characteristic Definitions
+     */
+    static SiriListening;
+    /**
+     * @group Characteristic Definitions
+     */
+    static SiriTouchToUse;
+    /**
+     * @group Characteristic Definitions
+     */
+    static SlatType;
+    /**
+     * @group Characteristic Definitions
+     */
+    static SleepDiscoveryMode;
+    /**
+     * @group Characteristic Definitions
+     */
+    static SleepInterval;
+    /**
+     * @group Characteristic Definitions
+     */
+    static SmokeDetected;
+    /**
+     * @group Characteristic Definitions
+     */
+    static SoftwareRevision;
+    /**
+     * @group Characteristic Definitions
+     */
+    static StagedFirmwareVersion;
+    /**
+     * @group Characteristic Definitions
+     */
+    static StatusActive;
+    /**
+     * @group Characteristic Definitions
+     */
+    static StatusFault;
+    /**
+     * @group Characteristic Definitions
+     */
+    static StatusJammed;
+    /**
+     * @group Characteristic Definitions
+     */
+    static StatusLowBattery;
+    /**
+     * @group Characteristic Definitions
+     */
+    static StatusTampered;
+    /**
+     * @group Characteristic Definitions
+     */
+    static StreamingStatus;
+    /**
+     * @group Characteristic Definitions
+     */
+    static SulphurDioxideDensity;
+    /**
+     * @group Characteristic Definitions
+     */
+    static SupportedAssetTypes;
+    /**
+     * @group Characteristic Definitions
+     */
+    static SupportedAudioRecordingConfiguration;
+    /**
+     * @group Characteristic Definitions
+     */
+    static SupportedAudioStreamConfiguration;
+    /**
+     * @group Characteristic Definitions
+     */
+    static SupportedCameraRecordingConfiguration;
+    /**
+     * @group Characteristic Definitions
+     */
+    static SupportedCharacteristicValueTransitionConfiguration;
+    /**
+     * @group Characteristic Definitions
+     */
+    static SupportedDataStreamTransportConfiguration;
+    /**
+     * @group Characteristic Definitions
+     */
+    static SupportedDiagnosticsModes;
+    /**
+     * @group Characteristic Definitions
+     */
+    static SupportedDiagnosticsSnapshot;
+    /**
+     * @group Characteristic Definitions
+     */
+    static SupportedFirmwareUpdateConfiguration;
+    /**
+     * @group Characteristic Definitions
+     */
+    static SupportedMetrics;
+    /**
+     * @group Characteristic Definitions
+     */
+    static SupportedRouterConfiguration;
+    /**
+     * @group Characteristic Definitions
+     */
+    static SupportedRTPConfiguration;
+    /**
+     * @group Characteristic Definitions
+     */
+    static SupportedSleepConfiguration;
+    /**
+     * @group Characteristic Definitions
+     */
+    static SupportedTransferTransportConfiguration;
+    /**
+     * @group Characteristic Definitions
+     */
+    static SupportedVideoRecordingConfiguration;
+    /**
+     * @group Characteristic Definitions
+     */
+    static SupportedVideoStreamConfiguration;
+    /**
+     * @group Characteristic Definitions
+     */
+    static SwingMode;
+    /**
+     * @group Characteristic Definitions
+     */
+    static TapType;
+    /**
+     * @group Characteristic Definitions
+     */
+    static TargetAirPurifierState;
+    /**
+     * @group Characteristic Definitions
+     * @deprecated Removed and not used anymore
+     */
+    static TargetAirQuality;
+    /**
+     * @group Characteristic Definitions
+     */
+    static TargetControlList;
+    /**
+     * @group Characteristic Definitions
+     */
+    static TargetControlSupportedConfiguration;
+    /**
+     * @group Characteristic Definitions
+     */
+    static TargetDoorState;
+    /**
+     * @group Characteristic Definitions
+     */
+    static TargetFanState;
+    /**
+     * @group Characteristic Definitions
+     */
+    static TargetHeaterCoolerState;
+    /**
+     * @group Characteristic Definitions
+     */
+    static TargetHeatingCoolingState;
+    /**
+     * @group Characteristic Definitions
+     */
+    static TargetHorizontalTiltAngle;
+    /**
+     * @group Characteristic Definitions
+     */
+    static TargetHumidifierDehumidifierState;
+    /**
+     * @group Characteristic Definitions
+     */
+    static TargetMediaState;
+    /**
+     * @group Characteristic Definitions
+     */
+    static TargetPosition;
+    /**
+     * @group Characteristic Definitions
+     */
+    static TargetRelativeHumidity;
+    /**
+     * @group Characteristic Definitions
+     * @deprecated Removed and not used anymore
+     */
+    static TargetSlatState;
+    /**
+     * @group Characteristic Definitions
+     */
+    static TargetTemperature;
+    /**
+     * @group Characteristic Definitions
+     */
+    static TargetTiltAngle;
+    /**
+     * @group Characteristic Definitions
+     */
+    static TargetVerticalTiltAngle;
+    /**
+     * @group Characteristic Definitions
+     */
+    static TargetVisibilityState;
+    /**
+     * @group Characteristic Definitions
+     */
+    static TemperatureDisplayUnits;
+    /**
+     * @group Characteristic Definitions
+     */
+    static ThirdPartyCameraActive;
+    /**
+     * @group Characteristic Definitions
+     */
+    static ThreadControlPoint;
+    /**
+     * @group Characteristic Definitions
+     */
+    static ThreadNodeCapabilities;
+    /**
+     * @group Characteristic Definitions
+     */
+    static ThreadOpenThreadVersion;
+    /**
+     * @group Characteristic Definitions
+     */
+    static ThreadStatus;
+    /**
+     * @group Characteristic Definitions
+     */
+    static Token;
+    /**
+     * @group Characteristic Definitions
+     */
+    static TransmitPower;
+    /**
+     * @group Characteristic Definitions
+     */
+    static ValveType;
+    /**
+     * @group Characteristic Definitions
+     */
+    static Version;
+    /**
+     * @group Characteristic Definitions
+     */
+    static VideoAnalysisActive;
+    /**
+     * @group Characteristic Definitions
+     */
+    static VOCDensity;
+    /**
+     * @group Characteristic Definitions
+     */
+    static Volume;
+    /**
+     * @group Characteristic Definitions
+     */
+    static VolumeControlType;
+    /**
+     * @group Characteristic Definitions
+     */
+    static VolumeSelector;
+    /**
+     * @group Characteristic Definitions
+     */
+    static WakeConfiguration;
+    /**
+     * @group Characteristic Definitions
+     */
+    static WANConfigurationList;
+    /**
+     * @group Characteristic Definitions
+     */
+    static WANStatusList;
+    /**
+     * @group Characteristic Definitions
+     */
+    static WaterLevel;
+    /**
+     * @group Characteristic Definitions
+     */
+    static WiFiCapabilities;
+    /**
+     * @group Characteristic Definitions
+     */
+    static WiFiConfigurationControl;
+    /**
+     * @group Characteristic Definitions
+     */
+    static WiFiSatelliteStatus;
+    // =-=-=-=-=-=-=-=-=-=-=-=-=-=-=
+    // NOTICE: when adding/changing properties, remember to possibly adjust the serialize/deserialize functions
+    displayName;
+    UUID;
+    iid = null;
+    value = null;
+    /**
+     * @deprecated replaced by {@link statusCode}
+     * @private
+     */
+    status = null;
+    /**
+     * @private
+     */
+    statusCode = 0 /* HAPStatus.SUCCESS */;
+    props;
+    /**
+     * The {@link Characteristic.onGet} handler
+     */
+    getHandler;
+    /**
+     * The {@link Characteristic.onSet} handler
+     */
+    setHandler;
+    subscriptions = 0;
+    /**
+     * @private
+     */
+    additionalAuthorizationHandler;
+    constructor(displayName, UUID, props) {
+        super();
+        this.displayName = displayName;
+        this.UUID = UUID;
+        this.props = {
             format: "int" /* Formats.INT */,
             perms: ["ev" /* Perms.NOTIFY */],
         };
-        _this.setProps(props || {}); // ensure sanity checks are called
-        return _this;
+        this.setProps(props || {}); // ensure sanity checks are called
     }
     /**
      * Accepts a function that will be called to retrieve the current value of a Characteristic.
@@ -343,21 +1303,21 @@ var Characteristic = /** @class */ (function (_super) {
      * ```
      * @param handler
      */
-    Characteristic.prototype.onGet = function (handler) {
+    onGet(handler) {
         if (typeof handler !== "function") {
             this.characteristicWarning(".onGet handler must be a function");
             return this;
         }
         this.getHandler = handler;
         return this;
-    };
+    }
     /**
      * Removes the {@link CharacteristicGetHandler} handler which was configured using {@link onGet}.
      */
-    Characteristic.prototype.removeOnGet = function () {
+    removeOnGet() {
         this.getHandler = undefined;
         return this;
-    };
+    }
     /**
      * Accepts a function that will be called when setting the value of a Characteristic.
      * If the characteristic supports {@link Perms.WRITE_RESPONSE} and the request requests a write-response value,
@@ -372,21 +1332,21 @@ var Characteristic = /** @class */ (function (_super) {
      * ```
      * @param handler
      */
-    Characteristic.prototype.onSet = function (handler) {
+    onSet(handler) {
         if (typeof handler !== "function") {
             this.characteristicWarning(".onSet handler must be a function");
             return this;
         }
         this.setHandler = handler;
         return this;
-    };
+    }
     /**
      * Removes the {@link CharacteristicSetHandler} which was configured using {@link onSet}.
      */
-    Characteristic.prototype.removeOnSet = function () {
+    removeOnSet() {
         this.setHandler = undefined;
         return this;
-    };
+    }
     /**
      * Updates the properties of this characteristic.
      * Properties passed via the parameter will be set. Any parameter set to null will be deleted.
@@ -394,10 +1354,10 @@ var Characteristic = /** @class */ (function (_super) {
      *
      * @param props - Partial properties object with the desired updates.
      */
-    Characteristic.prototype.setProps = function (props) {
+    setProps(props) {
         (0, assert_1.default)(props, "props cannot be undefined when setting props");
         // TODO calling setProps after publish doesn't lead to a increment in the current configuration number
-        var formatDidChange = false;
+        let formatDidChange = false;
         // for every value "null" can be used to reset props, except for required props
         if (props.format) {
             formatDidChange = this.props.format !== props.format;
@@ -423,7 +1383,7 @@ var Characteristic = /** @class */ (function (_super) {
                 props.minValue = undefined;
             }
             else if (typeof props.minValue !== "number" || !Number.isFinite(props.minValue)) {
-                this.characteristicWarning("Characteristic Property 'minValue' must be a finite number, received \"".concat(props.minValue, "\" (").concat(typeof props.minValue, ")"), "error-message" /* CharacteristicWarningType.ERROR_MESSAGE */);
+                this.characteristicWarning(`Characteristic Property 'minValue' must be a finite number, received "${props.minValue}" (${typeof props.minValue})`, "error-message" /* CharacteristicWarningType.ERROR_MESSAGE */);
                 props.minValue = undefined;
             }
             else {
@@ -450,7 +1410,7 @@ var Characteristic = /** @class */ (function (_super) {
                 props.maxValue = undefined;
             }
             else if (typeof props.maxValue !== "number" || !Number.isFinite(props.maxValue)) {
-                this.characteristicWarning("Characteristic Property 'maxValue' must be a finite number, received \"".concat(props.maxValue, "\" (").concat(typeof props.maxValue, ")"), "error-message" /* CharacteristicWarningType.ERROR_MESSAGE */);
+                this.characteristicWarning(`Characteristic Property 'maxValue' must be a finite number, received "${props.maxValue}" (${typeof props.maxValue})`, "error-message" /* CharacteristicWarningType.ERROR_MESSAGE */);
                 props.maxValue = undefined;
             }
             else {
@@ -554,14 +1514,14 @@ var Characteristic = /** @class */ (function (_super) {
             // - If the characteristic is marked as erroneous the value is not considered valid anyway, and we must not remove the `statusCode`.
             // - Special case for `ProgrammableSwitchEvent` where every change in value is considered an event which would result in ghost button presses
             // validateUserInput when called from setProps is intended to clamp value withing allowed range. It is why warnings should not be displayed.
-            var correctedValue = this.validateUserInput(this.value, "debug-message" /* CharacteristicWarningType.DEBUG_MESSAGE */);
+            const correctedValue = this.validateUserInput(this.value, "debug-message" /* CharacteristicWarningType.DEBUG_MESSAGE */);
             if (correctedValue !== this.value) {
                 // we don't want to emit a CHANGE event if the value didn't change at all!
                 this.updateValue(correctedValue);
             }
         }
         return this;
-    };
+    }
     /**
      * This method can be used to gain an Iterator to loop over all valid values defined for this characteristic.
      *
@@ -590,9 +1550,9 @@ var Characteristic = /** @class */ (function (_super) {
      * const validValues = Array.from(characteristic.validValuesIterator());
      * ```
      */
-    Characteristic.prototype.validValuesIterator = function () {
+    validValuesIterator() {
         return new ValidValuesIterable(this.props);
-    };
+    }
     // noinspection JSUnusedGlobalSymbols
     /**
      * This method can be used to set up additional authorization for a characteristic.
@@ -610,12 +1570,12 @@ var Characteristic = /** @class */ (function (_super) {
      *
      * @param handler - Handler called to check additional authorization data.
      */
-    Characteristic.prototype.setupAdditionalAuthorization = function (handler) {
+    setupAdditionalAuthorization(handler) {
         if (!this.props.perms.includes("aa" /* Perms.ADDITIONAL_AUTHORIZATION */)) {
             this.props.perms.push("aa" /* Perms.ADDITIONAL_AUTHORIZATION */);
         }
         this.additionalAuthorizationHandler = handler;
-    };
+    }
     /**
      * Updates the current value of the characteristic.
      *
@@ -625,18 +1585,18 @@ var Characteristic = /** @class */ (function (_super) {
      *
      * @deprecated
      */
-    Characteristic.prototype.getValue = function (callback, context) {
-        this.handleGetRequest(undefined, context).then(function (value) {
+    getValue(callback, context) {
+        this.handleGetRequest(undefined, context).then(value => {
             if (callback) {
                 callback(null, value);
             }
-        }, function (reason) {
+        }, reason => {
             if (callback) {
                 callback(reason);
             }
         });
-    };
-    Characteristic.prototype.setValue = function (value, callback, context) {
+    }
+    setValue(value, callback, context) {
         if (value instanceof Error) {
             this.statusCode = value instanceof hapStatusError_1.HapStatusError ? value.hapStatus : extractHAPStatusFromError(value);
             // noinspection JSDeprecatedSymbols
@@ -654,13 +1614,13 @@ var Characteristic = /** @class */ (function (_super) {
             value = this.validateUserInput(value);
         }
         catch (error) {
-            this.characteristicWarning((error === null || error === void 0 ? void 0 : error.message) + "", "error-message" /* CharacteristicWarningType.ERROR_MESSAGE */, error === null || error === void 0 ? void 0 : error.stack);
+            this.characteristicWarning(error?.message + "", "error-message" /* CharacteristicWarningType.ERROR_MESSAGE */, error?.stack);
             if (callback) {
                 callback(error);
             }
             return this;
         }
-        this.handleSetRequest(value, undefined, context).then(function (value) {
+        this.handleSetRequest(value, undefined, context).then(value => {
             if (callback) {
                 if (value) { // possible write response
                     callback(null, value);
@@ -669,14 +1629,14 @@ var Characteristic = /** @class */ (function (_super) {
                     callback(null);
                 }
             }
-        }, function (reason) {
+        }, reason => {
             if (callback) {
                 callback(reason);
             }
         });
         return this;
-    };
-    Characteristic.prototype.updateValue = function (value, callback, context) {
+    }
+    updateValue(value, callback, context) {
         if (value instanceof Error) {
             this.statusCode = value instanceof hapStatusError_1.HapStatusError ? value.hapStatus : extractHAPStatusFromError(value);
             // noinspection JSDeprecatedSymbols
@@ -694,7 +1654,7 @@ var Characteristic = /** @class */ (function (_super) {
             value = this.validateUserInput(value);
         }
         catch (error) {
-            this.characteristicWarning((error === null || error === void 0 ? void 0 : error.message) + "", "error-message" /* CharacteristicWarningType.ERROR_MESSAGE */, error === null || error === void 0 ? void 0 : error.stack);
+            this.characteristicWarning(error?.message + "", "error-message" /* CharacteristicWarningType.ERROR_MESSAGE */, error?.stack);
             if (callback) {
                 callback();
             }
@@ -703,14 +1663,14 @@ var Characteristic = /** @class */ (function (_super) {
         this.statusCode = 0 /* HAPStatus.SUCCESS */;
         // noinspection JSDeprecatedSymbols
         this.status = null;
-        var oldValue = this.value;
+        const oldValue = this.value;
         this.value = value;
         if (callback) {
             callback();
         }
         this.emit("change" /* CharacteristicEventTypes.CHANGE */, { originator: undefined, oldValue: oldValue, newValue: value, reason: "update" /* ChangeReason.UPDATE */, context: context });
         return this; // for chaining
-    };
+    }
     /**
      * This method acts similarly to {@link updateValue} by setting the current value of the characteristic
      * without calling any {@link CharacteristicEventTypes.SET} or {@link onSet} handlers.
@@ -720,16 +1680,16 @@ var Characteristic = /** @class */ (function (_super) {
      * @param value - The new value.
      * @param context - Passed to the {@link CharacteristicEventTypes.CHANGE} event handler.
      */
-    Characteristic.prototype.sendEventNotification = function (value, context) {
+    sendEventNotification(value, context) {
         this.statusCode = 0 /* HAPStatus.SUCCESS */;
         // noinspection JSDeprecatedSymbols
         this.status = null;
         value = this.validateUserInput(value);
-        var oldValue = this.value;
+        const oldValue = this.value;
         this.value = value;
         this.emit("change" /* CharacteristicEventTypes.CHANGE */, { originator: undefined, oldValue: oldValue, newValue: value, reason: "event" /* ChangeReason.EVENT */, context: context });
         return this; // for chaining
-    };
+    }
     /**
      * Called when a HAP requests wants to know the current value of the characteristic.
      *
@@ -737,130 +1697,118 @@ var Characteristic = /** @class */ (function (_super) {
      * @param context - Deprecated parameter. There for backwards compatibility.
      * @private Used by the Accessory to load the characteristic value
      */
-    Characteristic.prototype.handleGetRequest = function (connection, context) {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var value, oldValue, error_1, hapStatusError;
-            var _this = this;
-            return tslib_1.__generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        if (!this.props.perms.includes("pr" /* Perms.PAIRED_READ */)) { // check if we are allowed to read from this characteristic
-                            throw -70405 /* HAPStatus.WRITE_ONLY_CHARACTERISTIC */;
-                        }
-                        if (this.UUID === Characteristic.ProgrammableSwitchEvent.UUID) {
-                            // special workaround for event only programmable switch event, which must always return null
-                            return [2 /*return*/, null];
-                        }
-                        if (!this.getHandler) return [3 /*break*/, 4];
-                        if (this.listeners("get" /* CharacteristicEventTypes.GET */).length > 0) {
-                            this.characteristicWarning("Ignoring on('get') handler as onGet handler was defined instead");
-                        }
-                        _a.label = 1;
-                    case 1:
-                        _a.trys.push([1, 3, , 4]);
-                        return [4 /*yield*/, this.getHandler(context, connection)];
-                    case 2:
-                        value = _a.sent();
-                        this.statusCode = 0 /* HAPStatus.SUCCESS */;
-                        // noinspection JSDeprecatedSymbols
-                        this.status = null;
-                        try {
-                            value = this.validateUserInput(value);
-                        }
-                        catch (error) {
-                            this.characteristicWarning("An illegal value was supplied by the read handler for characteristic: ".concat(error === null || error === void 0 ? void 0 : error.message), "warn-message" /* CharacteristicWarningType.WARN_MESSAGE */, error === null || error === void 0 ? void 0 : error.stack);
-                            this.statusCode = -70402 /* HAPStatus.SERVICE_COMMUNICATION_FAILURE */;
-                            // noinspection JSDeprecatedSymbols
-                            this.status = error;
-                            return [2 /*return*/, Promise.reject(-70402 /* HAPStatus.SERVICE_COMMUNICATION_FAILURE */)];
-                        }
-                        oldValue = this.value;
-                        this.value = value;
-                        if (oldValue !== value) { // emit a change event if necessary
-                            this.emit("change" /* CharacteristicEventTypes.CHANGE */, { originator: connection, oldValue: oldValue, newValue: value, reason: "read" /* ChangeReason.READ */, context: context });
-                        }
-                        return [2 /*return*/, value];
-                    case 3:
-                        error_1 = _a.sent();
-                        if (typeof error_1 === "number") {
-                            hapStatusError = new hapStatusError_1.HapStatusError(error_1);
+    async handleGetRequest(connection, context) {
+        if (!this.props.perms.includes("pr" /* Perms.PAIRED_READ */)) { // check if we are allowed to read from this characteristic
+            throw -70405 /* HAPStatus.WRITE_ONLY_CHARACTERISTIC */;
+        }
+        if (this.UUID === Characteristic.ProgrammableSwitchEvent.UUID) {
+            // special workaround for event only programmable switch event, which must always return null
+            return null;
+        }
+        if (this.getHandler) {
+            if (this.listeners("get" /* CharacteristicEventTypes.GET */).length > 0) {
+                this.characteristicWarning("Ignoring on('get') handler as onGet handler was defined instead");
+            }
+            try {
+                let value = await this.getHandler(context, connection);
+                this.statusCode = 0 /* HAPStatus.SUCCESS */;
+                // noinspection JSDeprecatedSymbols
+                this.status = null;
+                try {
+                    value = this.validateUserInput(value);
+                }
+                catch (error) {
+                    this.characteristicWarning(`An illegal value was supplied by the read handler for characteristic: ${error?.message}`, "warn-message" /* CharacteristicWarningType.WARN_MESSAGE */, error?.stack);
+                    this.statusCode = -70402 /* HAPStatus.SERVICE_COMMUNICATION_FAILURE */;
+                    // noinspection JSDeprecatedSymbols
+                    this.status = error;
+                    return Promise.reject(-70402 /* HAPStatus.SERVICE_COMMUNICATION_FAILURE */);
+                }
+                const oldValue = this.value;
+                this.value = value;
+                if (oldValue !== value) { // emit a change event if necessary
+                    this.emit("change" /* CharacteristicEventTypes.CHANGE */, { originator: connection, oldValue: oldValue, newValue: value, reason: "read" /* ChangeReason.READ */, context: context });
+                }
+                return value;
+            }
+            catch (error) {
+                if (typeof error === "number") {
+                    const hapStatusError = new hapStatusError_1.HapStatusError(error);
+                    this.statusCode = hapStatusError.hapStatus;
+                    // noinspection JSDeprecatedSymbols
+                    this.status = hapStatusError;
+                }
+                else if (error instanceof hapStatusError_1.HapStatusError) {
+                    this.statusCode = error.hapStatus;
+                    // noinspection JSDeprecatedSymbols
+                    this.status = error;
+                }
+                else {
+                    this.characteristicWarning(`Unhandled error thrown inside read handler for characteristic: ${error?.message}`, "error-message" /* CharacteristicWarningType.ERROR_MESSAGE */, error?.stack);
+                    this.statusCode = -70402 /* HAPStatus.SERVICE_COMMUNICATION_FAILURE */;
+                    // noinspection JSDeprecatedSymbols
+                    this.status = error;
+                }
+                throw this.statusCode;
+            }
+        }
+        if (this.listeners("get" /* CharacteristicEventTypes.GET */).length === 0) {
+            if (this.statusCode) {
+                throw this.statusCode;
+            }
+            try {
+                return this.validateUserInput(this.value);
+            }
+            catch (error) {
+                this.characteristicWarning(`An illegal value was supplied by setting \`value\` for characteristic: ${error?.message}`, "warn-message" /* CharacteristicWarningType.WARN_MESSAGE */, error?.stack);
+                return Promise.reject(-70402 /* HAPStatus.SERVICE_COMMUNICATION_FAILURE */);
+            }
+        }
+        return new Promise((resolve, reject) => {
+            try {
+                this.emit("get" /* CharacteristicEventTypes.GET */, (0, once_1.once)((status, value) => {
+                    if (status) {
+                        if (typeof status === "number") {
+                            const hapStatusError = new hapStatusError_1.HapStatusError(status);
                             this.statusCode = hapStatusError.hapStatus;
                             // noinspection JSDeprecatedSymbols
                             this.status = hapStatusError;
                         }
-                        else if (error_1 instanceof hapStatusError_1.HapStatusError) {
-                            this.statusCode = error_1.hapStatus;
+                        else if (status instanceof hapStatusError_1.HapStatusError) {
+                            this.statusCode = status.hapStatus;
                             // noinspection JSDeprecatedSymbols
-                            this.status = error_1;
+                            this.status = status;
                         }
                         else {
-                            this.characteristicWarning("Unhandled error thrown inside read handler for characteristic: ".concat(error_1 === null || error_1 === void 0 ? void 0 : error_1.message), "error-message" /* CharacteristicWarningType.ERROR_MESSAGE */, error_1 === null || error_1 === void 0 ? void 0 : error_1.stack);
-                            this.statusCode = -70402 /* HAPStatus.SERVICE_COMMUNICATION_FAILURE */;
+                            debug("[%s] Received error from get handler %s", this.displayName, status.stack);
+                            this.statusCode = extractHAPStatusFromError(status);
                             // noinspection JSDeprecatedSymbols
-                            this.status = error_1;
-                        }
-                        throw this.statusCode;
-                    case 4:
-                        if (this.listeners("get" /* CharacteristicEventTypes.GET */).length === 0) {
-                            if (this.statusCode) {
-                                throw this.statusCode;
-                            }
-                            try {
-                                return [2 /*return*/, this.validateUserInput(this.value)];
-                            }
-                            catch (error) {
-                                this.characteristicWarning("An illegal value was supplied by setting `value` for characteristic: ".concat(error === null || error === void 0 ? void 0 : error.message), "warn-message" /* CharacteristicWarningType.WARN_MESSAGE */, error === null || error === void 0 ? void 0 : error.stack);
-                                return [2 /*return*/, Promise.reject(-70402 /* HAPStatus.SERVICE_COMMUNICATION_FAILURE */)];
-                            }
+                            this.status = status;
                         }
-                        return [2 /*return*/, new Promise(function (resolve, reject) {
-                                try {
-                                    _this.emit("get" /* CharacteristicEventTypes.GET */, (0, once_1.once)(function (status, value) {
-                                        if (status) {
-                                            if (typeof status === "number") {
-                                                var hapStatusError = new hapStatusError_1.HapStatusError(status);
-                                                _this.statusCode = hapStatusError.hapStatus;
-                                                // noinspection JSDeprecatedSymbols
-                                                _this.status = hapStatusError;
-                                            }
-                                            else if (status instanceof hapStatusError_1.HapStatusError) {
-                                                _this.statusCode = status.hapStatus;
-                                                // noinspection JSDeprecatedSymbols
-                                                _this.status = status;
-                                            }
-                                            else {
-                                                debug("[%s] Received error from get handler %s", _this.displayName, status.stack);
-                                                _this.statusCode = extractHAPStatusFromError(status);
-                                                // noinspection JSDeprecatedSymbols
-                                                _this.status = status;
-                                            }
-                                            reject(_this.statusCode);
-                                            return;
-                                        }
-                                        _this.statusCode = 0 /* HAPStatus.SUCCESS */;
-                                        // noinspection JSDeprecatedSymbols
-                                        _this.status = null;
-                                        value = _this.validateUserInput(value);
-                                        var oldValue = _this.value;
-                                        _this.value = value;
-                                        resolve(value);
-                                        if (oldValue !== value) { // emit a change event if necessary
-                                            _this.emit("change" /* CharacteristicEventTypes.CHANGE */, { originator: connection, oldValue: oldValue, newValue: value, reason: "read" /* ChangeReason.READ */, context: context });
-                                        }
-                                    }), context, connection);
-                                }
-                                catch (error) {
-                                    _this.characteristicWarning("Unhandled error thrown inside read handler for characteristic: ".concat(error === null || error === void 0 ? void 0 : error.message), "error-message" /* CharacteristicWarningType.ERROR_MESSAGE */, error === null || error === void 0 ? void 0 : error.stack);
-                                    _this.statusCode = -70402 /* HAPStatus.SERVICE_COMMUNICATION_FAILURE */;
-                                    // noinspection JSDeprecatedSymbols
-                                    _this.status = error;
-                                    reject(-70402 /* HAPStatus.SERVICE_COMMUNICATION_FAILURE */);
-                                }
-                            })];
-                }
-            });
+                        reject(this.statusCode);
+                        return;
+                    }
+                    this.statusCode = 0 /* HAPStatus.SUCCESS */;
+                    // noinspection JSDeprecatedSymbols
+                    this.status = null;
+                    value = this.validateUserInput(value);
+                    const oldValue = this.value;
+                    this.value = value;
+                    resolve(value);
+                    if (oldValue !== value) { // emit a change event if necessary
+                        this.emit("change" /* CharacteristicEventTypes.CHANGE */, { originator: connection, oldValue: oldValue, newValue: value, reason: "read" /* ChangeReason.READ */, context: context });
+                    }
+                }), context, connection);
+            }
+            catch (error) {
+                this.characteristicWarning(`Unhandled error thrown inside read handler for characteristic: ${error?.message}`, "error-message" /* CharacteristicWarningType.ERROR_MESSAGE */, error?.stack);
+                this.statusCode = -70402 /* HAPStatus.SERVICE_COMMUNICATION_FAILURE */;
+                // noinspection JSDeprecatedSymbols
+                this.status = error;
+                reject(-70402 /* HAPStatus.SERVICE_COMMUNICATION_FAILURE */);
+            }
         });
-    };
+    }
     /**
      * Called when a HAP requests update the current value of the characteristic.
      *
@@ -872,162 +1820,147 @@ var Characteristic = /** @class */ (function (_super) {
      *  write response value is resolved.
      * @private
      */
-    Characteristic.prototype.handleSetRequest = function (value, connection, context) {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var oldValue, writeResponse, error_2, hapStatusError;
-            var _this = this;
-            return tslib_1.__generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        this.statusCode = 0 /* HAPStatus.SUCCESS */;
-                        // noinspection JSDeprecatedSymbols
-                        this.status = null;
-                        if (connection !== undefined) {
-                            // if connection is undefined, the set "request" comes from the setValue method.
-                            // for setValue a value of "null" is allowed and checked via validateUserInput.
-                            try {
-                                value = this.validateClientSuppliedValue(value);
+    async handleSetRequest(value, connection, context) {
+        this.statusCode = 0 /* HAPStatus.SUCCESS */;
+        // noinspection JSDeprecatedSymbols
+        this.status = null;
+        if (connection !== undefined) {
+            // if connection is undefined, the set "request" comes from the setValue method.
+            // for setValue a value of "null" is allowed and checked via validateUserInput.
+            try {
+                value = this.validateClientSuppliedValue(value);
+            }
+            catch (e) {
+                debug(`[${this.displayName}]`, e.message);
+                return Promise.reject(-70410 /* HAPStatus.INVALID_VALUE_IN_REQUEST */);
+            }
+        }
+        const oldValue = this.value;
+        if (this.setHandler) {
+            if (this.listeners("set" /* CharacteristicEventTypes.SET */).length > 0) {
+                this.characteristicWarning("Ignoring on('set') handler as onSet handler was defined instead");
+            }
+            try {
+                const writeResponse = await this.setHandler(value, context, connection);
+                this.statusCode = 0 /* HAPStatus.SUCCESS */;
+                // noinspection JSDeprecatedSymbols
+                this.status = null;
+                if (writeResponse != null && this.props.perms.includes("wr" /* Perms.WRITE_RESPONSE */)) {
+                    this.value = this.validateUserInput(writeResponse);
+                    return this.value;
+                }
+                else {
+                    if (writeResponse != null) {
+                        this.characteristicWarning("SET handler returned write response value, though the characteristic doesn't support write response", "debug-message" /* CharacteristicWarningType.DEBUG_MESSAGE */);
+                    }
+                    this.value = value;
+                    this.emit("change" /* CharacteristicEventTypes.CHANGE */, { originator: connection, oldValue: oldValue, newValue: value, reason: "write" /* ChangeReason.WRITE */, context: context });
+                    return;
+                }
+            }
+            catch (error) {
+                if (typeof error === "number") {
+                    const hapStatusError = new hapStatusError_1.HapStatusError(error);
+                    this.statusCode = hapStatusError.hapStatus;
+                    // noinspection JSDeprecatedSymbols
+                    this.status = hapStatusError;
+                }
+                else if (error instanceof hapStatusError_1.HapStatusError) {
+                    this.statusCode = error.hapStatus;
+                    // noinspection JSDeprecatedSymbols
+                    this.status = error;
+                }
+                else {
+                    this.characteristicWarning(`Unhandled error thrown inside write handler for characteristic: ${error?.message}`, "error-message" /* CharacteristicWarningType.ERROR_MESSAGE */, error?.stack);
+                    this.statusCode = -70402 /* HAPStatus.SERVICE_COMMUNICATION_FAILURE */;
+                    // noinspection JSDeprecatedSymbols
+                    this.status = error;
+                }
+                throw this.statusCode;
+            }
+        }
+        if (this.listeners("set" /* CharacteristicEventTypes.SET */).length === 0) {
+            this.value = value;
+            this.emit("change" /* CharacteristicEventTypes.CHANGE */, { originator: connection, oldValue: oldValue, newValue: value, reason: "write" /* ChangeReason.WRITE */, context: context });
+            return Promise.resolve();
+        }
+        else {
+            return new Promise((resolve, reject) => {
+                try {
+                    this.emit("set" /* CharacteristicEventTypes.SET */, value, (0, once_1.once)((status, writeResponse) => {
+                        if (status) {
+                            if (typeof status === "number") {
+                                const hapStatusError = new hapStatusError_1.HapStatusError(status);
+                                this.statusCode = hapStatusError.hapStatus;
+                                // noinspection JSDeprecatedSymbols
+                                this.status = hapStatusError;
                             }
-                            catch (e) {
-                                debug("[".concat(this.displayName, "]"), e.message);
-                                return [2 /*return*/, Promise.reject(-70410 /* HAPStatus.INVALID_VALUE_IN_REQUEST */)];
+                            else if (status instanceof hapStatusError_1.HapStatusError) {
+                                this.statusCode = status.hapStatus;
+                                // noinspection JSDeprecatedSymbols
+                                this.status = status;
                             }
+                            else {
+                                debug("[%s] Received error from set handler %s", this.displayName, status.stack);
+                                this.statusCode = extractHAPStatusFromError(status);
+                                // noinspection JSDeprecatedSymbols
+                                this.status = status;
+                            }
+                            reject(this.statusCode);
+                            return;
                         }
-                        oldValue = this.value;
-                        if (!this.setHandler) return [3 /*break*/, 4];
-                        if (this.listeners("set" /* CharacteristicEventTypes.SET */).length > 0) {
-                            this.characteristicWarning("Ignoring on('set') handler as onSet handler was defined instead");
-                        }
-                        _a.label = 1;
-                    case 1:
-                        _a.trys.push([1, 3, , 4]);
-                        return [4 /*yield*/, this.setHandler(value, context, connection)];
-                    case 2:
-                        writeResponse = _a.sent();
                         this.statusCode = 0 /* HAPStatus.SUCCESS */;
                         // noinspection JSDeprecatedSymbols
                         this.status = null;
                         if (writeResponse != null && this.props.perms.includes("wr" /* Perms.WRITE_RESPONSE */)) {
+                            // support write response simply by letting the implementor pass the response as second argument to the callback
                             this.value = this.validateUserInput(writeResponse);
-                            return [2 /*return*/, this.value];
+                            resolve(this.value);
                         }
                         else {
                             if (writeResponse != null) {
                                 this.characteristicWarning("SET handler returned write response value, though the characteristic doesn't support write response", "debug-message" /* CharacteristicWarningType.DEBUG_MESSAGE */);
                             }
                             this.value = value;
+                            resolve();
                             this.emit("change" /* CharacteristicEventTypes.CHANGE */, { originator: connection, oldValue: oldValue, newValue: value, reason: "write" /* ChangeReason.WRITE */, context: context });
-                            return [2 /*return*/];
-                        }
-                        return [3 /*break*/, 4];
-                    case 3:
-                        error_2 = _a.sent();
-                        if (typeof error_2 === "number") {
-                            hapStatusError = new hapStatusError_1.HapStatusError(error_2);
-                            this.statusCode = hapStatusError.hapStatus;
-                            // noinspection JSDeprecatedSymbols
-                            this.status = hapStatusError;
-                        }
-                        else if (error_2 instanceof hapStatusError_1.HapStatusError) {
-                            this.statusCode = error_2.hapStatus;
-                            // noinspection JSDeprecatedSymbols
-                            this.status = error_2;
-                        }
-                        else {
-                            this.characteristicWarning("Unhandled error thrown inside write handler for characteristic: ".concat(error_2 === null || error_2 === void 0 ? void 0 : error_2.message), "error-message" /* CharacteristicWarningType.ERROR_MESSAGE */, error_2 === null || error_2 === void 0 ? void 0 : error_2.stack);
-                            this.statusCode = -70402 /* HAPStatus.SERVICE_COMMUNICATION_FAILURE */;
-                            // noinspection JSDeprecatedSymbols
-                            this.status = error_2;
-                        }
-                        throw this.statusCode;
-                    case 4:
-                        if (this.listeners("set" /* CharacteristicEventTypes.SET */).length === 0) {
-                            this.value = value;
-                            this.emit("change" /* CharacteristicEventTypes.CHANGE */, { originator: connection, oldValue: oldValue, newValue: value, reason: "write" /* ChangeReason.WRITE */, context: context });
-                            return [2 /*return*/, Promise.resolve()];
-                        }
-                        else {
-                            return [2 /*return*/, new Promise(function (resolve, reject) {
-                                    try {
-                                        _this.emit("set" /* CharacteristicEventTypes.SET */, value, (0, once_1.once)(function (status, writeResponse) {
-                                            if (status) {
-                                                if (typeof status === "number") {
-                                                    var hapStatusError = new hapStatusError_1.HapStatusError(status);
-                                                    _this.statusCode = hapStatusError.hapStatus;
-                                                    // noinspection JSDeprecatedSymbols
-                                                    _this.status = hapStatusError;
-                                                }
-                                                else if (status instanceof hapStatusError_1.HapStatusError) {
-                                                    _this.statusCode = status.hapStatus;
-                                                    // noinspection JSDeprecatedSymbols
-                                                    _this.status = status;
-                                                }
-                                                else {
-                                                    debug("[%s] Received error from set handler %s", _this.displayName, status.stack);
-                                                    _this.statusCode = extractHAPStatusFromError(status);
-                                                    // noinspection JSDeprecatedSymbols
-                                                    _this.status = status;
-                                                }
-                                                reject(_this.statusCode);
-                                                return;
-                                            }
-                                            _this.statusCode = 0 /* HAPStatus.SUCCESS */;
-                                            // noinspection JSDeprecatedSymbols
-                                            _this.status = null;
-                                            if (writeResponse != null && _this.props.perms.includes("wr" /* Perms.WRITE_RESPONSE */)) {
-                                                // support write response simply by letting the implementor pass the response as second argument to the callback
-                                                _this.value = _this.validateUserInput(writeResponse);
-                                                resolve(_this.value);
-                                            }
-                                            else {
-                                                if (writeResponse != null) {
-                                                    _this.characteristicWarning("SET handler returned write response value, though the characteristic doesn't support write response", "debug-message" /* CharacteristicWarningType.DEBUG_MESSAGE */);
-                                                }
-                                                _this.value = value;
-                                                resolve();
-                                                _this.emit("change" /* CharacteristicEventTypes.CHANGE */, { originator: connection, oldValue: oldValue, newValue: value, reason: "write" /* ChangeReason.WRITE */, context: context });
-                                            }
-                                        }), context, connection);
-                                    }
-                                    catch (error) {
-                                        _this.characteristicWarning("Unhandled error thrown inside write handler for characteristic: ".concat(error === null || error === void 0 ? void 0 : error.message), "error-message" /* CharacteristicWarningType.ERROR_MESSAGE */, error === null || error === void 0 ? void 0 : error.stack);
-                                        _this.statusCode = -70402 /* HAPStatus.SERVICE_COMMUNICATION_FAILURE */;
-                                        // noinspection JSDeprecatedSymbols
-                                        _this.status = error;
-                                        reject(-70402 /* HAPStatus.SERVICE_COMMUNICATION_FAILURE */);
-                                    }
-                                })];
                         }
-                        return [2 /*return*/];
+                    }), context, connection);
+                }
+                catch (error) {
+                    this.characteristicWarning(`Unhandled error thrown inside write handler for characteristic: ${error?.message}`, "error-message" /* CharacteristicWarningType.ERROR_MESSAGE */, error?.stack);
+                    this.statusCode = -70402 /* HAPStatus.SERVICE_COMMUNICATION_FAILURE */;
+                    // noinspection JSDeprecatedSymbols
+                    this.status = error;
+                    reject(-70402 /* HAPStatus.SERVICE_COMMUNICATION_FAILURE */);
                 }
             });
-        });
-    };
+        }
+    }
     /**
      * Called once a HomeKit controller subscribes to events of this characteristic.
      * @private
      */
-    Characteristic.prototype.subscribe = function () {
+    subscribe() {
         if (this.subscriptions === 0) {
             this.emit("subscribe" /* CharacteristicEventTypes.SUBSCRIBE */);
         }
         this.subscriptions++;
-    };
+    }
     /**
      * Called once a HomeKit controller unsubscribe to events of this characteristic or a HomeKit controller
      * which was subscribed to this characteristic disconnects.
      * @private
      */
-    Characteristic.prototype.unsubscribe = function () {
-        var wasOne = this.subscriptions === 1;
+    unsubscribe() {
+        const wasOne = this.subscriptions === 1;
         this.subscriptions--;
         this.subscriptions = Math.max(this.subscriptions, 0);
         if (wasOne) {
             this.emit("unsubscribe" /* CharacteristicEventTypes.UNSUBSCRIBE */);
         }
-    };
-    Characteristic.prototype.getDefaultValue = function () {
-        var _a;
+    }
+    getDefaultValue() {
         // noinspection JSDeprecatedSymbols
         switch (this.props.format) {
             case "bool" /* Formats.BOOL */:
@@ -1063,7 +1996,7 @@ var Characteristic = /** @class */ (function (_super) {
                     case Characteristic.CurrentTemperature.UUID:
                         return 0; // some existing integrations expect this to be 0 by default
                     default: {
-                        if (((_a = this.props.validValues) === null || _a === void 0 ? void 0 : _a.length) && typeof this.props.validValues[0] === "number") {
+                        if (this.props.validValues?.length && typeof this.props.validValues[0] === "number") {
                             return this.props.validValues[0];
                         }
                         if (typeof this.props.minValue === "number" && Number.isFinite(this.props.minValue)) {
@@ -1075,16 +2008,16 @@ var Characteristic = /** @class */ (function (_super) {
             default:
                 return 0;
         }
-    };
+    }
     /**
      * Checks if the value received from the HAP request is valid.
      * If returned false the received value is not valid and {@link HAPStatus.INVALID_VALUE_IN_REQUEST}
      * must be returned.
      * @param value - Value supplied by the HomeKit controller
      */
-    Characteristic.prototype.validateClientSuppliedValue = function (value) {
+    validateClientSuppliedValue(value) {
         if (value == null) {
-            throw new Error("Client supplied invalid value for ".concat(this.props.format, ": ").concat(value));
+            throw new Error(`Client supplied invalid value for ${this.props.format}: ${value}`);
         }
         switch (this.props.format) {
             case "bool" /* Formats.BOOL */: {
@@ -1094,7 +2027,7 @@ var Characteristic = /** @class */ (function (_super) {
                 if (typeof value === "number" && (value === 1 || value === 0)) {
                     return Boolean(value);
                 }
-                throw new Error("Client supplied invalid type for ".concat(this.props.format, ": \"").concat(value, "\" (").concat(typeof value, ")"));
+                throw new Error(`Client supplied invalid type for ${this.props.format}: "${value}" (${typeof value})`);
             }
             case "int" /* Formats.INT */:
             case "float" /* Formats.FLOAT */:
@@ -1106,58 +2039,58 @@ var Characteristic = /** @class */ (function (_super) {
                     value = value ? 1 : 0;
                 }
                 if (typeof value !== "number" || !Number.isFinite(value)) {
-                    throw new Error("Client supplied invalid type for ".concat(this.props.format, ": \"").concat(value, "\" (").concat(typeof value, ")"));
+                    throw new Error(`Client supplied invalid type for ${this.props.format}: "${value}" (${typeof value})`);
                 }
-                var numericMin = maxWithUndefined(this.props.minValue, (0, request_util_1.numericLowerBound)(this.props.format));
-                var numericMax = minWithUndefined(this.props.maxValue, (0, request_util_1.numericUpperBound)(this.props.format));
+                const numericMin = maxWithUndefined(this.props.minValue, (0, request_util_1.numericLowerBound)(this.props.format));
+                const numericMax = minWithUndefined(this.props.maxValue, (0, request_util_1.numericUpperBound)(this.props.format));
                 if (typeof numericMin === "number" && value < numericMin) {
-                    throw new Error("Client supplied value of ".concat(value, " is less than the minimum allowed value of ").concat(numericMin));
+                    throw new Error(`Client supplied value of ${value} is less than the minimum allowed value of ${numericMin}`);
                 }
                 if (typeof numericMax === "number" && value > numericMax) {
-                    throw new Error("Client supplied value of ".concat(value, " is greater than the maximum allowed value of ").concat(numericMax));
+                    throw new Error(`Client supplied value of ${value} is greater than the maximum allowed value of ${numericMax}`);
                 }
                 if (this.props.validValues && !this.props.validValues.includes(value)) {
-                    throw new Error("Client supplied value of ".concat(value, " is not in ").concat(this.props.validValues.toString()));
+                    throw new Error(`Client supplied value of ${value} is not in ${this.props.validValues.toString()}`);
                 }
                 if (this.props.validValueRanges && this.props.validValueRanges.length === 2) {
                     if (value < this.props.validValueRanges[0]) {
-                        throw new Error("Client supplied value of ".concat(value, " is less than the minimum allowed value of ").concat(this.props.validValueRanges[0]));
+                        throw new Error(`Client supplied value of ${value} is less than the minimum allowed value of ${this.props.validValueRanges[0]}`);
                     }
                     if (value > this.props.validValueRanges[1]) {
-                        throw new Error("Client supplied value of ".concat(value, " is greater than the maximum allowed value of ").concat(this.props.validValueRanges[1]));
+                        throw new Error(`Client supplied value of ${value} is greater than the maximum allowed value of ${this.props.validValueRanges[1]}`);
                     }
                 }
                 return value;
             }
             case "string" /* Formats.STRING */: {
                 if (typeof value !== "string") {
-                    throw new Error("Client supplied invalid type for ".concat(this.props.format, ": \"").concat(value, "\" (").concat(typeof value, ")"));
+                    throw new Error(`Client supplied invalid type for ${this.props.format}: "${value}" (${typeof value})`);
                 }
-                var maxLength = this.props.maxLen != null ? this.props.maxLen : 64; // default is 64; max is 256 which is set in setProps
+                const maxLength = this.props.maxLen != null ? this.props.maxLen : 64; // default is 64; max is 256 which is set in setProps
                 if (value.length > maxLength) {
-                    throw new Error("Client supplied value length of ".concat(value.length, " exceeds maximum length allowed of ").concat(maxLength));
+                    throw new Error(`Client supplied value length of ${value.length} exceeds maximum length allowed of ${maxLength}`);
                 }
                 return value;
             }
             case "data" /* Formats.DATA */: {
                 if (typeof value !== "string") {
-                    throw new Error("Client supplied invalid type for ".concat(this.props.format, ": \"").concat(value, "\" (").concat(typeof value, ")"));
+                    throw new Error(`Client supplied invalid type for ${this.props.format}: "${value}" (${typeof value})`);
                 }
                 // we don't validate base64 here
-                var maxLength = this.props.maxDataLen != null ? this.props.maxDataLen : 0x200000; // default is 0x200000
+                const maxLength = this.props.maxDataLen != null ? this.props.maxDataLen : 0x200000; // default is 0x200000
                 if (value.length > maxLength) {
-                    throw new Error("Client supplied value length of ".concat(value.length, " exceeds maximum length allowed of ").concat(maxLength));
+                    throw new Error(`Client supplied value length of ${value.length} exceeds maximum length allowed of ${maxLength}`);
                 }
                 return value;
             }
             case "tlv8" /* Formats.TLV8 */:
                 if (typeof value !== "string") {
-                    throw new Error("Client supplied invalid type for ".concat(this.props.format, ": \"").concat(value, "\" (").concat(typeof value, ")"));
+                    throw new Error(`Client supplied invalid type for ${this.props.format}: "${value}" (${typeof value})`);
                 }
                 return value;
         }
         return value;
-    };
+    }
     /**
      * Checks if the value received from the API call is valid.
      * It adjusts the value where it makes sense, prints a warning where values may be rejected with an error
@@ -1166,9 +2099,7 @@ var Characteristic = /** @class */ (function (_super) {
      * @param value - The value received from the API call
      * @param warningType - Optionally defines the warning type to use when raising a {@link CharacteristicEventTypes.CHARACTERISTIC_WARNING}.
      */
-    Characteristic.prototype.validateUserInput = function (value, warningType) {
-        var _a;
-        if (warningType === void 0) { warningType = "warn-message" /* CharacteristicWarningType.WARN_MESSAGE */; }
+    validateUserInput(value, warningType = "warn-message" /* CharacteristicWarningType.WARN_MESSAGE */) {
         if (value === null) {
             if (this.UUID === Characteristic.Model.UUID || this.UUID === Characteristic.SerialNumber.UUID) { // mirrors the statement in case: Formats.STRING
                 this.characteristicWarning("characteristic must have a non null value otherwise HomeKit will reject this accessory, ignoring new value", "error-message" /* CharacteristicWarningType.ERROR_MESSAGE */);
@@ -1229,12 +2160,12 @@ var Characteristic = /** @class */ (function (_super) {
                     value = this.props.format === "float" /* Formats.FLOAT */ ? parseFloat(value) : parseInt(value, 10);
                 }
                 if (typeof value !== "number" || !Number.isFinite(value)) {
-                    this.characteristicWarning("characteristic value expected valid finite number and received \"".concat(value, "\" (").concat(typeof value, ")"), warningType);
+                    this.characteristicWarning(`characteristic value expected valid finite number and received "${value}" (${typeof value})`, warningType);
                     value = typeof this.value === "number" ? this.value : this.props.minValue || 0;
                 }
-                var numericMin = maxWithUndefined(this.props.minValue, (0, request_util_1.numericLowerBound)(this.props.format));
-                var numericMax = minWithUndefined(this.props.maxValue, (0, request_util_1.numericUpperBound)(this.props.format));
-                var stepValue = undefined;
+                const numericMin = maxWithUndefined(this.props.minValue, (0, request_util_1.numericLowerBound)(this.props.format));
+                const numericMax = minWithUndefined(this.props.maxValue, (0, request_util_1.numericUpperBound)(this.props.format));
+                let stepValue = undefined;
                 if (this.props.format === "float" /* Formats.FLOAT */) {
                     stepValue = this.props.minStep;
                 }
@@ -1242,28 +2173,30 @@ var Characteristic = /** @class */ (function (_super) {
                     stepValue = maxWithUndefined(this.props.minStep, 1);
                 }
                 if (stepValue != null && stepValue > 0) {
-                    var minValue = this.props.minValue != null ? this.props.minValue : 0;
+                    const minValue = this.props.minValue != null ? this.props.minValue : 0;
                     value = stepValue * Math.round((value - minValue) / stepValue) + minValue;
                 }
                 if (numericMin != null && value < numericMin) {
-                    this.characteristicWarning("characteristic was supplied illegal value: number ".concat(value, " exceeded minimum of ").concat(numericMin), warningType);
+                    this.characteristicWarning(`characteristic was supplied illegal value: number ${value} exceeded minimum of ${numericMin}`, warningType);
                     value = numericMin;
                 }
                 if (numericMax != null && value > numericMax) {
-                    this.characteristicWarning("characteristic was supplied illegal value: number ".concat(value, " exceeded maximum of ").concat(numericMax), warningType);
+                    this.characteristicWarning(`characteristic was supplied illegal value: number ${value} exceeded maximum of ${numericMax}`, warningType);
                     value = numericMax;
                 }
                 if (this.props.validValues && !this.props.validValues.includes(value)) {
-                    this.characteristicWarning("characteristic value ".concat(value, " is not contained in valid values array"), warningType);
+                    this.characteristicWarning(`characteristic value ${value} is not contained in valid values array`, warningType);
                     return this.props.validValues.includes(this.value) ? this.value : (this.props.validValues[0] || 0);
                 }
                 if (this.props.validValueRanges && this.props.validValueRanges.length === 2) {
                     if (value < this.props.validValueRanges[0]) {
-                        this.characteristicWarning("characteristic was supplied illegal value: number ".concat(value, " not contained in valid value range of           ").concat(this.props.validValueRanges, ", supplying illegal values will throw errors in the future"), warningType);
+                        this.characteristicWarning(`characteristic was supplied illegal value: number ${value} not contained in valid value range of `
+                            + `${this.props.validValueRanges}, supplying illegal values will throw errors in the future`, warningType);
                         value = this.props.validValueRanges[0];
                     }
                     else if (value > this.props.validValueRanges[1]) {
-                        this.characteristicWarning("characteristic was supplied illegal value: number ".concat(value, " not contained in valid value range of           ").concat(this.props.validValueRanges, ", supplying illegal values will throw errors in the future"), warningType);
+                        this.characteristicWarning(`characteristic was supplied illegal value: number ${value} not contained in valid value range of `
+                            + `${this.props.validValueRanges}, supplying illegal values will throw errors in the future`, warningType);
                         value = this.props.validValueRanges[1];
                     }
                 }
@@ -1281,13 +2214,13 @@ var Characteristic = /** @class */ (function (_super) {
                 }
                 // mirrors the case value = null at the beginning
                 if (value.length <= 1 && (this.UUID === Characteristic.Model.UUID || this.UUID === Characteristic.SerialNumber.UUID)) {
-                    this.characteristicWarning("[".concat(this.displayName, "] characteristic must have a length of more than 1 character otherwise")
-                        + " HomeKit will reject this accessory, ignoring new value ".concat(warningType));
+                    this.characteristicWarning(`[${this.displayName}] characteristic must have a length of more than 1 character otherwise`
+                        + ` HomeKit will reject this accessory, ignoring new value ${warningType}`);
                     return this.value; // just return the current value
                 }
-                var maxLength = (_a = this.props.maxLen) !== null && _a !== void 0 ? _a : 64; // default is 64 (max is 256 which is set in setProps)
+                const maxLength = this.props.maxLen ?? 64; // default is 64 (max is 256 which is set in setProps)
                 if (value.length > maxLength) {
-                    this.characteristicWarning("characteristic was supplied illegal value: string '".concat(value, "' exceeded max length of ").concat(maxLength), warningType);
+                    this.characteristicWarning(`characteristic was supplied illegal value: string '${value}' exceeded max length of ${maxLength}`, warningType);
                     value = value.substring(0, maxLength);
                 }
                 if (value.length > 0 && this.UUID === Characteristic.ConfiguredName.UUID) {
@@ -1317,109 +2250,88 @@ var Characteristic = /** @class */ (function (_super) {
             return this.value;
         }
         return value;
-    };
+    }
     /**
      * @private used to assign iid to characteristic
      */
-    Characteristic.prototype._assignID = function (identifierCache, accessoryName, serviceUUID, serviceSubtype) {
+    _assignID(identifierCache, accessoryName, serviceUUID, serviceSubtype) {
         // generate our IID based on our UUID
         this.iid = identifierCache.getIID(accessoryName, serviceUUID, serviceSubtype, this.UUID);
-    };
-    Characteristic.prototype.characteristicWarning = function (message, type, stack) {
-        if (type === void 0) { type = "warn-message" /* CharacteristicWarningType.WARN_MESSAGE */; }
-        if (stack === void 0) { stack = new Error().stack; }
+    }
+    characteristicWarning(message, type = "warn-message" /* CharacteristicWarningType.WARN_MESSAGE */, stack = new Error().stack) {
         this.emit("characteristic-warning" /* CharacteristicEventTypes.CHARACTERISTIC_WARNING */, type, message, stack);
-    };
+    }
     /**
      * @param event
      * @private
      */
-    Characteristic.prototype.removeAllListeners = function (event) {
+    removeAllListeners(event) {
         if (!event) {
             this.removeOnGet();
             this.removeOnSet();
         }
-        return _super.prototype.removeAllListeners.call(this, event);
-    };
+        return super.removeAllListeners(event);
+    }
     /**
      * @param characteristic
      * @private
      */
-    Characteristic.prototype.replaceBy = function (characteristic) {
-        var _this = this;
+    replaceBy(characteristic) {
         this.props = characteristic.props;
         this.updateValue(characteristic.value);
-        var getListeners = characteristic.listeners("get" /* CharacteristicEventTypes.GET */);
+        const getListeners = characteristic.listeners("get" /* CharacteristicEventTypes.GET */);
         if (getListeners.length) {
             // the callback can only be called once, so we remove all old listeners
             this.removeAllListeners("get" /* CharacteristicEventTypes.GET */);
             // @ts-expect-error: force type
-            getListeners.forEach(function (listener) { return _this.addListener("get" /* CharacteristicEventTypes.GET */, listener); });
+            getListeners.forEach(listener => this.addListener("get" /* CharacteristicEventTypes.GET */, listener));
         }
         this.removeOnGet();
         if (characteristic.getHandler) {
             this.onGet(characteristic.getHandler);
         }
-        var setListeners = characteristic.listeners("set" /* CharacteristicEventTypes.SET */);
+        const setListeners = characteristic.listeners("set" /* CharacteristicEventTypes.SET */);
         if (setListeners.length) {
             // the callback can only be called once, so we remove all old listeners
             this.removeAllListeners("set" /* CharacteristicEventTypes.SET */);
             // @ts-expect-error: force type
-            setListeners.forEach(function (listener) { return _this.addListener("set" /* CharacteristicEventTypes.SET */, listener); });
+            setListeners.forEach(listener => this.addListener("set" /* CharacteristicEventTypes.SET */, listener));
         }
         this.removeOnSet();
         if (characteristic.setHandler) {
             this.onSet(characteristic.setHandler);
         }
-    };
+    }
     /**
      * Returns a JSON representation of this characteristic suitable for delivering to HAP clients.
      * @private used to generate response to /accessories query
      */
-    Characteristic.prototype.toHAP = function (connection_1) {
-        return tslib_1.__awaiter(this, arguments, void 0, function (connection, contactGetHandlers) {
-            var object, value, _a;
-            var _this = this;
-            if (contactGetHandlers === void 0) { contactGetHandlers = true; }
-            return tslib_1.__generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0:
-                        object = this.internalHAPRepresentation();
-                        if (!!this.props.perms.includes("pr" /* Perms.PAIRED_READ */)) return [3 /*break*/, 1];
-                        object.value = undefined;
-                        return [3 /*break*/, 6];
-                    case 1:
-                        if (!(this.UUID === Characteristic.ProgrammableSwitchEvent.UUID)) return [3 /*break*/, 2];
-                        // special workaround for event only programmable switch event, which must always return null
-                        object.value = null;
-                        return [3 /*break*/, 6];
-                    case 2:
-                        if (!contactGetHandlers) return [3 /*break*/, 4];
-                        return [4 /*yield*/, this.handleGetRequest(connection).catch(function () {
-                                var value = _this.getDefaultValue();
-                                debug("[%s] Error getting value for characteristic on /accessories request. Returning default value instead: %s", _this.displayName, "".concat(value));
-                                return value; // use default value
-                            })];
-                    case 3:
-                        _a = _b.sent();
-                        return [3 /*break*/, 5];
-                    case 4:
-                        _a = this.value;
-                        _b.label = 5;
-                    case 5:
-                        value = _a;
-                        object.value = (0, request_util_1.formatOutgoingCharacteristicValue)(value, this.props);
-                        _b.label = 6;
-                    case 6: return [2 /*return*/, object];
-                }
-            });
-        });
-    };
+    async toHAP(connection, contactGetHandlers = true) {
+        const object = this.internalHAPRepresentation();
+        if (!this.props.perms.includes("pr" /* Perms.PAIRED_READ */)) {
+            object.value = undefined;
+        }
+        else if (this.UUID === Characteristic.ProgrammableSwitchEvent.UUID) {
+            // special workaround for event only programmable switch event, which must always return null
+            object.value = null;
+        }
+        else { // query the current value
+            const value = contactGetHandlers
+                ? await this.handleGetRequest(connection).catch(() => {
+                    const value = this.getDefaultValue();
+                    debug("[%s] Error getting value for characteristic on /accessories request. Returning default value instead: %s", this.displayName, `${value}`);
+                    return value; // use default value
+                })
+                : this.value;
+            object.value = (0, request_util_1.formatOutgoingCharacteristicValue)(value, this.props);
+        }
+        return object;
+    }
     /**
      * Returns a JSON representation of this characteristic without the value.
      * @private used to generate the config hash
      */
-    Characteristic.prototype.internalHAPRepresentation = function () {
+    internalHAPRepresentation() {
         (0, assert_1.default)(this.iid, "iid cannot be undefined for characteristic '" + this.displayName + "'");
         // TODO include the value for characteristics of the AccessoryInformation service
         return {
@@ -1438,15 +2350,15 @@ var Characteristic = /** @class */ (function (_super) {
             "valid-values": this.props.validValues,
             "valid-values-range": this.props.validValueRanges,
         };
-    };
+    }
     /**
      * Serialize characteristic into json string.
      *
      * @param characteristic - Characteristic object.
      * @private used to store characteristic on disk
      */
-    Characteristic.serialize = function (characteristic) {
-        var constructorName;
+    static serialize(characteristic) {
+        let constructorName;
         if (characteristic.constructor.name !== "Characteristic") {
             constructorName = characteristic.constructor.name;
         }
@@ -1458,18 +2370,18 @@ var Characteristic = /** @class */ (function (_super) {
             value: characteristic.value,
             props: (0, clone_1.clone)({}, characteristic.props),
         };
-    };
+    }
     /**
      * Deserialize characteristic from json string.
      *
      * @param json - Json string representing a characteristic.
      * @private used to recreate characteristic from disk
      */
-    Characteristic.deserialize = function (json) {
-        var characteristic;
+    static deserialize(json) {
+        let characteristic;
         if (json.constructorName && json.constructorName.charAt(0).toUpperCase() === json.constructorName.charAt(0)
             && Characteristic[json.constructorName]) { // MUST start with uppercase character and must exist on Characteristic object
-            var constructor = Characteristic[json.constructorName];
+            const constructor = Characteristic[json.constructorName];
             characteristic = new constructor();
             characteristic.displayName = json.displayName;
             characteristic.setProps(json.props);
@@ -1479,24 +2391,8 @@ var Characteristic = /** @class */ (function (_super) {
         }
         characteristic.value = json.value;
         return characteristic;
-    };
-    /**
-     * @deprecated Please use the Formats const enum above.
-     */
-    // @ts-expect-error: forceConsistentCasingInFileNames compiler option
-    Characteristic.Formats = Formats;
-    /**
-     * @deprecated Please use the Units const enum above.
-     */
-    // @ts-expect-error: forceConsistentCasingInFileNames compiler option
-    Characteristic.Units = Units;
-    /**
-     * @deprecated Please use the Perms const enum above.
-     */
-    // @ts-expect-error: forceConsistentCasingInFileNames compiler option
-    Characteristic.Perms = Perms;
-    return Characteristic;
-}(events_1.EventEmitter));
+    }
+}
 exports.Characteristic = Characteristic;
 // We have a cyclic dependency problem. Within this file we have the definitions of "./definitions" as
 // type imports only (in order to define the static properties). Setting those properties is done outside