@zwave-js/cc 15.1.0 → 15.1.2

package/build/cjs/cc/ConfigurationCC.js

@@ -49,9 +49,8 @@ __export(ConfigurationCC_exports, {
 });
 module.exports = __toCommonJS(ConfigurationCC_exports);
 var __validateArgs = __toESM(require("./ConfigurationCC._validateArgs.js"), 1);
-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_core = require("@zwave-js/core");
+var import_shared = require("@zwave-js/shared");
 var import_arrays = require("alcalzone-shared/arrays");
 var import_API = require("../lib/API.js");
 var import_CommandClass = require("../lib/CommandClass.js");
@@ -107,7 +106,7 @@ function configValueToString(value) {
     return [...value].join(", ");
 }
 __name(configValueToString, "configValueToString");
-class ConfigurationCCError extends import_safe.ZWaveError {
+class ConfigurationCCError extends import_core.ZWaveError {
   static {
     __name(this, "ConfigurationCCError");
   }
@@ -131,7 +130,7 @@ function normalizeConfigurationCCAPISetOptions(ctx, endpoint, options) {
     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);
+      throw new import_core.ZWaveError("Setting a partial configuration parameter requires it to be defined in a device config file!", import_core.ZWaveErrorCodes.Argument_Invalid);
     }
     return {
       parameter: options.parameter,
@@ -141,7 +140,7 @@ function normalizeConfigurationCCAPISetOptions(ctx, endpoint, options) {
       valueFormat: paramInfo.format
     };
   } else if ("valueSize" in options) {
-    return (0, import_safe3.pick)(options, [
+    return (0, import_shared.pick)(options, [
       "parameter",
       "value",
       "valueSize",
@@ -151,7 +150,7 @@ function normalizeConfigurationCCAPISetOptions(ctx, endpoint, options) {
     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);
+      throw new import_core.ZWaveError("Setting a configuration parameter without specifying a value size and format requires it to be defined in a device config file!", import_core.ZWaveErrorCodes.Argument_Invalid);
     }
     return {
       parameter: options.parameter,
@@ -189,12 +188,12 @@ function bulkMergePartialParamValues(ctx, endpoint, options) {
 }
 __name(bulkMergePartialParamValues, "bulkMergePartialParamValues");
 function isSignedPartial(bitMask, format) {
-  return (0, import_safe.getBitMaskWidth)(bitMask) > 1 && (format ?? import_safe.ConfigValueFormat.SignedInteger) === import_safe.ConfigValueFormat.SignedInteger;
+  return (0, import_core.getBitMaskWidth)(bitMask) > 1 && (format ?? import_core.ConfigValueFormat.SignedInteger) === import_core.ConfigValueFormat.SignedInteger;
 }
 __name(isSignedPartial, "isSignedPartial");
 function reInterpretSignedValue(value, valueSize, targetFormat) {
-  const raw = new import_safe2.Bytes(valueSize);
-  serializeValue(raw, 0, valueSize, import_safe.ConfigValueFormat.SignedInteger, value);
+  const raw = new import_shared.Bytes(valueSize);
+  serializeValue(raw, 0, valueSize, import_core.ConfigValueFormat.SignedInteger, value);
   return parseValue(raw, valueSize, targetFormat);
 }
 __name(reInterpretSignedValue, "reInterpretSignedValue");
@@ -208,7 +207,7 @@ function getParamInformationFromConfigFile(ctx, nodeId, endpointIndex) {
 }
 __name(getParamInformationFromConfigFile, "getParamInformationFromConfigFile");
 let ConfigurationCCAPI = (() => {
-  let _classDecorators = [(0, import_CommandClassDecorators.API)(import_safe.CommandClasses.Configuration)];
+  let _classDecorators = [(0, import_CommandClassDecorators.API)(import_core.CommandClasses.Configuration)];
   let _classDescriptor;
   let _classExtraInitializers = [];
   let _classThis;
@@ -290,8 +289,8 @@ let ConfigurationCCAPI = (() => {
           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);
+          if (!nodes.every((node) => node.getEndpoint(this.endpoint.index)?.supportsCC(import_core.CommandClasses.Configuration))) {
+            throw new import_core.ZWaveError(`The multicast setValue API for Configuration CC requires all virtual target endpoints to support Configuration CC!`, import_core.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) => {
@@ -299,27 +298,27 @@ let ConfigurationCCAPI = (() => {
               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);
+            throw new import_core.ZWaveError(`The multicast setValue API for Configuration CC requires all virtual target nodes to have the same parameter definition!`, import_core.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);
+          throw new import_core.ZWaveError(`The setValue API for Configuration CC is not supported via broadcast!`, import_core.ZWaveErrorCodes.CC_NotSupported);
         }
-        let { valueSize, format: valueFormat = import_safe.ConfigValueFormat.SignedInteger } = ccInstance.getParamInformation(applHost, property);
+        let { valueSize, format: valueFormat = import_core.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;
+          valueFormat = import_core.ConfigValueFormat.UnsignedInteger;
         } else {
           targetValue = value;
         }
         if (!valueSize) {
-          valueSize = (0, import_safe.getMinIntegerSize)(targetValue, valueFormat === import_safe.ConfigValueFormat.SignedInteger);
+          valueSize = (0, import_core.getMinIntegerSize)(targetValue, valueFormat === import_core.ConfigValueFormat.SignedInteger);
           if (!valueSize) {
-            throw new import_safe.ZWaveError(`The value ${targetValue} is not valid for configuration parameters!`, import_safe.ZWaveErrorCodes.Argument_Invalid);
+            throw new import_core.ZWaveError(`The value ${targetValue} is not valid for configuration parameters!`, import_core.ZWaveErrorCodes.Argument_Invalid);
           }
         }
         if (!isSafeValue(targetValue, valueSize, valueFormat)) {
@@ -331,7 +330,7 @@ let ConfigurationCCAPI = (() => {
           valueSize,
           valueFormat
         });
-        if (!(0, import_safe.supervisedCommandSucceeded)(result) && this.isSinglecast()) {
+        if (!(0, import_core.supervisedCommandSucceeded)(result) && this.isSinglecast()) {
           this.schedulePoll(
             { property, propertyKey },
             targetValue,
@@ -385,7 +384,7 @@ let ConfigurationCCAPI = (() => {
         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));
+        return (0, import_core.parsePartial)(response.value, valueBitMask, isSignedPartial(valueBitMask, paramInfo.format));
       }
       this.host.logNode(this.endpoint.nodeId, {
         endpoint: this.endpoint.index,
@@ -393,7 +392,7 @@ let ConfigurationCCAPI = (() => {
         direction: "inbound",
         level: "error"
       });
-      throw new ConfigurationCCError(`The first existing parameter on this node is ${response.parameter}`, import_safe.ZWaveErrorCodes.ConfigurationCC_FirstParameterNumber, response.parameter);
+      throw new ConfigurationCCError(`The first existing parameter on this node is ${response.parameter}`, import_core.ZWaveErrorCodes.ConfigurationCC_FirstParameterNumber, response.parameter);
     }
     /**
      * Requests the current value of the config parameters from the device.
@@ -403,7 +402,7 @@ let ConfigurationCCAPI = (() => {
       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)) {
+      if (this.supportsCommand(import_Types.ConfigurationCommand.BulkGet) && (0, import_core.isConsecutiveArray)(distinctParameters)) {
         const cc2 = new ConfigurationCCBulkGet({
           nodeId: this.endpoint.nodeId,
           endpointIndex: this.endpoint.index,
@@ -433,7 +432,7 @@ let ConfigurationCCAPI = (() => {
         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));
+          value = (0, import_core.parsePartial)(value, o.bitMask, isSignedPartial(o.bitMask, paramInfo.format));
         }
         return { ...o, value };
       });
@@ -469,7 +468,7 @@ let ConfigurationCCAPI = (() => {
     async setBulk(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;
+      const canUseBulkSet = this.supportsCommand(import_Types.ConfigurationCommand.BulkSet) && (0, import_core.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,
@@ -486,7 +485,7 @@ let ConfigurationCCAPI = (() => {
           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
+            status: success ? import_core.SupervisionStatus.Success : import_core.SupervisionStatus.Fail
           };
         } else {
           return void 0;
@@ -505,7 +504,7 @@ let ConfigurationCCAPI = (() => {
           });
           supervisionResults.push(await this.host.sendCommand(cc, this.commandOptions));
         }
-        return (0, import_safe.mergeSupervisionResults)(supervisionResults);
+        return (0, import_core.mergeSupervisionResults)(supervisionResults);
       }
     }
     /**
@@ -518,7 +517,7 @@ let ConfigurationCCAPI = (() => {
         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);
+        throw new import_core.ZWaveError(`Resetting configuration parameters to default MUST not be done on nodes implementing ConfigurationCC V3 or below!`, import_core.ZWaveErrorCodes.ConfigurationCC_NoResetToDefaultOnLegacyDevices);
       }
       this.assertSupportsCommand(import_Types.ConfigurationCommand, import_Types.ConfigurationCommand.Set);
       const cc = new ConfigurationCCSet({
@@ -535,7 +534,7 @@ let ConfigurationCCAPI = (() => {
      * WARNING: This will throw on legacy devices (ConfigurationCC v3 and below)
      */
     async resetBulk(parameters) {
-      if ((0, import_safe.isConsecutiveArray)(parameters) && this.supportsCommand(import_Types.ConfigurationCommand.BulkSet)) {
+      if ((0, import_core.isConsecutiveArray)(parameters) && this.supportsCommand(import_Types.ConfigurationCommand.BulkSet)) {
         const cc = new ConfigurationCCBulkSet({
           nodeId: this.endpoint.nodeId,
           endpointIndex: this.endpoint.index,
@@ -575,7 +574,7 @@ let ConfigurationCCAPI = (() => {
       });
       const response = await this.host.sendCommand(cc, this.commandOptions);
       if (response) {
-        return (0, import_safe3.pick)(response, [
+        return (0, import_shared.pick)(response, [
           "valueSize",
           "valueFormat",
           "minValue",
@@ -624,7 +623,7 @@ let ConfigurationCCAPI = (() => {
      */
     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);
+        throw new import_core.ZWaveError("Use ConfigurationCC.interview instead of scanning parameters for versions 3 and above.", import_core.ZWaveErrorCodes.ConfigurationCC_NoLegacyScanOnNewDevices);
       }
       this.assertPhysicalEndpoint(this.endpoint);
       this.host.logNode(this.endpoint.nodeId, {
@@ -658,7 +657,7 @@ let ConfigurationCCAPI = (() => {
             });
           }
         } catch (e) {
-          if (e instanceof ConfigurationCCError && e.code === import_safe.ZWaveErrorCodes.ConfigurationCC_FirstParameterNumber) {
+          if (e instanceof ConfigurationCCError && e.code === import_core.ZWaveErrorCodes.ConfigurationCC_FirstParameterNumber) {
             if (e.argument - 1 > param)
               param = e.argument - 1;
             continue;
@@ -675,7 +674,7 @@ let ConfigurationCCAPI = (() => {
   return ConfigurationCCAPI2 = _classThis;
 })();
 let ConfigurationCC = (() => {
-  let _classDecorators = [(0, import_CommandClassDecorators.commandClass)(import_safe.CommandClasses.Configuration), (0, import_CommandClassDecorators.implementedVersion)(4), (0, import_CommandClassDecorators.ccValues)(import_CCValues_generated.ConfigurationCCValues)];
+  let _classDecorators = [(0, import_CommandClassDecorators.commandClass)(import_core.CommandClasses.Configuration), (0, import_CommandClassDecorators.implementedVersion)(4), (0, import_CommandClassDecorators.ccValues)(import_CCValues_generated.ConfigurationCCValues)];
   let _classDescriptor;
   let _classExtraInitializers = [];
   let _classThis;
@@ -697,8 +696,8 @@ let ConfigurationCC = (() => {
     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
+      const api = import_API.CCAPI.create(import_core.CommandClasses.Configuration, ctx, endpoint).withOptions({
+        priority: import_core.MessagePriority.NodeQuery
       });
       ctx.logNode(node.id, {
         endpoint: this.endpointIndex,
@@ -786,7 +785,7 @@ let ConfigurationCC = (() => {
 parameter name:      ${name}`;
             }
             logMessage += `
-value format:        ${(0, import_safe3.getEnumMemberName)(import_safe.ConfigValueFormat, properties.valueFormat)}
+value format:        ${(0, import_shared.getEnumMemberName)(import_core.ConfigValueFormat, properties.valueFormat)}
 value size:          ${properties.valueSize} bytes
 min value:           ${properties.minValue?.toString() ?? "undefined"}
 max value:           ${properties.maxValue?.toString() ?? "undefined"}
@@ -814,8 +813,8 @@ alters capabilities: ${!!properties.altersCapabilities}`;
     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
+      const api = import_API.CCAPI.create(import_core.CommandClasses.Configuration, ctx, endpoint).withOptions({
+        priority: import_core.MessagePriority.NodeQuery
       });
       if (api.version < 3) {
         const paramInfo = getParamInformationFromConfigFile(ctx, node.id, this.endpointIndex);
@@ -914,7 +913,7 @@ alters capabilities: ${!!properties.altersCapabilities}`;
      */
     getParamInformation(ctx, parameter, valueBitMask) {
       return this.getMetadata(ctx, import_CCValues_generated.ConfigurationCCValues.paramInformation(parameter, valueBitMask)) ?? {
-        ...import_safe.ValueMetadata.Any
+        ...import_core.ValueMetadata.Any
       };
     }
     /**
@@ -951,10 +950,10 @@ alters capabilities: ${!!properties.altersCapabilities}`;
       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);
+        ret = (0, import_core.encodePartial)(ret, partialValue, bitMask);
       }
       for (const { bitMask, partialValue } of partials) {
-        ret = (0, import_safe.encodePartial)(ret, partialValue, bitMask);
+        ret = (0, import_core.encodePartial)(ret, partialValue, bitMask);
       }
       return ret;
     }
@@ -973,7 +972,7 @@ alters capabilities: ${!!properties.altersCapabilities}`;
       }
       this.setValue(ctx, import_CCValues_generated.ConfigurationCCValues.isParamInformationFromConfig, false);
       for (const [param, info] of config.entries()) {
-        const paramInfo = (0, import_safe.stripUndefined)({
+        const paramInfo = (0, import_core.stripUndefined)({
           // TODO: Make this smarter! (0...1 ==> boolean)
           type: "number",
           valueSize: info.valueSize,
@@ -981,7 +980,7 @@ alters capabilities: ${!!properties.altersCapabilities}`;
           max: info.maxValue,
           default: info.defaultValue,
           unit: info.unit,
-          format: info.unsigned ? import_safe.ConfigValueFormat.UnsignedInteger : import_safe.ConfigValueFormat.SignedInteger,
+          format: info.unsigned ? import_core.ConfigValueFormat.UnsignedInteger : import_core.ConfigValueFormat.SignedInteger,
           readable: !info.writeOnly,
           writeable: !info.readOnly,
           allowManualEntry: info.allowManualEntry,
@@ -1047,11 +1046,11 @@ let ConfigurationCCReport = (() => {
       this.valueFormat = options.valueFormat;
     }
     static from(raw, ctx) {
-      (0, import_safe.validatePayload)(raw.payload.length > 2);
+      (0, import_core.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);
+      (0, import_core.validatePayload)(valueSize >= 1, valueSize <= 4, raw.payload.length >= 2 + valueSize);
+      const value = parseValue(raw.payload.subarray(2), valueSize, import_core.ConfigValueFormat.SignedInteger);
       return new this({
         nodeId: ctx.sourceNodeId,
         parameter,
@@ -1079,17 +1078,17 @@ let ConfigurationCCReport = (() => {
           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));
+          const isSigned = oldParamInformation.format == void 0 || oldParamInformation.format === import_core.ConfigValueFormat.SignedInteger;
+          this.extendParamInformation(ctx, this.parameter, void 0, (0, import_core.getIntegerLimits)(this.valueSize, isSigned));
         }
       }
-      if (cachedValueFormat != void 0 && cachedValueFormat !== import_safe.ConfigValueFormat.SignedInteger) {
+      if (cachedValueFormat != void 0 && cachedValueFormat !== import_core.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, import_CCValues_generated.ConfigurationCCValues.paramInformation(this.parameter, param.propertyKey), (0, import_safe.parsePartial)(this.value, param.propertyKey, isSignedPartial(param.propertyKey, param.metadata.format)));
+            this.setValue(ctx, import_CCValues_generated.ConfigurationCCValues.paramInformation(this.parameter, param.propertyKey), (0, import_core.parsePartial)(this.value, param.propertyKey, isSignedPartial(param.propertyKey, param.metadata.format)));
           }
         }
       } else {
@@ -1098,11 +1097,11 @@ let ConfigurationCCReport = (() => {
       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)
+      this.payload = import_shared.Bytes.concat([
+        import_shared.Bytes.from([this.parameter, this.valueSize & 7]),
+        new import_shared.Bytes(this.valueSize)
       ]);
-      serializeValue(this.payload, 2, this.valueSize, this.valueFormat ?? import_safe.ConfigValueFormat.SignedInteger, this.value);
+      serializeValue(this.payload, 2, this.valueSize, this.valueFormat ?? import_core.ConfigValueFormat.SignedInteger, this.value);
       return super.serialize(ctx);
     }
     toLogEntry(ctx) {
@@ -1148,7 +1147,7 @@ let ConfigurationCCGet = (() => {
       this.allowUnexpectedResponse = options.allowUnexpectedResponse ?? false;
     }
     static from(raw, ctx) {
-      (0, import_safe.validatePayload)(raw.payload.length >= 1);
+      (0, import_core.validatePayload)(raw.payload.length >= 1);
       const parameter = raw.payload[0];
       return new this({
         nodeId: ctx.sourceNodeId,
@@ -1158,7 +1157,7 @@ let ConfigurationCCGet = (() => {
     parameter;
     allowUnexpectedResponse;
     serialize(ctx) {
-      this.payload = import_safe2.Bytes.from([this.parameter]);
+      this.payload = import_shared.Bytes.from([this.parameter]);
       return super.serialize(ctx);
     }
     toLogEntry(ctx) {
@@ -1196,17 +1195,17 @@ let ConfigurationCCSet = (() => {
       this.resetToDefault = !!options.resetToDefault;
       if (!options.resetToDefault) {
         this.valueSize = options.valueSize;
-        this.valueFormat = options.valueFormat ?? import_safe.ConfigValueFormat.SignedInteger;
+        this.valueFormat = options.valueFormat ?? import_core.ConfigValueFormat.SignedInteger;
         this.value = options.value;
       }
     }
     static from(raw, ctx) {
-      (0, import_safe.validatePayload)(raw.payload.length >= 2);
+      (0, import_core.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);
+      (0, import_core.validatePayload)(valueSize >= 1, valueSize <= 4, raw.payload.length >= 2 + valueSize);
+      const value = parseValue(raw.payload.subarray(2), valueSize, import_core.ConfigValueFormat.SignedInteger);
       return new this({
         nodeId: ctx.sourceNodeId,
         parameter,
@@ -1223,7 +1222,7 @@ let ConfigurationCCSet = (() => {
     serialize(ctx) {
       const valueSize = this.resetToDefault ? 1 : this.valueSize;
       const payloadLength = 2 + valueSize;
-      this.payload = import_safe2.Bytes.alloc(payloadLength, 0);
+      this.payload = import_shared.Bytes.alloc(payloadLength, 0);
       this.payload[0] = this.parameter;
       this.payload[1] = (this.resetToDefault ? 128 : 0) | valueSize & 7;
       if (!this.resetToDefault) {
@@ -1247,7 +1246,7 @@ let ConfigurationCCSet = (() => {
         message["value size"] = this.valueSize;
       }
       if (this.valueFormat != void 0) {
-        message["value format"] = (0, import_safe3.getEnumMemberName)(import_safe.ConfigValueFormat, this.valueFormat);
+        message["value format"] = (0, import_shared.getEnumMemberName)(import_core.ConfigValueFormat, this.valueFormat);
       }
       if (this.value != void 0) {
         message.value = configValueToString(this.value);
@@ -1288,24 +1287,24 @@ let ConfigurationCCBulkSet = (() => {
       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);
+        throw new import_core.ZWaveError(`In a ConfigurationCC.BulkSet, parameters must be a non-empty array`, import_core.ZWaveErrorCodes.CC_Invalid);
+      } else if (!(0, import_core.isConsecutiveArray)(this._parameters)) {
+        throw new import_core.ZWaveError(`A ConfigurationCC.BulkSet can only be used for consecutive parameters`, import_core.ZWaveErrorCodes.CC_Invalid);
       }
       this._handshake = !!options.handshake;
       this._resetToDefault = !!options.resetToDefault;
       if (!!options.resetToDefault) {
         this._valueSize = 1;
-        this._valueFormat = import_safe.ConfigValueFormat.SignedInteger;
+        this._valueFormat = import_core.ConfigValueFormat.SignedInteger;
         this._values = this._parameters.map(() => 0);
       } else {
         this._valueSize = options.valueSize;
-        this._valueFormat = options.valueFormat ?? import_safe.ConfigValueFormat.SignedInteger;
+        this._valueFormat = options.valueFormat ?? import_core.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);
+      throw new import_core.ZWaveError(`${this.name}: deserialization not implemented`, import_core.ZWaveErrorCodes.Deserialization_NotImplemented);
     }
     _parameters;
     get parameters() {
@@ -1334,7 +1333,7 @@ let ConfigurationCCBulkSet = (() => {
     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 = import_shared.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;
@@ -1403,18 +1402,18 @@ let ConfigurationCCBulkReport = (() => {
       }
     }
     static from(raw, ctx) {
-      (0, import_safe.validatePayload)(raw.payload.length >= 5);
+      (0, import_core.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);
+      (0, import_core.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);
+        values[param] = parseValue(raw.payload.subarray(5 + i * valueSize), valueSize, import_core.ConfigValueFormat.SignedInteger);
       }
       return new this({
         nodeId: ctx.sourceNodeId,
@@ -1430,7 +1429,7 @@ let ConfigurationCCBulkReport = (() => {
         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) {
+        if (oldParamInformation.format != void 0 && oldParamInformation.format !== import_core.ConfigValueFormat.SignedInteger) {
           value = reInterpretSignedValue(value, this.valueSize, oldParamInformation.format);
           this._values.set(parameter, value);
         }
@@ -1494,19 +1493,19 @@ let ConfigurationCCBulkGet = (() => {
     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);
+      if (!(0, import_core.isConsecutiveArray)(this.parameters)) {
+        throw new import_core.ZWaveError(`A ConfigurationCC.BulkGet can only be used for consecutive parameters`, import_core.ZWaveErrorCodes.CC_Invalid);
       }
     }
     static from(_raw, _ctx) {
-      throw new import_safe.ZWaveError(`${this.name}: deserialization not implemented`, import_safe.ZWaveErrorCodes.Deserialization_NotImplemented);
+      throw new import_core.ZWaveError(`${this.name}: deserialization not implemented`, import_core.ZWaveErrorCodes.Deserialization_NotImplemented);
     }
     _parameters;
     get parameters() {
       return this._parameters;
     }
     serialize(ctx) {
-      this.payload = new import_safe2.Bytes(3);
+      this.payload = new import_shared.Bytes(3);
       this.payload.writeUInt16BE(this.parameters[0], 0);
       this.payload[2] = this.parameters.length;
       return super.serialize(ctx);
@@ -1547,11 +1546,11 @@ let ConfigurationCCNameReport = (() => {
       this.reportsToFollow = options.reportsToFollow;
     }
     static from(raw, ctx) {
-      (0, import_safe.validatePayload)(raw.payload.length >= 3);
+      (0, import_core.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);
+        (0, import_core.validatePayload)(raw.payload.length >= 4);
       }
       const name = raw.payload.subarray(3).toString("utf8");
       return new this({
@@ -1589,8 +1588,8 @@ let ConfigurationCCNameReport = (() => {
       return true;
     }
     serialize(ctx) {
-      const nameBuffer = import_safe2.Bytes.from(this.name, "utf8");
-      this.payload = new import_safe2.Bytes(3 + nameBuffer.length);
+      const nameBuffer = import_shared.Bytes.from(this.name, "utf8");
+      this.payload = new import_shared.Bytes(3 + nameBuffer.length);
       this.payload.writeUInt16BE(this.parameter, 0);
       this.payload[2] = this.reportsToFollow;
       this.payload.set(nameBuffer, 3);
@@ -1644,7 +1643,7 @@ let ConfigurationCCNameGet = (() => {
       this.parameter = options.parameter;
     }
     static from(raw, ctx) {
-      (0, import_safe.validatePayload)(raw.payload.length >= 2);
+      (0, import_core.validatePayload)(raw.payload.length >= 2);
       const parameter = raw.payload.readUInt16BE(0);
       return new this({
         nodeId: ctx.sourceNodeId,
@@ -1653,7 +1652,7 @@ let ConfigurationCCNameGet = (() => {
     }
     parameter;
     serialize(ctx) {
-      this.payload = new import_safe2.Bytes(2);
+      this.payload = new import_shared.Bytes(2);
       this.payload.writeUInt16BE(this.parameter, 0);
       return super.serialize(ctx);
     }
@@ -1693,11 +1692,11 @@ let ConfigurationCCInfoReport = (() => {
       this.reportsToFollow = options.reportsToFollow;
     }
     static from(raw, ctx) {
-      (0, import_safe.validatePayload)(raw.payload.length >= 3);
+      (0, import_core.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);
+        (0, import_core.validatePayload)(raw.payload.length >= 4);
       }
       const info = raw.payload.subarray(3).toString("utf8");
       return new this({
@@ -1735,8 +1734,8 @@ let ConfigurationCCInfoReport = (() => {
       return true;
     }
     serialize(ctx) {
-      const infoBuffer = import_safe2.Bytes.from(this.info, "utf8");
-      this.payload = new import_safe2.Bytes(3 + infoBuffer.length);
+      const infoBuffer = import_shared.Bytes.from(this.info, "utf8");
+      this.payload = new import_shared.Bytes(3 + infoBuffer.length);
       this.payload.writeUInt16BE(this.parameter, 0);
       this.payload[2] = this.reportsToFollow;
       this.payload.set(infoBuffer, 3);
@@ -1790,7 +1789,7 @@ let ConfigurationCCInfoGet = (() => {
       this.parameter = options.parameter;
     }
     static from(raw, ctx) {
-      (0, import_safe.validatePayload)(raw.payload.length >= 2);
+      (0, import_core.validatePayload)(raw.payload.length >= 2);
       const parameter = raw.payload.readUInt16BE(0);
       return new this({
         nodeId: ctx.sourceNodeId,
@@ -1799,7 +1798,7 @@ let ConfigurationCCInfoGet = (() => {
     }
     parameter;
     serialize(ctx) {
-      this.payload = new import_safe2.Bytes(2);
+      this.payload = new import_shared.Bytes(2);
       this.payload.writeUInt16BE(this.parameter, 0);
       return super.serialize(ctx);
     }
@@ -1839,11 +1838,11 @@ let ConfigurationCCPropertiesReport = (() => {
       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);
+          throw new import_core.ZWaveError("The minimum value must be set when the value size is non-zero", import_core.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);
+          throw new import_core.ZWaveError("The maximum value must be set when the value size is non-zero", import_core.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);
+          throw new import_core.ZWaveError("The default value must be set when the value size is non-zero", import_core.ZWaveErrorCodes.Argument_Invalid);
         }
         this.minValue = options.minValue;
         this.maxValue = options.maxValue;
@@ -1856,7 +1855,7 @@ let ConfigurationCCPropertiesReport = (() => {
       this.noBulkSupport = options.noBulkSupport;
     }
     static from(raw, ctx) {
-      (0, import_safe.validatePayload)(raw.payload.length >= 3);
+      (0, import_core.validatePayload)(raw.payload.length >= 3);
       const parameter = raw.payload.readUInt16BE(0);
       const valueFormat = (raw.payload[2] & 56) >>> 3;
       const valueSize = raw.payload[2] & 7;
@@ -1872,12 +1871,12 @@ let ConfigurationCCPropertiesReport = (() => {
         });
       }
       const nextParameterOffset = 3 + 3 * valueSize;
-      (0, import_safe.validatePayload)(raw.payload.length >= nextParameterOffset + 2);
+      (0, import_core.validatePayload)(raw.payload.length >= nextParameterOffset + 2);
       let minValue;
       let maxValue;
       let defaultValue;
       if (valueSize > 0) {
-        if (valueFormat === import_safe.ConfigValueFormat.BitField) {
+        if (valueFormat === import_core.ConfigValueFormat.BitField) {
           minValue = 0;
         } else {
           minValue = parseValue(raw.payload.subarray(3), valueSize, valueFormat);
@@ -1929,9 +1928,9 @@ let ConfigurationCCPropertiesReport = (() => {
           noBulkSupport: this.noBulkSupport,
           isFromConfig: false
         };
-        if (this.valueFormat !== import_safe.ConfigValueFormat.BitField) {
+        if (this.valueFormat !== import_core.ConfigValueFormat.BitField) {
           if (!this.paramExistsInConfigFile(ctx, this.parameter)) {
-            const paramInfo = (0, import_safe.stripUndefined)({
+            const paramInfo = (0, import_core.stripUndefined)({
               ...baseInfo,
               min: this.minValue,
               max: this.maxValue,
@@ -1947,7 +1946,7 @@ let ConfigurationCCPropertiesReport = (() => {
               // Only create partials that exist
               !!(mask & bits) && !this.paramExistsInConfigFile(ctx, this.parameter, mask)
             ) {
-              const paramInfo = (0, import_safe.stripUndefined)({
+              const paramInfo = (0, import_core.stripUndefined)({
                 ...baseInfo,
                 min: 0,
                 max: 1,
@@ -1973,7 +1972,7 @@ let ConfigurationCCPropertiesReport = (() => {
     isAdvanced;
     noBulkSupport;
     serialize(ctx) {
-      this.payload = new import_safe2.Bytes(3 + 3 * this.valueSize + 2 + 1);
+      this.payload = new import_shared.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;
@@ -1997,7 +1996,7 @@ let ConfigurationCCPropertiesReport = (() => {
         "parameter #": this.parameter,
         "next param #": this.nextParameter,
         "value size": this.valueSize,
-        "value format": (0, import_safe3.getEnumMemberName)(import_safe.ConfigValueFormat, this.valueFormat)
+        "value format": (0, import_shared.getEnumMemberName)(import_core.ConfigValueFormat, this.valueFormat)
       };
       if (this.minValue != void 0) {
         message["min value"] = configValueToString(this.minValue);
@@ -2053,7 +2052,7 @@ let ConfigurationCCPropertiesGet = (() => {
       this.parameter = options.parameter;
     }
     static from(raw, ctx) {
-      (0, import_safe.validatePayload)(raw.payload.length >= 2);
+      (0, import_core.validatePayload)(raw.payload.length >= 2);
       const parameter = raw.payload.readUInt16BE(0);
       return new this({
         nodeId: ctx.sourceNodeId,
@@ -2062,7 +2061,7 @@ let ConfigurationCCPropertiesGet = (() => {
     }
     parameter;
     serialize(ctx) {
-      this.payload = new import_safe2.Bytes(2);
+      this.payload = new import_shared.Bytes(2);
       this.payload.writeUInt16BE(this.parameter, 0);
       return super.serialize(ctx);
     }
@@ -2102,13 +2101,13 @@ function isSafeValue(value, size, format) {
   let minValue;
   let maxValue;
   switch (format) {
-    case import_safe.ConfigValueFormat.SignedInteger:
+    case import_core.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:
+    case import_core.ConfigValueFormat.UnsignedInteger:
+    case import_core.ConfigValueFormat.Enumerated:
+    case import_core.ConfigValueFormat.BitField:
       minValue = 0;
       maxValue = Math.pow(2, 8 * size);
       break;
@@ -2120,17 +2119,17 @@ function isSafeValue(value, size, format) {
 __name(isSafeValue, "isSafeValue");
 function parseValue(raw, size, format) {
   switch (format) {
-    case import_safe.ConfigValueFormat.SignedInteger:
+    case import_core.ConfigValueFormat.SignedInteger:
       return raw.readIntBE(0, size);
-    case import_safe.ConfigValueFormat.UnsignedInteger:
-    case import_safe.ConfigValueFormat.Enumerated:
-    case import_safe.ConfigValueFormat.BitField:
+    case import_core.ConfigValueFormat.UnsignedInteger:
+    case import_core.ConfigValueFormat.Enumerated:
+    case import_core.ConfigValueFormat.BitField:
       return raw.readUIntBE(0, size);
   }
 }
 __name(parseValue, "parseValue");
 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);
+  throw new import_core.ZWaveError(`The value ${value} is invalid for configuration parameter ${parameter} (size = ${valueSize}, format = ${(0, import_shared.getEnumMemberName)(import_core.ConfigValueFormat, valueFormat)})!`, import_core.ZWaveErrorCodes.Argument_Invalid);
 }
 __name(throwInvalidValueError, "throwInvalidValueError");
 function tryCatchOutOfBoundsError(e, value, parameter, valueSize, valueFormat) {
@@ -2143,12 +2142,12 @@ function tryCatchOutOfBoundsError(e, value, parameter, valueSize, valueFormat) {
 __name(tryCatchOutOfBoundsError, "tryCatchOutOfBoundsError");
 function serializeValue(payload, offset, size, format, value) {
   switch (format) {
-    case import_safe.ConfigValueFormat.SignedInteger:
+    case import_core.ConfigValueFormat.SignedInteger:
       payload.writeIntBE(value, offset, size);
       return;
-    case import_safe.ConfigValueFormat.UnsignedInteger:
-    case import_safe.ConfigValueFormat.Enumerated:
-    case import_safe.ConfigValueFormat.BitField:
+    case import_core.ConfigValueFormat.UnsignedInteger:
+    case import_core.ConfigValueFormat.Enumerated:
+    case import_core.ConfigValueFormat.BitField:
       payload.writeUIntBE(value, offset, size);
       return;
   }