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

package/build/esm/cc/NotificationCC.js

@@ -0,0 +1,1350 @@
+var __decorate = (this && this.__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, ZWaveErrorCodes } = require("@zwave-js/core");
+    if (boundHasError()) {
+        throw new ZWaveError(typeName ? `${argName} is not a ${typeName}` : `${argName} has the wrong type`, ZWaveErrorCodes.Argument_Invalid);
+    }
+}
+const __assertType__NotificationCCReportOptions = $o => {
+    function _number($o) {
+        return typeof $o !== "number" ? {} : null;
+    }
+    function _uint8array($o) {
+        return !require("@zwave-js/shared/safe").isUint8Array($o) ? {} : null;
+    }
+    function _0($o) {
+        if (typeof $o !== "object" || $o === null || Array.isArray($o))
+            return {};
+        if ("alarmType" in $o && $o["alarmType"] !== undefined) {
+            const error = _number($o["alarmType"]);
+            if (error)
+                return error;
+        }
+        if ("alarmLevel" in $o && $o["alarmLevel"] !== undefined) {
+            const error = _number($o["alarmLevel"]);
+            if (error)
+                return error;
+        }
+        if ("notificationType" in $o && $o["notificationType"] !== undefined) {
+            const error = _number($o["notificationType"]);
+            if (error)
+                return error;
+        }
+        if ("notificationEvent" in $o && $o["notificationEvent"] !== undefined) {
+            const error = _number($o["notificationEvent"]);
+            if (error)
+                return error;
+        }
+        if ("notificationStatus" in $o && $o["notificationStatus"] !== undefined) {
+            const error = _number($o["notificationStatus"]);
+            if (error)
+                return error;
+        }
+        if ("eventParameters" in $o && $o["eventParameters"] !== undefined) {
+            const error = _uint8array($o["eventParameters"]);
+            if (error)
+                return error;
+        }
+        if ("sequenceNumber" in $o && $o["sequenceNumber"] !== undefined) {
+            const error = _number($o["sequenceNumber"]);
+            if (error)
+                return error;
+        }
+        return null;
+    }
+    return _0($o);
+};
+const __assertType__NotificationCCGetOptions = $o => {
+    function _number($o) {
+        return typeof $o !== "number" ? {} : null;
+    }
+    function _1($o) {
+        if (typeof $o !== "object" || $o === null || Array.isArray($o))
+            return {};
+        if ("alarmType" in $o && $o["alarmType"] !== undefined) {
+            const error = _number($o["alarmType"]);
+            if (error)
+                return error;
+        }
+        else
+            return {};
+        return null;
+    }
+    function _2($o) {
+        if (typeof $o !== "object" || $o === null || Array.isArray($o))
+            return {};
+        if ("notificationType" in $o && $o["notificationType"] !== undefined) {
+            const error = _number($o["notificationType"]);
+            if (error)
+                return error;
+        }
+        else
+            return {};
+        if ("notificationEvent" in $o && $o["notificationEvent"] !== undefined) {
+            const error = _number($o["notificationEvent"]);
+            if (error)
+                return error;
+        }
+        return null;
+    }
+    function su__1__2_eu($o) {
+        const conditions = [_1, _2];
+        for (const condition of conditions) {
+            const error = condition($o);
+            if (!error)
+                return null;
+        }
+        return {};
+    }
+    return su__1__2_eu($o);
+};
+const __assertType__number = $o => {
+    function _number($o) {
+        return typeof $o !== "number" ? {} : null;
+    }
+    return _number($o);
+};
+const __assertType__boolean = $o => {
+    function _boolean($o) {
+        return typeof $o !== "boolean" ? {} : null;
+    }
+    return _boolean($o);
+};
+import { getNotification, getNotificationEventName, getNotificationName, getNotificationValue, getNotificationValueName, timespan, } from "@zwave-js/core";
+import { CommandClasses, Duration, MessagePriority, SecurityClass, ValueMetadata, ZWaveError, ZWaveErrorCodes, encodeBitMask, getCCName, isZWaveError, parseBitMask, validatePayload, } from "@zwave-js/core/safe";
+import { Bytes, isUint8Array } from "@zwave-js/shared/safe";
+import { buffer2hex, num2hex, pick } from "@zwave-js/shared/safe";
+import { isArray } from "alcalzone-shared/typeguards/index.js";
+import { CCAPI, POLL_VALUE, PhysicalCCAPI, throwUnsupportedProperty, } from "../lib/API.js";
+import { CCRaw, CommandClass, InvalidCC, getEffectiveCCVersion, } from "../lib/CommandClass.js";
+import { API, CCCommand, ccValue, ccValues, commandClass, expectedCCResponse, implementedVersion, useSupervision, } from "../lib/CommandClassDecorators.js";
+import { isNotificationEventPayload } from "../lib/NotificationEventPayload.js";
+import { V } from "../lib/Values.js";
+import { NotificationCommand, UserCodeCommand } from "../lib/_Types.js";
+import * as ccUtils from "../lib/utils.js";
+import { AssociationGroupInfoCC } from "./AssociationGroupInfoCC.js";
+export const NotificationCCValues = Object.freeze({
+    ...V.defineStaticCCValues(CommandClasses.Notification, {
+        ...V.staticProperty("supportsV1Alarm", undefined, {
+            internal: true,
+            supportsEndpoints: false,
+        }),
+        ...V.staticProperty("supportedNotificationTypes", undefined, {
+            internal: true,
+            supportsEndpoints: false,
+        }),
+        ...V.staticProperty("notificationMode", undefined, {
+            internal: true,
+            supportsEndpoints: false,
+        }),
+        ...V.staticProperty("lastRefresh", undefined, {
+            internal: true,
+        }),
+        // V1 Alarm values
+        ...V.staticProperty("alarmType", {
+            ...ValueMetadata.ReadOnlyUInt8,
+            label: "Alarm Type",
+        }),
+        ...V.staticProperty("alarmLevel", {
+            ...ValueMetadata.ReadOnlyUInt8,
+            label: "Alarm Level",
+        }),
+        // Simplification for the Door state variable, where we cannot know
+        // if any of the enum values are supported
+        ...V.staticPropertyAndKeyWithName("doorStateSimple", "Access Control", "Door state (simple)", {
+            // Must be a number for compatibility reasons
+            ...ValueMetadata.ReadOnlyUInt8,
+            label: "Door state (simple)",
+            states: {
+                [0x16]: "Window/door is open",
+                [0x17]: "Window/door is closed",
+            },
+            ccSpecific: {
+                notificationType: 0x06,
+            },
+        }, {
+            autoCreate: shouldAutoCreateSimpleDoorSensorValue,
+        }),
+        // Binary tilt value extracted from the Door state variable.
+        ...V.staticPropertyAndKeyWithName("doorTiltState", "Access Control", "Door tilt state", {
+            // Must be a number for compatibility reasons
+            ...ValueMetadata.ReadOnlyUInt8,
+            label: "Door tilt state",
+            states: {
+                [0x00]: "Window/door is not tilted",
+                [0x01]: "Window/door is tilted",
+            },
+            ccSpecific: {
+                notificationType: 0x06,
+            },
+        }, {
+            // This is created when the tilt state is first received.
+            autoCreate: false,
+        }),
+    }),
+    ...V.defineDynamicCCValues(CommandClasses.Notification, {
+        ...V.dynamicPropertyAndKeyWithName("supportedNotificationEvents", "supportedNotificationEvents", (notificationType) => notificationType, ({ property, propertyKey }) => property === "supportedNotificationEvents"
+            && typeof propertyKey === "number", undefined, { internal: true, supportsEndpoints: false }),
+        // Different variants of the V2 notification values:
+        // Unknown type
+        ...V.dynamicPropertyWithName("unknownNotificationType", (notificationType) => `UNKNOWN_${num2hex(notificationType)}`, ({ property }) => typeof property === "string"
+            && property.startsWith("UNKNOWN_0x"), (notificationType) => ({
+            ...ValueMetadata.ReadOnlyUInt8,
+            label: `Unknown notification (${num2hex(notificationType)})`,
+            ccSpecific: { notificationType },
+        })),
+        // Known type, unknown variable
+        ...V.dynamicPropertyAndKeyWithName("unknownNotificationVariable", (notificationType, notificationName) => notificationName, "unknown", ({ property, propertyKey }) => typeof property === "string" && propertyKey === "unknown", (notificationType, notificationName) => ({
+            ...ValueMetadata.ReadOnlyUInt8,
+            label: `${notificationName}: Unknown value`,
+            ccSpecific: { notificationType },
+        })),
+        // (Stateful) notification variable
+        ...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
+        undefined),
+    }),
+});
+function shouldAutoCreateSimpleDoorSensorValue(ctx, endpoint) {
+    const valueDB = ctx.tryGetValueDB(endpoint.nodeId);
+    if (!valueDB)
+        return false;
+    const supportedACEvents = valueDB.getValue(NotificationCCValues.supportedNotificationEvents(
+    // Access Control
+    0x06).endpoint(endpoint.index));
+    if (!supportedACEvents)
+        return false;
+    return (supportedACEvents.includes(
+    // Window/door is open
+    0x16)
+        && supportedACEvents.includes(
+        // Window/door is closed
+        0x17));
+}
+let NotificationCCAPI = class NotificationCCAPI extends PhysicalCCAPI {
+    supportsCommand(cmd) {
+        switch (cmd) {
+            case NotificationCommand.Report:
+            case NotificationCommand.Get:
+                return true; // These exist starting with V1
+            case NotificationCommand.Set:
+            case NotificationCommand.SupportedGet:
+                return this.version >= 2;
+            case NotificationCommand.EventSupportedGet:
+                return this.version >= 3;
+        }
+        return super.supportsCommand(cmd);
+    }
+    get [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 != undefined) {
+                    return this.getInternal({ notificationType });
+                }
+            }
+            throwUnsupportedProperty(this.ccId, property);
+        };
+    }
+    /**
+     * @internal
+     */
+    async getInternal(options) {
+        this.assertSupportsCommand(NotificationCommand, 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(NotificationCommand, 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 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(NotificationCommand, 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(NotificationCommand, 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 pick(response, [
+                "supportsV1Alarm",
+                "supportedNotificationTypes",
+            ]);
+        }
+    }
+    async getSupportedEvents(notificationType) {
+        __assertType("notificationType", "number", __assertType__number.bind(void 0, notificationType));
+        this.assertSupportsCommand(NotificationCommand, 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([
+    API(CommandClasses.Notification)
+], NotificationCCAPI);
+export { NotificationCCAPI };
+export 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";
+    // An enum value replaces the original value if there is only a single possible state
+    // which also has an enum parameter
+    if (numStatesWithEnums === 1 && variable.states.size === 1) {
+        return "replace";
+    }
+    return "extend";
+}
+export function getNotificationStateValueWithEnum(stateValue, enumValue) {
+    return (stateValue << 8) | enumValue;
+}
+/**
+ * Returns the metadata to use for a known notification value.
+ * Can be used to extend a previously defined metadata,
+ * e.g. for V2 notifications that don't allow discovering supported events.
+ */
+export function getNotificationValueMetadata(previous, notification, valueConfig) {
+    const metadata = previous ?? {
+        ...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 NotificationCC extends CommandClass {
+    // former AlarmCC (v1..v2)
+    determineRequiredCCInterviews() {
+        return [
+            ...super.determineRequiredCCInterviews(),
+            CommandClasses.Association,
+            CommandClasses["Multi Channel Association"],
+            CommandClasses["Association Group Information"],
+        ];
+    }
+    async determineNotificationMode(ctx, api, supportedNotificationEvents) {
+        const node = this.getNode(ctx);
+        // SDS14223: If the supporting node does not support the Association Command Class,
+        // it may be concluded that the supporting node implements Pull Mode and discovery may be aborted.
+        if (!node.supportsCC(CommandClasses.Association))
+            return "pull";
+        if (node.supportsCC(CommandClasses["Association Group Information"])) {
+            try {
+                const groupsIssueingNotifications = AssociationGroupInfoCC
+                    .findGroupsForIssuedCommand(ctx, node, this.ccId, NotificationCommand.Report);
+                return groupsIssueingNotifications.length > 0 ? "push" : "pull";
+            }
+            catch {
+                // We might be dealing with an older cache file, fall back to testing
+            }
+        }
+        ctx.logNode(node.id, {
+            endpoint: this.endpointIndex,
+            message: `determining whether this node is pull or push...`,
+            direction: "outbound",
+        });
+        // Find a notification type with at least one supported event
+        for (const [type, events] of supportedNotificationEvents) {
+            if (events.length === 0)
+                continue;
+            // Enable the event and request the status
+            await api.set(type, true);
+            try {
+                const resp = await api.get({
+                    notificationType: type,
+                    notificationEvent: events[0],
+                });
+                switch (resp?.notificationStatus) {
+                    case 0xff:
+                        return "push";
+                    case 0xfe:
+                    case 0x00:
+                        return "pull";
+                }
+            }
+            catch {
+                /* ignore */
+            }
+        }
+        // If everything failed, e.g. because the node is V1/V2, assume this is a "push" node.
+        // If we assumed "pull", we would have to query the node regularly, which can cause
+        // the node to return old (already handled) notifications.
+        // https://github.com/zwave-js/node-zwave-js/issues/5626
+        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 = CCAPI.create(CommandClasses.Notification, ctx, endpoint).withOptions({
+            priority: MessagePriority.NodeQuery,
+        });
+        ctx.logNode(node.id, {
+            endpoint: this.endpointIndex,
+            message: `Interviewing ${this.ccName}...`,
+            direction: "none",
+        });
+        // If one Association group issues Notification Reports,
+        // we must associate ourselves with that channel
+        try {
+            await ccUtils.assignLifelineIssueingCommand(ctx, endpoint, this.ccId, NotificationCommand.Report);
+        }
+        catch {
+            ctx.logNode(node.id, {
+                endpoint: endpoint.index,
+                message: `Configuring associations to receive ${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(getNotificationName);
+            const supportedNotificationEvents = new Map();
+            const logMessage = `received supported notification types:${supportedNotificationNames
+                .map((name) => `\n· ${name}`)
+                .join("")}`;
+            ctx.logNode(node.id, {
+                endpoint: this.endpointIndex,
+                message: logMessage,
+                direction: "inbound",
+            });
+            if (api.version >= 3) {
+                // Query each notification for its supported events
+                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",
+                        });
+                    }
+                }
+            }
+            // Determine whether the node is a push or pull node
+            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);
+            } /* if (notificationMode === "push") */
+            else {
+                for (let i = 0; i < supportedNotificationTypes.length; i++) {
+                    const type = supportedNotificationTypes[i];
+                    const name = supportedNotificationNames[i];
+                    const notification = getNotification(type);
+                    // Enable reports for each notification type
+                    ctx.logNode(node.id, {
+                        endpoint: this.endpointIndex,
+                        message: `enabling notifications for ${name}...`,
+                        direction: "outbound",
+                    });
+                    await api.set(type, true);
+                    // Set the value to idle if possible and there is no value yet
+                    if (notification) {
+                        const events = supportedNotificationEvents.get(type);
+                        if (events) {
+                            // Find all variables that are supported by this node and have an idle state
+                            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);
+                                    // Set the value to idle if it has no value yet
+                                    // TODO: GH#1028
+                                    // * do this only if the last update was more than 5 minutes ago
+                                    // * schedule an auto-idle if the last update was less than 5 minutes ago but before the current applHost start
+                                    if (this.getValue(ctx, value)
+                                        == undefined) {
+                                        this.setValue(ctx, value, 0);
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        // Only create metadata for V1 values if necessary
+        if (api.version === 1 || supportsV1Alarm) {
+            this.ensureMetadata(ctx, NotificationCCValues.alarmType);
+            this.ensureMetadata(ctx, NotificationCCValues.alarmLevel);
+        }
+        // Also create metadata for values mapped through compat config
+        const mappings = ctx.getDeviceConfig?.(this.nodeId)
+            ?.compat?.alarmMapping;
+        if (mappings) {
+            // Find all mappings to a valid notification variable
+            const supportedNotifications = new Map();
+            for (const { to } of mappings) {
+                const notification = getNotification(to.notificationType);
+                if (!notification)
+                    continue;
+                const valueConfig = getNotificationValue(notification, to.notificationEvent);
+                // Remember supported notification types and events to create the internal values later
+                if (!supportedNotifications.has(to.notificationType)) {
+                    supportedNotifications.set(to.notificationType, 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);
+                // Create or update the metadata
+                const metadata = getNotificationValueMetadata(this.getMetadata(ctx, notificationValue), notification, valueConfig);
+                this.setMetadata(ctx, notificationValue, metadata);
+                // Set the value to idle if it has no value yet
+                if (valueConfig.idle) {
+                    // TODO: GH#1028
+                    // * do this only if the last update was more than 5 minutes ago
+                    // * schedule an auto-idle if the last update was less than 5 minutes ago but before the current applHost start
+                    if (this.getValue(ctx, notificationValue) == undefined) {
+                        this.setValue(ctx, notificationValue, 0);
+                    }
+                }
+            }
+            // Remember supported notification types and events in the cache
+            this.setValue(ctx, NotificationCCValues.supportedNotificationTypes, [...supportedNotifications.keys()]);
+            for (const [type, events] of supportedNotifications) {
+                this.setValue(ctx, NotificationCCValues.supportedNotificationEvents(type), [...events]);
+            }
+        }
+        // Remember that the interview is complete
+        this.setInterviewComplete(ctx, true);
+    }
+    async refreshValues(ctx) {
+        const node = this.getNode(ctx);
+        // Refreshing values only works on pull nodes
+        if (NotificationCC_1.getNotificationMode(ctx, node) === "pull") {
+            const endpoint = this.getEndpoint(ctx);
+            const api = CCAPI.create(CommandClasses.Notification, ctx, endpoint).withOptions({
+                priority: MessagePriority.NodeQuery,
+            });
+            // Load supported notification types and events from cache
+            const supportedNotificationTypes = this.getValue(ctx, NotificationCCValues.supportedNotificationTypes) ?? [];
+            const supportedNotificationNames = supportedNotificationTypes.map(getNotificationName);
+            for (let i = 0; i < supportedNotificationTypes.length; i++) {
+                const type = supportedNotificationTypes[i];
+                const name = supportedNotificationNames[i];
+                // Always query each notification for its current status
+                ctx.logNode(node.id, {
+                    endpoint: this.endpointIndex,
+                    message: `querying notification status for ${name}...`,
+                    direction: "outbound",
+                });
+                const response = await api.getInternal({
+                    notificationType: type,
+                });
+                // NotificationReports don't store their values themselves,
+                // because the behaviour is too complex and spans the lifetime
+                // of several reports. Thus we handle it in the Node instance
+                // @ts-expect-error
+                if (response)
+                    await node.handleCommand(response);
+            }
+            // Remember when we did this
+            this.setValue(ctx, NotificationCCValues.lastRefresh, Date.now());
+        }
+    }
+    shouldRefreshValues(ctx) {
+        // Pull-mode nodes must be polled regularly
+        const isPullMode = NotificationCC_1.getNotificationMode(ctx, this.getNode(ctx)) === "pull";
+        if (!isPullMode)
+            return false;
+        const lastUpdated = this.getValue(ctx, NotificationCCValues.lastRefresh);
+        return (lastUpdated == undefined
+            || Date.now() - lastUpdated > timespan.hours(6));
+    }
+};
+NotificationCC = NotificationCC_1 = __decorate([
+    commandClass(CommandClasses.Notification),
+    implementedVersion(8),
+    ccValues(NotificationCCValues)
+], NotificationCC);
+export { NotificationCC };
+let NotificationCCSet = NotificationCCSet_1 = class NotificationCCSet extends NotificationCC {
+    constructor(options) {
+        super(options);
+        this.notificationType = options.notificationType;
+        this.notificationStatus = options.notificationStatus;
+    }
+    static from(raw, ctx) {
+        validatePayload(raw.payload.length >= 2);
+        const notificationType = raw.payload[0];
+        const notificationStatus = raw.payload[1] === 0xff;
+        return new NotificationCCSet_1({
+            nodeId: ctx.sourceNodeId,
+            notificationType,
+            notificationStatus,
+        });
+    }
+    notificationType;
+    notificationStatus;
+    serialize(ctx) {
+        this.payload = Bytes.from([
+            this.notificationType,
+            this.notificationStatus ? 0xff : 0x00,
+        ]);
+        return super.serialize(ctx);
+    }
+    toLogEntry(ctx) {
+        return {
+            ...super.toLogEntry(ctx),
+            message: {
+                "notification type": getNotificationName(this.notificationType),
+                status: this.notificationStatus,
+            },
+        };
+    }
+};
+NotificationCCSet = NotificationCCSet_1 = __decorate([
+    CCCommand(NotificationCommand.Set),
+    useSupervision()
+], NotificationCCSet);
+export { NotificationCCSet };
+let NotificationCCReport = NotificationCCReport_1 = class NotificationCCReport extends NotificationCC {
+    constructor(options) {
+        super(options);
+        if (options.alarmType != undefined) {
+            this.alarmType = options.alarmType;
+            this.alarmLevel = options.alarmLevel;
+        }
+        if (options.notificationType != undefined) {
+            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) {
+        validatePayload(raw.payload.length >= 2);
+        const alarmType = raw.payload[0];
+        const alarmLevel = raw.payload[1];
+        // Byte 2 used to be zensorNetSourceNodeId in V2 and V3, but we don't care about that
+        if (raw.payload.length < 7) {
+            return new NotificationCCReport_1({
+                nodeId: ctx.sourceNodeId,
+                alarmType,
+                alarmLevel,
+            });
+        }
+        // V2+ requires the alarm bytes to be zero. Manufacturers don't care though, so we don't enforce that.
+        // Don't use the version to decide because we might discard notifications
+        // before the interview is complete
+        const notificationStatus = raw.payload[3];
+        const notificationType = raw.payload[4];
+        const notificationEvent = raw.payload[5];
+        const containsSeqNum = !!(raw.payload[6] & 0b1000_0000);
+        const numEventParams = raw.payload[6] & 0b11111;
+        let eventParameters;
+        if (numEventParams > 0) {
+            validatePayload(raw.payload.length >= 7 + numEventParams);
+            eventParameters = raw.payload.subarray(7, 7 + numEventParams);
+        }
+        let sequenceNumber;
+        if (containsSeqNum) {
+            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 = getEffectiveCCVersion(ctx, this);
+        // Check if we need to re-interpret the alarm values somehow
+        if (this.alarmType != undefined
+            && this.alarmLevel != undefined
+            && this.alarmType !== 0) {
+            if (ccVersion >= 2) {
+                // Check if the device actually supports Notification CC, but chooses
+                // to send Alarm frames instead (GH#1034)
+                const supportedNotificationTypes = this.getValue(ctx, NotificationCCValues.supportedNotificationTypes);
+                if (isArray(supportedNotificationTypes)
+                    && supportedNotificationTypes.includes(this.alarmType)) {
+                    const supportedNotificationEvents = this.getValue(ctx, NotificationCCValues.supportedNotificationEvents(this.alarmType));
+                    if (isArray(supportedNotificationEvents)
+                        && supportedNotificationEvents.includes(this.alarmLevel)) {
+                        // This alarm frame corresponds to a valid notification event
+                        ctx.logNode(this.nodeId, `treating V1 Alarm frame as Notification Report`);
+                        this.notificationType = this.alarmType;
+                        this.notificationEvent = this.alarmLevel;
+                        this.alarmType = undefined;
+                        this.alarmLevel = undefined;
+                    }
+                }
+            }
+            else {
+                // V1 Alarm, check if there is a compat option to map this V1 report to a V2+ report
+                const mapping = ctx.getDeviceConfig?.(this.nodeId)?.compat?.alarmMapping;
+                const match = mapping?.find((m) => m.from.alarmType === this.alarmType
+                    && (m.from.alarmLevel == undefined
+                        || 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;
+                            }
+                        }
+                    }
+                    // After mapping we do not set the legacy V1 values to undefined
+                    // Otherwise, adding a new mapping will be a breaking change
+                }
+            }
+        }
+        // Now we can interpret the event parameters and turn them into something useful
+        this.parseEventParameters(ctx);
+        if (this.alarmType != undefined) {
+            const alarmTypeValue = NotificationCCValues.alarmType;
+            this.ensureMetadata(ctx, alarmTypeValue);
+            this.setValue(ctx, alarmTypeValue, this.alarmType);
+        }
+        if (this.alarmLevel != undefined) {
+            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 = getNotification(this.notificationType);
+            if (notification) {
+                valueConfig = getNotificationValue(notification, this.notificationEvent);
+            }
+            if (valueConfig) {
+                message = {
+                    ...message,
+                    "notification type": getNotificationName(this.notificationType),
+                    "notification status": this.notificationStatus,
+                    [`notification ${valueConfig.type}`]: valueConfig.label
+                        ?? `Unknown (${num2hex(this.notificationEvent)})`,
+                };
+            }
+            else if (this.notificationEvent === 0x00) {
+                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": num2hex(this.notificationEvent),
+                };
+            }
+        }
+        if (this.sequenceNumber != undefined) {
+            message["sequence number"] = this.sequenceNumber;
+        }
+        if (this.eventParameters != undefined) {
+            if (typeof this.eventParameters === "number") {
+                // Try to look up the enum label
+                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"] = num2hex(this.eventParameters);
+                }
+            }
+            else if (isUint8Array(this.eventParameters)) {
+                message["event parameters"] = buffer2hex(this.eventParameters);
+            }
+            else if (this.eventParameters instanceof Duration) {
+                message["event parameters"] = this.eventParameters.toString();
+            }
+            else {
+                message["event parameters"] = Object.entries(this.eventParameters)
+                    .map(([param, val]) => `\n  ${param}: ${num2hex(val)}`)
+                    .join("");
+            }
+        }
+        else if (valueConfig?.parameter?.type === "enum"
+            && valueConfig.parameter.default != undefined) {
+            const label = valueConfig.parameter.values[valueConfig.parameter.default];
+            if (label) {
+                message["state parameters"] = `${label} (omitted)`;
+            }
+        }
+        return {
+            ...super.toLogEntry(ctx),
+            message,
+        };
+    }
+    parseEventParameters(ctx) {
+        // This only makes sense for V2+ notifications
+        if (this.notificationType == undefined
+            || this.notificationEvent == undefined) {
+            return;
+        }
+        // Look up the received notification and value in the config
+        const notification = getNotification(this.notificationType);
+        if (!notification)
+            return;
+        const valueConfig = getNotificationValue(notification, this.notificationEvent);
+        if (!valueConfig)
+            return;
+        // Parse the event parameters if possible
+        if (valueConfig.parameter?.type === "duration") {
+            // This only makes sense if the event parameters are a buffer
+            if (!isUint8Array(this.eventParameters)) {
+                return;
+            }
+            // The parameters contain a Duration
+            this.eventParameters = Duration.parseReport(this.eventParameters[0]);
+        }
+        else if (valueConfig.parameter?.type === "commandclass") {
+            // This only makes sense if the event parameters are a buffer
+            if (!isUint8Array(this.eventParameters)) {
+                return;
+            }
+            // The parameters **should** contain a CC, however there might be some exceptions
+            if (this.eventParameters.length === 1
+                && notification.type === 0x06
+                && (this.notificationEvent === 0x05
+                    || this.notificationEvent === 0x06)) {
+                // Access control -> Keypad Lock/Unlock operation
+                // Some devices only send the User ID, not a complete CC payload
+                this.eventParameters = {
+                    userId: this.eventParameters[0],
+                };
+            }
+            else {
+                // Try to parse the event parameters - if this fails, we should still handle the notification report
+                try {
+                    // Convert CommandClass instances to a standardized object representation
+                    const cc = 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: () => SecurityClass.None,
+                        setSecurityClass: () => { },
+                        securityManager: undefined,
+                        securityManager2: undefined,
+                        securityManagerLR: undefined,
+                    });
+                    validatePayload(!(cc instanceof InvalidCC));
+                    cc.encapsulatingCC = this;
+                    if (isNotificationEventPayload(cc)) {
+                        this.eventParameters = cc
+                            .toNotificationEventParameters();
+                    }
+                    else {
+                        // If a CC has no good toJSON() representation, we're only interested in the payload
+                        let json = cc.toJSON();
+                        if ("nodeId" in json
+                            && "ccId" in json
+                            && "payload" in json) {
+                            json = pick(json, ["payload"]);
+                        }
+                        this.eventParameters = json;
+                    }
+                }
+                catch (e) {
+                    if (isZWaveError(e)
+                        && e.code
+                            === ZWaveErrorCodes.PacketFormat_InvalidPayload
+                        && isUint8Array(this.eventParameters)) {
+                        const { ccId, ccCommand } = CCRaw.parse(this.eventParameters);
+                        if (ccId === CommandClasses["User Code"]
+                            && ccCommand === UserCodeCommand.Report
+                            && this.eventParameters.length >= 3) {
+                            // Access control -> Keypad Lock/Unlock operation
+                            // Some devices report the user code with truncated UserCode reports
+                            this.eventParameters = {
+                                userId: this.eventParameters[2],
+                            };
+                        }
+                        else {
+                            ctx.logNode(this.nodeId, `Failed to parse Notification CC event parameters, ignoring them...`, "error");
+                        }
+                    }
+                    else {
+                        // unexpected error
+                        throw e;
+                    }
+                }
+            }
+        }
+        else if (valueConfig.parameter?.type === "value") {
+            // This only makes sense if the event parameters are a buffer
+            if (!isUint8Array(this.eventParameters)) {
+                return;
+            }
+            // The parameters contain a named value
+            this.eventParameters = {
+                [valueConfig.parameter.propertyName]: Bytes.view(this.eventParameters)
+                    .readUIntBE(0, this.eventParameters.length),
+            };
+        }
+        else if (valueConfig.parameter?.type === "enum") {
+            // The parameters may contain an enum value
+            this.eventParameters = isUint8Array(this.eventParameters)
+                && this.eventParameters.length === 1
+                ? this.eventParameters[0]
+                : undefined;
+            // Some devices send notifications without an event parameter when they should.
+            // In this case, fall back to the default value where possible.
+            if (this.eventParameters == undefined
+                && valueConfig.parameter.default != undefined) {
+                this.eventParameters = valueConfig.parameter.default;
+            }
+        }
+    }
+    serialize(ctx) {
+        if (this.notificationType != undefined) {
+            if (this.notificationEvent == undefined) {
+                throw new ZWaveError(`Notification CC reports requires the notification event to be set!`, ZWaveErrorCodes.Argument_Invalid);
+            }
+            else if (this.eventParameters != undefined
+                && !isUint8Array(this.eventParameters)) {
+                throw new ZWaveError(`When sending Notification CC reports, the event parameters can only be buffers!`, ZWaveErrorCodes.Argument_Invalid);
+            }
+            const controlByte = (this.sequenceNumber != undefined ? 0b1000_0000 : 0)
+                | ((this.eventParameters?.length ?? 0) & 0b11111);
+            this.payload = Bytes.from([
+                0,
+                0,
+                0,
+                0xff,
+                this.notificationType,
+                this.notificationEvent,
+                controlByte,
+            ]);
+            if (this.eventParameters) {
+                this.payload = Bytes.concat([
+                    this.payload,
+                    this.eventParameters,
+                ]);
+            }
+            if (this.sequenceNumber != undefined) {
+                this.payload = Bytes.concat([
+                    this.payload,
+                    Bytes.from([this.sequenceNumber]),
+                ]);
+            }
+        }
+        else {
+            this.payload = Bytes.from([
+                this.alarmType ?? 0x00,
+                this.alarmLevel ?? 0x00,
+            ]);
+        }
+        return super.serialize(ctx);
+    }
+};
+NotificationCCReport = NotificationCCReport_1 = __decorate([
+    CCCommand(NotificationCommand.Report),
+    useSupervision()
+], NotificationCCReport);
+export { NotificationCCReport };
+let NotificationCCGet = NotificationCCGet_1 = class NotificationCCGet 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) {
+        validatePayload(raw.payload.length >= 1);
+        if (raw.payload.length >= 2) {
+            const notificationType = raw.payload[1];
+            let notificationEvent;
+            if (raw.payload.length >= 3 && notificationType != 0xff) {
+                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 === 0xff
+            ? 0x00
+            : this.notificationEvent;
+        this.payload = Bytes.from([
+            this.alarmType ?? 0x00,
+            this.notificationType ?? 0xff,
+            notificationEvent ?? 0x00,
+        ]);
+        return super.serialize(ctx);
+    }
+    toLogEntry(ctx) {
+        const message = {};
+        if (this.alarmType != undefined) {
+            message["V1 alarm type"] = this.alarmType;
+        }
+        if (this.notificationType != undefined) {
+            message["notification type"] = getNotificationName(this.notificationType);
+            if (this.notificationEvent != undefined) {
+                message["notification event"] = getNotificationEventName(this.notificationType, this.notificationEvent);
+            }
+        }
+        return {
+            ...super.toLogEntry(ctx),
+            message,
+        };
+    }
+};
+NotificationCCGet = NotificationCCGet_1 = __decorate([
+    CCCommand(NotificationCommand.Get),
+    expectedCCResponse(NotificationCCReport)
+], NotificationCCGet);
+export { NotificationCCGet };
+let NotificationCCSupportedReport = NotificationCCSupportedReport_1 = class NotificationCCSupportedReport extends NotificationCC {
+    constructor(options) {
+        super(options);
+        this.supportsV1Alarm = options.supportsV1Alarm;
+        this.supportedNotificationTypes = options.supportedNotificationTypes;
+    }
+    static from(raw, ctx) {
+        validatePayload(raw.payload.length >= 1);
+        const supportsV1Alarm = !!(raw.payload[0] & 0b1000_0000);
+        const numBitMaskBytes = raw.payload[0] & 0b0001_1111;
+        validatePayload(numBitMaskBytes > 0, raw.payload.length >= 1 + numBitMaskBytes);
+        const notificationBitMask = raw.payload.subarray(1, 1 + numBitMaskBytes);
+        const supportedNotificationTypes = 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 = encodeBitMask(this.supportedNotificationTypes, Math.max(...this.supportedNotificationTypes), 0);
+        this.payload = Bytes.concat([
+            Bytes.from([
+                (this.supportsV1Alarm ? 0b1000_0000 : 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) => `\n· ${getNotificationName(t)}`)
+                    .join(""),
+            },
+        };
+    }
+};
+__decorate([
+    ccValue(NotificationCCValues.supportsV1Alarm)
+], NotificationCCSupportedReport.prototype, "supportsV1Alarm", void 0);
+__decorate([
+    ccValue(NotificationCCValues.supportedNotificationTypes)
+], NotificationCCSupportedReport.prototype, "supportedNotificationTypes", void 0);
+NotificationCCSupportedReport = NotificationCCSupportedReport_1 = __decorate([
+    CCCommand(NotificationCommand.SupportedReport)
+], NotificationCCSupportedReport);
+export { NotificationCCSupportedReport };
+let NotificationCCSupportedGet = class NotificationCCSupportedGet extends NotificationCC {
+};
+NotificationCCSupportedGet = __decorate([
+    CCCommand(NotificationCommand.SupportedGet),
+    expectedCCResponse(NotificationCCSupportedReport)
+], NotificationCCSupportedGet);
+export { NotificationCCSupportedGet };
+let NotificationCCEventSupportedReport = NotificationCCEventSupportedReport_1 = class NotificationCCEventSupportedReport extends NotificationCC {
+    constructor(options) {
+        super(options);
+        this.notificationType = options.notificationType;
+        this.supportedEvents = options.supportedEvents;
+    }
+    static from(raw, ctx) {
+        validatePayload(raw.payload.length >= 1);
+        const notificationType = raw.payload[0];
+        const numBitMaskBytes = raw.payload[1] & 0b000_11111;
+        if (numBitMaskBytes === 0) {
+            // Notification type is not supported
+            return new NotificationCCEventSupportedReport_1({
+                nodeId: ctx.sourceNodeId,
+                notificationType,
+                supportedEvents: [],
+            });
+        }
+        validatePayload(raw.payload.length >= 2 + numBitMaskBytes);
+        const eventBitMask = raw.payload.subarray(2, 2 + numBitMaskBytes);
+        const supportedEvents = 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;
+        // Store which events this notification supports
+        this.setValue(ctx, NotificationCCValues.supportedNotificationEvents(this.notificationType), this.supportedEvents);
+        // For each event, predefine the value metadata
+        const notification = getNotification(this.notificationType);
+        if (!notification) {
+            // This is an unknown notification
+            this.setMetadata(ctx, NotificationCCValues.unknownNotificationType(this.notificationType));
+        }
+        else {
+            // This is a standardized notification
+            let isFirst = true;
+            for (const value of this.supportedEvents) {
+                // Find out which property we need to update
+                const valueConfig = getNotificationValue(notification, value);
+                if (valueConfig?.type === "state") {
+                    const notificationValue = NotificationCCValues
+                        .notificationVariable(notification.name, valueConfig.variableName);
+                    // After we've created the metadata initially, extend it
+                    const metadata = getNotificationValueMetadata(isFirst
+                        ? undefined
+                        : this.getMetadata(ctx, notificationValue), notification, valueConfig);
+                    this.setMetadata(ctx, notificationValue, metadata);
+                    isFirst = false;
+                }
+            }
+        }
+        return true;
+    }
+    notificationType;
+    supportedEvents;
+    serialize(ctx) {
+        this.payload = Bytes.from([this.notificationType, 0]);
+        if (this.supportedEvents.length > 0) {
+            const bitMask = encodeBitMask(this.supportedEvents, Math.max(...this.supportedEvents), 0);
+            this.payload[1] = bitMask.length;
+            this.payload = Bytes.concat([this.payload, bitMask]);
+        }
+        return super.serialize(ctx);
+    }
+    toLogEntry(ctx) {
+        return {
+            ...super.toLogEntry(ctx),
+            message: {
+                "notification type": getNotificationName(this.notificationType),
+                "supported events": this.supportedEvents
+                    .map((e) => `\n· ${getNotificationValueName(this.notificationType, e)}`)
+                    .join(""),
+            },
+        };
+    }
+};
+NotificationCCEventSupportedReport = NotificationCCEventSupportedReport_1 = __decorate([
+    CCCommand(NotificationCommand.EventSupportedReport)
+], NotificationCCEventSupportedReport);
+export { NotificationCCEventSupportedReport };
+let NotificationCCEventSupportedGet = NotificationCCEventSupportedGet_1 = class NotificationCCEventSupportedGet extends NotificationCC {
+    constructor(options) {
+        super(options);
+        this.notificationType = options.notificationType;
+    }
+    static from(raw, ctx) {
+        validatePayload(raw.payload.length >= 1);
+        const notificationType = raw.payload[0];
+        return new NotificationCCEventSupportedGet_1({
+            nodeId: ctx.sourceNodeId,
+            notificationType,
+        });
+    }
+    notificationType;
+    serialize(ctx) {
+        this.payload = Bytes.from([this.notificationType]);
+        return super.serialize(ctx);
+    }
+    toLogEntry(ctx) {
+        return {
+            ...super.toLogEntry(ctx),
+            message: {
+                "notification type": getNotificationName(this.notificationType),
+            },
+        };
+    }
+};
+NotificationCCEventSupportedGet = NotificationCCEventSupportedGet_1 = __decorate([
+    CCCommand(NotificationCommand.EventSupportedGet),
+    expectedCCResponse(NotificationCCEventSupportedReport)
+], NotificationCCEventSupportedGet);
+export { NotificationCCEventSupportedGet };
+//# sourceMappingURL=NotificationCC.js.map