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

package/build/cjs/cc/NotificationCC.js

@@ -0,0 +1,1399 @@
+"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 __esDecorate = function(ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+  function accept(f) {
+    if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected");
+    return f;
+  }
+  var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+  var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+  var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+  var _, done = false;
+  for (var i = decorators.length - 1; i >= 0; i--) {
+    var context = {};
+    for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+    for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+    context.addInitializer = function(f) {
+      if (done) throw new TypeError("Cannot add initializers after decoration has completed");
+      extraInitializers.push(accept(f || null));
+    };
+    var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+    if (kind === "accessor") {
+      if (result === void 0) continue;
+      if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+      if (_ = accept(result.get)) descriptor.get = _;
+      if (_ = accept(result.set)) descriptor.set = _;
+      if (_ = accept(result.init)) initializers.unshift(_);
+    } else if (_ = accept(result)) {
+      if (kind === "field") initializers.unshift(_);
+      else descriptor[key] = _;
+    }
+  }
+  if (target) Object.defineProperty(target, contextIn.name, descriptor);
+  done = true;
+};
+var __runInitializers = function(thisArg, initializers, value) {
+  var useValue = arguments.length > 2;
+  for (var i = 0; i < initializers.length; i++) {
+    value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+  }
+  return useValue ? value : void 0;
+};
+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 = (() => {
+  let _classDecorators = [(0, import_CommandClassDecorators.API)(import_safe.CommandClasses.Notification)];
+  let _classDescriptor;
+  let _classExtraInitializers = [];
+  let _classThis;
+  let _classSuper = import_API.PhysicalCCAPI;
+  var NotificationCCAPI2 = class extends _classSuper {
+    static {
+      _classThis = this;
+    }
+    static {
+      const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+      __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+      NotificationCCAPI2 = _classThis = _classDescriptor.value;
+      if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+      __runInitializers(_classThis, _classExtraInitializers);
+    }
+    supportsCommand(cmd) {
+      switch (cmd) {
+        case import_Types.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;
+    }
+  };
+  return NotificationCCAPI2 = _classThis;
+})();
+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 = (() => {
+  let _classDecorators = [(0, import_CommandClassDecorators.commandClass)(import_safe.CommandClasses.Notification), (0, import_CommandClassDecorators.implementedVersion)(8), (0, import_CommandClassDecorators.ccValues)(NotificationCCValues)];
+  let _classDescriptor;
+  let _classExtraInitializers = [];
+  let _classThis;
+  let _classSuper = import_CommandClass.CommandClass;
+  var NotificationCC2 = class extends _classSuper {
+    static {
+      _classThis = this;
+    }
+    static {
+      const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+      __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+      NotificationCC2 = _classThis = _classDescriptor.value;
+      if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+      __runInitializers(_classThis, _classExtraInitializers);
+    }
+    // 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 (NotificationCC2.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 = NotificationCC2.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);
+    }
+  };
+  return NotificationCC2 = _classThis;
+})();
+let NotificationCCSet = (() => {
+  let _classDecorators = [(0, import_CommandClassDecorators.CCCommand)(import_Types.NotificationCommand.Set), (0, import_CommandClassDecorators.useSupervision)()];
+  let _classDescriptor;
+  let _classExtraInitializers = [];
+  let _classThis;
+  let _classSuper = NotificationCC;
+  var NotificationCCSet2 = class extends _classSuper {
+    static {
+      _classThis = this;
+    }
+    static {
+      const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+      __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+      NotificationCCSet2 = _classThis = _classDescriptor.value;
+      if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+      __runInitializers(_classThis, _classExtraInitializers);
+    }
+    constructor(options) {
+      super(options);
+      this.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 this({
+        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
+        }
+      };
+    }
+  };
+  return NotificationCCSet2 = _classThis;
+})();
+let NotificationCCReport = (() => {
+  let _classDecorators = [(0, import_CommandClassDecorators.CCCommand)(import_Types.NotificationCommand.Report), (0, import_CommandClassDecorators.useSupervision)()];
+  let _classDescriptor;
+  let _classExtraInitializers = [];
+  let _classThis;
+  let _classSuper = NotificationCC;
+  var NotificationCCReport2 = class extends _classSuper {
+    static {
+      _classThis = this;
+    }
+    static {
+      const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+      __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+      NotificationCCReport2 = _classThis = _classDescriptor.value;
+      if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+      __runInitializers(_classThis, _classExtraInitializers);
+    }
+    constructor(options) {
+      super(options);
+      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 this({
+          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 this({
+        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);
+    }
+  };
+  return NotificationCCReport2 = _classThis;
+})();
+let NotificationCCGet = (() => {
+  let _classDecorators = [(0, import_CommandClassDecorators.CCCommand)(import_Types.NotificationCommand.Get), (0, import_CommandClassDecorators.expectedCCResponse)(NotificationCCReport)];
+  let _classDescriptor;
+  let _classExtraInitializers = [];
+  let _classThis;
+  let _classSuper = NotificationCC;
+  var NotificationCCGet2 = class extends _classSuper {
+    static {
+      _classThis = this;
+    }
+    static {
+      const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+      __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+      NotificationCCGet2 = _classThis = _classDescriptor.value;
+      if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+      __runInitializers(_classThis, _classExtraInitializers);
+    }
+    constructor(options) {
+      super(options);
+      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 this({
+          nodeId: ctx.sourceNodeId,
+          notificationType,
+          notificationEvent
+        });
+      } else {
+        const alarmType = raw.payload[0];
+        return new this({
+          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
+      };
+    }
+  };
+  return NotificationCCGet2 = _classThis;
+})();
+let NotificationCCSupportedReport = (() => {
+  let _classDecorators = [(0, import_CommandClassDecorators.CCCommand)(import_Types.NotificationCommand.SupportedReport), (0, import_CommandClassDecorators.ccValueProperty)("supportsV1Alarm", NotificationCCValues.supportsV1Alarm), (0, import_CommandClassDecorators.ccValueProperty)("supportedNotificationTypes", NotificationCCValues.supportedNotificationTypes)];
+  let _classDescriptor;
+  let _classExtraInitializers = [];
+  let _classThis;
+  let _classSuper = NotificationCC;
+  var NotificationCCSupportedReport2 = class extends _classSuper {
+    static {
+      _classThis = this;
+    }
+    static {
+      const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+      __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+      NotificationCCSupportedReport2 = _classThis = _classDescriptor.value;
+      if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+      __runInitializers(_classThis, _classExtraInitializers);
+    }
+    constructor(options) {
+      super(options);
+      this.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 this({
+        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("")
+        }
+      };
+    }
+  };
+  return NotificationCCSupportedReport2 = _classThis;
+})();
+let NotificationCCSupportedGet = (() => {
+  let _classDecorators = [(0, import_CommandClassDecorators.CCCommand)(import_Types.NotificationCommand.SupportedGet), (0, import_CommandClassDecorators.expectedCCResponse)(NotificationCCSupportedReport)];
+  let _classDescriptor;
+  let _classExtraInitializers = [];
+  let _classThis;
+  let _classSuper = NotificationCC;
+  var NotificationCCSupportedGet2 = class extends _classSuper {
+    static {
+      _classThis = this;
+    }
+    static {
+      const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+      __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+      NotificationCCSupportedGet2 = _classThis = _classDescriptor.value;
+      if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+      __runInitializers(_classThis, _classExtraInitializers);
+    }
+  };
+  return NotificationCCSupportedGet2 = _classThis;
+})();
+let NotificationCCEventSupportedReport = (() => {
+  let _classDecorators = [(0, import_CommandClassDecorators.CCCommand)(import_Types.NotificationCommand.EventSupportedReport)];
+  let _classDescriptor;
+  let _classExtraInitializers = [];
+  let _classThis;
+  let _classSuper = NotificationCC;
+  var NotificationCCEventSupportedReport2 = class extends _classSuper {
+    static {
+      _classThis = this;
+    }
+    static {
+      const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+      __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+      NotificationCCEventSupportedReport2 = _classThis = _classDescriptor.value;
+      if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+      __runInitializers(_classThis, _classExtraInitializers);
+    }
+    constructor(options) {
+      super(options);
+      this.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 this({
+          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 this({
+        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("")
+        }
+      };
+    }
+  };
+  return NotificationCCEventSupportedReport2 = _classThis;
+})();
+let NotificationCCEventSupportedGet = (() => {
+  let _classDecorators = [(0, import_CommandClassDecorators.CCCommand)(import_Types.NotificationCommand.EventSupportedGet), (0, import_CommandClassDecorators.expectedCCResponse)(NotificationCCEventSupportedReport)];
+  let _classDescriptor;
+  let _classExtraInitializers = [];
+  let _classThis;
+  let _classSuper = NotificationCC;
+  var NotificationCCEventSupportedGet2 = class extends _classSuper {
+    static {
+      _classThis = this;
+    }
+    static {
+      const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+      __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+      NotificationCCEventSupportedGet2 = _classThis = _classDescriptor.value;
+      if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+      __runInitializers(_classThis, _classExtraInitializers);
+    }
+    constructor(options) {
+      super(options);
+      this.notificationType = options.notificationType;
+    }
+    static from(raw, ctx) {
+      (0, import_safe.validatePayload)(raw.payload.length >= 1);
+      const notificationType = raw.payload[0];
+      return new this({
+        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)
+        }
+      };
+    }
+  };
+  return NotificationCCEventSupportedGet2 = _classThis;
+})();
+// 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