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

package/build/cjs/cc/NotificationCC.js

@@ -0,0 +1,1245 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var NotificationCC_exports = {};
+__export(NotificationCC_exports, {
+  NotificationCC: () => NotificationCC,
+  NotificationCCAPI: () => NotificationCCAPI,
+  NotificationCCEventSupportedGet: () => NotificationCCEventSupportedGet,
+  NotificationCCEventSupportedReport: () => NotificationCCEventSupportedReport,
+  NotificationCCGet: () => NotificationCCGet,
+  NotificationCCReport: () => NotificationCCReport,
+  NotificationCCSet: () => NotificationCCSet,
+  NotificationCCSupportedGet: () => NotificationCCSupportedGet,
+  NotificationCCSupportedReport: () => NotificationCCSupportedReport,
+  NotificationCCValues: () => NotificationCCValues,
+  getNotificationEnumBehavior: () => getNotificationEnumBehavior,
+  getNotificationStateValueWithEnum: () => getNotificationStateValueWithEnum,
+  getNotificationValueMetadata: () => getNotificationValueMetadata
+});
+module.exports = __toCommonJS(NotificationCC_exports);
+var import_core = require("@zwave-js/core");
+var import_safe = require("@zwave-js/core/safe");
+var import_safe2 = require("@zwave-js/shared/safe");
+var import_safe3 = require("@zwave-js/shared/safe");
+var import_typeguards = require("alcalzone-shared/typeguards/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_NotificationEventPayload = require("../lib/NotificationEventPayload.js");
+var import_Values = require("../lib/Values.js");
+var import_Types = require("../lib/_Types.js");
+var ccUtils = __toESM(require("../lib/utils.js"), 1);
+var import_AssociationGroupInfoCC = require("./AssociationGroupInfoCC.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 NotificationCC_1, NotificationCCSet_1, NotificationCCReport_1, NotificationCCGet_1, NotificationCCSupportedReport_1, NotificationCCEventSupportedReport_1, NotificationCCEventSupportedGet_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__NotificationCCReportOptions = ($o) => {
+  function _number($o2) {
+    return typeof $o2 !== "number" ? {} : null;
+  }
+  function _uint8array($o2) {
+    return !require("@zwave-js/shared/safe").isUint8Array($o2) ? {} : null;
+  }
+  function _0($o2) {
+    if (typeof $o2 !== "object" || $o2 === null || Array.isArray($o2))
+      return {};
+    if ("alarmType" in $o2 && $o2["alarmType"] !== void 0) {
+      const error = _number($o2["alarmType"]);
+      if (error)
+        return error;
+    }
+    if ("alarmLevel" in $o2 && $o2["alarmLevel"] !== void 0) {
+      const error = _number($o2["alarmLevel"]);
+      if (error)
+        return error;
+    }
+    if ("notificationType" in $o2 && $o2["notificationType"] !== void 0) {
+      const error = _number($o2["notificationType"]);
+      if (error)
+        return error;
+    }
+    if ("notificationEvent" in $o2 && $o2["notificationEvent"] !== void 0) {
+      const error = _number($o2["notificationEvent"]);
+      if (error)
+        return error;
+    }
+    if ("notificationStatus" in $o2 && $o2["notificationStatus"] !== void 0) {
+      const error = _number($o2["notificationStatus"]);
+      if (error)
+        return error;
+    }
+    if ("eventParameters" in $o2 && $o2["eventParameters"] !== void 0) {
+      const error = _uint8array($o2["eventParameters"]);
+      if (error)
+        return error;
+    }
+    if ("sequenceNumber" in $o2 && $o2["sequenceNumber"] !== void 0) {
+      const error = _number($o2["sequenceNumber"]);
+      if (error)
+        return error;
+    }
+    return null;
+  }
+  return _0($o);
+};
+const __assertType__NotificationCCGetOptions = ($o) => {
+  function _number($o2) {
+    return typeof $o2 !== "number" ? {} : null;
+  }
+  function _1($o2) {
+    if (typeof $o2 !== "object" || $o2 === null || Array.isArray($o2))
+      return {};
+    if ("alarmType" in $o2 && $o2["alarmType"] !== void 0) {
+      const error = _number($o2["alarmType"]);
+      if (error)
+        return error;
+    } else
+      return {};
+    return null;
+  }
+  function _2($o2) {
+    if (typeof $o2 !== "object" || $o2 === null || Array.isArray($o2))
+      return {};
+    if ("notificationType" in $o2 && $o2["notificationType"] !== void 0) {
+      const error = _number($o2["notificationType"]);
+      if (error)
+        return error;
+    } else
+      return {};
+    if ("notificationEvent" in $o2 && $o2["notificationEvent"] !== void 0) {
+      const error = _number($o2["notificationEvent"]);
+      if (error)
+        return error;
+    }
+    return null;
+  }
+  function su__1__2_eu($o2) {
+    const conditions = [_1, _2];
+    for (const condition of conditions) {
+      const error = condition($o2);
+      if (!error)
+        return null;
+    }
+    return {};
+  }
+  return su__1__2_eu($o);
+};
+const __assertType__number = ($o) => {
+  function _number($o2) {
+    return typeof $o2 !== "number" ? {} : null;
+  }
+  return _number($o);
+};
+const __assertType__boolean = ($o) => {
+  function _boolean($o2) {
+    return typeof $o2 !== "boolean" ? {} : null;
+  }
+  return _boolean($o);
+};
+const NotificationCCValues = Object.freeze({
+  ...import_Values.V.defineStaticCCValues(import_safe.CommandClasses.Notification, {
+    ...import_Values.V.staticProperty("supportsV1Alarm", void 0, {
+      internal: true,
+      supportsEndpoints: false
+    }),
+    ...import_Values.V.staticProperty("supportedNotificationTypes", void 0, {
+      internal: true,
+      supportsEndpoints: false
+    }),
+    ...import_Values.V.staticProperty("notificationMode", void 0, {
+      internal: true,
+      supportsEndpoints: false
+    }),
+    ...import_Values.V.staticProperty("lastRefresh", void 0, {
+      internal: true
+    }),
+    // V1 Alarm values
+    ...import_Values.V.staticProperty("alarmType", {
+      ...import_safe.ValueMetadata.ReadOnlyUInt8,
+      label: "Alarm Type"
+    }),
+    ...import_Values.V.staticProperty("alarmLevel", {
+      ...import_safe.ValueMetadata.ReadOnlyUInt8,
+      label: "Alarm Level"
+    }),
+    // Simplification for the Door state variable, where we cannot know
+    // if any of the enum values are supported
+    ...import_Values.V.staticPropertyAndKeyWithName("doorStateSimple", "Access Control", "Door state (simple)", {
+      // Must be a number for compatibility reasons
+      ...import_safe.ValueMetadata.ReadOnlyUInt8,
+      label: "Door state (simple)",
+      states: {
+        [22]: "Window/door is open",
+        [23]: "Window/door is closed"
+      },
+      ccSpecific: {
+        notificationType: 6
+      }
+    }, {
+      autoCreate: shouldAutoCreateSimpleDoorSensorValue
+    }),
+    // Binary tilt value extracted from the Door state variable.
+    ...import_Values.V.staticPropertyAndKeyWithName("doorTiltState", "Access Control", "Door tilt state", {
+      // Must be a number for compatibility reasons
+      ...import_safe.ValueMetadata.ReadOnlyUInt8,
+      label: "Door tilt state",
+      states: {
+        [0]: "Window/door is not tilted",
+        [1]: "Window/door is tilted"
+      },
+      ccSpecific: {
+        notificationType: 6
+      }
+    }, {
+      // This is created when the tilt state is first received.
+      autoCreate: false
+    })
+  }),
+  ...import_Values.V.defineDynamicCCValues(import_safe.CommandClasses.Notification, {
+    ...import_Values.V.dynamicPropertyAndKeyWithName("supportedNotificationEvents", "supportedNotificationEvents", (notificationType) => notificationType, ({ property, propertyKey }) => property === "supportedNotificationEvents" && typeof propertyKey === "number", void 0, { internal: true, supportsEndpoints: false }),
+    // Different variants of the V2 notification values:
+    // Unknown type
+    ...import_Values.V.dynamicPropertyWithName("unknownNotificationType", (notificationType) => `UNKNOWN_${(0, import_safe3.num2hex)(notificationType)}`, ({ property }) => typeof property === "string" && property.startsWith("UNKNOWN_0x"), (notificationType) => ({
+      ...import_safe.ValueMetadata.ReadOnlyUInt8,
+      label: `Unknown notification (${(0, import_safe3.num2hex)(notificationType)})`,
+      ccSpecific: { notificationType }
+    })),
+    // Known type, unknown variable
+    ...import_Values.V.dynamicPropertyAndKeyWithName("unknownNotificationVariable", (notificationType, notificationName) => notificationName, "unknown", ({ property, propertyKey }) => typeof property === "string" && propertyKey === "unknown", (notificationType, notificationName) => ({
+      ...import_safe.ValueMetadata.ReadOnlyUInt8,
+      label: `${notificationName}: Unknown value`,
+      ccSpecific: { notificationType }
+    })),
+    // (Stateful) notification variable
+    ...import_Values.V.dynamicPropertyAndKeyWithName(
+      "notificationVariable",
+      // eslint-disable-next-line @typescript-eslint/no-unused-vars
+      (notificationName, variableName) => notificationName,
+      (notificationName, variableName) => variableName,
+      ({ property, propertyKey }) => typeof property === "string" && typeof propertyKey === "string",
+      // Notification metadata is so dynamic, it does not make sense to define it here
+      void 0
+    )
+  })
+});
+function shouldAutoCreateSimpleDoorSensorValue(ctx, endpoint) {
+  const valueDB = ctx.tryGetValueDB(endpoint.nodeId);
+  if (!valueDB)
+    return false;
+  const supportedACEvents = valueDB.getValue(NotificationCCValues.supportedNotificationEvents(
+    // Access Control
+    6
+  ).endpoint(endpoint.index));
+  if (!supportedACEvents)
+    return false;
+  return supportedACEvents.includes(
+    // Window/door is open
+    22
+  ) && supportedACEvents.includes(
+    // Window/door is closed
+    23
+  );
+}
+let NotificationCCAPI = class NotificationCCAPI2 extends import_API.PhysicalCCAPI {
+  supportsCommand(cmd) {
+    switch (cmd) {
+      case import_Types.NotificationCommand.Report:
+      case import_Types.NotificationCommand.Get:
+        return true;
+      // These exist starting with V1
+      case import_Types.NotificationCommand.Set:
+      case import_Types.NotificationCommand.SupportedGet:
+        return this.version >= 2;
+      case import_Types.NotificationCommand.EventSupportedGet:
+        return this.version >= 3;
+    }
+    return super.supportsCommand(cmd);
+  }
+  get [import_API.POLL_VALUE]() {
+    return async function({ property, propertyKey }) {
+      const valueId = {
+        commandClass: this.ccId,
+        endpoint: this.endpoint.index,
+        property,
+        propertyKey
+      };
+      if (NotificationCCValues.notificationVariable.is(valueId)) {
+        const notificationType = this.tryGetValueDB()?.getMetadata(valueId)?.ccSpecific?.notificationType;
+        if (notificationType != void 0) {
+          return this.getInternal({ notificationType });
+        }
+      }
+      (0, import_API.throwUnsupportedProperty)(this.ccId, property);
+    };
+  }
+  /**
+   * @internal
+   */
+  async getInternal(options) {
+    this.assertSupportsCommand(import_Types.NotificationCommand, import_Types.NotificationCommand.Get);
+    const cc = new NotificationCCGet({
+      nodeId: this.endpoint.nodeId,
+      endpointIndex: this.endpoint.index,
+      ...options
+    });
+    return this.host.sendCommand(cc, this.commandOptions);
+  }
+  async sendReport(options) {
+    __assertType("options", "NotificationCCReportOptions", __assertType__NotificationCCReportOptions.bind(void 0, options));
+    this.assertSupportsCommand(import_Types.NotificationCommand, import_Types.NotificationCommand.Report);
+    const cc = new NotificationCCReport({
+      nodeId: this.endpoint.nodeId,
+      endpointIndex: this.endpoint.index,
+      ...options
+    });
+    return this.host.sendCommand(cc, this.commandOptions);
+  }
+  async get(options) {
+    __assertType("options", "NotificationCCGetOptions", __assertType__NotificationCCGetOptions.bind(void 0, options));
+    const response = await this.getInternal(options);
+    if (response) {
+      return (0, import_safe3.pick)(response, [
+        "notificationStatus",
+        "notificationEvent",
+        "alarmLevel",
+        "eventParameters",
+        "sequenceNumber"
+      ]);
+    }
+  }
+  async set(notificationType, notificationStatus) {
+    __assertType("notificationType", "number", __assertType__number.bind(void 0, notificationType));
+    __assertType("notificationStatus", "boolean", __assertType__boolean.bind(void 0, notificationStatus));
+    this.assertSupportsCommand(import_Types.NotificationCommand, import_Types.NotificationCommand.Set);
+    const cc = new NotificationCCSet({
+      nodeId: this.endpoint.nodeId,
+      endpointIndex: this.endpoint.index,
+      notificationType,
+      notificationStatus
+    });
+    return this.host.sendCommand(cc, this.commandOptions);
+  }
+  // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
+  async getSupported() {
+    this.assertSupportsCommand(import_Types.NotificationCommand, import_Types.NotificationCommand.SupportedGet);
+    const cc = new NotificationCCSupportedGet({
+      nodeId: this.endpoint.nodeId,
+      endpointIndex: this.endpoint.index
+    });
+    const response = await this.host.sendCommand(cc, this.commandOptions);
+    if (response) {
+      return (0, import_safe3.pick)(response, [
+        "supportsV1Alarm",
+        "supportedNotificationTypes"
+      ]);
+    }
+  }
+  async getSupportedEvents(notificationType) {
+    __assertType("notificationType", "number", __assertType__number.bind(void 0, notificationType));
+    this.assertSupportsCommand(import_Types.NotificationCommand, import_Types.NotificationCommand.EventSupportedGet);
+    const cc = new NotificationCCEventSupportedGet({
+      nodeId: this.endpoint.nodeId,
+      endpointIndex: this.endpoint.index,
+      notificationType
+    });
+    const response = await this.host.sendCommand(cc, this.commandOptions);
+    return response?.supportedEvents;
+  }
+};
+NotificationCCAPI = __decorate([
+  (0, import_CommandClassDecorators.API)(import_safe.CommandClasses.Notification)
+], NotificationCCAPI);
+function getNotificationEnumBehavior(notification, valueConfig) {
+  const variable = notification.variables.find((v) => v.states.has(valueConfig.value));
+  if (!variable)
+    return "none";
+  const numStatesWithEnums = [...variable.states.values()].filter((val) => val.parameter?.type === "enum").length;
+  if (numStatesWithEnums === 0)
+    return "none";
+  if (numStatesWithEnums === 1 && variable.states.size === 1) {
+    return "replace";
+  }
+  return "extend";
+}
+function getNotificationStateValueWithEnum(stateValue, enumValue) {
+  return stateValue << 8 | enumValue;
+}
+function getNotificationValueMetadata(previous, notification, valueConfig) {
+  const metadata = previous ?? {
+    ...import_safe.ValueMetadata.ReadOnlyUInt8,
+    label: valueConfig.variableName,
+    states: {},
+    ccSpecific: {
+      notificationType: notification.type
+    }
+  };
+  if (valueConfig.idle) {
+    metadata.states[0] = "idle";
+  }
+  const enumBehavior = getNotificationEnumBehavior(notification, valueConfig);
+  if (enumBehavior !== "replace") {
+    metadata.states[valueConfig.value] = valueConfig.label;
+  }
+  if (valueConfig.parameter?.type === "enum") {
+    for (const [key, label] of Object.entries(valueConfig.parameter.values)) {
+      const value = parseInt(key);
+      const stateKey = enumBehavior === "replace" ? value : getNotificationStateValueWithEnum(valueConfig.value, value);
+      metadata.states[stateKey] = label;
+    }
+  }
+  return metadata;
+}
+let NotificationCC = NotificationCC_1 = class NotificationCC2 extends import_CommandClass.CommandClass {
+  // former AlarmCC (v1..v2)
+  determineRequiredCCInterviews() {
+    return [
+      ...super.determineRequiredCCInterviews(),
+      import_safe.CommandClasses.Association,
+      import_safe.CommandClasses["Multi Channel Association"],
+      import_safe.CommandClasses["Association Group Information"]
+    ];
+  }
+  async determineNotificationMode(ctx, api, supportedNotificationEvents) {
+    const node = this.getNode(ctx);
+    if (!node.supportsCC(import_safe.CommandClasses.Association))
+      return "pull";
+    if (node.supportsCC(import_safe.CommandClasses["Association Group Information"])) {
+      try {
+        const groupsIssueingNotifications = import_AssociationGroupInfoCC.AssociationGroupInfoCC.findGroupsForIssuedCommand(ctx, node, this.ccId, import_Types.NotificationCommand.Report);
+        return groupsIssueingNotifications.length > 0 ? "push" : "pull";
+      } catch {
+      }
+    }
+    ctx.logNode(node.id, {
+      endpoint: this.endpointIndex,
+      message: `determining whether this node is pull or push...`,
+      direction: "outbound"
+    });
+    for (const [type, events] of supportedNotificationEvents) {
+      if (events.length === 0)
+        continue;
+      await api.set(type, true);
+      try {
+        const resp = await api.get({
+          notificationType: type,
+          notificationEvent: events[0]
+        });
+        switch (resp?.notificationStatus) {
+          case 255:
+            return "push";
+          case 254:
+          case 0:
+            return "pull";
+        }
+      } catch {
+      }
+    }
+    return "push";
+  }
+  /** Whether the node implements push or pull notifications */
+  static getNotificationMode(ctx, node) {
+    return ctx.getValueDB(node.id).getValue(NotificationCCValues.notificationMode.id);
+  }
+  async interview(ctx) {
+    const node = this.getNode(ctx);
+    const endpoint = this.getEndpoint(ctx);
+    const api = import_API.CCAPI.create(import_safe.CommandClasses.Notification, ctx, endpoint).withOptions({
+      priority: import_safe.MessagePriority.NodeQuery
+    });
+    ctx.logNode(node.id, {
+      endpoint: this.endpointIndex,
+      message: `Interviewing ${this.ccName}...`,
+      direction: "none"
+    });
+    try {
+      await ccUtils.assignLifelineIssueingCommand(ctx, endpoint, this.ccId, import_Types.NotificationCommand.Report);
+    } catch {
+      ctx.logNode(node.id, {
+        endpoint: endpoint.index,
+        message: `Configuring associations to receive ${(0, import_safe.getCCName)(this.ccId)} reports failed!`,
+        level: "warn"
+      });
+    }
+    let supportsV1Alarm = false;
+    if (api.version >= 2) {
+      ctx.logNode(node.id, {
+        endpoint: this.endpointIndex,
+        message: "querying supported notification types...",
+        direction: "outbound"
+      });
+      const suppResponse = await api.getSupported();
+      if (!suppResponse) {
+        ctx.logNode(node.id, {
+          endpoint: this.endpointIndex,
+          message: "Querying supported notification types timed out, skipping interview...",
+          level: "warn"
+        });
+        return;
+      }
+      supportsV1Alarm = suppResponse.supportsV1Alarm;
+      const supportedNotificationTypes = suppResponse.supportedNotificationTypes;
+      const supportedNotificationNames = supportedNotificationTypes.map(import_core.getNotificationName);
+      const supportedNotificationEvents = /* @__PURE__ */ new Map();
+      const logMessage = `received supported notification types:${supportedNotificationNames.map((name) => `
+\xB7 ${name}`).join("")}`;
+      ctx.logNode(node.id, {
+        endpoint: this.endpointIndex,
+        message: logMessage,
+        direction: "inbound"
+      });
+      if (api.version >= 3) {
+        for (let i = 0; i < supportedNotificationTypes.length; i++) {
+          const type = supportedNotificationTypes[i];
+          const name = supportedNotificationNames[i];
+          ctx.logNode(node.id, {
+            endpoint: this.endpointIndex,
+            message: `querying supported notification events for ${name}...`,
+            direction: "outbound"
+          });
+          const supportedEvents = await api.getSupportedEvents(type);
+          if (supportedEvents) {
+            supportedNotificationEvents.set(type, supportedEvents);
+            ctx.logNode(node.id, {
+              endpoint: this.endpointIndex,
+              message: `received supported notification events for ${name}: ${supportedEvents.map(String).join(", ")}`,
+              direction: "inbound"
+            });
+          }
+        }
+      }
+      let notificationMode = this.getValue(ctx, NotificationCCValues.notificationMode);
+      if (notificationMode !== "push" && notificationMode !== "pull") {
+        notificationMode = await this.determineNotificationMode(ctx, api, supportedNotificationEvents);
+        this.setValue(ctx, NotificationCCValues.notificationMode, notificationMode);
+      }
+      if (notificationMode === "pull") {
+        await this.refreshValues(ctx);
+      } else {
+        for (let i = 0; i < supportedNotificationTypes.length; i++) {
+          const type = supportedNotificationTypes[i];
+          const name = supportedNotificationNames[i];
+          const notification = (0, import_core.getNotification)(type);
+          ctx.logNode(node.id, {
+            endpoint: this.endpointIndex,
+            message: `enabling notifications for ${name}...`,
+            direction: "outbound"
+          });
+          await api.set(type, true);
+          if (notification) {
+            const events = supportedNotificationEvents.get(type);
+            if (events) {
+              for (const variable of notification.variables.filter((v) => !!v.idle)) {
+                if ([...variable.states.keys()].some((key) => events.includes(key))) {
+                  const value = NotificationCCValues.notificationVariable(notification.name, variable.name);
+                  if (this.getValue(ctx, value) == void 0) {
+                    this.setValue(ctx, value, 0);
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+    if (api.version === 1 || supportsV1Alarm) {
+      this.ensureMetadata(ctx, NotificationCCValues.alarmType);
+      this.ensureMetadata(ctx, NotificationCCValues.alarmLevel);
+    }
+    const mappings = ctx.getDeviceConfig?.(this.nodeId)?.compat?.alarmMapping;
+    if (mappings) {
+      const supportedNotifications = /* @__PURE__ */ new Map();
+      for (const { to } of mappings) {
+        const notification = (0, import_core.getNotification)(to.notificationType);
+        if (!notification)
+          continue;
+        const valueConfig = (0, import_core.getNotificationValue)(notification, to.notificationEvent);
+        if (!supportedNotifications.has(to.notificationType)) {
+          supportedNotifications.set(to.notificationType, /* @__PURE__ */ new Set());
+        }
+        const supportedNotificationTypesSet = supportedNotifications.get(to.notificationType);
+        supportedNotificationTypesSet.add(to.notificationEvent);
+        if (valueConfig?.type !== "state")
+          continue;
+        const notificationValue = NotificationCCValues.notificationVariable(notification.name, valueConfig.variableName);
+        const metadata = getNotificationValueMetadata(this.getMetadata(ctx, notificationValue), notification, valueConfig);
+        this.setMetadata(ctx, notificationValue, metadata);
+        if (valueConfig.idle) {
+          if (this.getValue(ctx, notificationValue) == void 0) {
+            this.setValue(ctx, notificationValue, 0);
+          }
+        }
+      }
+      this.setValue(ctx, NotificationCCValues.supportedNotificationTypes, [...supportedNotifications.keys()]);
+      for (const [type, events] of supportedNotifications) {
+        this.setValue(ctx, NotificationCCValues.supportedNotificationEvents(type), [...events]);
+      }
+    }
+    this.setInterviewComplete(ctx, true);
+  }
+  async refreshValues(ctx) {
+    const node = this.getNode(ctx);
+    if (NotificationCC_1.getNotificationMode(ctx, node) === "pull") {
+      const endpoint = this.getEndpoint(ctx);
+      const api = import_API.CCAPI.create(import_safe.CommandClasses.Notification, ctx, endpoint).withOptions({
+        priority: import_safe.MessagePriority.NodeQuery
+      });
+      const supportedNotificationTypes = this.getValue(ctx, NotificationCCValues.supportedNotificationTypes) ?? [];
+      const supportedNotificationNames = supportedNotificationTypes.map(import_core.getNotificationName);
+      for (let i = 0; i < supportedNotificationTypes.length; i++) {
+        const type = supportedNotificationTypes[i];
+        const name = supportedNotificationNames[i];
+        ctx.logNode(node.id, {
+          endpoint: this.endpointIndex,
+          message: `querying notification status for ${name}...`,
+          direction: "outbound"
+        });
+        const response = await api.getInternal({
+          notificationType: type
+        });
+        if (response)
+          await node.handleCommand(response);
+      }
+      this.setValue(ctx, NotificationCCValues.lastRefresh, Date.now());
+    }
+  }
+  shouldRefreshValues(ctx) {
+    const isPullMode = NotificationCC_1.getNotificationMode(ctx, this.getNode(ctx)) === "pull";
+    if (!isPullMode)
+      return false;
+    const lastUpdated = this.getValue(ctx, NotificationCCValues.lastRefresh);
+    return lastUpdated == void 0 || Date.now() - lastUpdated > import_core.timespan.hours(6);
+  }
+};
+NotificationCC = NotificationCC_1 = __decorate([
+  (0, import_CommandClassDecorators.commandClass)(import_safe.CommandClasses.Notification),
+  (0, import_CommandClassDecorators.implementedVersion)(8),
+  (0, import_CommandClassDecorators.ccValues)(NotificationCCValues)
+], NotificationCC);
+let NotificationCCSet = NotificationCCSet_1 = class NotificationCCSet2 extends NotificationCC {
+  constructor(options) {
+    super(options);
+    this.notificationType = options.notificationType;
+    this.notificationStatus = options.notificationStatus;
+  }
+  static from(raw, ctx) {
+    (0, import_safe.validatePayload)(raw.payload.length >= 2);
+    const notificationType = raw.payload[0];
+    const notificationStatus = raw.payload[1] === 255;
+    return new NotificationCCSet_1({
+      nodeId: ctx.sourceNodeId,
+      notificationType,
+      notificationStatus
+    });
+  }
+  notificationType;
+  notificationStatus;
+  serialize(ctx) {
+    this.payload = import_safe2.Bytes.from([
+      this.notificationType,
+      this.notificationStatus ? 255 : 0
+    ]);
+    return super.serialize(ctx);
+  }
+  toLogEntry(ctx) {
+    return {
+      ...super.toLogEntry(ctx),
+      message: {
+        "notification type": (0, import_core.getNotificationName)(this.notificationType),
+        status: this.notificationStatus
+      }
+    };
+  }
+};
+NotificationCCSet = NotificationCCSet_1 = __decorate([
+  (0, import_CommandClassDecorators.CCCommand)(import_Types.NotificationCommand.Set),
+  (0, import_CommandClassDecorators.useSupervision)()
+], NotificationCCSet);
+let NotificationCCReport = NotificationCCReport_1 = class NotificationCCReport2 extends NotificationCC {
+  constructor(options) {
+    super(options);
+    if (options.alarmType != void 0) {
+      this.alarmType = options.alarmType;
+      this.alarmLevel = options.alarmLevel;
+    }
+    if (options.notificationType != void 0) {
+      this.notificationType = options.notificationType;
+      this.notificationStatus = options.notificationStatus ?? true;
+      this.notificationEvent = options.notificationEvent;
+      this.eventParameters = options.eventParameters;
+      this.sequenceNumber = options.sequenceNumber;
+    }
+  }
+  static from(raw, ctx) {
+    (0, import_safe.validatePayload)(raw.payload.length >= 2);
+    const alarmType = raw.payload[0];
+    const alarmLevel = raw.payload[1];
+    if (raw.payload.length < 7) {
+      return new NotificationCCReport_1({
+        nodeId: ctx.sourceNodeId,
+        alarmType,
+        alarmLevel
+      });
+    }
+    const notificationStatus = raw.payload[3];
+    const notificationType = raw.payload[4];
+    const notificationEvent = raw.payload[5];
+    const containsSeqNum = !!(raw.payload[6] & 128);
+    const numEventParams = raw.payload[6] & 31;
+    let eventParameters;
+    if (numEventParams > 0) {
+      (0, import_safe.validatePayload)(raw.payload.length >= 7 + numEventParams);
+      eventParameters = raw.payload.subarray(7, 7 + numEventParams);
+    }
+    let sequenceNumber;
+    if (containsSeqNum) {
+      (0, import_safe.validatePayload)(raw.payload.length >= 7 + numEventParams + 1);
+      sequenceNumber = raw.payload[7 + numEventParams];
+    }
+    return new NotificationCCReport_1({
+      nodeId: ctx.sourceNodeId,
+      alarmType,
+      alarmLevel,
+      notificationStatus,
+      notificationType,
+      notificationEvent,
+      eventParameters,
+      sequenceNumber
+    });
+  }
+  persistValues(ctx) {
+    if (!super.persistValues(ctx))
+      return false;
+    const ccVersion = (0, import_CommandClass.getEffectiveCCVersion)(ctx, this);
+    if (this.alarmType != void 0 && this.alarmLevel != void 0 && this.alarmType !== 0) {
+      if (ccVersion >= 2) {
+        const supportedNotificationTypes = this.getValue(ctx, NotificationCCValues.supportedNotificationTypes);
+        if ((0, import_typeguards.isArray)(supportedNotificationTypes) && supportedNotificationTypes.includes(this.alarmType)) {
+          const supportedNotificationEvents = this.getValue(ctx, NotificationCCValues.supportedNotificationEvents(this.alarmType));
+          if ((0, import_typeguards.isArray)(supportedNotificationEvents) && supportedNotificationEvents.includes(this.alarmLevel)) {
+            ctx.logNode(this.nodeId, `treating V1 Alarm frame as Notification Report`);
+            this.notificationType = this.alarmType;
+            this.notificationEvent = this.alarmLevel;
+            this.alarmType = void 0;
+            this.alarmLevel = void 0;
+          }
+        }
+      } else {
+        const mapping = ctx.getDeviceConfig?.(this.nodeId)?.compat?.alarmMapping;
+        const match = mapping?.find((m) => m.from.alarmType === this.alarmType && (m.from.alarmLevel == void 0 || m.from.alarmLevel === this.alarmLevel));
+        if (match) {
+          ctx.logNode(this.nodeId, `compat mapping found, treating V1 Alarm frame as Notification Report`);
+          this.notificationType = match.to.notificationType;
+          this.notificationEvent = match.to.notificationEvent;
+          if (match.to.eventParameters) {
+            this.eventParameters = {};
+            for (const [key, val] of Object.entries(match.to.eventParameters)) {
+              if (typeof val === "number") {
+                this.eventParameters[key] = val;
+              } else if (val === "alarmLevel") {
+                this.eventParameters[key] = this.alarmLevel;
+              }
+            }
+          }
+        }
+      }
+    }
+    this.parseEventParameters(ctx);
+    if (this.alarmType != void 0) {
+      const alarmTypeValue = NotificationCCValues.alarmType;
+      this.ensureMetadata(ctx, alarmTypeValue);
+      this.setValue(ctx, alarmTypeValue, this.alarmType);
+    }
+    if (this.alarmLevel != void 0) {
+      const alarmLevelValue = NotificationCCValues.alarmLevel;
+      this.ensureMetadata(ctx, alarmLevelValue);
+      this.setValue(ctx, alarmLevelValue, this.alarmLevel);
+    }
+    return true;
+  }
+  alarmType;
+  alarmLevel;
+  notificationType;
+  notificationStatus;
+  notificationEvent;
+  eventParameters;
+  sequenceNumber;
+  toLogEntry(ctx) {
+    let message = {};
+    if (this.alarmType) {
+      message = {
+        "V1 alarm type": this.alarmType,
+        "V1 alarm level": this.alarmLevel
+      };
+    }
+    let valueConfig;
+    if (this.notificationType) {
+      const notification = (0, import_core.getNotification)(this.notificationType);
+      if (notification) {
+        valueConfig = (0, import_core.getNotificationValue)(notification, this.notificationEvent);
+      }
+      if (valueConfig) {
+        message = {
+          ...message,
+          "notification type": (0, import_core.getNotificationName)(this.notificationType),
+          "notification status": this.notificationStatus,
+          [`notification ${valueConfig.type}`]: valueConfig.label ?? `Unknown (${(0, import_safe3.num2hex)(this.notificationEvent)})`
+        };
+      } else if (this.notificationEvent === 0) {
+        message = {
+          ...message,
+          "notification type": this.notificationType,
+          "notification status": this.notificationStatus,
+          "notification state": "idle"
+        };
+      } else {
+        message = {
+          ...message,
+          "notification type": this.notificationType,
+          "notification status": this.notificationStatus,
+          "notification event": (0, import_safe3.num2hex)(this.notificationEvent)
+        };
+      }
+    }
+    if (this.sequenceNumber != void 0) {
+      message["sequence number"] = this.sequenceNumber;
+    }
+    if (this.eventParameters != void 0) {
+      if (typeof this.eventParameters === "number") {
+        let found = false;
+        if (valueConfig?.parameter?.type === "enum") {
+          const label = valueConfig.parameter.values[this.eventParameters];
+          if (label) {
+            message["state parameters"] = label;
+            found = true;
+          }
+        }
+        if (!found) {
+          message["state parameters"] = (0, import_safe3.num2hex)(this.eventParameters);
+        }
+      } else if ((0, import_safe2.isUint8Array)(this.eventParameters)) {
+        message["event parameters"] = (0, import_safe3.buffer2hex)(this.eventParameters);
+      } else if (this.eventParameters instanceof import_safe.Duration) {
+        message["event parameters"] = this.eventParameters.toString();
+      } else {
+        message["event parameters"] = Object.entries(this.eventParameters).map(([param, val]) => `
+  ${param}: ${(0, import_safe3.num2hex)(val)}`).join("");
+      }
+    } else if (valueConfig?.parameter?.type === "enum" && valueConfig.parameter.default != void 0) {
+      const label = valueConfig.parameter.values[valueConfig.parameter.default];
+      if (label) {
+        message["state parameters"] = `${label} (omitted)`;
+      }
+    }
+    return {
+      ...super.toLogEntry(ctx),
+      message
+    };
+  }
+  parseEventParameters(ctx) {
+    if (this.notificationType == void 0 || this.notificationEvent == void 0) {
+      return;
+    }
+    const notification = (0, import_core.getNotification)(this.notificationType);
+    if (!notification)
+      return;
+    const valueConfig = (0, import_core.getNotificationValue)(notification, this.notificationEvent);
+    if (!valueConfig)
+      return;
+    if (valueConfig.parameter?.type === "duration") {
+      if (!(0, import_safe2.isUint8Array)(this.eventParameters)) {
+        return;
+      }
+      this.eventParameters = import_safe.Duration.parseReport(this.eventParameters[0]);
+    } else if (valueConfig.parameter?.type === "commandclass") {
+      if (!(0, import_safe2.isUint8Array)(this.eventParameters)) {
+        return;
+      }
+      if (this.eventParameters.length === 1 && notification.type === 6 && (this.notificationEvent === 5 || this.notificationEvent === 6)) {
+        this.eventParameters = {
+          userId: this.eventParameters[0]
+        };
+      } else {
+        try {
+          const cc = import_CommandClass.CommandClass.parse(this.eventParameters, {
+            ...ctx,
+            frameType: "singlecast",
+            sourceNodeId: this.nodeId,
+            // Security encapsulation is handled outside of this CC,
+            // so it is not needed here:
+            hasSecurityClass: () => false,
+            getHighestSecurityClass: () => import_safe.SecurityClass.None,
+            setSecurityClass: () => {
+            },
+            securityManager: void 0,
+            securityManager2: void 0,
+            securityManagerLR: void 0
+          });
+          (0, import_safe.validatePayload)(!(cc instanceof import_CommandClass.InvalidCC));
+          cc.encapsulatingCC = this;
+          if ((0, import_NotificationEventPayload.isNotificationEventPayload)(cc)) {
+            this.eventParameters = cc.toNotificationEventParameters();
+          } else {
+            let json = cc.toJSON();
+            if ("nodeId" in json && "ccId" in json && "payload" in json) {
+              json = (0, import_safe3.pick)(json, ["payload"]);
+            }
+            this.eventParameters = json;
+          }
+        } catch (e) {
+          if ((0, import_safe.isZWaveError)(e) && e.code === import_safe.ZWaveErrorCodes.PacketFormat_InvalidPayload && (0, import_safe2.isUint8Array)(this.eventParameters)) {
+            const { ccId, ccCommand } = import_CommandClass.CCRaw.parse(this.eventParameters);
+            if (ccId === import_safe.CommandClasses["User Code"] && ccCommand === import_Types.UserCodeCommand.Report && this.eventParameters.length >= 3) {
+              this.eventParameters = {
+                userId: this.eventParameters[2]
+              };
+            } else {
+              ctx.logNode(this.nodeId, `Failed to parse Notification CC event parameters, ignoring them...`, "error");
+            }
+          } else {
+            throw e;
+          }
+        }
+      }
+    } else if (valueConfig.parameter?.type === "value") {
+      if (!(0, import_safe2.isUint8Array)(this.eventParameters)) {
+        return;
+      }
+      this.eventParameters = {
+        [valueConfig.parameter.propertyName]: import_safe2.Bytes.view(this.eventParameters).readUIntBE(0, this.eventParameters.length)
+      };
+    } else if (valueConfig.parameter?.type === "enum") {
+      this.eventParameters = (0, import_safe2.isUint8Array)(this.eventParameters) && this.eventParameters.length === 1 ? this.eventParameters[0] : void 0;
+      if (this.eventParameters == void 0 && valueConfig.parameter.default != void 0) {
+        this.eventParameters = valueConfig.parameter.default;
+      }
+    }
+  }
+  serialize(ctx) {
+    if (this.notificationType != void 0) {
+      if (this.notificationEvent == void 0) {
+        throw new import_safe.ZWaveError(`Notification CC reports requires the notification event to be set!`, import_safe.ZWaveErrorCodes.Argument_Invalid);
+      } else if (this.eventParameters != void 0 && !(0, import_safe2.isUint8Array)(this.eventParameters)) {
+        throw new import_safe.ZWaveError(`When sending Notification CC reports, the event parameters can only be buffers!`, import_safe.ZWaveErrorCodes.Argument_Invalid);
+      }
+      const controlByte = (this.sequenceNumber != void 0 ? 128 : 0) | (this.eventParameters?.length ?? 0) & 31;
+      this.payload = import_safe2.Bytes.from([
+        0,
+        0,
+        0,
+        255,
+        this.notificationType,
+        this.notificationEvent,
+        controlByte
+      ]);
+      if (this.eventParameters) {
+        this.payload = import_safe2.Bytes.concat([
+          this.payload,
+          this.eventParameters
+        ]);
+      }
+      if (this.sequenceNumber != void 0) {
+        this.payload = import_safe2.Bytes.concat([
+          this.payload,
+          import_safe2.Bytes.from([this.sequenceNumber])
+        ]);
+      }
+    } else {
+      this.payload = import_safe2.Bytes.from([
+        this.alarmType ?? 0,
+        this.alarmLevel ?? 0
+      ]);
+    }
+    return super.serialize(ctx);
+  }
+};
+NotificationCCReport = NotificationCCReport_1 = __decorate([
+  (0, import_CommandClassDecorators.CCCommand)(import_Types.NotificationCommand.Report),
+  (0, import_CommandClassDecorators.useSupervision)()
+], NotificationCCReport);
+let NotificationCCGet = NotificationCCGet_1 = class NotificationCCGet2 extends NotificationCC {
+  constructor(options) {
+    super(options);
+    if ("alarmType" in options) {
+      this.alarmType = options.alarmType;
+    } else {
+      this.notificationType = options.notificationType;
+      this.notificationEvent = options.notificationEvent;
+    }
+  }
+  static from(raw, ctx) {
+    (0, import_safe.validatePayload)(raw.payload.length >= 1);
+    if (raw.payload.length >= 2) {
+      const notificationType = raw.payload[1];
+      let notificationEvent;
+      if (raw.payload.length >= 3 && notificationType != 255) {
+        notificationEvent = raw.payload[2];
+      }
+      return new NotificationCCGet_1({
+        nodeId: ctx.sourceNodeId,
+        notificationType,
+        notificationEvent
+      });
+    } else {
+      const alarmType = raw.payload[0];
+      return new NotificationCCGet_1({
+        nodeId: ctx.sourceNodeId,
+        alarmType
+      });
+    }
+  }
+  /** Proprietary V1/V2 alarm type */
+  alarmType;
+  /** Regulated V3+ notification type */
+  notificationType;
+  notificationEvent;
+  serialize(ctx) {
+    const notificationEvent = this.notificationEvent === 255 ? 0 : this.notificationEvent;
+    this.payload = import_safe2.Bytes.from([
+      this.alarmType ?? 0,
+      this.notificationType ?? 255,
+      notificationEvent ?? 0
+    ]);
+    return super.serialize(ctx);
+  }
+  toLogEntry(ctx) {
+    const message = {};
+    if (this.alarmType != void 0) {
+      message["V1 alarm type"] = this.alarmType;
+    }
+    if (this.notificationType != void 0) {
+      message["notification type"] = (0, import_core.getNotificationName)(this.notificationType);
+      if (this.notificationEvent != void 0) {
+        message["notification event"] = (0, import_core.getNotificationEventName)(this.notificationType, this.notificationEvent);
+      }
+    }
+    return {
+      ...super.toLogEntry(ctx),
+      message
+    };
+  }
+};
+NotificationCCGet = NotificationCCGet_1 = __decorate([
+  (0, import_CommandClassDecorators.CCCommand)(import_Types.NotificationCommand.Get),
+  (0, import_CommandClassDecorators.expectedCCResponse)(NotificationCCReport)
+], NotificationCCGet);
+let NotificationCCSupportedReport = NotificationCCSupportedReport_1 = class NotificationCCSupportedReport2 extends NotificationCC {
+  constructor(options) {
+    super(options);
+    this.supportsV1Alarm = options.supportsV1Alarm;
+    this.supportedNotificationTypes = options.supportedNotificationTypes;
+  }
+  static from(raw, ctx) {
+    (0, import_safe.validatePayload)(raw.payload.length >= 1);
+    const supportsV1Alarm = !!(raw.payload[0] & 128);
+    const numBitMaskBytes = raw.payload[0] & 31;
+    (0, import_safe.validatePayload)(numBitMaskBytes > 0, raw.payload.length >= 1 + numBitMaskBytes);
+    const notificationBitMask = raw.payload.subarray(1, 1 + numBitMaskBytes);
+    const supportedNotificationTypes = (0, import_safe.parseBitMask)(
+      notificationBitMask,
+      // bit 0 is ignored, but counting still starts at 1, so the first bit must have the value 0
+      0
+    );
+    return new NotificationCCSupportedReport_1({
+      nodeId: ctx.sourceNodeId,
+      supportsV1Alarm,
+      supportedNotificationTypes
+    });
+  }
+  supportsV1Alarm;
+  supportedNotificationTypes;
+  serialize(ctx) {
+    const bitMask = (0, import_safe.encodeBitMask)(this.supportedNotificationTypes, Math.max(...this.supportedNotificationTypes), 0);
+    this.payload = import_safe2.Bytes.concat([
+      import_safe2.Bytes.from([
+        (this.supportsV1Alarm ? 128 : 0) | bitMask.length
+      ]),
+      bitMask
+    ]);
+    return super.serialize(ctx);
+  }
+  toLogEntry(ctx) {
+    return {
+      ...super.toLogEntry(ctx),
+      message: {
+        "supports V1 alarm": this.supportsV1Alarm,
+        "supported notification types": this.supportedNotificationTypes.map((t) => `
+\xB7 ${(0, import_core.getNotificationName)(t)}`).join("")
+      }
+    };
+  }
+};
+__decorate([
+  (0, import_CommandClassDecorators.ccValue)(NotificationCCValues.supportsV1Alarm)
+], NotificationCCSupportedReport.prototype, "supportsV1Alarm", void 0);
+__decorate([
+  (0, import_CommandClassDecorators.ccValue)(NotificationCCValues.supportedNotificationTypes)
+], NotificationCCSupportedReport.prototype, "supportedNotificationTypes", void 0);
+NotificationCCSupportedReport = NotificationCCSupportedReport_1 = __decorate([
+  (0, import_CommandClassDecorators.CCCommand)(import_Types.NotificationCommand.SupportedReport)
+], NotificationCCSupportedReport);
+let NotificationCCSupportedGet = class NotificationCCSupportedGet2 extends NotificationCC {
+};
+NotificationCCSupportedGet = __decorate([
+  (0, import_CommandClassDecorators.CCCommand)(import_Types.NotificationCommand.SupportedGet),
+  (0, import_CommandClassDecorators.expectedCCResponse)(NotificationCCSupportedReport)
+], NotificationCCSupportedGet);
+let NotificationCCEventSupportedReport = NotificationCCEventSupportedReport_1 = class NotificationCCEventSupportedReport2 extends NotificationCC {
+  constructor(options) {
+    super(options);
+    this.notificationType = options.notificationType;
+    this.supportedEvents = options.supportedEvents;
+  }
+  static from(raw, ctx) {
+    (0, import_safe.validatePayload)(raw.payload.length >= 1);
+    const notificationType = raw.payload[0];
+    const numBitMaskBytes = raw.payload[1] & 31;
+    if (numBitMaskBytes === 0) {
+      return new NotificationCCEventSupportedReport_1({
+        nodeId: ctx.sourceNodeId,
+        notificationType,
+        supportedEvents: []
+      });
+    }
+    (0, import_safe.validatePayload)(raw.payload.length >= 2 + numBitMaskBytes);
+    const eventBitMask = raw.payload.subarray(2, 2 + numBitMaskBytes);
+    const supportedEvents = (0, import_safe.parseBitMask)(
+      eventBitMask,
+      // In this mask, bit 0 is ignored, but counting still starts at 1, so the first bit must have the value 0
+      0
+    );
+    return new NotificationCCEventSupportedReport_1({
+      nodeId: ctx.sourceNodeId,
+      notificationType,
+      supportedEvents
+    });
+  }
+  persistValues(ctx) {
+    if (!super.persistValues(ctx))
+      return false;
+    this.setValue(ctx, NotificationCCValues.supportedNotificationEvents(this.notificationType), this.supportedEvents);
+    const notification = (0, import_core.getNotification)(this.notificationType);
+    if (!notification) {
+      this.setMetadata(ctx, NotificationCCValues.unknownNotificationType(this.notificationType));
+    } else {
+      let isFirst = true;
+      for (const value of this.supportedEvents) {
+        const valueConfig = (0, import_core.getNotificationValue)(notification, value);
+        if (valueConfig?.type === "state") {
+          const notificationValue = NotificationCCValues.notificationVariable(notification.name, valueConfig.variableName);
+          const metadata = getNotificationValueMetadata(isFirst ? void 0 : this.getMetadata(ctx, notificationValue), notification, valueConfig);
+          this.setMetadata(ctx, notificationValue, metadata);
+          isFirst = false;
+        }
+      }
+    }
+    return true;
+  }
+  notificationType;
+  supportedEvents;
+  serialize(ctx) {
+    this.payload = import_safe2.Bytes.from([this.notificationType, 0]);
+    if (this.supportedEvents.length > 0) {
+      const bitMask = (0, import_safe.encodeBitMask)(this.supportedEvents, Math.max(...this.supportedEvents), 0);
+      this.payload[1] = bitMask.length;
+      this.payload = import_safe2.Bytes.concat([this.payload, bitMask]);
+    }
+    return super.serialize(ctx);
+  }
+  toLogEntry(ctx) {
+    return {
+      ...super.toLogEntry(ctx),
+      message: {
+        "notification type": (0, import_core.getNotificationName)(this.notificationType),
+        "supported events": this.supportedEvents.map((e) => `
+\xB7 ${(0, import_core.getNotificationValueName)(this.notificationType, e)}`).join("")
+      }
+    };
+  }
+};
+NotificationCCEventSupportedReport = NotificationCCEventSupportedReport_1 = __decorate([
+  (0, import_CommandClassDecorators.CCCommand)(import_Types.NotificationCommand.EventSupportedReport)
+], NotificationCCEventSupportedReport);
+let NotificationCCEventSupportedGet = NotificationCCEventSupportedGet_1 = class NotificationCCEventSupportedGet2 extends NotificationCC {
+  constructor(options) {
+    super(options);
+    this.notificationType = options.notificationType;
+  }
+  static from(raw, ctx) {
+    (0, import_safe.validatePayload)(raw.payload.length >= 1);
+    const notificationType = raw.payload[0];
+    return new NotificationCCEventSupportedGet_1({
+      nodeId: ctx.sourceNodeId,
+      notificationType
+    });
+  }
+  notificationType;
+  serialize(ctx) {
+    this.payload = import_safe2.Bytes.from([this.notificationType]);
+    return super.serialize(ctx);
+  }
+  toLogEntry(ctx) {
+    return {
+      ...super.toLogEntry(ctx),
+      message: {
+        "notification type": (0, import_core.getNotificationName)(this.notificationType)
+      }
+    };
+  }
+};
+NotificationCCEventSupportedGet = NotificationCCEventSupportedGet_1 = __decorate([
+  (0, import_CommandClassDecorators.CCCommand)(import_Types.NotificationCommand.EventSupportedGet),
+  (0, import_CommandClassDecorators.expectedCCResponse)(NotificationCCEventSupportedReport)
+], NotificationCCEventSupportedGet);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  NotificationCC,
+  NotificationCCAPI,
+  NotificationCCEventSupportedGet,
+  NotificationCCEventSupportedReport,
+  NotificationCCGet,
+  NotificationCCReport,
+  NotificationCCSet,
+  NotificationCCSupportedGet,
+  NotificationCCSupportedReport,
+  NotificationCCValues,
+  getNotificationEnumBehavior,
+  getNotificationStateValueWithEnum,
+  getNotificationValueMetadata
+});
+//# sourceMappingURL=NotificationCC.js.map