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

package/build/cjs/cc/AssociationGroupInfoCC.js

@@ -0,0 +1,746 @@
+"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 AssociationGroupInfoCC_exports = {};
+__export(AssociationGroupInfoCC_exports, {
+  AssociationGroupInfoCC: () => AssociationGroupInfoCC,
+  AssociationGroupInfoCCAPI: () => AssociationGroupInfoCCAPI,
+  AssociationGroupInfoCCCommandListGet: () => AssociationGroupInfoCCCommandListGet,
+  AssociationGroupInfoCCCommandListReport: () => AssociationGroupInfoCCCommandListReport,
+  AssociationGroupInfoCCInfoGet: () => AssociationGroupInfoCCInfoGet,
+  AssociationGroupInfoCCInfoReport: () => AssociationGroupInfoCCInfoReport,
+  AssociationGroupInfoCCNameGet: () => AssociationGroupInfoCCNameGet,
+  AssociationGroupInfoCCNameReport: () => AssociationGroupInfoCCNameReport,
+  AssociationGroupInfoCCValues: () => AssociationGroupInfoCCValues
+});
+module.exports = __toCommonJS(AssociationGroupInfoCC_exports);
+var import_safe = require("@zwave-js/core/safe");
+var import_safe2 = require("@zwave-js/shared/safe");
+var import_safe3 = require("@zwave-js/shared/safe");
+var import_API = require("../lib/API.js");
+var import_CommandClass = require("../lib/CommandClass.js");
+var import_CommandClassDecorators = require("../lib/CommandClassDecorators.js");
+var import_Values = require("../lib/Values.js");
+var import_Types = require("../lib/_Types.js");
+var import_AssociationCC = require("./AssociationCC.js");
+var import_MultiChannelAssociationCC = require("./MultiChannelAssociationCC.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 AssociationGroupInfoCC_1, AssociationGroupInfoCCNameReport_1, AssociationGroupInfoCCNameGet_1, AssociationGroupInfoCCInfoReport_1, AssociationGroupInfoCCInfoGet_1, AssociationGroupInfoCCCommandListReport_1, AssociationGroupInfoCCCommandListGet_1;
+function __assertType(argName, typeName, boundHasError) {
+  const { ZWaveError, ZWaveErrorCodes } = require("@zwave-js/core");
+  if (boundHasError()) {
+    throw new ZWaveError(typeName ? `${argName} is not a ${typeName}` : `${argName} has the wrong type`, ZWaveErrorCodes.Argument_Invalid);
+  }
+}
+const __assertType__number = ($o) => {
+  function _number($o2) {
+    return typeof $o2 !== "number" ? {} : null;
+  }
+  return _number($o);
+};
+const __assertType__string = ($o) => {
+  function _string($o2) {
+    return typeof $o2 !== "string" ? {} : null;
+  }
+  return _string($o);
+};
+const __assertType__optional_boolean = ($o) => {
+  function _boolean($o2) {
+    return typeof $o2 !== "boolean" ? {} : null;
+  }
+  function optional__boolean($o2) {
+    if ($o2 !== void 0) {
+      const error = _boolean($o2);
+      if (error)
+        return error;
+    }
+    return null;
+  }
+  return optional__boolean($o);
+};
+const __assertType__AssociationGroupInfoCCInfoReportOptions = ($o) => {
+  function _boolean($o2) {
+    return typeof $o2 !== "boolean" ? {} : null;
+  }
+  function _number($o2) {
+    return typeof $o2 !== "number" ? {} : null;
+  }
+  function _3($o2) {
+    if (typeof $o2 !== "object" || $o2 === null || Array.isArray($o2))
+      return {};
+    if ("groupId" in $o2 && $o2["groupId"] !== void 0) {
+      const error = _number($o2["groupId"]);
+      if (error)
+        return error;
+    } else
+      return {};
+    if ("mode" in $o2 && $o2["mode"] !== void 0) {
+      const error = _number($o2["mode"]);
+      if (error)
+        return error;
+    } else
+      return {};
+    if ("profile" in $o2 && $o2["profile"] !== void 0) {
+      const error = _number($o2["profile"]);
+      if (error)
+        return error;
+    } else
+      return {};
+    if ("eventCode" in $o2 && $o2["eventCode"] !== void 0) {
+      const error = _number($o2["eventCode"]);
+      if (error)
+        return error;
+    } else
+      return {};
+    return null;
+  }
+  function sa__3_ea_3($o2) {
+    if (!Array.isArray($o2))
+      return {};
+    for (let i = 0; i < $o2.length; i++) {
+      const error = _3($o2[i]);
+      if (error)
+        return error;
+    }
+    return null;
+  }
+  function _0($o2) {
+    if (typeof $o2 !== "object" || $o2 === null || Array.isArray($o2))
+      return {};
+    if ("isListMode" in $o2 && $o2["isListMode"] !== void 0) {
+      const error = _boolean($o2["isListMode"]);
+      if (error)
+        return error;
+    } else
+      return {};
+    if ("hasDynamicInfo" in $o2 && $o2["hasDynamicInfo"] !== void 0) {
+      const error = _boolean($o2["hasDynamicInfo"]);
+      if (error)
+        return error;
+    } else
+      return {};
+    if ("groups" in $o2 && $o2["groups"] !== void 0) {
+      const error = sa__3_ea_3($o2["groups"]);
+      if (error)
+        return error;
+    } else
+      return {};
+    return null;
+  }
+  return _0($o);
+};
+const __assertType___0_1_2 = ($o) => {
+  function _ignore() {
+    return null;
+  }
+  function _number($o2) {
+    return typeof $o2 !== "number" ? {} : null;
+  }
+  function _0_1_2($o2) {
+    if (typeof $o2 !== "object" || $o2 === null || Array.isArray($o2))
+      return {};
+    if ("forEach" in $o2 && $o2["forEach"] !== void 0) {
+      const error = _ignore($o2["forEach"]);
+      if (error)
+        return error;
+    } else
+      return {};
+    if ("get" in $o2 && $o2["get"] !== void 0) {
+      const error = _ignore($o2["get"]);
+      if (error)
+        return error;
+    } else
+      return {};
+    if ("has" in $o2 && $o2["has"] !== void 0) {
+      const error = _ignore($o2["has"]);
+      if (error)
+        return error;
+    } else
+      return {};
+    if ("size" in $o2 && $o2["size"] !== void 0) {
+      const error = _number($o2["size"]);
+      if (error)
+        return error;
+    } else
+      return {};
+    if ("entries" in $o2 && $o2["entries"] !== void 0) {
+      const error = _ignore($o2["entries"]);
+      if (error)
+        return error;
+    } else
+      return {};
+    if ("keys" in $o2 && $o2["keys"] !== void 0) {
+      const error = _ignore($o2["keys"]);
+      if (error)
+        return error;
+    } else
+      return {};
+    if ("values" in $o2 && $o2["values"] !== void 0) {
+      const error = _ignore($o2["values"]);
+      if (error)
+        return error;
+    } else
+      return {};
+    return null;
+  }
+  return _0_1_2($o);
+};
+const AssociationGroupInfoCCValues = Object.freeze({
+  // Defines values that do not depend on anything else
+  ...import_Values.V.defineStaticCCValues(import_safe.CommandClasses["Association Group Information"], {
+    ...import_Values.V.staticProperty("hasDynamicInfo", void 0, { internal: true })
+  }),
+  // Defines values that depend on one or more arguments and need to be called as a function
+  ...import_Values.V.defineDynamicCCValues(import_safe.CommandClasses["Association Group Information"], {
+    ...import_Values.V.dynamicPropertyAndKeyWithName("groupName", "name", (groupId) => groupId, ({ property, propertyKey }) => property === "name" && typeof propertyKey === "number", void 0, { internal: true }),
+    ...import_Values.V.dynamicPropertyAndKeyWithName("groupInfo", "info", (groupId) => groupId, ({ property, propertyKey }) => property === "info" && typeof propertyKey === "number", void 0, { internal: true }),
+    ...import_Values.V.dynamicPropertyAndKeyWithName("commands", "issuedCommands", (groupId) => groupId, ({ property, propertyKey }) => property === "issuedCommands" && typeof propertyKey === "number", void 0, { internal: true })
+  })
+});
+let AssociationGroupInfoCCAPI = class AssociationGroupInfoCCAPI2 extends import_API.PhysicalCCAPI {
+  supportsCommand(cmd) {
+    switch (cmd) {
+      case import_Types.AssociationGroupInfoCommand.NameGet:
+      case import_Types.AssociationGroupInfoCommand.NameReport:
+      case import_Types.AssociationGroupInfoCommand.InfoGet:
+      case import_Types.AssociationGroupInfoCommand.InfoReport:
+      case import_Types.AssociationGroupInfoCommand.CommandListGet:
+      case import_Types.AssociationGroupInfoCommand.CommandListReport:
+        return true;
+    }
+    return super.supportsCommand(cmd);
+  }
+  async getGroupName(groupId) {
+    __assertType("groupId", "number", __assertType__number.bind(void 0, groupId));
+    this.assertSupportsCommand(import_Types.AssociationGroupInfoCommand, import_Types.AssociationGroupInfoCommand.NameGet);
+    const cc = new AssociationGroupInfoCCNameGet({
+      nodeId: this.endpoint.nodeId,
+      endpointIndex: this.endpoint.index,
+      groupId
+    });
+    const response = await this.host.sendCommand(cc, this.commandOptions);
+    if (response)
+      return response.name;
+  }
+  async reportGroupName(groupId, name) {
+    __assertType("groupId", "number", __assertType__number.bind(void 0, groupId));
+    __assertType("name", "string", __assertType__string.bind(void 0, name));
+    this.assertSupportsCommand(import_Types.AssociationGroupInfoCommand, import_Types.AssociationGroupInfoCommand.NameReport);
+    const cc = new AssociationGroupInfoCCNameReport({
+      nodeId: this.endpoint.nodeId,
+      endpointIndex: this.endpoint.index,
+      groupId,
+      name
+    });
+    await this.host.sendCommand(cc, this.commandOptions);
+  }
+  async getGroupInfo(groupId, refreshCache = false) {
+    __assertType("groupId", "number", __assertType__number.bind(void 0, groupId));
+    __assertType("refreshCache", "(optional) boolean", __assertType__optional_boolean.bind(void 0, refreshCache));
+    this.assertSupportsCommand(import_Types.AssociationGroupInfoCommand, import_Types.AssociationGroupInfoCommand.InfoGet);
+    const cc = new AssociationGroupInfoCCInfoGet({
+      nodeId: this.endpoint.nodeId,
+      endpointIndex: this.endpoint.index,
+      groupId,
+      refreshCache
+    });
+    const response = await this.host.sendCommand(cc, this.commandOptions);
+    if (response && response.groups.length > 0) {
+      const { groupId: _, ...info } = response.groups[0];
+      return {
+        hasDynamicInfo: response.hasDynamicInfo,
+        ...info
+      };
+    }
+  }
+  async reportGroupInfo(options) {
+    __assertType("options", "AssociationGroupInfoCCInfoReportOptions", __assertType__AssociationGroupInfoCCInfoReportOptions.bind(void 0, options));
+    this.assertSupportsCommand(import_Types.AssociationGroupInfoCommand, import_Types.AssociationGroupInfoCommand.InfoReport);
+    const cc = new AssociationGroupInfoCCInfoReport({
+      nodeId: this.endpoint.nodeId,
+      endpointIndex: this.endpoint.index,
+      ...options
+    });
+    await this.host.sendCommand(cc, this.commandOptions);
+  }
+  async getCommands(groupId, allowCache = true) {
+    __assertType("groupId", "number", __assertType__number.bind(void 0, groupId));
+    __assertType("allowCache", "(optional) boolean", __assertType__optional_boolean.bind(void 0, allowCache));
+    this.assertSupportsCommand(import_Types.AssociationGroupInfoCommand, import_Types.AssociationGroupInfoCommand.CommandListGet);
+    const cc = new AssociationGroupInfoCCCommandListGet({
+      nodeId: this.endpoint.nodeId,
+      endpointIndex: this.endpoint.index,
+      groupId,
+      allowCache
+    });
+    const response = await this.host.sendCommand(cc, this.commandOptions);
+    if (response)
+      return response.commands;
+  }
+  async reportCommands(groupId, commands) {
+    __assertType("groupId", "number", __assertType__number.bind(void 0, groupId));
+    __assertType("commands", void 0, __assertType___0_1_2.bind(void 0, commands));
+    this.assertSupportsCommand(import_Types.AssociationGroupInfoCommand, import_Types.AssociationGroupInfoCommand.CommandListReport);
+    const cc = new AssociationGroupInfoCCCommandListReport({
+      nodeId: this.endpoint.nodeId,
+      endpointIndex: this.endpoint.index,
+      groupId,
+      commands
+    });
+    await this.host.sendCommand(cc, this.commandOptions);
+  }
+};
+AssociationGroupInfoCCAPI = __decorate([
+  (0, import_CommandClassDecorators.API)(import_safe.CommandClasses["Association Group Information"])
+], AssociationGroupInfoCCAPI);
+let AssociationGroupInfoCC = AssociationGroupInfoCC_1 = class AssociationGroupInfoCC2 extends import_CommandClass.CommandClass {
+  determineRequiredCCInterviews() {
+    return [
+      ...super.determineRequiredCCInterviews(),
+      import_safe.CommandClasses.Association,
+      import_safe.CommandClasses["Multi Channel Association"]
+    ];
+  }
+  /** Returns the name of an association group */
+  static getGroupNameCached(ctx, endpoint, groupId) {
+    return ctx.getValueDB(endpoint.nodeId).getValue(AssociationGroupInfoCCValues.groupName(groupId).endpoint(endpoint.index));
+  }
+  /** Returns the association profile for an association group */
+  static getGroupProfileCached(ctx, endpoint, groupId) {
+    return ctx.getValueDB(endpoint.nodeId).getValue(AssociationGroupInfoCCValues.groupInfo(groupId).endpoint(endpoint.index))?.profile;
+  }
+  /** Returns the dictionary of all commands issued by the given association group */
+  static getIssuedCommandsCached(ctx, endpoint, groupId) {
+    return ctx.getValueDB(endpoint.nodeId).getValue(AssociationGroupInfoCCValues.commands(groupId).endpoint(endpoint.index));
+  }
+  static findGroupsForIssuedCommand(ctx, endpoint, ccId, command) {
+    const ret = [];
+    const associationGroupCount = this.getAssociationGroupCountCached(ctx, endpoint);
+    for (let groupId = 1; groupId <= associationGroupCount; groupId++) {
+      const issuedCommands = this.getIssuedCommandsCached(ctx, endpoint, groupId);
+      if (!issuedCommands)
+        continue;
+      if (issuedCommands.has(ccId) && issuedCommands.get(ccId).includes(command)) {
+        ret.push(groupId);
+        continue;
+      }
+    }
+    return ret;
+  }
+  static getAssociationGroupCountCached(ctx, endpoint) {
+    return (
+      // First query the Multi Channel Association CC
+      // And fall back to 0
+      endpoint.supportsCC(import_safe.CommandClasses["Multi Channel Association"]) && import_MultiChannelAssociationCC.MultiChannelAssociationCC.getGroupCountCached(ctx, endpoint) || endpoint.supportsCC(import_safe.CommandClasses.Association) && import_AssociationCC.AssociationCC.getGroupCountCached(ctx, endpoint) || 0
+    );
+  }
+  async interview(ctx) {
+    const node = this.getNode(ctx);
+    const endpoint = this.getEndpoint(ctx);
+    const api = import_API.CCAPI.create(import_safe.CommandClasses["Association Group Information"], ctx, endpoint).withOptions({ priority: import_safe.MessagePriority.NodeQuery });
+    ctx.logNode(node.id, {
+      endpoint: this.endpointIndex,
+      message: `Interviewing ${this.ccName}...`,
+      direction: "none"
+    });
+    const associationGroupCount = AssociationGroupInfoCC_1.getAssociationGroupCountCached(ctx, endpoint);
+    for (let groupId = 1; groupId <= associationGroupCount; groupId++) {
+      ctx.logNode(node.id, {
+        endpoint: this.endpointIndex,
+        message: `Association group #${groupId}: Querying name...`,
+        direction: "outbound"
+      });
+      const name = await api.getGroupName(groupId);
+      if (name) {
+        const logMessage = `Association group #${groupId} has name "${name}"`;
+        ctx.logNode(node.id, {
+          endpoint: this.endpointIndex,
+          message: logMessage,
+          direction: "inbound"
+        });
+      }
+      ctx.logNode(node.id, {
+        endpoint: this.endpointIndex,
+        message: `Association group #${groupId}: Querying command list...`,
+        direction: "outbound"
+      });
+      await api.getCommands(groupId);
+    }
+    await this.refreshValues(ctx);
+    this.setInterviewComplete(ctx, true);
+  }
+  async refreshValues(ctx) {
+    const node = this.getNode(ctx);
+    const endpoint = this.getEndpoint(ctx);
+    const api = import_API.CCAPI.create(import_safe.CommandClasses["Association Group Information"], ctx, endpoint).withOptions({ priority: import_safe.MessagePriority.NodeQuery });
+    const associationGroupCount = AssociationGroupInfoCC_1.getAssociationGroupCountCached(ctx, endpoint);
+    const hasDynamicInfo = this.getValue(ctx, AssociationGroupInfoCCValues.hasDynamicInfo);
+    for (let groupId = 1; groupId <= associationGroupCount; groupId++) {
+      ctx.logNode(node.id, {
+        endpoint: this.endpointIndex,
+        message: `Association group #${groupId}: Querying info...`,
+        direction: "outbound"
+      });
+      const info = await api.getGroupInfo(groupId, !!hasDynamicInfo);
+      if (info) {
+        const logMessage = `Received info for association group #${groupId}:
+info is dynamic: ${info.hasDynamicInfo}
+profile:         ${(0, import_safe3.getEnumMemberName)(import_Types.AssociationGroupInfoProfile, info.profile)}`;
+        ctx.logNode(node.id, {
+          endpoint: this.endpointIndex,
+          message: logMessage,
+          direction: "inbound"
+        });
+      }
+    }
+  }
+};
+AssociationGroupInfoCC = AssociationGroupInfoCC_1 = __decorate([
+  (0, import_CommandClassDecorators.commandClass)(import_safe.CommandClasses["Association Group Information"]),
+  (0, import_CommandClassDecorators.implementedVersion)(3),
+  (0, import_CommandClassDecorators.ccValues)(AssociationGroupInfoCCValues)
+], AssociationGroupInfoCC);
+let AssociationGroupInfoCCNameReport = AssociationGroupInfoCCNameReport_1 = class AssociationGroupInfoCCNameReport2 extends AssociationGroupInfoCC {
+  constructor(options) {
+    super(options);
+    this.groupId = options.groupId;
+    this.name = options.name;
+  }
+  static from(raw, ctx) {
+    (0, import_safe.validatePayload)(raw.payload.length >= 2);
+    const groupId = raw.payload[0];
+    const nameLength = raw.payload[1];
+    (0, import_safe.validatePayload)(raw.payload.length >= 2 + nameLength);
+    const name = (0, import_safe3.cpp2js)(raw.payload.subarray(2, 2 + nameLength).toString("utf8"));
+    return new AssociationGroupInfoCCNameReport_1({
+      nodeId: ctx.sourceNodeId,
+      groupId,
+      name
+    });
+  }
+  groupId;
+  name;
+  persistValues(ctx) {
+    if (!super.persistValues(ctx))
+      return false;
+    const valueDB = this.getValueDB(ctx);
+    valueDB.setValue(AssociationGroupInfoCCValues.groupName(this.groupId).endpoint(this.endpointIndex), this.name);
+    return true;
+  }
+  serialize(ctx) {
+    this.payload = import_safe2.Bytes.concat([
+      import_safe2.Bytes.from([this.groupId, this.name.length]),
+      import_safe2.Bytes.from(this.name, "utf8")
+    ]);
+    return super.serialize(ctx);
+  }
+  toLogEntry(ctx) {
+    return {
+      ...super.toLogEntry(ctx),
+      message: {
+        "group id": this.groupId,
+        name: this.name
+      }
+    };
+  }
+};
+AssociationGroupInfoCCNameReport = AssociationGroupInfoCCNameReport_1 = __decorate([
+  (0, import_CommandClassDecorators.CCCommand)(import_Types.AssociationGroupInfoCommand.NameReport)
+], AssociationGroupInfoCCNameReport);
+let AssociationGroupInfoCCNameGet = AssociationGroupInfoCCNameGet_1 = class AssociationGroupInfoCCNameGet2 extends AssociationGroupInfoCC {
+  constructor(options) {
+    super(options);
+    this.groupId = options.groupId;
+  }
+  static from(raw, ctx) {
+    (0, import_safe.validatePayload)(raw.payload.length >= 1);
+    const groupId = raw.payload[0];
+    return new AssociationGroupInfoCCNameGet_1({
+      nodeId: ctx.sourceNodeId,
+      groupId
+    });
+  }
+  groupId;
+  serialize(ctx) {
+    this.payload = import_safe2.Bytes.from([this.groupId]);
+    return super.serialize(ctx);
+  }
+  toLogEntry(ctx) {
+    return {
+      ...super.toLogEntry(ctx),
+      message: { "group id": this.groupId }
+    };
+  }
+};
+AssociationGroupInfoCCNameGet = AssociationGroupInfoCCNameGet_1 = __decorate([
+  (0, import_CommandClassDecorators.CCCommand)(import_Types.AssociationGroupInfoCommand.NameGet),
+  (0, import_CommandClassDecorators.expectedCCResponse)(AssociationGroupInfoCCNameReport)
+], AssociationGroupInfoCCNameGet);
+let AssociationGroupInfoCCInfoReport = AssociationGroupInfoCCInfoReport_1 = class AssociationGroupInfoCCInfoReport2 extends AssociationGroupInfoCC {
+  constructor(options) {
+    super(options);
+    this.isListMode = options.isListMode;
+    this.hasDynamicInfo = options.hasDynamicInfo;
+    this.groups = options.groups;
+  }
+  static from(raw, ctx) {
+    (0, import_safe.validatePayload)(raw.payload.length >= 1);
+    const isListMode = !!(raw.payload[0] & 128);
+    const hasDynamicInfo = !!(raw.payload[0] & 64);
+    const groupCount = raw.payload[0] & 63;
+    (0, import_safe.validatePayload)(raw.payload.length >= 1 + groupCount * 7);
+    const groups = [];
+    for (let i = 0; i < groupCount; i++) {
+      const offset = 1 + i * 7;
+      const groupBytes = raw.payload.subarray(offset, offset + 7);
+      const groupId = groupBytes[0];
+      const mode = 0;
+      const profile = groupBytes.readUInt16BE(2);
+      const eventCode = 0;
+      groups.push({ groupId, mode, profile, eventCode });
+    }
+    return new AssociationGroupInfoCCInfoReport_1({
+      nodeId: ctx.sourceNodeId,
+      isListMode,
+      hasDynamicInfo,
+      groups
+    });
+  }
+  isListMode;
+  hasDynamicInfo;
+  groups;
+  persistValues(ctx) {
+    if (!super.persistValues(ctx))
+      return false;
+    for (const group of this.groups) {
+      const { groupId, mode, profile, eventCode } = group;
+      this.setValue(ctx, AssociationGroupInfoCCValues.groupInfo(groupId), {
+        mode,
+        profile,
+        eventCode
+      });
+    }
+    return true;
+  }
+  serialize(ctx) {
+    this.payload = import_safe2.Bytes.alloc(1 + this.groups.length * 7, 0);
+    this.payload[0] = (this.isListMode ? 128 : 0) | (this.hasDynamicInfo ? 64 : 0) | this.groups.length & 63;
+    for (let i = 0; i < this.groups.length; i++) {
+      const offset = 1 + i * 7;
+      this.payload[offset] = this.groups[i].groupId;
+      this.payload.writeUInt16BE(this.groups[i].profile, offset + 2);
+    }
+    return super.serialize(ctx);
+  }
+  toLogEntry(ctx) {
+    return {
+      ...super.toLogEntry(ctx),
+      message: {
+        "is list mode": this.isListMode,
+        "has dynamic info": this.hasDynamicInfo,
+        groups: `${this.groups.map((g) => `
+\xB7 Group #${g.groupId}
+  mode:       ${g.mode}
+  profile:    ${g.profile}
+  event code: ${g.eventCode}`).join("")}`
+      }
+    };
+  }
+};
+__decorate([
+  (0, import_CommandClassDecorators.ccValue)(AssociationGroupInfoCCValues.hasDynamicInfo)
+], AssociationGroupInfoCCInfoReport.prototype, "hasDynamicInfo", void 0);
+AssociationGroupInfoCCInfoReport = AssociationGroupInfoCCInfoReport_1 = __decorate([
+  (0, import_CommandClassDecorators.CCCommand)(import_Types.AssociationGroupInfoCommand.InfoReport)
+], AssociationGroupInfoCCInfoReport);
+let AssociationGroupInfoCCInfoGet = AssociationGroupInfoCCInfoGet_1 = class AssociationGroupInfoCCInfoGet2 extends AssociationGroupInfoCC {
+  constructor(options) {
+    super(options);
+    this.refreshCache = options.refreshCache;
+    if ("listMode" in options)
+      this.listMode = options.listMode;
+    if ("groupId" in options)
+      this.groupId = options.groupId;
+  }
+  static from(raw, ctx) {
+    (0, import_safe.validatePayload)(raw.payload.length >= 2);
+    const optionByte = raw.payload[0];
+    const refreshCache = !!(optionByte & 128);
+    const listMode = !!(optionByte & 64);
+    let groupId;
+    if (!listMode) {
+      groupId = raw.payload[1];
+    }
+    return new AssociationGroupInfoCCInfoGet_1({
+      nodeId: ctx.sourceNodeId,
+      refreshCache,
+      listMode,
+      groupId
+    });
+  }
+  refreshCache;
+  listMode;
+  groupId;
+  serialize(ctx) {
+    const isListMode = this.listMode === true;
+    const optionByte = (this.refreshCache ? 128 : 0) | (isListMode ? 64 : 0);
+    this.payload = import_safe2.Bytes.from([
+      optionByte,
+      isListMode ? 0 : this.groupId
+    ]);
+    return super.serialize(ctx);
+  }
+  toLogEntry(ctx) {
+    const message = {};
+    if (this.groupId != void 0) {
+      message["group id"] = this.groupId;
+    }
+    if (this.listMode != void 0) {
+      message["list mode"] = this.listMode;
+    }
+    message["refresh cache"] = this.refreshCache;
+    return {
+      ...super.toLogEntry(ctx),
+      message
+    };
+  }
+};
+AssociationGroupInfoCCInfoGet = AssociationGroupInfoCCInfoGet_1 = __decorate([
+  (0, import_CommandClassDecorators.CCCommand)(import_Types.AssociationGroupInfoCommand.InfoGet),
+  (0, import_CommandClassDecorators.expectedCCResponse)(AssociationGroupInfoCCInfoReport)
+], AssociationGroupInfoCCInfoGet);
+let AssociationGroupInfoCCCommandListReport = AssociationGroupInfoCCCommandListReport_1 = class AssociationGroupInfoCCCommandListReport2 extends AssociationGroupInfoCC {
+  constructor(options) {
+    super(options);
+    this.groupId = options.groupId;
+    this.commands = options.commands;
+  }
+  static from(raw, ctx) {
+    (0, import_safe.validatePayload)(raw.payload.length >= 2);
+    const groupId = raw.payload[0];
+    const listLength = raw.payload[1];
+    (0, import_safe.validatePayload)(raw.payload.length >= 2 + listLength);
+    const listBytes = raw.payload.subarray(2, 2 + listLength);
+    let offset = 0;
+    const commands = /* @__PURE__ */ new Map();
+    while (offset < listLength) {
+      const { ccId, bytesRead } = (0, import_safe.parseCCId)(listBytes, offset);
+      const command = listBytes[offset + bytesRead];
+      if (!commands.has(ccId))
+        commands.set(ccId, []);
+      commands.get(ccId).push(command);
+      offset += bytesRead + 1;
+    }
+    return new AssociationGroupInfoCCCommandListReport_1({
+      nodeId: ctx.sourceNodeId,
+      groupId,
+      commands
+    });
+  }
+  groupId;
+  commands;
+  serialize(ctx) {
+    this.payload = new import_safe2.Bytes(2 + this.commands.size * 3);
+    this.payload[0] = this.groupId;
+    let offset = 2;
+    for (const [ccId, commands] of this.commands) {
+      for (const command of commands) {
+        offset += (0, import_safe.encodeCCId)(ccId, this.payload, offset);
+        this.payload[offset] = command;
+        offset++;
+      }
+    }
+    this.payload[1] = offset - 2;
+    return super.serialize(ctx);
+  }
+  toLogEntry(ctx) {
+    return {
+      ...super.toLogEntry(ctx),
+      message: {
+        "group id": this.groupId,
+        commands: `${[...this.commands].map(([cc, cmds]) => {
+          return `
+\xB7 ${(0, import_safe.getCCName)(cc)}: ${cmds.map((cmd) => (0, import_safe3.num2hex)(cmd)).join(", ")}`;
+        }).join("")}`
+      }
+    };
+  }
+};
+__decorate([
+  (0, import_CommandClassDecorators.ccValue)(AssociationGroupInfoCCValues.commands, (self) => [self.groupId])
+], AssociationGroupInfoCCCommandListReport.prototype, "commands", void 0);
+AssociationGroupInfoCCCommandListReport = AssociationGroupInfoCCCommandListReport_1 = __decorate([
+  (0, import_CommandClassDecorators.CCCommand)(import_Types.AssociationGroupInfoCommand.CommandListReport)
+], AssociationGroupInfoCCCommandListReport);
+let AssociationGroupInfoCCCommandListGet = AssociationGroupInfoCCCommandListGet_1 = class AssociationGroupInfoCCCommandListGet2 extends AssociationGroupInfoCC {
+  constructor(options) {
+    super(options);
+    this.allowCache = options.allowCache;
+    this.groupId = options.groupId;
+  }
+  static from(raw, ctx) {
+    (0, import_safe.validatePayload)(raw.payload.length >= 2);
+    const allowCache = !!(raw.payload[0] & 128);
+    const groupId = raw.payload[1];
+    return new AssociationGroupInfoCCCommandListGet_1({
+      nodeId: ctx.sourceNodeId,
+      allowCache,
+      groupId
+    });
+  }
+  allowCache;
+  groupId;
+  serialize(ctx) {
+    this.payload = import_safe2.Bytes.from([
+      this.allowCache ? 128 : 0,
+      this.groupId
+    ]);
+    return super.serialize(ctx);
+  }
+  toLogEntry(ctx) {
+    return {
+      ...super.toLogEntry(ctx),
+      message: {
+        "group id": this.groupId,
+        "allow cache": this.allowCache
+      }
+    };
+  }
+};
+AssociationGroupInfoCCCommandListGet = AssociationGroupInfoCCCommandListGet_1 = __decorate([
+  (0, import_CommandClassDecorators.CCCommand)(import_Types.AssociationGroupInfoCommand.CommandListGet),
+  (0, import_CommandClassDecorators.expectedCCResponse)(AssociationGroupInfoCCCommandListReport)
+], AssociationGroupInfoCCCommandListGet);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AssociationGroupInfoCC,
+  AssociationGroupInfoCCAPI,
+  AssociationGroupInfoCCCommandListGet,
+  AssociationGroupInfoCCCommandListReport,
+  AssociationGroupInfoCCInfoGet,
+  AssociationGroupInfoCCInfoReport,
+  AssociationGroupInfoCCNameGet,
+  AssociationGroupInfoCCNameReport,
+  AssociationGroupInfoCCValues
+});
+//# sourceMappingURL=AssociationGroupInfoCC.js.map