@zwave-js/cc 14.0.0-beta.4 → 14.0.0-beta.5

package/build/cjs/cc/DoorLockCC.js

@@ -40,13 +40,45 @@ var import_CommandClass = require("../lib/CommandClass.js");
 var import_CommandClassDecorators = require("../lib/CommandClassDecorators.js");
 var import_Values = require("../lib/Values.js");
 var import_Types = require("../lib/_Types.js");
-var __decorate = function(decorators, target, key, desc) {
-  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-  return c > 3 && r && Object.defineProperty(target, key, r), r;
+var __esDecorate = function(ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+  function accept(f) {
+    if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected");
+    return f;
+  }
+  var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+  var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+  var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+  var _, done = false;
+  for (var i = decorators.length - 1; i >= 0; i--) {
+    var context = {};
+    for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+    for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+    context.addInitializer = function(f) {
+      if (done) throw new TypeError("Cannot add initializers after decoration has completed");
+      extraInitializers.push(accept(f || null));
+    };
+    var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+    if (kind === "accessor") {
+      if (result === void 0) continue;
+      if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+      if (_ = accept(result.get)) descriptor.get = _;
+      if (_ = accept(result.set)) descriptor.set = _;
+      if (_ = accept(result.init)) initializers.unshift(_);
+    } else if (_ = accept(result)) {
+      if (kind === "field") initializers.unshift(_);
+      else descriptor[key] = _;
+    }
+  }
+  if (target) Object.defineProperty(target, contextIn.name, descriptor);
+  done = true;
+};
+var __runInitializers = function(thisArg, initializers, value) {
+  var useValue = arguments.length > 2;
+  for (var i = 0; i < initializers.length; i++) {
+    value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+  }
+  return useValue ? value : void 0;
 };
-var DoorLockCCOperationReport_1, DoorLockCCConfigurationReport_1, DoorLockCCCapabilitiesReport_1;
 function __assertType(argName, typeName, boundHasError) {
   const { ZWaveError: ZWaveError2, ZWaveErrorCodes: ZWaveErrorCodes2 } = require("@zwave-js/core");
   if (boundHasError()) {
@@ -371,206 +403,237 @@ const configurationSetParameters = [
   "twistAssist",
   "blockToBlock"
 ];
-let DoorLockCCAPI = class DoorLockCCAPI2 extends import_API.PhysicalCCAPI {
-  supportsCommand(cmd) {
-    switch (cmd) {
-      case import_Types.DoorLockCommand.OperationSet:
-      case import_Types.DoorLockCommand.OperationGet:
-      case import_Types.DoorLockCommand.ConfigurationSet:
-      case import_Types.DoorLockCommand.ConfigurationGet:
-        return true;
-      // This is mandatory
-      case import_Types.DoorLockCommand.CapabilitiesGet:
-        return this.version >= 4;
+let DoorLockCCAPI = (() => {
+  let _classDecorators = [(0, import_CommandClassDecorators.API)(import_safe.CommandClasses["Door Lock"])];
+  let _classDescriptor;
+  let _classExtraInitializers = [];
+  let _classThis;
+  let _classSuper = import_API.PhysicalCCAPI;
+  var DoorLockCCAPI2 = class extends _classSuper {
+    static {
+      _classThis = this;
     }
-    return super.supportsCommand(cmd);
-  }
-  get [import_API.SET_VALUE]() {
-    return async function({ property }, value) {
-      if (property === "targetMode") {
-        if (typeof value !== "number") {
-          (0, import_API.throwWrongValueType)(this.ccId, property, "number", typeof value);
-        }
-        const result = await this.set(value);
-        if ((0, import_safe.supervisedCommandSucceeded)(result)) {
-          this.getValueDB().setValue(DoorLockCCValues.currentMode.endpoint(this.endpoint.index), value);
-        } else {
-          this.schedulePoll({ property }, value);
-        }
-        return result;
-      } else if (typeof property === "string" && configurationSetParameters.includes(property)) {
-        const config = {
-          [property]: value
-        };
-        for (const param of configurationSetParameters) {
-          if (param !== property) {
-            config[param] = this.tryGetValueDB()?.getValue({
-              commandClass: this.ccId,
-              endpoint: this.endpoint.index,
-              property: param
-            });
+    static {
+      const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+      __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+      DoorLockCCAPI2 = _classThis = _classDescriptor.value;
+      if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+      __runInitializers(_classThis, _classExtraInitializers);
+    }
+    supportsCommand(cmd) {
+      switch (cmd) {
+        case import_Types.DoorLockCommand.OperationSet:
+        case import_Types.DoorLockCommand.OperationGet:
+        case import_Types.DoorLockCommand.ConfigurationSet:
+        case import_Types.DoorLockCommand.ConfigurationGet:
+          return true;
+        // This is mandatory
+        case import_Types.DoorLockCommand.CapabilitiesGet:
+          return this.version >= 4;
+      }
+      return super.supportsCommand(cmd);
+    }
+    get [import_API.SET_VALUE]() {
+      return async function({ property }, value) {
+        if (property === "targetMode") {
+          if (typeof value !== "number") {
+            (0, import_API.throwWrongValueType)(this.ccId, property, "number", typeof value);
           }
+          const result = await this.set(value);
+          if ((0, import_safe.supervisedCommandSucceeded)(result)) {
+            this.getValueDB().setValue(DoorLockCCValues.currentMode.endpoint(this.endpoint.index), value);
+          } else {
+            this.schedulePoll({ property }, value);
+          }
+          return result;
+        } else if (typeof property === "string" && configurationSetParameters.includes(property)) {
+          const config = {
+            [property]: value
+          };
+          for (const param of configurationSetParameters) {
+            if (param !== property) {
+              config[param] = this.tryGetValueDB()?.getValue({
+                commandClass: this.ccId,
+                endpoint: this.endpoint.index,
+                property: param
+              });
+            }
+          }
+          const allTrue = [true, true, true, true];
+          if (!config.insideHandlesCanOpenDoorConfiguration) {
+            config.insideHandlesCanOpenDoorConfiguration = allTrue;
+          }
+          if (!config.outsideHandlesCanOpenDoorConfiguration) {
+            config.outsideHandlesCanOpenDoorConfiguration = allTrue;
+          }
+          const result = await this.setConfiguration(config);
+          if (!(0, import_safe.supervisedCommandSucceeded)(result)) {
+            this.schedulePoll({ property }, value);
+          }
+          return result;
+        } else {
+          (0, import_API.throwUnsupportedProperty)(this.ccId, property);
         }
-        const allTrue = [true, true, true, true];
-        if (!config.insideHandlesCanOpenDoorConfiguration) {
-          config.insideHandlesCanOpenDoorConfiguration = allTrue;
-        }
-        if (!config.outsideHandlesCanOpenDoorConfiguration) {
-          config.outsideHandlesCanOpenDoorConfiguration = allTrue;
-        }
-        const result = await this.setConfiguration(config);
-        if (!(0, import_safe.supervisedCommandSucceeded)(result)) {
-          this.schedulePoll({ property }, value);
+      };
+    }
+    get [import_API.POLL_VALUE]() {
+      return async function({ property }) {
+        switch (property) {
+          case "currentMode":
+          case "targetMode":
+          case "duration":
+          case "outsideHandlesCanOpenDoor":
+          case "insideHandlesCanOpenDoor":
+          case "latchStatus":
+          case "boltStatus":
+          case "doorStatus":
+          case "lockTimeout":
+            return (await this.get())?.[property];
+          case "operationType":
+          case "outsideHandlesCanOpenDoorConfiguration":
+          case "insideHandlesCanOpenDoorConfiguration":
+          case "lockTimeoutConfiguration":
+          case "autoRelockTime":
+          case "holdAndReleaseTime":
+          case "twistAssist":
+          case "blockToBlock":
+            return (await this.getConfiguration())?.[property];
+          default:
+            (0, import_API.throwUnsupportedProperty)(this.ccId, property);
         }
-        return result;
-      } else {
-        (0, import_API.throwUnsupportedProperty)(this.ccId, property);
+      };
+    }
+    // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
+    async getCapabilities() {
+      this.assertSupportsCommand(import_Types.DoorLockCommand, import_Types.DoorLockCommand.CapabilitiesGet);
+      const cc = new DoorLockCCCapabilitiesGet({
+        nodeId: this.endpoint.nodeId,
+        endpointIndex: this.endpoint.index
+      });
+      const response = await this.host.sendCommand(cc, this.commandOptions);
+      if (response) {
+        return (0, import_safe3.pick)(response, [
+          "autoRelockSupported",
+          "blockToBlockSupported",
+          "boltSupported",
+          "doorSupported",
+          "holdAndReleaseSupported",
+          "latchSupported",
+          "twistAssistSupported",
+          "supportedDoorLockModes",
+          "supportedInsideHandles",
+          "supportedOperationTypes",
+          "supportedOutsideHandles"
+        ]);
       }
-    };
-  }
-  get [import_API.POLL_VALUE]() {
-    return async function({ property }) {
-      switch (property) {
-        case "currentMode":
-        case "targetMode":
-        case "duration":
-        case "outsideHandlesCanOpenDoor":
-        case "insideHandlesCanOpenDoor":
-        case "latchStatus":
-        case "boltStatus":
-        case "doorStatus":
-        case "lockTimeout":
-          return (await this.get())?.[property];
-        case "operationType":
-        case "outsideHandlesCanOpenDoorConfiguration":
-        case "insideHandlesCanOpenDoorConfiguration":
-        case "lockTimeoutConfiguration":
-        case "autoRelockTime":
-        case "holdAndReleaseTime":
-        case "twistAssist":
-        case "blockToBlock":
-          return (await this.getConfiguration())?.[property];
-        default:
-          (0, import_API.throwUnsupportedProperty)(this.ccId, property);
+    }
+    // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
+    async get() {
+      this.assertSupportsCommand(import_Types.DoorLockCommand, import_Types.DoorLockCommand.OperationGet);
+      const cc = new DoorLockCCOperationGet({
+        nodeId: this.endpoint.nodeId,
+        endpointIndex: this.endpoint.index
+      });
+      const response = await this.host.sendCommand(cc, this.commandOptions);
+      if (response) {
+        return (0, import_safe3.pick)(response, [
+          "currentMode",
+          "targetMode",
+          "duration",
+          "outsideHandlesCanOpenDoor",
+          "insideHandlesCanOpenDoor",
+          "latchStatus",
+          "boltStatus",
+          "doorStatus",
+          "lockTimeout"
+        ]);
       }
-    };
-  }
-  // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
-  async getCapabilities() {
-    this.assertSupportsCommand(import_Types.DoorLockCommand, import_Types.DoorLockCommand.CapabilitiesGet);
-    const cc = new DoorLockCCCapabilitiesGet({
-      nodeId: this.endpoint.nodeId,
-      endpointIndex: this.endpoint.index
-    });
-    const response = await this.host.sendCommand(cc, this.commandOptions);
-    if (response) {
-      return (0, import_safe3.pick)(response, [
-        "autoRelockSupported",
-        "blockToBlockSupported",
-        "boltSupported",
-        "doorSupported",
-        "holdAndReleaseSupported",
-        "latchSupported",
-        "twistAssistSupported",
-        "supportedDoorLockModes",
-        "supportedInsideHandles",
-        "supportedOperationTypes",
-        "supportedOutsideHandles"
-      ]);
     }
-  }
-  // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
-  async get() {
-    this.assertSupportsCommand(import_Types.DoorLockCommand, import_Types.DoorLockCommand.OperationGet);
-    const cc = new DoorLockCCOperationGet({
-      nodeId: this.endpoint.nodeId,
-      endpointIndex: this.endpoint.index
-    });
-    const response = await this.host.sendCommand(cc, this.commandOptions);
-    if (response) {
-      return (0, import_safe3.pick)(response, [
-        "currentMode",
-        "targetMode",
-        "duration",
-        "outsideHandlesCanOpenDoor",
-        "insideHandlesCanOpenDoor",
-        "latchStatus",
-        "boltStatus",
-        "doorStatus",
-        "lockTimeout"
-      ]);
+    async set(mode) {
+      __assertType("mode", "DoorLockMode", __assertType__DoorLockMode.bind(void 0, mode));
+      this.assertSupportsCommand(import_Types.DoorLockCommand, import_Types.DoorLockCommand.OperationSet);
+      const cc = new DoorLockCCOperationSet({
+        nodeId: this.endpoint.nodeId,
+        endpointIndex: this.endpoint.index,
+        mode
+      });
+      return this.host.sendCommand(cc, this.commandOptions);
     }
-  }
-  async set(mode) {
-    __assertType("mode", "DoorLockMode", __assertType__DoorLockMode.bind(void 0, mode));
-    this.assertSupportsCommand(import_Types.DoorLockCommand, import_Types.DoorLockCommand.OperationSet);
-    const cc = new DoorLockCCOperationSet({
-      nodeId: this.endpoint.nodeId,
-      endpointIndex: this.endpoint.index,
-      mode
-    });
-    return this.host.sendCommand(cc, this.commandOptions);
-  }
-  async setConfiguration(configuration) {
-    __assertType("configuration", "DoorLockCCConfigurationSetOptions", __assertType__DoorLockCCConfigurationSetOptions.bind(void 0, configuration));
-    this.assertSupportsCommand(import_Types.DoorLockCommand, import_Types.DoorLockCommand.ConfigurationSet);
-    const cc = new DoorLockCCConfigurationSet({
-      nodeId: this.endpoint.nodeId,
-      endpointIndex: this.endpoint.index,
-      ...configuration
-    });
-    return this.host.sendCommand(cc, this.commandOptions);
-  }
-  // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
-  async getConfiguration() {
-    this.assertSupportsCommand(import_Types.DoorLockCommand, import_Types.DoorLockCommand.ConfigurationGet);
-    const cc = new DoorLockCCConfigurationGet({
-      nodeId: this.endpoint.nodeId,
-      endpointIndex: this.endpoint.index
-    });
-    const response = await this.host.sendCommand(cc, this.commandOptions);
-    if (response) {
-      return (0, import_safe3.pick)(response, [
-        "operationType",
-        "outsideHandlesCanOpenDoorConfiguration",
-        "insideHandlesCanOpenDoorConfiguration",
-        "lockTimeoutConfiguration",
-        "autoRelockTime",
-        "holdAndReleaseTime",
-        "twistAssist",
-        "blockToBlock"
-      ]);
+    async setConfiguration(configuration) {
+      __assertType("configuration", "DoorLockCCConfigurationSetOptions", __assertType__DoorLockCCConfigurationSetOptions.bind(void 0, configuration));
+      this.assertSupportsCommand(import_Types.DoorLockCommand, import_Types.DoorLockCommand.ConfigurationSet);
+      const cc = new DoorLockCCConfigurationSet({
+        nodeId: this.endpoint.nodeId,
+        endpointIndex: this.endpoint.index,
+        ...configuration
+      });
+      return this.host.sendCommand(cc, this.commandOptions);
     }
-  }
-};
-DoorLockCCAPI = __decorate([
-  (0, import_CommandClassDecorators.API)(import_safe.CommandClasses["Door Lock"])
-], DoorLockCCAPI);
-let DoorLockCC = class DoorLockCC2 extends import_CommandClass.CommandClass {
-  async interview(ctx) {
-    const node = this.getNode(ctx);
-    const endpoint = this.getEndpoint(ctx);
-    const api = import_API.CCAPI.create(import_safe.CommandClasses["Door Lock"], ctx, endpoint).withOptions({
-      priority: import_safe.MessagePriority.NodeQuery
-    });
-    ctx.logNode(node.id, {
-      endpoint: this.endpointIndex,
-      message: `Interviewing ${this.ccName}...`,
-      direction: "none"
-    });
-    let hadCriticalTimeout = false;
-    let doorSupported = true;
-    let boltSupported = true;
-    let latchSupported = true;
-    if (api.version >= 4) {
+    // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
+    async getConfiguration() {
+      this.assertSupportsCommand(import_Types.DoorLockCommand, import_Types.DoorLockCommand.ConfigurationGet);
+      const cc = new DoorLockCCConfigurationGet({
+        nodeId: this.endpoint.nodeId,
+        endpointIndex: this.endpoint.index
+      });
+      const response = await this.host.sendCommand(cc, this.commandOptions);
+      if (response) {
+        return (0, import_safe3.pick)(response, [
+          "operationType",
+          "outsideHandlesCanOpenDoorConfiguration",
+          "insideHandlesCanOpenDoorConfiguration",
+          "lockTimeoutConfiguration",
+          "autoRelockTime",
+          "holdAndReleaseTime",
+          "twistAssist",
+          "blockToBlock"
+        ]);
+      }
+    }
+  };
+  return DoorLockCCAPI2 = _classThis;
+})();
+let DoorLockCC = (() => {
+  let _classDecorators = [(0, import_CommandClassDecorators.commandClass)(import_safe.CommandClasses["Door Lock"]), (0, import_CommandClassDecorators.implementedVersion)(4), (0, import_CommandClassDecorators.ccValues)(DoorLockCCValues)];
+  let _classDescriptor;
+  let _classExtraInitializers = [];
+  let _classThis;
+  let _classSuper = import_CommandClass.CommandClass;
+  var DoorLockCC2 = class extends _classSuper {
+    static {
+      _classThis = this;
+    }
+    static {
+      const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+      __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+      DoorLockCC2 = _classThis = _classDescriptor.value;
+      if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+      __runInitializers(_classThis, _classExtraInitializers);
+    }
+    async interview(ctx) {
+      const node = this.getNode(ctx);
+      const endpoint = this.getEndpoint(ctx);
+      const api = import_API.CCAPI.create(import_safe.CommandClasses["Door Lock"], ctx, endpoint).withOptions({
+        priority: import_safe.MessagePriority.NodeQuery
+      });
       ctx.logNode(node.id, {
         endpoint: this.endpointIndex,
-        message: "requesting lock capabilities...",
-        direction: "outbound"
+        message: `Interviewing ${this.ccName}...`,
+        direction: "none"
       });
-      const resp = await api.getCapabilities();
-      if (resp) {
-        const logMessage = `received lock capabilities:
+      let hadCriticalTimeout = false;
+      let doorSupported = true;
+      let boltSupported = true;
+      let latchSupported = true;
+      if (api.version >= 4) {
+        ctx.logNode(node.id, {
+          endpoint: this.endpointIndex,
+          message: "requesting lock capabilities...",
+          direction: "outbound"
+        });
+        const resp = await api.getCapabilities();
+        if (resp) {
+          const logMessage = `received lock capabilities:
 supported operation types: ${resp.supportedOperationTypes.map((t) => (0, import_safe3.getEnumMemberName)(import_Types.DoorLockOperationType, t)).join(", ")}
 supported door lock modes: ${resp.supportedDoorLockModes.map((t) => (0, import_safe3.getEnumMemberName)(import_Types.DoorLockMode, t)).map((str) => `
 \xB7 ${str}`).join("")}
@@ -583,645 +646,709 @@ supports auto-relock:      ${resp.autoRelockSupported}
 supports hold-and-release: ${resp.holdAndReleaseSupported}
 supports twist assist:     ${resp.twistAssistSupported}
 supports block to block:   ${resp.blockToBlockSupported}`;
-        ctx.logNode(node.id, {
-          endpoint: this.endpointIndex,
-          message: logMessage,
-          direction: "inbound"
-        });
-        doorSupported = resp.doorSupported;
-        boltSupported = resp.boltSupported;
-        latchSupported = resp.latchSupported;
-        const targetModeValue = DoorLockCCValues.targetMode;
-        this.setMetadata(ctx, targetModeValue, {
-          ...targetModeValue.meta,
-          states: (0, import_safe.enumValuesToMetadataStates)(import_Types.DoorLockMode, resp.supportedDoorLockModes)
-        });
-        const operationTypeValue = DoorLockCCValues.operationType;
-        this.setMetadata(ctx, operationTypeValue, {
-          ...operationTypeValue.meta,
-          states: (0, import_safe.enumValuesToMetadataStates)(import_Types.DoorLockOperationType, resp.supportedOperationTypes)
-        });
-      } else {
-        hadCriticalTimeout = true;
+          ctx.logNode(node.id, {
+            endpoint: this.endpointIndex,
+            message: logMessage,
+            direction: "inbound"
+          });
+          doorSupported = resp.doorSupported;
+          boltSupported = resp.boltSupported;
+          latchSupported = resp.latchSupported;
+          const targetModeValue = DoorLockCCValues.targetMode;
+          this.setMetadata(ctx, targetModeValue, {
+            ...targetModeValue.meta,
+            states: (0, import_safe.enumValuesToMetadataStates)(import_Types.DoorLockMode, resp.supportedDoorLockModes)
+          });
+          const operationTypeValue = DoorLockCCValues.operationType;
+          this.setMetadata(ctx, operationTypeValue, {
+            ...operationTypeValue.meta,
+            states: (0, import_safe.enumValuesToMetadataStates)(import_Types.DoorLockOperationType, resp.supportedOperationTypes)
+          });
+        } else {
+          hadCriticalTimeout = true;
+        }
       }
+      if (!hadCriticalTimeout) {
+        const doorStatusValue = DoorLockCCValues.doorStatus;
+        if (doorSupported)
+          this.setMetadata(ctx, doorStatusValue);
+        this.setValue(ctx, DoorLockCCValues.doorSupported, doorSupported);
+        const latchStatusValue = DoorLockCCValues.latchStatus;
+        if (latchSupported)
+          this.setMetadata(ctx, latchStatusValue);
+        this.setValue(ctx, DoorLockCCValues.latchSupported, latchSupported);
+        const boltStatusValue = DoorLockCCValues.boltStatus;
+        if (boltSupported)
+          this.setMetadata(ctx, boltStatusValue);
+        this.setValue(ctx, DoorLockCCValues.boltSupported, boltSupported);
+      }
+      await this.refreshValues(ctx);
+      if (!hadCriticalTimeout)
+        this.setInterviewComplete(ctx, true);
     }
-    if (!hadCriticalTimeout) {
-      const doorStatusValue = DoorLockCCValues.doorStatus;
-      if (doorSupported)
-        this.setMetadata(ctx, doorStatusValue);
-      this.setValue(ctx, DoorLockCCValues.doorSupported, doorSupported);
-      const latchStatusValue = DoorLockCCValues.latchStatus;
-      if (latchSupported)
-        this.setMetadata(ctx, latchStatusValue);
-      this.setValue(ctx, DoorLockCCValues.latchSupported, latchSupported);
-      const boltStatusValue = DoorLockCCValues.boltStatus;
-      if (boltSupported)
-        this.setMetadata(ctx, boltStatusValue);
-      this.setValue(ctx, DoorLockCCValues.boltSupported, boltSupported);
-    }
-    await this.refreshValues(ctx);
-    if (!hadCriticalTimeout)
-      this.setInterviewComplete(ctx, true);
-  }
-  async refreshValues(ctx) {
-    const node = this.getNode(ctx);
-    const endpoint = this.getEndpoint(ctx);
-    const api = import_API.CCAPI.create(import_safe.CommandClasses["Door Lock"], ctx, endpoint).withOptions({
-      priority: import_safe.MessagePriority.NodeQuery
-    });
-    ctx.logNode(node.id, {
-      endpoint: this.endpointIndex,
-      message: "requesting lock configuration...",
-      direction: "outbound"
-    });
-    const config = await api.getConfiguration();
-    if (config) {
-      let logMessage = `received lock configuration:
+    async refreshValues(ctx) {
+      const node = this.getNode(ctx);
+      const endpoint = this.getEndpoint(ctx);
+      const api = import_API.CCAPI.create(import_safe.CommandClasses["Door Lock"], ctx, endpoint).withOptions({
+        priority: import_safe.MessagePriority.NodeQuery
+      });
+      ctx.logNode(node.id, {
+        endpoint: this.endpointIndex,
+        message: "requesting lock configuration...",
+        direction: "outbound"
+      });
+      const config = await api.getConfiguration();
+      if (config) {
+        let logMessage = `received lock configuration:
 operation type:                ${(0, import_safe3.getEnumMemberName)(import_Types.DoorLockOperationType, config.operationType)}`;
-      if (config.operationType === import_Types.DoorLockOperationType.Timed) {
-        logMessage += `
+        if (config.operationType === import_Types.DoorLockOperationType.Timed) {
+          logMessage += `
 lock timeout:                  ${config.lockTimeoutConfiguration} seconds
 `;
-      }
-      logMessage += `
+        }
+        logMessage += `
 outside handles can open door: ${config.outsideHandlesCanOpenDoorConfiguration.map(String).join(", ")}
 inside handles can open door:  ${config.insideHandlesCanOpenDoorConfiguration.map(String).join(", ")}`;
-      if (api.version >= 4) {
-        logMessage += `
+        if (api.version >= 4) {
+          logMessage += `
 auto-relock time               ${config.autoRelockTime ?? "-"} seconds
 hold-and-release time          ${config.holdAndReleaseTime ?? "-"} seconds
 twist assist                   ${!!config.twistAssist}
 block to block                 ${!!config.blockToBlock}`;
+        }
+        ctx.logNode(node.id, {
+          endpoint: this.endpointIndex,
+          message: logMessage,
+          direction: "inbound"
+        });
       }
       ctx.logNode(node.id, {
         endpoint: this.endpointIndex,
-        message: logMessage,
-        direction: "inbound"
+        message: "requesting current lock status...",
+        direction: "outbound"
       });
-    }
-    ctx.logNode(node.id, {
-      endpoint: this.endpointIndex,
-      message: "requesting current lock status...",
-      direction: "outbound"
-    });
-    const status = await api.get();
-    if (status) {
-      let logMessage = `received lock status:
+      const status = await api.get();
+      if (status) {
+        let logMessage = `received lock status:
 current mode:       ${(0, import_safe3.getEnumMemberName)(import_Types.DoorLockMode, status.currentMode)}`;
-      if (status.targetMode != void 0) {
-        logMessage += `
+        if (status.targetMode != void 0) {
+          logMessage += `
 target mode:        ${(0, import_safe3.getEnumMemberName)(import_Types.DoorLockMode, status.targetMode)}
 remaining duration: ${status.duration?.toString() ?? "undefined"}`;
-      }
-      if (status.lockTimeout != void 0) {
-        logMessage += `
+        }
+        if (status.lockTimeout != void 0) {
+          logMessage += `
 lock timeout:       ${status.lockTimeout} seconds`;
-      }
-      if (status.doorStatus != void 0) {
-        logMessage += `
+        }
+        if (status.doorStatus != void 0) {
+          logMessage += `
 door status:        ${status.doorStatus}`;
-      }
-      if (status.boltStatus != void 0) {
-        logMessage += `
+        }
+        if (status.boltStatus != void 0) {
+          logMessage += `
 bolt status:        ${status.boltStatus}`;
-      }
-      if (status.latchStatus != void 0) {
-        logMessage += `
+        }
+        if (status.latchStatus != void 0) {
+          logMessage += `
 latch status:       ${status.latchStatus}`;
+        }
+        ctx.logNode(node.id, {
+          endpoint: this.endpointIndex,
+          message: logMessage,
+          direction: "inbound"
+        });
       }
-      ctx.logNode(node.id, {
-        endpoint: this.endpointIndex,
-        message: logMessage,
-        direction: "inbound"
-      });
     }
-  }
-};
-DoorLockCC = __decorate([
-  (0, import_CommandClassDecorators.commandClass)(import_safe.CommandClasses["Door Lock"]),
-  (0, import_CommandClassDecorators.implementedVersion)(4),
-  (0, import_CommandClassDecorators.ccValues)(DoorLockCCValues)
-], DoorLockCC);
-let DoorLockCCOperationSet = class DoorLockCCOperationSet2 extends DoorLockCC {
-  constructor(options) {
-    super(options);
-    if (options.mode === import_Types.DoorLockMode.Unknown) {
-      throw new import_safe.ZWaveError(`Unknown is not a valid door lock target state!`, import_safe.ZWaveErrorCodes.Argument_Invalid);
+  };
+  return DoorLockCC2 = _classThis;
+})();
+let DoorLockCCOperationSet = (() => {
+  let _classDecorators = [(0, import_CommandClassDecorators.CCCommand)(import_Types.DoorLockCommand.OperationSet), (0, import_CommandClassDecorators.useSupervision)()];
+  let _classDescriptor;
+  let _classExtraInitializers = [];
+  let _classThis;
+  let _classSuper = DoorLockCC;
+  var DoorLockCCOperationSet2 = class extends _classSuper {
+    static {
+      _classThis = this;
     }
-    this.mode = options.mode;
-  }
-  static from(_raw, _ctx) {
-    throw new import_safe.ZWaveError(`${this.name}: deserialization not implemented`, import_safe.ZWaveErrorCodes.Deserialization_NotImplemented);
-  }
-  mode;
-  serialize(ctx) {
-    this.payload = import_safe2.Bytes.from([this.mode]);
-    return super.serialize(ctx);
-  }
-  toLogEntry(ctx) {
-    return {
-      ...super.toLogEntry(ctx),
-      message: {
-        "target mode": (0, import_safe3.getEnumMemberName)(import_Types.DoorLockMode, this.mode)
+    static {
+      const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+      __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+      DoorLockCCOperationSet2 = _classThis = _classDescriptor.value;
+      if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+      __runInitializers(_classThis, _classExtraInitializers);
+    }
+    constructor(options) {
+      super(options);
+      if (options.mode === import_Types.DoorLockMode.Unknown) {
+        throw new import_safe.ZWaveError(`Unknown is not a valid door lock target state!`, import_safe.ZWaveErrorCodes.Argument_Invalid);
       }
-    };
-  }
-};
-DoorLockCCOperationSet = __decorate([
-  (0, import_CommandClassDecorators.CCCommand)(import_Types.DoorLockCommand.OperationSet),
-  (0, import_CommandClassDecorators.useSupervision)()
-], DoorLockCCOperationSet);
-let DoorLockCCOperationReport = DoorLockCCOperationReport_1 = class DoorLockCCOperationReport2 extends DoorLockCC {
-  constructor(options) {
-    super(options);
-    this.currentMode = options.currentMode;
-    this.outsideHandlesCanOpenDoor = options.outsideHandlesCanOpenDoor;
-    this.insideHandlesCanOpenDoor = options.insideHandlesCanOpenDoor;
-    this.doorStatus = options.doorStatus;
-    this.boltStatus = options.boltStatus;
-    this.latchStatus = options.latchStatus;
-    this.lockTimeout = options.lockTimeout;
-    this.targetMode = options.targetMode;
-    this.duration = options.duration;
-  }
-  static from(raw, ctx) {
-    (0, import_safe.validatePayload)(raw.payload.length >= 5);
-    const currentMode = raw.payload[0];
-    const outsideHandlesCanOpenDoor = [
-      !!(raw.payload[1] & 16),
-      !!(raw.payload[1] & 32),
-      !!(raw.payload[1] & 64),
-      !!(raw.payload[1] & 128)
-    ];
-    const insideHandlesCanOpenDoor = [
-      !!(raw.payload[1] & 1),
-      !!(raw.payload[1] & 2),
-      !!(raw.payload[1] & 4),
-      !!(raw.payload[1] & 8)
-    ];
-    const doorStatus = !!(raw.payload[2] & 1) ? "closed" : "open";
-    const boltStatus = !!(raw.payload[2] & 2) ? "unlocked" : "locked";
-    const latchStatus = !!(raw.payload[2] & 4) ? "closed" : "open";
-    const lockTimeoutMinutes = raw.payload[3];
-    const lockTimeoutSeconds = raw.payload[4];
-    let lockTimeout;
-    if (lockTimeoutMinutes <= 253 && lockTimeoutSeconds <= 59) {
-      lockTimeout = lockTimeoutSeconds + lockTimeoutMinutes * 60;
+      this.mode = options.mode;
     }
-    let targetMode;
-    let duration;
-    if (raw.payload.length >= 7) {
-      targetMode = raw.payload[5];
-      duration = import_safe.Duration.parseReport(raw.payload[6]);
+    static from(_raw, _ctx) {
+      throw new import_safe.ZWaveError(`${this.name}: deserialization not implemented`, import_safe.ZWaveErrorCodes.Deserialization_NotImplemented);
     }
-    return new DoorLockCCOperationReport_1({
-      nodeId: ctx.sourceNodeId,
-      currentMode,
-      outsideHandlesCanOpenDoor,
-      insideHandlesCanOpenDoor,
-      doorStatus,
-      boltStatus,
-      latchStatus,
-      lockTimeout,
-      targetMode,
-      duration
-    });
-  }
-  persistValues(ctx) {
-    if (!super.persistValues(ctx))
-      return false;
-    const supportsDoorStatus = !!this.getValue(ctx, DoorLockCCValues.doorSupported);
-    if (supportsDoorStatus) {
-      this.setValue(ctx, DoorLockCCValues.doorStatus, this.doorStatus);
+    mode;
+    serialize(ctx) {
+      this.payload = import_safe2.Bytes.from([this.mode]);
+      return super.serialize(ctx);
     }
-    const supportsBoltStatus = !!this.getValue(ctx, DoorLockCCValues.boltSupported);
-    if (supportsBoltStatus) {
-      this.setValue(ctx, DoorLockCCValues.boltStatus, this.boltStatus);
+    toLogEntry(ctx) {
+      return {
+        ...super.toLogEntry(ctx),
+        message: {
+          "target mode": (0, import_safe3.getEnumMemberName)(import_Types.DoorLockMode, this.mode)
+        }
+      };
     }
-    const supportsLatchStatus = !!this.getValue(ctx, DoorLockCCValues.latchSupported);
-    if (supportsLatchStatus) {
-      this.setValue(ctx, DoorLockCCValues.latchStatus, this.latchStatus);
+  };
+  return DoorLockCCOperationSet2 = _classThis;
+})();
+let DoorLockCCOperationReport = (() => {
+  let _classDecorators = [(0, import_CommandClassDecorators.CCCommand)(import_Types.DoorLockCommand.OperationReport), (0, import_CommandClassDecorators.ccValueProperty)("currentMode", DoorLockCCValues.currentMode), (0, import_CommandClassDecorators.ccValueProperty)("targetMode", DoorLockCCValues.targetMode), (0, import_CommandClassDecorators.ccValueProperty)("duration", DoorLockCCValues.duration), (0, import_CommandClassDecorators.ccValueProperty)("outsideHandlesCanOpenDoor", DoorLockCCValues.outsideHandlesCanOpenDoor), (0, import_CommandClassDecorators.ccValueProperty)("insideHandlesCanOpenDoor", DoorLockCCValues.insideHandlesCanOpenDoor), (0, import_CommandClassDecorators.ccValueProperty)("lockTimeout", DoorLockCCValues.lockTimeout)];
+  let _classDescriptor;
+  let _classExtraInitializers = [];
+  let _classThis;
+  let _classSuper = DoorLockCC;
+  var DoorLockCCOperationReport2 = class extends _classSuper {
+    static {
+      _classThis = this;
     }
-    return true;
-  }
-  currentMode;
-  targetMode;
-  duration;
-  outsideHandlesCanOpenDoor;
-  insideHandlesCanOpenDoor;
-  latchStatus;
-  boltStatus;
-  doorStatus;
-  lockTimeout;
-  // in seconds
-  toLogEntry(ctx) {
-    const message = {
-      "current mode": (0, import_safe3.getEnumMemberName)(import_Types.DoorLockMode, this.currentMode),
-      "active outside handles": this.outsideHandlesCanOpenDoor.join(", "),
-      "active inside handles": this.insideHandlesCanOpenDoor.join(", ")
-    };
-    if (this.latchStatus != void 0) {
-      message["latch status"] = this.latchStatus;
+    static {
+      const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+      __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+      DoorLockCCOperationReport2 = _classThis = _classDescriptor.value;
+      if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+      __runInitializers(_classThis, _classExtraInitializers);
     }
-    if (this.boltStatus != void 0) {
-      message["bolt status"] = this.boltStatus;
+    constructor(options) {
+      super(options);
+      this.currentMode = options.currentMode;
+      this.outsideHandlesCanOpenDoor = options.outsideHandlesCanOpenDoor;
+      this.insideHandlesCanOpenDoor = options.insideHandlesCanOpenDoor;
+      this.doorStatus = options.doorStatus;
+      this.boltStatus = options.boltStatus;
+      this.latchStatus = options.latchStatus;
+      this.lockTimeout = options.lockTimeout;
+      this.targetMode = options.targetMode;
+      this.duration = options.duration;
     }
-    if (this.doorStatus != void 0) {
-      message["door status"] = this.doorStatus;
+    static from(raw, ctx) {
+      (0, import_safe.validatePayload)(raw.payload.length >= 5);
+      const currentMode = raw.payload[0];
+      const outsideHandlesCanOpenDoor = [
+        !!(raw.payload[1] & 16),
+        !!(raw.payload[1] & 32),
+        !!(raw.payload[1] & 64),
+        !!(raw.payload[1] & 128)
+      ];
+      const insideHandlesCanOpenDoor = [
+        !!(raw.payload[1] & 1),
+        !!(raw.payload[1] & 2),
+        !!(raw.payload[1] & 4),
+        !!(raw.payload[1] & 8)
+      ];
+      const doorStatus = !!(raw.payload[2] & 1) ? "closed" : "open";
+      const boltStatus = !!(raw.payload[2] & 2) ? "unlocked" : "locked";
+      const latchStatus = !!(raw.payload[2] & 4) ? "closed" : "open";
+      const lockTimeoutMinutes = raw.payload[3];
+      const lockTimeoutSeconds = raw.payload[4];
+      let lockTimeout;
+      if (lockTimeoutMinutes <= 253 && lockTimeoutSeconds <= 59) {
+        lockTimeout = lockTimeoutSeconds + lockTimeoutMinutes * 60;
+      }
+      let targetMode;
+      let duration;
+      if (raw.payload.length >= 7) {
+        targetMode = raw.payload[5];
+        duration = import_safe.Duration.parseReport(raw.payload[6]);
+      }
+      return new this({
+        nodeId: ctx.sourceNodeId,
+        currentMode,
+        outsideHandlesCanOpenDoor,
+        insideHandlesCanOpenDoor,
+        doorStatus,
+        boltStatus,
+        latchStatus,
+        lockTimeout,
+        targetMode,
+        duration
+      });
     }
-    if (this.targetMode != void 0) {
-      message["target mode"] = (0, import_safe3.getEnumMemberName)(import_Types.DoorLockMode, this.targetMode);
+    persistValues(ctx) {
+      if (!super.persistValues(ctx))
+        return false;
+      const supportsDoorStatus = !!this.getValue(ctx, DoorLockCCValues.doorSupported);
+      if (supportsDoorStatus) {
+        this.setValue(ctx, DoorLockCCValues.doorStatus, this.doorStatus);
+      }
+      const supportsBoltStatus = !!this.getValue(ctx, DoorLockCCValues.boltSupported);
+      if (supportsBoltStatus) {
+        this.setValue(ctx, DoorLockCCValues.boltStatus, this.boltStatus);
+      }
+      const supportsLatchStatus = !!this.getValue(ctx, DoorLockCCValues.latchSupported);
+      if (supportsLatchStatus) {
+        this.setValue(ctx, DoorLockCCValues.latchStatus, this.latchStatus);
+      }
+      return true;
     }
-    if (this.duration != void 0) {
-      message["remaining duration"] = this.duration.toString();
+    currentMode;
+    targetMode;
+    duration;
+    outsideHandlesCanOpenDoor;
+    insideHandlesCanOpenDoor;
+    latchStatus;
+    boltStatus;
+    doorStatus;
+    lockTimeout;
+    // in seconds
+    toLogEntry(ctx) {
+      const message = {
+        "current mode": (0, import_safe3.getEnumMemberName)(import_Types.DoorLockMode, this.currentMode),
+        "active outside handles": this.outsideHandlesCanOpenDoor.join(", "),
+        "active inside handles": this.insideHandlesCanOpenDoor.join(", ")
+      };
+      if (this.latchStatus != void 0) {
+        message["latch status"] = this.latchStatus;
+      }
+      if (this.boltStatus != void 0) {
+        message["bolt status"] = this.boltStatus;
+      }
+      if (this.doorStatus != void 0) {
+        message["door status"] = this.doorStatus;
+      }
+      if (this.targetMode != void 0) {
+        message["target mode"] = (0, import_safe3.getEnumMemberName)(import_Types.DoorLockMode, this.targetMode);
+      }
+      if (this.duration != void 0) {
+        message["remaining duration"] = this.duration.toString();
+      }
+      if (this.lockTimeout != void 0) {
+        message["lock timeout"] = `${this.lockTimeout} seconds`;
+      }
+      return {
+        ...super.toLogEntry(ctx),
+        message
+      };
     }
-    if (this.lockTimeout != void 0) {
-      message["lock timeout"] = `${this.lockTimeout} seconds`;
+  };
+  return DoorLockCCOperationReport2 = _classThis;
+})();
+let DoorLockCCOperationGet = (() => {
+  let _classDecorators = [(0, import_CommandClassDecorators.CCCommand)(import_Types.DoorLockCommand.OperationGet), (0, import_CommandClassDecorators.expectedCCResponse)(DoorLockCCOperationReport)];
+  let _classDescriptor;
+  let _classExtraInitializers = [];
+  let _classThis;
+  let _classSuper = DoorLockCC;
+  var DoorLockCCOperationGet2 = class extends _classSuper {
+    static {
+      _classThis = this;
     }
-    return {
-      ...super.toLogEntry(ctx),
-      message
-    };
-  }
-};
-__decorate([
-  (0, import_CommandClassDecorators.ccValue)(DoorLockCCValues.currentMode)
-], DoorLockCCOperationReport.prototype, "currentMode", void 0);
-__decorate([
-  (0, import_CommandClassDecorators.ccValue)(DoorLockCCValues.targetMode)
-], DoorLockCCOperationReport.prototype, "targetMode", void 0);
-__decorate([
-  (0, import_CommandClassDecorators.ccValue)(DoorLockCCValues.duration)
-], DoorLockCCOperationReport.prototype, "duration", void 0);
-__decorate([
-  (0, import_CommandClassDecorators.ccValue)(DoorLockCCValues.outsideHandlesCanOpenDoor)
-], DoorLockCCOperationReport.prototype, "outsideHandlesCanOpenDoor", void 0);
-__decorate([
-  (0, import_CommandClassDecorators.ccValue)(DoorLockCCValues.insideHandlesCanOpenDoor)
-], DoorLockCCOperationReport.prototype, "insideHandlesCanOpenDoor", void 0);
-__decorate([
-  (0, import_CommandClassDecorators.ccValue)(DoorLockCCValues.lockTimeout)
-], DoorLockCCOperationReport.prototype, "lockTimeout", void 0);
-DoorLockCCOperationReport = DoorLockCCOperationReport_1 = __decorate([
-  (0, import_CommandClassDecorators.CCCommand)(import_Types.DoorLockCommand.OperationReport)
-], DoorLockCCOperationReport);
-let DoorLockCCOperationGet = class DoorLockCCOperationGet2 extends DoorLockCC {
-};
-DoorLockCCOperationGet = __decorate([
-  (0, import_CommandClassDecorators.CCCommand)(import_Types.DoorLockCommand.OperationGet),
-  (0, import_CommandClassDecorators.expectedCCResponse)(DoorLockCCOperationReport)
-], DoorLockCCOperationGet);
-let DoorLockCCConfigurationReport = DoorLockCCConfigurationReport_1 = class DoorLockCCConfigurationReport2 extends DoorLockCC {
-  constructor(options) {
-    super(options);
-    this.operationType = options.operationType;
-    this.outsideHandlesCanOpenDoorConfiguration = options.outsideHandlesCanOpenDoorConfiguration;
-    this.insideHandlesCanOpenDoorConfiguration = options.insideHandlesCanOpenDoorConfiguration;
-    this.lockTimeoutConfiguration = options.lockTimeoutConfiguration;
-    this.autoRelockTime = options.autoRelockTime;
-    this.holdAndReleaseTime = options.holdAndReleaseTime;
-    this.twistAssist = options.twistAssist;
-    this.blockToBlock = options.blockToBlock;
-  }
-  static from(raw, ctx) {
-    (0, import_safe.validatePayload)(raw.payload.length >= 4);
-    const operationType = raw.payload[0];
-    const outsideHandlesCanOpenDoorConfiguration = [
-      !!(raw.payload[1] & 16),
-      !!(raw.payload[1] & 32),
-      !!(raw.payload[1] & 64),
-      !!(raw.payload[1] & 128)
-    ];
-    const insideHandlesCanOpenDoorConfiguration = [
-      !!(raw.payload[1] & 1),
-      !!(raw.payload[1] & 2),
-      !!(raw.payload[1] & 4),
-      !!(raw.payload[1] & 8)
-    ];
-    let lockTimeoutConfiguration;
-    if (operationType === import_Types.DoorLockOperationType.Timed) {
-      const lockTimeoutMinutes = raw.payload[2];
-      const lockTimeoutSeconds = raw.payload[3];
-      if (lockTimeoutMinutes <= 253 && lockTimeoutSeconds <= 59) {
-        lockTimeoutConfiguration = lockTimeoutSeconds + lockTimeoutMinutes * 60;
-      }
+    static {
+      const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+      __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+      DoorLockCCOperationGet2 = _classThis = _classDescriptor.value;
+      if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+      __runInitializers(_classThis, _classExtraInitializers);
     }
-    let autoRelockTime;
-    let holdAndReleaseTime;
-    let twistAssist;
-    let blockToBlock;
-    if (raw.payload.length >= 5) {
-      autoRelockTime = raw.payload.readUInt16BE(4);
-      holdAndReleaseTime = raw.payload.readUInt16BE(6);
-      const flags = raw.payload[8];
-      twistAssist = !!(flags & 1);
-      blockToBlock = !!(flags & 2);
+  };
+  return DoorLockCCOperationGet2 = _classThis;
+})();
+let DoorLockCCConfigurationReport = (() => {
+  let _classDecorators = [(0, import_CommandClassDecorators.CCCommand)(import_Types.DoorLockCommand.ConfigurationReport), (0, import_CommandClassDecorators.ccValueProperty)("operationType", DoorLockCCValues.operationType), (0, import_CommandClassDecorators.ccValueProperty)("outsideHandlesCanOpenDoorConfiguration", DoorLockCCValues.outsideHandlesCanOpenDoorConfiguration), (0, import_CommandClassDecorators.ccValueProperty)("insideHandlesCanOpenDoorConfiguration", DoorLockCCValues.insideHandlesCanOpenDoorConfiguration), (0, import_CommandClassDecorators.ccValueProperty)("lockTimeoutConfiguration", DoorLockCCValues.lockTimeoutConfiguration)];
+  let _classDescriptor;
+  let _classExtraInitializers = [];
+  let _classThis;
+  let _classSuper = DoorLockCC;
+  var DoorLockCCConfigurationReport2 = class extends _classSuper {
+    static {
+      _classThis = this;
     }
-    return new DoorLockCCConfigurationReport_1({
-      nodeId: ctx.sourceNodeId,
-      operationType,
-      outsideHandlesCanOpenDoorConfiguration,
-      insideHandlesCanOpenDoorConfiguration,
-      lockTimeoutConfiguration,
-      autoRelockTime,
-      holdAndReleaseTime,
-      twistAssist,
-      blockToBlock
-    });
-  }
-  operationType;
-  outsideHandlesCanOpenDoorConfiguration;
-  insideHandlesCanOpenDoorConfiguration;
-  lockTimeoutConfiguration;
-  // These are not always supported and have to be persisted manually
-  // to avoid unsupported values being exposed to the user
-  autoRelockTime;
-  holdAndReleaseTime;
-  twistAssist;
-  blockToBlock;
-  persistValues(ctx) {
-    if (!super.persistValues(ctx))
-      return false;
-    const supportsAutoRelock = !!this.getValue(ctx, DoorLockCCValues.autoRelockSupported);
-    if (supportsAutoRelock) {
-      this.setValue(ctx, DoorLockCCValues.autoRelockTime, this.autoRelockTime);
+    static {
+      const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+      __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+      DoorLockCCConfigurationReport2 = _classThis = _classDescriptor.value;
+      if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+      __runInitializers(_classThis, _classExtraInitializers);
     }
-    const supportsHoldAndRelease = !!this.getValue(ctx, DoorLockCCValues.holdAndReleaseSupported);
-    if (supportsHoldAndRelease) {
-      this.setValue(ctx, DoorLockCCValues.holdAndReleaseTime, this.holdAndReleaseTime);
+    constructor(options) {
+      super(options);
+      this.operationType = options.operationType;
+      this.outsideHandlesCanOpenDoorConfiguration = options.outsideHandlesCanOpenDoorConfiguration;
+      this.insideHandlesCanOpenDoorConfiguration = options.insideHandlesCanOpenDoorConfiguration;
+      this.lockTimeoutConfiguration = options.lockTimeoutConfiguration;
+      this.autoRelockTime = options.autoRelockTime;
+      this.holdAndReleaseTime = options.holdAndReleaseTime;
+      this.twistAssist = options.twistAssist;
+      this.blockToBlock = options.blockToBlock;
     }
-    const supportsTwistAssist = !!this.getValue(ctx, DoorLockCCValues.twistAssistSupported);
-    if (supportsTwistAssist) {
-      this.setValue(ctx, DoorLockCCValues.twistAssist, this.twistAssist);
+    static from(raw, ctx) {
+      (0, import_safe.validatePayload)(raw.payload.length >= 4);
+      const operationType = raw.payload[0];
+      const outsideHandlesCanOpenDoorConfiguration = [
+        !!(raw.payload[1] & 16),
+        !!(raw.payload[1] & 32),
+        !!(raw.payload[1] & 64),
+        !!(raw.payload[1] & 128)
+      ];
+      const insideHandlesCanOpenDoorConfiguration = [
+        !!(raw.payload[1] & 1),
+        !!(raw.payload[1] & 2),
+        !!(raw.payload[1] & 4),
+        !!(raw.payload[1] & 8)
+      ];
+      let lockTimeoutConfiguration;
+      if (operationType === import_Types.DoorLockOperationType.Timed) {
+        const lockTimeoutMinutes = raw.payload[2];
+        const lockTimeoutSeconds = raw.payload[3];
+        if (lockTimeoutMinutes <= 253 && lockTimeoutSeconds <= 59) {
+          lockTimeoutConfiguration = lockTimeoutSeconds + lockTimeoutMinutes * 60;
+        }
+      }
+      let autoRelockTime;
+      let holdAndReleaseTime;
+      let twistAssist;
+      let blockToBlock;
+      if (raw.payload.length >= 5) {
+        autoRelockTime = raw.payload.readUInt16BE(4);
+        holdAndReleaseTime = raw.payload.readUInt16BE(6);
+        const flags = raw.payload[8];
+        twistAssist = !!(flags & 1);
+        blockToBlock = !!(flags & 2);
+      }
+      return new this({
+        nodeId: ctx.sourceNodeId,
+        operationType,
+        outsideHandlesCanOpenDoorConfiguration,
+        insideHandlesCanOpenDoorConfiguration,
+        lockTimeoutConfiguration,
+        autoRelockTime,
+        holdAndReleaseTime,
+        twistAssist,
+        blockToBlock
+      });
     }
-    const supportsBlockToBlock = !!this.getValue(ctx, DoorLockCCValues.blockToBlockSupported);
-    if (supportsBlockToBlock) {
-      this.setValue(ctx, DoorLockCCValues.blockToBlock, this.blockToBlock);
+    operationType;
+    outsideHandlesCanOpenDoorConfiguration;
+    insideHandlesCanOpenDoorConfiguration;
+    lockTimeoutConfiguration;
+    // These are not always supported and have to be persisted manually
+    // to avoid unsupported values being exposed to the user
+    autoRelockTime;
+    holdAndReleaseTime;
+    twistAssist;
+    blockToBlock;
+    persistValues(ctx) {
+      if (!super.persistValues(ctx))
+        return false;
+      const supportsAutoRelock = !!this.getValue(ctx, DoorLockCCValues.autoRelockSupported);
+      if (supportsAutoRelock) {
+        this.setValue(ctx, DoorLockCCValues.autoRelockTime, this.autoRelockTime);
+      }
+      const supportsHoldAndRelease = !!this.getValue(ctx, DoorLockCCValues.holdAndReleaseSupported);
+      if (supportsHoldAndRelease) {
+        this.setValue(ctx, DoorLockCCValues.holdAndReleaseTime, this.holdAndReleaseTime);
+      }
+      const supportsTwistAssist = !!this.getValue(ctx, DoorLockCCValues.twistAssistSupported);
+      if (supportsTwistAssist) {
+        this.setValue(ctx, DoorLockCCValues.twistAssist, this.twistAssist);
+      }
+      const supportsBlockToBlock = !!this.getValue(ctx, DoorLockCCValues.blockToBlockSupported);
+      if (supportsBlockToBlock) {
+        this.setValue(ctx, DoorLockCCValues.blockToBlock, this.blockToBlock);
+      }
+      return true;
     }
-    return true;
-  }
-  toLogEntry(ctx) {
-    const message = {
-      "operation type": (0, import_safe3.getEnumMemberName)(import_Types.DoorLockOperationType, this.operationType),
-      "outside handle configuration": this.outsideHandlesCanOpenDoorConfiguration.join(", "),
-      "inside handle configuration": this.insideHandlesCanOpenDoorConfiguration.join(", ")
-    };
-    if (this.lockTimeoutConfiguration != void 0) {
-      message["timed mode duration"] = `${this.lockTimeoutConfiguration} seconds`;
+    toLogEntry(ctx) {
+      const message = {
+        "operation type": (0, import_safe3.getEnumMemberName)(import_Types.DoorLockOperationType, this.operationType),
+        "outside handle configuration": this.outsideHandlesCanOpenDoorConfiguration.join(", "),
+        "inside handle configuration": this.insideHandlesCanOpenDoorConfiguration.join(", ")
+      };
+      if (this.lockTimeoutConfiguration != void 0) {
+        message["timed mode duration"] = `${this.lockTimeoutConfiguration} seconds`;
+      }
+      if (this.autoRelockTime != void 0) {
+        message["auto-relock time"] = `${this.autoRelockTime} seconds`;
+      }
+      if (this.holdAndReleaseTime != void 0) {
+        message["hold-and-release time"] = `${this.holdAndReleaseTime} seconds`;
+      }
+      if (this.twistAssist != void 0) {
+        message["twist assist enabled"] = this.twistAssist;
+      }
+      if (this.blockToBlock != void 0) {
+        message["block-to-block enabled"] = this.blockToBlock;
+      }
+      return {
+        ...super.toLogEntry(ctx),
+        message
+      };
     }
-    if (this.autoRelockTime != void 0) {
-      message["auto-relock time"] = `${this.autoRelockTime} seconds`;
+  };
+  return DoorLockCCConfigurationReport2 = _classThis;
+})();
+let DoorLockCCConfigurationGet = (() => {
+  let _classDecorators = [(0, import_CommandClassDecorators.CCCommand)(import_Types.DoorLockCommand.ConfigurationGet), (0, import_CommandClassDecorators.expectedCCResponse)(DoorLockCCConfigurationReport)];
+  let _classDescriptor;
+  let _classExtraInitializers = [];
+  let _classThis;
+  let _classSuper = DoorLockCC;
+  var DoorLockCCConfigurationGet2 = class extends _classSuper {
+    static {
+      _classThis = this;
     }
-    if (this.holdAndReleaseTime != void 0) {
-      message["hold-and-release time"] = `${this.holdAndReleaseTime} seconds`;
+    static {
+      const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+      __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+      DoorLockCCConfigurationGet2 = _classThis = _classDescriptor.value;
+      if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+      __runInitializers(_classThis, _classExtraInitializers);
     }
-    if (this.twistAssist != void 0) {
-      message["twist assist enabled"] = this.twistAssist;
+  };
+  return DoorLockCCConfigurationGet2 = _classThis;
+})();
+let DoorLockCCConfigurationSet = (() => {
+  let _classDecorators = [(0, import_CommandClassDecorators.CCCommand)(import_Types.DoorLockCommand.ConfigurationSet), (0, import_CommandClassDecorators.useSupervision)()];
+  let _classDescriptor;
+  let _classExtraInitializers = [];
+  let _classThis;
+  let _classSuper = DoorLockCC;
+  var DoorLockCCConfigurationSet2 = class extends _classSuper {
+    static {
+      _classThis = this;
     }
-    if (this.blockToBlock != void 0) {
-      message["block-to-block enabled"] = this.blockToBlock;
+    static {
+      const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+      __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+      DoorLockCCConfigurationSet2 = _classThis = _classDescriptor.value;
+      if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+      __runInitializers(_classThis, _classExtraInitializers);
     }
-    return {
-      ...super.toLogEntry(ctx),
-      message
-    };
-  }
-};
-__decorate([
-  (0, import_CommandClassDecorators.ccValue)(DoorLockCCValues.operationType)
-], DoorLockCCConfigurationReport.prototype, "operationType", void 0);
-__decorate([
-  (0, import_CommandClassDecorators.ccValue)(DoorLockCCValues.outsideHandlesCanOpenDoorConfiguration)
-], DoorLockCCConfigurationReport.prototype, "outsideHandlesCanOpenDoorConfiguration", void 0);
-__decorate([
-  (0, import_CommandClassDecorators.ccValue)(DoorLockCCValues.insideHandlesCanOpenDoorConfiguration)
-], DoorLockCCConfigurationReport.prototype, "insideHandlesCanOpenDoorConfiguration", void 0);
-__decorate([
-  (0, import_CommandClassDecorators.ccValue)(DoorLockCCValues.lockTimeoutConfiguration)
-], DoorLockCCConfigurationReport.prototype, "lockTimeoutConfiguration", void 0);
-DoorLockCCConfigurationReport = DoorLockCCConfigurationReport_1 = __decorate([
-  (0, import_CommandClassDecorators.CCCommand)(import_Types.DoorLockCommand.ConfigurationReport)
-], DoorLockCCConfigurationReport);
-let DoorLockCCConfigurationGet = class DoorLockCCConfigurationGet2 extends DoorLockCC {
-};
-DoorLockCCConfigurationGet = __decorate([
-  (0, import_CommandClassDecorators.CCCommand)(import_Types.DoorLockCommand.ConfigurationGet),
-  (0, import_CommandClassDecorators.expectedCCResponse)(DoorLockCCConfigurationReport)
-], DoorLockCCConfigurationGet);
-let DoorLockCCConfigurationSet = class DoorLockCCConfigurationSet2 extends DoorLockCC {
-  constructor(options) {
-    super(options);
-    this.operationType = options.operationType;
-    this.outsideHandlesCanOpenDoorConfiguration = options.outsideHandlesCanOpenDoorConfiguration;
-    this.insideHandlesCanOpenDoorConfiguration = options.insideHandlesCanOpenDoorConfiguration;
-    this.lockTimeoutConfiguration = options.lockTimeoutConfiguration;
-    this.autoRelockTime = options.autoRelockTime;
-    this.holdAndReleaseTime = options.holdAndReleaseTime;
-    this.twistAssist = options.twistAssist;
-    this.blockToBlock = options.blockToBlock;
-  }
-  static from(_raw, _ctx) {
-    throw new import_safe.ZWaveError(`${this.name}: deserialization not implemented`, import_safe.ZWaveErrorCodes.Deserialization_NotImplemented);
-  }
-  operationType;
-  outsideHandlesCanOpenDoorConfiguration;
-  insideHandlesCanOpenDoorConfiguration;
-  lockTimeoutConfiguration;
-  autoRelockTime;
-  holdAndReleaseTime;
-  twistAssist;
-  blockToBlock;
-  serialize(ctx) {
-    const insideHandles = (0, import_typeguards.isArray)(this.insideHandlesCanOpenDoorConfiguration) ? this.insideHandlesCanOpenDoorConfiguration : [];
-    const outsideHandles = (0, import_typeguards.isArray)(this.outsideHandlesCanOpenDoorConfiguration) ? this.outsideHandlesCanOpenDoorConfiguration : [];
-    const handles = [...insideHandles, ...outsideHandles].map((val, i) => val ? 1 << i : 0).reduce((acc, cur) => acc | cur, 0);
-    let lockTimeoutMinutes;
-    let lockTimeoutSeconds;
-    if (this.operationType === import_Types.DoorLockOperationType.Constant) {
-      lockTimeoutMinutes = lockTimeoutSeconds = 254;
-    } else {
-      lockTimeoutMinutes = Math.floor(this.lockTimeoutConfiguration / 60);
-      lockTimeoutSeconds = this.lockTimeoutConfiguration % 60;
+    constructor(options) {
+      super(options);
+      this.operationType = options.operationType;
+      this.outsideHandlesCanOpenDoorConfiguration = options.outsideHandlesCanOpenDoorConfiguration;
+      this.insideHandlesCanOpenDoorConfiguration = options.insideHandlesCanOpenDoorConfiguration;
+      this.lockTimeoutConfiguration = options.lockTimeoutConfiguration;
+      this.autoRelockTime = options.autoRelockTime;
+      this.holdAndReleaseTime = options.holdAndReleaseTime;
+      this.twistAssist = options.twistAssist;
+      this.blockToBlock = options.blockToBlock;
     }
-    const flags = (this.twistAssist ? 1 : 0) | (this.blockToBlock ? 2 : 0);
-    this.payload = import_safe2.Bytes.from([
-      this.operationType,
-      handles,
-      lockTimeoutMinutes,
-      lockTimeoutSeconds,
-      // placeholder for auto relock time
-      0,
-      0,
-      // placeholder for hold and release time
-      0,
-      0,
-      flags
-    ]);
-    this.payload.writeUInt16BE((this.autoRelockTime ?? 0) & 65535, 4);
-    this.payload.writeUInt16BE((this.holdAndReleaseTime ?? 0) & 65535, 6);
-    return super.serialize(ctx);
-  }
-  toLogEntry(ctx) {
-    const insideHandles = (0, import_typeguards.isArray)(this.insideHandlesCanOpenDoorConfiguration) ? this.insideHandlesCanOpenDoorConfiguration : [];
-    const outsideHandles = (0, import_typeguards.isArray)(this.outsideHandlesCanOpenDoorConfiguration) ? this.outsideHandlesCanOpenDoorConfiguration : [];
-    const message = {
-      "operation type": (0, import_safe3.getEnumMemberName)(import_Types.DoorLockOperationType, this.operationType),
-      "outside handle configuration": outsideHandles.join(", "),
-      "inside handle configuration": insideHandles.join(", ")
-    };
-    if (this.lockTimeoutConfiguration != void 0) {
-      message["timed mode duration"] = `${this.lockTimeoutConfiguration} seconds`;
+    static from(_raw, _ctx) {
+      throw new import_safe.ZWaveError(`${this.name}: deserialization not implemented`, import_safe.ZWaveErrorCodes.Deserialization_NotImplemented);
+    }
+    operationType;
+    outsideHandlesCanOpenDoorConfiguration;
+    insideHandlesCanOpenDoorConfiguration;
+    lockTimeoutConfiguration;
+    autoRelockTime;
+    holdAndReleaseTime;
+    twistAssist;
+    blockToBlock;
+    serialize(ctx) {
+      const insideHandles = (0, import_typeguards.isArray)(this.insideHandlesCanOpenDoorConfiguration) ? this.insideHandlesCanOpenDoorConfiguration : [];
+      const outsideHandles = (0, import_typeguards.isArray)(this.outsideHandlesCanOpenDoorConfiguration) ? this.outsideHandlesCanOpenDoorConfiguration : [];
+      const handles = [...insideHandles, ...outsideHandles].map((val, i) => val ? 1 << i : 0).reduce((acc, cur) => acc | cur, 0);
+      let lockTimeoutMinutes;
+      let lockTimeoutSeconds;
+      if (this.operationType === import_Types.DoorLockOperationType.Constant) {
+        lockTimeoutMinutes = lockTimeoutSeconds = 254;
+      } else {
+        lockTimeoutMinutes = Math.floor(this.lockTimeoutConfiguration / 60);
+        lockTimeoutSeconds = this.lockTimeoutConfiguration % 60;
+      }
+      const flags = (this.twistAssist ? 1 : 0) | (this.blockToBlock ? 2 : 0);
+      this.payload = import_safe2.Bytes.from([
+        this.operationType,
+        handles,
+        lockTimeoutMinutes,
+        lockTimeoutSeconds,
+        // placeholder for auto relock time
+        0,
+        0,
+        // placeholder for hold and release time
+        0,
+        0,
+        flags
+      ]);
+      this.payload.writeUInt16BE((this.autoRelockTime ?? 0) & 65535, 4);
+      this.payload.writeUInt16BE((this.holdAndReleaseTime ?? 0) & 65535, 6);
+      return super.serialize(ctx);
     }
-    if (this.autoRelockTime != void 0) {
-      message["auto-relock time"] = `${this.autoRelockTime} seconds`;
+    toLogEntry(ctx) {
+      const insideHandles = (0, import_typeguards.isArray)(this.insideHandlesCanOpenDoorConfiguration) ? this.insideHandlesCanOpenDoorConfiguration : [];
+      const outsideHandles = (0, import_typeguards.isArray)(this.outsideHandlesCanOpenDoorConfiguration) ? this.outsideHandlesCanOpenDoorConfiguration : [];
+      const message = {
+        "operation type": (0, import_safe3.getEnumMemberName)(import_Types.DoorLockOperationType, this.operationType),
+        "outside handle configuration": outsideHandles.join(", "),
+        "inside handle configuration": insideHandles.join(", ")
+      };
+      if (this.lockTimeoutConfiguration != void 0) {
+        message["timed mode duration"] = `${this.lockTimeoutConfiguration} seconds`;
+      }
+      if (this.autoRelockTime != void 0) {
+        message["auto-relock time"] = `${this.autoRelockTime} seconds`;
+      }
+      if (this.holdAndReleaseTime != void 0) {
+        message["hold-and-release time"] = `${this.holdAndReleaseTime} seconds`;
+      }
+      if (this.twistAssist != void 0) {
+        message["enable twist assist"] = this.twistAssist;
+      }
+      if (this.blockToBlock != void 0) {
+        message["enable block-to-block"] = this.blockToBlock;
+      }
+      return {
+        ...super.toLogEntry(ctx),
+        message
+      };
     }
-    if (this.holdAndReleaseTime != void 0) {
-      message["hold-and-release time"] = `${this.holdAndReleaseTime} seconds`;
+  };
+  return DoorLockCCConfigurationSet2 = _classThis;
+})();
+let DoorLockCCCapabilitiesReport = (() => {
+  let _classDecorators = [(0, import_CommandClassDecorators.CCCommand)(import_Types.DoorLockCommand.CapabilitiesReport), (0, import_CommandClassDecorators.ccValueProperty)("supportedOutsideHandles", DoorLockCCValues.supportedOutsideHandles), (0, import_CommandClassDecorators.ccValueProperty)("supportedInsideHandles", DoorLockCCValues.supportedInsideHandles), (0, import_CommandClassDecorators.ccValueProperty)("autoRelockSupported", DoorLockCCValues.autoRelockSupported), (0, import_CommandClassDecorators.ccValueProperty)("holdAndReleaseSupported", DoorLockCCValues.holdAndReleaseSupported), (0, import_CommandClassDecorators.ccValueProperty)("twistAssistSupported", DoorLockCCValues.twistAssistSupported), (0, import_CommandClassDecorators.ccValueProperty)("blockToBlockSupported", DoorLockCCValues.blockToBlockSupported)];
+  let _classDescriptor;
+  let _classExtraInitializers = [];
+  let _classThis;
+  let _classSuper = DoorLockCC;
+  var DoorLockCCCapabilitiesReport2 = class extends _classSuper {
+    static {
+      _classThis = this;
     }
-    if (this.twistAssist != void 0) {
-      message["enable twist assist"] = this.twistAssist;
+    static {
+      const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+      __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+      DoorLockCCCapabilitiesReport2 = _classThis = _classDescriptor.value;
+      if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+      __runInitializers(_classThis, _classExtraInitializers);
     }
-    if (this.blockToBlock != void 0) {
-      message["enable block-to-block"] = this.blockToBlock;
+    constructor(options) {
+      super(options);
+      this.supportedOperationTypes = options.supportedOperationTypes;
+      this.supportedDoorLockModes = options.supportedDoorLockModes;
+      this.supportedOutsideHandles = options.supportedOutsideHandles;
+      this.supportedInsideHandles = options.supportedInsideHandles;
+      this.doorSupported = options.doorSupported;
+      this.boltSupported = options.boltSupported;
+      this.latchSupported = options.latchSupported;
+      this.blockToBlockSupported = options.blockToBlockSupported;
+      this.twistAssistSupported = options.twistAssistSupported;
+      this.holdAndReleaseSupported = options.holdAndReleaseSupported;
+      this.autoRelockSupported = options.autoRelockSupported;
     }
-    return {
-      ...super.toLogEntry(ctx),
-      message
-    };
-  }
-};
-DoorLockCCConfigurationSet = __decorate([
-  (0, import_CommandClassDecorators.CCCommand)(import_Types.DoorLockCommand.ConfigurationSet),
-  (0, import_CommandClassDecorators.useSupervision)()
-], DoorLockCCConfigurationSet);
-let DoorLockCCCapabilitiesReport = DoorLockCCCapabilitiesReport_1 = class DoorLockCCCapabilitiesReport2 extends DoorLockCC {
-  constructor(options) {
-    super(options);
-    this.supportedOperationTypes = options.supportedOperationTypes;
-    this.supportedDoorLockModes = options.supportedDoorLockModes;
-    this.supportedOutsideHandles = options.supportedOutsideHandles;
-    this.supportedInsideHandles = options.supportedInsideHandles;
-    this.doorSupported = options.doorSupported;
-    this.boltSupported = options.boltSupported;
-    this.latchSupported = options.latchSupported;
-    this.blockToBlockSupported = options.blockToBlockSupported;
-    this.twistAssistSupported = options.twistAssistSupported;
-    this.holdAndReleaseSupported = options.holdAndReleaseSupported;
-    this.autoRelockSupported = options.autoRelockSupported;
-  }
-  static from(raw, ctx) {
-    (0, import_safe.validatePayload)(raw.payload.length >= 1);
-    const bitMaskLength = raw.payload[0] & 31;
-    let offset = 1;
-    (0, import_safe.validatePayload)(raw.payload.length >= offset + bitMaskLength + 1);
-    const supportedOperationTypes = (0, import_safe.parseBitMask)(
-      raw.payload.subarray(offset, offset + bitMaskLength),
-      // bit 0 is reserved, bitmask starts at 1
-      0
-    );
-    offset += bitMaskLength;
-    const listLength = raw.payload[offset];
-    offset += 1;
-    (0, import_safe.validatePayload)(raw.payload.length >= offset + listLength + 3);
-    const supportedDoorLockModes = [
-      ...raw.payload.subarray(offset, offset + listLength)
-    ];
-    offset += listLength;
-    const supportedOutsideHandles = [
-      !!(raw.payload[offset] & 16),
-      !!(raw.payload[offset] & 32),
-      !!(raw.payload[offset] & 64),
-      !!(raw.payload[offset] & 128)
-    ];
-    const supportedInsideHandles = [
-      !!(raw.payload[offset] & 1),
-      !!(raw.payload[offset] & 2),
-      !!(raw.payload[offset] & 4),
-      !!(raw.payload[offset] & 8)
-    ];
-    const doorSupported = !!(raw.payload[offset + 1] & 1);
-    const boltSupported = !!(raw.payload[offset + 1] & 2);
-    const latchSupported = !!(raw.payload[offset + 1] & 4);
-    const blockToBlockSupported = !!(raw.payload[offset + 2] & 1);
-    const twistAssistSupported = !!(raw.payload[offset + 2] & 2);
-    const holdAndReleaseSupported = !!(raw.payload[offset + 2] & 4);
-    const autoRelockSupported = !!(raw.payload[offset + 2] & 8);
-    return new DoorLockCCCapabilitiesReport_1({
-      nodeId: ctx.sourceNodeId,
-      supportedOperationTypes,
-      supportedDoorLockModes,
-      supportedOutsideHandles,
-      supportedInsideHandles,
-      doorSupported,
-      boltSupported,
-      latchSupported,
-      blockToBlockSupported,
-      twistAssistSupported,
-      holdAndReleaseSupported,
-      autoRelockSupported
-    });
-  }
-  supportedOperationTypes;
-  supportedDoorLockModes;
-  supportedOutsideHandles;
-  supportedInsideHandles;
-  // These 3 are not automatically persisted because in CC version 3
-  // we have to assume them to be supported. In v4 we can query this.
-  latchSupported;
-  boltSupported;
-  doorSupported;
-  autoRelockSupported;
-  holdAndReleaseSupported;
-  twistAssistSupported;
-  blockToBlockSupported;
-  toLogEntry(ctx) {
-    return {
-      ...super.toLogEntry(ctx),
-      message: {
-        door: this.doorSupported,
-        bolt: this.boltSupported,
-        latch: this.latchSupported,
-        "block-to-block feature": this.blockToBlockSupported,
-        "twist assist feature": this.twistAssistSupported,
-        "hold-and-release feature": this.holdAndReleaseSupported,
-        "auto-relock feature": this.autoRelockSupported,
-        "operation types": this.supportedOperationTypes.map((t) => `
+    static from(raw, ctx) {
+      (0, import_safe.validatePayload)(raw.payload.length >= 1);
+      const bitMaskLength = raw.payload[0] & 31;
+      let offset = 1;
+      (0, import_safe.validatePayload)(raw.payload.length >= offset + bitMaskLength + 1);
+      const supportedOperationTypes = (0, import_safe.parseBitMask)(
+        raw.payload.subarray(offset, offset + bitMaskLength),
+        // bit 0 is reserved, bitmask starts at 1
+        0
+      );
+      offset += bitMaskLength;
+      const listLength = raw.payload[offset];
+      offset += 1;
+      (0, import_safe.validatePayload)(raw.payload.length >= offset + listLength + 3);
+      const supportedDoorLockModes = [
+        ...raw.payload.subarray(offset, offset + listLength)
+      ];
+      offset += listLength;
+      const supportedOutsideHandles = [
+        !!(raw.payload[offset] & 16),
+        !!(raw.payload[offset] & 32),
+        !!(raw.payload[offset] & 64),
+        !!(raw.payload[offset] & 128)
+      ];
+      const supportedInsideHandles = [
+        !!(raw.payload[offset] & 1),
+        !!(raw.payload[offset] & 2),
+        !!(raw.payload[offset] & 4),
+        !!(raw.payload[offset] & 8)
+      ];
+      const doorSupported = !!(raw.payload[offset + 1] & 1);
+      const boltSupported = !!(raw.payload[offset + 1] & 2);
+      const latchSupported = !!(raw.payload[offset + 1] & 4);
+      const blockToBlockSupported = !!(raw.payload[offset + 2] & 1);
+      const twistAssistSupported = !!(raw.payload[offset + 2] & 2);
+      const holdAndReleaseSupported = !!(raw.payload[offset + 2] & 4);
+      const autoRelockSupported = !!(raw.payload[offset + 2] & 8);
+      return new this({
+        nodeId: ctx.sourceNodeId,
+        supportedOperationTypes,
+        supportedDoorLockModes,
+        supportedOutsideHandles,
+        supportedInsideHandles,
+        doorSupported,
+        boltSupported,
+        latchSupported,
+        blockToBlockSupported,
+        twistAssistSupported,
+        holdAndReleaseSupported,
+        autoRelockSupported
+      });
+    }
+    supportedOperationTypes;
+    supportedDoorLockModes;
+    supportedOutsideHandles;
+    supportedInsideHandles;
+    // These 3 are not automatically persisted because in CC version 3
+    // we have to assume them to be supported. In v4 we can query this.
+    latchSupported;
+    boltSupported;
+    doorSupported;
+    autoRelockSupported;
+    holdAndReleaseSupported;
+    twistAssistSupported;
+    blockToBlockSupported;
+    toLogEntry(ctx) {
+      return {
+        ...super.toLogEntry(ctx),
+        message: {
+          door: this.doorSupported,
+          bolt: this.boltSupported,
+          latch: this.latchSupported,
+          "block-to-block feature": this.blockToBlockSupported,
+          "twist assist feature": this.twistAssistSupported,
+          "hold-and-release feature": this.holdAndReleaseSupported,
+          "auto-relock feature": this.autoRelockSupported,
+          "operation types": this.supportedOperationTypes.map((t) => `
 \xB7 ${(0, import_safe3.getEnumMemberName)(import_Types.DoorLockOperationType, t)}`).join(""),
-        "door lock modes": this.supportedDoorLockModes.map((t) => `
+          "door lock modes": this.supportedDoorLockModes.map((t) => `
 \xB7 ${(0, import_safe3.getEnumMemberName)(import_Types.DoorLockMode, t)}`).join(""),
-        "outside handles": this.supportedOutsideHandles.join(", "),
-        "inside handles": this.supportedInsideHandles.join(", ")
-      }
-    };
-  }
-};
-__decorate([
-  (0, import_CommandClassDecorators.ccValue)(DoorLockCCValues.supportedOutsideHandles)
-], DoorLockCCCapabilitiesReport.prototype, "supportedOutsideHandles", void 0);
-__decorate([
-  (0, import_CommandClassDecorators.ccValue)(DoorLockCCValues.supportedInsideHandles)
-], DoorLockCCCapabilitiesReport.prototype, "supportedInsideHandles", void 0);
-__decorate([
-  (0, import_CommandClassDecorators.ccValue)(DoorLockCCValues.autoRelockSupported)
-], DoorLockCCCapabilitiesReport.prototype, "autoRelockSupported", void 0);
-__decorate([
-  (0, import_CommandClassDecorators.ccValue)(DoorLockCCValues.holdAndReleaseSupported)
-], DoorLockCCCapabilitiesReport.prototype, "holdAndReleaseSupported", void 0);
-__decorate([
-  (0, import_CommandClassDecorators.ccValue)(DoorLockCCValues.twistAssistSupported)
-], DoorLockCCCapabilitiesReport.prototype, "twistAssistSupported", void 0);
-__decorate([
-  (0, import_CommandClassDecorators.ccValue)(DoorLockCCValues.blockToBlockSupported)
-], DoorLockCCCapabilitiesReport.prototype, "blockToBlockSupported", void 0);
-DoorLockCCCapabilitiesReport = DoorLockCCCapabilitiesReport_1 = __decorate([
-  (0, import_CommandClassDecorators.CCCommand)(import_Types.DoorLockCommand.CapabilitiesReport)
-], DoorLockCCCapabilitiesReport);
-let DoorLockCCCapabilitiesGet = class DoorLockCCCapabilitiesGet2 extends DoorLockCC {
-};
-DoorLockCCCapabilitiesGet = __decorate([
-  (0, import_CommandClassDecorators.CCCommand)(import_Types.DoorLockCommand.CapabilitiesGet),
-  (0, import_CommandClassDecorators.expectedCCResponse)(DoorLockCCCapabilitiesReport)
-], DoorLockCCCapabilitiesGet);
+          "outside handles": this.supportedOutsideHandles.join(", "),
+          "inside handles": this.supportedInsideHandles.join(", ")
+        }
+      };
+    }
+  };
+  return DoorLockCCCapabilitiesReport2 = _classThis;
+})();
+let DoorLockCCCapabilitiesGet = (() => {
+  let _classDecorators = [(0, import_CommandClassDecorators.CCCommand)(import_Types.DoorLockCommand.CapabilitiesGet), (0, import_CommandClassDecorators.expectedCCResponse)(DoorLockCCCapabilitiesReport)];
+  let _classDescriptor;
+  let _classExtraInitializers = [];
+  let _classThis;
+  let _classSuper = DoorLockCC;
+  var DoorLockCCCapabilitiesGet2 = class extends _classSuper {
+    static {
+      _classThis = this;
+    }
+    static {
+      const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+      __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+      DoorLockCCCapabilitiesGet2 = _classThis = _classDescriptor.value;
+      if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+      __runInitializers(_classThis, _classExtraInitializers);
+    }
+  };
+  return DoorLockCCCapabilitiesGet2 = _classThis;
+})();
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   DoorLockCC,