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

package/build/cjs/cc/MultiChannelCC.js

@@ -0,0 +1,1050 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var MultiChannelCC_exports = {};
+__export(MultiChannelCC_exports, {
+  MultiChannelCC: () => MultiChannelCC,
+  MultiChannelCCAPI: () => MultiChannelCCAPI,
+  MultiChannelCCAggregatedMembersGet: () => MultiChannelCCAggregatedMembersGet,
+  MultiChannelCCAggregatedMembersReport: () => MultiChannelCCAggregatedMembersReport,
+  MultiChannelCCCapabilityGet: () => MultiChannelCCCapabilityGet,
+  MultiChannelCCCapabilityReport: () => MultiChannelCCCapabilityReport,
+  MultiChannelCCCommandEncapsulation: () => MultiChannelCCCommandEncapsulation,
+  MultiChannelCCEndPointFind: () => MultiChannelCCEndPointFind,
+  MultiChannelCCEndPointFindReport: () => MultiChannelCCEndPointFindReport,
+  MultiChannelCCEndPointGet: () => MultiChannelCCEndPointGet,
+  MultiChannelCCEndPointReport: () => MultiChannelCCEndPointReport,
+  MultiChannelCCV1CommandEncapsulation: () => MultiChannelCCV1CommandEncapsulation,
+  MultiChannelCCV1Get: () => MultiChannelCCV1Get,
+  MultiChannelCCV1Report: () => MultiChannelCCV1Report,
+  MultiChannelCCValues: () => MultiChannelCCValues
+});
+module.exports = __toCommonJS(MultiChannelCC_exports);
+var import_safe = require("@zwave-js/core/safe");
+var import_safe2 = require("@zwave-js/shared/safe");
+var import_arrays = require("alcalzone-shared/arrays/index.js");
+var import_API = require("../lib/API.js");
+var import_CommandClass = require("../lib/CommandClass.js");
+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 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()) {
+    throw new ZWaveError2(typeName ? `${argName} is not a ${typeName}` : `${argName} has the wrong type`, ZWaveErrorCodes2.Argument_Invalid);
+  }
+}
+const __assertType__number = ($o) => {
+  function _number($o2) {
+    return typeof $o2 !== "number" ? {} : null;
+  }
+  return _number($o);
+};
+const MultiChannelCCValues = Object.freeze({
+  ...import_Values.V.defineStaticCCValues(import_safe.CommandClasses["Multi Channel"], {
+    ...import_Values.V.staticProperty("endpointIndizes", void 0, {
+      internal: true,
+      supportsEndpoints: false
+    }),
+    ...import_Values.V.staticPropertyWithName("individualEndpointCount", "individualCount", void 0, {
+      internal: true,
+      supportsEndpoints: false
+    }),
+    ...import_Values.V.staticPropertyWithName("aggregatedEndpointCount", "aggregatedCount", void 0, {
+      internal: true,
+      supportsEndpoints: false
+    }),
+    ...import_Values.V.staticPropertyWithName("endpointCountIsDynamic", "countIsDynamic", void 0, {
+      internal: true,
+      supportsEndpoints: false
+    }),
+    ...import_Values.V.staticPropertyWithName("endpointsHaveIdenticalCapabilities", "identicalCapabilities", void 0, {
+      internal: true,
+      supportsEndpoints: false
+    }),
+    ...import_Values.V.staticPropertyWithName("endpointCCs", "commandClasses", void 0, { internal: true }),
+    ...import_Values.V.staticPropertyWithName("endpointDeviceClass", "deviceClass", void 0, { internal: true })
+  }),
+  ...import_Values.V.defineDynamicCCValues(import_safe.CommandClasses["Multi Channel"], {
+    ...import_Values.V.dynamicPropertyAndKeyWithName("aggregatedEndpointMembers", "members", (endpointIndex) => endpointIndex, ({ property, propertyKey }) => property === "members" && typeof propertyKey === "number", void 0, { internal: true })
+  })
+});
+function areEndpointsUnnecessary(ctx, nodeId, endpointIndizes) {
+  const deviceClasses = /* @__PURE__ */ new Map();
+  for (const endpoint of endpointIndizes) {
+    const devClassValueId = MultiChannelCCValues.endpointDeviceClass.endpoint(endpoint);
+    const deviceClass = ctx.getValueDB(nodeId).getValue(devClassValueId);
+    if (deviceClass) {
+      deviceClasses.set(endpoint, {
+        generic: deviceClass.generic,
+        specific: deviceClass.specific
+      });
+    }
+  }
+  const distinctDeviceClasses = (0, import_arrays.distinct)([...deviceClasses.values()].map(({ generic, specific }) => generic * 256 + specific));
+  if (distinctDeviceClasses.length !== endpointIndizes.length) {
+    return false;
+  }
+  const switchTypeDeviceClasses = [
+    16,
+    // Binary Switch
+    17,
+    // Multilevel Switch
+    18,
+    // Remote Switch
+    19
+    // Toggle Switch
+  ];
+  const numSwitchEndpoints = [...deviceClasses.values()].filter(({ generic }) => switchTypeDeviceClasses.includes(generic)).length;
+  if (numSwitchEndpoints > 1)
+    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
+      };
+    }
+  }
+  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);
+  }
+};
+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 === "*") {
+      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: `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) {
+      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 += `
+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"
+      });
+      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: `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) {
+        ctx.logNode(node.id, {
+          endpoint: this.endpointIndex,
+          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;
+      }
+      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}):
+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 += `
+  \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.`
+        });
+      }
+    }
+    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"
+      });
+      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);
+  }
+};
+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;
+    }
+    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
+      });
+      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("")
+      }
+    };
+  }
+};
+MultiChannelCCCapabilityReport = MultiChannelCCCapabilityReport_1 = __decorate([
+  (0, import_CommandClassDecorators.CCCommand)(import_Types.MultiChannelCommand.CapabilityReport)
+], MultiChannelCCCapabilityReport);
+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);
+function getCCResponseForCommandEncapsulation(sent) {
+  if (typeof sent.destination === "number" && sent.encapsulated.expectsCCResponse()) {
+    return [
+      MultiChannelCCCommandEncapsulation,
+      MultiChannelCCV1CommandEncapsulation
+    ];
+  }
+}
+function testResponseForCommandEncapsulation(sent, received) {
+  if (typeof sent.destination === "number" && sent.destination === received.endpointIndex) {
+    return "checkEncapsulated";
+  }
+  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;
+        }
+        break;
+      } else if ((0, import_EncapsulatingCommandClass.isEncapsulatingCommandClass)(cur)) {
+        cur.encapsulated.endpointIndex = this.endpointIndex;
+        cur = cur.encapsulated;
+      } else {
+        break;
+      }
+    }
+    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]));
+      }
+    }
+    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;
+      }
+    }
+    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);
+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);
+function getResponseForV1CommandEncapsulation(sent) {
+  if (sent.encapsulated.expectsCCResponse()) {
+    return MultiChannelCCV1CommandEncapsulation;
+  }
+}
+function testResponseForV1CommandEncapsulation(sent, received) {
+  if (sent.endpointIndex === received.endpointIndex) {
+    return "checkEncapsulated";
+  }
+  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);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MultiChannelCC,
+  MultiChannelCCAPI,
+  MultiChannelCCAggregatedMembersGet,
+  MultiChannelCCAggregatedMembersReport,
+  MultiChannelCCCapabilityGet,
+  MultiChannelCCCapabilityReport,
+  MultiChannelCCCommandEncapsulation,
+  MultiChannelCCEndPointFind,
+  MultiChannelCCEndPointFindReport,
+  MultiChannelCCEndPointGet,
+  MultiChannelCCEndPointReport,
+  MultiChannelCCV1CommandEncapsulation,
+  MultiChannelCCV1Get,
+  MultiChannelCCV1Report,
+  MultiChannelCCValues
+});
+//# sourceMappingURL=MultiChannelCC.js.map