@zwave-js/cc 13.10.1 → 14.0.0-beta.0

package/build/cc/NotificationCC.js

@@ -28,7 +28,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __setModuleDefault(result, mod);
     return result;
 };
-var NotificationCC_1;
+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;
@@ -44,7 +44,10 @@ const __assertType__NotificationCCReportOptions = $o => {
     function _number($o) {
         return typeof $o !== "number" ? {} : null;
     }
-    function _1($o) {
+    function _buffer($o) {
+        return !Buffer.isBuffer($o) ? {} : null;
+    }
+    function _0($o) {
         if (typeof $o !== "object" || $o === null || Array.isArray($o))
             return {};
         if ("alarmType" in $o && $o["alarmType"] !== undefined) {
@@ -52,37 +55,26 @@ const __assertType__NotificationCCReportOptions = $o => {
             if (error)
                 return error;
         }
-        else
-            return {};
         if ("alarmLevel" in $o && $o["alarmLevel"] !== undefined) {
             const error = _number($o["alarmLevel"]);
             if (error)
                 return error;
         }
-        else
-            return {};
-        return null;
-    }
-    function _buffer($o) {
-        return !Buffer.isBuffer($o) ? {} : 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;
         }
-        else
-            return {};
+        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 = _buffer($o["eventParameters"]);
             if (error)
@@ -95,18 +87,9 @@ const __assertType__NotificationCCReportOptions = $o => {
         }
         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);
+    return _0($o);
 };
-const __assertType__NotificationCCGetSpecificOptions = $o => {
+const __assertType__NotificationCCGetOptions = $o => {
     function _number($o) {
         return typeof $o !== "number" ? {} : null;
     }
@@ -258,8 +241,8 @@ exports.NotificationCCValues = Object.freeze({
         undefined),
     }),
 });
-function shouldAutoCreateSimpleDoorSensorValue(applHost, endpoint) {
-    const valueDB = applHost.tryGetValueDB(endpoint.nodeId);
+function shouldAutoCreateSimpleDoorSensorValue(ctx, endpoint) {
+    const valueDB = ctx.tryGetValueDB(endpoint.nodeId);
     if (!valueDB)
         return false;
     const supportedACEvents = valueDB.getValue(exports.NotificationCCValues.supportedNotificationEvents(
@@ -312,32 +295,31 @@ let NotificationCCAPI = class NotificationCCAPI extends API_1.PhysicalCCAPI {
      */
     async getInternal(options) {
         this.assertSupportsCommand(_Types_1.NotificationCommand, _Types_1.NotificationCommand.Get);
-        const cc = new NotificationCCGet(this.applHost, {
+        const cc = new NotificationCCGet({
             nodeId: this.endpoint.nodeId,
-            endpoint: this.endpoint.index,
+            endpointIndex: this.endpoint.index,
             ...options,
         });
-        return this.applHost.sendCommand(cc, this.commandOptions);
+        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(this.applHost, {
+        const cc = new NotificationCCReport({
             nodeId: this.endpoint.nodeId,
-            endpoint: this.endpoint.index,
+            endpointIndex: this.endpoint.index,
             ...options,
         });
-        return this.applHost.sendCommand(cc, this.commandOptions);
+        return this.host.sendCommand(cc, this.commandOptions);
     }
     async get(options) {
-        __assertType("options", "NotificationCCGetSpecificOptions", __assertType__NotificationCCGetSpecificOptions.bind(void 0, options));
+        __assertType("options", "NotificationCCGetOptions", __assertType__NotificationCCGetOptions.bind(void 0, options));
         const response = await this.getInternal(options);
         if (response) {
             return (0, safe_2.pick)(response, [
                 "notificationStatus",
                 "notificationEvent",
                 "alarmLevel",
-                "zensorNetSourceNodeId",
                 "eventParameters",
                 "sequenceNumber",
             ]);
@@ -347,22 +329,22 @@ let NotificationCCAPI = class NotificationCCAPI extends API_1.PhysicalCCAPI {
         __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(this.applHost, {
+        const cc = new NotificationCCSet({
             nodeId: this.endpoint.nodeId,
-            endpoint: this.endpoint.index,
+            endpointIndex: this.endpoint.index,
             notificationType,
             notificationStatus,
         });
-        return this.applHost.sendCommand(cc, this.commandOptions);
+        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(this.applHost, {
+        const cc = new NotificationCCSupportedGet({
             nodeId: this.endpoint.nodeId,
-            endpoint: this.endpoint.index,
+            endpointIndex: this.endpoint.index,
         });
-        const response = await this.applHost.sendCommand(cc, this.commandOptions);
+        const response = await this.host.sendCommand(cc, this.commandOptions);
         if (response) {
             return (0, safe_2.pick)(response, [
                 "supportsV1Alarm",
@@ -373,12 +355,12 @@ let NotificationCCAPI = class NotificationCCAPI extends API_1.PhysicalCCAPI {
     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(this.applHost, {
+        const cc = new NotificationCCEventSupportedGet({
             nodeId: this.endpoint.nodeId,
-            endpoint: this.endpoint.index,
+            endpointIndex: this.endpoint.index,
             notificationType,
         });
-        const response = await this.applHost.sendCommand(cc, this.commandOptions);
+        const response = await this.host.sendCommand(cc, this.commandOptions);
         return response?.supportedEvents;
     }
 };
@@ -445,8 +427,8 @@ let NotificationCC = NotificationCC_1 = class NotificationCC extends CommandClas
             safe_1.CommandClasses["Association Group Information"],
         ];
     }
-    async determineNotificationMode(applHost, api, supportedNotificationEvents) {
-        const node = this.getNode(applHost);
+    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))
@@ -454,14 +436,14 @@ let NotificationCC = NotificationCC_1 = class NotificationCC extends CommandClas
         if (node.supportsCC(safe_1.CommandClasses["Association Group Information"])) {
             try {
                 const groupsIssueingNotifications = AssociationGroupInfoCC_1.AssociationGroupInfoCC
-                    .findGroupsForIssuedCommand(applHost, node, this.ccId, _Types_1.NotificationCommand.Report);
+                    .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
             }
         }
-        applHost.controllerLog.logNode(node.id, {
+        ctx.logNode(node.id, {
             endpoint: this.endpointIndex,
             message: `determining whether this node is pull or push...`,
             direction: "outbound",
@@ -496,18 +478,18 @@ let NotificationCC = NotificationCC_1 = class NotificationCC extends CommandClas
         return "push";
     }
     /** Whether the node implements push or pull notifications */
-    static getNotificationMode(applHost, node) {
-        return applHost
+    static getNotificationMode(ctx, node) {
+        return ctx
             .getValueDB(node.id)
             .getValue(exports.NotificationCCValues.notificationMode.id);
     }
-    async interview(applHost) {
-        const node = this.getNode(applHost);
-        const endpoint = this.getEndpoint(applHost);
-        const api = API_1.CCAPI.create(safe_1.CommandClasses.Notification, applHost, endpoint).withOptions({
+    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,
         });
-        applHost.controllerLog.logNode(node.id, {
+        ctx.logNode(node.id, {
             endpoint: this.endpointIndex,
             message: `Interviewing ${this.ccName}...`,
             direction: "none",
@@ -515,25 +497,25 @@ let NotificationCC = NotificationCC_1 = class NotificationCC extends CommandClas
         // If one Association group issues Notification Reports,
         // we must associate ourselves with that channel
         try {
-            await ccUtils.assignLifelineIssueingCommand(applHost, endpoint, this.ccId, _Types_1.NotificationCommand.Report);
+            await ccUtils.assignLifelineIssueingCommand(ctx, endpoint, this.ccId, _Types_1.NotificationCommand.Report);
         }
         catch {
-            applHost.controllerLog.logNode(node.id, {
+            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 (this.version >= 2) {
-            applHost.controllerLog.logNode(node.id, {
+        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) {
-                applHost.controllerLog.logNode(node.id, {
+                ctx.logNode(node.id, {
                     endpoint: this.endpointIndex,
                     message: "Querying supported notification types timed out, skipping interview...",
                     level: "warn",
@@ -547,17 +529,17 @@ let NotificationCC = NotificationCC_1 = class NotificationCC extends CommandClas
             const logMessage = `received supported notification types:${supportedNotificationNames
                 .map((name) => `\n· ${name}`)
                 .join("")}`;
-            applHost.controllerLog.logNode(node.id, {
+            ctx.logNode(node.id, {
                 endpoint: this.endpointIndex,
                 message: logMessage,
                 direction: "inbound",
             });
-            if (this.version >= 3) {
+            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];
-                    applHost.controllerLog.logNode(node.id, {
+                    ctx.logNode(node.id, {
                         endpoint: this.endpointIndex,
                         message: `querying supported notification events for ${name}...`,
                         direction: "outbound",
@@ -565,7 +547,7 @@ let NotificationCC = NotificationCC_1 = class NotificationCC extends CommandClas
                     const supportedEvents = await api.getSupportedEvents(type);
                     if (supportedEvents) {
                         supportedNotificationEvents.set(type, supportedEvents);
-                        applHost.controllerLog.logNode(node.id, {
+                        ctx.logNode(node.id, {
                             endpoint: this.endpointIndex,
                             message: `received supported notification events for ${name}: ${supportedEvents
                                 .map(String)
@@ -576,13 +558,13 @@ let NotificationCC = NotificationCC_1 = class NotificationCC extends CommandClas
                 }
             }
             // Determine whether the node is a push or pull node
-            let notificationMode = this.getValue(applHost, exports.NotificationCCValues.notificationMode);
+            let notificationMode = this.getValue(ctx, exports.NotificationCCValues.notificationMode);
             if (notificationMode !== "push" && notificationMode !== "pull") {
-                notificationMode = await this.determineNotificationMode(applHost, api, supportedNotificationEvents);
-                this.setValue(applHost, exports.NotificationCCValues.notificationMode, notificationMode);
+                notificationMode = await this.determineNotificationMode(ctx, api, supportedNotificationEvents);
+                this.setValue(ctx, exports.NotificationCCValues.notificationMode, notificationMode);
             }
             if (notificationMode === "pull") {
-                await this.refreshValues(applHost);
+                await this.refreshValues(ctx);
             } /* if (notificationMode === "push") */
             else {
                 for (let i = 0; i < supportedNotificationTypes.length; i++) {
@@ -590,7 +572,7 @@ let NotificationCC = NotificationCC_1 = class NotificationCC extends CommandClas
                     const name = supportedNotificationNames[i];
                     const notification = (0, core_1.getNotification)(type);
                     // Enable reports for each notification type
-                    applHost.controllerLog.logNode(node.id, {
+                    ctx.logNode(node.id, {
                         endpoint: this.endpointIndex,
                         message: `enabling notifications for ${name}...`,
                         direction: "outbound",
@@ -610,9 +592,9 @@ let NotificationCC = NotificationCC_1 = class NotificationCC extends CommandClas
                                     // 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(applHost, value)
+                                    if (this.getValue(ctx, value)
                                         == undefined) {
-                                        this.setValue(applHost, value, 0);
+                                        this.setValue(ctx, value, 0);
                                     }
                                 }
                             }
@@ -622,12 +604,12 @@ let NotificationCC = NotificationCC_1 = class NotificationCC extends CommandClas
             }
         }
         // Only create metadata for V1 values if necessary
-        if (this.version === 1 || supportsV1Alarm) {
-            this.ensureMetadata(applHost, exports.NotificationCCValues.alarmType);
-            this.ensureMetadata(applHost, exports.NotificationCCValues.alarmLevel);
+        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 = applHost.getDeviceConfig?.(this.nodeId)
+        const mappings = ctx.getDeviceConfig?.(this.nodeId)
             ?.compat?.alarmMapping;
         if (mappings) {
             // Find all mappings to a valid notification variable
@@ -649,43 +631,43 @@ let NotificationCC = NotificationCC_1 = class NotificationCC extends CommandClas
                 const notificationValue = exports.NotificationCCValues
                     .notificationVariable(notification.name, valueConfig.variableName);
                 // Create or update the metadata
-                const metadata = getNotificationValueMetadata(this.getMetadata(applHost, notificationValue), notification, valueConfig);
-                this.setMetadata(applHost, notificationValue, 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(applHost, notificationValue) == undefined) {
-                        this.setValue(applHost, notificationValue, 0);
+                    if (this.getValue(ctx, notificationValue) == undefined) {
+                        this.setValue(ctx, notificationValue, 0);
                     }
                 }
             }
             // Remember supported notification types and events in the cache
-            this.setValue(applHost, exports.NotificationCCValues.supportedNotificationTypes, [...supportedNotifications.keys()]);
+            this.setValue(ctx, exports.NotificationCCValues.supportedNotificationTypes, [...supportedNotifications.keys()]);
             for (const [type, events] of supportedNotifications) {
-                this.setValue(applHost, exports.NotificationCCValues.supportedNotificationEvents(type), [...events]);
+                this.setValue(ctx, exports.NotificationCCValues.supportedNotificationEvents(type), [...events]);
             }
         }
         // Remember that the interview is complete
-        this.setInterviewComplete(applHost, true);
+        this.setInterviewComplete(ctx, true);
     }
-    async refreshValues(applHost) {
-        const node = this.getNode(applHost);
+    async refreshValues(ctx) {
+        const node = this.getNode(ctx);
         // Refreshing values only works on pull nodes
-        if (NotificationCC_1.getNotificationMode(applHost, node) === "pull") {
-            const endpoint = this.getEndpoint(applHost);
-            const api = API_1.CCAPI.create(safe_1.CommandClasses.Notification, applHost, endpoint).withOptions({
+        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(applHost, exports.NotificationCCValues.supportedNotificationTypes) ?? [];
+            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
-                applHost.controllerLog.logNode(node.id, {
+                ctx.logNode(node.id, {
                     endpoint: this.endpointIndex,
                     message: `querying notification status for ${name}...`,
                     direction: "outbound",
@@ -701,15 +683,15 @@ let NotificationCC = NotificationCC_1 = class NotificationCC extends CommandClas
                     await node.handleCommand(response);
             }
             // Remember when we did this
-            this.setValue(applHost, exports.NotificationCCValues.lastRefresh, Date.now());
+            this.setValue(ctx, exports.NotificationCCValues.lastRefresh, Date.now());
         }
     }
-    shouldRefreshValues(applHost) {
+    shouldRefreshValues(ctx) {
         // Pull-mode nodes must be polled regularly
-        const isPullMode = NotificationCC_1.getNotificationMode(applHost, this.getNode(applHost)) === "pull";
+        const isPullMode = NotificationCC_1.getNotificationMode(ctx, this.getNode(ctx)) === "pull";
         if (!isPullMode)
             return false;
-        const lastUpdated = this.getValue(applHost, exports.NotificationCCValues.lastRefresh);
+        const lastUpdated = this.getValue(ctx, exports.NotificationCCValues.lastRefresh);
         return (lastUpdated == undefined
             || Date.now() - lastUpdated > core_1.timespan.hours(6));
     }
@@ -720,31 +702,34 @@ exports.NotificationCC = NotificationCC = NotificationCC_1 = __decorate([
     (0, CommandClassDecorators_1.implementedVersion)(8),
     (0, CommandClassDecorators_1.ccValues)(exports.NotificationCCValues)
 ], NotificationCC);
-let NotificationCCSet = class NotificationCCSet extends NotificationCC {
-    constructor(host, options) {
-        super(host, options);
-        if ((0, CommandClass_1.gotDeserializationOptions)(options)) {
-            (0, safe_1.validatePayload)(this.payload.length >= 2);
-            this.notificationType = this.payload[0];
-            this.notificationStatus = this.payload[1] === 0xff;
-        }
-        else {
-            this.notificationType = options.notificationType;
-            this.notificationStatus = options.notificationStatus;
-        }
+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() {
+    serialize(ctx) {
         this.payload = Buffer.from([
             this.notificationType,
             this.notificationStatus ? 0xff : 0x00,
         ]);
-        return super.serialize();
+        return super.serialize(ctx);
     }
-    toLogEntry(host) {
+    toLogEntry(ctx) {
         return {
-            ...super.toLogEntry(host),
+            ...super.toLogEntry(ctx),
             message: {
                 "notification type": (0, core_1.getNotificationName)(this.notificationType),
                 status: this.notificationStatus,
@@ -753,77 +738,85 @@ let NotificationCCSet = class NotificationCCSet extends NotificationCC {
     }
 };
 exports.NotificationCCSet = NotificationCCSet;
-exports.NotificationCCSet = NotificationCCSet = __decorate([
+exports.NotificationCCSet = NotificationCCSet = NotificationCCSet_1 = __decorate([
     (0, CommandClassDecorators_1.CCCommand)(_Types_1.NotificationCommand.Set),
     (0, CommandClassDecorators_1.useSupervision)()
 ], NotificationCCSet);
-let NotificationCCReport = class NotificationCCReport extends NotificationCC {
-    constructor(host, options) {
-        super(host, options);
-        if ((0, CommandClass_1.gotDeserializationOptions)(options)) {
-            (0, safe_1.validatePayload)(this.payload.length >= 2);
-            this.alarmType = this.payload[0];
-            this.alarmLevel = this.payload[1];
-            // V2..V3, reserved in V4+
-            if ((this.version === 2 || this.version === 3)
-                && this.payload.length >= 3) {
-                this.zensorNetSourceNodeId = this.payload[2];
-            }
-            // 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
-            if (this.payload.length >= 7) {
-                this.notificationStatus = this.payload[3];
-                this.notificationType = this.payload[4];
-                this.notificationEvent = this.payload[5];
-                const containsSeqNum = !!(this.payload[6] & 0b1000_0000);
-                const numEventParams = this.payload[6] & 0b11111;
-                if (numEventParams > 0) {
-                    (0, safe_1.validatePayload)(this.payload.length >= 7 + numEventParams);
-                    this.eventParameters = Buffer.from(this.payload.subarray(7, 7 + numEventParams));
-                }
-                if (containsSeqNum) {
-                    (0, safe_1.validatePayload)(this.payload.length >= 7 + numEventParams + 1);
-                    this.sequenceNumber = this.payload[7 + numEventParams];
-                }
-            }
-            // Store the V1 alarm values if they exist
+let NotificationCCReport = NotificationCCReport_1 = class NotificationCCReport extends NotificationCC {
+    constructor(options) {
+        super(options);
+        if (options.alarmType != undefined) {
+            this.alarmType = options.alarmType;
+            this.alarmLevel = options.alarmLevel;
         }
-        else {
-            // Create a notification to send
-            if ("alarmType" in options) {
-                this.alarmType = options.alarmType;
-                this.alarmLevel = options.alarmLevel;
-                // Send a V1 command
-                this.version = 1;
-            }
-            else {
-                this.notificationType = options.notificationType;
-                this.notificationStatus = true;
-                this.notificationEvent = options.notificationEvent;
-                this.eventParameters = options.eventParameters;
-                this.sequenceNumber = options.sequenceNumber;
-            }
+        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;
         }
     }
-    persistValues(applHost) {
-        if (!super.persistValues(applHost))
+    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 = Buffer.from(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 (this.version >= 2) {
+            if (ccVersion >= 2) {
                 // Check if the device actually supports Notification CC, but chooses
                 // to send Alarm frames instead (GH#1034)
-                const supportedNotificationTypes = this.getValue(applHost, exports.NotificationCCValues.supportedNotificationTypes);
+                const supportedNotificationTypes = this.getValue(ctx, exports.NotificationCCValues.supportedNotificationTypes);
                 if ((0, typeguards_1.isArray)(supportedNotificationTypes)
                     && supportedNotificationTypes.includes(this.alarmType)) {
-                    const supportedNotificationEvents = this.getValue(applHost, exports.NotificationCCValues.supportedNotificationEvents(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
-                        applHost.controllerLog.logNode(this.nodeId, `treating V1 Alarm frame as Notification Report`);
+                        ctx.logNode(this.nodeId, `treating V1 Alarm frame as Notification Report`);
                         this.notificationType = this.alarmType;
                         this.notificationEvent = this.alarmLevel;
                         this.alarmType = undefined;
@@ -833,12 +826,12 @@ let NotificationCCReport = class NotificationCCReport extends NotificationCC {
             }
             else {
                 // V1 Alarm, check if there is a compat option to map this V1 report to a V2+ report
-                const mapping = this.host.getDeviceConfig?.(this.nodeId)?.compat?.alarmMapping;
+                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) {
-                    applHost.controllerLog.logNode(this.nodeId, `compat mapping found, treating V1 Alarm frame as Notification Report`);
+                    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) {
@@ -858,16 +851,16 @@ let NotificationCCReport = class NotificationCCReport extends NotificationCC {
             }
         }
         // Now we can interpret the event parameters and turn them into something useful
-        this.parseEventParameters(applHost);
+        this.parseEventParameters(ctx);
         if (this.alarmType != undefined) {
             const alarmTypeValue = exports.NotificationCCValues.alarmType;
-            this.ensureMetadata(applHost, alarmTypeValue);
-            this.setValue(applHost, alarmTypeValue, this.alarmType);
+            this.ensureMetadata(ctx, alarmTypeValue);
+            this.setValue(ctx, alarmTypeValue, this.alarmType);
         }
         if (this.alarmLevel != undefined) {
             const alarmLevelValue = exports.NotificationCCValues.alarmLevel;
-            this.ensureMetadata(applHost, alarmLevelValue);
-            this.setValue(applHost, alarmLevelValue, this.alarmLevel);
+            this.ensureMetadata(ctx, alarmLevelValue);
+            this.setValue(ctx, alarmLevelValue, this.alarmLevel);
         }
         return true;
     }
@@ -876,10 +869,9 @@ let NotificationCCReport = class NotificationCCReport extends NotificationCC {
     notificationType;
     notificationStatus;
     notificationEvent;
-    zensorNetSourceNodeId;
     eventParameters;
     sequenceNumber;
-    toLogEntry(host) {
+    toLogEntry(ctx) {
         let message = {};
         if (this.alarmType) {
             message = {
@@ -919,9 +911,6 @@ let NotificationCCReport = class NotificationCCReport extends NotificationCC {
                 };
             }
         }
-        if (this.zensorNetSourceNodeId) {
-            message["zensor net source node id"] = this.zensorNetSourceNodeId;
-        }
         if (this.sequenceNumber != undefined) {
             message["sequence number"] = this.sequenceNumber;
         }
@@ -960,11 +949,11 @@ let NotificationCCReport = class NotificationCCReport extends NotificationCC {
             }
         }
         return {
-            ...super.toLogEntry(host),
+            ...super.toLogEntry(ctx),
             message,
         };
     }
-    parseEventParameters(applHost) {
+    parseEventParameters(ctx) {
         // This only makes sense for V2+ notifications
         if (this.notificationType == undefined
             || this.notificationEvent == undefined) {
@@ -1006,12 +995,21 @@ let NotificationCCReport = class NotificationCCReport extends NotificationCC {
                 // 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.from(this.host, {
-                        data: this.eventParameters,
-                        fromEncapsulation: true,
-                        encapCC: this,
+                    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();
@@ -1032,8 +1030,7 @@ let NotificationCCReport = class NotificationCCReport extends NotificationCC {
                         && e.code
                             === safe_1.ZWaveErrorCodes.PacketFormat_InvalidPayload
                         && Buffer.isBuffer(this.eventParameters)) {
-                        const ccId = CommandClass_1.CommandClass.getCommandClass(this.eventParameters);
-                        const ccCommand = CommandClass_1.CommandClass.getCCCommand(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) {
@@ -1044,7 +1041,7 @@ let NotificationCCReport = class NotificationCCReport extends NotificationCC {
                             };
                         }
                         else {
-                            applHost.controllerLog.logNode(this.nodeId, `Failed to parse Notification CC event parameters, ignoring them...`, "error");
+                            ctx.logNode(this.nodeId, `Failed to parse Notification CC event parameters, ignoring them...`, "error");
                         }
                     }
                     else {
@@ -1079,17 +1076,10 @@ let NotificationCCReport = class NotificationCCReport extends NotificationCC {
             }
         }
     }
-    serialize() {
-        if (this.version === 1) {
-            if (this.alarmLevel == undefined || this.alarmType == undefined) {
-                throw new safe_1.ZWaveError(`Notification CC V1 (Alarm CC) reports requires the alarm type and level to be set!`, safe_1.ZWaveErrorCodes.Argument_Invalid);
-            }
-            this.payload = Buffer.from([this.alarmType, this.alarmLevel]);
-        }
-        else {
-            if (this.notificationType == undefined
-                || this.notificationEvent == undefined) {
-                throw new safe_1.ZWaveError(`Notification CC reports requires the notification type and event to be set!`, safe_1.ZWaveErrorCodes.Argument_Invalid);
+    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
                 && !Buffer.isBuffer(this.eventParameters)) {
@@ -1119,35 +1109,51 @@ let NotificationCCReport = class NotificationCCReport extends NotificationCC {
                 ]);
             }
         }
-        return super.serialize();
+        else {
+            this.payload = Buffer.from([
+                this.alarmType ?? 0x00,
+                this.alarmLevel ?? 0x00,
+            ]);
+        }
+        return super.serialize(ctx);
     }
 };
 exports.NotificationCCReport = NotificationCCReport;
-exports.NotificationCCReport = NotificationCCReport = __decorate([
+exports.NotificationCCReport = NotificationCCReport = NotificationCCReport_1 = __decorate([
     (0, CommandClassDecorators_1.CCCommand)(_Types_1.NotificationCommand.Report),
     (0, CommandClassDecorators_1.useSupervision)()
 ], NotificationCCReport);
-let NotificationCCGet = class NotificationCCGet extends NotificationCC {
-    constructor(host, options) {
-        super(host, options);
-        if ((0, CommandClass_1.gotDeserializationOptions)(options)) {
-            (0, safe_1.validatePayload)(this.payload.length >= 1);
-            this.alarmType = this.payload[0] || undefined;
-            if (this.payload.length >= 2) {
-                this.notificationType = this.payload[1] || undefined;
-                if (this.payload.length >= 3 && this.notificationType != 0xff) {
-                    this.notificationEvent = this.payload[2];
-                }
-            }
+let NotificationCCGet = NotificationCCGet_1 = class NotificationCCGet extends NotificationCC {
+    constructor(options) {
+        super(options);
+        if ("alarmType" in options) {
+            this.alarmType = options.alarmType;
         }
         else {
-            if ("alarmType" in options) {
-                this.alarmType = options.alarmType;
-            }
-            else {
-                this.notificationType = options.notificationType;
-                this.notificationEvent = options.notificationEvent;
+            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 */
@@ -1155,20 +1161,18 @@ let NotificationCCGet = class NotificationCCGet extends NotificationCC {
     /** Regulated V3+ notification type */
     notificationType;
     notificationEvent;
-    serialize() {
-        const payload = [this.alarmType || 0];
-        if (this.version >= 2 && this.notificationType != undefined) {
-            payload.push(this.notificationType);
-            if (this.version >= 3) {
-                payload.push(this.notificationType === 0xff
-                    ? 0x00
-                    : this.notificationEvent || 0);
-            }
-        }
-        this.payload = Buffer.from(payload);
-        return super.serialize();
+    serialize(ctx) {
+        const notificationEvent = this.notificationEvent === 0xff
+            ? 0x00
+            : this.notificationEvent;
+        this.payload = Buffer.from([
+            this.alarmType ?? 0x00,
+            this.notificationType ?? 0xff,
+            notificationEvent ?? 0x00,
+        ]);
+        return super.serialize(ctx);
     }
-    toLogEntry(host) {
+    toLogEntry(ctx) {
         const message = {};
         if (this.alarmType != undefined) {
             message["V1 alarm type"] = this.alarmType;
@@ -1180,38 +1184,40 @@ let NotificationCCGet = class NotificationCCGet extends NotificationCC {
             }
         }
         return {
-            ...super.toLogEntry(host),
+            ...super.toLogEntry(ctx),
             message,
         };
     }
 };
 exports.NotificationCCGet = NotificationCCGet;
-exports.NotificationCCGet = NotificationCCGet = __decorate([
+exports.NotificationCCGet = NotificationCCGet = NotificationCCGet_1 = __decorate([
     (0, CommandClassDecorators_1.CCCommand)(_Types_1.NotificationCommand.Get),
     (0, CommandClassDecorators_1.expectedCCResponse)(NotificationCCReport)
 ], NotificationCCGet);
-let NotificationCCSupportedReport = class NotificationCCSupportedReport extends NotificationCC {
-    constructor(host, options) {
-        super(host, options);
-        if ((0, CommandClass_1.gotDeserializationOptions)(options)) {
-            (0, safe_1.validatePayload)(this.payload.length >= 1);
-            this.supportsV1Alarm = !!(this.payload[0] & 0b1000_0000);
-            const numBitMaskBytes = this.payload[0] & 0b0001_1111;
-            (0, safe_1.validatePayload)(numBitMaskBytes > 0, this.payload.length >= 1 + numBitMaskBytes);
-            const notificationBitMask = this.payload.subarray(1, 1 + numBitMaskBytes);
-            this.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);
-        }
-        else {
-            this.supportsV1Alarm = options.supportsV1Alarm;
-            this.supportedNotificationTypes =
-                options.supportedNotificationTypes;
-        }
+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() {
+    serialize(ctx) {
         const bitMask = (0, safe_1.encodeBitMask)(this.supportedNotificationTypes, Math.max(...this.supportedNotificationTypes), 0);
         this.payload = Buffer.concat([
             Buffer.from([
@@ -1219,11 +1225,11 @@ let NotificationCCSupportedReport = class NotificationCCSupportedReport extends
             ]),
             bitMask,
         ]);
-        return super.serialize();
+        return super.serialize(ctx);
     }
-    toLogEntry(host) {
+    toLogEntry(ctx) {
         return {
-            ...super.toLogEntry(host),
+            ...super.toLogEntry(ctx),
             message: {
                 "supports V1 alarm": this.supportsV1Alarm,
                 "supported notification types": this.supportedNotificationTypes
@@ -1240,7 +1246,7 @@ __decorate([
 __decorate([
     (0, CommandClassDecorators_1.ccValue)(exports.NotificationCCValues.supportedNotificationTypes)
 ], NotificationCCSupportedReport.prototype, "supportedNotificationTypes", void 0);
-exports.NotificationCCSupportedReport = NotificationCCSupportedReport = __decorate([
+exports.NotificationCCSupportedReport = NotificationCCSupportedReport = NotificationCCSupportedReport_1 = __decorate([
     (0, CommandClassDecorators_1.CCCommand)(_Types_1.NotificationCommand.SupportedReport)
 ], NotificationCCSupportedReport);
 let NotificationCCSupportedGet = class NotificationCCSupportedGet extends NotificationCC {
@@ -1250,39 +1256,45 @@ exports.NotificationCCSupportedGet = NotificationCCSupportedGet = __decorate([
     (0, CommandClassDecorators_1.CCCommand)(_Types_1.NotificationCommand.SupportedGet),
     (0, CommandClassDecorators_1.expectedCCResponse)(NotificationCCSupportedReport)
 ], NotificationCCSupportedGet);
-let NotificationCCEventSupportedReport = class NotificationCCEventSupportedReport extends NotificationCC {
-    constructor(host, options) {
-        super(host, options);
-        if ((0, CommandClass_1.gotDeserializationOptions)(options)) {
-            (0, safe_1.validatePayload)(this.payload.length >= 1);
-            this.notificationType = this.payload[0];
-            const numBitMaskBytes = this.payload[1] & 0b000_11111;
-            if (numBitMaskBytes === 0) {
-                // Notification type is not supported
-                this.supportedEvents = [];
-                return;
-            }
-            (0, safe_1.validatePayload)(this.payload.length >= 2 + numBitMaskBytes);
-            const eventBitMask = this.payload.subarray(2, 2 + numBitMaskBytes);
-            this.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);
-        }
-        else {
-            this.notificationType = options.notificationType;
-            this.supportedEvents = options.supportedEvents;
+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(applHost) {
-        if (!super.persistValues(applHost))
+    persistValues(ctx) {
+        if (!super.persistValues(ctx))
             return false;
         // Store which events this notification supports
-        this.setValue(applHost, exports.NotificationCCValues.supportedNotificationEvents(this.notificationType), this.supportedEvents);
+        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(applHost, exports.NotificationCCValues.unknownNotificationType(this.notificationType));
+            this.setMetadata(ctx, exports.NotificationCCValues.unknownNotificationType(this.notificationType));
         }
         else {
             // This is a standardized notification
@@ -1296,8 +1308,8 @@ let NotificationCCEventSupportedReport = class NotificationCCEventSupportedRepor
                     // After we've created the metadata initially, extend it
                     const metadata = getNotificationValueMetadata(isFirst
                         ? undefined
-                        : this.getMetadata(applHost, notificationValue), notification, valueConfig);
-                    this.setMetadata(applHost, notificationValue, metadata);
+                        : this.getMetadata(ctx, notificationValue), notification, valueConfig);
+                    this.setMetadata(ctx, notificationValue, metadata);
                     isFirst = false;
                 }
             }
@@ -1306,18 +1318,18 @@ let NotificationCCEventSupportedReport = class NotificationCCEventSupportedRepor
     }
     notificationType;
     supportedEvents;
-    serialize() {
+    serialize(ctx) {
         this.payload = Buffer.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 = Buffer.concat([this.payload, bitMask]);
         }
-        return super.serialize();
+        return super.serialize(ctx);
     }
-    toLogEntry(host) {
+    toLogEntry(ctx) {
         return {
-            ...super.toLogEntry(host),
+            ...super.toLogEntry(ctx),
             message: {
                 "notification type": (0, core_1.getNotificationName)(this.notificationType),
                 "supported events": this.supportedEvents
@@ -1328,28 +1340,30 @@ let NotificationCCEventSupportedReport = class NotificationCCEventSupportedRepor
     }
 };
 exports.NotificationCCEventSupportedReport = NotificationCCEventSupportedReport;
-exports.NotificationCCEventSupportedReport = NotificationCCEventSupportedReport = __decorate([
+exports.NotificationCCEventSupportedReport = NotificationCCEventSupportedReport = NotificationCCEventSupportedReport_1 = __decorate([
     (0, CommandClassDecorators_1.CCCommand)(_Types_1.NotificationCommand.EventSupportedReport)
 ], NotificationCCEventSupportedReport);
-let NotificationCCEventSupportedGet = class NotificationCCEventSupportedGet extends NotificationCC {
-    constructor(host, options) {
-        super(host, options);
-        if ((0, CommandClass_1.gotDeserializationOptions)(options)) {
-            (0, safe_1.validatePayload)(this.payload.length >= 1);
-            this.notificationType = this.payload[0];
-        }
-        else {
-            this.notificationType = options.notificationType;
-        }
+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() {
+    serialize(ctx) {
         this.payload = Buffer.from([this.notificationType]);
-        return super.serialize();
+        return super.serialize(ctx);
     }
-    toLogEntry(host) {
+    toLogEntry(ctx) {
         return {
-            ...super.toLogEntry(host),
+            ...super.toLogEntry(ctx),
             message: {
                 "notification type": (0, core_1.getNotificationName)(this.notificationType),
             },
@@ -1357,7 +1371,7 @@ let NotificationCCEventSupportedGet = class NotificationCCEventSupportedGet exte
     }
 };
 exports.NotificationCCEventSupportedGet = NotificationCCEventSupportedGet;
-exports.NotificationCCEventSupportedGet = NotificationCCEventSupportedGet = __decorate([
+exports.NotificationCCEventSupportedGet = NotificationCCEventSupportedGet = NotificationCCEventSupportedGet_1 = __decorate([
     (0, CommandClassDecorators_1.CCCommand)(_Types_1.NotificationCommand.EventSupportedGet),
     (0, CommandClassDecorators_1.expectedCCResponse)(NotificationCCEventSupportedReport)
 ], NotificationCCEventSupportedGet);