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

package/build/cjs/cc/ConfigurationCC.js

@@ -0,0 +1,2230 @@
+"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 ConfigurationCC_exports = {};
+__export(ConfigurationCC_exports, {
+  ConfigurationCC: () => ConfigurationCC,
+  ConfigurationCCAPI: () => ConfigurationCCAPI,
+  ConfigurationCCBulkGet: () => ConfigurationCCBulkGet,
+  ConfigurationCCBulkReport: () => ConfigurationCCBulkReport,
+  ConfigurationCCBulkSet: () => ConfigurationCCBulkSet,
+  ConfigurationCCDefaultReset: () => ConfigurationCCDefaultReset,
+  ConfigurationCCError: () => ConfigurationCCError,
+  ConfigurationCCGet: () => ConfigurationCCGet,
+  ConfigurationCCInfoGet: () => ConfigurationCCInfoGet,
+  ConfigurationCCInfoReport: () => ConfigurationCCInfoReport,
+  ConfigurationCCNameGet: () => ConfigurationCCNameGet,
+  ConfigurationCCNameReport: () => ConfigurationCCNameReport,
+  ConfigurationCCPropertiesGet: () => ConfigurationCCPropertiesGet,
+  ConfigurationCCPropertiesReport: () => ConfigurationCCPropertiesReport,
+  ConfigurationCCReport: () => ConfigurationCCReport,
+  ConfigurationCCSet: () => ConfigurationCCSet,
+  ConfigurationCCValues: () => ConfigurationCCValues
+});
+module.exports = __toCommonJS(ConfigurationCC_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_arrays = require("alcalzone-shared/arrays/index.js");
+var import_objects = require("alcalzone-shared/objects/index.js");
+var import_strings = require("alcalzone-shared/strings/index.js");
+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 ConfigurationCCReport_1, ConfigurationCCGet_1, ConfigurationCCSet_1, ConfigurationCCBulkReport_1, ConfigurationCCNameReport_1, ConfigurationCCNameGet_1, ConfigurationCCInfoReport_1, ConfigurationCCInfoGet_1, ConfigurationCCPropertiesReport_1, ConfigurationCCPropertiesGet_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__number = ($o) => {
+  function _number($o2) {
+    return typeof $o2 !== "number" ? {} : null;
+  }
+  return _number($o);
+};
+const __assertType__optional__0 = ($o) => {
+  function _number($o2) {
+    return typeof $o2 !== "number" ? {} : null;
+  }
+  function _boolean($o2) {
+    return typeof $o2 !== "boolean" ? {} : null;
+  }
+  function _0($o2) {
+    if (typeof $o2 !== "object" || $o2 === null || Array.isArray($o2))
+      return {};
+    if ("valueBitMask" in $o2 && $o2["valueBitMask"] !== void 0) {
+      const error = _number($o2["valueBitMask"]);
+      if (error)
+        return error;
+    }
+    if ("allowUnexpectedResponse" in $o2 && $o2["allowUnexpectedResponse"] !== void 0) {
+      const error = _boolean($o2["allowUnexpectedResponse"]);
+      if (error)
+        return error;
+    }
+    return null;
+  }
+  function optional__0($o2) {
+    if ($o2 !== void 0) {
+      const error = _0($o2);
+      if (error)
+        return error;
+    }
+    return null;
+  }
+  return optional__0($o);
+};
+const __assertType__sa__2_ea_2 = ($o) => {
+  function _number($o2) {
+    return typeof $o2 !== "number" ? {} : null;
+  }
+  function _2($o2) {
+    if (typeof $o2 !== "object" || $o2 === null || Array.isArray($o2))
+      return {};
+    if ("parameter" in $o2 && $o2["parameter"] !== void 0) {
+      const error = _number($o2["parameter"]);
+      if (error)
+        return error;
+    } else
+      return {};
+    if ("bitMask" in $o2 && $o2["bitMask"] !== void 0) {
+      const error = _number($o2["bitMask"]);
+      if (error)
+        return error;
+    }
+    return null;
+  }
+  function sa__2_ea_2($o2) {
+    if (!Array.isArray($o2))
+      return {};
+    for (let i = 0; i < $o2.length; i++) {
+      const error = _2($o2[i]);
+      if (error)
+        return error;
+    }
+    return null;
+  }
+  return sa__2_ea_2($o);
+};
+const __assertType__ConfigurationCCAPISetOptions = ($o) => {
+  function _number($o2) {
+    return typeof $o2 !== "number" ? {} : null;
+  }
+  function _2($o2) {
+    if (typeof $o2 !== "object" || $o2 === null || Array.isArray($o2))
+      return {};
+    if ("parameter" in $o2 && $o2["parameter"] !== void 0) {
+      const error = _number($o2["parameter"]);
+      if (error)
+        return error;
+    } else
+      return {};
+    return null;
+  }
+  function _undefined($o2) {
+    return $o2 !== void 0 ? {} : null;
+  }
+  function _3($o2) {
+    if (typeof $o2 !== "object" || $o2 === null || Array.isArray($o2))
+      return {};
+    if ("bitMask" in $o2 && $o2["bitMask"] !== void 0) {
+      const error = _undefined($o2["bitMask"]);
+      if (error)
+        return error;
+    }
+    if ("value" in $o2 && $o2["value"] !== void 0) {
+      const error = _number($o2["value"]);
+      if (error)
+        return error;
+    } else
+      return {};
+    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 _9($o2) {
+    return $o2 !== 1 ? {} : null;
+  }
+  function _10($o2) {
+    return $o2 !== 2 ? {} : null;
+  }
+  function _11($o2) {
+    return $o2 !== 4 ? {} : null;
+  }
+  function su__9__10__11_eu($o2) {
+    const conditions = [_9, _10, _11];
+    for (const condition of conditions) {
+      const error = condition($o2);
+      if (!error)
+        return null;
+    }
+    return {};
+  }
+  function su__13__14__15__16_eu($o2) {
+    return ![0, 1, 2, 3].includes($o2) ? {} : null;
+  }
+  function _5($o2) {
+    if (typeof $o2 !== "object" || $o2 === null || Array.isArray($o2))
+      return {};
+    if ("bitMask" in $o2 && $o2["bitMask"] !== void 0) {
+      const error = _undefined($o2["bitMask"]);
+      if (error)
+        return error;
+    }
+    if ("value" in $o2 && $o2["value"] !== void 0) {
+      const error = _number($o2["value"]);
+      if (error)
+        return error;
+    } else
+      return {};
+    if ("valueSize" in $o2 && $o2["valueSize"] !== void 0) {
+      const error = su__9__10__11_eu($o2["valueSize"]);
+      if (error)
+        return error;
+    } else
+      return {};
+    if ("valueFormat" in $o2 && $o2["valueFormat"] !== void 0) {
+      const error = su__13__14__15__16_eu($o2["valueFormat"]);
+      if (error)
+        return error;
+    } else
+      return {};
+    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 _7($o2) {
+    if (typeof $o2 !== "object" || $o2 === null || Array.isArray($o2))
+      return {};
+    if ("bitMask" in $o2 && $o2["bitMask"] !== void 0) {
+      const error = _number($o2["bitMask"]);
+      if (error)
+        return error;
+    } else
+      return {};
+    if ("value" in $o2 && $o2["value"] !== void 0) {
+      const error = _number($o2["value"]);
+      if (error)
+        return error;
+    } else
+      return {};
+    return null;
+  }
+  function si__2__7_ei($o2) {
+    const conditions = [_2, _7];
+    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_si__2__7_ei_eu($o2) {
+    const conditions = [si__2__3_ei, si__2__5_ei, si__2__7_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_si__2__7_ei_eu($o);
+};
+const __assertType__sa_su_si__4__5_ei_si__4__7_ei_si__4__9_ei_eu_ea_2 = ($o) => {
+  function _number($o2) {
+    return typeof $o2 !== "number" ? {} : null;
+  }
+  function _4($o2) {
+    if (typeof $o2 !== "object" || $o2 === null || Array.isArray($o2))
+      return {};
+    if ("parameter" in $o2 && $o2["parameter"] !== void 0) {
+      const error = _number($o2["parameter"]);
+      if (error)
+        return error;
+    } else
+      return {};
+    return null;
+  }
+  function _undefined($o2) {
+    return $o2 !== void 0 ? {} : null;
+  }
+  function _5($o2) {
+    if (typeof $o2 !== "object" || $o2 === null || Array.isArray($o2))
+      return {};
+    if ("bitMask" in $o2 && $o2["bitMask"] !== void 0) {
+      const error = _undefined($o2["bitMask"]);
+      if (error)
+        return error;
+    }
+    if ("value" in $o2 && $o2["value"] !== void 0) {
+      const error = _number($o2["value"]);
+      if (error)
+        return error;
+    } else
+      return {};
+    return null;
+  }
+  function si__4__5_ei($o2) {
+    const conditions = [_4, _5];
+    for (const condition of conditions) {
+      const error = condition($o2);
+      if (error)
+        return error;
+    }
+    return null;
+  }
+  function _11($o2) {
+    return $o2 !== 1 ? {} : null;
+  }
+  function _12($o2) {
+    return $o2 !== 2 ? {} : null;
+  }
+  function _13($o2) {
+    return $o2 !== 4 ? {} : null;
+  }
+  function su__11__12__13_eu($o2) {
+    const conditions = [_11, _12, _13];
+    for (const condition of conditions) {
+      const error = condition($o2);
+      if (!error)
+        return null;
+    }
+    return {};
+  }
+  function su__15__16__17__18_eu($o2) {
+    return ![0, 1, 2, 3].includes($o2) ? {} : null;
+  }
+  function _7($o2) {
+    if (typeof $o2 !== "object" || $o2 === null || Array.isArray($o2))
+      return {};
+    if ("bitMask" in $o2 && $o2["bitMask"] !== void 0) {
+      const error = _undefined($o2["bitMask"]);
+      if (error)
+        return error;
+    }
+    if ("value" in $o2 && $o2["value"] !== void 0) {
+      const error = _number($o2["value"]);
+      if (error)
+        return error;
+    } else
+      return {};
+    if ("valueSize" in $o2 && $o2["valueSize"] !== void 0) {
+      const error = su__11__12__13_eu($o2["valueSize"]);
+      if (error)
+        return error;
+    } else
+      return {};
+    if ("valueFormat" in $o2 && $o2["valueFormat"] !== void 0) {
+      const error = su__15__16__17__18_eu($o2["valueFormat"]);
+      if (error)
+        return error;
+    } else
+      return {};
+    return null;
+  }
+  function si__4__7_ei($o2) {
+    const conditions = [_4, _7];
+    for (const condition of conditions) {
+      const error = condition($o2);
+      if (error)
+        return error;
+    }
+    return null;
+  }
+  function _9($o2) {
+    if (typeof $o2 !== "object" || $o2 === null || Array.isArray($o2))
+      return {};
+    if ("bitMask" in $o2 && $o2["bitMask"] !== void 0) {
+      const error = _number($o2["bitMask"]);
+      if (error)
+        return error;
+    } else
+      return {};
+    if ("value" in $o2 && $o2["value"] !== void 0) {
+      const error = _number($o2["value"]);
+      if (error)
+        return error;
+    } else
+      return {};
+    return null;
+  }
+  function si__4__9_ei($o2) {
+    const conditions = [_4, _9];
+    for (const condition of conditions) {
+      const error = condition($o2);
+      if (error)
+        return error;
+    }
+    return null;
+  }
+  function su_si__4__5_ei_si__4__7_ei_si__4__9_ei_eu($o2) {
+    const conditions = [si__4__5_ei, si__4__7_ei, si__4__9_ei];
+    for (const condition of conditions) {
+      const error = condition($o2);
+      if (!error)
+        return null;
+    }
+    return {};
+  }
+  function sa_su_si__4__5_ei_si__4__7_ei_si__4__9_ei_eu_ea_2($o2) {
+    if (!Array.isArray($o2))
+      return {};
+    for (let i = 0; i < $o2.length; i++) {
+      const error = su_si__4__5_ei_si__4__7_ei_si__4__9_ei_eu($o2[i]);
+      if (error)
+        return error;
+    }
+    return null;
+  }
+  return sa_su_si__4__5_ei_si__4__7_ei_si__4__9_ei_eu_ea_2($o);
+};
+const __assertType__sa__number_ea_2 = ($o) => {
+  function _number($o2) {
+    return typeof $o2 !== "number" ? {} : null;
+  }
+  function sa__number_ea_2($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;
+  }
+  return sa__number_ea_2($o);
+};
+function configValueToString(value) {
+  if (typeof value === "number")
+    return value.toString();
+  else
+    return [...value].join(", ");
+}
+class ConfigurationCCError extends import_safe.ZWaveError {
+  message;
+  code;
+  argument;
+  constructor(message, code, argument) {
+    super(message, code);
+    this.message = message;
+    this.code = code;
+    this.argument = argument;
+    Object.setPrototypeOf(this, ConfigurationCCError.prototype);
+  }
+}
+const ConfigurationCCValues = Object.freeze({
+  ...import_Values.V.defineStaticCCValues(import_safe.CommandClasses.Configuration, {
+    ...import_Values.V.staticProperty(
+      "isParamInformationFromConfig",
+      void 0,
+      // meta
+      { internal: true, supportsEndpoints: false }
+    )
+  }),
+  ...import_Values.V.defineDynamicCCValues(import_safe.CommandClasses.Configuration, {
+    ...import_Values.V.dynamicPropertyAndKeyWithName(
+      "paramInformation",
+      // eslint-disable-next-line @typescript-eslint/no-unused-vars
+      (parameter, bitMask) => parameter,
+      (parameter, bitMask) => bitMask,
+      ({ property, propertyKey }) => typeof property === "number" && (typeof propertyKey === "number" || propertyKey == void 0),
+      // Metadata is determined dynamically depending on other factors
+      void 0
+    )
+  })
+});
+function createConfigurationCCInstance(endpoint) {
+  return import_CommandClass.CommandClass.createInstanceUnchecked(endpoint.virtual ? endpoint.node.physicalNodes[0] : endpoint, ConfigurationCC);
+}
+function normalizeConfigurationCCAPISetOptions(ctx, endpoint, options) {
+  if ("bitMask" in options && options.bitMask) {
+    const ccc = createConfigurationCCInstance(endpoint);
+    const paramInfo = ccc.getParamInformation(ctx, options.parameter, options.bitMask);
+    if (!paramInfo.isFromConfig) {
+      throw new import_safe.ZWaveError("Setting a partial configuration parameter requires it to be defined in a device config file!", import_safe.ZWaveErrorCodes.Argument_Invalid);
+    }
+    return {
+      parameter: options.parameter,
+      bitMask: options.bitMask,
+      value: options.value,
+      valueSize: paramInfo.valueSize,
+      valueFormat: paramInfo.format
+    };
+  } else if ("valueSize" in options) {
+    return (0, import_safe3.pick)(options, [
+      "parameter",
+      "value",
+      "valueSize",
+      "valueFormat"
+    ]);
+  } else {
+    const ccc = createConfigurationCCInstance(endpoint);
+    const paramInfo = ccc.getParamInformation(ctx, options.parameter, options.bitMask);
+    if (!paramInfo.isFromConfig) {
+      throw new import_safe.ZWaveError("Setting a configuration parameter without specifying a value size and format requires it to be defined in a device config file!", import_safe.ZWaveErrorCodes.Argument_Invalid);
+    }
+    return {
+      parameter: options.parameter,
+      value: options.value,
+      valueSize: paramInfo.valueSize,
+      valueFormat: paramInfo.format
+    };
+  }
+}
+function bulkMergePartialParamValues(ctx, endpoint, options) {
+  const allParams = options.filter((o) => o.bitMask == void 0);
+  const unmergedPartials = /* @__PURE__ */ new Map();
+  for (const partial of options.filter((o) => o.bitMask != void 0)) {
+    if (!unmergedPartials.has(partial.parameter)) {
+      unmergedPartials.set(partial.parameter, []);
+    }
+    unmergedPartials.get(partial.parameter).push(partial);
+  }
+  if (unmergedPartials.size) {
+    const ccc = createConfigurationCCInstance(endpoint);
+    for (const [parameter, partials] of unmergedPartials) {
+      allParams.push({
+        parameter,
+        value: ccc.composePartialParamValues(ctx, parameter, partials.map((p) => ({
+          bitMask: p.bitMask,
+          partialValue: p.value
+        }))),
+        valueSize: partials[0].valueSize,
+        valueFormat: partials[0].valueFormat
+      });
+    }
+  }
+  return allParams;
+}
+function isSignedPartial(bitMask, format) {
+  return (0, import_safe.getBitMaskWidth)(bitMask) > 1 && (format ?? import_safe.ConfigValueFormat.SignedInteger) === import_safe.ConfigValueFormat.SignedInteger;
+}
+function reInterpretSignedValue(value, valueSize, targetFormat) {
+  const raw = new import_safe2.Bytes(valueSize);
+  serializeValue(raw, 0, valueSize, import_safe.ConfigValueFormat.SignedInteger, value);
+  return parseValue(raw, valueSize, targetFormat);
+}
+function getParamInformationFromConfigFile(ctx, nodeId, endpointIndex) {
+  const deviceConfig = ctx.getDeviceConfig?.(nodeId);
+  if (endpointIndex === 0) {
+    return deviceConfig?.paramInformation ?? deviceConfig?.endpoints?.get(0)?.paramInformation;
+  } else {
+    return deviceConfig?.endpoints?.get(endpointIndex)?.paramInformation;
+  }
+}
+let ConfigurationCCAPI = class ConfigurationCCAPI2 extends import_API.CCAPI {
+  supportsCommand(cmd) {
+    switch (cmd) {
+      case import_Types.ConfigurationCommand.Get:
+      case import_Types.ConfigurationCommand.Set:
+        return true;
+      // This is mandatory
+      case import_Types.ConfigurationCommand.BulkGet:
+      case import_Types.ConfigurationCommand.BulkSet:
+        return this.version >= 2;
+      case import_Types.ConfigurationCommand.NameGet:
+      case import_Types.ConfigurationCommand.InfoGet:
+      case import_Types.ConfigurationCommand.PropertiesGet:
+        return this.version >= 3;
+      case import_Types.ConfigurationCommand.DefaultReset:
+        return this.version >= 4;
+    }
+    return super.supportsCommand(cmd);
+  }
+  get [import_API.SET_VALUE]() {
+    return async function({ property, propertyKey }, value) {
+      if (typeof property !== "number") {
+        (0, import_API.throwUnsupportedProperty)(this.ccId, property);
+      }
+      if (propertyKey != void 0 && typeof propertyKey !== "number") {
+        (0, import_API.throwUnsupportedPropertyKey)(this.ccId, property, propertyKey);
+      }
+      if (typeof value !== "number") {
+        (0, import_API.throwWrongValueType)(this.ccId, property, "number", typeof value);
+      }
+      let ccInstance;
+      const applHost = this.host;
+      if (this.isSinglecast()) {
+        ccInstance = createConfigurationCCInstance(this.endpoint);
+      } else if (this.isMulticast()) {
+        const nodes = this.endpoint.node.physicalNodes;
+        if (!nodes.every((node) => node.getEndpoint(this.endpoint.index)?.supportsCC(import_safe.CommandClasses.Configuration))) {
+          throw new import_safe.ZWaveError(`The multicast setValue API for Configuration CC requires all virtual target endpoints to support Configuration CC!`, import_safe.ZWaveErrorCodes.CC_Invalid);
+        }
+        const paramInfos = this.endpoint.node.physicalNodes.map((node) => createConfigurationCCInstance(node.getEndpoint(this.endpoint.index)).getParamInformation(this.host, property, propertyKey));
+        if (!paramInfos.length || !paramInfos.every((info, index) => {
+          if (index === 0)
+            return true;
+          return info.valueSize === paramInfos[0].valueSize && info.format === paramInfos[0].format;
+        })) {
+          throw new import_safe.ZWaveError(`The multicast setValue API for Configuration CC requires all virtual target nodes to have the same parameter definition!`, import_safe.ZWaveErrorCodes.CC_Invalid);
+        }
+        ccInstance = createConfigurationCCInstance(this.endpoint);
+      } else {
+        throw new import_safe.ZWaveError(`The setValue API for Configuration CC is not supported via broadcast!`, import_safe.ZWaveErrorCodes.CC_NotSupported);
+      }
+      let { valueSize, format: valueFormat = import_safe.ConfigValueFormat.SignedInteger } = ccInstance.getParamInformation(applHost, property);
+      let targetValue;
+      if (propertyKey) {
+        if (!valueSize) {
+          valueSize = ccInstance.getParamInformation(applHost, property, propertyKey).valueSize;
+        }
+        targetValue = ccInstance.composePartialParamValue(applHost, property, propertyKey, value);
+        valueFormat = import_safe.ConfigValueFormat.UnsignedInteger;
+      } else {
+        targetValue = value;
+      }
+      if (!valueSize) {
+        valueSize = (0, import_safe.getMinIntegerSize)(targetValue, valueFormat === import_safe.ConfigValueFormat.SignedInteger);
+        if (!valueSize) {
+          throw new import_safe.ZWaveError(`The value ${targetValue} is not valid for configuration parameters!`, import_safe.ZWaveErrorCodes.Argument_Invalid);
+        }
+      }
+      if (!isSafeValue(targetValue, valueSize, valueFormat)) {
+        throwInvalidValueError(targetValue, property, valueSize, valueFormat);
+      }
+      const result = await this.set({
+        parameter: property,
+        value: targetValue,
+        valueSize,
+        valueFormat
+      });
+      if (!(0, import_safe.supervisedCommandSucceeded)(result) && this.isSinglecast()) {
+        this.schedulePoll(
+          { property, propertyKey },
+          targetValue,
+          // Configuration changes are instant
+          { transition: "fast" }
+        );
+      }
+      return result;
+    };
+  }
+  get [import_API.POLL_VALUE]() {
+    return async function({ property, propertyKey }) {
+      if (typeof property !== "number") {
+        (0, import_API.throwUnsupportedProperty)(this.ccId, property);
+      }
+      if (propertyKey != void 0 && typeof propertyKey !== "number") {
+        (0, import_API.throwUnsupportedPropertyKey)(this.ccId, property, propertyKey);
+      }
+      return this.get(property, { valueBitMask: propertyKey });
+    };
+  }
+  /**
+   * Requests the current value of a given config parameter from the device.
+   * This may timeout and return `undefined` if the node does not respond.
+   * If the node replied with a different parameter number, a `ConfigurationCCError`
+   * is thrown with the `argument` property set to the reported parameter number.
+   */
+  async get(parameter, options) {
+    __assertType("parameter", "number", __assertType__number.bind(void 0, parameter));
+    __assertType("options", void 0, __assertType__optional__0.bind(void 0, options));
+    this.assertPhysicalEndpoint(this.endpoint);
+    if (parameter > 255) {
+      const result = await this.getBulk([
+        {
+          parameter,
+          bitMask: options?.valueBitMask
+        }
+      ]);
+      return result.find((r) => r.parameter === parameter)?.value;
+    }
+    this.assertSupportsCommand(import_Types.ConfigurationCommand, import_Types.ConfigurationCommand.Get);
+    const { valueBitMask, allowUnexpectedResponse } = options ?? {};
+    const cc = new ConfigurationCCGet({
+      nodeId: this.endpoint.nodeId,
+      endpointIndex: this.endpoint.index,
+      parameter,
+      allowUnexpectedResponse
+    });
+    const response = await this.host.sendCommand(cc, this.commandOptions);
+    if (!response)
+      return;
+    if (response.parameter === parameter) {
+      if (!valueBitMask)
+        return response.value;
+      const paramInfo = cc.getParamInformation(this.host, response.parameter, valueBitMask);
+      return (0, import_safe.parsePartial)(response.value, valueBitMask, isSignedPartial(valueBitMask, paramInfo.format));
+    }
+    this.host.logNode(this.endpoint.nodeId, {
+      endpoint: this.endpoint.index,
+      message: `Received unexpected ConfigurationReport (param = ${response.parameter}, value = ${response.value.toString()})`,
+      direction: "inbound",
+      level: "error"
+    });
+    throw new ConfigurationCCError(`The first existing parameter on this node is ${response.parameter}`, import_safe.ZWaveErrorCodes.ConfigurationCC_FirstParameterNumber, response.parameter);
+  }
+  /**
+   * Requests the current value of the config parameters from the device.
+   * When the node does not respond due to a timeout, the `value` in the returned array will be `undefined`.
+   */
+  async getBulk(options) {
+    __assertType("options", void 0, __assertType__sa__2_ea_2.bind(void 0, options));
+    this.assertPhysicalEndpoint(this.endpoint);
+    let values;
+    const distinctParameters = (0, import_arrays.distinct)(options.map((o) => o.parameter));
+    if (this.supportsCommand(import_Types.ConfigurationCommand.BulkGet) && (0, import_safe.isConsecutiveArray)(distinctParameters)) {
+      const cc2 = new ConfigurationCCBulkGet({
+        nodeId: this.endpoint.nodeId,
+        endpointIndex: this.endpoint.index,
+        parameters: distinctParameters
+      });
+      const response = await this.host.sendCommand(cc2, this.commandOptions);
+      if (response)
+        values = response.values;
+    } else {
+      this.assertSupportsCommand(import_Types.ConfigurationCommand, import_Types.ConfigurationCommand.Get);
+      const _values = /* @__PURE__ */ new Map();
+      for (const parameter of distinctParameters) {
+        const cc2 = new ConfigurationCCGet({
+          nodeId: this.endpoint.nodeId,
+          endpointIndex: this.endpoint.index,
+          parameter
+        });
+        const response = await this.host.sendCommand(cc2, this.commandOptions);
+        if (response) {
+          _values.set(response.parameter, response.value);
+        }
+      }
+      values = _values;
+    }
+    const cc = createConfigurationCCInstance(this.endpoint);
+    return options.map((o) => {
+      let value = values?.get(o.parameter);
+      if (typeof value === "number" && o.bitMask) {
+        const paramInfo = cc.getParamInformation(this.host, o.parameter, o.bitMask);
+        value = (0, import_safe.parsePartial)(value, o.bitMask, isSignedPartial(o.bitMask, paramInfo.format));
+      }
+      return { ...o, value };
+    });
+  }
+  /**
+   * Sets a new value for a given config parameter of the device.
+   */
+  async set(options) {
+    __assertType("options", "ConfigurationCCAPISetOptions", __assertType__ConfigurationCCAPISetOptions.bind(void 0, options));
+    if (options.parameter > 255) {
+      return this.setBulk([options]);
+    }
+    this.assertSupportsCommand(import_Types.ConfigurationCommand, import_Types.ConfigurationCommand.Set);
+    const normalized = normalizeConfigurationCCAPISetOptions(this.host, this.endpoint, options);
+    let value = normalized.value;
+    if (normalized.bitMask) {
+      const ccc = createConfigurationCCInstance(this.endpoint);
+      value = ccc.composePartialParamValue(this.host, normalized.parameter, normalized.bitMask, normalized.value);
+    }
+    const cc = new ConfigurationCCSet({
+      nodeId: this.endpoint.nodeId,
+      endpointIndex: this.endpoint.index,
+      resetToDefault: false,
+      parameter: normalized.parameter,
+      value,
+      valueSize: normalized.valueSize,
+      valueFormat: normalized.valueFormat
+    });
+    return this.host.sendCommand(cc, this.commandOptions);
+  }
+  /**
+   * Sets new values for multiple config parameters of the device. Uses the `BulkSet` command if supported, otherwise falls back to individual `Set` commands.
+   */
+  async setBulk(values) {
+    __assertType("values", void 0, __assertType__sa_su_si__4__5_ei_si__4__7_ei_si__4__9_ei_eu_ea_2.bind(void 0, values));
+    const normalized = values.map((v) => normalizeConfigurationCCAPISetOptions(this.host, this.endpoint, v));
+    const allParams = bulkMergePartialParamValues(this.host, this.endpoint, normalized);
+    const canUseBulkSet = this.supportsCommand(import_Types.ConfigurationCommand.BulkSet) && (0, import_safe.isConsecutiveArray)(allParams.map((v) => v.parameter)) && new Set(allParams.map((v) => v.valueFormat)).size === 1 && new Set(allParams.map((v) => v.valueSize)).size === 1;
+    if (canUseBulkSet) {
+      const cc = new ConfigurationCCBulkSet({
+        nodeId: this.endpoint.nodeId,
+        endpointIndex: this.endpoint.index,
+        parameters: allParams.map((v) => v.parameter),
+        valueSize: allParams[0].valueSize,
+        valueFormat: allParams[0].valueFormat,
+        values: allParams.map((v) => v.value),
+        handshake: true
+      });
+      const result = await this.host.sendCommand(cc, this.commandOptions);
+      if (result) {
+        const sentValues = cc.values;
+        const receivedValues = [...result.values.values()];
+        const success = sentValues.length === receivedValues.length && sentValues.every((v, i) => v === receivedValues[i]);
+        return {
+          status: success ? import_safe.SupervisionStatus.Success : import_safe.SupervisionStatus.Fail
+        };
+      } else {
+        return void 0;
+      }
+    } else {
+      this.assertSupportsCommand(import_Types.ConfigurationCommand, import_Types.ConfigurationCommand.Set);
+      const supervisionResults = [];
+      for (const { parameter, value, valueSize, valueFormat } of allParams) {
+        const cc = new ConfigurationCCSet({
+          nodeId: this.endpoint.nodeId,
+          endpointIndex: this.endpoint.index,
+          parameter,
+          value,
+          valueSize,
+          valueFormat
+        });
+        supervisionResults.push(await this.host.sendCommand(cc, this.commandOptions));
+      }
+      return (0, import_safe.mergeSupervisionResults)(supervisionResults);
+    }
+  }
+  /**
+   * Resets a configuration parameter to its default value.
+   *
+   * WARNING: This will throw on legacy devices (ConfigurationCC v3 and below)
+   */
+  async reset(parameter) {
+    __assertType("parameter", "number", __assertType__number.bind(void 0, parameter));
+    if (parameter > 255) {
+      return this.resetBulk([parameter]);
+    }
+    if (this.version <= 3) {
+      throw new import_safe.ZWaveError(`Resetting configuration parameters to default MUST not be done on nodes implementing ConfigurationCC V3 or below!`, import_safe.ZWaveErrorCodes.ConfigurationCC_NoResetToDefaultOnLegacyDevices);
+    }
+    this.assertSupportsCommand(import_Types.ConfigurationCommand, import_Types.ConfigurationCommand.Set);
+    const cc = new ConfigurationCCSet({
+      nodeId: this.endpoint.nodeId,
+      endpointIndex: this.endpoint.index,
+      parameter,
+      resetToDefault: true
+    });
+    return this.host.sendCommand(cc, this.commandOptions);
+  }
+  /**
+   * Resets multiple configuration parameters to their default value. Uses BulkSet if supported, otherwise falls back to individual Set commands.
+   *
+   * WARNING: This will throw on legacy devices (ConfigurationCC v3 and below)
+   */
+  async resetBulk(parameters) {
+    __assertType("parameters", void 0, __assertType__sa__number_ea_2.bind(void 0, parameters));
+    if ((0, import_safe.isConsecutiveArray)(parameters) && this.supportsCommand(import_Types.ConfigurationCommand.BulkSet)) {
+      const cc = new ConfigurationCCBulkSet({
+        nodeId: this.endpoint.nodeId,
+        endpointIndex: this.endpoint.index,
+        parameters,
+        resetToDefault: true
+      });
+      return this.host.sendCommand(cc, this.commandOptions);
+    } else {
+      this.assertSupportsCommand(import_Types.ConfigurationCommand, import_Types.ConfigurationCommand.Set);
+      const CCs = (0, import_arrays.distinct)(parameters).map((parameter) => new ConfigurationCCSet({
+        nodeId: this.endpoint.nodeId,
+        endpointIndex: this.endpoint.index,
+        parameter,
+        resetToDefault: true
+      }));
+      for (const cc of CCs) {
+        await this.host.sendCommand(cc, this.commandOptions);
+      }
+    }
+  }
+  /** Resets all configuration parameters to their default value */
+  async resetAll() {
+    this.assertPhysicalEndpoint(this.endpoint);
+    this.assertSupportsCommand(import_Types.ConfigurationCommand, import_Types.ConfigurationCommand.DefaultReset);
+    const cc = new ConfigurationCCDefaultReset({
+      nodeId: this.endpoint.nodeId,
+      endpointIndex: this.endpoint.index
+    });
+    await this.host.sendCommand(cc, this.commandOptions);
+  }
+  async getProperties(parameter) {
+    __assertType("parameter", "number", __assertType__number.bind(void 0, parameter));
+    this.assertPhysicalEndpoint(this.endpoint);
+    const cc = new ConfigurationCCPropertiesGet({
+      nodeId: this.endpoint.nodeId,
+      endpointIndex: this.endpoint.index,
+      parameter
+    });
+    const response = await this.host.sendCommand(cc, this.commandOptions);
+    if (response) {
+      return (0, import_safe3.pick)(response, [
+        "valueSize",
+        "valueFormat",
+        "minValue",
+        "maxValue",
+        "defaultValue",
+        "nextParameter",
+        "altersCapabilities",
+        "isReadonly",
+        "isAdvanced",
+        "noBulkSupport"
+      ]);
+    }
+  }
+  /** Requests the name of a configuration parameter from the node */
+  async getName(parameter) {
+    __assertType("parameter", "number", __assertType__number.bind(void 0, parameter));
+    this.assertPhysicalEndpoint(this.endpoint);
+    const cc = new ConfigurationCCNameGet({
+      nodeId: this.endpoint.nodeId,
+      endpointIndex: this.endpoint.index,
+      parameter
+    });
+    const response = await this.host.sendCommand(cc, this.commandOptions);
+    return response?.name;
+  }
+  /** Requests usage info for a configuration parameter from the node */
+  async getInfo(parameter) {
+    __assertType("parameter", "number", __assertType__number.bind(void 0, parameter));
+    this.assertPhysicalEndpoint(this.endpoint);
+    const cc = new ConfigurationCCInfoGet({
+      nodeId: this.endpoint.nodeId,
+      endpointIndex: this.endpoint.index,
+      parameter
+    });
+    const response = await this.host.sendCommand(cc, this.commandOptions);
+    return response?.info;
+  }
+  /**
+   * This scans the node for the existing parameters. Found parameters will be reported
+   * through the `value added` and `value updated` events.
+   *
+   * WARNING: This method throws for newer devices.
+   *
+   * WARNING: On nodes implementing V1 and V2, this process may take
+   * **up to an hour**, depending on the configured timeout.
+   *
+   * WARNING: On nodes implementing V2, all parameters after 255 will be ignored.
+   */
+  async scanParametersLegacy() {
+    if (this.version >= 3) {
+      throw new import_safe.ZWaveError("Use ConfigurationCC.interview instead of scanning parameters for versions 3 and above.", import_safe.ZWaveErrorCodes.ConfigurationCC_NoLegacyScanOnNewDevices);
+    }
+    this.assertPhysicalEndpoint(this.endpoint);
+    this.host.logNode(this.endpoint.nodeId, {
+      endpoint: this.endpoint.index,
+      message: `Scanning available parameters...`
+    });
+    const ccInstance = createConfigurationCCInstance(this.endpoint);
+    for (let param = 1; param <= 255; param++) {
+      let originalValue;
+      this.host.logNode(this.endpoint.nodeId, {
+        endpoint: this.endpoint.index,
+        message: `  trying param ${param}...`,
+        direction: "outbound"
+      });
+      try {
+        originalValue = await this.get(param, {
+          // When requesting a non-existing parameter, a node SHOULD respond with the
+          // first available parameter. We use this for the first param only,
+          // because delayed responses might otherwise confuse the interview process
+          allowUnexpectedResponse: param === 1
+        });
+        if (originalValue != void 0) {
+          const logMessage = `  Param ${param}:
+    readable  = true
+    valueSize = ${ccInstance.getParamInformation(this.host, param).valueSize}
+    value     = ${originalValue.toString()}`;
+          this.host.logNode(this.endpoint.nodeId, {
+            endpoint: this.endpoint.index,
+            message: logMessage,
+            direction: "inbound"
+          });
+        }
+      } catch (e) {
+        if (e instanceof ConfigurationCCError && e.code === import_safe.ZWaveErrorCodes.ConfigurationCC_FirstParameterNumber) {
+          if (e.argument - 1 > param)
+            param = e.argument - 1;
+          continue;
+        }
+        throw e;
+      }
+    }
+  }
+};
+ConfigurationCCAPI = __decorate([
+  (0, import_CommandClassDecorators.API)(import_safe.CommandClasses.Configuration)
+], ConfigurationCCAPI);
+let ConfigurationCC = class ConfigurationCC2 extends import_CommandClass.CommandClass {
+  async interview(ctx) {
+    const node = this.getNode(ctx);
+    const endpoint = this.getEndpoint(ctx);
+    const api = import_API.CCAPI.create(import_safe.CommandClasses.Configuration, ctx, endpoint).withOptions({
+      priority: import_safe.MessagePriority.NodeQuery
+    });
+    ctx.logNode(node.id, {
+      endpoint: this.endpointIndex,
+      message: `Interviewing ${this.ccName}...`,
+      direction: "none"
+    });
+    const deviceConfig = ctx.getDeviceConfig?.(node.id);
+    const paramInfo = getParamInformationFromConfigFile(ctx, node.id, this.endpointIndex);
+    if (paramInfo) {
+      ctx.logNode(node.id, {
+        endpoint: this.endpointIndex,
+        message: `${this.constructor.name}: Loading configuration parameters from device config`,
+        direction: "none"
+      });
+      this.deserializeParamInformationFromConfig(ctx, paramInfo);
+    }
+    const documentedParamNumbers = new Set(Array.from(paramInfo?.keys() ?? []).map((k) => k.parameter));
+    if (api.version >= 3) {
+      ctx.logNode(node.id, {
+        endpoint: this.endpointIndex,
+        message: "finding first configuration parameter...",
+        direction: "outbound"
+      });
+      const param0props = await api.getProperties(0);
+      let param;
+      if (param0props) {
+        param = param0props.nextParameter;
+        if (param === 0) {
+          ctx.logNode(node.id, {
+            endpoint: this.endpointIndex,
+            message: `didn't report any config params, trying #1 just to be sure...`,
+            direction: "inbound"
+          });
+          param = 1;
+        }
+      } else {
+        ctx.logNode(node.id, {
+          endpoint: this.endpointIndex,
+          message: "Finding first configuration parameter timed out, skipping interview...",
+          level: "warn"
+        });
+        return;
+      }
+      while (param > 0) {
+        ctx.logNode(node.id, {
+          endpoint: this.endpointIndex,
+          message: `querying parameter #${param} information...`,
+          direction: "outbound"
+        });
+        const props = await api.getProperties(param).catch(
+          // If querying the properties fails, don't abort the entire interview
+          () => void 0
+        );
+        if (!props) {
+          ctx.logNode(node.id, {
+            endpoint: this.endpointIndex,
+            message: `Querying parameter #${param} information timed out, skipping scan...`,
+            level: "warn"
+          });
+          break;
+        }
+        const { nextParameter, ...properties } = props;
+        let logMessage;
+        if (properties.valueSize === 0) {
+          logMessage = `Parameter #${param} is unsupported. Next parameter: ${nextParameter}`;
+        } else {
+          let name;
+          if (!documentedParamNumbers.has(param)) {
+            if (!deviceConfig?.compat?.skipConfigurationNameQuery) {
+              name = await api.getName(param).catch(
+                // If querying the name fails, don't abort the entire interview
+                () => void 0
+              );
+            }
+            if (!deviceConfig?.compat?.skipConfigurationInfoQuery) {
+              await api.getInfo(param).catch(
+                // If querying the info fails, don't abort the entire interview
+                () => void 0
+              );
+            }
+          }
+          logMessage = `received information for parameter #${param}:`;
+          if (name) {
+            logMessage += `
+parameter name:      ${name}`;
+          }
+          logMessage += `
+value format:        ${(0, import_safe3.getEnumMemberName)(import_safe.ConfigValueFormat, properties.valueFormat)}
+value size:          ${properties.valueSize} bytes
+min value:           ${properties.minValue?.toString() ?? "undefined"}
+max value:           ${properties.maxValue?.toString() ?? "undefined"}
+default value:       ${properties.defaultValue?.toString() ?? "undefined"}
+is read-only:        ${!!properties.isReadonly}
+is advanced (UI):    ${!!properties.isAdvanced}
+has bulk support:    ${!properties.noBulkSupport}
+alters capabilities: ${!!properties.altersCapabilities}`;
+        }
+        ctx.logNode(node.id, {
+          endpoint: this.endpointIndex,
+          message: logMessage,
+          direction: "inbound"
+        });
+        if (nextParameter > param) {
+          param = nextParameter;
+        } else {
+          break;
+        }
+      }
+    }
+    await this.refreshValues(ctx);
+    this.setInterviewComplete(ctx, true);
+  }
+  async refreshValues(ctx) {
+    const node = this.getNode(ctx);
+    const endpoint = this.getEndpoint(ctx);
+    const api = import_API.CCAPI.create(import_safe.CommandClasses.Configuration, ctx, endpoint).withOptions({
+      priority: import_safe.MessagePriority.NodeQuery
+    });
+    if (api.version < 3) {
+      const paramInfo = getParamInformationFromConfigFile(ctx, node.id, this.endpointIndex);
+      if (paramInfo?.size) {
+        const alreadyQueried = /* @__PURE__ */ new Set();
+        for (const param of paramInfo.keys()) {
+          if (paramInfo.get(param)?.writeOnly)
+            continue;
+          if (alreadyQueried.has(param.parameter))
+            continue;
+          alreadyQueried.add(param.parameter);
+          ctx.logNode(node.id, {
+            endpoint: this.endpointIndex,
+            message: `querying parameter #${param.parameter} value...`,
+            direction: "outbound"
+          });
+          const paramValue = await api.get(param.parameter);
+          if (typeof paramValue === "number") {
+            ctx.logNode(node.id, {
+              endpoint: this.endpointIndex,
+              message: `parameter #${param.parameter} has value: ${paramValue}`,
+              direction: "inbound"
+            });
+          } else if (!paramValue) {
+            ctx.logNode(node.id, {
+              endpoint: this.endpointIndex,
+              message: `received no value for parameter #${param.parameter}`,
+              direction: "inbound",
+              level: "warn"
+            });
+          }
+        }
+      } else {
+        ctx.logNode(node.id, {
+          endpoint: this.endpointIndex,
+          message: `${this.constructor.name}: skipping interview because CC version is < 3 and there is no config file`,
+          direction: "none"
+        });
+      }
+    } else {
+      const parameters = (0, import_arrays.distinct)(this.getDefinedValueIDs(ctx).map((v) => v.property).filter((p) => typeof p === "number"));
+      for (const param of parameters) {
+        if (this.getParamInformation(ctx, param).readable !== false) {
+          ctx.logNode(node.id, {
+            endpoint: this.endpointIndex,
+            message: `querying parameter #${param} value...`,
+            direction: "outbound"
+          });
+          await api.get(param);
+        } else {
+          ctx.logNode(node.id, {
+            endpoint: this.endpointIndex,
+            message: `not querying parameter #${param} value, because it is writeonly`,
+            direction: "none"
+          });
+        }
+      }
+    }
+  }
+  /**
+   * Whether this node's param information was loaded from a config file.
+   * If this is true, we don't trust what the node reports
+   */
+  paramExistsInConfigFile(ctx, parameter, valueBitMask) {
+    if (this.getValue(ctx, ConfigurationCCValues.isParamInformationFromConfig) !== true) {
+      return false;
+    }
+    const paramInformation = getParamInformationFromConfigFile(ctx, this.nodeId, this.endpointIndex);
+    if (!paramInformation)
+      return false;
+    if (paramInformation.has({ parameter, valueBitMask })) {
+      return true;
+    } else if (valueBitMask == void 0) {
+      for (const key of paramInformation.keys()) {
+        if (key.parameter === parameter)
+          return true;
+      }
+    }
+    return false;
+  }
+  /**
+   * @internal
+   * Stores config parameter metadata for this CC's node
+   */
+  extendParamInformation(ctx, parameter, valueBitMask, info) {
+    if (valueBitMask === void 0 && this.paramExistsInConfigFile(ctx, parameter)) {
+      return;
+    }
+    const metadata = this.getParamInformation(ctx, parameter, valueBitMask);
+    Object.assign(metadata, info);
+    this.setMetadata(ctx, ConfigurationCCValues.paramInformation(parameter, valueBitMask), metadata);
+  }
+  /**
+   * @internal
+   * Returns stored config parameter metadata for this CC's node
+   */
+  getParamInformation(ctx, parameter, valueBitMask) {
+    return this.getMetadata(ctx, ConfigurationCCValues.paramInformation(parameter, valueBitMask)) ?? {
+      ...import_safe.ValueMetadata.Any
+    };
+  }
+  /**
+   * **INTERNAL:** Returns the param info that was queried for this node. This returns the information that was returned by the node
+   * and does not include partial parameters.
+   */
+  getQueriedParamInfos(ctx) {
+    const parameters = (0, import_arrays.distinct)(this.getDefinedValueIDs(ctx).map((v) => v.property).filter((p) => typeof p === "number"));
+    return (0, import_objects.composeObject)(parameters.map((p) => [
+      p,
+      this.getParamInformation(ctx, p)
+    ]));
+  }
+  /**
+   * Returns stored config parameter metadata for all partial config params addressed with the given parameter number
+   */
+  getPartialParamInfos(ctx, parameter) {
+    const valueDB = this.getValueDB(ctx);
+    return valueDB.findMetadata((id) => id.commandClass === this.ccId && (id.endpoint ?? 0) === this.endpointIndex && id.property === parameter && id.propertyKey != void 0);
+  }
+  /**
+   * Computes the full value of a parameter after applying a partial param value
+   */
+  composePartialParamValue(ctx, parameter, bitMask, partialValue) {
+    return this.composePartialParamValues(ctx, parameter, [
+      { bitMask, partialValue }
+    ]);
+  }
+  /**
+   * Computes the full value of a parameter after applying multiple partial param values
+   */
+  composePartialParamValues(ctx, parameter, partials) {
+    const valueDB = this.getValueDB(ctx);
+    const otherValues = valueDB.findValues((id) => id.commandClass === this.ccId && (id.endpoint ?? 0) === this.endpointIndex && id.property === parameter && id.propertyKey != void 0 && !partials.some((p) => id.propertyKey === p.bitMask));
+    let ret = 0;
+    for (const { propertyKey: bitMask, value: partialValue } of otherValues) {
+      ret = (0, import_safe.encodePartial)(ret, partialValue, bitMask);
+    }
+    for (const { bitMask, partialValue } of partials) {
+      ret = (0, import_safe.encodePartial)(ret, partialValue, bitMask);
+    }
+    return ret;
+  }
+  /** Deserializes the config parameter info from a config file */
+  deserializeParamInformationFromConfig(ctx, config) {
+    const valueDB = this.getValueDB(ctx);
+    for (const meta of valueDB.getAllMetadata(this.ccId)) {
+      if (typeof meta.property === "number" && (meta.endpoint ?? 0) === this.endpointIndex) {
+        valueDB.setMetadata(
+          meta,
+          void 0,
+          // Don't emit the added/updated events, as this will spam applications with untranslated events
+          { noEvent: true }
+        );
+      }
+    }
+    this.setValue(ctx, ConfigurationCCValues.isParamInformationFromConfig, false);
+    for (const [param, info] of config.entries()) {
+      const paramInfo = (0, import_safe.stripUndefined)({
+        // TODO: Make this smarter! (0...1 ==> boolean)
+        type: "number",
+        valueSize: info.valueSize,
+        min: info.minValue,
+        max: info.maxValue,
+        default: info.defaultValue,
+        unit: info.unit,
+        format: info.unsigned ? import_safe.ConfigValueFormat.UnsignedInteger : import_safe.ConfigValueFormat.SignedInteger,
+        readable: !info.writeOnly,
+        writeable: !info.readOnly,
+        allowManualEntry: info.allowManualEntry,
+        states: info.options.length > 0 ? (0, import_objects.composeObject)(info.options.map(({ label, value }) => [
+          value.toString(),
+          label
+        ])) : void 0,
+        label: info.label,
+        description: info.description,
+        isFromConfig: true
+      });
+      this.extendParamInformation(ctx, param.parameter, param.valueBitMask, paramInfo);
+    }
+    this.setValue(ctx, ConfigurationCCValues.isParamInformationFromConfig, true);
+  }
+  translatePropertyKey(ctx, property, propertyKey) {
+    if (typeof property === "number" && (propertyKey == void 0 || typeof propertyKey === "number")) {
+      return void 0;
+    }
+    return super.translateProperty(ctx, property, propertyKey);
+  }
+  translateProperty(ctx, property, propertyKey) {
+    if (typeof property === "number" && (propertyKey == void 0 || typeof propertyKey === "number")) {
+      const paramInfo = this.getParamInformation(ctx, property, propertyKey);
+      if (paramInfo.label)
+        return paramInfo.label;
+      let ret = `param${(0, import_strings.padStart)(property.toString(), 3, "0")}`;
+      if (propertyKey != void 0) {
+        ret += "_" + propertyKey.toString();
+      }
+      return ret;
+    }
+    return super.translateProperty(ctx, property, propertyKey);
+  }
+};
+ConfigurationCC = __decorate([
+  (0, import_CommandClassDecorators.commandClass)(import_safe.CommandClasses.Configuration),
+  (0, import_CommandClassDecorators.implementedVersion)(4),
+  (0, import_CommandClassDecorators.ccValues)(ConfigurationCCValues)
+], ConfigurationCC);
+let ConfigurationCCReport = ConfigurationCCReport_1 = class ConfigurationCCReport2 extends ConfigurationCC {
+  constructor(options) {
+    super(options);
+    this.parameter = options.parameter;
+    this.value = options.value;
+    this.valueSize = options.valueSize;
+    this.valueFormat = options.valueFormat;
+  }
+  static from(raw, ctx) {
+    (0, import_safe.validatePayload)(raw.payload.length > 2);
+    const parameter = raw.payload[0];
+    const valueSize = raw.payload[1] & 7;
+    (0, import_safe.validatePayload)(valueSize >= 1, valueSize <= 4, raw.payload.length >= 2 + valueSize);
+    const value = parseValue(raw.payload.subarray(2), valueSize, import_safe.ConfigValueFormat.SignedInteger);
+    return new ConfigurationCCReport_1({
+      nodeId: ctx.sourceNodeId,
+      parameter,
+      valueSize,
+      value
+    });
+  }
+  parameter;
+  value;
+  valueSize;
+  valueFormat;
+  // only used for serialization
+  persistValues(ctx) {
+    if (!super.persistValues(ctx))
+      return false;
+    const ccVersion = (0, import_CommandClass.getEffectiveCCVersion)(ctx, this);
+    const partialParams = this.getPartialParamInfos(ctx, this.parameter);
+    let cachedValueFormat;
+    if (partialParams.length > 0) {
+      cachedValueFormat = partialParams[0].metadata.format;
+    } else {
+      const oldParamInformation = this.getParamInformation(ctx, this.parameter);
+      cachedValueFormat = oldParamInformation.format;
+      this.extendParamInformation(ctx, this.parameter, void 0, {
+        valueSize: this.valueSize
+      });
+      if (ccVersion < 3 && !this.paramExistsInConfigFile(ctx, this.parameter) && oldParamInformation.min == void 0 && oldParamInformation.max == void 0) {
+        const isSigned = oldParamInformation.format == void 0 || oldParamInformation.format === import_safe.ConfigValueFormat.SignedInteger;
+        this.extendParamInformation(ctx, this.parameter, void 0, (0, import_safe.getIntegerLimits)(this.valueSize, isSigned));
+      }
+    }
+    if (cachedValueFormat != void 0 && cachedValueFormat !== import_safe.ConfigValueFormat.SignedInteger) {
+      this.value = reInterpretSignedValue(this.value, this.valueSize, cachedValueFormat);
+    }
+    if (partialParams.length > 0) {
+      for (const param of partialParams) {
+        if (typeof param.propertyKey === "number") {
+          this.setValue(ctx, ConfigurationCCValues.paramInformation(this.parameter, param.propertyKey), (0, import_safe.parsePartial)(this.value, param.propertyKey, isSignedPartial(param.propertyKey, param.metadata.format)));
+        }
+      }
+    } else {
+      this.setValue(ctx, ConfigurationCCValues.paramInformation(this.parameter), this.value);
+    }
+    return true;
+  }
+  serialize(ctx) {
+    this.payload = import_safe2.Bytes.concat([
+      import_safe2.Bytes.from([this.parameter, this.valueSize & 7]),
+      new import_safe2.Bytes(this.valueSize)
+    ]);
+    serializeValue(this.payload, 2, this.valueSize, this.valueFormat ?? import_safe.ConfigValueFormat.SignedInteger, this.value);
+    return super.serialize(ctx);
+  }
+  toLogEntry(ctx) {
+    return {
+      ...super.toLogEntry(ctx),
+      message: {
+        "parameter #": this.parameter,
+        "value size": this.valueSize,
+        value: configValueToString(this.value)
+      }
+    };
+  }
+};
+ConfigurationCCReport = ConfigurationCCReport_1 = __decorate([
+  (0, import_CommandClassDecorators.CCCommand)(import_Types.ConfigurationCommand.Report)
+], ConfigurationCCReport);
+function testResponseForConfigurationGet(sent, received) {
+  return sent.parameter === received.parameter || sent.allowUnexpectedResponse;
+}
+let ConfigurationCCGet = ConfigurationCCGet_1 = class ConfigurationCCGet2 extends ConfigurationCC {
+  constructor(options) {
+    super(options);
+    this.parameter = options.parameter;
+    this.allowUnexpectedResponse = options.allowUnexpectedResponse ?? false;
+  }
+  static from(raw, ctx) {
+    (0, import_safe.validatePayload)(raw.payload.length >= 1);
+    const parameter = raw.payload[0];
+    return new ConfigurationCCGet_1({
+      nodeId: ctx.sourceNodeId,
+      parameter
+    });
+  }
+  parameter;
+  allowUnexpectedResponse;
+  serialize(ctx) {
+    this.payload = import_safe2.Bytes.from([this.parameter]);
+    return super.serialize(ctx);
+  }
+  toLogEntry(ctx) {
+    return {
+      ...super.toLogEntry(ctx),
+      message: { "parameter #": this.parameter }
+    };
+  }
+};
+ConfigurationCCGet = ConfigurationCCGet_1 = __decorate([
+  (0, import_CommandClassDecorators.CCCommand)(import_Types.ConfigurationCommand.Get),
+  (0, import_CommandClassDecorators.expectedCCResponse)(ConfigurationCCReport, testResponseForConfigurationGet)
+], ConfigurationCCGet);
+let ConfigurationCCSet = ConfigurationCCSet_1 = class ConfigurationCCSet2 extends ConfigurationCC {
+  constructor(options) {
+    super(options);
+    this.parameter = options.parameter;
+    this.resetToDefault = !!options.resetToDefault;
+    if (!options.resetToDefault) {
+      this.valueSize = options.valueSize;
+      this.valueFormat = options.valueFormat ?? import_safe.ConfigValueFormat.SignedInteger;
+      this.value = options.value;
+    }
+  }
+  static from(raw, ctx) {
+    (0, import_safe.validatePayload)(raw.payload.length >= 2);
+    const parameter = raw.payload[0];
+    const resetToDefault = !!(raw.payload[1] & 128);
+    const valueSize = raw.payload[1] & 7;
+    (0, import_safe.validatePayload)(valueSize >= 1, valueSize <= 4, raw.payload.length >= 2 + valueSize);
+    const value = parseValue(raw.payload.subarray(2), valueSize, import_safe.ConfigValueFormat.SignedInteger);
+    return new ConfigurationCCSet_1({
+      nodeId: ctx.sourceNodeId,
+      parameter,
+      resetToDefault,
+      valueSize,
+      value
+    });
+  }
+  resetToDefault;
+  parameter;
+  valueSize;
+  valueFormat;
+  value;
+  serialize(ctx) {
+    const valueSize = this.resetToDefault ? 1 : this.valueSize;
+    const payloadLength = 2 + valueSize;
+    this.payload = import_safe2.Bytes.alloc(payloadLength, 0);
+    this.payload[0] = this.parameter;
+    this.payload[1] = (this.resetToDefault ? 128 : 0) | valueSize & 7;
+    if (!this.resetToDefault) {
+      if (typeof this.value === "number" && !isSafeValue(this.value, valueSize, this.valueFormat)) {
+        throwInvalidValueError(this.value, this.parameter, valueSize, this.valueFormat);
+      }
+      try {
+        serializeValue(this.payload, 2, valueSize, this.valueFormat, this.value);
+      } catch (e) {
+        tryCatchOutOfBoundsError(e, this.value, this.parameter, valueSize, this.valueFormat);
+      }
+    }
+    return super.serialize(ctx);
+  }
+  toLogEntry(ctx) {
+    const message = {
+      "parameter #": this.parameter,
+      "reset to default": this.resetToDefault
+    };
+    if (this.valueSize != void 0) {
+      message["value size"] = this.valueSize;
+    }
+    if (this.valueFormat != void 0) {
+      message["value format"] = (0, import_safe3.getEnumMemberName)(import_safe.ConfigValueFormat, this.valueFormat);
+    }
+    if (this.value != void 0) {
+      message.value = configValueToString(this.value);
+    }
+    return {
+      ...super.toLogEntry(ctx),
+      message
+    };
+  }
+};
+ConfigurationCCSet = ConfigurationCCSet_1 = __decorate([
+  (0, import_CommandClassDecorators.CCCommand)(import_Types.ConfigurationCommand.Set),
+  (0, import_CommandClassDecorators.useSupervision)()
+], ConfigurationCCSet);
+function getResponseForBulkSet(cc) {
+  return cc.handshake ? ConfigurationCCBulkReport : void 0;
+}
+let ConfigurationCCBulkSet = class ConfigurationCCBulkSet2 extends ConfigurationCC {
+  constructor(options) {
+    super(options);
+    this._parameters = options.parameters;
+    if (this._parameters.length < 1) {
+      throw new import_safe.ZWaveError(`In a ConfigurationCC.BulkSet, parameters must be a non-empty array`, import_safe.ZWaveErrorCodes.CC_Invalid);
+    } else if (!(0, import_safe.isConsecutiveArray)(this._parameters)) {
+      throw new import_safe.ZWaveError(`A ConfigurationCC.BulkSet can only be used for consecutive parameters`, import_safe.ZWaveErrorCodes.CC_Invalid);
+    }
+    this._handshake = !!options.handshake;
+    this._resetToDefault = !!options.resetToDefault;
+    if (!!options.resetToDefault) {
+      this._valueSize = 1;
+      this._valueFormat = import_safe.ConfigValueFormat.SignedInteger;
+      this._values = this._parameters.map(() => 0);
+    } else {
+      this._valueSize = options.valueSize;
+      this._valueFormat = options.valueFormat ?? import_safe.ConfigValueFormat.SignedInteger;
+      this._values = options.values;
+    }
+  }
+  static from(_raw, _ctx) {
+    throw new import_safe.ZWaveError(`${this.name}: deserialization not implemented`, import_safe.ZWaveErrorCodes.Deserialization_NotImplemented);
+  }
+  _parameters;
+  get parameters() {
+    return this._parameters;
+  }
+  _resetToDefault;
+  get resetToDefault() {
+    return this._resetToDefault;
+  }
+  _valueSize;
+  get valueSize() {
+    return this._valueSize;
+  }
+  _valueFormat;
+  get valueFormat() {
+    return this._valueFormat;
+  }
+  _values;
+  get values() {
+    return this._values;
+  }
+  _handshake;
+  get handshake() {
+    return this._handshake;
+  }
+  serialize(ctx) {
+    const valueSize = this._resetToDefault ? 1 : this.valueSize;
+    const payloadLength = 4 + valueSize * this.parameters.length;
+    this.payload = import_safe2.Bytes.alloc(payloadLength, 0);
+    this.payload.writeUInt16BE(this.parameters[0], 0);
+    this.payload[2] = this.parameters.length;
+    this.payload[3] = (this._resetToDefault ? 128 : 0) | (this.handshake ? 64 : 0) | valueSize & 7;
+    if (!this._resetToDefault) {
+      for (let i = 0; i < this.parameters.length; i++) {
+        const value = this._values[i];
+        const param = this._parameters[i];
+        if (!isSafeValue(value, valueSize, this._valueFormat)) {
+          throwInvalidValueError(value, param, valueSize, this._valueFormat);
+        }
+        try {
+          serializeValue(this.payload, 4 + i * valueSize, valueSize, this._valueFormat, value);
+        } catch (e) {
+          tryCatchOutOfBoundsError(e, value, param, valueSize, this._valueFormat);
+        }
+      }
+    }
+    return super.serialize(ctx);
+  }
+  toLogEntry(ctx) {
+    const message = {
+      handshake: this.handshake,
+      "reset to default": this.resetToDefault,
+      "value size": this.valueSize
+    };
+    if (this._values.length > 0) {
+      message.values = this._values.map((value, i) => `
+\xB7 #${this._parameters[i]}: ${configValueToString(value)}`).join("");
+    }
+    return {
+      ...super.toLogEntry(ctx),
+      message
+    };
+  }
+};
+ConfigurationCCBulkSet = __decorate([
+  (0, import_CommandClassDecorators.CCCommand)(import_Types.ConfigurationCommand.BulkSet),
+  (0, import_CommandClassDecorators.expectedCCResponse)(getResponseForBulkSet),
+  (0, import_CommandClassDecorators.useSupervision)()
+], ConfigurationCCBulkSet);
+let ConfigurationCCBulkReport = ConfigurationCCBulkReport_1 = class ConfigurationCCBulkReport2 extends ConfigurationCC {
+  constructor(options) {
+    super(options);
+    this.reportsToFollow = options.reportsToFollow;
+    this.defaultValues = options.defaultValues;
+    this.isHandshakeResponse = options.isHandshakeResponse;
+    this.valueSize = options.valueSize;
+    for (const [param, value] of Object.entries(options.values)) {
+      this._values.set(parseInt(param), value);
+    }
+  }
+  static from(raw, ctx) {
+    (0, import_safe.validatePayload)(raw.payload.length >= 5);
+    const firstParameter = raw.payload.readUInt16BE(0);
+    const numParams = raw.payload[2];
+    const reportsToFollow = raw.payload[3];
+    const defaultValues = !!(raw.payload[4] & 128);
+    const isHandshakeResponse = !!(raw.payload[4] & 64);
+    const valueSize = raw.payload[4] & 7;
+    (0, import_safe.validatePayload)(raw.payload.length >= 5 + numParams * valueSize);
+    const values = {};
+    for (let i = 0; i < numParams; i++) {
+      const param = firstParameter + i;
+      values[param] = parseValue(raw.payload.subarray(5 + i * valueSize), valueSize, import_safe.ConfigValueFormat.SignedInteger);
+    }
+    return new ConfigurationCCBulkReport_1({
+      nodeId: ctx.sourceNodeId,
+      reportsToFollow,
+      defaultValues,
+      isHandshakeResponse,
+      valueSize,
+      values
+    });
+  }
+  persistValues(ctx) {
+    if (!super.persistValues(ctx))
+      return false;
+    for (let [parameter, value] of this._values.entries()) {
+      const oldParamInformation = this.getParamInformation(ctx, parameter);
+      if (oldParamInformation.format != void 0 && oldParamInformation.format !== import_safe.ConfigValueFormat.SignedInteger) {
+        value = reInterpretSignedValue(value, this.valueSize, oldParamInformation.format);
+        this._values.set(parameter, value);
+      }
+      this.setValue(ctx, ConfigurationCCValues.paramInformation(parameter), value);
+    }
+    return true;
+  }
+  reportsToFollow;
+  defaultValues;
+  isHandshakeResponse;
+  valueSize;
+  _values = /* @__PURE__ */ new Map();
+  get values() {
+    return this._values;
+  }
+  getPartialCCSessionId() {
+    return {};
+  }
+  expectMoreMessages() {
+    return this.reportsToFollow > 0;
+  }
+  toLogEntry(ctx) {
+    const message = {
+      "handshake response": this.isHandshakeResponse,
+      "default values": this.defaultValues,
+      "value size": this.valueSize,
+      "reports to follow": this.reportsToFollow
+    };
+    if (this._values.size > 0) {
+      message.values = [...this._values].map(([param, value]) => `
+\xB7 #${param}: ${configValueToString(value)}`).join("");
+    }
+    return {
+      ...super.toLogEntry(ctx),
+      message
+    };
+  }
+};
+ConfigurationCCBulkReport = ConfigurationCCBulkReport_1 = __decorate([
+  (0, import_CommandClassDecorators.CCCommand)(import_Types.ConfigurationCommand.BulkReport)
+], ConfigurationCCBulkReport);
+let ConfigurationCCBulkGet = class ConfigurationCCBulkGet2 extends ConfigurationCC {
+  constructor(options) {
+    super(options);
+    this._parameters = options.parameters.sort();
+    if (!(0, import_safe.isConsecutiveArray)(this.parameters)) {
+      throw new import_safe.ZWaveError(`A ConfigurationCC.BulkGet can only be used for consecutive parameters`, import_safe.ZWaveErrorCodes.CC_Invalid);
+    }
+  }
+  static from(_raw, _ctx) {
+    throw new import_safe.ZWaveError(`${this.name}: deserialization not implemented`, import_safe.ZWaveErrorCodes.Deserialization_NotImplemented);
+  }
+  _parameters;
+  get parameters() {
+    return this._parameters;
+  }
+  serialize(ctx) {
+    this.payload = new import_safe2.Bytes(3);
+    this.payload.writeUInt16BE(this.parameters[0], 0);
+    this.payload[2] = this.parameters.length;
+    return super.serialize(ctx);
+  }
+  toLogEntry(ctx) {
+    return {
+      ...super.toLogEntry(ctx),
+      message: { parameters: this.parameters.join(", ") }
+    };
+  }
+};
+ConfigurationCCBulkGet = __decorate([
+  (0, import_CommandClassDecorators.CCCommand)(import_Types.ConfigurationCommand.BulkGet),
+  (0, import_CommandClassDecorators.expectedCCResponse)(ConfigurationCCBulkReport)
+], ConfigurationCCBulkGet);
+let ConfigurationCCNameReport = ConfigurationCCNameReport_1 = class ConfigurationCCNameReport2 extends ConfigurationCC {
+  constructor(options) {
+    super(options);
+    this.parameter = options.parameter;
+    this.name = options.name;
+    this.reportsToFollow = options.reportsToFollow;
+  }
+  static from(raw, ctx) {
+    (0, import_safe.validatePayload)(raw.payload.length >= 3);
+    const parameter = raw.payload.readUInt16BE(0);
+    const reportsToFollow = raw.payload[2];
+    if (reportsToFollow > 0) {
+      (0, import_safe.validatePayload)(raw.payload.length >= 4);
+    }
+    const name = raw.payload.subarray(3).toString("utf8");
+    return new ConfigurationCCNameReport_1({
+      nodeId: ctx.sourceNodeId,
+      parameter,
+      reportsToFollow,
+      name
+    });
+  }
+  parameter;
+  name;
+  reportsToFollow;
+  persistValues(ctx) {
+    if (!super.persistValues(ctx))
+      return false;
+    const partialParams = this.getPartialParamInfos(ctx, this.parameter);
+    if (partialParams.length === 0) {
+      this.extendParamInformation(ctx, this.parameter, void 0, {
+        label: this.name
+      });
+    } else {
+      for (const param of partialParams) {
+        const paramNumber = param.property;
+        const bitMask = param.propertyKey;
+        const bitNumber = Math.log2(bitMask) % 1 === 0 ? Math.log2(bitMask) : void 0;
+        let label = `${this.name} - ${bitMask}`;
+        if (bitNumber != void 0) {
+          label += ` (bit ${bitNumber})`;
+        }
+        this.extendParamInformation(ctx, paramNumber, bitMask, {
+          label
+        });
+      }
+    }
+    return true;
+  }
+  serialize(ctx) {
+    const nameBuffer = import_safe2.Bytes.from(this.name, "utf8");
+    this.payload = new import_safe2.Bytes(3 + nameBuffer.length);
+    this.payload.writeUInt16BE(this.parameter, 0);
+    this.payload[2] = this.reportsToFollow;
+    this.payload.set(nameBuffer, 3);
+    return super.serialize(ctx);
+  }
+  getPartialCCSessionId() {
+    return { parameter: this.parameter };
+  }
+  expectMoreMessages() {
+    return this.reportsToFollow > 0;
+  }
+  mergePartialCCs(partials, _ctx) {
+    this.name = [...partials, this].map((report) => report.name).reduce((prev, cur) => prev + cur, "");
+  }
+  toLogEntry(ctx) {
+    return {
+      ...super.toLogEntry(ctx),
+      message: {
+        "parameter #": this.parameter,
+        name: this.name,
+        "reports to follow": this.reportsToFollow
+      }
+    };
+  }
+};
+ConfigurationCCNameReport = ConfigurationCCNameReport_1 = __decorate([
+  (0, import_CommandClassDecorators.CCCommand)(import_Types.ConfigurationCommand.NameReport)
+], ConfigurationCCNameReport);
+let ConfigurationCCNameGet = ConfigurationCCNameGet_1 = class ConfigurationCCNameGet2 extends ConfigurationCC {
+  constructor(options) {
+    super(options);
+    this.parameter = options.parameter;
+  }
+  static from(raw, ctx) {
+    (0, import_safe.validatePayload)(raw.payload.length >= 2);
+    const parameter = raw.payload.readUInt16BE(0);
+    return new ConfigurationCCNameGet_1({
+      nodeId: ctx.sourceNodeId,
+      parameter
+    });
+  }
+  parameter;
+  serialize(ctx) {
+    this.payload = new import_safe2.Bytes(2);
+    this.payload.writeUInt16BE(this.parameter, 0);
+    return super.serialize(ctx);
+  }
+  toLogEntry(ctx) {
+    return {
+      ...super.toLogEntry(ctx),
+      message: { "parameter #": this.parameter }
+    };
+  }
+};
+ConfigurationCCNameGet = ConfigurationCCNameGet_1 = __decorate([
+  (0, import_CommandClassDecorators.CCCommand)(import_Types.ConfigurationCommand.NameGet),
+  (0, import_CommandClassDecorators.expectedCCResponse)(ConfigurationCCNameReport)
+], ConfigurationCCNameGet);
+let ConfigurationCCInfoReport = ConfigurationCCInfoReport_1 = class ConfigurationCCInfoReport2 extends ConfigurationCC {
+  constructor(options) {
+    super(options);
+    this.parameter = options.parameter;
+    this.info = options.info;
+    this.reportsToFollow = options.reportsToFollow;
+  }
+  static from(raw, ctx) {
+    (0, import_safe.validatePayload)(raw.payload.length >= 3);
+    const parameter = raw.payload.readUInt16BE(0);
+    const reportsToFollow = raw.payload[2];
+    if (reportsToFollow > 0) {
+      (0, import_safe.validatePayload)(raw.payload.length >= 4);
+    }
+    const info = raw.payload.subarray(3).toString("utf8");
+    return new ConfigurationCCInfoReport_1({
+      nodeId: ctx.sourceNodeId,
+      parameter,
+      reportsToFollow,
+      info
+    });
+  }
+  parameter;
+  info;
+  reportsToFollow;
+  persistValues(ctx) {
+    if (!super.persistValues(ctx))
+      return false;
+    const partialParams = this.getPartialParamInfos(ctx, this.parameter).sort((a, b) => (a.propertyKey ?? 0) - (b.propertyKey ?? 0));
+    if (partialParams.length === 0) {
+      this.extendParamInformation(ctx, this.parameter, void 0, {
+        description: this.info
+      });
+    } else {
+      let firstParamLabel;
+      for (const param of partialParams) {
+        const paramNumber = param.property;
+        const bitMask = param.propertyKey;
+        const description = firstParamLabel ? `Refer to ${firstParamLabel}` : this.info;
+        this.extendParamInformation(ctx, paramNumber, bitMask, {
+          description
+        });
+        if (firstParamLabel == void 0) {
+          firstParamLabel = this.getParamInformation(ctx, paramNumber, bitMask).label ?? `parameter ${paramNumber} - ${bitMask}`;
+        }
+      }
+    }
+    return true;
+  }
+  serialize(ctx) {
+    const infoBuffer = import_safe2.Bytes.from(this.info, "utf8");
+    this.payload = new import_safe2.Bytes(3 + infoBuffer.length);
+    this.payload.writeUInt16BE(this.parameter, 0);
+    this.payload[2] = this.reportsToFollow;
+    this.payload.set(infoBuffer, 3);
+    return super.serialize(ctx);
+  }
+  getPartialCCSessionId() {
+    return { parameter: this.parameter };
+  }
+  expectMoreMessages() {
+    return this.reportsToFollow > 0;
+  }
+  mergePartialCCs(partials, _ctx) {
+    this.info = [...partials, this].map((report) => report.info).reduce((prev, cur) => prev + cur, "");
+  }
+  toLogEntry(ctx) {
+    return {
+      ...super.toLogEntry(ctx),
+      message: {
+        "parameter #": this.parameter,
+        info: this.info,
+        "reports to follow": this.reportsToFollow
+      }
+    };
+  }
+};
+ConfigurationCCInfoReport = ConfigurationCCInfoReport_1 = __decorate([
+  (0, import_CommandClassDecorators.CCCommand)(import_Types.ConfigurationCommand.InfoReport)
+], ConfigurationCCInfoReport);
+let ConfigurationCCInfoGet = ConfigurationCCInfoGet_1 = class ConfigurationCCInfoGet2 extends ConfigurationCC {
+  constructor(options) {
+    super(options);
+    this.parameter = options.parameter;
+  }
+  static from(raw, ctx) {
+    (0, import_safe.validatePayload)(raw.payload.length >= 2);
+    const parameter = raw.payload.readUInt16BE(0);
+    return new ConfigurationCCInfoGet_1({
+      nodeId: ctx.sourceNodeId,
+      parameter
+    });
+  }
+  parameter;
+  serialize(ctx) {
+    this.payload = new import_safe2.Bytes(2);
+    this.payload.writeUInt16BE(this.parameter, 0);
+    return super.serialize(ctx);
+  }
+  toLogEntry(ctx) {
+    return {
+      ...super.toLogEntry(ctx),
+      message: { "parameter #": this.parameter }
+    };
+  }
+};
+ConfigurationCCInfoGet = ConfigurationCCInfoGet_1 = __decorate([
+  (0, import_CommandClassDecorators.CCCommand)(import_Types.ConfigurationCommand.InfoGet),
+  (0, import_CommandClassDecorators.expectedCCResponse)(ConfigurationCCInfoReport)
+], ConfigurationCCInfoGet);
+let ConfigurationCCPropertiesReport = ConfigurationCCPropertiesReport_1 = class ConfigurationCCPropertiesReport2 extends ConfigurationCC {
+  constructor(options) {
+    super(options);
+    this.parameter = options.parameter;
+    this.valueSize = options.valueSize;
+    this.valueFormat = options.valueFormat;
+    if (this.valueSize > 0) {
+      if (options.minValue == void 0) {
+        throw new import_safe.ZWaveError("The minimum value must be set when the value size is non-zero", import_safe.ZWaveErrorCodes.Argument_Invalid);
+      } else if (options.maxValue == void 0) {
+        throw new import_safe.ZWaveError("The maximum value must be set when the value size is non-zero", import_safe.ZWaveErrorCodes.Argument_Invalid);
+      } else if (options.defaultValue == void 0) {
+        throw new import_safe.ZWaveError("The default value must be set when the value size is non-zero", import_safe.ZWaveErrorCodes.Argument_Invalid);
+      }
+      this.minValue = options.minValue;
+      this.maxValue = options.maxValue;
+      this.defaultValue = options.defaultValue;
+    }
+    this.nextParameter = options.nextParameter;
+    this.altersCapabilities = options.altersCapabilities;
+    this.isReadonly = options.isReadonly;
+    this.isAdvanced = options.isAdvanced;
+    this.noBulkSupport = options.noBulkSupport;
+  }
+  static from(raw, ctx) {
+    (0, import_safe.validatePayload)(raw.payload.length >= 3);
+    const parameter = raw.payload.readUInt16BE(0);
+    const valueFormat = (raw.payload[2] & 56) >>> 3;
+    const valueSize = raw.payload[2] & 7;
+    let nextParameter;
+    if (valueSize === 0 && raw.payload.length < 5) {
+      nextParameter = 0;
+      return new ConfigurationCCPropertiesReport_1({
+        nodeId: ctx.sourceNodeId,
+        parameter,
+        valueFormat,
+        valueSize,
+        nextParameter
+      });
+    }
+    const nextParameterOffset = 3 + 3 * valueSize;
+    (0, import_safe.validatePayload)(raw.payload.length >= nextParameterOffset + 2);
+    let minValue;
+    let maxValue;
+    let defaultValue;
+    if (valueSize > 0) {
+      if (valueFormat === import_safe.ConfigValueFormat.BitField) {
+        minValue = 0;
+      } else {
+        minValue = parseValue(raw.payload.subarray(3), valueSize, valueFormat);
+      }
+      maxValue = parseValue(raw.payload.subarray(3 + valueSize), valueSize, valueFormat);
+      defaultValue = parseValue(raw.payload.subarray(3 + 2 * valueSize), valueSize, valueFormat);
+    }
+    nextParameter = raw.payload.readUInt16BE(nextParameterOffset);
+    let altersCapabilities;
+    let isReadonly;
+    let isAdvanced;
+    let noBulkSupport;
+    if (raw.payload.length >= nextParameterOffset + 3) {
+      const options1 = raw.payload[2];
+      const options2 = raw.payload[3 + 3 * valueSize + 2];
+      altersCapabilities = !!(options1 & 128);
+      isReadonly = !!(options1 & 64);
+      isAdvanced = !!(options2 & 1);
+      noBulkSupport = !!(options2 & 2);
+    }
+    return new ConfigurationCCPropertiesReport_1({
+      nodeId: ctx.sourceNodeId,
+      parameter,
+      valueFormat,
+      valueSize,
+      nextParameter,
+      minValue,
+      maxValue,
+      defaultValue,
+      altersCapabilities,
+      isReadonly,
+      isAdvanced,
+      noBulkSupport
+    });
+  }
+  persistValues(ctx) {
+    if (!super.persistValues(ctx))
+      return false;
+    if (this.valueSize > 0) {
+      const baseInfo = {
+        type: "number",
+        format: this.valueFormat,
+        valueSize: this.valueSize,
+        requiresReInclusion: this.altersCapabilities,
+        readable: true,
+        writeable: !this.isReadonly,
+        allowManualEntry: true,
+        isAdvanced: this.isAdvanced,
+        noBulkSupport: this.noBulkSupport,
+        isFromConfig: false
+      };
+      if (this.valueFormat !== import_safe.ConfigValueFormat.BitField) {
+        if (!this.paramExistsInConfigFile(ctx, this.parameter)) {
+          const paramInfo = (0, import_safe.stripUndefined)({
+            ...baseInfo,
+            min: this.minValue,
+            max: this.maxValue,
+            default: this.defaultValue
+          });
+          this.extendParamInformation(ctx, this.parameter, void 0, paramInfo);
+        }
+      } else {
+        const bits = this.maxValue;
+        let mask = 1;
+        while (mask <= bits) {
+          if (
+            // Only create partials that exist
+            !!(mask & bits) && !this.paramExistsInConfigFile(ctx, this.parameter, mask)
+          ) {
+            const paramInfo = (0, import_safe.stripUndefined)({
+              ...baseInfo,
+              min: 0,
+              max: 1,
+              default: this.defaultValue & mask ? 1 : 0
+            });
+            this.extendParamInformation(ctx, this.parameter, mask, paramInfo);
+          }
+          mask *= 2;
+        }
+      }
+    }
+    return true;
+  }
+  parameter;
+  valueSize;
+  valueFormat;
+  minValue;
+  maxValue;
+  defaultValue;
+  nextParameter;
+  altersCapabilities;
+  isReadonly;
+  isAdvanced;
+  noBulkSupport;
+  serialize(ctx) {
+    this.payload = new import_safe2.Bytes(3 + 3 * this.valueSize + 2 + 1);
+    this.payload.writeUInt16BE(this.parameter, 0);
+    const options1 = (this.altersCapabilities ? 128 : 0) | (this.isReadonly ? 64 : 0) | (this.valueFormat & 7) << 3 | this.valueSize & 7;
+    this.payload[2] = options1;
+    let offset = 3;
+    if (this.valueSize > 0) {
+      serializeValue(this.payload, offset, this.valueSize, this.valueFormat, this.minValue);
+      offset += this.valueSize;
+      serializeValue(this.payload, offset, this.valueSize, this.valueFormat, this.maxValue);
+      offset += this.valueSize;
+      serializeValue(this.payload, offset, this.valueSize, this.valueFormat, this.defaultValue);
+      offset += this.valueSize;
+    }
+    this.payload.writeUInt16BE(this.nextParameter, offset);
+    offset += 2;
+    const options2 = (this.isAdvanced ? 1 : 0) | (this.noBulkSupport ? 2 : 0);
+    this.payload[offset] = options2;
+    return super.serialize(ctx);
+  }
+  toLogEntry(ctx) {
+    const message = {
+      "parameter #": this.parameter,
+      "next param #": this.nextParameter,
+      "value size": this.valueSize,
+      "value format": (0, import_safe3.getEnumMemberName)(import_safe.ConfigValueFormat, this.valueFormat)
+    };
+    if (this.minValue != void 0) {
+      message["min value"] = configValueToString(this.minValue);
+    }
+    if (this.maxValue != void 0) {
+      message["max value"] = configValueToString(this.maxValue);
+    }
+    if (this.defaultValue != void 0) {
+      message["default value"] = configValueToString(this.defaultValue);
+    }
+    if (this.altersCapabilities != void 0) {
+      message["alters capabilities"] = this.altersCapabilities;
+    }
+    if (this.isReadonly != void 0) {
+      message.readonly = this.isReadonly;
+    }
+    if (this.isAdvanced != void 0) {
+      message.advanced = this.isAdvanced;
+    }
+    if (this.noBulkSupport != void 0) {
+      message["bulk support"] = !this.noBulkSupport;
+    }
+    return {
+      ...super.toLogEntry(ctx),
+      message
+    };
+  }
+};
+ConfigurationCCPropertiesReport = ConfigurationCCPropertiesReport_1 = __decorate([
+  (0, import_CommandClassDecorators.CCCommand)(import_Types.ConfigurationCommand.PropertiesReport)
+], ConfigurationCCPropertiesReport);
+let ConfigurationCCPropertiesGet = ConfigurationCCPropertiesGet_1 = class ConfigurationCCPropertiesGet2 extends ConfigurationCC {
+  constructor(options) {
+    super(options);
+    this.parameter = options.parameter;
+  }
+  static from(raw, ctx) {
+    (0, import_safe.validatePayload)(raw.payload.length >= 2);
+    const parameter = raw.payload.readUInt16BE(0);
+    return new ConfigurationCCPropertiesGet_1({
+      nodeId: ctx.sourceNodeId,
+      parameter
+    });
+  }
+  parameter;
+  serialize(ctx) {
+    this.payload = new import_safe2.Bytes(2);
+    this.payload.writeUInt16BE(this.parameter, 0);
+    return super.serialize(ctx);
+  }
+  toLogEntry(ctx) {
+    return {
+      ...super.toLogEntry(ctx),
+      message: { "parameter #": this.parameter }
+    };
+  }
+};
+ConfigurationCCPropertiesGet = ConfigurationCCPropertiesGet_1 = __decorate([
+  (0, import_CommandClassDecorators.CCCommand)(import_Types.ConfigurationCommand.PropertiesGet),
+  (0, import_CommandClassDecorators.expectedCCResponse)(ConfigurationCCPropertiesReport)
+], ConfigurationCCPropertiesGet);
+let ConfigurationCCDefaultReset = class ConfigurationCCDefaultReset2 extends ConfigurationCC {
+};
+ConfigurationCCDefaultReset = __decorate([
+  (0, import_CommandClassDecorators.CCCommand)(import_Types.ConfigurationCommand.DefaultReset)
+], ConfigurationCCDefaultReset);
+function isSafeValue(value, size, format) {
+  let minValue;
+  let maxValue;
+  switch (format) {
+    case import_safe.ConfigValueFormat.SignedInteger:
+      minValue = -Math.pow(2, 8 * size - 1);
+      maxValue = Math.pow(2, 8 * size - 1) - 1;
+      break;
+    case import_safe.ConfigValueFormat.UnsignedInteger:
+    case import_safe.ConfigValueFormat.Enumerated:
+    case import_safe.ConfigValueFormat.BitField:
+      minValue = 0;
+      maxValue = Math.pow(2, 8 * size);
+      break;
+    default:
+      throw new Error("not implemented");
+  }
+  return minValue <= value && value <= maxValue;
+}
+function parseValue(raw, size, format) {
+  switch (format) {
+    case import_safe.ConfigValueFormat.SignedInteger:
+      return raw.readIntBE(0, size);
+    case import_safe.ConfigValueFormat.UnsignedInteger:
+    case import_safe.ConfigValueFormat.Enumerated:
+    case import_safe.ConfigValueFormat.BitField:
+      return raw.readUIntBE(0, size);
+  }
+}
+function throwInvalidValueError(value, parameter, valueSize, valueFormat) {
+  throw new import_safe.ZWaveError(`The value ${value} is invalid for configuration parameter ${parameter} (size = ${valueSize}, format = ${(0, import_safe3.getEnumMemberName)(import_safe.ConfigValueFormat, valueFormat)})!`, import_safe.ZWaveErrorCodes.Argument_Invalid);
+}
+function tryCatchOutOfBoundsError(e, value, parameter, valueSize, valueFormat) {
+  if (e.message.includes("out of bounds")) {
+    throwInvalidValueError(value, parameter, valueSize, valueFormat);
+  } else {
+    throw e;
+  }
+}
+function serializeValue(payload, offset, size, format, value) {
+  switch (format) {
+    case import_safe.ConfigValueFormat.SignedInteger:
+      payload.writeIntBE(value, offset, size);
+      return;
+    case import_safe.ConfigValueFormat.UnsignedInteger:
+    case import_safe.ConfigValueFormat.Enumerated:
+    case import_safe.ConfigValueFormat.BitField:
+      payload.writeUIntBE(value, offset, size);
+      return;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ConfigurationCC,
+  ConfigurationCCAPI,
+  ConfigurationCCBulkGet,
+  ConfigurationCCBulkReport,
+  ConfigurationCCBulkSet,
+  ConfigurationCCDefaultReset,
+  ConfigurationCCError,
+  ConfigurationCCGet,
+  ConfigurationCCInfoGet,
+  ConfigurationCCInfoReport,
+  ConfigurationCCNameGet,
+  ConfigurationCCNameReport,
+  ConfigurationCCPropertiesGet,
+  ConfigurationCCPropertiesReport,
+  ConfigurationCCReport,
+  ConfigurationCCSet,
+  ConfigurationCCValues
+});
+//# sourceMappingURL=ConfigurationCC.js.map