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

package/build/cjs/cc/MultiChannelCC.js

@@ -44,13 +44,45 @@ var import_CommandClassDecorators = require("../lib/CommandClassDecorators.js");
 var import_EncapsulatingCommandClass = require("../lib/EncapsulatingCommandClass.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 MultiChannelCCEndPointReport_1, MultiChannelCCCapabilityReport_1, MultiChannelCCCapabilityGet_1, MultiChannelCCEndPointFindReport_1, MultiChannelCCEndPointFind_1, MultiChannelCCAggregatedMembersReport_1, MultiChannelCCCommandEncapsulation_1, MultiChannelCCV1Report_1, MultiChannelCCV1CommandEncapsulation_1;
 function __assertType(argName, typeName, boundHasError) {
   const { ZWaveError: ZWaveError2, ZWaveErrorCodes: ZWaveErrorCodes2 } = require("@zwave-js/core");
   if (boundHasError()) {
@@ -123,713 +155,842 @@ function areEndpointsUnnecessary(ctx, nodeId, endpointIndizes) {
     return false;
   return true;
 }
-let MultiChannelCCAPI = class MultiChannelCCAPI2 extends import_API.CCAPI {
-  supportsCommand(cmd) {
-    switch (cmd) {
-      // Legacy commands:
-      case import_Types.MultiChannelCommand.GetV1:
-        return this.isSinglecast() && this.version === 1;
-      case import_Types.MultiChannelCommand.CommandEncapsulationV1:
-        return this.version === 1;
-      // The specs start at version 3 but according to OZW,
-      // these do seem to be supported in version 2
-      case import_Types.MultiChannelCommand.EndPointGet:
-      case import_Types.MultiChannelCommand.CapabilityGet:
-        return this.version >= 2 && this.isSinglecast();
-      case import_Types.MultiChannelCommand.CommandEncapsulation:
-        return this.version >= 2;
-      case import_Types.MultiChannelCommand.EndPointFind:
-        return this.version >= 3 && this.isSinglecast();
-      case import_Types.MultiChannelCommand.AggregatedMembersGet:
-        return this.version >= 4 && this.isSinglecast();
-    }
-    return super.supportsCommand(cmd);
-  }
-  // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
-  async getEndpoints() {
-    this.assertSupportsCommand(import_Types.MultiChannelCommand, import_Types.MultiChannelCommand.EndPointGet);
-    const cc = new MultiChannelCCEndPointGet({
-      nodeId: this.endpoint.nodeId,
-      endpointIndex: this.endpoint.index
-    });
-    const response = await this.host.sendCommand(cc, this.commandOptions);
-    if (response) {
-      return {
-        isDynamicEndpointCount: response.countIsDynamic,
-        identicalCapabilities: response.identicalCapabilities,
-        individualEndpointCount: response.individualCount,
-        aggregatedEndpointCount: response.aggregatedCount
-      };
+let MultiChannelCCAPI = (() => {
+  let _classDecorators = [(0, import_CommandClassDecorators.API)(import_safe.CommandClasses["Multi Channel"])];
+  let _classDescriptor;
+  let _classExtraInitializers = [];
+  let _classThis;
+  let _classSuper = import_API.CCAPI;
+  var MultiChannelCCAPI2 = class extends _classSuper {
+    static {
+      _classThis = this;
     }
-  }
-  async getEndpointCapabilities(endpoint) {
-    __assertType("endpoint", "number", __assertType__number.bind(void 0, endpoint));
-    this.assertSupportsCommand(import_Types.MultiChannelCommand, import_Types.MultiChannelCommand.CapabilityGet);
-    const cc = new MultiChannelCCCapabilityGet({
-      nodeId: this.endpoint.nodeId,
-      endpointIndex: this.endpoint.index,
-      requestedEndpoint: endpoint
-    });
-    const response = await this.host.sendCommand(cc, this.commandOptions);
-    if (response) {
-      const generic = (0, import_safe.getGenericDeviceClass)(response.genericDeviceClass);
-      const specific = (0, import_safe.getSpecificDeviceClass)(response.genericDeviceClass, response.specificDeviceClass);
-      return {
-        isDynamic: response.isDynamic,
-        wasRemoved: response.wasRemoved,
-        supportedCCs: response.supportedCCs,
-        generic,
-        specific
-      };
+    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);
+      MultiChannelCCAPI2 = _classThis = _classDescriptor.value;
+      if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+      __runInitializers(_classThis, _classExtraInitializers);
     }
-  }
-  async findEndpoints(genericClass, specificClass) {
-    __assertType("genericClass", "number", __assertType__number.bind(void 0, genericClass));
-    __assertType("specificClass", "number", __assertType__number.bind(void 0, specificClass));
-    this.assertSupportsCommand(import_Types.MultiChannelCommand, import_Types.MultiChannelCommand.EndPointFind);
-    const cc = new MultiChannelCCEndPointFind({
-      nodeId: this.endpoint.nodeId,
-      endpointIndex: this.endpoint.index,
-      genericClass,
-      specificClass
-    });
-    const response = await this.host.sendCommand(cc, this.commandOptions);
-    return response?.foundEndpoints;
-  }
-  async getAggregatedMembers(endpoint) {
-    __assertType("endpoint", "number", __assertType__number.bind(void 0, endpoint));
-    this.assertSupportsCommand(import_Types.MultiChannelCommand, import_Types.MultiChannelCommand.AggregatedMembersGet);
-    const cc = new MultiChannelCCAggregatedMembersGet({
-      nodeId: this.endpoint.nodeId,
-      endpointIndex: this.endpoint.index,
-      requestedEndpoint: endpoint
-    });
-    const response = await this.host.sendCommand(cc, this.commandOptions);
-    return response?.members;
-  }
-  // Encapsulation is used internally and too frequently that we
-  // want to pay the cost of validating each call
-  // eslint-disable-next-line @zwave-js/ccapi-validate-args
-  async sendEncapsulated(options) {
-    this.assertSupportsCommand(import_Types.MultiChannelCommand, import_Types.MultiChannelCommand.CommandEncapsulation);
-    const cc = new MultiChannelCCCommandEncapsulation({
-      nodeId: this.endpoint.nodeId,
-      ...options
-    });
-    await this.host.sendCommand(cc, this.commandOptions);
-  }
-  async getEndpointCountV1(ccId) {
-    __assertType("ccId", "CommandClasses", __assertType__number.bind(void 0, ccId));
-    this.assertSupportsCommand(import_Types.MultiChannelCommand, import_Types.MultiChannelCommand.GetV1);
-    const cc = new MultiChannelCCV1Get({
-      nodeId: this.endpoint.nodeId,
-      requestedCC: ccId
-    });
-    const response = await this.host.sendCommand(cc, this.commandOptions);
-    return response?.endpointCount;
-  }
-  // Encapsulation is used internally and too frequently that we
-  // want to pay the cost of validating each call
-  // eslint-disable-next-line @zwave-js/ccapi-validate-args
-  async sendEncapsulatedV1(encapsulated) {
-    this.assertSupportsCommand(import_Types.MultiChannelCommand, import_Types.MultiChannelCommand.CommandEncapsulationV1);
-    const cc = new MultiChannelCCV1CommandEncapsulation({
-      nodeId: this.endpoint.nodeId,
-      encapsulated
-    });
-    await this.host.sendCommand(cc, this.commandOptions);
-  }
-};
-MultiChannelCCAPI = __decorate([
-  (0, import_CommandClassDecorators.API)(import_safe.CommandClasses["Multi Channel"])
-], MultiChannelCCAPI);
-let MultiChannelCC = class MultiChannelCC2 extends import_CommandClass.CommandClass {
-  /** Tests if a command targets a specific endpoint and thus requires encapsulation */
-  static requiresEncapsulation(cc) {
-    return cc.endpointIndex !== 0 && !(cc instanceof MultiChannelCCCommandEncapsulation) && !(cc instanceof MultiChannelCCV1CommandEncapsulation);
-  }
-  /** Encapsulates a command that targets a specific endpoint, with version 2+ of the Multi Channel CC */
-  static encapsulate(cc) {
-    const ret = new MultiChannelCCCommandEncapsulation({
-      nodeId: cc.nodeId,
-      encapsulated: cc,
-      destination: cc.endpointIndex
-    });
-    ret.encapsulationFlags = cc.encapsulationFlags;
-    return ret;
-  }
-  /** Encapsulates a command that targets a specific endpoint, with version 1 of the Multi Channel CC */
-  static encapsulateV1(cc) {
-    const ret = new MultiChannelCCV1CommandEncapsulation({
-      nodeId: cc.nodeId,
-      encapsulated: cc
-    });
-    ret.encapsulationFlags = cc.encapsulationFlags;
-    return ret;
-  }
-  skipEndpointInterview() {
-    return true;
-  }
-  async interview(ctx) {
-    const node = this.getNode(ctx);
-    const removeEndpoints = ctx.getDeviceConfig?.(node.id)?.compat?.removeEndpoints;
-    if (removeEndpoints === "*") {
+    supportsCommand(cmd) {
+      switch (cmd) {
+        // Legacy commands:
+        case import_Types.MultiChannelCommand.GetV1:
+          return this.isSinglecast() && this.version === 1;
+        case import_Types.MultiChannelCommand.CommandEncapsulationV1:
+          return this.version === 1;
+        // The specs start at version 3 but according to OZW,
+        // these do seem to be supported in version 2
+        case import_Types.MultiChannelCommand.EndPointGet:
+        case import_Types.MultiChannelCommand.CapabilityGet:
+          return this.version >= 2 && this.isSinglecast();
+        case import_Types.MultiChannelCommand.CommandEncapsulation:
+          return this.version >= 2;
+        case import_Types.MultiChannelCommand.EndPointFind:
+          return this.version >= 3 && this.isSinglecast();
+        case import_Types.MultiChannelCommand.AggregatedMembersGet:
+          return this.version >= 4 && this.isSinglecast();
+      }
+      return super.supportsCommand(cmd);
+    }
+    // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
+    async getEndpoints() {
+      this.assertSupportsCommand(import_Types.MultiChannelCommand, import_Types.MultiChannelCommand.EndPointGet);
+      const cc = new MultiChannelCCEndPointGet({
+        nodeId: this.endpoint.nodeId,
+        endpointIndex: this.endpoint.index
+      });
+      const response = await this.host.sendCommand(cc, this.commandOptions);
+      if (response) {
+        return {
+          isDynamicEndpointCount: response.countIsDynamic,
+          identicalCapabilities: response.identicalCapabilities,
+          individualEndpointCount: response.individualCount,
+          aggregatedEndpointCount: response.aggregatedCount
+        };
+      }
+    }
+    async getEndpointCapabilities(endpoint) {
+      __assertType("endpoint", "number", __assertType__number.bind(void 0, endpoint));
+      this.assertSupportsCommand(import_Types.MultiChannelCommand, import_Types.MultiChannelCommand.CapabilityGet);
+      const cc = new MultiChannelCCCapabilityGet({
+        nodeId: this.endpoint.nodeId,
+        endpointIndex: this.endpoint.index,
+        requestedEndpoint: endpoint
+      });
+      const response = await this.host.sendCommand(cc, this.commandOptions);
+      if (response) {
+        const generic = (0, import_safe.getGenericDeviceClass)(response.genericDeviceClass);
+        const specific = (0, import_safe.getSpecificDeviceClass)(response.genericDeviceClass, response.specificDeviceClass);
+        return {
+          isDynamic: response.isDynamic,
+          wasRemoved: response.wasRemoved,
+          supportedCCs: response.supportedCCs,
+          generic,
+          specific
+        };
+      }
+    }
+    async findEndpoints(genericClass, specificClass) {
+      __assertType("genericClass", "number", __assertType__number.bind(void 0, genericClass));
+      __assertType("specificClass", "number", __assertType__number.bind(void 0, specificClass));
+      this.assertSupportsCommand(import_Types.MultiChannelCommand, import_Types.MultiChannelCommand.EndPointFind);
+      const cc = new MultiChannelCCEndPointFind({
+        nodeId: this.endpoint.nodeId,
+        endpointIndex: this.endpoint.index,
+        genericClass,
+        specificClass
+      });
+      const response = await this.host.sendCommand(cc, this.commandOptions);
+      return response?.foundEndpoints;
+    }
+    async getAggregatedMembers(endpoint) {
+      __assertType("endpoint", "number", __assertType__number.bind(void 0, endpoint));
+      this.assertSupportsCommand(import_Types.MultiChannelCommand, import_Types.MultiChannelCommand.AggregatedMembersGet);
+      const cc = new MultiChannelCCAggregatedMembersGet({
+        nodeId: this.endpoint.nodeId,
+        endpointIndex: this.endpoint.index,
+        requestedEndpoint: endpoint
+      });
+      const response = await this.host.sendCommand(cc, this.commandOptions);
+      return response?.members;
+    }
+    // Encapsulation is used internally and too frequently that we
+    // want to pay the cost of validating each call
+    // eslint-disable-next-line @zwave-js/ccapi-validate-args
+    async sendEncapsulated(options) {
+      this.assertSupportsCommand(import_Types.MultiChannelCommand, import_Types.MultiChannelCommand.CommandEncapsulation);
+      const cc = new MultiChannelCCCommandEncapsulation({
+        nodeId: this.endpoint.nodeId,
+        ...options
+      });
+      await this.host.sendCommand(cc, this.commandOptions);
+    }
+    async getEndpointCountV1(ccId) {
+      __assertType("ccId", "CommandClasses", __assertType__number.bind(void 0, ccId));
+      this.assertSupportsCommand(import_Types.MultiChannelCommand, import_Types.MultiChannelCommand.GetV1);
+      const cc = new MultiChannelCCV1Get({
+        nodeId: this.endpoint.nodeId,
+        requestedCC: ccId
+      });
+      const response = await this.host.sendCommand(cc, this.commandOptions);
+      return response?.endpointCount;
+    }
+    // Encapsulation is used internally and too frequently that we
+    // want to pay the cost of validating each call
+    // eslint-disable-next-line @zwave-js/ccapi-validate-args
+    async sendEncapsulatedV1(encapsulated) {
+      this.assertSupportsCommand(import_Types.MultiChannelCommand, import_Types.MultiChannelCommand.CommandEncapsulationV1);
+      const cc = new MultiChannelCCV1CommandEncapsulation({
+        nodeId: this.endpoint.nodeId,
+        encapsulated
+      });
+      await this.host.sendCommand(cc, this.commandOptions);
+    }
+  };
+  return MultiChannelCCAPI2 = _classThis;
+})();
+let MultiChannelCC = (() => {
+  let _classDecorators = [(0, import_CommandClassDecorators.commandClass)(import_safe.CommandClasses["Multi Channel"]), (0, import_CommandClassDecorators.implementedVersion)(4), (0, import_CommandClassDecorators.ccValues)(MultiChannelCCValues)];
+  let _classDescriptor;
+  let _classExtraInitializers = [];
+  let _classThis;
+  let _classSuper = import_CommandClass.CommandClass;
+  var MultiChannelCC2 = 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);
+      MultiChannelCC2 = _classThis = _classDescriptor.value;
+      if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+      __runInitializers(_classThis, _classExtraInitializers);
+    }
+    /** Tests if a command targets a specific endpoint and thus requires encapsulation */
+    static requiresEncapsulation(cc) {
+      return cc.endpointIndex !== 0 && !(cc instanceof MultiChannelCCCommandEncapsulation) && !(cc instanceof MultiChannelCCV1CommandEncapsulation);
+    }
+    /** Encapsulates a command that targets a specific endpoint, with version 2+ of the Multi Channel CC */
+    static encapsulate(cc) {
+      const ret = new MultiChannelCCCommandEncapsulation({
+        nodeId: cc.nodeId,
+        encapsulated: cc,
+        destination: cc.endpointIndex
+      });
+      ret.encapsulationFlags = cc.encapsulationFlags;
+      return ret;
+    }
+    /** Encapsulates a command that targets a specific endpoint, with version 1 of the Multi Channel CC */
+    static encapsulateV1(cc) {
+      const ret = new MultiChannelCCV1CommandEncapsulation({
+        nodeId: cc.nodeId,
+        encapsulated: cc
+      });
+      ret.encapsulationFlags = cc.encapsulationFlags;
+      return ret;
+    }
+    skipEndpointInterview() {
+      return true;
+    }
+    async interview(ctx) {
+      const node = this.getNode(ctx);
+      const removeEndpoints = ctx.getDeviceConfig?.(node.id)?.compat?.removeEndpoints;
+      if (removeEndpoints === "*") {
+        ctx.logNode(node.id, {
+          endpoint: this.endpointIndex,
+          message: `Skipping ${this.ccName} interview b/c all endpoints are ignored by the device config file...`,
+          direction: "none"
+        });
+        return;
+      }
       ctx.logNode(node.id, {
         endpoint: this.endpointIndex,
-        message: `Skipping ${this.ccName} interview b/c all endpoints are ignored by the device config file...`,
+        message: `Interviewing ${this.ccName}...`,
         direction: "none"
       });
-      return;
-    }
-    ctx.logNode(node.id, {
-      endpoint: this.endpointIndex,
-      message: `Interviewing ${this.ccName}...`,
-      direction: "none"
-    });
-    const ccVersion = (0, import_CommandClass.getEffectiveCCVersion)(ctx, this);
-    if (ccVersion === 1)
-      return this.interviewV1(ctx);
-    const endpoint = node.getEndpoint(this.endpointIndex);
-    const api = import_API.CCAPI.create(import_safe.CommandClasses["Multi Channel"], ctx, endpoint).withOptions({
-      priority: import_safe.MessagePriority.NodeQuery
-    });
-    const valueDB = this.getValueDB(ctx);
-    ctx.logNode(node.id, {
-      endpoint: this.endpointIndex,
-      message: "querying device endpoint information...",
-      direction: "outbound"
-    });
-    const multiResponse = await api.getEndpoints();
-    if (!multiResponse) {
+      const ccVersion = (0, import_CommandClass.getEffectiveCCVersion)(ctx, this);
+      if (ccVersion === 1)
+        return this.interviewV1(ctx);
+      const endpoint = node.getEndpoint(this.endpointIndex);
+      const api = import_API.CCAPI.create(import_safe.CommandClasses["Multi Channel"], ctx, endpoint).withOptions({
+        priority: import_safe.MessagePriority.NodeQuery
+      });
+      const valueDB = this.getValueDB(ctx);
       ctx.logNode(node.id, {
         endpoint: this.endpointIndex,
-        message: "Querying device endpoint information timed out, aborting interview...",
-        level: "warn"
+        message: "querying device endpoint information...",
+        direction: "outbound"
       });
-      return this.throwMissingCriticalInterviewResponse();
-    }
-    let logMessage = `received response for device endpoints:
+      const multiResponse = await api.getEndpoints();
+      if (!multiResponse) {
+        ctx.logNode(node.id, {
+          endpoint: this.endpointIndex,
+          message: "Querying device endpoint information timed out, aborting interview...",
+          level: "warn"
+        });
+        return this.throwMissingCriticalInterviewResponse();
+      }
+      let logMessage = `received response for device endpoints:
 endpoint count (individual): ${multiResponse.individualEndpointCount}
 count is dynamic:            ${multiResponse.isDynamicEndpointCount}
 identical capabilities:      ${multiResponse.identicalCapabilities}`;
-    if (multiResponse.aggregatedEndpointCount != void 0) {
-      logMessage += `
+      if (multiResponse.aggregatedEndpointCount != void 0) {
+        logMessage += `
 endpoint count (aggregated): ${multiResponse.aggregatedEndpointCount}`;
-    }
-    ctx.logNode(node.id, {
-      endpoint: this.endpointIndex,
-      message: logMessage,
-      direction: "inbound"
-    });
-    let allEndpoints = [];
-    const addSequentialEndpoints = () => {
-      for (let i = 1; i <= multiResponse.individualEndpointCount + (multiResponse.aggregatedEndpointCount ?? 0); i++) {
-        allEndpoints.push(i);
       }
-    };
-    if (api.supportsCommand(import_Types.MultiChannelCommand.EndPointFind)) {
       ctx.logNode(node.id, {
         endpoint: this.endpointIndex,
-        message: "querying all endpoints...",
-        direction: "outbound"
+        message: logMessage,
+        direction: "inbound"
       });
-      const foundEndpoints = await api.findEndpoints(255, 255);
-      if (foundEndpoints)
-        allEndpoints.push(...foundEndpoints);
-      if (!allEndpoints.length) {
+      let allEndpoints = [];
+      const addSequentialEndpoints = () => {
+        for (let i = 1; i <= multiResponse.individualEndpointCount + (multiResponse.aggregatedEndpointCount ?? 0); i++) {
+          allEndpoints.push(i);
+        }
+      };
+      if (api.supportsCommand(import_Types.MultiChannelCommand.EndPointFind)) {
         ctx.logNode(node.id, {
           endpoint: this.endpointIndex,
-          message: `Endpoint query returned no results, assuming that endpoints are sequential`,
-          direction: "inbound"
+          message: "querying all endpoints...",
+          direction: "outbound"
         });
-        addSequentialEndpoints();
+        const foundEndpoints = await api.findEndpoints(255, 255);
+        if (foundEndpoints)
+          allEndpoints.push(...foundEndpoints);
+        if (!allEndpoints.length) {
+          ctx.logNode(node.id, {
+            endpoint: this.endpointIndex,
+            message: `Endpoint query returned no results, assuming that endpoints are sequential`,
+            direction: "inbound"
+          });
+          addSequentialEndpoints();
+        } else {
+          ctx.logNode(node.id, {
+            endpoint: this.endpointIndex,
+            message: `received endpoints: ${allEndpoints.map(String).join(", ")}`,
+            direction: "inbound"
+          });
+        }
       } else {
         ctx.logNode(node.id, {
           endpoint: this.endpointIndex,
-          message: `received endpoints: ${allEndpoints.map(String).join(", ")}`,
-          direction: "inbound"
+          message: `does not support EndPointFind, assuming that endpoints are sequential`,
+          direction: "none"
         });
+        addSequentialEndpoints();
       }
-    } else {
-      ctx.logNode(node.id, {
-        endpoint: this.endpointIndex,
-        message: `does not support EndPointFind, assuming that endpoints are sequential`,
-        direction: "none"
-      });
-      addSequentialEndpoints();
-    }
-    if (removeEndpoints?.length) {
-      ctx.logNode(node.id, {
-        endpoint: this.endpointIndex,
-        message: `The following endpoints are ignored through the config file: ${removeEndpoints.join(", ")}`,
-        direction: "none"
-      });
-      allEndpoints = allEndpoints.filter((e) => !removeEndpoints.includes(e));
-    }
-    let hasQueriedCapabilities = false;
-    for (const endpoint2 of allEndpoints) {
-      if (endpoint2 > multiResponse.individualEndpointCount && ccVersion >= 4) {
+      if (removeEndpoints?.length) {
         ctx.logNode(node.id, {
           endpoint: this.endpointIndex,
-          message: `querying members of aggregated endpoint #${endpoint2}...`,
-          direction: "outbound"
+          message: `The following endpoints are ignored through the config file: ${removeEndpoints.join(", ")}`,
+          direction: "none"
         });
-        const members = await api.getAggregatedMembers(endpoint2);
-        if (members) {
+        allEndpoints = allEndpoints.filter((e) => !removeEndpoints.includes(e));
+      }
+      let hasQueriedCapabilities = false;
+      for (const endpoint2 of allEndpoints) {
+        if (endpoint2 > multiResponse.individualEndpointCount && ccVersion >= 4) {
           ctx.logNode(node.id, {
             endpoint: this.endpointIndex,
-            message: `aggregated endpoint #${endpoint2} has members ${members.map(String).join(", ")}`,
-            direction: "inbound"
+            message: `querying members of aggregated endpoint #${endpoint2}...`,
+            direction: "outbound"
           });
+          const members = await api.getAggregatedMembers(endpoint2);
+          if (members) {
+            ctx.logNode(node.id, {
+              endpoint: this.endpointIndex,
+              message: `aggregated endpoint #${endpoint2} has members ${members.map(String).join(", ")}`,
+              direction: "inbound"
+            });
+          }
+        }
+        if (multiResponse.identicalCapabilities && hasQueriedCapabilities) {
+          ctx.logNode(node.id, {
+            endpoint: this.endpointIndex,
+            message: `all endpoints identical, skipping capability query for endpoint #${endpoint2}...`,
+            direction: "none"
+          });
+          const devClass = valueDB.getValue(MultiChannelCCValues.endpointDeviceClass.endpoint(allEndpoints[0]));
+          valueDB.setValue(MultiChannelCCValues.endpointDeviceClass.endpoint(endpoint2), devClass);
+          const ep1Caps = valueDB.getValue(MultiChannelCCValues.endpointCCs.endpoint(allEndpoints[0]));
+          valueDB.setValue(MultiChannelCCValues.endpointCCs.endpoint(endpoint2), [...ep1Caps]);
+          continue;
         }
-      }
-      if (multiResponse.identicalCapabilities && hasQueriedCapabilities) {
         ctx.logNode(node.id, {
           endpoint: this.endpointIndex,
-          message: `all endpoints identical, skipping capability query for endpoint #${endpoint2}...`,
-          direction: "none"
+          message: `querying capabilities for endpoint #${endpoint2}...`,
+          direction: "outbound"
         });
-        const devClass = valueDB.getValue(MultiChannelCCValues.endpointDeviceClass.endpoint(allEndpoints[0]));
-        valueDB.setValue(MultiChannelCCValues.endpointDeviceClass.endpoint(endpoint2), devClass);
-        const ep1Caps = valueDB.getValue(MultiChannelCCValues.endpointCCs.endpoint(allEndpoints[0]));
-        valueDB.setValue(MultiChannelCCValues.endpointCCs.endpoint(endpoint2), [...ep1Caps]);
-        continue;
-      }
-      ctx.logNode(node.id, {
-        endpoint: this.endpointIndex,
-        message: `querying capabilities for endpoint #${endpoint2}...`,
-        direction: "outbound"
-      });
-      const caps = await api.getEndpointCapabilities(endpoint2);
-      if (caps) {
-        hasQueriedCapabilities = true;
-        logMessage = `received response for endpoint capabilities (#${endpoint2}):
+        const caps = await api.getEndpointCapabilities(endpoint2);
+        if (caps) {
+          hasQueriedCapabilities = true;
+          logMessage = `received response for endpoint capabilities (#${endpoint2}):
 generic device class:  ${caps.generic.label}
 specific device class: ${caps.specific.label}
 is dynamic end point:  ${caps.isDynamic}
 supported CCs:`;
-        for (const cc of caps.supportedCCs) {
-          logMessage += `
+          for (const cc of caps.supportedCCs) {
+            logMessage += `
   \xB7 ${(0, import_safe.getCCName)(cc)}`;
+          }
+          ctx.logNode(node.id, {
+            endpoint: this.endpointIndex,
+            message: logMessage,
+            direction: "inbound"
+          });
+        } else {
+          ctx.logNode(node.id, {
+            endpoint: this.endpointIndex,
+            message: `Querying endpoint #${endpoint2} capabilities timed out, aborting interview...`,
+            level: "warn"
+          });
+          return this.throwMissingCriticalInterviewResponse();
+        }
+      }
+      if (!multiResponse.identicalCapabilities && areEndpointsUnnecessary(ctx, node.id, allEndpoints)) {
+        const preserve = ctx.getDeviceConfig?.(node.id)?.compat?.preserveEndpoints;
+        if (!preserve) {
+          allEndpoints = [];
+          ctx.logNode(node.id, {
+            message: `Endpoints seem unnecessary b/c they have different device classes, ignoring all...`
+          });
+        } else if (preserve === "*") {
+          ctx.logNode(node.id, {
+            message: `Endpoints seem unnecessary, but are configured to be preserved.`
+          });
+        } else {
+          allEndpoints = allEndpoints.filter((ep) => preserve.includes(ep));
+          ctx.logNode(node.id, {
+            message: `Endpoints seem unnecessary, but endpoints ${allEndpoints.join(", ")} are configured to be preserved.`
+          });
         }
-        ctx.logNode(node.id, {
-          endpoint: this.endpointIndex,
-          message: logMessage,
-          direction: "inbound"
-        });
-      } else {
-        ctx.logNode(node.id, {
-          endpoint: this.endpointIndex,
-          message: `Querying endpoint #${endpoint2} capabilities timed out, aborting interview...`,
-          level: "warn"
-        });
-        return this.throwMissingCriticalInterviewResponse();
       }
+      this.setValue(ctx, MultiChannelCCValues.endpointIndizes, allEndpoints);
+      this.setInterviewComplete(ctx, true);
     }
-    if (!multiResponse.identicalCapabilities && areEndpointsUnnecessary(ctx, node.id, allEndpoints)) {
-      const preserve = ctx.getDeviceConfig?.(node.id)?.compat?.preserveEndpoints;
-      if (!preserve) {
-        allEndpoints = [];
+    async interviewV1(ctx) {
+      const node = this.getNode(ctx);
+      const endpoint = this.getEndpoint(ctx);
+      const api = import_API.CCAPI.create(import_safe.CommandClasses["Multi Channel"], ctx, endpoint);
+      const valueDB = this.getValueDB(ctx);
+      const supportedCCs = [...node.getCCs()].filter(([, info]) => info.isSupported).map(([cc]) => cc).filter((cc) => !import_CommandClass.CommandClass.createInstanceUnchecked(node, cc)?.skipEndpointInterview());
+      const endpointCounts = /* @__PURE__ */ new Map();
+      for (const ccId of supportedCCs) {
         ctx.logNode(node.id, {
-          message: `Endpoints seem unnecessary b/c they have different device classes, ignoring all...`
-        });
-      } else if (preserve === "*") {
-        ctx.logNode(node.id, {
-          message: `Endpoints seem unnecessary, but are configured to be preserved.`
-        });
-      } else {
-        allEndpoints = allEndpoints.filter((ep) => preserve.includes(ep));
-        ctx.logNode(node.id, {
-          message: `Endpoints seem unnecessary, but endpoints ${allEndpoints.join(", ")} are configured to be preserved.`
+          message: `Querying endpoint count for CommandClass ${(0, import_safe.getCCName)(ccId)}...`,
+          direction: "outbound"
         });
+        const endpointCount = await api.getEndpointCountV1(ccId);
+        if (endpointCount != void 0) {
+          endpointCounts.set(ccId, endpointCount);
+          ctx.logNode(node.id, {
+            message: `CommandClass ${(0, import_safe.getCCName)(ccId)} has ${endpointCount} endpoints`,
+            direction: "inbound"
+          });
+        }
+      }
+      const numEndpoints = Math.max(...endpointCounts.values());
+      this.setValue(ctx, MultiChannelCCValues.endpointCountIsDynamic, false);
+      this.setValue(ctx, MultiChannelCCValues.aggregatedEndpointCount, 0);
+      this.setValue(ctx, MultiChannelCCValues.individualEndpointCount, numEndpoints);
+      this.setValue(ctx, MultiChannelCCValues.endpointsHaveIdenticalCapabilities, false);
+      for (let endpoint2 = 1; endpoint2 <= numEndpoints; endpoint2++) {
+        const endpointCCs = [...endpointCounts.entries()].filter(([, ccEndpoints]) => ccEndpoints >= endpoint2).map(([ccId]) => ccId);
+        valueDB.setValue(MultiChannelCCValues.endpointCCs.endpoint(endpoint2), endpointCCs);
       }
+      this.setInterviewComplete(ctx, true);
     }
-    this.setValue(ctx, MultiChannelCCValues.endpointIndizes, allEndpoints);
-    this.setInterviewComplete(ctx, true);
-  }
-  async interviewV1(ctx) {
-    const node = this.getNode(ctx);
-    const endpoint = this.getEndpoint(ctx);
-    const api = import_API.CCAPI.create(import_safe.CommandClasses["Multi Channel"], ctx, endpoint);
-    const valueDB = this.getValueDB(ctx);
-    const supportedCCs = [...node.getCCs()].filter(([, info]) => info.isSupported).map(([cc]) => cc).filter((cc) => !import_CommandClass.CommandClass.createInstanceUnchecked(node, cc)?.skipEndpointInterview());
-    const endpointCounts = /* @__PURE__ */ new Map();
-    for (const ccId of supportedCCs) {
-      ctx.logNode(node.id, {
-        message: `Querying endpoint count for CommandClass ${(0, import_safe.getCCName)(ccId)}...`,
-        direction: "outbound"
+  };
+  return MultiChannelCC2 = _classThis;
+})();
+let MultiChannelCCEndPointReport = (() => {
+  let _classDecorators = [(0, import_CommandClassDecorators.CCCommand)(import_Types.MultiChannelCommand.EndPointReport), (0, import_CommandClassDecorators.ccValueProperty)("countIsDynamic", MultiChannelCCValues.endpointCountIsDynamic), (0, import_CommandClassDecorators.ccValueProperty)("identicalCapabilities", MultiChannelCCValues.endpointsHaveIdenticalCapabilities), (0, import_CommandClassDecorators.ccValueProperty)("individualCount", MultiChannelCCValues.individualEndpointCount), (0, import_CommandClassDecorators.ccValueProperty)("aggregatedCount", MultiChannelCCValues.aggregatedEndpointCount)];
+  let _classDescriptor;
+  let _classExtraInitializers = [];
+  let _classThis;
+  let _classSuper = MultiChannelCC;
+  var MultiChannelCCEndPointReport2 = 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);
+      MultiChannelCCEndPointReport2 = _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.countIsDynamic = options.countIsDynamic;
+      this.identicalCapabilities = options.identicalCapabilities;
+      this.individualCount = options.individualCount;
+      this.aggregatedCount = options.aggregatedCount;
+    }
+    static from(raw, ctx) {
+      (0, import_safe.validatePayload)(raw.payload.length >= 2);
+      const countIsDynamic = !!(raw.payload[0] & 128);
+      const identicalCapabilities = !!(raw.payload[0] & 64);
+      const individualCount = raw.payload[1] & 127;
+      let aggregatedCount;
+      if (raw.payload.length >= 3) {
+        aggregatedCount = raw.payload[2] & 127;
+      }
+      return new this({
+        nodeId: ctx.sourceNodeId,
+        countIsDynamic,
+        identicalCapabilities,
+        individualCount,
+        aggregatedCount
       });
-      const endpointCount = await api.getEndpointCountV1(ccId);
-      if (endpointCount != void 0) {
-        endpointCounts.set(ccId, endpointCount);
-        ctx.logNode(node.id, {
-          message: `CommandClass ${(0, import_safe.getCCName)(ccId)} has ${endpointCount} endpoints`,
-          direction: "inbound"
-        });
+    }
+    countIsDynamic;
+    identicalCapabilities;
+    individualCount;
+    aggregatedCount;
+    serialize(ctx) {
+      this.payload = import_safe2.Bytes.from([
+        (this.countIsDynamic ? 128 : 0) | (this.identicalCapabilities ? 64 : 0),
+        this.individualCount & 127,
+        this.aggregatedCount ?? 0
+      ]);
+      return super.serialize(ctx);
+    }
+    toLogEntry(ctx) {
+      const message = {
+        "endpoint count (individual)": this.individualCount,
+        "count is dynamic": this.countIsDynamic,
+        "identical capabilities": this.identicalCapabilities
+      };
+      if (this.aggregatedCount != void 0) {
+        message["endpoint count (aggregated)"] = this.aggregatedCount;
       }
+      const ret = {
+        ...super.toLogEntry(ctx),
+        message
+      };
+      return ret;
     }
-    const numEndpoints = Math.max(...endpointCounts.values());
-    this.setValue(ctx, MultiChannelCCValues.endpointCountIsDynamic, false);
-    this.setValue(ctx, MultiChannelCCValues.aggregatedEndpointCount, 0);
-    this.setValue(ctx, MultiChannelCCValues.individualEndpointCount, numEndpoints);
-    this.setValue(ctx, MultiChannelCCValues.endpointsHaveIdenticalCapabilities, false);
-    for (let endpoint2 = 1; endpoint2 <= numEndpoints; endpoint2++) {
-      const endpointCCs = [...endpointCounts.entries()].filter(([, ccEndpoints]) => ccEndpoints >= endpoint2).map(([ccId]) => ccId);
-      valueDB.setValue(MultiChannelCCValues.endpointCCs.endpoint(endpoint2), endpointCCs);
+  };
+  return MultiChannelCCEndPointReport2 = _classThis;
+})();
+let MultiChannelCCEndPointGet = (() => {
+  let _classDecorators = [(0, import_CommandClassDecorators.CCCommand)(import_Types.MultiChannelCommand.EndPointGet), (0, import_CommandClassDecorators.expectedCCResponse)(MultiChannelCCEndPointReport)];
+  let _classDescriptor;
+  let _classExtraInitializers = [];
+  let _classThis;
+  let _classSuper = MultiChannelCC;
+  var MultiChannelCCEndPointGet2 = class extends _classSuper {
+    static {
+      _classThis = this;
     }
-    this.setInterviewComplete(ctx, true);
-  }
-};
-MultiChannelCC = __decorate([
-  (0, import_CommandClassDecorators.commandClass)(import_safe.CommandClasses["Multi Channel"]),
-  (0, import_CommandClassDecorators.implementedVersion)(4),
-  (0, import_CommandClassDecorators.ccValues)(MultiChannelCCValues)
-], MultiChannelCC);
-let MultiChannelCCEndPointReport = MultiChannelCCEndPointReport_1 = class MultiChannelCCEndPointReport2 extends MultiChannelCC {
-  constructor(options) {
-    super(options);
-    this.countIsDynamic = options.countIsDynamic;
-    this.identicalCapabilities = options.identicalCapabilities;
-    this.individualCount = options.individualCount;
-    this.aggregatedCount = options.aggregatedCount;
-  }
-  static from(raw, ctx) {
-    (0, import_safe.validatePayload)(raw.payload.length >= 2);
-    const countIsDynamic = !!(raw.payload[0] & 128);
-    const identicalCapabilities = !!(raw.payload[0] & 64);
-    const individualCount = raw.payload[1] & 127;
-    let aggregatedCount;
-    if (raw.payload.length >= 3) {
-      aggregatedCount = raw.payload[2] & 127;
-    }
-    return new MultiChannelCCEndPointReport_1({
-      nodeId: ctx.sourceNodeId,
-      countIsDynamic,
-      identicalCapabilities,
-      individualCount,
-      aggregatedCount
-    });
-  }
-  countIsDynamic;
-  identicalCapabilities;
-  individualCount;
-  aggregatedCount;
-  serialize(ctx) {
-    this.payload = import_safe2.Bytes.from([
-      (this.countIsDynamic ? 128 : 0) | (this.identicalCapabilities ? 64 : 0),
-      this.individualCount & 127,
-      this.aggregatedCount ?? 0
-    ]);
-    return super.serialize(ctx);
-  }
-  toLogEntry(ctx) {
-    const message = {
-      "endpoint count (individual)": this.individualCount,
-      "count is dynamic": this.countIsDynamic,
-      "identical capabilities": this.identicalCapabilities
-    };
-    if (this.aggregatedCount != void 0) {
-      message["endpoint count (aggregated)"] = this.aggregatedCount;
+    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);
+      MultiChannelCCEndPointGet2 = _classThis = _classDescriptor.value;
+      if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+      __runInitializers(_classThis, _classExtraInitializers);
     }
-    const ret = {
-      ...super.toLogEntry(ctx),
-      message
-    };
-    return ret;
-  }
-};
-__decorate([
-  (0, import_CommandClassDecorators.ccValue)(MultiChannelCCValues.endpointCountIsDynamic)
-], MultiChannelCCEndPointReport.prototype, "countIsDynamic", void 0);
-__decorate([
-  (0, import_CommandClassDecorators.ccValue)(MultiChannelCCValues.endpointsHaveIdenticalCapabilities)
-], MultiChannelCCEndPointReport.prototype, "identicalCapabilities", void 0);
-__decorate([
-  (0, import_CommandClassDecorators.ccValue)(MultiChannelCCValues.individualEndpointCount)
-], MultiChannelCCEndPointReport.prototype, "individualCount", void 0);
-__decorate([
-  (0, import_CommandClassDecorators.ccValue)(MultiChannelCCValues.aggregatedEndpointCount)
-], MultiChannelCCEndPointReport.prototype, "aggregatedCount", void 0);
-MultiChannelCCEndPointReport = MultiChannelCCEndPointReport_1 = __decorate([
-  (0, import_CommandClassDecorators.CCCommand)(import_Types.MultiChannelCommand.EndPointReport)
-], MultiChannelCCEndPointReport);
-let MultiChannelCCEndPointGet = class MultiChannelCCEndPointGet2 extends MultiChannelCC {
-};
-MultiChannelCCEndPointGet = __decorate([
-  (0, import_CommandClassDecorators.CCCommand)(import_Types.MultiChannelCommand.EndPointGet),
-  (0, import_CommandClassDecorators.expectedCCResponse)(MultiChannelCCEndPointReport)
-], MultiChannelCCEndPointGet);
-let MultiChannelCCCapabilityReport = MultiChannelCCCapabilityReport_1 = class MultiChannelCCCapabilityReport2 extends MultiChannelCC {
-  constructor(options) {
-    super(options);
-    this.endpointIndex = options.endpointIndex;
-    this.genericDeviceClass = options.genericDeviceClass;
-    this.specificDeviceClass = options.specificDeviceClass;
-    this.supportedCCs = options.supportedCCs;
-    this.isDynamic = options.isDynamic;
-    this.wasRemoved = options.wasRemoved;
-  }
-  static from(raw, ctx) {
-    (0, import_safe.validatePayload)(raw.payload.length >= 1);
-    const endpointIndex = raw.payload[0] & 127;
-    const isDynamic = !!(raw.payload[0] & 128);
-    const NIF = (0, import_safe.parseApplicationNodeInformation)(raw.payload.subarray(1));
-    const genericDeviceClass = NIF.genericDeviceClass;
-    const specificDeviceClass = NIF.specificDeviceClass;
-    const supportedCCs = NIF.supportedCCs;
-    const wasRemoved = isDynamic && genericDeviceClass === 255 && specificDeviceClass === 0;
-    return new MultiChannelCCCapabilityReport_1({
-      nodeId: ctx.sourceNodeId,
-      endpointIndex,
-      isDynamic,
-      genericDeviceClass,
-      specificDeviceClass,
-      supportedCCs,
-      wasRemoved
-    });
-  }
-  persistValues(ctx) {
-    if (!super.persistValues(ctx))
-      return false;
-    const deviceClassValue = MultiChannelCCValues.endpointDeviceClass;
-    const ccsValue = MultiChannelCCValues.endpointCCs;
-    if (this.wasRemoved) {
-      this.removeValue(ctx, deviceClassValue);
-      this.removeValue(ctx, ccsValue);
-    } else {
-      this.setValue(ctx, deviceClassValue, {
-        generic: this.genericDeviceClass,
-        specific: this.specificDeviceClass
+  };
+  return MultiChannelCCEndPointGet2 = _classThis;
+})();
+let MultiChannelCCCapabilityReport = (() => {
+  let _classDecorators = [(0, import_CommandClassDecorators.CCCommand)(import_Types.MultiChannelCommand.CapabilityReport)];
+  let _classDescriptor;
+  let _classExtraInitializers = [];
+  let _classThis;
+  let _classSuper = MultiChannelCC;
+  var MultiChannelCCCapabilityReport2 = 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);
+      MultiChannelCCCapabilityReport2 = _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.endpointIndex = options.endpointIndex;
+      this.genericDeviceClass = options.genericDeviceClass;
+      this.specificDeviceClass = options.specificDeviceClass;
+      this.supportedCCs = options.supportedCCs;
+      this.isDynamic = options.isDynamic;
+      this.wasRemoved = options.wasRemoved;
+    }
+    static from(raw, ctx) {
+      (0, import_safe.validatePayload)(raw.payload.length >= 1);
+      const endpointIndex = raw.payload[0] & 127;
+      const isDynamic = !!(raw.payload[0] & 128);
+      const NIF = (0, import_safe.parseApplicationNodeInformation)(raw.payload.subarray(1));
+      const genericDeviceClass = NIF.genericDeviceClass;
+      const specificDeviceClass = NIF.specificDeviceClass;
+      const supportedCCs = NIF.supportedCCs;
+      const wasRemoved = isDynamic && genericDeviceClass === 255 && specificDeviceClass === 0;
+      return new this({
+        nodeId: ctx.sourceNodeId,
+        endpointIndex,
+        isDynamic,
+        genericDeviceClass,
+        specificDeviceClass,
+        supportedCCs,
+        wasRemoved
       });
-      this.setValue(ctx, ccsValue, this.supportedCCs);
     }
-    return true;
-  }
-  // The endpoint index must be overridden to be able to attribute the information to the correct endpoint
-  genericDeviceClass;
-  specificDeviceClass;
-  supportedCCs;
-  isDynamic;
-  wasRemoved;
-  serialize(ctx) {
-    this.payload = import_safe2.Bytes.concat([
-      import_safe2.Bytes.from([
-        this.endpointIndex & 127 | (this.isDynamic ? 128 : 0)
-      ]),
-      (0, import_safe.encodeApplicationNodeInformation)(this)
-    ]);
-    return super.serialize(ctx);
-  }
-  toLogEntry(ctx) {
-    return {
-      ...super.toLogEntry(ctx),
-      message: {
-        "endpoint index": this.endpointIndex,
-        "generic device class": (0, import_safe.getGenericDeviceClass)(this.genericDeviceClass).label,
-        "specific device class": (0, import_safe.getSpecificDeviceClass)(this.genericDeviceClass, this.specificDeviceClass).label,
-        "is dynamic end point": this.isDynamic,
-        "supported CCs": this.supportedCCs.map((cc) => `
-\xB7 ${(0, import_safe.getCCName)(cc)}`).join("")
+    persistValues(ctx) {
+      if (!super.persistValues(ctx))
+        return false;
+      const deviceClassValue = MultiChannelCCValues.endpointDeviceClass;
+      const ccsValue = MultiChannelCCValues.endpointCCs;
+      if (this.wasRemoved) {
+        this.removeValue(ctx, deviceClassValue);
+        this.removeValue(ctx, ccsValue);
+      } else {
+        this.setValue(ctx, deviceClassValue, {
+          generic: this.genericDeviceClass,
+          specific: this.specificDeviceClass
+        });
+        this.setValue(ctx, ccsValue, this.supportedCCs);
       }
-    };
-  }
-};
-MultiChannelCCCapabilityReport = MultiChannelCCCapabilityReport_1 = __decorate([
-  (0, import_CommandClassDecorators.CCCommand)(import_Types.MultiChannelCommand.CapabilityReport)
-], MultiChannelCCCapabilityReport);
+      return true;
+    }
+    // The endpoint index must be overridden to be able to attribute the information to the correct endpoint
+    genericDeviceClass;
+    specificDeviceClass;
+    supportedCCs;
+    isDynamic;
+    wasRemoved;
+    serialize(ctx) {
+      this.payload = import_safe2.Bytes.concat([
+        import_safe2.Bytes.from([
+          this.endpointIndex & 127 | (this.isDynamic ? 128 : 0)
+        ]),
+        (0, import_safe.encodeApplicationNodeInformation)(this)
+      ]);
+      return super.serialize(ctx);
+    }
+    toLogEntry(ctx) {
+      return {
+        ...super.toLogEntry(ctx),
+        message: {
+          "endpoint index": this.endpointIndex,
+          "generic device class": (0, import_safe.getGenericDeviceClass)(this.genericDeviceClass).label,
+          "specific device class": (0, import_safe.getSpecificDeviceClass)(this.genericDeviceClass, this.specificDeviceClass).label,
+          "is dynamic end point": this.isDynamic,
+          "supported CCs": this.supportedCCs.map((cc) => `
+\xB7 ${(0, import_safe.getCCName)(cc)}`).join("")
+        }
+      };
+    }
+  };
+  return MultiChannelCCCapabilityReport2 = _classThis;
+})();
 function testResponseForMultiChannelCapabilityGet(sent, received) {
   return received.endpointIndex === sent.requestedEndpoint;
 }
-let MultiChannelCCCapabilityGet = MultiChannelCCCapabilityGet_1 = class MultiChannelCCCapabilityGet2 extends MultiChannelCC {
-  constructor(options) {
-    super(options);
-    this.requestedEndpoint = options.requestedEndpoint;
-  }
-  static from(raw, ctx) {
-    (0, import_safe.validatePayload)(raw.payload.length >= 1);
-    const requestedEndpoint = raw.payload[0] & 127;
-    return new MultiChannelCCCapabilityGet_1({
-      nodeId: ctx.sourceNodeId,
-      requestedEndpoint
-    });
-  }
-  requestedEndpoint;
-  serialize(ctx) {
-    this.payload = import_safe2.Bytes.from([this.requestedEndpoint & 127]);
-    return super.serialize(ctx);
-  }
-  toLogEntry(ctx) {
-    return {
-      ...super.toLogEntry(ctx),
-      message: { endpoint: this.requestedEndpoint }
-    };
-  }
-};
-MultiChannelCCCapabilityGet = MultiChannelCCCapabilityGet_1 = __decorate([
-  (0, import_CommandClassDecorators.CCCommand)(import_Types.MultiChannelCommand.CapabilityGet),
-  (0, import_CommandClassDecorators.expectedCCResponse)(MultiChannelCCCapabilityReport, testResponseForMultiChannelCapabilityGet)
-], MultiChannelCCCapabilityGet);
-let MultiChannelCCEndPointFindReport = MultiChannelCCEndPointFindReport_1 = class MultiChannelCCEndPointFindReport2 extends MultiChannelCC {
-  constructor(options) {
-    super(options);
-    this.genericClass = options.genericClass;
-    this.specificClass = options.specificClass;
-    this.foundEndpoints = options.foundEndpoints;
-    this.reportsToFollow = options.reportsToFollow;
-  }
-  static from(raw, ctx) {
-    (0, import_safe.validatePayload)(raw.payload.length >= 3);
-    const reportsToFollow = raw.payload[0];
-    const genericClass = raw.payload[1];
-    const specificClass = raw.payload[2];
-    const foundEndpoints = [...raw.payload.subarray(3)].map((e) => e & 127).filter((e) => e !== 0);
-    return new MultiChannelCCEndPointFindReport_1({
-      nodeId: ctx.sourceNodeId,
-      reportsToFollow,
-      genericClass,
-      specificClass,
-      foundEndpoints
-    });
-  }
-  genericClass;
-  specificClass;
-  foundEndpoints;
-  reportsToFollow;
-  serialize(ctx) {
-    this.payload = import_safe2.Bytes.concat([
-      import_safe2.Bytes.from([
-        this.reportsToFollow,
-        this.genericClass,
-        this.specificClass
-      ]),
-      import_safe2.Bytes.from(this.foundEndpoints.map((e) => e & 127))
-    ]);
-    return super.serialize(ctx);
-  }
-  getPartialCCSessionId() {
-    return {
-      genericClass: this.genericClass,
-      specificClass: this.specificClass
-    };
-  }
-  expectMoreMessages() {
-    return this.reportsToFollow > 0;
-  }
-  mergePartialCCs(partials, _ctx) {
-    this.foundEndpoints = [...partials, this].map((report) => report.foundEndpoints).reduce((prev, cur) => prev.concat(...cur), []);
-  }
-  toLogEntry(ctx) {
-    return {
-      ...super.toLogEntry(ctx),
-      message: {
-        "generic device class": (0, import_safe.getGenericDeviceClass)(this.genericClass).label,
-        "specific device class": (0, import_safe.getSpecificDeviceClass)(this.genericClass, this.specificClass).label,
-        "found endpoints": this.foundEndpoints.join(", "),
-        "# of reports to follow": this.reportsToFollow
-      }
-    };
-  }
-};
-MultiChannelCCEndPointFindReport = MultiChannelCCEndPointFindReport_1 = __decorate([
-  (0, import_CommandClassDecorators.CCCommand)(import_Types.MultiChannelCommand.EndPointFindReport)
-], MultiChannelCCEndPointFindReport);
-let MultiChannelCCEndPointFind = MultiChannelCCEndPointFind_1 = class MultiChannelCCEndPointFind2 extends MultiChannelCC {
-  constructor(options) {
-    super(options);
-    this.genericClass = options.genericClass;
-    this.specificClass = options.specificClass;
-  }
-  static from(raw, ctx) {
-    (0, import_safe.validatePayload)(raw.payload.length >= 2);
-    const genericClass = raw.payload[0];
-    const specificClass = raw.payload[1];
-    return new MultiChannelCCEndPointFind_1({
-      nodeId: ctx.sourceNodeId,
-      genericClass,
-      specificClass
-    });
-  }
-  genericClass;
-  specificClass;
-  serialize(ctx) {
-    this.payload = import_safe2.Bytes.from([this.genericClass, this.specificClass]);
-    return super.serialize(ctx);
-  }
-  toLogEntry(ctx) {
-    return {
-      ...super.toLogEntry(ctx),
-      message: {
-        "generic device class": (0, import_safe.getGenericDeviceClass)(this.genericClass).label,
-        "specific device class": (0, import_safe.getSpecificDeviceClass)(this.genericClass, this.specificClass).label
-      }
-    };
-  }
-};
-MultiChannelCCEndPointFind = MultiChannelCCEndPointFind_1 = __decorate([
-  (0, import_CommandClassDecorators.CCCommand)(import_Types.MultiChannelCommand.EndPointFind),
-  (0, import_CommandClassDecorators.expectedCCResponse)(MultiChannelCCEndPointFindReport)
-], MultiChannelCCEndPointFind);
-let MultiChannelCCAggregatedMembersReport = MultiChannelCCAggregatedMembersReport_1 = class MultiChannelCCAggregatedMembersReport2 extends MultiChannelCC {
-  constructor(options) {
-    super(options);
-    this.aggregatedEndpointIndex = options.aggregatedEndpointIndex;
-    this.members = options.members;
-  }
-  static from(raw, ctx) {
-    (0, import_safe.validatePayload)(raw.payload.length >= 2);
-    const aggregatedEndpointIndex = raw.payload[0] & 127;
-    const bitMaskLength = raw.payload[1];
-    (0, import_safe.validatePayload)(raw.payload.length >= 2 + bitMaskLength);
-    const bitMask = raw.payload.subarray(2, 2 + bitMaskLength);
-    const members = (0, import_safe.parseBitMask)(bitMask);
-    return new MultiChannelCCAggregatedMembersReport_1({
-      nodeId: ctx.sourceNodeId,
-      aggregatedEndpointIndex,
-      members
-    });
-  }
-  aggregatedEndpointIndex;
-  members;
-  toLogEntry(ctx) {
-    return {
-      ...super.toLogEntry(ctx),
-      message: {
-        "aggregated endpoint": this.aggregatedEndpointIndex,
-        members: this.members.join(", ")
-      }
-    };
-  }
-};
-__decorate([
-  (0, import_CommandClassDecorators.ccValue)(MultiChannelCCValues.aggregatedEndpointMembers, (self) => [self.aggregatedEndpointIndex])
-], MultiChannelCCAggregatedMembersReport.prototype, "members", void 0);
-MultiChannelCCAggregatedMembersReport = MultiChannelCCAggregatedMembersReport_1 = __decorate([
-  (0, import_CommandClassDecorators.CCCommand)(import_Types.MultiChannelCommand.AggregatedMembersReport)
-], MultiChannelCCAggregatedMembersReport);
-let MultiChannelCCAggregatedMembersGet = class MultiChannelCCAggregatedMembersGet2 extends MultiChannelCC {
-  constructor(options) {
-    super(options);
-    this.requestedEndpoint = options.requestedEndpoint;
-  }
-  static from(_raw, _ctx) {
-    throw new import_safe.ZWaveError(`${this.name}: deserialization not implemented`, import_safe.ZWaveErrorCodes.Deserialization_NotImplemented);
-  }
-  requestedEndpoint;
-  serialize(ctx) {
-    this.payload = import_safe2.Bytes.from([this.requestedEndpoint & 127]);
-    return super.serialize(ctx);
-  }
-  toLogEntry(ctx) {
-    return {
-      ...super.toLogEntry(ctx),
-      message: { endpoint: this.requestedEndpoint }
-    };
-  }
-};
-MultiChannelCCAggregatedMembersGet = __decorate([
-  (0, import_CommandClassDecorators.CCCommand)(import_Types.MultiChannelCommand.AggregatedMembersGet),
-  (0, import_CommandClassDecorators.expectedCCResponse)(MultiChannelCCAggregatedMembersReport)
-], MultiChannelCCAggregatedMembersGet);
+let MultiChannelCCCapabilityGet = (() => {
+  let _classDecorators = [(0, import_CommandClassDecorators.CCCommand)(import_Types.MultiChannelCommand.CapabilityGet), (0, import_CommandClassDecorators.expectedCCResponse)(MultiChannelCCCapabilityReport, testResponseForMultiChannelCapabilityGet)];
+  let _classDescriptor;
+  let _classExtraInitializers = [];
+  let _classThis;
+  let _classSuper = MultiChannelCC;
+  var MultiChannelCCCapabilityGet2 = 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);
+      MultiChannelCCCapabilityGet2 = _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.requestedEndpoint = options.requestedEndpoint;
+    }
+    static from(raw, ctx) {
+      (0, import_safe.validatePayload)(raw.payload.length >= 1);
+      const requestedEndpoint = raw.payload[0] & 127;
+      return new this({
+        nodeId: ctx.sourceNodeId,
+        requestedEndpoint
+      });
+    }
+    requestedEndpoint;
+    serialize(ctx) {
+      this.payload = import_safe2.Bytes.from([this.requestedEndpoint & 127]);
+      return super.serialize(ctx);
+    }
+    toLogEntry(ctx) {
+      return {
+        ...super.toLogEntry(ctx),
+        message: { endpoint: this.requestedEndpoint }
+      };
+    }
+  };
+  return MultiChannelCCCapabilityGet2 = _classThis;
+})();
+let MultiChannelCCEndPointFindReport = (() => {
+  let _classDecorators = [(0, import_CommandClassDecorators.CCCommand)(import_Types.MultiChannelCommand.EndPointFindReport)];
+  let _classDescriptor;
+  let _classExtraInitializers = [];
+  let _classThis;
+  let _classSuper = MultiChannelCC;
+  var MultiChannelCCEndPointFindReport2 = 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);
+      MultiChannelCCEndPointFindReport2 = _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.genericClass = options.genericClass;
+      this.specificClass = options.specificClass;
+      this.foundEndpoints = options.foundEndpoints;
+      this.reportsToFollow = options.reportsToFollow;
+    }
+    static from(raw, ctx) {
+      (0, import_safe.validatePayload)(raw.payload.length >= 3);
+      const reportsToFollow = raw.payload[0];
+      const genericClass = raw.payload[1];
+      const specificClass = raw.payload[2];
+      const foundEndpoints = [...raw.payload.subarray(3)].map((e) => e & 127).filter((e) => e !== 0);
+      return new this({
+        nodeId: ctx.sourceNodeId,
+        reportsToFollow,
+        genericClass,
+        specificClass,
+        foundEndpoints
+      });
+    }
+    genericClass;
+    specificClass;
+    foundEndpoints;
+    reportsToFollow;
+    serialize(ctx) {
+      this.payload = import_safe2.Bytes.concat([
+        import_safe2.Bytes.from([
+          this.reportsToFollow,
+          this.genericClass,
+          this.specificClass
+        ]),
+        import_safe2.Bytes.from(this.foundEndpoints.map((e) => e & 127))
+      ]);
+      return super.serialize(ctx);
+    }
+    getPartialCCSessionId() {
+      return {
+        genericClass: this.genericClass,
+        specificClass: this.specificClass
+      };
+    }
+    expectMoreMessages() {
+      return this.reportsToFollow > 0;
+    }
+    mergePartialCCs(partials, _ctx) {
+      this.foundEndpoints = [...partials, this].map((report) => report.foundEndpoints).reduce((prev, cur) => prev.concat(...cur), []);
+    }
+    toLogEntry(ctx) {
+      return {
+        ...super.toLogEntry(ctx),
+        message: {
+          "generic device class": (0, import_safe.getGenericDeviceClass)(this.genericClass).label,
+          "specific device class": (0, import_safe.getSpecificDeviceClass)(this.genericClass, this.specificClass).label,
+          "found endpoints": this.foundEndpoints.join(", "),
+          "# of reports to follow": this.reportsToFollow
+        }
+      };
+    }
+  };
+  return MultiChannelCCEndPointFindReport2 = _classThis;
+})();
+let MultiChannelCCEndPointFind = (() => {
+  let _classDecorators = [(0, import_CommandClassDecorators.CCCommand)(import_Types.MultiChannelCommand.EndPointFind), (0, import_CommandClassDecorators.expectedCCResponse)(MultiChannelCCEndPointFindReport)];
+  let _classDescriptor;
+  let _classExtraInitializers = [];
+  let _classThis;
+  let _classSuper = MultiChannelCC;
+  var MultiChannelCCEndPointFind2 = 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);
+      MultiChannelCCEndPointFind2 = _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.genericClass = options.genericClass;
+      this.specificClass = options.specificClass;
+    }
+    static from(raw, ctx) {
+      (0, import_safe.validatePayload)(raw.payload.length >= 2);
+      const genericClass = raw.payload[0];
+      const specificClass = raw.payload[1];
+      return new this({
+        nodeId: ctx.sourceNodeId,
+        genericClass,
+        specificClass
+      });
+    }
+    genericClass;
+    specificClass;
+    serialize(ctx) {
+      this.payload = import_safe2.Bytes.from([this.genericClass, this.specificClass]);
+      return super.serialize(ctx);
+    }
+    toLogEntry(ctx) {
+      return {
+        ...super.toLogEntry(ctx),
+        message: {
+          "generic device class": (0, import_safe.getGenericDeviceClass)(this.genericClass).label,
+          "specific device class": (0, import_safe.getSpecificDeviceClass)(this.genericClass, this.specificClass).label
+        }
+      };
+    }
+  };
+  return MultiChannelCCEndPointFind2 = _classThis;
+})();
+let MultiChannelCCAggregatedMembersReport = (() => {
+  let _classDecorators = [(0, import_CommandClassDecorators.CCCommand)(import_Types.MultiChannelCommand.AggregatedMembersReport), (0, import_CommandClassDecorators.ccValueProperty)("members", MultiChannelCCValues.aggregatedEndpointMembers, (self) => [self.aggregatedEndpointIndex])];
+  let _classDescriptor;
+  let _classExtraInitializers = [];
+  let _classThis;
+  let _classSuper = MultiChannelCC;
+  var MultiChannelCCAggregatedMembersReport2 = 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);
+      MultiChannelCCAggregatedMembersReport2 = _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.aggregatedEndpointIndex = options.aggregatedEndpointIndex;
+      this.members = options.members;
+    }
+    static from(raw, ctx) {
+      (0, import_safe.validatePayload)(raw.payload.length >= 2);
+      const aggregatedEndpointIndex = raw.payload[0] & 127;
+      const bitMaskLength = raw.payload[1];
+      (0, import_safe.validatePayload)(raw.payload.length >= 2 + bitMaskLength);
+      const bitMask = raw.payload.subarray(2, 2 + bitMaskLength);
+      const members = (0, import_safe.parseBitMask)(bitMask);
+      return new this({
+        nodeId: ctx.sourceNodeId,
+        aggregatedEndpointIndex,
+        members
+      });
+    }
+    aggregatedEndpointIndex;
+    members;
+    toLogEntry(ctx) {
+      return {
+        ...super.toLogEntry(ctx),
+        message: {
+          "aggregated endpoint": this.aggregatedEndpointIndex,
+          members: this.members.join(", ")
+        }
+      };
+    }
+  };
+  return MultiChannelCCAggregatedMembersReport2 = _classThis;
+})();
+let MultiChannelCCAggregatedMembersGet = (() => {
+  let _classDecorators = [(0, import_CommandClassDecorators.CCCommand)(import_Types.MultiChannelCommand.AggregatedMembersGet), (0, import_CommandClassDecorators.expectedCCResponse)(MultiChannelCCAggregatedMembersReport)];
+  let _classDescriptor;
+  let _classExtraInitializers = [];
+  let _classThis;
+  let _classSuper = MultiChannelCC;
+  var MultiChannelCCAggregatedMembersGet2 = 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);
+      MultiChannelCCAggregatedMembersGet2 = _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.requestedEndpoint = options.requestedEndpoint;
+    }
+    static from(_raw, _ctx) {
+      throw new import_safe.ZWaveError(`${this.name}: deserialization not implemented`, import_safe.ZWaveErrorCodes.Deserialization_NotImplemented);
+    }
+    requestedEndpoint;
+    serialize(ctx) {
+      this.payload = import_safe2.Bytes.from([this.requestedEndpoint & 127]);
+      return super.serialize(ctx);
+    }
+    toLogEntry(ctx) {
+      return {
+        ...super.toLogEntry(ctx),
+        message: { endpoint: this.requestedEndpoint }
+      };
+    }
+  };
+  return MultiChannelCCAggregatedMembersGet2 = _classThis;
+})();
 function getCCResponseForCommandEncapsulation(sent) {
   if (typeof sent.destination === "number" && sent.encapsulated.expectsCCResponse()) {
     return [
@@ -844,141 +1005,184 @@ function testResponseForCommandEncapsulation(sent, received) {
   }
   return false;
 }
-let MultiChannelCCCommandEncapsulation = MultiChannelCCCommandEncapsulation_1 = class MultiChannelCCCommandEncapsulation2 extends MultiChannelCC {
-  constructor(options) {
-    super(options);
-    this.encapsulated = options.encapsulated;
-    this.encapsulated.encapsulatingCC = this;
-    let cur = this;
-    while (cur) {
-      if ((0, import_EncapsulatingCommandClass.isMultiEncapsulatingCommandClass)(cur)) {
-        for (const cc of cur.encapsulated) {
-          cc.endpointIndex = this.endpointIndex;
+let MultiChannelCCCommandEncapsulation = (() => {
+  let _classDecorators = [(0, import_CommandClassDecorators.CCCommand)(import_Types.MultiChannelCommand.CommandEncapsulation), (0, import_CommandClassDecorators.expectedCCResponse)(getCCResponseForCommandEncapsulation, testResponseForCommandEncapsulation)];
+  let _classDescriptor;
+  let _classExtraInitializers = [];
+  let _classThis;
+  let _classSuper = MultiChannelCC;
+  var MultiChannelCCCommandEncapsulation2 = 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);
+      MultiChannelCCCommandEncapsulation2 = _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.encapsulated = options.encapsulated;
+      this.encapsulated.encapsulatingCC = this;
+      let cur = this;
+      while (cur) {
+        if ((0, import_EncapsulatingCommandClass.isMultiEncapsulatingCommandClass)(cur)) {
+          for (const cc of cur.encapsulated) {
+            cc.endpointIndex = this.endpointIndex;
+          }
+          break;
+        } else if ((0, import_EncapsulatingCommandClass.isEncapsulatingCommandClass)(cur)) {
+          cur.encapsulated.endpointIndex = this.endpointIndex;
+          cur = cur.encapsulated;
+        } else {
+          break;
         }
-        break;
-      } else if ((0, import_EncapsulatingCommandClass.isEncapsulatingCommandClass)(cur)) {
-        cur.encapsulated.endpointIndex = this.endpointIndex;
-        cur = cur.encapsulated;
-      } else {
-        break;
       }
+      this.destination = options.destination;
     }
-    this.destination = options.destination;
-  }
-  static from(raw, ctx) {
-    (0, import_safe.validatePayload)(raw.payload.length >= 2);
-    let endpointIndex;
-    let destination;
-    if (ctx.getDeviceConfig?.(ctx.sourceNodeId)?.compat?.treatDestinationEndpointAsSource) {
-      endpointIndex = raw.payload[1] & 127;
-      destination = 0;
-    } else {
-      endpointIndex = raw.payload[0] & 127;
-      const isBitMask = !!(raw.payload[1] & 128);
-      destination = raw.payload[1] & 127;
-      if (isBitMask) {
-        destination = (0, import_safe.parseBitMask)(import_safe2.Bytes.from([destination]));
+    static from(raw, ctx) {
+      (0, import_safe.validatePayload)(raw.payload.length >= 2);
+      let endpointIndex;
+      let destination;
+      if (ctx.getDeviceConfig?.(ctx.sourceNodeId)?.compat?.treatDestinationEndpointAsSource) {
+        endpointIndex = raw.payload[1] & 127;
+        destination = 0;
+      } else {
+        endpointIndex = raw.payload[0] & 127;
+        const isBitMask = !!(raw.payload[1] & 128);
+        destination = raw.payload[1] & 127;
+        if (isBitMask) {
+          destination = (0, import_safe.parseBitMask)(import_safe2.Bytes.from([destination]));
+        }
       }
+      const encapsulated = import_CommandClass.CommandClass.parse(raw.payload.subarray(2), ctx);
+      return new this({
+        nodeId: ctx.sourceNodeId,
+        endpointIndex,
+        destination,
+        encapsulated
+      });
     }
-    const encapsulated = import_CommandClass.CommandClass.parse(raw.payload.subarray(2), ctx);
-    return new MultiChannelCCCommandEncapsulation_1({
-      nodeId: ctx.sourceNodeId,
-      endpointIndex,
-      destination,
-      encapsulated
-    });
-  }
-  encapsulated;
-  /** The destination end point (0-127) or an array of destination end points (1-7) */
-  destination;
-  serialize(ctx) {
-    if (ctx.getDeviceConfig?.(this.nodeId)?.compat?.treatDestinationEndpointAsSource) {
-      if (typeof this.destination === "number") {
-        this.endpointIndex = this.destination;
+    encapsulated;
+    /** The destination end point (0-127) or an array of destination end points (1-7) */
+    destination;
+    serialize(ctx) {
+      if (ctx.getDeviceConfig?.(this.nodeId)?.compat?.treatDestinationEndpointAsSource) {
+        if (typeof this.destination === "number") {
+          this.endpointIndex = this.destination;
+        }
       }
+      const destination = typeof this.destination === "number" ? this.destination & 127 : (0, import_safe.encodeBitMask)(this.destination, 7)[0] | 128;
+      this.payload = import_safe2.Bytes.concat([
+        import_safe2.Bytes.from([this.endpointIndex & 127, destination]),
+        this.encapsulated.serialize(ctx)
+      ]);
+      return super.serialize(ctx);
     }
-    const destination = typeof this.destination === "number" ? this.destination & 127 : (0, import_safe.encodeBitMask)(this.destination, 7)[0] | 128;
-    this.payload = import_safe2.Bytes.concat([
-      import_safe2.Bytes.from([this.endpointIndex & 127, destination]),
-      this.encapsulated.serialize(ctx)
-    ]);
-    return super.serialize(ctx);
-  }
-  toLogEntry(ctx) {
-    return {
-      ...super.toLogEntry(ctx),
-      message: {
-        source: this.endpointIndex,
-        destination: typeof this.destination === "number" ? this.destination : this.destination.join(", ")
-      }
-    };
-  }
-  computeEncapsulationOverhead() {
-    return super.computeEncapsulationOverhead() + 2;
-  }
-};
-MultiChannelCCCommandEncapsulation = MultiChannelCCCommandEncapsulation_1 = __decorate([
-  (0, import_CommandClassDecorators.CCCommand)(import_Types.MultiChannelCommand.CommandEncapsulation),
-  (0, import_CommandClassDecorators.expectedCCResponse)(getCCResponseForCommandEncapsulation, testResponseForCommandEncapsulation)
-], MultiChannelCCCommandEncapsulation);
-let MultiChannelCCV1Report = MultiChannelCCV1Report_1 = class MultiChannelCCV1Report2 extends MultiChannelCC {
-  constructor(options) {
-    super(options);
-    this.requestedCC = options.requestedCC;
-    this.endpointCount = options.endpointCount;
-  }
-  static from(raw, ctx) {
-    (0, import_safe.validatePayload)(raw.payload.length === 2);
-    const requestedCC = raw.payload[0];
-    const endpointCount = raw.payload[1];
-    return new MultiChannelCCV1Report_1({
-      nodeId: ctx.sourceNodeId,
-      requestedCC,
-      endpointCount
-    });
-  }
-  requestedCC;
-  endpointCount;
-  toLogEntry(ctx) {
-    return {
-      ...super.toLogEntry(ctx),
-      message: {
-        CC: (0, import_safe.getCCName)(this.requestedCC),
-        "# of endpoints": this.endpointCount
-      }
-    };
-  }
-};
-MultiChannelCCV1Report = MultiChannelCCV1Report_1 = __decorate([
-  (0, import_CommandClassDecorators.CCCommand)(import_Types.MultiChannelCommand.ReportV1)
-], MultiChannelCCV1Report);
+    toLogEntry(ctx) {
+      return {
+        ...super.toLogEntry(ctx),
+        message: {
+          source: this.endpointIndex,
+          destination: typeof this.destination === "number" ? this.destination : this.destination.join(", ")
+        }
+      };
+    }
+    computeEncapsulationOverhead() {
+      return super.computeEncapsulationOverhead() + 2;
+    }
+  };
+  return MultiChannelCCCommandEncapsulation2 = _classThis;
+})();
+let MultiChannelCCV1Report = (() => {
+  let _classDecorators = [(0, import_CommandClassDecorators.CCCommand)(import_Types.MultiChannelCommand.ReportV1)];
+  let _classDescriptor;
+  let _classExtraInitializers = [];
+  let _classThis;
+  let _classSuper = MultiChannelCC;
+  var MultiChannelCCV1Report2 = 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);
+      MultiChannelCCV1Report2 = _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.requestedCC = options.requestedCC;
+      this.endpointCount = options.endpointCount;
+    }
+    static from(raw, ctx) {
+      (0, import_safe.validatePayload)(raw.payload.length === 2);
+      const requestedCC = raw.payload[0];
+      const endpointCount = raw.payload[1];
+      return new this({
+        nodeId: ctx.sourceNodeId,
+        requestedCC,
+        endpointCount
+      });
+    }
+    requestedCC;
+    endpointCount;
+    toLogEntry(ctx) {
+      return {
+        ...super.toLogEntry(ctx),
+        message: {
+          CC: (0, import_safe.getCCName)(this.requestedCC),
+          "# of endpoints": this.endpointCount
+        }
+      };
+    }
+  };
+  return MultiChannelCCV1Report2 = _classThis;
+})();
 function testResponseForMultiChannelV1Get(sent, received) {
   return sent.requestedCC === received.requestedCC;
 }
-let MultiChannelCCV1Get = class MultiChannelCCV1Get2 extends MultiChannelCC {
-  constructor(options) {
-    super(options);
-    this.requestedCC = options.requestedCC;
-  }
-  static from(_raw, _ctx) {
-    throw new import_safe.ZWaveError(`${this.name}: deserialization not implemented`, import_safe.ZWaveErrorCodes.Deserialization_NotImplemented);
-  }
-  requestedCC;
-  serialize(ctx) {
-    this.payload = import_safe2.Bytes.from([this.requestedCC]);
-    return super.serialize(ctx);
-  }
-  toLogEntry(ctx) {
-    return {
-      ...super.toLogEntry(ctx),
-      message: { CC: (0, import_safe.getCCName)(this.requestedCC) }
-    };
-  }
-};
-MultiChannelCCV1Get = __decorate([
-  (0, import_CommandClassDecorators.CCCommand)(import_Types.MultiChannelCommand.GetV1),
-  (0, import_CommandClassDecorators.expectedCCResponse)(MultiChannelCCV1Report, testResponseForMultiChannelV1Get)
-], MultiChannelCCV1Get);
+let MultiChannelCCV1Get = (() => {
+  let _classDecorators = [(0, import_CommandClassDecorators.CCCommand)(import_Types.MultiChannelCommand.GetV1), (0, import_CommandClassDecorators.expectedCCResponse)(MultiChannelCCV1Report, testResponseForMultiChannelV1Get)];
+  let _classDescriptor;
+  let _classExtraInitializers = [];
+  let _classThis;
+  let _classSuper = MultiChannelCC;
+  var MultiChannelCCV1Get2 = 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);
+      MultiChannelCCV1Get2 = _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.requestedCC = options.requestedCC;
+    }
+    static from(_raw, _ctx) {
+      throw new import_safe.ZWaveError(`${this.name}: deserialization not implemented`, import_safe.ZWaveErrorCodes.Deserialization_NotImplemented);
+    }
+    requestedCC;
+    serialize(ctx) {
+      this.payload = import_safe2.Bytes.from([this.requestedCC]);
+      return super.serialize(ctx);
+    }
+    toLogEntry(ctx) {
+      return {
+        ...super.toLogEntry(ctx),
+        message: { CC: (0, import_safe.getCCName)(this.requestedCC) }
+      };
+    }
+  };
+  return MultiChannelCCV1Get2 = _classThis;
+})();
 function getResponseForV1CommandEncapsulation(sent) {
   if (sent.encapsulated.expectsCCResponse()) {
     return MultiChannelCCV1CommandEncapsulation;
@@ -990,45 +1194,59 @@ function testResponseForV1CommandEncapsulation(sent, received) {
   }
   return false;
 }
-let MultiChannelCCV1CommandEncapsulation = MultiChannelCCV1CommandEncapsulation_1 = class MultiChannelCCV1CommandEncapsulation2 extends MultiChannelCC {
-  constructor(options) {
-    super(options);
-    this.encapsulated = options.encapsulated;
-    this.endpointIndex = this.encapsulated.endpointIndex;
-  }
-  static from(raw, ctx) {
-    (0, import_safe.validatePayload)(raw.payload.length >= 1);
-    const endpointIndex = raw.payload[0];
-    const isV2withV1Header = raw.payload.length >= 2 && raw.payload[1] === 0;
-    const encapsulated = import_CommandClass.CommandClass.parse(raw.payload.subarray(isV2withV1Header ? 2 : 1), ctx);
-    return new MultiChannelCCV1CommandEncapsulation_1({
-      nodeId: ctx.sourceNodeId,
-      endpointIndex,
-      encapsulated
-    });
-  }
-  encapsulated;
-  serialize(ctx) {
-    this.payload = import_safe2.Bytes.concat([
-      import_safe2.Bytes.from([this.endpointIndex]),
-      this.encapsulated.serialize(ctx)
-    ]);
-    return super.serialize(ctx);
-  }
-  computeEncapsulationOverhead() {
-    return super.computeEncapsulationOverhead() + 1;
-  }
-  toLogEntry(ctx) {
-    return {
-      ...super.toLogEntry(ctx),
-      message: { source: this.endpointIndex }
-    };
-  }
-};
-MultiChannelCCV1CommandEncapsulation = MultiChannelCCV1CommandEncapsulation_1 = __decorate([
-  (0, import_CommandClassDecorators.CCCommand)(import_Types.MultiChannelCommand.CommandEncapsulationV1),
-  (0, import_CommandClassDecorators.expectedCCResponse)(getResponseForV1CommandEncapsulation, testResponseForV1CommandEncapsulation)
-], MultiChannelCCV1CommandEncapsulation);
+let MultiChannelCCV1CommandEncapsulation = (() => {
+  let _classDecorators = [(0, import_CommandClassDecorators.CCCommand)(import_Types.MultiChannelCommand.CommandEncapsulationV1), (0, import_CommandClassDecorators.expectedCCResponse)(getResponseForV1CommandEncapsulation, testResponseForV1CommandEncapsulation)];
+  let _classDescriptor;
+  let _classExtraInitializers = [];
+  let _classThis;
+  let _classSuper = MultiChannelCC;
+  var MultiChannelCCV1CommandEncapsulation2 = 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);
+      MultiChannelCCV1CommandEncapsulation2 = _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.encapsulated = options.encapsulated;
+      this.endpointIndex = this.encapsulated.endpointIndex;
+    }
+    static from(raw, ctx) {
+      (0, import_safe.validatePayload)(raw.payload.length >= 1);
+      const endpointIndex = raw.payload[0];
+      const isV2withV1Header = raw.payload.length >= 2 && raw.payload[1] === 0;
+      const encapsulated = import_CommandClass.CommandClass.parse(raw.payload.subarray(isV2withV1Header ? 2 : 1), ctx);
+      return new this({
+        nodeId: ctx.sourceNodeId,
+        endpointIndex,
+        encapsulated
+      });
+    }
+    encapsulated;
+    serialize(ctx) {
+      this.payload = import_safe2.Bytes.concat([
+        import_safe2.Bytes.from([this.endpointIndex]),
+        this.encapsulated.serialize(ctx)
+      ]);
+      return super.serialize(ctx);
+    }
+    computeEncapsulationOverhead() {
+      return super.computeEncapsulationOverhead() + 1;
+    }
+    toLogEntry(ctx) {
+      return {
+        ...super.toLogEntry(ctx),
+        message: { source: this.endpointIndex }
+      };
+    }
+  };
+  return MultiChannelCCV1CommandEncapsulation2 = _classThis;
+})();
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   MultiChannelCC,