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

package/build/cc/NotificationCC.js

@@ -1,1379 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-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 __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-var NotificationCC_1, NotificationCCSet_1, NotificationCCReport_1, NotificationCCGet_1, NotificationCCSupportedReport_1, NotificationCCEventSupportedReport_1, NotificationCCEventSupportedGet_1;
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.NotificationCCEventSupportedGet = exports.NotificationCCEventSupportedReport = exports.NotificationCCSupportedGet = exports.NotificationCCSupportedReport = exports.NotificationCCGet = exports.NotificationCCReport = exports.NotificationCCSet = exports.NotificationCC = exports.NotificationCCAPI = exports.NotificationCCValues = void 0;
-exports.getNotificationEnumBehavior = getNotificationEnumBehavior;
-exports.getNotificationStateValueWithEnum = getNotificationStateValueWithEnum;
-exports.getNotificationValueMetadata = getNotificationValueMetadata;
-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);
-};
-const core_1 = require("@zwave-js/core");
-const safe_1 = require("@zwave-js/core/safe");
-const safe_2 = require("@zwave-js/shared/safe");
-const safe_3 = require("@zwave-js/shared/safe");
-const typeguards_1 = require("alcalzone-shared/typeguards");
-const API_1 = require("../lib/API");
-const CommandClass_1 = require("../lib/CommandClass");
-const CommandClassDecorators_1 = require("../lib/CommandClassDecorators");
-const NotificationEventPayload_1 = require("../lib/NotificationEventPayload");
-const Values_1 = require("../lib/Values");
-const _Types_1 = require("../lib/_Types");
-const ccUtils = __importStar(require("../lib/utils"));
-const AssociationGroupInfoCC_1 = require("./AssociationGroupInfoCC");
-exports.NotificationCCValues = Object.freeze({
-    ...Values_1.V.defineStaticCCValues(safe_1.CommandClasses.Notification, {
-        ...Values_1.V.staticProperty("supportsV1Alarm", undefined, {
-            internal: true,
-            supportsEndpoints: false,
-        }),
-        ...Values_1.V.staticProperty("supportedNotificationTypes", undefined, {
-            internal: true,
-            supportsEndpoints: false,
-        }),
-        ...Values_1.V.staticProperty("notificationMode", undefined, {
-            internal: true,
-            supportsEndpoints: false,
-        }),
-        ...Values_1.V.staticProperty("lastRefresh", undefined, {
-            internal: true,
-        }),
-        // V1 Alarm values
-        ...Values_1.V.staticProperty("alarmType", {
-            ...safe_1.ValueMetadata.ReadOnlyUInt8,
-            label: "Alarm Type",
-        }),
-        ...Values_1.V.staticProperty("alarmLevel", {
-            ...safe_1.ValueMetadata.ReadOnlyUInt8,
-            label: "Alarm Level",
-        }),
-        // Simplification for the Door state variable, where we cannot know
-        // if any of the enum values are supported
-        ...Values_1.V.staticPropertyAndKeyWithName("doorStateSimple", "Access Control", "Door state (simple)", {
-            // Must be a number for compatibility reasons
-            ...safe_1.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.
-        ...Values_1.V.staticPropertyAndKeyWithName("doorTiltState", "Access Control", "Door tilt state", {
-            // Must be a number for compatibility reasons
-            ...safe_1.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,
-        }),
-    }),
-    ...Values_1.V.defineDynamicCCValues(safe_1.CommandClasses.Notification, {
-        ...Values_1.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
-        ...Values_1.V.dynamicPropertyWithName("unknownNotificationType", (notificationType) => `UNKNOWN_${(0, safe_3.num2hex)(notificationType)}`, ({ property }) => typeof property === "string"
-            && property.startsWith("UNKNOWN_0x"), (notificationType) => ({
-            ...safe_1.ValueMetadata.ReadOnlyUInt8,
-            label: `Unknown notification (${(0, safe_3.num2hex)(notificationType)})`,
-            ccSpecific: { notificationType },
-        })),
-        // Known type, unknown variable
-        ...Values_1.V.dynamicPropertyAndKeyWithName("unknownNotificationVariable", (notificationType, notificationName) => notificationName, "unknown", ({ property, propertyKey }) => typeof property === "string" && propertyKey === "unknown", (notificationType, notificationName) => ({
-            ...safe_1.ValueMetadata.ReadOnlyUInt8,
-            label: `${notificationName}: Unknown value`,
-            ccSpecific: { notificationType },
-        })),
-        // (Stateful) notification variable
-        ...Values_1.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(exports.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 API_1.PhysicalCCAPI {
-    supportsCommand(cmd) {
-        switch (cmd) {
-            case _Types_1.NotificationCommand.Report:
-            case _Types_1.NotificationCommand.Get:
-                return true; // These exist starting with V1
-            case _Types_1.NotificationCommand.Set:
-            case _Types_1.NotificationCommand.SupportedGet:
-                return this.version >= 2;
-            case _Types_1.NotificationCommand.EventSupportedGet:
-                return this.version >= 3;
-        }
-        return super.supportsCommand(cmd);
-    }
-    get [API_1.POLL_VALUE]() {
-        return async function ({ property, propertyKey }) {
-            const valueId = {
-                commandClass: this.ccId,
-                endpoint: this.endpoint.index,
-                property,
-                propertyKey,
-            };
-            if (exports.NotificationCCValues.notificationVariable.is(valueId)) {
-                const notificationType = this
-                    .tryGetValueDB()?.getMetadata(valueId)?.ccSpecific
-                    ?.notificationType;
-                if (notificationType != undefined) {
-                    return this.getInternal({ notificationType });
-                }
-            }
-            (0, API_1.throwUnsupportedProperty)(this.ccId, property);
-        };
-    }
-    /**
-     * @internal
-     */
-    async getInternal(options) {
-        this.assertSupportsCommand(_Types_1.NotificationCommand, _Types_1.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(_Types_1.NotificationCommand, _Types_1.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, safe_3.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(_Types_1.NotificationCommand, _Types_1.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(_Types_1.NotificationCommand, _Types_1.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, safe_3.pick)(response, [
-                "supportsV1Alarm",
-                "supportedNotificationTypes",
-            ]);
-        }
-    }
-    async getSupportedEvents(notificationType) {
-        __assertType("notificationType", "number", __assertType__number.bind(void 0, notificationType));
-        this.assertSupportsCommand(_Types_1.NotificationCommand, _Types_1.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;
-    }
-};
-exports.NotificationCCAPI = NotificationCCAPI;
-exports.NotificationCCAPI = NotificationCCAPI = __decorate([
-    (0, CommandClassDecorators_1.API)(safe_1.CommandClasses.Notification)
-], NotificationCCAPI);
-function getNotificationEnumBehavior(notification, valueConfig) {
-    const variable = notification.variables.find((v) => v.states.has(valueConfig.value));
-    if (!variable)
-        return "none";
-    const numStatesWithEnums = [...variable.states.values()].filter((val) => val.parameter?.type === "enum").length;
-    if (numStatesWithEnums === 0)
-        return "none";
-    // 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";
-}
-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.
- */
-function getNotificationValueMetadata(previous, notification, valueConfig) {
-    const metadata = previous ?? {
-        ...safe_1.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_1.CommandClass {
-    // former AlarmCC (v1..v2)
-    determineRequiredCCInterviews() {
-        return [
-            ...super.determineRequiredCCInterviews(),
-            safe_1.CommandClasses.Association,
-            safe_1.CommandClasses["Multi Channel Association"],
-            safe_1.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(safe_1.CommandClasses.Association))
-            return "pull";
-        if (node.supportsCC(safe_1.CommandClasses["Association Group Information"])) {
-            try {
-                const groupsIssueingNotifications = AssociationGroupInfoCC_1.AssociationGroupInfoCC
-                    .findGroupsForIssuedCommand(ctx, node, this.ccId, _Types_1.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(exports.NotificationCCValues.notificationMode.id);
-    }
-    async interview(ctx) {
-        const node = this.getNode(ctx);
-        const endpoint = this.getEndpoint(ctx);
-        const api = API_1.CCAPI.create(safe_1.CommandClasses.Notification, ctx, endpoint).withOptions({
-            priority: safe_1.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, _Types_1.NotificationCommand.Report);
-        }
-        catch {
-            ctx.logNode(node.id, {
-                endpoint: endpoint.index,
-                message: `Configuring associations to receive ${(0, safe_1.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(core_1.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, exports.NotificationCCValues.notificationMode);
-            if (notificationMode !== "push" && notificationMode !== "pull") {
-                notificationMode = await this.determineNotificationMode(ctx, api, supportedNotificationEvents);
-                this.setValue(ctx, exports.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 = (0, core_1.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 = exports.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, exports.NotificationCCValues.alarmType);
-            this.ensureMetadata(ctx, exports.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 = (0, core_1.getNotification)(to.notificationType);
-                if (!notification)
-                    continue;
-                const valueConfig = (0, core_1.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 = exports.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, exports.NotificationCCValues.supportedNotificationTypes, [...supportedNotifications.keys()]);
-            for (const [type, events] of supportedNotifications) {
-                this.setValue(ctx, exports.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 = API_1.CCAPI.create(safe_1.CommandClasses.Notification, ctx, endpoint).withOptions({
-                priority: safe_1.MessagePriority.NodeQuery,
-            });
-            // Load supported notification types and events from cache
-            const supportedNotificationTypes = this.getValue(ctx, exports.NotificationCCValues.supportedNotificationTypes) ?? [];
-            const supportedNotificationNames = supportedNotificationTypes.map(core_1.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, exports.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, exports.NotificationCCValues.lastRefresh);
-        return (lastUpdated == undefined
-            || Date.now() - lastUpdated > core_1.timespan.hours(6));
-    }
-};
-exports.NotificationCC = NotificationCC;
-exports.NotificationCC = NotificationCC = NotificationCC_1 = __decorate([
-    (0, CommandClassDecorators_1.commandClass)(safe_1.CommandClasses.Notification),
-    (0, CommandClassDecorators_1.implementedVersion)(8),
-    (0, CommandClassDecorators_1.ccValues)(exports.NotificationCCValues)
-], 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) {
-        (0, safe_1.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 = safe_2.Bytes.from([
-            this.notificationType,
-            this.notificationStatus ? 0xff : 0x00,
-        ]);
-        return super.serialize(ctx);
-    }
-    toLogEntry(ctx) {
-        return {
-            ...super.toLogEntry(ctx),
-            message: {
-                "notification type": (0, core_1.getNotificationName)(this.notificationType),
-                status: this.notificationStatus,
-            },
-        };
-    }
-};
-exports.NotificationCCSet = NotificationCCSet;
-exports.NotificationCCSet = NotificationCCSet = NotificationCCSet_1 = __decorate([
-    (0, CommandClassDecorators_1.CCCommand)(_Types_1.NotificationCommand.Set),
-    (0, CommandClassDecorators_1.useSupervision)()
-], 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) {
-        (0, safe_1.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) {
-            (0, safe_1.validatePayload)(raw.payload.length >= 7 + numEventParams);
-            eventParameters = raw.payload.subarray(7, 7 + numEventParams);
-        }
-        let sequenceNumber;
-        if (containsSeqNum) {
-            (0, safe_1.validatePayload)(raw.payload.length >= 7 + numEventParams + 1);
-            sequenceNumber = raw.payload[7 + numEventParams];
-        }
-        return new NotificationCCReport_1({
-            nodeId: ctx.sourceNodeId,
-            alarmType,
-            alarmLevel,
-            notificationStatus,
-            notificationType,
-            notificationEvent,
-            eventParameters,
-            sequenceNumber,
-        });
-    }
-    persistValues(ctx) {
-        if (!super.persistValues(ctx))
-            return false;
-        const ccVersion = (0, CommandClass_1.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, exports.NotificationCCValues.supportedNotificationTypes);
-                if ((0, typeguards_1.isArray)(supportedNotificationTypes)
-                    && supportedNotificationTypes.includes(this.alarmType)) {
-                    const supportedNotificationEvents = this.getValue(ctx, exports.NotificationCCValues.supportedNotificationEvents(this.alarmType));
-                    if ((0, typeguards_1.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 = exports.NotificationCCValues.alarmType;
-            this.ensureMetadata(ctx, alarmTypeValue);
-            this.setValue(ctx, alarmTypeValue, this.alarmType);
-        }
-        if (this.alarmLevel != undefined) {
-            const alarmLevelValue = exports.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, core_1.getNotification)(this.notificationType);
-            if (notification) {
-                valueConfig = (0, core_1.getNotificationValue)(notification, this.notificationEvent);
-            }
-            if (valueConfig) {
-                message = {
-                    ...message,
-                    "notification type": (0, core_1.getNotificationName)(this.notificationType),
-                    "notification status": this.notificationStatus,
-                    [`notification ${valueConfig.type}`]: valueConfig.label
-                        ?? `Unknown (${(0, safe_3.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": (0, safe_3.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"] = (0, safe_3.num2hex)(this.eventParameters);
-                }
-            }
-            else if ((0, safe_2.isUint8Array)(this.eventParameters)) {
-                message["event parameters"] = (0, safe_3.buffer2hex)(this.eventParameters);
-            }
-            else if (this.eventParameters instanceof safe_1.Duration) {
-                message["event parameters"] = this.eventParameters.toString();
-            }
-            else {
-                message["event parameters"] = Object.entries(this.eventParameters)
-                    .map(([param, val]) => `\n  ${param}: ${(0, safe_3.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 = (0, core_1.getNotification)(this.notificationType);
-        if (!notification)
-            return;
-        const valueConfig = (0, core_1.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 (!(0, safe_2.isUint8Array)(this.eventParameters)) {
-                return;
-            }
-            // The parameters contain a Duration
-            this.eventParameters = safe_1.Duration.parseReport(this.eventParameters[0]);
-        }
-        else if (valueConfig.parameter?.type === "commandclass") {
-            // This only makes sense if the event parameters are a buffer
-            if (!(0, safe_2.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_1.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: () => safe_1.SecurityClass.None,
-                        setSecurityClass: () => { },
-                        securityManager: undefined,
-                        securityManager2: undefined,
-                        securityManagerLR: undefined,
-                    });
-                    (0, safe_1.validatePayload)(!(cc instanceof CommandClass_1.InvalidCC));
-                    cc.encapsulatingCC = this;
-                    if ((0, NotificationEventPayload_1.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 = (0, safe_3.pick)(json, ["payload"]);
-                        }
-                        this.eventParameters = json;
-                    }
-                }
-                catch (e) {
-                    if ((0, safe_1.isZWaveError)(e)
-                        && e.code
-                            === safe_1.ZWaveErrorCodes.PacketFormat_InvalidPayload
-                        && (0, safe_2.isUint8Array)(this.eventParameters)) {
-                        const { ccId, ccCommand } = CommandClass_1.CCRaw.parse(this.eventParameters);
-                        if (ccId === safe_1.CommandClasses["User Code"]
-                            && ccCommand === _Types_1.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 (!(0, safe_2.isUint8Array)(this.eventParameters)) {
-                return;
-            }
-            // The parameters contain a named value
-            this.eventParameters = {
-                [valueConfig.parameter.propertyName]: safe_2.Bytes.view(this.eventParameters)
-                    .readUIntBE(0, this.eventParameters.length),
-            };
-        }
-        else if (valueConfig.parameter?.type === "enum") {
-            // The parameters may contain an enum value
-            this.eventParameters = (0, safe_2.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 safe_1.ZWaveError(`Notification CC reports requires the notification event to be set!`, safe_1.ZWaveErrorCodes.Argument_Invalid);
-            }
-            else if (this.eventParameters != undefined
-                && !(0, safe_2.isUint8Array)(this.eventParameters)) {
-                throw new safe_1.ZWaveError(`When sending Notification CC reports, the event parameters can only be buffers!`, safe_1.ZWaveErrorCodes.Argument_Invalid);
-            }
-            const controlByte = (this.sequenceNumber != undefined ? 0b1000_0000 : 0)
-                | ((this.eventParameters?.length ?? 0) & 0b11111);
-            this.payload = safe_2.Bytes.from([
-                0,
-                0,
-                0,
-                0xff,
-                this.notificationType,
-                this.notificationEvent,
-                controlByte,
-            ]);
-            if (this.eventParameters) {
-                this.payload = safe_2.Bytes.concat([
-                    this.payload,
-                    this.eventParameters,
-                ]);
-            }
-            if (this.sequenceNumber != undefined) {
-                this.payload = safe_2.Bytes.concat([
-                    this.payload,
-                    safe_2.Bytes.from([this.sequenceNumber]),
-                ]);
-            }
-        }
-        else {
-            this.payload = safe_2.Bytes.from([
-                this.alarmType ?? 0x00,
-                this.alarmLevel ?? 0x00,
-            ]);
-        }
-        return super.serialize(ctx);
-    }
-};
-exports.NotificationCCReport = NotificationCCReport;
-exports.NotificationCCReport = NotificationCCReport = NotificationCCReport_1 = __decorate([
-    (0, CommandClassDecorators_1.CCCommand)(_Types_1.NotificationCommand.Report),
-    (0, CommandClassDecorators_1.useSupervision)()
-], 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) {
-        (0, safe_1.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 = safe_2.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"] = (0, core_1.getNotificationName)(this.notificationType);
-            if (this.notificationEvent != undefined) {
-                message["notification event"] = (0, core_1.getNotificationEventName)(this.notificationType, this.notificationEvent);
-            }
-        }
-        return {
-            ...super.toLogEntry(ctx),
-            message,
-        };
-    }
-};
-exports.NotificationCCGet = NotificationCCGet;
-exports.NotificationCCGet = NotificationCCGet = NotificationCCGet_1 = __decorate([
-    (0, CommandClassDecorators_1.CCCommand)(_Types_1.NotificationCommand.Get),
-    (0, CommandClassDecorators_1.expectedCCResponse)(NotificationCCReport)
-], 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) {
-        (0, safe_1.validatePayload)(raw.payload.length >= 1);
-        const supportsV1Alarm = !!(raw.payload[0] & 0b1000_0000);
-        const numBitMaskBytes = raw.payload[0] & 0b0001_1111;
-        (0, safe_1.validatePayload)(numBitMaskBytes > 0, raw.payload.length >= 1 + numBitMaskBytes);
-        const notificationBitMask = raw.payload.subarray(1, 1 + numBitMaskBytes);
-        const supportedNotificationTypes = (0, safe_1.parseBitMask)(notificationBitMask, 
-        // bit 0 is ignored, but counting still starts at 1, so the first bit must have the value 0
-        0);
-        return new NotificationCCSupportedReport_1({
-            nodeId: ctx.sourceNodeId,
-            supportsV1Alarm,
-            supportedNotificationTypes,
-        });
-    }
-    supportsV1Alarm;
-    supportedNotificationTypes;
-    serialize(ctx) {
-        const bitMask = (0, safe_1.encodeBitMask)(this.supportedNotificationTypes, Math.max(...this.supportedNotificationTypes), 0);
-        this.payload = safe_2.Bytes.concat([
-            safe_2.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· ${(0, core_1.getNotificationName)(t)}`)
-                    .join(""),
-            },
-        };
-    }
-};
-exports.NotificationCCSupportedReport = NotificationCCSupportedReport;
-__decorate([
-    (0, CommandClassDecorators_1.ccValue)(exports.NotificationCCValues.supportsV1Alarm)
-], NotificationCCSupportedReport.prototype, "supportsV1Alarm", void 0);
-__decorate([
-    (0, CommandClassDecorators_1.ccValue)(exports.NotificationCCValues.supportedNotificationTypes)
-], NotificationCCSupportedReport.prototype, "supportedNotificationTypes", void 0);
-exports.NotificationCCSupportedReport = NotificationCCSupportedReport = NotificationCCSupportedReport_1 = __decorate([
-    (0, CommandClassDecorators_1.CCCommand)(_Types_1.NotificationCommand.SupportedReport)
-], NotificationCCSupportedReport);
-let NotificationCCSupportedGet = class NotificationCCSupportedGet extends NotificationCC {
-};
-exports.NotificationCCSupportedGet = NotificationCCSupportedGet;
-exports.NotificationCCSupportedGet = NotificationCCSupportedGet = __decorate([
-    (0, CommandClassDecorators_1.CCCommand)(_Types_1.NotificationCommand.SupportedGet),
-    (0, CommandClassDecorators_1.expectedCCResponse)(NotificationCCSupportedReport)
-], 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) {
-        (0, safe_1.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: [],
-            });
-        }
-        (0, safe_1.validatePayload)(raw.payload.length >= 2 + numBitMaskBytes);
-        const eventBitMask = raw.payload.subarray(2, 2 + numBitMaskBytes);
-        const supportedEvents = (0, safe_1.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, exports.NotificationCCValues.supportedNotificationEvents(this.notificationType), this.supportedEvents);
-        // For each event, predefine the value metadata
-        const notification = (0, core_1.getNotification)(this.notificationType);
-        if (!notification) {
-            // This is an unknown notification
-            this.setMetadata(ctx, exports.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 = (0, core_1.getNotificationValue)(notification, value);
-                if (valueConfig?.type === "state") {
-                    const notificationValue = exports.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 = safe_2.Bytes.from([this.notificationType, 0]);
-        if (this.supportedEvents.length > 0) {
-            const bitMask = (0, safe_1.encodeBitMask)(this.supportedEvents, Math.max(...this.supportedEvents), 0);
-            this.payload[1] = bitMask.length;
-            this.payload = safe_2.Bytes.concat([this.payload, bitMask]);
-        }
-        return super.serialize(ctx);
-    }
-    toLogEntry(ctx) {
-        return {
-            ...super.toLogEntry(ctx),
-            message: {
-                "notification type": (0, core_1.getNotificationName)(this.notificationType),
-                "supported events": this.supportedEvents
-                    .map((e) => `\n· ${(0, core_1.getNotificationValueName)(this.notificationType, e)}`)
-                    .join(""),
-            },
-        };
-    }
-};
-exports.NotificationCCEventSupportedReport = NotificationCCEventSupportedReport;
-exports.NotificationCCEventSupportedReport = NotificationCCEventSupportedReport = NotificationCCEventSupportedReport_1 = __decorate([
-    (0, CommandClassDecorators_1.CCCommand)(_Types_1.NotificationCommand.EventSupportedReport)
-], NotificationCCEventSupportedReport);
-let NotificationCCEventSupportedGet = NotificationCCEventSupportedGet_1 = class NotificationCCEventSupportedGet extends NotificationCC {
-    constructor(options) {
-        super(options);
-        this.notificationType = options.notificationType;
-    }
-    static from(raw, ctx) {
-        (0, safe_1.validatePayload)(raw.payload.length >= 1);
-        const notificationType = raw.payload[0];
-        return new NotificationCCEventSupportedGet_1({
-            nodeId: ctx.sourceNodeId,
-            notificationType,
-        });
-    }
-    notificationType;
-    serialize(ctx) {
-        this.payload = safe_2.Bytes.from([this.notificationType]);
-        return super.serialize(ctx);
-    }
-    toLogEntry(ctx) {
-        return {
-            ...super.toLogEntry(ctx),
-            message: {
-                "notification type": (0, core_1.getNotificationName)(this.notificationType),
-            },
-        };
-    }
-};
-exports.NotificationCCEventSupportedGet = NotificationCCEventSupportedGet;
-exports.NotificationCCEventSupportedGet = NotificationCCEventSupportedGet = NotificationCCEventSupportedGet_1 = __decorate([
-    (0, CommandClassDecorators_1.CCCommand)(_Types_1.NotificationCommand.EventSupportedGet),
-    (0, CommandClassDecorators_1.expectedCCResponse)(NotificationCCEventSupportedReport)
-], NotificationCCEventSupportedGet);
-//# sourceMappingURL=NotificationCC.js.map