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

package/build/cjs/cc/VersionCC.js

@@ -0,0 +1,828 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var VersionCC_exports = {};
+__export(VersionCC_exports, {
+  VersionCC: () => VersionCC,
+  VersionCCAPI: () => VersionCCAPI,
+  VersionCCCapabilitiesGet: () => VersionCCCapabilitiesGet,
+  VersionCCCapabilitiesReport: () => VersionCCCapabilitiesReport,
+  VersionCCCommandClassGet: () => VersionCCCommandClassGet,
+  VersionCCCommandClassReport: () => VersionCCCommandClassReport,
+  VersionCCGet: () => VersionCCGet,
+  VersionCCReport: () => VersionCCReport,
+  VersionCCValues: () => VersionCCValues,
+  VersionCCZWaveSoftwareGet: () => VersionCCZWaveSoftwareGet,
+  VersionCCZWaveSoftwareReport: () => VersionCCZWaveSoftwareReport
+});
+module.exports = __toCommonJS(VersionCC_exports);
+var import_safe = require("@zwave-js/core/safe");
+var import_safe2 = require("@zwave-js/shared/safe");
+var import_safe3 = require("@zwave-js/shared/safe");
+var import_API = require("../lib/API.js");
+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 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()) {
+    throw new ZWaveError2(typeName ? `${argName} is not a ${typeName}` : `${argName} has the wrong type`, ZWaveErrorCodes2.Argument_Invalid);
+  }
+}
+const __assertType__VersionCCReportOptions = ($o) => {
+  function su__2__3__4__5__6__7__8__9__10__11__12__13_eu($o2) {
+    return ![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11].includes($o2) ? {} : null;
+  }
+  function _string($o2) {
+    return typeof $o2 !== "string" ? {} : null;
+  }
+  function sa__string_ea_16($o2) {
+    if (!Array.isArray($o2))
+      return {};
+    for (let i = 0; i < $o2.length; i++) {
+      const error = _string($o2[i]);
+      if (error)
+        return error;
+    }
+    return null;
+  }
+  function _number($o2) {
+    return typeof $o2 !== "number" ? {} : null;
+  }
+  function _0($o2) {
+    if (typeof $o2 !== "object" || $o2 === null || Array.isArray($o2))
+      return {};
+    if ("libraryType" in $o2 && $o2["libraryType"] !== void 0) {
+      const error = su__2__3__4__5__6__7__8__9__10__11__12__13_eu($o2["libraryType"]);
+      if (error)
+        return error;
+    } else
+      return {};
+    if ("protocolVersion" in $o2 && $o2["protocolVersion"] !== void 0) {
+      const error = _string($o2["protocolVersion"]);
+      if (error)
+        return error;
+    } else
+      return {};
+    if ("firmwareVersions" in $o2 && $o2["firmwareVersions"] !== void 0) {
+      const error = sa__string_ea_16($o2["firmwareVersions"]);
+      if (error)
+        return error;
+    } else
+      return {};
+    if ("hardwareVersion" in $o2 && $o2["hardwareVersion"] !== void 0) {
+      const error = _number($o2["hardwareVersion"]);
+      if (error)
+        return error;
+    }
+    return null;
+  }
+  return _0($o);
+};
+const __assertType__number = ($o) => {
+  function _number($o2) {
+    return typeof $o2 !== "number" ? {} : null;
+  }
+  return _number($o);
+};
+const VersionCCValues = Object.freeze({
+  ...import_Values.V.defineStaticCCValues(import_safe.CommandClasses.Version, {
+    ...import_Values.V.staticProperty("firmwareVersions", {
+      ...import_safe.ValueMetadata.ReadOnly,
+      type: "string[]",
+      label: "Z-Wave chip firmware versions"
+    }, { supportsEndpoints: false }),
+    ...import_Values.V.staticProperty("libraryType", {
+      ...import_safe.ValueMetadata.ReadOnlyNumber,
+      label: "Library type",
+      states: (0, import_safe.enumValuesToMetadataStates)(import_safe.ZWaveLibraryTypes)
+    }, { supportsEndpoints: false }),
+    ...import_Values.V.staticProperty("protocolVersion", {
+      ...import_safe.ValueMetadata.ReadOnlyString,
+      label: "Z-Wave protocol version"
+    }, { supportsEndpoints: false }),
+    ...import_Values.V.staticProperty("hardwareVersion", {
+      ...import_safe.ValueMetadata.ReadOnlyNumber,
+      label: "Z-Wave chip hardware version"
+    }, {
+      minVersion: 2,
+      supportsEndpoints: false
+    }),
+    ...import_Values.V.staticProperty("supportsZWaveSoftwareGet", void 0, {
+      minVersion: 3,
+      internal: true
+    }),
+    ...import_Values.V.staticProperty("sdkVersion", {
+      ...import_safe.ValueMetadata.ReadOnlyString,
+      label: "SDK version"
+    }, {
+      minVersion: 3,
+      supportsEndpoints: false
+    }),
+    ...import_Values.V.staticProperty("applicationFrameworkAPIVersion", {
+      ...import_safe.ValueMetadata.ReadOnlyString,
+      label: "Z-Wave application framework API version"
+    }, {
+      minVersion: 3,
+      supportsEndpoints: false
+    }),
+    ...import_Values.V.staticProperty("applicationFrameworkBuildNumber", {
+      ...import_safe.ValueMetadata.ReadOnlyString,
+      label: "Z-Wave application framework API build number"
+    }, {
+      minVersion: 3,
+      supportsEndpoints: false
+    }),
+    ...import_Values.V.staticPropertyWithName("serialAPIVersion", "hostInterfaceVersion", {
+      ...import_safe.ValueMetadata.ReadOnlyString,
+      label: "Serial API version"
+    }, {
+      minVersion: 3,
+      supportsEndpoints: false
+    }),
+    ...import_Values.V.staticPropertyWithName("serialAPIBuildNumber", "hostInterfaceBuildNumber", {
+      ...import_safe.ValueMetadata.ReadOnlyString,
+      label: "Serial API build number"
+    }, {
+      minVersion: 3,
+      supportsEndpoints: false
+    }),
+    ...import_Values.V.staticProperty("zWaveProtocolVersion", {
+      ...import_safe.ValueMetadata.ReadOnlyString,
+      label: "Z-Wave protocol version"
+    }, {
+      minVersion: 3,
+      supportsEndpoints: false
+    }),
+    ...import_Values.V.staticProperty("zWaveProtocolBuildNumber", {
+      ...import_safe.ValueMetadata.ReadOnlyString,
+      label: "Z-Wave protocol build number"
+    }, {
+      minVersion: 3,
+      supportsEndpoints: false
+    }),
+    ...import_Values.V.staticProperty("applicationVersion", {
+      ...import_safe.ValueMetadata.ReadOnlyString,
+      label: "Application version"
+    }, {
+      minVersion: 3,
+      supportsEndpoints: false
+    }),
+    ...import_Values.V.staticProperty("applicationBuildNumber", {
+      ...import_safe.ValueMetadata.ReadOnlyString,
+      label: "Application build number"
+    }, {
+      minVersion: 3,
+      supportsEndpoints: false
+    })
+  })
+});
+function parseVersion(buffer) {
+  if (buffer[0] === 0 && buffer[1] === 0 && buffer[2] === 0)
+    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));
+      }
+    }
+    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"
+      ]);
+    }
+  }
+  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 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"
+      ]);
+    }
+  }
+};
+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;
+      }
+      ctx.logNode(node.id, {
+        endpoint: this.endpointIndex,
+        message: `  querying the CC version for ${(0, import_safe.getCCName)(cc)}...`,
+        direction: "outbound"
+      });
+      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: "querying node versions...",
+        direction: "outbound"
+      });
+      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 += `
+  hardware version:  ${versionGetResponse.hardwareVersion}`;
+        }
+        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...",
+        direction: "outbound"
+      });
+      const capsResponse = await api.getCapabilities();
+      if (capsResponse) {
+        const { supportsZWaveSoftwareGet } = capsResponse;
+        ctx.logNode(node.id, {
+          endpoint: this.endpointIndex,
+          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);
+  }
+};
+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 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;
+      }
+      this.payload = import_safe2.Bytes.concat([this.payload, firmwaresBuffer]);
+    }
+    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;
+    }
+    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
+      }
+    };
+  }
+};
+VersionCCCommandClassReport = VersionCCCommandClassReport_1 = __decorate([
+  (0, import_CommandClassDecorators.CCCommand)(import_Types.VersionCommand.CommandClassReport)
+], VersionCCCommandClassReport);
+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
+      }
+    };
+  }
+};
+__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;
+    }
+    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
+    };
+  }
+};
+__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);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  VersionCC,
+  VersionCCAPI,
+  VersionCCCapabilitiesGet,
+  VersionCCCapabilitiesReport,
+  VersionCCCommandClassGet,
+  VersionCCCommandClassReport,
+  VersionCCGet,
+  VersionCCReport,
+  VersionCCValues,
+  VersionCCZWaveSoftwareGet,
+  VersionCCZWaveSoftwareReport
+});
+//# sourceMappingURL=VersionCC.js.map