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

package/build/cjs/cc/FirmwareUpdateMetaDataCC.js

@@ -0,0 +1,1122 @@
+"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 FirmwareUpdateMetaDataCC_exports = {};
+__export(FirmwareUpdateMetaDataCC_exports, {
+  FirmwareUpdateMetaDataCC: () => FirmwareUpdateMetaDataCC,
+  FirmwareUpdateMetaDataCCAPI: () => FirmwareUpdateMetaDataCCAPI,
+  FirmwareUpdateMetaDataCCActivationReport: () => FirmwareUpdateMetaDataCCActivationReport,
+  FirmwareUpdateMetaDataCCActivationSet: () => FirmwareUpdateMetaDataCCActivationSet,
+  FirmwareUpdateMetaDataCCGet: () => FirmwareUpdateMetaDataCCGet,
+  FirmwareUpdateMetaDataCCMetaDataGet: () => FirmwareUpdateMetaDataCCMetaDataGet,
+  FirmwareUpdateMetaDataCCMetaDataReport: () => FirmwareUpdateMetaDataCCMetaDataReport,
+  FirmwareUpdateMetaDataCCPrepareGet: () => FirmwareUpdateMetaDataCCPrepareGet,
+  FirmwareUpdateMetaDataCCPrepareReport: () => FirmwareUpdateMetaDataCCPrepareReport,
+  FirmwareUpdateMetaDataCCReport: () => FirmwareUpdateMetaDataCCReport,
+  FirmwareUpdateMetaDataCCRequestGet: () => FirmwareUpdateMetaDataCCRequestGet,
+  FirmwareUpdateMetaDataCCRequestReport: () => FirmwareUpdateMetaDataCCRequestReport,
+  FirmwareUpdateMetaDataCCStatusReport: () => FirmwareUpdateMetaDataCCStatusReport,
+  FirmwareUpdateMetaDataCCValues: () => FirmwareUpdateMetaDataCCValues
+});
+module.exports = __toCommonJS(FirmwareUpdateMetaDataCC_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 FirmwareUpdateMetaDataCCMetaDataReport_1, FirmwareUpdateMetaDataCCRequestReport_1, FirmwareUpdateMetaDataCCGet_1, FirmwareUpdateMetaDataCCStatusReport_1, FirmwareUpdateMetaDataCCActivationReport_1, FirmwareUpdateMetaDataCCPrepareReport_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__FirmwareUpdateMetaDataCCMetaDataReportOptions = ($o) => {
+  function _number($o2) {
+    return typeof $o2 !== "number" ? {} : null;
+  }
+  function _boolean($o2) {
+    return typeof $o2 !== "boolean" ? {} : null;
+  }
+  function sa__number_ea_3($o2) {
+    if (!Array.isArray($o2))
+      return {};
+    for (let i = 0; i < $o2.length; i++) {
+      const error = _number($o2[i]);
+      if (error)
+        return error;
+    }
+    return null;
+  }
+  function _undefined($o2) {
+    return $o2 !== void 0 ? {} : null;
+  }
+  function _false($o2) {
+    return $o2 !== false ? {} : null;
+  }
+  function _true($o2) {
+    return $o2 !== true ? {} : null;
+  }
+  function su__undefined__6__7_eu($o2) {
+    const conditions = [_undefined, _false, _true];
+    for (const condition of conditions) {
+      const error = condition($o2);
+      if (!error)
+        return null;
+    }
+    return {};
+  }
+  function _0($o2) {
+    if (typeof $o2 !== "object" || $o2 === null || Array.isArray($o2))
+      return {};
+    if ("manufacturerId" in $o2 && $o2["manufacturerId"] !== void 0) {
+      const error = _number($o2["manufacturerId"]);
+      if (error)
+        return error;
+    } else
+      return {};
+    if ("firmwareId" in $o2 && $o2["firmwareId"] !== void 0) {
+      const error = _number($o2["firmwareId"]);
+      if (error)
+        return error;
+    }
+    if ("checksum" in $o2 && $o2["checksum"] !== void 0) {
+      const error = _number($o2["checksum"]);
+      if (error)
+        return error;
+    }
+    if ("firmwareUpgradable" in $o2 && $o2["firmwareUpgradable"] !== void 0) {
+      const error = _boolean($o2["firmwareUpgradable"]);
+      if (error)
+        return error;
+    } else
+      return {};
+    if ("maxFragmentSize" in $o2 && $o2["maxFragmentSize"] !== void 0) {
+      const error = _number($o2["maxFragmentSize"]);
+      if (error)
+        return error;
+    }
+    if ("additionalFirmwareIDs" in $o2 && $o2["additionalFirmwareIDs"] !== void 0) {
+      const error = sa__number_ea_3($o2["additionalFirmwareIDs"]);
+      if (error)
+        return error;
+    }
+    if ("hardwareVersion" in $o2 && $o2["hardwareVersion"] !== void 0) {
+      const error = _number($o2["hardwareVersion"]);
+      if (error)
+        return error;
+    }
+    if ("continuesToFunction" in $o2 && $o2["continuesToFunction"] !== void 0) {
+      const error = su__undefined__6__7_eu($o2["continuesToFunction"]);
+      if (error)
+        return error;
+    }
+    if ("supportsActivation" in $o2 && $o2["supportsActivation"] !== void 0) {
+      const error = su__undefined__6__7_eu($o2["supportsActivation"]);
+      if (error)
+        return error;
+    }
+    if ("supportsResuming" in $o2 && $o2["supportsResuming"] !== void 0) {
+      const error = su__undefined__6__7_eu($o2["supportsResuming"]);
+      if (error)
+        return error;
+    }
+    if ("supportsNonSecureTransfer" in $o2 && $o2["supportsNonSecureTransfer"] !== void 0) {
+      const error = su__undefined__6__7_eu($o2["supportsNonSecureTransfer"]);
+      if (error)
+        return error;
+    }
+    return null;
+  }
+  return _0($o);
+};
+const __assertType__FirmwareUpdateMetaDataCCRequestGetOptions = ($o) => {
+  function _number($o2) {
+    return typeof $o2 !== "number" ? {} : null;
+  }
+  function _2($o2) {
+    if (typeof $o2 !== "object" || $o2 === null || Array.isArray($o2))
+      return {};
+    if ("manufacturerId" in $o2 && $o2["manufacturerId"] !== void 0) {
+      const error = _number($o2["manufacturerId"]);
+      if (error)
+        return error;
+    } else
+      return {};
+    if ("firmwareId" in $o2 && $o2["firmwareId"] !== void 0) {
+      const error = _number($o2["firmwareId"]);
+      if (error)
+        return error;
+    } else
+      return {};
+    if ("checksum" in $o2 && $o2["checksum"] !== void 0) {
+      const error = _number($o2["checksum"]);
+      if (error)
+        return error;
+    } else
+      return {};
+    return null;
+  }
+  function _boolean($o2) {
+    return typeof $o2 !== "boolean" ? {} : null;
+  }
+  function _3($o2) {
+    if (typeof $o2 !== "object" || $o2 === null || Array.isArray($o2))
+      return {};
+    if ("firmwareTarget" in $o2 && $o2["firmwareTarget"] !== void 0) {
+      const error = _number($o2["firmwareTarget"]);
+      if (error)
+        return error;
+    } else
+      return {};
+    if ("fragmentSize" in $o2 && $o2["fragmentSize"] !== void 0) {
+      const error = _number($o2["fragmentSize"]);
+      if (error)
+        return error;
+    } else
+      return {};
+    if ("activation" in $o2 && $o2["activation"] !== void 0) {
+      const error = _boolean($o2["activation"]);
+      if (error)
+        return error;
+    }
+    if ("hardwareVersion" in $o2 && $o2["hardwareVersion"] !== void 0) {
+      const error = _number($o2["hardwareVersion"]);
+      if (error)
+        return error;
+    }
+    if ("resume" in $o2 && $o2["resume"] !== void 0) {
+      const error = _boolean($o2["resume"]);
+      if (error)
+        return error;
+    }
+    if ("nonSecureTransfer" in $o2 && $o2["nonSecureTransfer"] !== void 0) {
+      const error = _boolean($o2["nonSecureTransfer"]);
+      if (error)
+        return error;
+    }
+    return null;
+  }
+  function si__2__3_ei($o2) {
+    const conditions = [_2, _3];
+    for (const condition of conditions) {
+      const error = condition($o2);
+      if (error)
+        return error;
+    }
+    return null;
+  }
+  function _undefined($o2) {
+    return $o2 !== void 0 ? {} : null;
+  }
+  function _5($o2) {
+    if (typeof $o2 !== "object" || $o2 === null || Array.isArray($o2))
+      return {};
+    if ("firmwareTarget" in $o2 && $o2["firmwareTarget"] !== void 0) {
+      const error = _undefined($o2["firmwareTarget"]);
+      if (error)
+        return error;
+    }
+    if ("fragmentSize" in $o2 && $o2["fragmentSize"] !== void 0) {
+      const error = _undefined($o2["fragmentSize"]);
+      if (error)
+        return error;
+    }
+    if ("activation" in $o2 && $o2["activation"] !== void 0) {
+      const error = _undefined($o2["activation"]);
+      if (error)
+        return error;
+    }
+    if ("hardwareVersion" in $o2 && $o2["hardwareVersion"] !== void 0) {
+      const error = _undefined($o2["hardwareVersion"]);
+      if (error)
+        return error;
+    }
+    if ("resume" in $o2 && $o2["resume"] !== void 0) {
+      const error = _undefined($o2["resume"]);
+      if (error)
+        return error;
+    }
+    if ("nonSecureTransfer" in $o2 && $o2["nonSecureTransfer"] !== void 0) {
+      const error = _undefined($o2["nonSecureTransfer"]);
+      if (error)
+        return error;
+    }
+    return null;
+  }
+  function si__2__5_ei($o2) {
+    const conditions = [_2, _5];
+    for (const condition of conditions) {
+      const error = condition($o2);
+      if (error)
+        return error;
+    }
+    return null;
+  }
+  function su_si__2__3_ei_si__2__5_ei_eu($o2) {
+    const conditions = [si__2__3_ei, si__2__5_ei];
+    for (const condition of conditions) {
+      const error = condition($o2);
+      if (!error)
+        return null;
+    }
+    return {};
+  }
+  return su_si__2__3_ei_si__2__5_ei_eu($o);
+};
+const __assertType__number = ($o) => {
+  function _number($o2) {
+    return typeof $o2 !== "number" ? {} : null;
+  }
+  return _number($o);
+};
+const __assertType__boolean = ($o) => {
+  function _boolean($o2) {
+    return typeof $o2 !== "boolean" ? {} : null;
+  }
+  return _boolean($o);
+};
+const __assertType__Uint8Array = ($o) => {
+  function _uint8array($o2) {
+    return !require("@zwave-js/shared/safe").isUint8Array($o2) ? {} : null;
+  }
+  return _uint8array($o);
+};
+const __assertType__FirmwareUpdateMetaDataCCActivationSetOptions = ($o) => {
+  function _number($o2) {
+    return typeof $o2 !== "number" ? {} : null;
+  }
+  function _0($o2) {
+    if (typeof $o2 !== "object" || $o2 === null || Array.isArray($o2))
+      return {};
+    if ("manufacturerId" in $o2 && $o2["manufacturerId"] !== void 0) {
+      const error = _number($o2["manufacturerId"]);
+      if (error)
+        return error;
+    } else
+      return {};
+    if ("firmwareId" in $o2 && $o2["firmwareId"] !== void 0) {
+      const error = _number($o2["firmwareId"]);
+      if (error)
+        return error;
+    } else
+      return {};
+    if ("checksum" in $o2 && $o2["checksum"] !== void 0) {
+      const error = _number($o2["checksum"]);
+      if (error)
+        return error;
+    } else
+      return {};
+    if ("firmwareTarget" in $o2 && $o2["firmwareTarget"] !== void 0) {
+      const error = _number($o2["firmwareTarget"]);
+      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 FirmwareUpdateMetaDataCCValues = Object.freeze({
+  ...import_Values.V.defineStaticCCValues(import_safe.CommandClasses["Firmware Update Meta Data"], {
+    ...import_Values.V.staticProperty("supportsActivation", void 0, {
+      internal: true
+    }),
+    ...import_Values.V.staticProperty("firmwareUpgradable", void 0, {
+      internal: true
+    }),
+    ...import_Values.V.staticProperty("additionalFirmwareIDs", void 0, {
+      internal: true
+    }),
+    ...import_Values.V.staticProperty("continuesToFunction", void 0, {
+      internal: true
+    }),
+    ...import_Values.V.staticProperty("supportsResuming", void 0, {
+      internal: true
+    }),
+    ...import_Values.V.staticProperty("supportsNonSecureTransfer", void 0, {
+      internal: true
+    })
+  })
+});
+let FirmwareUpdateMetaDataCCAPI = class FirmwareUpdateMetaDataCCAPI2 extends import_API.PhysicalCCAPI {
+  supportsCommand(cmd) {
+    switch (cmd) {
+      case import_Types.FirmwareUpdateMetaDataCommand.MetaDataGet:
+      case import_Types.FirmwareUpdateMetaDataCommand.MetaDataReport:
+      case import_Types.FirmwareUpdateMetaDataCommand.RequestGet:
+      case import_Types.FirmwareUpdateMetaDataCommand.Report:
+      case import_Types.FirmwareUpdateMetaDataCommand.StatusReport:
+        return true;
+      case import_Types.FirmwareUpdateMetaDataCommand.ActivationSet:
+        return this.version >= 4 && (this.version < 7 || this.tryGetValueDB()?.getValue(FirmwareUpdateMetaDataCCValues.supportsActivation.endpoint(this.endpoint.index)) === true);
+      case import_Types.FirmwareUpdateMetaDataCommand.PrepareGet:
+        return this.version >= 5;
+    }
+    return super.supportsCommand(cmd);
+  }
+  /**
+   * Requests information about the current firmware on the device
+   */
+  async getMetaData() {
+    this.assertSupportsCommand(import_Types.FirmwareUpdateMetaDataCommand, import_Types.FirmwareUpdateMetaDataCommand.MetaDataGet);
+    const cc = new FirmwareUpdateMetaDataCCMetaDataGet({
+      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, [
+        "manufacturerId",
+        "firmwareId",
+        "checksum",
+        "firmwareUpgradable",
+        "maxFragmentSize",
+        "additionalFirmwareIDs",
+        "hardwareVersion",
+        "continuesToFunction",
+        "supportsActivation",
+        "supportsResuming",
+        "supportsNonSecureTransfer"
+      ]);
+    }
+  }
+  async reportMetaData(options) {
+    __assertType("options", "FirmwareUpdateMetaDataCCMetaDataReportOptions", __assertType__FirmwareUpdateMetaDataCCMetaDataReportOptions.bind(void 0, options));
+    this.assertSupportsCommand(import_Types.FirmwareUpdateMetaDataCommand, import_Types.FirmwareUpdateMetaDataCommand.Report);
+    const cc = new FirmwareUpdateMetaDataCCMetaDataReport({
+      nodeId: this.endpoint.nodeId,
+      endpointIndex: this.endpoint.index,
+      ...options
+    });
+    await this.host.sendCommand(cc, this.commandOptions);
+  }
+  /**
+   * Requests the device to start the firmware update process.
+   * This does not wait for the reply - that is up to the caller of this method.
+   */
+  async requestUpdate(options) {
+    __assertType("options", "FirmwareUpdateMetaDataCCRequestGetOptions", __assertType__FirmwareUpdateMetaDataCCRequestGetOptions.bind(void 0, options));
+    this.assertSupportsCommand(import_Types.FirmwareUpdateMetaDataCommand, import_Types.FirmwareUpdateMetaDataCommand.RequestGet);
+    const cc = new FirmwareUpdateMetaDataCCRequestGet({
+      nodeId: this.endpoint.nodeId,
+      endpointIndex: this.endpoint.index,
+      ...options
+    });
+    await this.host.sendCommand(cc, {
+      ...this.commandOptions,
+      // Do not wait for Nonce Reports
+      s2VerifyDelivery: false
+    });
+  }
+  /**
+   * Sends a fragment of the new firmware to the device
+   */
+  async sendFirmwareFragment(fragmentNumber, isLastFragment, data) {
+    __assertType("fragmentNumber", "number", __assertType__number.bind(void 0, fragmentNumber));
+    __assertType("isLastFragment", "boolean", __assertType__boolean.bind(void 0, isLastFragment));
+    __assertType("data", "Uint8Array", __assertType__Uint8Array.bind(void 0, data));
+    this.assertSupportsCommand(import_Types.FirmwareUpdateMetaDataCommand, import_Types.FirmwareUpdateMetaDataCommand.Report);
+    const cc = new FirmwareUpdateMetaDataCCReport({
+      nodeId: this.endpoint.nodeId,
+      endpointIndex: this.endpoint.index,
+      reportNumber: fragmentNumber,
+      isLast: isLastFragment,
+      firmwareData: data
+    });
+    await this.host.sendCommand(cc, {
+      ...this.commandOptions,
+      // Do not wait for Nonce Reports
+      s2VerifyDelivery: false
+    });
+  }
+  /** Activates a previously transferred firmware image */
+  async activateFirmware(options) {
+    __assertType("options", "FirmwareUpdateMetaDataCCActivationSetOptions", __assertType__FirmwareUpdateMetaDataCCActivationSetOptions.bind(void 0, options));
+    this.assertSupportsCommand(import_Types.FirmwareUpdateMetaDataCommand, import_Types.FirmwareUpdateMetaDataCommand.ActivationSet);
+    const cc = new FirmwareUpdateMetaDataCCActivationSet({
+      nodeId: this.endpoint.nodeId,
+      endpointIndex: this.endpoint.index,
+      ...options
+    });
+    const response = await this.host.sendCommand(cc, this.commandOptions);
+    return response?.activationStatus;
+  }
+};
+FirmwareUpdateMetaDataCCAPI = __decorate([
+  (0, import_CommandClassDecorators.API)(import_safe.CommandClasses["Firmware Update Meta Data"])
+], FirmwareUpdateMetaDataCCAPI);
+let FirmwareUpdateMetaDataCC = class FirmwareUpdateMetaDataCC2 extends import_CommandClass.CommandClass {
+  skipEndpointInterview() {
+    return true;
+  }
+  async interview(ctx) {
+    const node = this.getNode(ctx);
+    const endpoint = this.getEndpoint(ctx);
+    const api = import_API.CCAPI.create(import_safe.CommandClasses["Firmware Update Meta Data"], ctx, endpoint).withOptions({
+      priority: import_safe.MessagePriority.NodeQuery
+    });
+    ctx.logNode(node.id, {
+      endpoint: this.endpointIndex,
+      message: `Interviewing ${this.ccName}...`,
+      direction: "none"
+    });
+    ctx.logNode(node.id, {
+      endpoint: this.endpointIndex,
+      message: "Querying firmware update capabilities...",
+      direction: "outbound"
+    });
+    const caps = await api.getMetaData();
+    if (caps) {
+      let logMessage = `Received firmware update capabilities:`;
+      if (caps.firmwareUpgradable) {
+        logMessage += `
+  firmware targets:             ${[0, ...caps.additionalFirmwareIDs].join(", ")}
+  continues to function:        ${caps.continuesToFunction}
+  supports activation:          ${caps.supportsActivation}`;
+        if (caps.supportsResuming != void 0) {
+          logMessage += `
+  supports resuming:            ${caps.supportsResuming}`;
+        }
+        if (caps.supportsNonSecureTransfer != void 0) {
+          logMessage += `
+  supports non-secure transfer: ${caps.supportsNonSecureTransfer}`;
+        }
+      } else {
+        logMessage += `
+firmware upgradeable: false`;
+      }
+      ctx.logNode(node.id, {
+        endpoint: this.endpointIndex,
+        message: logMessage,
+        direction: "inbound"
+      });
+    } else {
+      ctx.logNode(node.id, {
+        endpoint: this.endpointIndex,
+        message: "Firmware update capability query timed out",
+        direction: "inbound"
+      });
+    }
+    this.setInterviewComplete(ctx, true);
+  }
+};
+FirmwareUpdateMetaDataCC = __decorate([
+  (0, import_CommandClassDecorators.commandClass)(import_safe.CommandClasses["Firmware Update Meta Data"]),
+  (0, import_CommandClassDecorators.implementedVersion)(8),
+  (0, import_CommandClassDecorators.ccValues)(FirmwareUpdateMetaDataCCValues)
+], FirmwareUpdateMetaDataCC);
+let FirmwareUpdateMetaDataCCMetaDataReport = FirmwareUpdateMetaDataCCMetaDataReport_1 = class FirmwareUpdateMetaDataCCMetaDataReport2 extends FirmwareUpdateMetaDataCC {
+  constructor(options) {
+    super(options);
+    this.manufacturerId = options.manufacturerId;
+    this.firmwareId = options.firmwareId ?? 0;
+    this.checksum = options.checksum ?? 0;
+    this.firmwareUpgradable = options.firmwareUpgradable;
+    this.maxFragmentSize = options.maxFragmentSize;
+    this.additionalFirmwareIDs = options.additionalFirmwareIDs ?? [];
+    this.hardwareVersion = options.hardwareVersion;
+    this.continuesToFunction = options.continuesToFunction;
+    this.supportsActivation = options.supportsActivation;
+    this.supportsResuming = options.supportsResuming;
+    this.supportsNonSecureTransfer = options.supportsNonSecureTransfer;
+  }
+  static from(raw, ctx) {
+    (0, import_safe.validatePayload)(raw.payload.length >= 6);
+    const manufacturerId = raw.payload.readUInt16BE(0);
+    const firmwareId = raw.payload.readUInt16BE(2);
+    const checksum = raw.payload.readUInt16BE(4);
+    const firmwareUpgradable = raw.payload[6] === 255 || raw.payload[6] == void 0;
+    let maxFragmentSize;
+    let additionalFirmwareIDs;
+    let hardwareVersion;
+    let continuesToFunction;
+    let supportsActivation;
+    let supportsResuming;
+    let supportsNonSecureTransfer;
+    if (raw.payload.length >= 10) {
+      maxFragmentSize = raw.payload.readUInt16BE(8);
+      const numAdditionalFirmwares = raw.payload[7];
+      additionalFirmwareIDs = [];
+      (0, import_safe.validatePayload)(raw.payload.length >= 10 + 2 * numAdditionalFirmwares);
+      for (let i = 0; i < numAdditionalFirmwares; i++) {
+        additionalFirmwareIDs.push(raw.payload.readUInt16BE(10 + 2 * i));
+      }
+      let offset = 10 + 2 * numAdditionalFirmwares;
+      if (raw.payload.length >= offset + 1) {
+        hardwareVersion = raw.payload[offset];
+        offset++;
+        if (raw.payload.length >= offset + 1) {
+          const capabilities = raw.payload[offset];
+          offset++;
+          continuesToFunction = !!(capabilities & 1);
+          supportsActivation = !!(capabilities & 2);
+          supportsResuming = !!(capabilities & 8);
+          supportsNonSecureTransfer = !!(capabilities & 4);
+        }
+      }
+    }
+    return new FirmwareUpdateMetaDataCCMetaDataReport_1({
+      nodeId: ctx.sourceNodeId,
+      manufacturerId,
+      firmwareId,
+      checksum,
+      firmwareUpgradable,
+      maxFragmentSize,
+      additionalFirmwareIDs,
+      hardwareVersion,
+      continuesToFunction,
+      supportsActivation,
+      supportsResuming,
+      supportsNonSecureTransfer
+    });
+  }
+  manufacturerId;
+  firmwareId;
+  checksum;
+  firmwareUpgradable;
+  maxFragmentSize;
+  additionalFirmwareIDs = [];
+  hardwareVersion;
+  continuesToFunction;
+  supportsActivation;
+  supportsResuming;
+  supportsNonSecureTransfer;
+  serialize(ctx) {
+    this.payload = import_safe2.Bytes.alloc(12 + 2 * this.additionalFirmwareIDs.length);
+    this.payload.writeUInt16BE(this.manufacturerId, 0);
+    this.payload.writeUInt16BE(this.firmwareId, 2);
+    this.payload.writeUInt16BE(this.checksum, 4);
+    this.payload[6] = this.firmwareUpgradable ? 255 : 0;
+    this.payload[7] = this.additionalFirmwareIDs.length;
+    this.payload.writeUInt16BE(this.maxFragmentSize ?? 255, 8);
+    let offset = 10;
+    for (const id of this.additionalFirmwareIDs) {
+      this.payload.writeUInt16BE(id, offset);
+      offset += 2;
+    }
+    this.payload[offset++] = this.hardwareVersion ?? 255;
+    this.payload[offset++] = (this.continuesToFunction ? 1 : 0) | (this.supportsActivation ? 2 : 0) | (this.supportsNonSecureTransfer ? 4 : 0) | (this.supportsResuming ? 8 : 0);
+    return super.serialize(ctx);
+  }
+  toLogEntry(ctx) {
+    const message = {
+      "manufacturer id": this.manufacturerId,
+      "firmware id": this.firmwareId,
+      checksum: this.checksum,
+      "firmware upgradable": this.firmwareUpgradable
+    };
+    if (this.maxFragmentSize != void 0) {
+      message["max fragment size"] = this.maxFragmentSize;
+    }
+    if (this.additionalFirmwareIDs.length) {
+      message["additional firmware IDs"] = JSON.stringify(this.additionalFirmwareIDs);
+    }
+    if (this.hardwareVersion != void 0) {
+      message["hardware version"] = this.hardwareVersion;
+    }
+    if (this.continuesToFunction != void 0) {
+      message["continues to function"] = this.continuesToFunction;
+    }
+    if (this.supportsActivation != void 0) {
+      message["supports activation"] = this.supportsActivation;
+    }
+    if (this.supportsResuming != void 0) {
+      message["supports resuming"] = this.supportsResuming;
+    }
+    if (this.supportsNonSecureTransfer != void 0) {
+      message["supports non-secure transfer"] = this.supportsNonSecureTransfer;
+    }
+    return {
+      ...super.toLogEntry(ctx),
+      message
+    };
+  }
+};
+__decorate([
+  (0, import_CommandClassDecorators.ccValue)(FirmwareUpdateMetaDataCCValues.firmwareUpgradable)
+], FirmwareUpdateMetaDataCCMetaDataReport.prototype, "firmwareUpgradable", void 0);
+__decorate([
+  (0, import_CommandClassDecorators.ccValue)(FirmwareUpdateMetaDataCCValues.additionalFirmwareIDs)
+], FirmwareUpdateMetaDataCCMetaDataReport.prototype, "additionalFirmwareIDs", void 0);
+__decorate([
+  (0, import_CommandClassDecorators.ccValue)(FirmwareUpdateMetaDataCCValues.continuesToFunction)
+], FirmwareUpdateMetaDataCCMetaDataReport.prototype, "continuesToFunction", void 0);
+__decorate([
+  (0, import_CommandClassDecorators.ccValue)(FirmwareUpdateMetaDataCCValues.supportsActivation)
+], FirmwareUpdateMetaDataCCMetaDataReport.prototype, "supportsActivation", void 0);
+__decorate([
+  (0, import_CommandClassDecorators.ccValue)(FirmwareUpdateMetaDataCCValues.supportsResuming)
+], FirmwareUpdateMetaDataCCMetaDataReport.prototype, "supportsResuming", void 0);
+__decorate([
+  (0, import_CommandClassDecorators.ccValue)(FirmwareUpdateMetaDataCCValues.supportsNonSecureTransfer)
+], FirmwareUpdateMetaDataCCMetaDataReport.prototype, "supportsNonSecureTransfer", void 0);
+FirmwareUpdateMetaDataCCMetaDataReport = FirmwareUpdateMetaDataCCMetaDataReport_1 = __decorate([
+  (0, import_CommandClassDecorators.CCCommand)(import_Types.FirmwareUpdateMetaDataCommand.MetaDataReport)
+], FirmwareUpdateMetaDataCCMetaDataReport);
+let FirmwareUpdateMetaDataCCMetaDataGet = class FirmwareUpdateMetaDataCCMetaDataGet2 extends FirmwareUpdateMetaDataCC {
+};
+FirmwareUpdateMetaDataCCMetaDataGet = __decorate([
+  (0, import_CommandClassDecorators.CCCommand)(import_Types.FirmwareUpdateMetaDataCommand.MetaDataGet),
+  (0, import_CommandClassDecorators.expectedCCResponse)(FirmwareUpdateMetaDataCCMetaDataReport)
+], FirmwareUpdateMetaDataCCMetaDataGet);
+let FirmwareUpdateMetaDataCCRequestReport = FirmwareUpdateMetaDataCCRequestReport_1 = class FirmwareUpdateMetaDataCCRequestReport2 extends FirmwareUpdateMetaDataCC {
+  constructor(options) {
+    super(options);
+    this.status = options.status;
+    this.resume = options.resume;
+    this.nonSecureTransfer = options.nonSecureTransfer;
+  }
+  static from(raw, ctx) {
+    (0, import_safe.validatePayload)(raw.payload.length >= 1);
+    const status = raw.payload[0];
+    let resume;
+    let nonSecureTransfer;
+    if (raw.payload.length >= 2) {
+      resume = !!(raw.payload[1] & 4);
+      nonSecureTransfer = !!(raw.payload[1] & 2);
+    }
+    return new FirmwareUpdateMetaDataCCRequestReport_1({
+      nodeId: ctx.sourceNodeId,
+      status,
+      resume,
+      nonSecureTransfer
+    });
+  }
+  status;
+  resume;
+  nonSecureTransfer;
+  toLogEntry(ctx) {
+    const message = {
+      status: (0, import_safe3.getEnumMemberName)(import_Types.FirmwareUpdateRequestStatus, this.status)
+    };
+    if (this.resume != void 0) {
+      message.resume = this.resume;
+    }
+    if (this.nonSecureTransfer != void 0) {
+      message["non-secure transfer"] = this.nonSecureTransfer;
+    }
+    return {
+      ...super.toLogEntry(ctx),
+      message
+    };
+  }
+};
+FirmwareUpdateMetaDataCCRequestReport = FirmwareUpdateMetaDataCCRequestReport_1 = __decorate([
+  (0, import_CommandClassDecorators.CCCommand)(import_Types.FirmwareUpdateMetaDataCommand.RequestReport)
+], FirmwareUpdateMetaDataCCRequestReport);
+let FirmwareUpdateMetaDataCCRequestGet = class FirmwareUpdateMetaDataCCRequestGet2 extends FirmwareUpdateMetaDataCC {
+  constructor(options) {
+    super(options);
+    this.manufacturerId = options.manufacturerId;
+    this.firmwareId = options.firmwareId;
+    this.checksum = options.checksum;
+    if ("firmwareTarget" in options) {
+      this.firmwareTarget = options.firmwareTarget;
+      this.fragmentSize = options.fragmentSize;
+      this.activation = options.activation ?? false;
+      this.hardwareVersion = options.hardwareVersion;
+      this.resume = options.resume;
+      this.nonSecureTransfer = options.nonSecureTransfer;
+    }
+  }
+  static from(_raw, _ctx) {
+    throw new import_safe.ZWaveError(`${this.name}: deserialization not implemented`, import_safe.ZWaveErrorCodes.Deserialization_NotImplemented);
+  }
+  manufacturerId;
+  firmwareId;
+  checksum;
+  firmwareTarget;
+  fragmentSize;
+  activation;
+  hardwareVersion;
+  resume;
+  nonSecureTransfer;
+  serialize(ctx) {
+    this.payload = import_safe2.Bytes.alloc(11, 0);
+    this.payload.writeUInt16BE(this.manufacturerId, 0);
+    this.payload.writeUInt16BE(this.firmwareId, 2);
+    this.payload.writeUInt16BE(this.checksum, 4);
+    this.payload[6] = this.firmwareTarget ?? 0;
+    this.payload.writeUInt16BE(this.fragmentSize ?? 32, 7);
+    this.payload[9] = (this.activation ? 1 : 0) | (this.nonSecureTransfer ? 2 : 0) | (this.resume ? 4 : 0);
+    this.payload[10] = this.hardwareVersion ?? 0;
+    return super.serialize(ctx);
+  }
+  toLogEntry(ctx) {
+    const message = {
+      "manufacturer id": (0, import_safe3.num2hex)(this.manufacturerId),
+      "firmware id": (0, import_safe3.num2hex)(this.firmwareId),
+      checksum: (0, import_safe3.num2hex)(this.checksum)
+    };
+    if (this.firmwareTarget != void 0) {
+      message["firmware target"] = this.firmwareTarget;
+    }
+    if (this.fragmentSize != void 0) {
+      message["fragment size"] = this.fragmentSize;
+    }
+    if (this.activation != void 0) {
+      message.activation = this.activation;
+    }
+    if (this.resume != void 0) {
+      message.resume = this.resume;
+    }
+    if (this.nonSecureTransfer != void 0) {
+      message["non-secure transfer"] = this.nonSecureTransfer;
+    }
+    if (this.hardwareVersion != void 0) {
+      message["hardware version"] = this.hardwareVersion;
+    }
+    return {
+      ...super.toLogEntry(ctx),
+      message
+    };
+  }
+};
+FirmwareUpdateMetaDataCCRequestGet = __decorate([
+  (0, import_CommandClassDecorators.CCCommand)(import_Types.FirmwareUpdateMetaDataCommand.RequestGet)
+  // This would expect a FirmwareUpdateMetaDataCCRequestReport, but the response may take
+  // a while to come. We don't want to block communication, so we don't expect a response here
+], FirmwareUpdateMetaDataCCRequestGet);
+let FirmwareUpdateMetaDataCCGet = FirmwareUpdateMetaDataCCGet_1 = class FirmwareUpdateMetaDataCCGet2 extends FirmwareUpdateMetaDataCC {
+  constructor(options) {
+    super(options);
+    this.numReports = options.numReports;
+    this.reportNumber = options.reportNumber;
+  }
+  static from(raw, ctx) {
+    (0, import_safe.validatePayload)(raw.payload.length >= 3);
+    const numReports = raw.payload[0];
+    const reportNumber = raw.payload.readUInt16BE(1) & 32767;
+    return new FirmwareUpdateMetaDataCCGet_1({
+      nodeId: ctx.sourceNodeId,
+      numReports,
+      reportNumber
+    });
+  }
+  numReports;
+  reportNumber;
+  toLogEntry(ctx) {
+    return {
+      ...super.toLogEntry(ctx),
+      message: {
+        "total # of reports": this.numReports,
+        "report number": this.reportNumber
+      }
+    };
+  }
+};
+FirmwareUpdateMetaDataCCGet = FirmwareUpdateMetaDataCCGet_1 = __decorate([
+  (0, import_CommandClassDecorators.CCCommand)(import_Types.FirmwareUpdateMetaDataCommand.Get)
+  // This is sent to us from the node, so we expect no response
+], FirmwareUpdateMetaDataCCGet);
+let FirmwareUpdateMetaDataCCReport = class FirmwareUpdateMetaDataCCReport2 extends FirmwareUpdateMetaDataCC {
+  constructor(options) {
+    super(options);
+    this.reportNumber = options.reportNumber;
+    this.firmwareData = options.firmwareData;
+    this.isLast = options.isLast;
+  }
+  static from(_raw, _ctx) {
+    throw new import_safe.ZWaveError(`${this.name}: deserialization not implemented`, import_safe.ZWaveErrorCodes.Deserialization_NotImplemented);
+  }
+  isLast;
+  reportNumber;
+  firmwareData;
+  serialize(ctx) {
+    const commandBuffer = import_safe2.Bytes.concat([
+      new import_safe2.Bytes(2),
+      // placeholder for report number
+      this.firmwareData
+    ]);
+    commandBuffer.writeUInt16BE(this.reportNumber & 32767 | (this.isLast ? 32768 : 0), 0);
+    const ccVersion = (0, import_CommandClass.getEffectiveCCVersion)(ctx, this);
+    if (ccVersion >= 2) {
+      let crc = (0, import_safe.CRC16_CCITT)(import_safe2.Bytes.from([this.ccId, this.ccCommand]));
+      crc = (0, import_safe.CRC16_CCITT)(commandBuffer, crc);
+      this.payload = import_safe2.Bytes.concat([
+        commandBuffer,
+        new import_safe2.Bytes(2)
+      ]);
+      this.payload.writeUInt16BE(crc, this.payload.length - 2);
+    } else {
+      this.payload = commandBuffer;
+    }
+    return super.serialize(ctx);
+  }
+  toLogEntry(ctx) {
+    return {
+      ...super.toLogEntry(ctx),
+      message: {
+        "report #": this.reportNumber,
+        "is last": this.isLast
+      }
+    };
+  }
+};
+FirmwareUpdateMetaDataCCReport = __decorate([
+  (0, import_CommandClassDecorators.CCCommand)(import_Types.FirmwareUpdateMetaDataCommand.Report)
+  // We send this in reply to the Get command and expect no response
+], FirmwareUpdateMetaDataCCReport);
+let FirmwareUpdateMetaDataCCStatusReport = FirmwareUpdateMetaDataCCStatusReport_1 = class FirmwareUpdateMetaDataCCStatusReport2 extends FirmwareUpdateMetaDataCC {
+  constructor(options) {
+    super(options);
+    this.status = options.status;
+    this.waitTime = options.waitTime;
+  }
+  static from(raw, ctx) {
+    (0, import_safe.validatePayload)(raw.payload.length >= 1);
+    const status = raw.payload[0];
+    let waitTime;
+    if (raw.payload.length >= 3) {
+      waitTime = raw.payload.readUInt16BE(1);
+    }
+    return new FirmwareUpdateMetaDataCCStatusReport_1({
+      nodeId: ctx.sourceNodeId,
+      status,
+      waitTime
+    });
+  }
+  status;
+  /** The wait time in seconds before the node becomes available for communication after the update */
+  waitTime;
+  toLogEntry(ctx) {
+    const message = {
+      status: (0, import_safe3.getEnumMemberName)(import_Types.FirmwareUpdateStatus, this.status)
+    };
+    if (this.waitTime != void 0) {
+      message["wait time"] = `${this.waitTime} seconds`;
+    }
+    return {
+      ...super.toLogEntry(ctx),
+      message
+    };
+  }
+};
+FirmwareUpdateMetaDataCCStatusReport = FirmwareUpdateMetaDataCCStatusReport_1 = __decorate([
+  (0, import_CommandClassDecorators.CCCommand)(import_Types.FirmwareUpdateMetaDataCommand.StatusReport)
+], FirmwareUpdateMetaDataCCStatusReport);
+let FirmwareUpdateMetaDataCCActivationReport = FirmwareUpdateMetaDataCCActivationReport_1 = class FirmwareUpdateMetaDataCCActivationReport2 extends FirmwareUpdateMetaDataCC {
+  constructor(options) {
+    super(options);
+    this.manufacturerId = options.manufacturerId;
+    this.firmwareId = options.firmwareId;
+    this.checksum = options.checksum;
+    this.firmwareTarget = options.firmwareTarget;
+    this.activationStatus = options.activationStatus;
+    this.hardwareVersion = options.hardwareVersion;
+  }
+  static from(raw, ctx) {
+    (0, import_safe.validatePayload)(raw.payload.length >= 8);
+    const manufacturerId = raw.payload.readUInt16BE(0);
+    const firmwareId = raw.payload.readUInt16BE(2);
+    const checksum = raw.payload.readUInt16BE(4);
+    const firmwareTarget = raw.payload[6];
+    const activationStatus = raw.payload[7];
+    let hardwareVersion;
+    if (raw.payload.length >= 9) {
+      hardwareVersion = raw.payload[8];
+    }
+    return new FirmwareUpdateMetaDataCCActivationReport_1({
+      nodeId: ctx.sourceNodeId,
+      manufacturerId,
+      firmwareId,
+      checksum,
+      firmwareTarget,
+      activationStatus,
+      hardwareVersion
+    });
+  }
+  manufacturerId;
+  firmwareId;
+  checksum;
+  firmwareTarget;
+  activationStatus;
+  hardwareVersion;
+  toLogEntry(ctx) {
+    const message = {
+      "manufacturer id": (0, import_safe3.num2hex)(this.manufacturerId),
+      "firmware id": (0, import_safe3.num2hex)(this.firmwareId),
+      checksum: (0, import_safe3.num2hex)(this.checksum),
+      "firmware target": this.firmwareTarget,
+      "activation status": (0, import_safe3.getEnumMemberName)(import_Types.FirmwareUpdateActivationStatus, this.activationStatus)
+    };
+    if (this.hardwareVersion != void 0) {
+      message.hardwareVersion = this.hardwareVersion;
+    }
+    return {
+      ...super.toLogEntry(ctx),
+      message
+    };
+  }
+};
+FirmwareUpdateMetaDataCCActivationReport = FirmwareUpdateMetaDataCCActivationReport_1 = __decorate([
+  (0, import_CommandClassDecorators.CCCommand)(import_Types.FirmwareUpdateMetaDataCommand.ActivationReport)
+], FirmwareUpdateMetaDataCCActivationReport);
+let FirmwareUpdateMetaDataCCActivationSet = class FirmwareUpdateMetaDataCCActivationSet2 extends FirmwareUpdateMetaDataCC {
+  constructor(options) {
+    super(options);
+    this.manufacturerId = options.manufacturerId;
+    this.firmwareId = options.firmwareId;
+    this.checksum = options.checksum;
+    this.firmwareTarget = options.firmwareTarget;
+    this.hardwareVersion = options.hardwareVersion;
+  }
+  static from(_raw, _ctx) {
+    throw new import_safe.ZWaveError(`${this.name}: deserialization not implemented`, import_safe.ZWaveErrorCodes.Deserialization_NotImplemented);
+  }
+  manufacturerId;
+  firmwareId;
+  checksum;
+  firmwareTarget;
+  hardwareVersion;
+  serialize(ctx) {
+    this.payload = new import_safe2.Bytes(8);
+    this.payload.writeUInt16BE(this.manufacturerId, 0);
+    this.payload.writeUInt16BE(this.firmwareId, 2);
+    this.payload.writeUInt16BE(this.checksum, 4);
+    this.payload[6] = this.firmwareTarget;
+    this.payload[7] = this.hardwareVersion ?? 0;
+    return super.serialize(ctx);
+  }
+  toLogEntry(ctx) {
+    const message = {
+      "manufacturer id": (0, import_safe3.num2hex)(this.manufacturerId),
+      "firmware id": (0, import_safe3.num2hex)(this.firmwareId),
+      checksum: (0, import_safe3.num2hex)(this.checksum),
+      "firmware target": this.firmwareTarget
+    };
+    if (this.hardwareVersion != void 0) {
+      message["hardware version"] = this.hardwareVersion;
+    }
+    return {
+      ...super.toLogEntry(ctx),
+      message
+    };
+  }
+};
+FirmwareUpdateMetaDataCCActivationSet = __decorate([
+  (0, import_CommandClassDecorators.CCCommand)(import_Types.FirmwareUpdateMetaDataCommand.ActivationSet),
+  (0, import_CommandClassDecorators.expectedCCResponse)(FirmwareUpdateMetaDataCCActivationReport)
+], FirmwareUpdateMetaDataCCActivationSet);
+let FirmwareUpdateMetaDataCCPrepareReport = FirmwareUpdateMetaDataCCPrepareReport_1 = class FirmwareUpdateMetaDataCCPrepareReport2 extends FirmwareUpdateMetaDataCC {
+  constructor(options) {
+    super(options);
+    this.status = options.status;
+    this.checksum = options.checksum;
+  }
+  static from(raw, ctx) {
+    (0, import_safe.validatePayload)(raw.payload.length >= 3);
+    const status = raw.payload[0];
+    const checksum = raw.payload.readUInt16BE(1);
+    return new FirmwareUpdateMetaDataCCPrepareReport_1({
+      nodeId: ctx.sourceNodeId,
+      status,
+      checksum
+    });
+  }
+  status;
+  checksum;
+  toLogEntry(ctx) {
+    return {
+      ...super.toLogEntry(ctx),
+      message: {
+        status: (0, import_safe3.getEnumMemberName)(import_Types.FirmwareDownloadStatus, this.status),
+        checksum: (0, import_safe3.num2hex)(this.checksum)
+      }
+    };
+  }
+};
+FirmwareUpdateMetaDataCCPrepareReport = FirmwareUpdateMetaDataCCPrepareReport_1 = __decorate([
+  (0, import_CommandClassDecorators.CCCommand)(import_Types.FirmwareUpdateMetaDataCommand.PrepareReport)
+], FirmwareUpdateMetaDataCCPrepareReport);
+let FirmwareUpdateMetaDataCCPrepareGet = class FirmwareUpdateMetaDataCCPrepareGet2 extends FirmwareUpdateMetaDataCC {
+  constructor(options) {
+    super(options);
+    this.manufacturerId = options.manufacturerId;
+    this.firmwareId = options.firmwareId;
+    this.firmwareTarget = options.firmwareTarget;
+    this.fragmentSize = options.fragmentSize;
+    this.hardwareVersion = options.hardwareVersion;
+  }
+  static from(_raw, _ctx) {
+    throw new import_safe.ZWaveError(`${this.name}: deserialization not implemented`, import_safe.ZWaveErrorCodes.Deserialization_NotImplemented);
+  }
+  manufacturerId;
+  firmwareId;
+  firmwareTarget;
+  fragmentSize;
+  hardwareVersion;
+  serialize(ctx) {
+    this.payload = new import_safe2.Bytes(8);
+    this.payload.writeUInt16BE(this.manufacturerId, 0);
+    this.payload.writeUInt16BE(this.firmwareId, 2);
+    this.payload[4] = this.firmwareTarget;
+    this.payload.writeUInt16BE(this.fragmentSize, 5);
+    this.payload[7] = this.hardwareVersion;
+    return super.serialize(ctx);
+  }
+  toLogEntry(ctx) {
+    return {
+      ...super.toLogEntry(ctx),
+      message: {
+        "manufacturer id": (0, import_safe3.num2hex)(this.manufacturerId),
+        "firmware id": (0, import_safe3.num2hex)(this.firmwareId),
+        "firmware target": this.firmwareTarget,
+        "fragment size": this.fragmentSize,
+        "hardware version": this.hardwareVersion
+      }
+    };
+  }
+};
+FirmwareUpdateMetaDataCCPrepareGet = __decorate([
+  (0, import_CommandClassDecorators.CCCommand)(import_Types.FirmwareUpdateMetaDataCommand.PrepareGet),
+  (0, import_CommandClassDecorators.expectedCCResponse)(FirmwareUpdateMetaDataCCReport)
+], FirmwareUpdateMetaDataCCPrepareGet);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  FirmwareUpdateMetaDataCC,
+  FirmwareUpdateMetaDataCCAPI,
+  FirmwareUpdateMetaDataCCActivationReport,
+  FirmwareUpdateMetaDataCCActivationSet,
+  FirmwareUpdateMetaDataCCGet,
+  FirmwareUpdateMetaDataCCMetaDataGet,
+  FirmwareUpdateMetaDataCCMetaDataReport,
+  FirmwareUpdateMetaDataCCPrepareGet,
+  FirmwareUpdateMetaDataCCPrepareReport,
+  FirmwareUpdateMetaDataCCReport,
+  FirmwareUpdateMetaDataCCRequestGet,
+  FirmwareUpdateMetaDataCCRequestReport,
+  FirmwareUpdateMetaDataCCStatusReport,
+  FirmwareUpdateMetaDataCCValues
+});
+//# sourceMappingURL=FirmwareUpdateMetaDataCC.js.map