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

package/build/cjs/cc/MeterCC.js

@@ -38,13 +38,45 @@ 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 __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;
 };
-var MeterCCReport_1, MeterCCGet_1, MeterCCSupportedReport_1, MeterCCReset_1;
 function __assertType(argName, typeName, boundHasError) {
   const { ZWaveError, ZWaveErrorCodes } = require("@zwave-js/core");
   if (boundHasError()) {
@@ -449,777 +481,865 @@ function isAccumulatedValue(meterType, scale) {
   }
   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;
-      }
+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;
     }
-    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];
+    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;
         }
-        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"
-        ])
-      };
+      return super.supportsCommand(cmd);
     }
-  }
-  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;
+    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];
           }
-          const response = await this.get({
-            scale,
-            rateType
-          });
-          if (response)
-            ret.push(response);
+          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"
+          ])
+        };
       }
-      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 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 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
-        });
+    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 {
-        return this.reset();
+        const response = await this.get();
+        return response ? [response] : [];
       }
-      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" });
+    }
+    // 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;
       };
-    } else {
-      const valueDB = this.tryGetValueDB();
-      if (!valueDB)
+    }
+    [import_API.SET_VALUE_HOOKS] = ({ property, propertyKey }, _value, _options) => {
+      if (property !== "reset")
         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);
+      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" });
           }
-        },
-        verifyChanges: () => {
-          for (const valueID of accumulatedValues) {
-            this.schedulePoll(valueID, 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) {
+  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: "querying meter support...",
-        direction: "outbound"
+        message: `Interviewing ${this.ccName}...`,
+        direction: "none"
       });
-      const suppResp = await api.getSupported();
-      if (suppResp) {
-        const logMessage = `received meter support:
+      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: logMessage,
-          direction: "inbound"
+          message: `querying default meter value...`,
+          direction: "outbound"
         });
+        await api.get();
       } else {
-        ctx.logNode(node.id, {
-          endpoint: this.endpointIndex,
-          message: "Querying meter support timed out, skipping interview...",
-          level: "warn"
-        });
-        return;
+        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 });
+          }
+        }
       }
     }
-    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"
+    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);
       });
-      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 });
+    }
+    /**
+     * 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);
     }
-  }
-  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 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;
     }
-    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));
+    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;
         }
-        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));
+        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
+      });
     }
-    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
+    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));
+          }
+        }
       }
-    });
-    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
-      ]);
+      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;
     }
-    if (scale2 != void 0) {
+    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([
-        this.payload,
-        import_safe2.Bytes.from([scale2])
+        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);
     }
-    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;
+    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 {
-      ...super.toLogEntry(ctx),
-      message
-    };
-  }
-};
-MeterCCReport = MeterCCReport_1 = __decorate([
-  (0, import_CommandClassDecorators.CCCommand)(import_Types.MeterCommand.Report)
-], MeterCCReport);
+  };
+  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 = 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];
-      }
+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;
     }
-    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;
+    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 {
-        message.scale = this.scale;
+        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);
     }
-    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)}`
-          });
+    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 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 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;
     }
-    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
+    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
       });
     }
-    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) {
+    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([scale2])
+          import_safe2.Bytes.from([supportedScales.length - 1]),
+          import_safe2.Bytes.from(supportedScales.subarray(1))
         ]);
       }
+      return super.serialize(ctx);
     }
-    return super.serialize(ctx);
-  }
-  toLogEntry(ctx) {
-    const message = {};
-    if (this.type != void 0) {
-      message.type = (0, import_core.getMeterName)(this.type);
+    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
+      };
     }
-    if (this.rateType != void 0) {
-      message["rate type"] = (0, import_safe3.getEnumMemberName)(import_Types.RateType, this.rateType);
+  };
+  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;
     }
-    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;
+    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);
     }
-    if (this.targetValue != void 0) {
-      message["target value"] = this.targetValue;
+  };
+  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;
     }
-    return {
-      ...super.toLogEntry(ctx),
-      message
-    };
-  }
-};
-MeterCCReset = MeterCCReset_1 = __decorate([
-  (0, import_CommandClassDecorators.CCCommand)(import_Types.MeterCommand.Reset),
-  (0, import_CommandClassDecorators.useSupervision)()
-], MeterCCReset);
+    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,