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

package/build/cjs/cc/MeterCC.js

@@ -0,0 +1,1355 @@
+"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 MeterCC_exports = {};
+__export(MeterCC_exports, {
+  MeterCC: () => MeterCC,
+  MeterCCAPI: () => MeterCCAPI,
+  MeterCCGet: () => MeterCCGet,
+  MeterCCReport: () => MeterCCReport,
+  MeterCCReset: () => MeterCCReset,
+  MeterCCSupportedGet: () => MeterCCSupportedGet,
+  MeterCCSupportedReport: () => MeterCCSupportedReport,
+  MeterCCValues: () => MeterCCValues,
+  isAccumulatedValue: () => isAccumulatedValue
+});
+module.exports = __toCommonJS(MeterCC_exports);
+var import_core = require("@zwave-js/core");
+var import_safe = require("@zwave-js/core/safe");
+var import_safe2 = require("@zwave-js/shared/safe");
+var import_safe3 = require("@zwave-js/shared/safe");
+var import_API = require("../lib/API.js");
+var import_CommandClass = require("../lib/CommandClass.js");
+var import_CommandClassDecorators = require("../lib/CommandClassDecorators.js");
+var import_Values = require("../lib/Values.js");
+var import_Types = require("../lib/_Types.js");
+var __esDecorate = function(ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+  function accept(f) {
+    if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected");
+    return f;
+  }
+  var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+  var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+  var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+  var _, done = false;
+  for (var i = decorators.length - 1; i >= 0; i--) {
+    var context = {};
+    for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+    for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+    context.addInitializer = function(f) {
+      if (done) throw new TypeError("Cannot add initializers after decoration has completed");
+      extraInitializers.push(accept(f || null));
+    };
+    var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+    if (kind === "accessor") {
+      if (result === void 0) continue;
+      if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+      if (_ = accept(result.get)) descriptor.get = _;
+      if (_ = accept(result.set)) descriptor.set = _;
+      if (_ = accept(result.init)) initializers.unshift(_);
+    } else if (_ = accept(result)) {
+      if (kind === "field") initializers.unshift(_);
+      else descriptor[key] = _;
+    }
+  }
+  if (target) Object.defineProperty(target, contextIn.name, descriptor);
+  done = true;
+};
+var __runInitializers = function(thisArg, initializers, value) {
+  var useValue = arguments.length > 2;
+  for (var i = 0; i < initializers.length; i++) {
+    value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+  }
+  return useValue ? value : void 0;
+};
+function __assertType(argName, typeName, boundHasError) {
+  const { ZWaveError, ZWaveErrorCodes } = require("@zwave-js/core");
+  if (boundHasError()) {
+    throw new ZWaveError(typeName ? `${argName} is not a ${typeName}` : `${argName} has the wrong type`, ZWaveErrorCodes.Argument_Invalid);
+  }
+}
+const __assertType__optional_MeterCCGetOptions = ($o) => {
+  function _number($o2) {
+    return typeof $o2 !== "number" ? {} : null;
+  }
+  function su__2__3__4_eu($o2) {
+    return ![0, 1, 2].includes($o2) ? {} : null;
+  }
+  function _0($o2) {
+    if (typeof $o2 !== "object" || $o2 === null || Array.isArray($o2))
+      return {};
+    if ("scale" in $o2 && $o2["scale"] !== void 0) {
+      const error = _number($o2["scale"]);
+      if (error)
+        return error;
+    }
+    if ("rateType" in $o2 && $o2["rateType"] !== void 0) {
+      const error = su__2__3__4_eu($o2["rateType"]);
+      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__MeterCCReportOptions = ($o) => {
+  function _number($o2) {
+    return typeof $o2 !== "number" ? {} : null;
+  }
+  function _undefined($o2) {
+    return $o2 !== void 0 ? {} : null;
+  }
+  function su__undefined__number_eu($o2) {
+    const conditions = [_undefined, _number];
+    for (const condition of conditions) {
+      const error = condition($o2);
+      if (!error)
+        return null;
+    }
+    return {};
+  }
+  function su__5__6__7_eu($o2) {
+    return ![0, 1, 2].includes($o2) ? {} : null;
+  }
+  function _null($o2) {
+    return $o2 !== null ? {} : null;
+  }
+  function su__null__number_eu($o2) {
+    const conditions = [_null, _number];
+    for (const condition of conditions) {
+      const error = condition($o2);
+      if (!error)
+        return null;
+    }
+    return {};
+  }
+  function _0($o2) {
+    if (typeof $o2 !== "object" || $o2 === null || Array.isArray($o2))
+      return {};
+    if ("type" in $o2 && $o2["type"] !== void 0) {
+      const error = _number($o2["type"]);
+      if (error)
+        return error;
+    } else
+      return {};
+    if ("scale" in $o2 && $o2["scale"] !== void 0) {
+      const error = _number($o2["scale"]);
+      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 {};
+    if ("previousValue" in $o2 && $o2["previousValue"] !== void 0) {
+      const error = su__undefined__number_eu($o2["previousValue"]);
+      if (error)
+        return error;
+    }
+    if ("rateType" in $o2 && $o2["rateType"] !== void 0) {
+      const error = su__5__6__7_eu($o2["rateType"]);
+      if (error)
+        return error;
+    }
+    if ("deltaTime" in $o2 && $o2["deltaTime"] !== void 0) {
+      const error = su__null__number_eu($o2["deltaTime"]);
+      if (error)
+        return error;
+    }
+    return null;
+  }
+  return _0($o);
+};
+const __assertType__optional_boolean = ($o) => {
+  function _boolean($o2) {
+    return typeof $o2 !== "boolean" ? {} : null;
+  }
+  function optional__boolean($o2) {
+    if ($o2 !== void 0) {
+      const error = _boolean($o2);
+      if (error)
+        return error;
+    }
+    return null;
+  }
+  return optional__boolean($o);
+};
+const __assertType__MeterCCSupportedReportOptions = ($o) => {
+  function _number($o2) {
+    return typeof $o2 !== "number" ? {} : null;
+  }
+  function _boolean($o2) {
+    return typeof $o2 !== "boolean" ? {} : null;
+  }
+  function sa__number_ea_3($o2) {
+    if (!Array.isArray($o2))
+      return {};
+    for (let i = 0; i < $o2.length; i++) {
+      const error = _number($o2[i]);
+      if (error)
+        return error;
+    }
+    return null;
+  }
+  function su__5__6__7_eu($o2) {
+    return ![0, 1, 2].includes($o2) ? {} : null;
+  }
+  function sa_su__5__6__7_eu_ea_4($o2) {
+    if (!Array.isArray($o2))
+      return {};
+    for (let i = 0; i < $o2.length; i++) {
+      const error = su__5__6__7_eu($o2[i]);
+      if (error)
+        return error;
+    }
+    return null;
+  }
+  function _0($o2) {
+    if (typeof $o2 !== "object" || $o2 === null || Array.isArray($o2))
+      return {};
+    if ("type" in $o2 && $o2["type"] !== void 0) {
+      const error = _number($o2["type"]);
+      if (error)
+        return error;
+    } else
+      return {};
+    if ("supportsReset" in $o2 && $o2["supportsReset"] !== void 0) {
+      const error = _boolean($o2["supportsReset"]);
+      if (error)
+        return error;
+    } else
+      return {};
+    if ("supportedScales" in $o2 && $o2["supportedScales"] !== void 0) {
+      const error = sa__number_ea_3($o2["supportedScales"]);
+      if (error)
+        return error;
+    } else
+      return {};
+    if ("supportedRateTypes" in $o2 && $o2["supportedRateTypes"] !== void 0) {
+      const error = sa_su__5__6__7_eu_ea_4($o2["supportedRateTypes"]);
+      if (error)
+        return error;
+    } else
+      return {};
+    return null;
+  }
+  return _0($o);
+};
+const __assertType__optional_MeterCCResetOptions = ($o) => {
+  function _number($o2) {
+    return typeof $o2 !== "number" ? {} : null;
+  }
+  function su__4__5__6_eu($o2) {
+    return ![0, 1, 2].includes($o2) ? {} : null;
+  }
+  function _1($o2) {
+    if (typeof $o2 !== "object" || $o2 === null || Array.isArray($o2))
+      return {};
+    if ("type" in $o2 && $o2["type"] !== void 0) {
+      const error = _number($o2["type"]);
+      if (error)
+        return error;
+    } else
+      return {};
+    if ("scale" in $o2 && $o2["scale"] !== void 0) {
+      const error = _number($o2["scale"]);
+      if (error)
+        return error;
+    } else
+      return {};
+    if ("rateType" in $o2 && $o2["rateType"] !== void 0) {
+      const error = su__4__5__6_eu($o2["rateType"]);
+      if (error)
+        return error;
+    } else
+      return {};
+    if ("targetValue" in $o2 && $o2["targetValue"] !== void 0) {
+      const error = _number($o2["targetValue"]);
+      if (error)
+        return error;
+    } else
+      return {};
+    return null;
+  }
+  function _undefined($o2) {
+    return $o2 !== void 0 ? {} : null;
+  }
+  function _2($o2) {
+    if (typeof $o2 !== "object" || $o2 === null || Array.isArray($o2))
+      return {};
+    if ("type" in $o2 && $o2["type"] !== void 0) {
+      const error = _undefined($o2["type"]);
+      if (error)
+        return error;
+    }
+    if ("scale" in $o2 && $o2["scale"] !== void 0) {
+      const error = _undefined($o2["scale"]);
+      if (error)
+        return error;
+    }
+    if ("rateType" in $o2 && $o2["rateType"] !== void 0) {
+      const error = _undefined($o2["rateType"]);
+      if (error)
+        return error;
+    }
+    if ("targetValue" in $o2 && $o2["targetValue"] !== void 0) {
+      const error = _undefined($o2["targetValue"]);
+      if (error)
+        return error;
+    }
+    return null;
+  }
+  function su__1__2_eu($o2) {
+    const conditions = [_1, _2];
+    for (const condition of conditions) {
+      const error = condition($o2);
+      if (!error)
+        return null;
+    }
+    return {};
+  }
+  function optional_su__1__2_eu($o2) {
+    if ($o2 !== void 0) {
+      const error = su__1__2_eu($o2);
+      if (error)
+        return error;
+    }
+    return null;
+  }
+  return optional_su__1__2_eu($o);
+};
+const MeterCCValues = Object.freeze({
+  ...import_Values.V.defineStaticCCValues(import_safe.CommandClasses.Meter, {
+    ...import_Values.V.staticProperty("type", void 0, { internal: true }),
+    ...import_Values.V.staticProperty("supportsReset", void 0, { internal: true }),
+    ...import_Values.V.staticProperty("supportedScales", void 0, { internal: true }),
+    ...import_Values.V.staticProperty("supportedRateTypes", void 0, {
+      internal: true
+    }),
+    ...import_Values.V.staticPropertyWithName("resetAll", "reset", {
+      ...import_safe.ValueMetadata.WriteOnlyBoolean,
+      label: `Reset accumulated values`,
+      states: {
+        true: "Reset"
+      }
+    })
+  }),
+  ...import_Values.V.defineDynamicCCValues(import_safe.CommandClasses.Meter, {
+    ...import_Values.V.dynamicPropertyAndKeyWithName("resetSingle", "reset", toPropertyKey, ({ property, propertyKey }) => property === "reset" && typeof propertyKey === "number", (meterType, rateType, scale) => ({
+      ...import_safe.ValueMetadata.WriteOnlyBoolean,
+      // This is only a placeholder label. A config manager is needed to
+      // determine the actual label.
+      label: `Reset (${rateType === import_Types.RateType.Consumed ? "Consumption, " : rateType === import_Types.RateType.Produced ? "Production, " : ""}${(0, import_safe3.num2hex)(scale)})`,
+      states: {
+        true: "Reset"
+      },
+      ccSpecific: {
+        meterType,
+        rateType,
+        scale
+      }
+    })),
+    ...import_Values.V.dynamicPropertyAndKeyWithName("value", "value", toPropertyKey, ({ property, propertyKey }) => property === "value" && typeof propertyKey === "number", (meterType, rateType, scale) => ({
+      ...import_safe.ValueMetadata.ReadOnlyNumber,
+      // Label and unit can only be determined with a config manager
+      ccSpecific: {
+        meterType,
+        rateType,
+        scale
+      }
+    }))
+  })
+});
+function toPropertyKey(meterType, rateType, scale) {
+  return meterType << 16 | scale << 8 | rateType;
+}
+function splitPropertyKey(key) {
+  return {
+    rateType: key & 255,
+    scale: key >>> 8 & 255,
+    meterType: key >>> 16
+  };
+}
+function getValueLabel(meterType, scale, rateType, suffix) {
+  let ret = (0, import_core.getMeterName)(meterType);
+  const scaleLabel = ((0, import_core.getMeterScale)(meterType, scale) ?? (0, import_core.getUnknownMeterScale)(scale)).label;
+  switch (rateType) {
+    case import_Types.RateType.Consumed:
+      ret += ` Consumption [${scaleLabel}]`;
+      break;
+    case import_Types.RateType.Produced:
+      ret += ` Production [${scaleLabel}]`;
+      break;
+    default:
+      ret += ` [${scaleLabel}]`;
+  }
+  if (suffix) {
+    ret += ` (${suffix})`;
+  }
+  return ret;
+}
+function parseMeterValueAndInfo(data, offset) {
+  (0, import_safe.validatePayload)(data.length >= offset + 1);
+  const type = data[offset] & 31;
+  const rateType = (data[offset] & 96) >>> 5;
+  const scale1Bit2 = (data[offset] & 128) >>> 7;
+  const { scale: scale1Bits10, value, bytesRead } = (0, import_safe.parseFloatWithScale)(data.subarray(offset + 1));
+  return {
+    type,
+    rateType,
+    // The scale is composed of two fields
+    scale1: scale1Bit2 << 2 | scale1Bits10,
+    value,
+    // We've read one byte more than the float contains
+    bytesRead: bytesRead + 1
+  };
+}
+function encodeMeterValueAndInfo(type, rateType, scale, value) {
+  const scale1 = scale >= 7 ? 7 : scale & 7;
+  const scale1Bits10 = scale1 & 3;
+  const scale1Bit2 = scale1 >>> 2;
+  const scale2 = scale >= 7 ? scale - 7 : void 0;
+  const typeByte = type & 31 | (rateType & 3) << 5 | scale1Bit2 << 7;
+  const floatParams = (0, import_core.getFloatParameters)(value);
+  const valueBytes = (0, import_core.encodeFloatWithScale)(value, scale1Bits10, floatParams);
+  return {
+    data: import_safe2.Bytes.concat([import_safe2.Bytes.from([typeByte]), valueBytes]),
+    floatParams: (0, import_safe3.pick)(floatParams, ["precision", "size"]),
+    scale2
+  };
+}
+function parseScale(scale1, data, scale2Offset) {
+  if (scale1 === 7) {
+    (0, import_safe.validatePayload)(data.length >= scale2Offset + 1);
+    const scale2 = data[scale2Offset];
+    return scale1 + scale2;
+  } else {
+    return scale1;
+  }
+}
+function isAccumulatedValue(meterType, scale) {
+  switch (meterType) {
+    case 1:
+      return (
+        // kVarh
+        // Pulse count
+        scale === 0 || scale === 1 || scale === 3 || scale === 8
+      );
+    case 2:
+      return (
+        // Pulse count
+        // ft³
+        scale === 0 || scale === 1 || scale === 3
+      );
+    case 3:
+      return (
+        // Pulse count
+        // US gallons
+        scale === 0 || scale === 1 || scale === 2 || scale === 3
+      );
+    case 4:
+      return scale === 0;
+    // kWh
+    case 5:
+      return scale === 0;
+  }
+  return false;
+}
+let MeterCCAPI = (() => {
+  let _classDecorators = [(0, import_CommandClassDecorators.API)(import_safe.CommandClasses.Meter)];
+  let _classDescriptor;
+  let _classExtraInitializers = [];
+  let _classThis;
+  let _classSuper = import_API.PhysicalCCAPI;
+  var MeterCCAPI2 = class extends _classSuper {
+    static {
+      _classThis = this;
+    }
+    static {
+      const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+      __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+      MeterCCAPI2 = _classThis = _classDescriptor.value;
+      if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+      __runInitializers(_classThis, _classExtraInitializers);
+    }
+    supportsCommand(cmd) {
+      switch (cmd) {
+        case import_Types.MeterCommand.Get:
+        case import_Types.MeterCommand.Report:
+          return true;
+        // This is mandatory
+        case import_Types.MeterCommand.SupportedGet:
+        case import_Types.MeterCommand.SupportedReport:
+          return this.version >= 2;
+        case import_Types.MeterCommand.Reset: {
+          const ret = this.tryGetValueDB()?.getValue({
+            commandClass: (0, import_CommandClassDecorators.getCommandClass)(this),
+            endpoint: this.endpoint.index,
+            property: "supportsReset"
+          });
+          return ret === true;
+        }
+      }
+      return super.supportsCommand(cmd);
+    }
+    get [import_API.POLL_VALUE]() {
+      return async function({ property, propertyKey }) {
+        switch (property) {
+          case "value":
+          case "previousValue":
+          case "deltaTime": {
+            if (propertyKey == void 0) {
+              (0, import_API.throwMissingPropertyKey)(this.ccId, property);
+            } else if (typeof propertyKey !== "number") {
+              (0, import_API.throwUnsupportedPropertyKey)(this.ccId, property, propertyKey);
+            }
+            const { rateType, scale } = splitPropertyKey(propertyKey);
+            return (await this.get({
+              rateType,
+              scale
+            }))?.[property];
+          }
+          default:
+            (0, import_API.throwUnsupportedProperty)(this.ccId, property);
+        }
+      };
+    }
+    async get(options) {
+      __assertType("options", "(optional) MeterCCGetOptions", __assertType__optional_MeterCCGetOptions.bind(void 0, options));
+      this.assertSupportsCommand(import_Types.MeterCommand, import_Types.MeterCommand.Get);
+      const cc = new MeterCCGet({
+        nodeId: this.endpoint.nodeId,
+        endpointIndex: this.endpoint.index,
+        ...options
+      });
+      const response = await this.host.sendCommand(cc, this.commandOptions);
+      if (response) {
+        return {
+          type: response.type,
+          scale: (0, import_core.getMeterScale)(response.type, response.scale) ?? (0, import_core.getUnknownMeterScale)(response.scale),
+          ...(0, import_safe3.pick)(response, [
+            "value",
+            "previousValue",
+            "rateType",
+            "deltaTime"
+          ])
+        };
+      }
+    }
+    async sendReport(options) {
+      __assertType("options", "MeterCCReportOptions", __assertType__MeterCCReportOptions.bind(void 0, options));
+      this.assertSupportsCommand(import_Types.MeterCommand, import_Types.MeterCommand.Report);
+      const cc = new MeterCCReport({
+        nodeId: this.endpoint.nodeId,
+        endpointIndex: this.endpoint.index,
+        ...options
+      });
+      return this.host.sendCommand(cc, this.commandOptions);
+    }
+    async getAll(accumulatedOnly = false) {
+      __assertType("accumulatedOnly", "(optional) boolean", __assertType__optional_boolean.bind(void 0, accumulatedOnly));
+      const valueDB = this.tryGetValueDB();
+      if (this.version >= 2) {
+        const meterType = valueDB?.getValue(MeterCCValues.type.endpoint(this.endpoint.index));
+        const supportedScales = valueDB?.getValue(MeterCCValues.supportedScales.endpoint(this.endpoint.index)) ?? [];
+        const supportedRateTypes = valueDB?.getValue(MeterCCValues.supportedRateTypes.endpoint(this.endpoint.index)) ?? [];
+        const rateTypes = supportedRateTypes.length ? supportedRateTypes : [void 0];
+        const ret = [];
+        for (const rateType of rateTypes) {
+          for (const scale of supportedScales) {
+            if (accumulatedOnly && meterType != void 0 && !isAccumulatedValue(meterType, scale)) {
+              continue;
+            }
+            const response = await this.get({
+              scale,
+              rateType
+            });
+            if (response)
+              ret.push(response);
+          }
+        }
+        return ret;
+      } else {
+        const response = await this.get();
+        return response ? [response] : [];
+      }
+    }
+    // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
+    async getSupported() {
+      this.assertSupportsCommand(import_Types.MeterCommand, import_Types.MeterCommand.SupportedGet);
+      const cc = new MeterCCSupportedGet({
+        nodeId: this.endpoint.nodeId,
+        endpointIndex: this.endpoint.index
+      });
+      const response = await this.host.sendCommand(cc, this.commandOptions);
+      if (response) {
+        return (0, import_safe3.pick)(response, [
+          "type",
+          "supportsReset",
+          "supportedScales",
+          "supportedRateTypes"
+        ]);
+      }
+    }
+    async sendSupportedReport(options) {
+      __assertType("options", "MeterCCSupportedReportOptions", __assertType__MeterCCSupportedReportOptions.bind(void 0, options));
+      this.assertSupportsCommand(import_Types.MeterCommand, import_Types.MeterCommand.SupportedReport);
+      const cc = new MeterCCSupportedReport({
+        nodeId: this.endpoint.nodeId,
+        endpointIndex: this.endpoint.index,
+        ...options
+      });
+      await this.host.sendCommand(cc, this.commandOptions);
+    }
+    async reset(options) {
+      __assertType("options", "(optional) MeterCCResetOptions", __assertType__optional_MeterCCResetOptions.bind(void 0, options));
+      this.assertSupportsCommand(import_Types.MeterCommand, import_Types.MeterCommand.Reset);
+      const cc = new MeterCCReset({
+        nodeId: this.endpoint.nodeId,
+        endpointIndex: this.endpoint.index,
+        ...options
+      });
+      return this.host.sendCommand(cc, this.commandOptions);
+    }
+    get [import_API.SET_VALUE]() {
+      return async function({ property, propertyKey }, value) {
+        if (property !== "reset") {
+          (0, import_API.throwUnsupportedProperty)(this.ccId, property);
+        } else if (propertyKey != void 0 && typeof propertyKey !== "number") {
+          (0, import_API.throwUnsupportedPropertyKey)(this.ccId, property, propertyKey);
+        } else if (value !== true) {
+          (0, import_API.throwWrongValueType)(this.ccId, property, "true", value === false ? "false" : typeof value);
+        }
+        if (typeof propertyKey === "number") {
+          const { meterType, scale, rateType } = splitPropertyKey(propertyKey);
+          return this.reset({
+            type: meterType,
+            scale,
+            rateType,
+            targetValue: 0
+          });
+        } else {
+          return this.reset();
+        }
+        return void 0;
+      };
+    }
+    [import_API.SET_VALUE_HOOKS] = ({ property, propertyKey }, _value, _options) => {
+      if (property !== "reset")
+        return;
+      if (typeof propertyKey === "number") {
+        const { meterType, rateType, scale } = splitPropertyKey(propertyKey);
+        const readingValueId = MeterCCValues.value(meterType, rateType, scale).endpoint(this.endpoint.index);
+        return {
+          optimisticallyUpdateRelatedValues: (supervisedAndSuccessful) => {
+            if (!supervisedAndSuccessful)
+              return;
+            const valueDB = this.tryGetValueDB();
+            if (!valueDB)
+              return;
+            if (isAccumulatedValue(meterType, scale)) {
+              valueDB.setValue({
+                commandClass: this.ccId,
+                endpoint: this.endpoint.index,
+                property,
+                propertyKey
+              }, 0);
+            }
+          },
+          verifyChanges: () => {
+            this.schedulePoll(readingValueId, 0, { transition: "fast" });
+          }
+        };
+      } else {
+        const valueDB = this.tryGetValueDB();
+        if (!valueDB)
+          return;
+        const accumulatedValues = valueDB.findValues((vid) => vid.commandClass === this.ccId && vid.endpoint === this.endpoint.index && MeterCCValues.value.is(vid)).filter(({ propertyKey: propertyKey2 }) => {
+          if (typeof propertyKey2 !== "number")
+            return false;
+          const { meterType, scale } = splitPropertyKey(propertyKey2);
+          return isAccumulatedValue(meterType, scale);
+        });
+        return {
+          optimisticallyUpdateRelatedValues: (supervisedAndSuccessful) => {
+            if (!supervisedAndSuccessful)
+              return;
+            for (const value of accumulatedValues) {
+              valueDB.setValue(value, 0);
+            }
+          },
+          verifyChanges: () => {
+            for (const valueID of accumulatedValues) {
+              this.schedulePoll(valueID, 0, { transition: "fast" });
+            }
+          }
+        };
+      }
+    };
+  };
+  return MeterCCAPI2 = _classThis;
+})();
+let MeterCC = (() => {
+  let _classDecorators = [(0, import_CommandClassDecorators.commandClass)(import_safe.CommandClasses.Meter), (0, import_CommandClassDecorators.implementedVersion)(6), (0, import_CommandClassDecorators.ccValues)(MeterCCValues)];
+  let _classDescriptor;
+  let _classExtraInitializers = [];
+  let _classThis;
+  let _classSuper = import_CommandClass.CommandClass;
+  var MeterCC2 = class extends _classSuper {
+    static {
+      _classThis = this;
+    }
+    static {
+      const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+      __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+      MeterCC2 = _classThis = _classDescriptor.value;
+      if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+      __runInitializers(_classThis, _classExtraInitializers);
+    }
+    async interview(ctx) {
+      const node = this.getNode(ctx);
+      const endpoint = this.getEndpoint(ctx);
+      const api = import_API.CCAPI.create(import_safe.CommandClasses.Meter, ctx, endpoint).withOptions({
+        priority: import_safe.MessagePriority.NodeQuery
+      });
+      ctx.logNode(node.id, {
+        endpoint: this.endpointIndex,
+        message: `Interviewing ${this.ccName}...`,
+        direction: "none"
+      });
+      if (api.version >= 2) {
+        ctx.logNode(node.id, {
+          endpoint: this.endpointIndex,
+          message: "querying meter support...",
+          direction: "outbound"
+        });
+        const suppResp = await api.getSupported();
+        if (suppResp) {
+          const logMessage = `received meter support:
+type:                 ${(0, import_core.getMeterName)(suppResp.type)}
+supported scales:     ${suppResp.supportedScales.map((s) => ((0, import_core.getMeterScale)(suppResp.type, s) ?? (0, import_core.getUnknownMeterScale)(s)).label).map((label) => `
+\xB7 ${label}`).join("")}
+supported rate types: ${suppResp.supportedRateTypes.map((rt) => (0, import_safe3.getEnumMemberName)(import_Types.RateType, rt)).map((label) => `
+\xB7 ${label}`).join("")}
+supports reset:       ${suppResp.supportsReset}`;
+          ctx.logNode(node.id, {
+            endpoint: this.endpointIndex,
+            message: logMessage,
+            direction: "inbound"
+          });
+        } else {
+          ctx.logNode(node.id, {
+            endpoint: this.endpointIndex,
+            message: "Querying meter support timed out, skipping interview...",
+            level: "warn"
+          });
+          return;
+        }
+      }
+      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.Meter, ctx, endpoint).withOptions({
+        priority: import_safe.MessagePriority.NodeQuery
+      });
+      if (api.version === 1) {
+        ctx.logNode(node.id, {
+          endpoint: this.endpointIndex,
+          message: `querying default meter value...`,
+          direction: "outbound"
+        });
+        await api.get();
+      } else {
+        const type = this.getValue(ctx, MeterCCValues.type) ?? 0;
+        const supportedScales = this.getValue(ctx, MeterCCValues.supportedScales) ?? [];
+        const supportedRateTypes = this.getValue(ctx, MeterCCValues.supportedRateTypes) ?? [];
+        const rateTypes = supportedRateTypes.length ? supportedRateTypes : [void 0];
+        for (const rateType of rateTypes) {
+          for (const scale of supportedScales) {
+            ctx.logNode(node.id, {
+              endpoint: this.endpointIndex,
+              message: `querying meter value (type = ${(0, import_core.getMeterName)(type)}, scale = ${((0, import_core.getMeterScale)(type, scale) ?? (0, import_core.getUnknownMeterScale)(scale)).label}${rateType != void 0 ? `, rate type = ${(0, import_safe3.getEnumMemberName)(import_Types.RateType, rateType)}` : ""})...`,
+              direction: "outbound"
+            });
+            await api.get({ scale, rateType });
+          }
+        }
+      }
+    }
+    shouldRefreshValues(ctx) {
+      const valueDB = ctx.tryGetValueDB(this.nodeId);
+      if (!valueDB)
+        return true;
+      const values = this.getDefinedValueIDs(ctx).filter((v) => MeterCCValues.value.is(v));
+      return values.every((v) => {
+        const lastUpdated = valueDB.getTimestamp(v);
+        return lastUpdated == void 0 || Date.now() - lastUpdated > import_core.timespan.hours(6);
+      });
+    }
+    /**
+     * Returns which type this meter has.
+     * This only works AFTER the interview process
+     */
+    static getMeterTypeCached(ctx, endpoint) {
+      return ctx.getValueDB(endpoint.nodeId).getValue(MeterCCValues.type.endpoint(endpoint.index));
+    }
+    /**
+     * Returns which scales are supported by this meter.
+     * This only works AFTER the interview process
+     */
+    static getSupportedScalesCached(ctx, endpoint) {
+      return ctx.getValueDB(endpoint.nodeId).getValue(MeterCCValues.supportedScales.endpoint(endpoint.index));
+    }
+    /**
+     * Returns whether reset is supported by this meter.
+     * This only works AFTER the interview process
+     */
+    static supportsResetCached(ctx, endpoint) {
+      return ctx.getValueDB(endpoint.nodeId).getValue(MeterCCValues.supportsReset.endpoint(endpoint.index));
+    }
+    /**
+     * Returns which rate types are supported by this meter.
+     * This only works AFTER the interview process
+     */
+    static getSupportedRateTypesCached(ctx, endpoint) {
+      return ctx.getValueDB(endpoint.nodeId).getValue(MeterCCValues.supportedRateTypes.endpoint(endpoint.index));
+    }
+    translatePropertyKey(ctx, property, propertyKey) {
+      if (property === "value" && typeof propertyKey === "number") {
+        const { meterType, rateType, scale } = splitPropertyKey(propertyKey);
+        let ret;
+        if (meterType !== 0) {
+          ret = `${(0, import_core.getMeterName)(meterType)}_${((0, import_core.getMeterScale)(meterType, scale) ?? (0, import_core.getUnknownMeterScale)(scale)).label}`;
+        } else {
+          ret = "default";
+        }
+        if (rateType !== import_Types.RateType.Unspecified) {
+          ret += "_" + (0, import_safe3.getEnumMemberName)(import_Types.RateType, rateType);
+        }
+        return ret;
+      } else if (property === "reset" && typeof propertyKey === "number") {
+        return (0, import_core.getMeterName)(propertyKey);
+      }
+      return super.translatePropertyKey(ctx, property, propertyKey);
+    }
+  };
+  return MeterCC2 = _classThis;
+})();
+let MeterCCReport = (() => {
+  let _classDecorators = [(0, import_CommandClassDecorators.CCCommand)(import_Types.MeterCommand.Report)];
+  let _classDescriptor;
+  let _classExtraInitializers = [];
+  let _classThis;
+  let _classSuper = MeterCC;
+  var MeterCCReport2 = class extends _classSuper {
+    static {
+      _classThis = this;
+    }
+    static {
+      const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+      __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+      MeterCCReport2 = _classThis = _classDescriptor.value;
+      if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+      __runInitializers(_classThis, _classExtraInitializers);
+    }
+    constructor(options) {
+      super(options);
+      this.type = options.type;
+      this.scale = options.scale;
+      this.value = options.value;
+      this.previousValue = options.previousValue;
+      this.rateType = options.rateType ?? import_Types.RateType.Unspecified;
+      this.deltaTime = options.deltaTime ?? import_safe.UNKNOWN_STATE;
+    }
+    static from(raw, ctx) {
+      const { type, rateType, scale1, value, bytesRead } = parseMeterValueAndInfo(raw.payload, 0);
+      let offset = bytesRead;
+      const floatSize = bytesRead - 2;
+      let deltaTime;
+      let previousValue;
+      if (raw.payload.length >= offset + 2) {
+        deltaTime = raw.payload.readUInt16BE(offset);
+        offset += 2;
+        if (deltaTime === 65535) {
+          deltaTime = import_safe.UNKNOWN_STATE;
+        }
+        if (
+          // Previous value is included only if delta time is not 0
+          deltaTime !== 0 && raw.payload.length >= offset + floatSize
+        ) {
+          const { value: prevValue } = (0, import_safe.parseFloatWithScale)(
+            // This float is split in the payload
+            import_safe2.Bytes.concat([
+              import_safe2.Bytes.from([raw.payload[1]]),
+              raw.payload.subarray(offset)
+            ])
+          );
+          offset += floatSize;
+          previousValue = prevValue;
+        }
+      } else {
+        deltaTime = 0;
+      }
+      const scale = parseScale(scale1, raw.payload, offset);
+      return new this({
+        nodeId: ctx.sourceNodeId,
+        type,
+        rateType,
+        value,
+        deltaTime,
+        previousValue,
+        scale
+      });
+    }
+    persistValues(ctx) {
+      if (!super.persistValues(ctx))
+        return false;
+      const ccVersion = (0, import_CommandClass.getEffectiveCCVersion)(ctx, this);
+      const meter = (0, import_core.getMeter)(this.type);
+      const scale = (0, import_core.getMeterScale)(this.type, this.scale) ?? (0, import_core.getUnknownMeterScale)(this.scale);
+      const measurementValidation = !ctx.getDeviceConfig?.(this.nodeId)?.compat?.disableStrictMeasurementValidation;
+      if (measurementValidation) {
+        import_safe.validatePayload.withReason(`Unknown meter type ${(0, import_safe3.num2hex)(this.type)} or corrupted data`)(!!meter);
+        import_safe.validatePayload.withReason(`Unknown meter scale ${(0, import_safe3.num2hex)(this.scale)} or corrupted data`)(scale.label !== (0, import_core.getUnknownMeterScale)(this.scale).label);
+        if (ccVersion >= 2) {
+          const expectedType = this.getValue(ctx, MeterCCValues.type);
+          if (expectedType != void 0) {
+            import_safe.validatePayload.withReason("Unexpected meter type or corrupted data")(this.type === expectedType);
+          }
+          const supportedScales = this.getValue(ctx, MeterCCValues.supportedScales);
+          if (supportedScales?.length) {
+            import_safe.validatePayload.withReason(`Unsupported meter scale ${scale.label} or corrupted data`)(supportedScales.includes(this.scale));
+          }
+          const supportedRateTypes = this.getValue(ctx, MeterCCValues.supportedRateTypes);
+          if (supportedRateTypes?.length) {
+            import_safe.validatePayload.withReason(`Unsupported rate type ${(0, import_safe3.getEnumMemberName)(import_Types.RateType, this.rateType)} or corrupted data`)(supportedRateTypes.includes(this.rateType));
+          }
+        }
+      }
+      const valueValue = MeterCCValues.value(this.type, this.rateType, this.scale);
+      this.setMetadata(ctx, valueValue, {
+        ...valueValue.meta,
+        label: getValueLabel(this.type, this.scale, this.rateType),
+        unit: scale.unit,
+        ccSpecific: {
+          meterType: this.type,
+          scale: this.scale,
+          rateType: this.rateType
+        }
+      });
+      this.setValue(ctx, valueValue, this.value);
+      return true;
+    }
+    type;
+    scale;
+    value;
+    previousValue;
+    rateType;
+    deltaTime;
+    serialize(ctx) {
+      const { data: typeAndValue, floatParams, scale2 } = encodeMeterValueAndInfo(this.type, this.rateType, this.scale, this.value);
+      const deltaTime = this.deltaTime ?? 65535;
+      const deltaTimeBytes = new import_safe2.Bytes(2);
+      deltaTimeBytes.writeUInt16BE(deltaTime, 0);
+      this.payload = import_safe2.Bytes.concat([
+        typeAndValue,
+        deltaTimeBytes
+      ]);
+      if (this.deltaTime !== 0 && this.previousValue != void 0) {
+        const prevValueBytes = (0, import_core.encodeFloatWithScale)(
+          this.previousValue,
+          0,
+          // we discard the scale anyways
+          floatParams
+        ).subarray(1);
+        this.payload = import_safe2.Bytes.concat([
+          this.payload,
+          prevValueBytes
+        ]);
+      }
+      if (scale2 != void 0) {
+        this.payload = import_safe2.Bytes.concat([
+          this.payload,
+          import_safe2.Bytes.from([scale2])
+        ]);
+      }
+      return super.serialize(ctx);
+    }
+    toLogEntry(ctx) {
+      const scale = (0, import_core.getMeterScale)(this.type, this.scale) ?? (0, import_core.getUnknownMeterScale)(this.scale);
+      const message = {
+        "meter type": (0, import_core.getMeterName)(this.type),
+        scale: scale.label,
+        "rate type": (0, import_safe3.getEnumMemberName)(import_Types.RateType, this.rateType),
+        value: this.value
+      };
+      if (this.deltaTime !== import_safe.UNKNOWN_STATE) {
+        message["time delta"] = `${this.deltaTime} seconds`;
+      }
+      if (this.previousValue != void 0) {
+        message["prev. value"] = this.previousValue;
+      }
+      return {
+        ...super.toLogEntry(ctx),
+        message
+      };
+    }
+  };
+  return MeterCCReport2 = _classThis;
+})();
+function testResponseForMeterGet(sent, received) {
+  return (sent.scale == void 0 || sent.scale === received.scale) && (sent.rateType == void 0 || sent.rateType == received.rateType);
+}
+let MeterCCGet = (() => {
+  let _classDecorators = [(0, import_CommandClassDecorators.CCCommand)(import_Types.MeterCommand.Get), (0, import_CommandClassDecorators.expectedCCResponse)(MeterCCReport, testResponseForMeterGet)];
+  let _classDescriptor;
+  let _classExtraInitializers = [];
+  let _classThis;
+  let _classSuper = MeterCC;
+  var MeterCCGet2 = class extends _classSuper {
+    static {
+      _classThis = this;
+    }
+    static {
+      const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+      __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+      MeterCCGet2 = _classThis = _classDescriptor.value;
+      if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+      __runInitializers(_classThis, _classExtraInitializers);
+    }
+    constructor(options) {
+      super(options);
+      this.rateType = options.rateType;
+      this.scale = options.scale;
+    }
+    static from(raw, ctx) {
+      let rateType;
+      let scale;
+      if (raw.payload.length >= 1) {
+        rateType = (raw.payload[0] & 192) >>> 6;
+        scale = (raw.payload[0] & 56) >>> 3;
+        if (scale === 7) {
+          (0, import_safe.validatePayload)(raw.payload.length >= 2);
+          scale += raw.payload[1];
+        }
+      }
+      return new this({
+        nodeId: ctx.sourceNodeId,
+        rateType,
+        scale
+      });
+    }
+    rateType;
+    scale;
+    serialize(ctx) {
+      let scale1;
+      let scale2;
+      let bufferLength = 0;
+      const ccVersion = (0, import_CommandClass.getEffectiveCCVersion)(ctx, this);
+      if (this.scale == void 0) {
+        scale1 = 0;
+      } else if (ccVersion >= 4 && this.scale >= 7) {
+        scale1 = 7;
+        scale2 = this.scale >>> 3;
+        bufferLength = 2;
+      } else if (ccVersion >= 3) {
+        scale1 = this.scale & 7;
+        bufferLength = 1;
+      } else if (ccVersion >= 2) {
+        scale1 = this.scale & 3;
+        bufferLength = 1;
+      } else {
+        scale1 = 0;
+      }
+      let rateTypeFlags = 0;
+      if (ccVersion >= 4 && this.rateType != void 0) {
+        rateTypeFlags = this.rateType & 3;
+        bufferLength = Math.max(bufferLength, 1);
+      }
+      this.payload = import_safe2.Bytes.alloc(bufferLength, 0);
+      this.payload[0] = rateTypeFlags << 6 | scale1 << 3;
+      if (scale2)
+        this.payload[1] = scale2;
+      return super.serialize(ctx);
+    }
+    toLogEntry(ctx) {
+      const message = {};
+      if (this.rateType != void 0) {
+        message["rate type"] = (0, import_safe3.getEnumMemberName)(import_Types.RateType, this.rateType);
+      }
+      if (this.scale != void 0) {
+        if (ctx) {
+          const type = this.getValue(ctx, MeterCCValues.type);
+          if (type != void 0) {
+            message.scale = ((0, import_core.getMeterScale)(type, this.scale) ?? (0, import_core.getUnknownMeterScale)(this.scale)).label;
+          }
+        } else {
+          message.scale = this.scale;
+        }
+      }
+      return {
+        ...super.toLogEntry(ctx),
+        message
+      };
+    }
+  };
+  return MeterCCGet2 = _classThis;
+})();
+let MeterCCSupportedReport = (() => {
+  let _classDecorators = [(0, import_CommandClassDecorators.CCCommand)(import_Types.MeterCommand.SupportedReport), (0, import_CommandClassDecorators.ccValueProperty)("type", MeterCCValues.type), (0, import_CommandClassDecorators.ccValueProperty)("supportsReset", MeterCCValues.supportsReset), (0, import_CommandClassDecorators.ccValueProperty)("supportedScales", MeterCCValues.supportedScales), (0, import_CommandClassDecorators.ccValueProperty)("supportedRateTypes", MeterCCValues.supportedRateTypes)];
+  let _classDescriptor;
+  let _classExtraInitializers = [];
+  let _classThis;
+  let _classSuper = MeterCC;
+  var MeterCCSupportedReport2 = class extends _classSuper {
+    static {
+      _classThis = this;
+    }
+    static {
+      const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+      __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+      MeterCCSupportedReport2 = _classThis = _classDescriptor.value;
+      if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+      __runInitializers(_classThis, _classExtraInitializers);
+    }
+    constructor(options) {
+      super(options);
+      this.type = options.type;
+      this.supportsReset = options.supportsReset;
+      this.supportedScales = options.supportedScales;
+      this.supportedRateTypes = options.supportedRateTypes;
+    }
+    static from(raw, ctx) {
+      (0, import_safe.validatePayload)(raw.payload.length >= 2);
+      const type = raw.payload[0] & 31;
+      const supportsReset = !!(raw.payload[0] & 128);
+      const hasMoreScales = !!(raw.payload[1] & 128);
+      let supportedScales;
+      if (hasMoreScales) {
+        (0, import_safe.validatePayload)(raw.payload.length >= 3);
+        const extraBytes = raw.payload[2];
+        (0, import_safe.validatePayload)(raw.payload.length >= 3 + extraBytes);
+        supportedScales = (0, import_safe.parseBitMask)(import_safe2.Bytes.concat([
+          import_safe2.Bytes.from([raw.payload[1] & 127]),
+          raw.payload.subarray(3, 3 + extraBytes)
+        ]), 0).map((scale) => scale >= 8 ? scale - 1 : scale);
+      } else {
+        supportedScales = (0, import_safe.parseBitMask)(import_safe2.Bytes.from([raw.payload[1]]), 0);
+      }
+      const supportedRateTypes = (0, import_safe.parseBitMask)(import_safe2.Bytes.from([(raw.payload[0] & 96) >>> 5]), 1);
+      return new this({
+        nodeId: ctx.sourceNodeId,
+        type,
+        supportsReset,
+        supportedScales,
+        supportedRateTypes
+      });
+    }
+    type;
+    supportsReset;
+    supportedScales;
+    supportedRateTypes;
+    persistValues(ctx) {
+      if (!super.persistValues(ctx))
+        return false;
+      if (!this.supportsReset)
+        return true;
+      const ccVersion = (0, import_CommandClass.getEffectiveCCVersion)(ctx, this);
+      if (ccVersion < 6) {
+        this.ensureMetadata(ctx, MeterCCValues.resetAll);
+      } else {
+        for (const scale of this.supportedScales) {
+          if (!isAccumulatedValue(this.type, scale))
+            continue;
+          for (const rateType of this.supportedRateTypes) {
+            const resetSingleValue = MeterCCValues.resetSingle(this.type, rateType, scale);
+            this.ensureMetadata(ctx, resetSingleValue, {
+              ...resetSingleValue.meta,
+              label: `Reset ${getValueLabel(this.type, scale, rateType)}`
+            });
+          }
+        }
+      }
+      return true;
+    }
+    serialize(ctx) {
+      const typeByte = this.type & 31 | (this.supportedRateTypes.includes(import_Types.RateType.Consumed) ? 32 : 0) | (this.supportedRateTypes.includes(import_Types.RateType.Produced) ? 64 : 0) | (this.supportsReset ? 128 : 0);
+      const supportedScales = (0, import_core.encodeBitMask)(
+        this.supportedScales,
+        void 0,
+        // The first byte only has 7 bits for the bitmask,
+        // so we add a fake bit for the value -1 and later shift
+        // the first byte one to the right
+        -1
+      );
+      const scalesByte1 = supportedScales[0] >>> 1 | (supportedScales.length > 1 ? 128 : 0);
+      this.payload = import_safe2.Bytes.from([
+        typeByte,
+        scalesByte1
+      ]);
+      if (supportedScales.length > 1) {
+        this.payload = import_safe2.Bytes.concat([
+          this.payload,
+          import_safe2.Bytes.from([supportedScales.length - 1]),
+          import_safe2.Bytes.from(supportedScales.subarray(1))
+        ]);
+      }
+      return super.serialize(ctx);
+    }
+    toLogEntry(ctx) {
+      const message = {
+        "meter type": (0, import_core.getMeterName)(this.type),
+        "supports reset": this.supportsReset,
+        "supported scales": `${this.supportedScales.map((scale) => `
+\xB7 ${((0, import_core.getMeterScale)(this.type, scale) ?? (0, import_core.getUnknownMeterScale)(scale)).label}`).join("")}`,
+        "supported rate types": this.supportedRateTypes.map((rt) => (0, import_safe3.getEnumMemberName)(import_Types.RateType, rt)).join(", ")
+      };
+      return {
+        ...super.toLogEntry(ctx),
+        message
+      };
+    }
+  };
+  return MeterCCSupportedReport2 = _classThis;
+})();
+let MeterCCSupportedGet = (() => {
+  let _classDecorators = [(0, import_CommandClassDecorators.CCCommand)(import_Types.MeterCommand.SupportedGet), (0, import_CommandClassDecorators.expectedCCResponse)(MeterCCSupportedReport)];
+  let _classDescriptor;
+  let _classExtraInitializers = [];
+  let _classThis;
+  let _classSuper = MeterCC;
+  var MeterCCSupportedGet2 = class extends _classSuper {
+    static {
+      _classThis = this;
+    }
+    static {
+      const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+      __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+      MeterCCSupportedGet2 = _classThis = _classDescriptor.value;
+      if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+      __runInitializers(_classThis, _classExtraInitializers);
+    }
+  };
+  return MeterCCSupportedGet2 = _classThis;
+})();
+let MeterCCReset = (() => {
+  let _classDecorators = [(0, import_CommandClassDecorators.CCCommand)(import_Types.MeterCommand.Reset), (0, import_CommandClassDecorators.useSupervision)()];
+  let _classDescriptor;
+  let _classExtraInitializers = [];
+  let _classThis;
+  let _classSuper = MeterCC;
+  var MeterCCReset2 = class extends _classSuper {
+    static {
+      _classThis = this;
+    }
+    static {
+      const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+      __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+      MeterCCReset2 = _classThis = _classDescriptor.value;
+      if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+      __runInitializers(_classThis, _classExtraInitializers);
+    }
+    constructor(options) {
+      super(options);
+      this.type = options.type;
+      this.scale = options.scale;
+      this.rateType = options.rateType;
+      this.targetValue = options.targetValue;
+    }
+    static from(raw, ctx) {
+      if (raw.payload.length === 0) {
+        return new this({
+          nodeId: ctx.sourceNodeId
+        });
+      }
+      const { type, rateType, scale1, value: targetValue, bytesRead: scale2Offset } = parseMeterValueAndInfo(raw.payload, 0);
+      const scale = parseScale(scale1, raw.payload, scale2Offset);
+      return new this({
+        nodeId: ctx.sourceNodeId,
+        type,
+        rateType,
+        targetValue,
+        scale
+      });
+    }
+    type;
+    scale;
+    rateType;
+    targetValue;
+    serialize(ctx) {
+      if (this.type != void 0 && this.scale != void 0 && this.rateType != void 0 && this.targetValue != void 0) {
+        const { data: typeAndValue, scale2 } = encodeMeterValueAndInfo(this.type, this.rateType, this.scale, this.targetValue);
+        this.payload = typeAndValue;
+        if (scale2 != void 0) {
+          this.payload = import_safe2.Bytes.concat([
+            this.payload,
+            import_safe2.Bytes.from([scale2])
+          ]);
+        }
+      }
+      return super.serialize(ctx);
+    }
+    toLogEntry(ctx) {
+      const message = {};
+      if (this.type != void 0) {
+        message.type = (0, import_core.getMeterName)(this.type);
+      }
+      if (this.rateType != void 0) {
+        message["rate type"] = (0, import_safe3.getEnumMemberName)(import_Types.RateType, this.rateType);
+      }
+      if (this.type != void 0 && this.scale != void 0) {
+        message.scale = ((0, import_core.getMeterScale)(this.type, this.scale) ?? (0, import_core.getUnknownMeterScale)(this.scale)).label;
+      }
+      if (this.targetValue != void 0) {
+        message["target value"] = this.targetValue;
+      }
+      return {
+        ...super.toLogEntry(ctx),
+        message
+      };
+    }
+  };
+  return MeterCCReset2 = _classThis;
+})();
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MeterCC,
+  MeterCCAPI,
+  MeterCCGet,
+  MeterCCReport,
+  MeterCCReset,
+  MeterCCSupportedGet,
+  MeterCCSupportedReport,
+  MeterCCValues,
+  isAccumulatedValue
+});
+//# sourceMappingURL=MeterCC.js.map