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

package/build/cjs/cc/VersionCC.js

@@ -39,13 +39,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 VersionCCReport_1, VersionCCCommandClassReport_1, VersionCCCommandClassGet_1, VersionCCCapabilitiesReport_1, VersionCCZWaveSoftwareReport_1;
 function __assertType(argName, typeName, boundHasError) {
   const { ZWaveError: ZWaveError2, ZWaveErrorCodes: ZWaveErrorCodes2 } = require("@zwave-js/core");
   if (boundHasError()) {
@@ -205,612 +237,714 @@ function parseVersion(buffer) {
     return "unused";
   return `${buffer[0]}.${buffer[1]}.${buffer[2]}`;
 }
-let VersionCCAPI = class VersionCCAPI2 extends import_API.PhysicalCCAPI {
-  supportsCommand(cmd) {
-    switch (cmd) {
-      case import_Types.VersionCommand.Get:
-      case import_Types.VersionCommand.Report:
-      case import_Types.VersionCommand.CommandClassGet:
-      case import_Types.VersionCommand.CommandClassReport:
-        return true;
-      // This is mandatory
-      case import_Types.VersionCommand.CapabilitiesGet:
-      case import_Types.VersionCommand.CapabilitiesReport:
-      case import_Types.VersionCommand.ZWaveSoftwareReport:
-        return this.version >= 3;
-      case import_Types.VersionCommand.ZWaveSoftwareGet: {
-        return this.getValueDB().getValue(VersionCCValues.supportsZWaveSoftwareGet.endpoint(this.endpoint.index));
+let VersionCCAPI = (() => {
+  let _classDecorators = [(0, import_CommandClassDecorators.API)(import_safe.CommandClasses.Version)];
+  let _classDescriptor;
+  let _classExtraInitializers = [];
+  let _classThis;
+  let _classSuper = import_API.PhysicalCCAPI;
+  var VersionCCAPI2 = 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);
+      VersionCCAPI2 = _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.VersionCommand.Get:
+        case import_Types.VersionCommand.Report:
+        case import_Types.VersionCommand.CommandClassGet:
+        case import_Types.VersionCommand.CommandClassReport:
+          return true;
+        // This is mandatory
+        case import_Types.VersionCommand.CapabilitiesGet:
+        case import_Types.VersionCommand.CapabilitiesReport:
+        case import_Types.VersionCommand.ZWaveSoftwareReport:
+          return this.version >= 3;
+        case import_Types.VersionCommand.ZWaveSoftwareGet: {
+          return this.getValueDB().getValue(VersionCCValues.supportsZWaveSoftwareGet.endpoint(this.endpoint.index));
+        }
       }
+      return super.supportsCommand(cmd);
     }
-    return super.supportsCommand(cmd);
-  }
-  // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
-  async get() {
-    this.assertSupportsCommand(import_Types.VersionCommand, import_Types.VersionCommand.Get);
-    const cc = new VersionCCGet({
-      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, [
-        "libraryType",
-        "protocolVersion",
-        "firmwareVersions",
-        "hardwareVersion"
-      ]);
+    // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
+    async get() {
+      this.assertSupportsCommand(import_Types.VersionCommand, import_Types.VersionCommand.Get);
+      const cc = new VersionCCGet({
+        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, [
+          "libraryType",
+          "protocolVersion",
+          "firmwareVersions",
+          "hardwareVersion"
+        ]);
+      }
     }
-  }
-  async sendReport(options) {
-    __assertType("options", "VersionCCReportOptions", __assertType__VersionCCReportOptions.bind(void 0, options));
-    this.assertSupportsCommand(import_Types.VersionCommand, import_Types.VersionCommand.Report);
-    const cc = new VersionCCReport({
-      nodeId: this.endpoint.nodeId,
-      endpointIndex: this.endpoint.index,
-      ...options
-    });
-    await this.host.sendCommand(cc, this.commandOptions);
-  }
-  async getCCVersion(requestedCC) {
-    __assertType("requestedCC", "CommandClasses", __assertType__number.bind(void 0, requestedCC));
-    this.assertSupportsCommand(import_Types.VersionCommand, import_Types.VersionCommand.CommandClassGet);
-    const cc = new VersionCCCommandClassGet({
-      nodeId: this.endpoint.nodeId,
-      endpointIndex: this.endpoint.index,
-      requestedCC
-    });
-    const response = await this.host.sendCommand(cc, this.commandOptions);
-    return response?.ccVersion;
-  }
-  async reportCCVersion(requestedCC) {
-    __assertType("requestedCC", "CommandClasses", __assertType__number.bind(void 0, requestedCC));
-    this.assertSupportsCommand(import_Types.VersionCommand, import_Types.VersionCommand.CommandClassReport);
-    let ccVersion;
-    switch (requestedCC) {
-      case import_safe.CommandClasses["Z-Wave Protocol"]:
-      case import_safe.CommandClasses["Z-Wave Long Range"]:
-        ccVersion = 0;
-        break;
-      case import_safe.CommandClasses.Hail:
-      case import_safe.CommandClasses["Manufacturer Proprietary"]:
-        ccVersion = 0;
-        break;
-      default:
-        ccVersion = (0, import_CommandClassDecorators.getImplementedVersion)(requestedCC);
-        break;
-    }
-    const cc = new VersionCCCommandClassReport({
-      nodeId: this.endpoint.nodeId,
-      endpointIndex: this.endpoint.index,
-      requestedCC,
-      ccVersion
-    });
-    await this.host.sendCommand(cc, this.commandOptions);
-  }
-  // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
-  async getCapabilities() {
-    this.assertSupportsCommand(import_Types.VersionCommand, import_Types.VersionCommand.CapabilitiesGet);
-    const cc = new VersionCCCapabilitiesGet({
-      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, ["supportsZWaveSoftwareGet"]);
+    async sendReport(options) {
+      __assertType("options", "VersionCCReportOptions", __assertType__VersionCCReportOptions.bind(void 0, options));
+      this.assertSupportsCommand(import_Types.VersionCommand, import_Types.VersionCommand.Report);
+      const cc = new VersionCCReport({
+        nodeId: this.endpoint.nodeId,
+        endpointIndex: this.endpoint.index,
+        ...options
+      });
+      await this.host.sendCommand(cc, this.commandOptions);
     }
-  }
-  async reportCapabilities() {
-    this.assertSupportsCommand(import_Types.VersionCommand, import_Types.VersionCommand.CapabilitiesReport);
-    const cc = new VersionCCCapabilitiesReport({
-      nodeId: this.endpoint.nodeId,
-      endpointIndex: this.endpoint.index,
-      // At this time, we do not support responding to Z-Wave Software Get
-      supportsZWaveSoftwareGet: false
-    });
-    await this.host.sendCommand(cc, this.commandOptions);
-  }
-  // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
-  async getZWaveSoftware() {
-    this.assertSupportsCommand(import_Types.VersionCommand, import_Types.VersionCommand.ZWaveSoftwareGet);
-    const cc = new VersionCCZWaveSoftwareGet({
-      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, [
-        "sdkVersion",
-        "applicationFrameworkAPIVersion",
-        "applicationFrameworkBuildNumber",
-        "hostInterfaceVersion",
-        "hostInterfaceBuildNumber",
-        "zWaveProtocolVersion",
-        "zWaveProtocolBuildNumber",
-        "applicationVersion",
-        "applicationBuildNumber"
-      ]);
+    async getCCVersion(requestedCC) {
+      __assertType("requestedCC", "CommandClasses", __assertType__number.bind(void 0, requestedCC));
+      this.assertSupportsCommand(import_Types.VersionCommand, import_Types.VersionCommand.CommandClassGet);
+      const cc = new VersionCCCommandClassGet({
+        nodeId: this.endpoint.nodeId,
+        endpointIndex: this.endpoint.index,
+        requestedCC
+      });
+      const response = await this.host.sendCommand(cc, this.commandOptions);
+      return response?.ccVersion;
     }
-  }
-};
-VersionCCAPI = __decorate([
-  (0, import_CommandClassDecorators.API)(import_safe.CommandClasses.Version)
-], VersionCCAPI);
-let VersionCC = class VersionCC2 extends import_CommandClass.CommandClass {
-  determineRequiredCCInterviews() {
-    return [import_safe.CommandClasses["Manufacturer Specific"]];
-  }
-  async interview(ctx) {
-    const node = this.getNode(ctx);
-    const endpoint = this.getEndpoint(ctx);
-    const api = import_API.CCAPI.create(import_safe.CommandClasses.Version, ctx, node).withOptions({
-      priority: import_safe.MessagePriority.NodeQuery
-    });
-    ctx.logNode(node.id, {
-      endpoint: this.endpointIndex,
-      message: `Interviewing ${this.ccName}...`,
-      direction: "none"
-    });
-    const queryCCVersion = async (cc) => {
-      const maxImplemented = (0, import_CommandClassDecorators.getImplementedVersion)(cc);
-      if (maxImplemented === 0) {
-        ctx.logNode(node.id, `  skipping query for ${import_safe.CommandClasses[cc]} (${(0, import_safe3.num2hex)(cc)}) because max implemented version is ${maxImplemented}`);
-        return;
+    async reportCCVersion(requestedCC) {
+      __assertType("requestedCC", "CommandClasses", __assertType__number.bind(void 0, requestedCC));
+      this.assertSupportsCommand(import_Types.VersionCommand, import_Types.VersionCommand.CommandClassReport);
+      let ccVersion;
+      switch (requestedCC) {
+        case import_safe.CommandClasses["Z-Wave Protocol"]:
+        case import_safe.CommandClasses["Z-Wave Long Range"]:
+          ccVersion = 0;
+          break;
+        case import_safe.CommandClasses.Hail:
+        case import_safe.CommandClasses["Manufacturer Proprietary"]:
+          ccVersion = 0;
+          break;
+        default:
+          ccVersion = (0, import_CommandClassDecorators.getImplementedVersion)(requestedCC);
+          break;
+      }
+      const cc = new VersionCCCommandClassReport({
+        nodeId: this.endpoint.nodeId,
+        endpointIndex: this.endpoint.index,
+        requestedCC,
+        ccVersion
+      });
+      await this.host.sendCommand(cc, this.commandOptions);
+    }
+    // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
+    async getCapabilities() {
+      this.assertSupportsCommand(import_Types.VersionCommand, import_Types.VersionCommand.CapabilitiesGet);
+      const cc = new VersionCCCapabilitiesGet({
+        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, ["supportsZWaveSoftwareGet"]);
+      }
+    }
+    async reportCapabilities() {
+      this.assertSupportsCommand(import_Types.VersionCommand, import_Types.VersionCommand.CapabilitiesReport);
+      const cc = new VersionCCCapabilitiesReport({
+        nodeId: this.endpoint.nodeId,
+        endpointIndex: this.endpoint.index,
+        // At this time, we do not support responding to Z-Wave Software Get
+        supportsZWaveSoftwareGet: false
+      });
+      await this.host.sendCommand(cc, this.commandOptions);
+    }
+    // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
+    async getZWaveSoftware() {
+      this.assertSupportsCommand(import_Types.VersionCommand, import_Types.VersionCommand.ZWaveSoftwareGet);
+      const cc = new VersionCCZWaveSoftwareGet({
+        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, [
+          "sdkVersion",
+          "applicationFrameworkAPIVersion",
+          "applicationFrameworkBuildNumber",
+          "hostInterfaceVersion",
+          "hostInterfaceBuildNumber",
+          "zWaveProtocolVersion",
+          "zWaveProtocolBuildNumber",
+          "applicationVersion",
+          "applicationBuildNumber"
+        ]);
       }
+    }
+  };
+  return VersionCCAPI2 = _classThis;
+})();
+let VersionCC = (() => {
+  let _classDecorators = [(0, import_CommandClassDecorators.commandClass)(import_safe.CommandClasses.Version), (0, import_CommandClassDecorators.implementedVersion)(3), (0, import_CommandClassDecorators.ccValues)(VersionCCValues)];
+  let _classDescriptor;
+  let _classExtraInitializers = [];
+  let _classThis;
+  let _classSuper = import_CommandClass.CommandClass;
+  var VersionCC2 = 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);
+      VersionCC2 = _classThis = _classDescriptor.value;
+      if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+      __runInitializers(_classThis, _classExtraInitializers);
+    }
+    determineRequiredCCInterviews() {
+      return [import_safe.CommandClasses["Manufacturer Specific"]];
+    }
+    async interview(ctx) {
+      const node = this.getNode(ctx);
+      const endpoint = this.getEndpoint(ctx);
+      const api = import_API.CCAPI.create(import_safe.CommandClasses.Version, ctx, node).withOptions({
+        priority: import_safe.MessagePriority.NodeQuery
+      });
       ctx.logNode(node.id, {
         endpoint: this.endpointIndex,
-        message: `  querying the CC version for ${(0, import_safe.getCCName)(cc)}...`,
-        direction: "outbound"
+        message: `Interviewing ${this.ccName}...`,
+        direction: "none"
       });
-      const supportedVersion = await api.getCCVersion(cc);
-      if (supportedVersion != void 0) {
-        let logMessage;
-        if (supportedVersion > 0) {
-          if (cc === import_safe.CommandClasses.Basic) {
-            endpoint.addCC(cc, { version: supportedVersion });
-          } else {
-            endpoint.addCC(cc, {
-              isSupported: true,
-              version: supportedVersion
-            });
-          }
-          logMessage = `  supports CC ${import_safe.CommandClasses[cc]} (${(0, import_safe3.num2hex)(cc)}) in version ${supportedVersion}`;
-        } else {
-          if (cc === import_safe.CommandClasses.Version || cc === import_safe.CommandClasses["Manufacturer Specific"]) {
-            logMessage = `  claims NOT to support CC ${import_safe.CommandClasses[cc]} (${(0, import_safe3.num2hex)(cc)}), but it must. Assuming the ${this.endpointIndex === 0 ? "node" : "endpoint"} supports version 1...`;
-            endpoint.addCC(cc, { version: 1 });
-          } else if (cc === import_safe.CommandClasses.Security && node.hasSecurityClass(import_safe.SecurityClass.S0_Legacy) || cc === import_safe.CommandClasses["Security 2"] && import_safe.securityClassOrder.some((sc) => (0, import_safe.securityClassIsS2)(sc) && node.hasSecurityClass(sc))) {
-            logMessage = `  claims NOT to support CC ${import_safe.CommandClasses[cc]} (${(0, import_safe3.num2hex)(cc)}), but it is known to support it. Assuming the ${this.endpointIndex === 0 ? "node" : "endpoint"} supports version 1...`;
-            endpoint.addCC(cc, { version: 1 });
-          } else {
-            logMessage = `  does NOT support CC ${import_safe.CommandClasses[cc]} (${(0, import_safe3.num2hex)(cc)})`;
-            endpoint.removeCC(cc);
-          }
+      const queryCCVersion = async (cc) => {
+        const maxImplemented = (0, import_CommandClassDecorators.getImplementedVersion)(cc);
+        if (maxImplemented === 0) {
+          ctx.logNode(node.id, `  skipping query for ${import_safe.CommandClasses[cc]} (${(0, import_safe3.num2hex)(cc)}) because max implemented version is ${maxImplemented}`);
+          return;
         }
         ctx.logNode(node.id, {
           endpoint: this.endpointIndex,
-          message: logMessage
+          message: `  querying the CC version for ${(0, import_safe.getCCName)(cc)}...`,
+          direction: "outbound"
         });
-      } else {
+        const supportedVersion = await api.getCCVersion(cc);
+        if (supportedVersion != void 0) {
+          let logMessage;
+          if (supportedVersion > 0) {
+            if (cc === import_safe.CommandClasses.Basic) {
+              endpoint.addCC(cc, { version: supportedVersion });
+            } else {
+              endpoint.addCC(cc, {
+                isSupported: true,
+                version: supportedVersion
+              });
+            }
+            logMessage = `  supports CC ${import_safe.CommandClasses[cc]} (${(0, import_safe3.num2hex)(cc)}) in version ${supportedVersion}`;
+          } else {
+            if (cc === import_safe.CommandClasses.Version || cc === import_safe.CommandClasses["Manufacturer Specific"]) {
+              logMessage = `  claims NOT to support CC ${import_safe.CommandClasses[cc]} (${(0, import_safe3.num2hex)(cc)}), but it must. Assuming the ${this.endpointIndex === 0 ? "node" : "endpoint"} supports version 1...`;
+              endpoint.addCC(cc, { version: 1 });
+            } else if (cc === import_safe.CommandClasses.Security && node.hasSecurityClass(import_safe.SecurityClass.S0_Legacy) || cc === import_safe.CommandClasses["Security 2"] && import_safe.securityClassOrder.some((sc) => (0, import_safe.securityClassIsS2)(sc) && node.hasSecurityClass(sc))) {
+              logMessage = `  claims NOT to support CC ${import_safe.CommandClasses[cc]} (${(0, import_safe3.num2hex)(cc)}), but it is known to support it. Assuming the ${this.endpointIndex === 0 ? "node" : "endpoint"} supports version 1...`;
+              endpoint.addCC(cc, { version: 1 });
+            } else {
+              logMessage = `  does NOT support CC ${import_safe.CommandClasses[cc]} (${(0, import_safe3.num2hex)(cc)})`;
+              endpoint.removeCC(cc);
+            }
+          }
+          ctx.logNode(node.id, {
+            endpoint: this.endpointIndex,
+            message: logMessage
+          });
+        } else {
+          ctx.logNode(node.id, {
+            endpoint: this.endpointIndex,
+            message: `CC version query for ${(0, import_safe.getCCName)(cc)} timed out - assuming the ${this.endpointIndex === 0 ? "node" : "endpoint"} supports version 1...`,
+            level: "warn"
+          });
+          endpoint.addCC(cc, { version: 1 });
+        }
+      };
+      if (this.endpointIndex === 0) {
+        await queryCCVersion(import_safe.CommandClasses.Version);
         ctx.logNode(node.id, {
           endpoint: this.endpointIndex,
-          message: `CC version query for ${(0, import_safe.getCCName)(cc)} timed out - assuming the ${this.endpointIndex === 0 ? "node" : "endpoint"} supports version 1...`,
-          level: "warn"
+          message: "querying node versions...",
+          direction: "outbound"
         });
-        endpoint.addCC(cc, { version: 1 });
-      }
-    };
-    if (this.endpointIndex === 0) {
-      await queryCCVersion(import_safe.CommandClasses.Version);
-      ctx.logNode(node.id, {
-        endpoint: this.endpointIndex,
-        message: "querying node versions...",
-        direction: "outbound"
-      });
-      const versionGetResponse = await api.get();
-      if (versionGetResponse) {
-        let logMessage = `received response for node versions:
+        const versionGetResponse = await api.get();
+        if (versionGetResponse) {
+          let logMessage = `received response for node versions:
   library type:      ${import_safe.ZWaveLibraryTypes[versionGetResponse.libraryType]} (${(0, import_safe3.num2hex)(versionGetResponse.libraryType)})
   protocol version:  ${versionGetResponse.protocolVersion}
   firmware versions: ${versionGetResponse.firmwareVersions.join(", ")}`;
-        if (versionGetResponse.hardwareVersion != void 0) {
-          logMessage += `
+          if (versionGetResponse.hardwareVersion != void 0) {
+            logMessage += `
   hardware version:  ${versionGetResponse.hardwareVersion}`;
+          }
+          ctx.logNode(node.id, {
+            endpoint: this.endpointIndex,
+            message: logMessage,
+            direction: "inbound"
+          });
         }
-        ctx.logNode(node.id, {
-          endpoint: this.endpointIndex,
-          message: logMessage,
-          direction: "inbound"
-        });
       }
-    }
-    ctx.logNode(node.id, {
-      endpoint: this.endpointIndex,
-      message: "querying CC versions...",
-      direction: "outbound"
-    });
-    {
-      const cc = import_safe.CommandClasses.Basic;
-      if (this.endpointIndex === 0 || node.getCCVersion(cc) === 0) {
-        await queryCCVersion(cc);
-      }
-    }
-    for (const [cc] of endpoint.getCCs()) {
-      if (cc === import_safe.CommandClasses.Version)
-        continue;
-      if (cc === import_safe.CommandClasses.Basic)
-        continue;
-      if (this.endpointIndex > 0 && node.getCCVersion(cc) > 0)
-        continue;
-      await queryCCVersion(cc);
-    }
-    if (this.endpointIndex === 0 && api.version >= 3) {
       ctx.logNode(node.id, {
         endpoint: this.endpointIndex,
-        message: "querying if Z-Wave Software Get is supported...",
+        message: "querying CC versions...",
         direction: "outbound"
       });
-      const capsResponse = await api.getCapabilities();
-      if (capsResponse) {
-        const { supportsZWaveSoftwareGet } = capsResponse;
+      {
+        const cc = import_safe.CommandClasses.Basic;
+        if (this.endpointIndex === 0 || node.getCCVersion(cc) === 0) {
+          await queryCCVersion(cc);
+        }
+      }
+      for (const [cc] of endpoint.getCCs()) {
+        if (cc === import_safe.CommandClasses.Version)
+          continue;
+        if (cc === import_safe.CommandClasses.Basic)
+          continue;
+        if (this.endpointIndex > 0 && node.getCCVersion(cc) > 0)
+          continue;
+        await queryCCVersion(cc);
+      }
+      if (this.endpointIndex === 0 && api.version >= 3) {
         ctx.logNode(node.id, {
           endpoint: this.endpointIndex,
-          message: `Z-Wave Software Get is${supportsZWaveSoftwareGet ? "" : " not"} supported`,
-          direction: "inbound"
+          message: "querying if Z-Wave Software Get is supported...",
+          direction: "outbound"
         });
-        if (supportsZWaveSoftwareGet) {
-          ctx.logNode(node.id, {
-            endpoint: this.endpointIndex,
-            message: "querying Z-Wave software versions...",
-            direction: "outbound"
-          });
-          await api.getZWaveSoftware();
+        const capsResponse = await api.getCapabilities();
+        if (capsResponse) {
+          const { supportsZWaveSoftwareGet } = capsResponse;
           ctx.logNode(node.id, {
             endpoint: this.endpointIndex,
-            message: "received Z-Wave software versions",
+            message: `Z-Wave Software Get is${supportsZWaveSoftwareGet ? "" : " not"} supported`,
             direction: "inbound"
           });
+          if (supportsZWaveSoftwareGet) {
+            ctx.logNode(node.id, {
+              endpoint: this.endpointIndex,
+              message: "querying Z-Wave software versions...",
+              direction: "outbound"
+            });
+            await api.getZWaveSoftware();
+            ctx.logNode(node.id, {
+              endpoint: this.endpointIndex,
+              message: "received Z-Wave software versions",
+              direction: "inbound"
+            });
+          }
         }
       }
+      this.setInterviewComplete(ctx, true);
     }
-    this.setInterviewComplete(ctx, true);
-  }
-};
-VersionCC = __decorate([
-  (0, import_CommandClassDecorators.commandClass)(import_safe.CommandClasses.Version),
-  (0, import_CommandClassDecorators.implementedVersion)(3),
-  (0, import_CommandClassDecorators.ccValues)(VersionCCValues)
-], VersionCC);
-let VersionCCReport = VersionCCReport_1 = class VersionCCReport2 extends VersionCC {
-  constructor(options) {
-    super(options);
-    if (!/^\d+\.\d+(\.\d+)?$/.test(options.protocolVersion)) {
-      throw new import_safe.ZWaveError(`protocolVersion must be a string in the format "major.minor" or "major.minor.patch", received "${options.protocolVersion}"`, import_safe.ZWaveErrorCodes.Argument_Invalid);
-    } else if (!options.firmwareVersions.every((fw) => /^\d+\.\d+(\.\d+)?$/.test(fw))) {
-      throw new import_safe.ZWaveError(`firmwareVersions must be an array of strings in the format "major.minor" or "major.minor.patch", received "${JSON.stringify(options.firmwareVersions)}"`, import_safe.ZWaveErrorCodes.Argument_Invalid);
-    }
-    this.libraryType = options.libraryType;
-    this.protocolVersion = options.protocolVersion;
-    this.firmwareVersions = options.firmwareVersions;
-    this.hardwareVersion = options.hardwareVersion;
-  }
-  static from(raw, ctx) {
-    (0, import_safe.validatePayload)(raw.payload.length >= 5);
-    const libraryType = raw.payload[0];
-    const protocolVersion = `${raw.payload[1]}.${raw.payload[2]}`;
-    const firmwareVersions = [`${raw.payload[3]}.${raw.payload[4]}`];
-    let hardwareVersion;
-    if (raw.payload.length >= 7) {
-      hardwareVersion = raw.payload[5];
-      const additionalFirmwares = raw.payload[6];
-      (0, import_safe.validatePayload)(raw.payload.length >= 7 + 2 * additionalFirmwares);
-      for (let i = 0; i < additionalFirmwares; i++) {
-        firmwareVersions.push(`${raw.payload[7 + 2 * i]}.${raw.payload[7 + 2 * i + 1]}`);
+  };
+  return VersionCC2 = _classThis;
+})();
+let VersionCCReport = (() => {
+  let _classDecorators = [(0, import_CommandClassDecorators.CCCommand)(import_Types.VersionCommand.Report), (0, import_CommandClassDecorators.ccValueProperty)("libraryType", VersionCCValues.libraryType), (0, import_CommandClassDecorators.ccValueProperty)("protocolVersion", VersionCCValues.protocolVersion), (0, import_CommandClassDecorators.ccValueProperty)("firmwareVersions", VersionCCValues.firmwareVersions), (0, import_CommandClassDecorators.ccValueProperty)("hardwareVersion", VersionCCValues.hardwareVersion)];
+  let _classDescriptor;
+  let _classExtraInitializers = [];
+  let _classThis;
+  let _classSuper = VersionCC;
+  var VersionCCReport2 = 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);
+      VersionCCReport2 = _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 (!/^\d+\.\d+(\.\d+)?$/.test(options.protocolVersion)) {
+        throw new import_safe.ZWaveError(`protocolVersion must be a string in the format "major.minor" or "major.minor.patch", received "${options.protocolVersion}"`, import_safe.ZWaveErrorCodes.Argument_Invalid);
+      } else if (!options.firmwareVersions.every((fw) => /^\d+\.\d+(\.\d+)?$/.test(fw))) {
+        throw new import_safe.ZWaveError(`firmwareVersions must be an array of strings in the format "major.minor" or "major.minor.patch", received "${JSON.stringify(options.firmwareVersions)}"`, import_safe.ZWaveErrorCodes.Argument_Invalid);
       }
+      this.libraryType = options.libraryType;
+      this.protocolVersion = options.protocolVersion;
+      this.firmwareVersions = options.firmwareVersions;
+      this.hardwareVersion = options.hardwareVersion;
     }
-    return new VersionCCReport_1({
-      nodeId: ctx.sourceNodeId,
-      libraryType,
-      protocolVersion,
-      firmwareVersions,
-      hardwareVersion
-    });
-  }
-  libraryType;
-  protocolVersion;
-  firmwareVersions;
-  hardwareVersion;
-  serialize(ctx) {
-    this.payload = import_safe2.Bytes.from([
-      this.libraryType,
-      ...this.protocolVersion.split(".").map((n) => parseInt(n)).slice(0, 2),
-      ...this.firmwareVersions[0].split(".").map((n) => parseInt(n)).slice(0, 2),
-      this.hardwareVersion ?? 0,
-      this.firmwareVersions.length - 1
-    ]);
-    if (this.firmwareVersions.length > 1) {
-      const firmwaresBuffer = new import_safe2.Bytes((this.firmwareVersions.length - 1) * 2);
-      for (let i = 1; i < this.firmwareVersions.length; i++) {
-        const [major, minor] = this.firmwareVersions[i].split(".").map((n) => parseInt(n));
-        firmwaresBuffer[2 * (i - 1)] = major;
-        firmwaresBuffer[2 * (i - 1) + 1] = minor;
+    static from(raw, ctx) {
+      (0, import_safe.validatePayload)(raw.payload.length >= 5);
+      const libraryType = raw.payload[0];
+      const protocolVersion = `${raw.payload[1]}.${raw.payload[2]}`;
+      const firmwareVersions = [`${raw.payload[3]}.${raw.payload[4]}`];
+      let hardwareVersion;
+      if (raw.payload.length >= 7) {
+        hardwareVersion = raw.payload[5];
+        const additionalFirmwares = raw.payload[6];
+        (0, import_safe.validatePayload)(raw.payload.length >= 7 + 2 * additionalFirmwares);
+        for (let i = 0; i < additionalFirmwares; i++) {
+          firmwareVersions.push(`${raw.payload[7 + 2 * i]}.${raw.payload[7 + 2 * i + 1]}`);
+        }
       }
-      this.payload = import_safe2.Bytes.concat([this.payload, firmwaresBuffer]);
+      return new this({
+        nodeId: ctx.sourceNodeId,
+        libraryType,
+        protocolVersion,
+        firmwareVersions,
+        hardwareVersion
+      });
     }
-    return super.serialize(ctx);
-  }
-  toLogEntry(ctx) {
-    const message = {
-      "library type": (0, import_safe3.getEnumMemberName)(import_safe.ZWaveLibraryTypes, this.libraryType),
-      "protocol version": this.protocolVersion,
-      "firmware versions": this.firmwareVersions.join(", ")
-    };
-    if (this.hardwareVersion != void 0) {
-      message["hardware version"] = this.hardwareVersion;
+    libraryType;
+    protocolVersion;
+    firmwareVersions;
+    hardwareVersion;
+    serialize(ctx) {
+      this.payload = import_safe2.Bytes.from([
+        this.libraryType,
+        ...this.protocolVersion.split(".").map((n) => parseInt(n)).slice(0, 2),
+        ...this.firmwareVersions[0].split(".").map((n) => parseInt(n)).slice(0, 2),
+        this.hardwareVersion ?? 0,
+        this.firmwareVersions.length - 1
+      ]);
+      if (this.firmwareVersions.length > 1) {
+        const firmwaresBuffer = new import_safe2.Bytes((this.firmwareVersions.length - 1) * 2);
+        for (let i = 1; i < this.firmwareVersions.length; i++) {
+          const [major, minor] = this.firmwareVersions[i].split(".").map((n) => parseInt(n));
+          firmwaresBuffer[2 * (i - 1)] = major;
+          firmwaresBuffer[2 * (i - 1) + 1] = minor;
+        }
+        this.payload = import_safe2.Bytes.concat([this.payload, firmwaresBuffer]);
+      }
+      return super.serialize(ctx);
     }
-    return {
-      ...super.toLogEntry(ctx),
-      message
-    };
-  }
-};
-__decorate([
-  (0, import_CommandClassDecorators.ccValue)(VersionCCValues.libraryType)
-], VersionCCReport.prototype, "libraryType", void 0);
-__decorate([
-  (0, import_CommandClassDecorators.ccValue)(VersionCCValues.protocolVersion)
-], VersionCCReport.prototype, "protocolVersion", void 0);
-__decorate([
-  (0, import_CommandClassDecorators.ccValue)(VersionCCValues.firmwareVersions)
-], VersionCCReport.prototype, "firmwareVersions", void 0);
-__decorate([
-  (0, import_CommandClassDecorators.ccValue)(VersionCCValues.hardwareVersion)
-], VersionCCReport.prototype, "hardwareVersion", void 0);
-VersionCCReport = VersionCCReport_1 = __decorate([
-  (0, import_CommandClassDecorators.CCCommand)(import_Types.VersionCommand.Report)
-], VersionCCReport);
-let VersionCCGet = class VersionCCGet2 extends VersionCC {
-};
-VersionCCGet = __decorate([
-  (0, import_CommandClassDecorators.CCCommand)(import_Types.VersionCommand.Get),
-  (0, import_CommandClassDecorators.expectedCCResponse)(VersionCCReport)
-], VersionCCGet);
-let VersionCCCommandClassReport = VersionCCCommandClassReport_1 = class VersionCCCommandClassReport2 extends VersionCC {
-  constructor(options) {
-    super(options);
-    this.requestedCC = options.requestedCC;
-    this.ccVersion = options.ccVersion;
-  }
-  static from(raw, ctx) {
-    (0, import_safe.validatePayload)(raw.payload.length >= 2);
-    const requestedCC = raw.payload[0];
-    const ccVersion = raw.payload[1];
-    return new VersionCCCommandClassReport_1({
-      nodeId: ctx.sourceNodeId,
-      requestedCC,
-      ccVersion
-    });
-  }
-  ccVersion;
-  requestedCC;
-  serialize(ctx) {
-    this.payload = import_safe2.Bytes.from([this.requestedCC, this.ccVersion]);
-    return super.serialize(ctx);
-  }
-  toLogEntry(ctx) {
-    return {
-      ...super.toLogEntry(ctx),
-      message: {
-        CC: (0, import_safe.getCCName)(this.requestedCC),
-        version: this.ccVersion
+    toLogEntry(ctx) {
+      const message = {
+        "library type": (0, import_safe3.getEnumMemberName)(import_safe.ZWaveLibraryTypes, this.libraryType),
+        "protocol version": this.protocolVersion,
+        "firmware versions": this.firmwareVersions.join(", ")
+      };
+      if (this.hardwareVersion != void 0) {
+        message["hardware version"] = this.hardwareVersion;
       }
-    };
-  }
-};
-VersionCCCommandClassReport = VersionCCCommandClassReport_1 = __decorate([
-  (0, import_CommandClassDecorators.CCCommand)(import_Types.VersionCommand.CommandClassReport)
-], VersionCCCommandClassReport);
+      return {
+        ...super.toLogEntry(ctx),
+        message
+      };
+    }
+  };
+  return VersionCCReport2 = _classThis;
+})();
+let VersionCCGet = (() => {
+  let _classDecorators = [(0, import_CommandClassDecorators.CCCommand)(import_Types.VersionCommand.Get), (0, import_CommandClassDecorators.expectedCCResponse)(VersionCCReport)];
+  let _classDescriptor;
+  let _classExtraInitializers = [];
+  let _classThis;
+  let _classSuper = VersionCC;
+  var VersionCCGet2 = 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);
+      VersionCCGet2 = _classThis = _classDescriptor.value;
+      if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+      __runInitializers(_classThis, _classExtraInitializers);
+    }
+  };
+  return VersionCCGet2 = _classThis;
+})();
+let VersionCCCommandClassReport = (() => {
+  let _classDecorators = [(0, import_CommandClassDecorators.CCCommand)(import_Types.VersionCommand.CommandClassReport)];
+  let _classDescriptor;
+  let _classExtraInitializers = [];
+  let _classThis;
+  let _classSuper = VersionCC;
+  var VersionCCCommandClassReport2 = 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);
+      VersionCCCommandClassReport2 = _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);
+      this.requestedCC = options.requestedCC;
+      this.ccVersion = options.ccVersion;
+    }
+    static from(raw, ctx) {
+      (0, import_safe.validatePayload)(raw.payload.length >= 2);
+      const requestedCC = raw.payload[0];
+      const ccVersion = raw.payload[1];
+      return new this({
+        nodeId: ctx.sourceNodeId,
+        requestedCC,
+        ccVersion
+      });
+    }
+    ccVersion;
+    requestedCC;
+    serialize(ctx) {
+      this.payload = import_safe2.Bytes.from([this.requestedCC, this.ccVersion]);
+      return super.serialize(ctx);
+    }
+    toLogEntry(ctx) {
+      return {
+        ...super.toLogEntry(ctx),
+        message: {
+          CC: (0, import_safe.getCCName)(this.requestedCC),
+          version: this.ccVersion
+        }
+      };
+    }
+  };
+  return VersionCCCommandClassReport2 = _classThis;
+})();
 function testResponseForVersionCommandClassGet(sent, received) {
   return sent.requestedCC === received.requestedCC;
 }
-let VersionCCCommandClassGet = VersionCCCommandClassGet_1 = class VersionCCCommandClassGet2 extends VersionCC {
-  constructor(options) {
-    super(options);
-    this.requestedCC = options.requestedCC;
-  }
-  static from(raw, ctx) {
-    (0, import_safe.validatePayload)(raw.payload.length >= 1);
-    const requestedCC = raw.payload[0];
-    return new VersionCCCommandClassGet_1({
-      nodeId: ctx.sourceNodeId,
-      requestedCC
-    });
-  }
-  requestedCC;
-  serialize(ctx) {
-    this.payload = import_safe2.Bytes.from([this.requestedCC]);
-    return super.serialize(ctx);
-  }
-  toLogEntry(ctx) {
-    return {
-      ...super.toLogEntry(ctx),
-      message: { CC: (0, import_safe.getCCName)(this.requestedCC) }
-    };
-  }
-};
-VersionCCCommandClassGet = VersionCCCommandClassGet_1 = __decorate([
-  (0, import_CommandClassDecorators.CCCommand)(import_Types.VersionCommand.CommandClassGet),
-  (0, import_CommandClassDecorators.expectedCCResponse)(VersionCCCommandClassReport, testResponseForVersionCommandClassGet)
-], VersionCCCommandClassGet);
-let VersionCCCapabilitiesReport = VersionCCCapabilitiesReport_1 = class VersionCCCapabilitiesReport2 extends VersionCC {
-  constructor(options) {
-    super(options);
-    this.supportsZWaveSoftwareGet = options.supportsZWaveSoftwareGet;
-  }
-  static from(raw, ctx) {
-    (0, import_safe.validatePayload)(raw.payload.length >= 1);
-    const capabilities = raw.payload[0];
-    const supportsZWaveSoftwareGet = !!(capabilities & 4);
-    return new VersionCCCapabilitiesReport_1({
-      nodeId: ctx.sourceNodeId,
-      supportsZWaveSoftwareGet
-    });
-  }
-  supportsZWaveSoftwareGet;
-  serialize(ctx) {
-    this.payload = import_safe2.Bytes.from([
-      (this.supportsZWaveSoftwareGet ? 4 : 0) | 3
-    ]);
-    return super.serialize(ctx);
-  }
-  toLogEntry(ctx) {
-    return {
-      ...super.toLogEntry(ctx),
-      message: {
-        "supports Z-Wave Software Get command": this.supportsZWaveSoftwareGet
+let VersionCCCommandClassGet = (() => {
+  let _classDecorators = [(0, import_CommandClassDecorators.CCCommand)(import_Types.VersionCommand.CommandClassGet), (0, import_CommandClassDecorators.expectedCCResponse)(VersionCCCommandClassReport, testResponseForVersionCommandClassGet)];
+  let _classDescriptor;
+  let _classExtraInitializers = [];
+  let _classThis;
+  let _classSuper = VersionCC;
+  var VersionCCCommandClassGet2 = 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);
+      VersionCCCommandClassGet2 = _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);
+      this.requestedCC = options.requestedCC;
+    }
+    static from(raw, ctx) {
+      (0, import_safe.validatePayload)(raw.payload.length >= 1);
+      const requestedCC = raw.payload[0];
+      return new this({
+        nodeId: ctx.sourceNodeId,
+        requestedCC
+      });
+    }
+    requestedCC;
+    serialize(ctx) {
+      this.payload = import_safe2.Bytes.from([this.requestedCC]);
+      return super.serialize(ctx);
+    }
+    toLogEntry(ctx) {
+      return {
+        ...super.toLogEntry(ctx),
+        message: { CC: (0, import_safe.getCCName)(this.requestedCC) }
+      };
+    }
+  };
+  return VersionCCCommandClassGet2 = _classThis;
+})();
+let VersionCCCapabilitiesReport = (() => {
+  let _classDecorators = [(0, import_CommandClassDecorators.CCCommand)(import_Types.VersionCommand.CapabilitiesReport), (0, import_CommandClassDecorators.ccValueProperty)("supportsZWaveSoftwareGet", VersionCCValues.supportsZWaveSoftwareGet)];
+  let _classDescriptor;
+  let _classExtraInitializers = [];
+  let _classThis;
+  let _classSuper = VersionCC;
+  var VersionCCCapabilitiesReport2 = 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);
+      VersionCCCapabilitiesReport2 = _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);
+      this.supportsZWaveSoftwareGet = options.supportsZWaveSoftwareGet;
+    }
+    static from(raw, ctx) {
+      (0, import_safe.validatePayload)(raw.payload.length >= 1);
+      const capabilities = raw.payload[0];
+      const supportsZWaveSoftwareGet = !!(capabilities & 4);
+      return new this({
+        nodeId: ctx.sourceNodeId,
+        supportsZWaveSoftwareGet
+      });
+    }
+    supportsZWaveSoftwareGet;
+    serialize(ctx) {
+      this.payload = import_safe2.Bytes.from([
+        (this.supportsZWaveSoftwareGet ? 4 : 0) | 3
+      ]);
+      return super.serialize(ctx);
+    }
+    toLogEntry(ctx) {
+      return {
+        ...super.toLogEntry(ctx),
+        message: {
+          "supports Z-Wave Software Get command": this.supportsZWaveSoftwareGet
+        }
+      };
+    }
+  };
+  return VersionCCCapabilitiesReport2 = _classThis;
+})();
+let VersionCCCapabilitiesGet = (() => {
+  let _classDecorators = [(0, import_CommandClassDecorators.CCCommand)(import_Types.VersionCommand.CapabilitiesGet), (0, import_CommandClassDecorators.expectedCCResponse)(VersionCCCapabilitiesReport)];
+  let _classDescriptor;
+  let _classExtraInitializers = [];
+  let _classThis;
+  let _classSuper = VersionCC;
+  var VersionCCCapabilitiesGet2 = 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);
+      VersionCCCapabilitiesGet2 = _classThis = _classDescriptor.value;
+      if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+      __runInitializers(_classThis, _classExtraInitializers);
+    }
+  };
+  return VersionCCCapabilitiesGet2 = _classThis;
+})();
+let VersionCCZWaveSoftwareReport = (() => {
+  let _classDecorators = [(0, import_CommandClassDecorators.CCCommand)(import_Types.VersionCommand.ZWaveSoftwareReport), (0, import_CommandClassDecorators.ccValueProperty)("sdkVersion", VersionCCValues.sdkVersion), (0, import_CommandClassDecorators.ccValueProperty)("applicationFrameworkAPIVersion", VersionCCValues.applicationFrameworkAPIVersion), (0, import_CommandClassDecorators.ccValueProperty)("applicationFrameworkBuildNumber", VersionCCValues.applicationFrameworkBuildNumber), (0, import_CommandClassDecorators.ccValueProperty)("hostInterfaceVersion", VersionCCValues.serialAPIVersion), (0, import_CommandClassDecorators.ccValueProperty)("hostInterfaceBuildNumber", VersionCCValues.serialAPIBuildNumber), (0, import_CommandClassDecorators.ccValueProperty)("zWaveProtocolVersion", VersionCCValues.zWaveProtocolVersion), (0, import_CommandClassDecorators.ccValueProperty)("zWaveProtocolBuildNumber", VersionCCValues.zWaveProtocolBuildNumber), (0, import_CommandClassDecorators.ccValueProperty)("applicationVersion", VersionCCValues.applicationVersion), (0, import_CommandClassDecorators.ccValueProperty)("applicationBuildNumber", VersionCCValues.applicationBuildNumber)];
+  let _classDescriptor;
+  let _classExtraInitializers = [];
+  let _classThis;
+  let _classSuper = VersionCC;
+  var VersionCCZWaveSoftwareReport2 = 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);
+      VersionCCZWaveSoftwareReport2 = _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);
+      this.sdkVersion = options.sdkVersion;
+      this.applicationFrameworkAPIVersion = options.applicationFrameworkAPIVersion;
+      this.applicationFrameworkBuildNumber = options.applicationFrameworkBuildNumber;
+      this.hostInterfaceVersion = options.hostInterfaceVersion;
+      this.hostInterfaceBuildNumber = options.hostInterfaceBuildNumber;
+      this.zWaveProtocolVersion = options.zWaveProtocolVersion;
+      this.zWaveProtocolBuildNumber = options.zWaveProtocolBuildNumber;
+      this.applicationVersion = options.applicationVersion;
+      this.applicationBuildNumber = options.applicationBuildNumber;
+    }
+    static from(raw, ctx) {
+      (0, import_safe.validatePayload)(raw.payload.length >= 23);
+      const sdkVersion = parseVersion(raw.payload);
+      const applicationFrameworkAPIVersion = parseVersion(raw.payload.subarray(3));
+      let applicationFrameworkBuildNumber;
+      if (applicationFrameworkAPIVersion !== "unused") {
+        applicationFrameworkBuildNumber = raw.payload.readUInt16BE(6);
+      } else {
+        applicationFrameworkBuildNumber = 0;
       }
-    };
-  }
-};
-__decorate([
-  (0, import_CommandClassDecorators.ccValue)(VersionCCValues.supportsZWaveSoftwareGet)
-], VersionCCCapabilitiesReport.prototype, "supportsZWaveSoftwareGet", void 0);
-VersionCCCapabilitiesReport = VersionCCCapabilitiesReport_1 = __decorate([
-  (0, import_CommandClassDecorators.CCCommand)(import_Types.VersionCommand.CapabilitiesReport)
-], VersionCCCapabilitiesReport);
-let VersionCCCapabilitiesGet = class VersionCCCapabilitiesGet2 extends VersionCC {
-};
-VersionCCCapabilitiesGet = __decorate([
-  (0, import_CommandClassDecorators.CCCommand)(import_Types.VersionCommand.CapabilitiesGet),
-  (0, import_CommandClassDecorators.expectedCCResponse)(VersionCCCapabilitiesReport)
-], VersionCCCapabilitiesGet);
-let VersionCCZWaveSoftwareReport = VersionCCZWaveSoftwareReport_1 = class VersionCCZWaveSoftwareReport2 extends VersionCC {
-  constructor(options) {
-    super(options);
-    this.sdkVersion = options.sdkVersion;
-    this.applicationFrameworkAPIVersion = options.applicationFrameworkAPIVersion;
-    this.applicationFrameworkBuildNumber = options.applicationFrameworkBuildNumber;
-    this.hostInterfaceVersion = options.hostInterfaceVersion;
-    this.hostInterfaceBuildNumber = options.hostInterfaceBuildNumber;
-    this.zWaveProtocolVersion = options.zWaveProtocolVersion;
-    this.zWaveProtocolBuildNumber = options.zWaveProtocolBuildNumber;
-    this.applicationVersion = options.applicationVersion;
-    this.applicationBuildNumber = options.applicationBuildNumber;
-  }
-  static from(raw, ctx) {
-    (0, import_safe.validatePayload)(raw.payload.length >= 23);
-    const sdkVersion = parseVersion(raw.payload);
-    const applicationFrameworkAPIVersion = parseVersion(raw.payload.subarray(3));
-    let applicationFrameworkBuildNumber;
-    if (applicationFrameworkAPIVersion !== "unused") {
-      applicationFrameworkBuildNumber = raw.payload.readUInt16BE(6);
-    } else {
-      applicationFrameworkBuildNumber = 0;
-    }
-    const hostInterfaceVersion = parseVersion(raw.payload.subarray(8));
-    let hostInterfaceBuildNumber;
-    if (hostInterfaceVersion !== "unused") {
-      hostInterfaceBuildNumber = raw.payload.readUInt16BE(11);
-    } else {
-      hostInterfaceBuildNumber = 0;
-    }
-    const zWaveProtocolVersion = parseVersion(raw.payload.subarray(13));
-    let zWaveProtocolBuildNumber;
-    if (zWaveProtocolVersion !== "unused") {
-      zWaveProtocolBuildNumber = raw.payload.readUInt16BE(16);
-    } else {
-      zWaveProtocolBuildNumber = 0;
-    }
-    const applicationVersion = parseVersion(raw.payload.subarray(18));
-    let applicationBuildNumber;
-    if (applicationVersion !== "unused") {
-      applicationBuildNumber = raw.payload.readUInt16BE(21);
-    } else {
-      applicationBuildNumber = 0;
-    }
-    return new VersionCCZWaveSoftwareReport_1({
-      nodeId: ctx.sourceNodeId,
-      sdkVersion,
-      applicationFrameworkAPIVersion,
-      applicationFrameworkBuildNumber,
-      hostInterfaceVersion,
-      hostInterfaceBuildNumber,
-      zWaveProtocolVersion,
-      zWaveProtocolBuildNumber,
-      applicationVersion,
-      applicationBuildNumber
-    });
-  }
-  sdkVersion;
-  applicationFrameworkAPIVersion;
-  applicationFrameworkBuildNumber;
-  hostInterfaceVersion;
-  hostInterfaceBuildNumber;
-  zWaveProtocolVersion;
-  zWaveProtocolBuildNumber;
-  applicationVersion;
-  applicationBuildNumber;
-  toLogEntry(ctx) {
-    const message = {
-      "SDK version": this.sdkVersion
-    };
-    message["appl. framework API version"] = this.applicationFrameworkAPIVersion;
-    if (this.applicationFrameworkAPIVersion !== "unused") {
-      message["appl. framework build number"] = this.applicationFrameworkBuildNumber;
+      const hostInterfaceVersion = parseVersion(raw.payload.subarray(8));
+      let hostInterfaceBuildNumber;
+      if (hostInterfaceVersion !== "unused") {
+        hostInterfaceBuildNumber = raw.payload.readUInt16BE(11);
+      } else {
+        hostInterfaceBuildNumber = 0;
+      }
+      const zWaveProtocolVersion = parseVersion(raw.payload.subarray(13));
+      let zWaveProtocolBuildNumber;
+      if (zWaveProtocolVersion !== "unused") {
+        zWaveProtocolBuildNumber = raw.payload.readUInt16BE(16);
+      } else {
+        zWaveProtocolBuildNumber = 0;
+      }
+      const applicationVersion = parseVersion(raw.payload.subarray(18));
+      let applicationBuildNumber;
+      if (applicationVersion !== "unused") {
+        applicationBuildNumber = raw.payload.readUInt16BE(21);
+      } else {
+        applicationBuildNumber = 0;
+      }
+      return new this({
+        nodeId: ctx.sourceNodeId,
+        sdkVersion,
+        applicationFrameworkAPIVersion,
+        applicationFrameworkBuildNumber,
+        hostInterfaceVersion,
+        hostInterfaceBuildNumber,
+        zWaveProtocolVersion,
+        zWaveProtocolBuildNumber,
+        applicationVersion,
+        applicationBuildNumber
+      });
     }
-    message["host interface version"] = this.hostInterfaceVersion;
-    if (this.hostInterfaceVersion !== "unused") {
-      message["host interface  build number"] = this.hostInterfaceBuildNumber;
+    sdkVersion;
+    applicationFrameworkAPIVersion;
+    applicationFrameworkBuildNumber;
+    hostInterfaceVersion;
+    hostInterfaceBuildNumber;
+    zWaveProtocolVersion;
+    zWaveProtocolBuildNumber;
+    applicationVersion;
+    applicationBuildNumber;
+    toLogEntry(ctx) {
+      const message = {
+        "SDK version": this.sdkVersion
+      };
+      message["appl. framework API version"] = this.applicationFrameworkAPIVersion;
+      if (this.applicationFrameworkAPIVersion !== "unused") {
+        message["appl. framework build number"] = this.applicationFrameworkBuildNumber;
+      }
+      message["host interface version"] = this.hostInterfaceVersion;
+      if (this.hostInterfaceVersion !== "unused") {
+        message["host interface  build number"] = this.hostInterfaceBuildNumber;
+      }
+      message["Z-Wave protocol version"] = this.zWaveProtocolVersion;
+      if (this.zWaveProtocolVersion !== "unused") {
+        message["Z-Wave protocol build number"] = this.zWaveProtocolBuildNumber;
+      }
+      message["application version"] = this.applicationVersion;
+      if (this.applicationVersion !== "unused") {
+        message["application build number"] = this.applicationBuildNumber;
+      }
+      return {
+        ...super.toLogEntry(ctx),
+        message
+      };
     }
-    message["Z-Wave protocol version"] = this.zWaveProtocolVersion;
-    if (this.zWaveProtocolVersion !== "unused") {
-      message["Z-Wave protocol build number"] = this.zWaveProtocolBuildNumber;
+  };
+  return VersionCCZWaveSoftwareReport2 = _classThis;
+})();
+let VersionCCZWaveSoftwareGet = (() => {
+  let _classDecorators = [(0, import_CommandClassDecorators.CCCommand)(import_Types.VersionCommand.ZWaveSoftwareGet), (0, import_CommandClassDecorators.expectedCCResponse)(VersionCCZWaveSoftwareReport)];
+  let _classDescriptor;
+  let _classExtraInitializers = [];
+  let _classThis;
+  let _classSuper = VersionCC;
+  var VersionCCZWaveSoftwareGet2 = class extends _classSuper {
+    static {
+      _classThis = this;
     }
-    message["application version"] = this.applicationVersion;
-    if (this.applicationVersion !== "unused") {
-      message["application build number"] = this.applicationBuildNumber;
+    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);
+      VersionCCZWaveSoftwareGet2 = _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)(VersionCCValues.sdkVersion)
-], VersionCCZWaveSoftwareReport.prototype, "sdkVersion", void 0);
-__decorate([
-  (0, import_CommandClassDecorators.ccValue)(VersionCCValues.applicationFrameworkAPIVersion)
-], VersionCCZWaveSoftwareReport.prototype, "applicationFrameworkAPIVersion", void 0);
-__decorate([
-  (0, import_CommandClassDecorators.ccValue)(VersionCCValues.applicationFrameworkBuildNumber)
-], VersionCCZWaveSoftwareReport.prototype, "applicationFrameworkBuildNumber", void 0);
-__decorate([
-  (0, import_CommandClassDecorators.ccValue)(VersionCCValues.serialAPIVersion)
-], VersionCCZWaveSoftwareReport.prototype, "hostInterfaceVersion", void 0);
-__decorate([
-  (0, import_CommandClassDecorators.ccValue)(VersionCCValues.serialAPIBuildNumber)
-], VersionCCZWaveSoftwareReport.prototype, "hostInterfaceBuildNumber", void 0);
-__decorate([
-  (0, import_CommandClassDecorators.ccValue)(VersionCCValues.zWaveProtocolVersion)
-], VersionCCZWaveSoftwareReport.prototype, "zWaveProtocolVersion", void 0);
-__decorate([
-  (0, import_CommandClassDecorators.ccValue)(VersionCCValues.zWaveProtocolBuildNumber)
-], VersionCCZWaveSoftwareReport.prototype, "zWaveProtocolBuildNumber", void 0);
-__decorate([
-  (0, import_CommandClassDecorators.ccValue)(VersionCCValues.applicationVersion)
-], VersionCCZWaveSoftwareReport.prototype, "applicationVersion", void 0);
-__decorate([
-  (0, import_CommandClassDecorators.ccValue)(VersionCCValues.applicationBuildNumber)
-], VersionCCZWaveSoftwareReport.prototype, "applicationBuildNumber", void 0);
-VersionCCZWaveSoftwareReport = VersionCCZWaveSoftwareReport_1 = __decorate([
-  (0, import_CommandClassDecorators.CCCommand)(import_Types.VersionCommand.ZWaveSoftwareReport)
-], VersionCCZWaveSoftwareReport);
-let VersionCCZWaveSoftwareGet = class VersionCCZWaveSoftwareGet2 extends VersionCC {
-};
-VersionCCZWaveSoftwareGet = __decorate([
-  (0, import_CommandClassDecorators.CCCommand)(import_Types.VersionCommand.ZWaveSoftwareGet),
-  (0, import_CommandClassDecorators.expectedCCResponse)(VersionCCZWaveSoftwareReport)
-], VersionCCZWaveSoftwareGet);
+  };
+  return VersionCCZWaveSoftwareGet2 = _classThis;
+})();
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   VersionCC,