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

package/build/cjs/cc/MeterCC.js

@@ -0,0 +1,1235 @@
+"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 __decorate = function(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var MeterCCReport_1, MeterCCGet_1, MeterCCSupportedReport_1, MeterCCReset_1;
+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 = class MeterCCAPI2 extends import_API.PhysicalCCAPI {
+  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" });
+          }
+        }
+      };
+    }
+  };
+};
+MeterCCAPI = __decorate([
+  (0, import_CommandClassDecorators.API)(import_safe.CommandClasses.Meter)
+], MeterCCAPI);
+let MeterCC = class MeterCC2 extends import_CommandClass.CommandClass {
+  async interview(ctx) {
+    const node = this.getNode(ctx);
+    const endpoint = this.getEndpoint(ctx);
+    const api = import_API.CCAPI.create(import_safe.CommandClasses.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);
+  }
+};
+MeterCC = __decorate([
+  (0, import_CommandClassDecorators.commandClass)(import_safe.CommandClasses.Meter),
+  (0, import_CommandClassDecorators.implementedVersion)(6),
+  (0, import_CommandClassDecorators.ccValues)(MeterCCValues)
+], MeterCC);
+let MeterCCReport = MeterCCReport_1 = class MeterCCReport2 extends MeterCC {
+  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 MeterCCReport_1({
+      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
+    };
+  }
+};
+MeterCCReport = MeterCCReport_1 = __decorate([
+  (0, import_CommandClassDecorators.CCCommand)(import_Types.MeterCommand.Report)
+], MeterCCReport);
+function testResponseForMeterGet(sent, received) {
+  return (sent.scale == void 0 || sent.scale === received.scale) && (sent.rateType == void 0 || sent.rateType == received.rateType);
+}
+let MeterCCGet = MeterCCGet_1 = class MeterCCGet2 extends MeterCC {
+  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 MeterCCGet_1({
+      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
+    };
+  }
+};
+MeterCCGet = MeterCCGet_1 = __decorate([
+  (0, import_CommandClassDecorators.CCCommand)(import_Types.MeterCommand.Get),
+  (0, import_CommandClassDecorators.expectedCCResponse)(MeterCCReport, testResponseForMeterGet)
+], MeterCCGet);
+let MeterCCSupportedReport = MeterCCSupportedReport_1 = class MeterCCSupportedReport2 extends MeterCC {
+  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 MeterCCSupportedReport_1({
+      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
+    };
+  }
+};
+__decorate([
+  (0, import_CommandClassDecorators.ccValue)(MeterCCValues.type)
+], MeterCCSupportedReport.prototype, "type", void 0);
+__decorate([
+  (0, import_CommandClassDecorators.ccValue)(MeterCCValues.supportsReset)
+], MeterCCSupportedReport.prototype, "supportsReset", void 0);
+__decorate([
+  (0, import_CommandClassDecorators.ccValue)(MeterCCValues.supportedScales)
+], MeterCCSupportedReport.prototype, "supportedScales", void 0);
+__decorate([
+  (0, import_CommandClassDecorators.ccValue)(MeterCCValues.supportedRateTypes)
+], MeterCCSupportedReport.prototype, "supportedRateTypes", void 0);
+MeterCCSupportedReport = MeterCCSupportedReport_1 = __decorate([
+  (0, import_CommandClassDecorators.CCCommand)(import_Types.MeterCommand.SupportedReport)
+], MeterCCSupportedReport);
+let MeterCCSupportedGet = class MeterCCSupportedGet2 extends MeterCC {
+};
+MeterCCSupportedGet = __decorate([
+  (0, import_CommandClassDecorators.CCCommand)(import_Types.MeterCommand.SupportedGet),
+  (0, import_CommandClassDecorators.expectedCCResponse)(MeterCCSupportedReport)
+], MeterCCSupportedGet);
+let MeterCCReset = MeterCCReset_1 = class MeterCCReset2 extends MeterCC {
+  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 MeterCCReset_1({
+        nodeId: ctx.sourceNodeId
+      });
+    }
+    const { type, rateType, scale1, value: targetValue, bytesRead: scale2Offset } = parseMeterValueAndInfo(raw.payload, 0);
+    const scale = parseScale(scale1, raw.payload, scale2Offset);
+    return new MeterCCReset_1({
+      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
+    };
+  }
+};
+MeterCCReset = MeterCCReset_1 = __decorate([
+  (0, import_CommandClassDecorators.CCCommand)(import_Types.MeterCommand.Reset),
+  (0, import_CommandClassDecorators.useSupervision)()
+], MeterCCReset);
+// 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