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

package/build/cc/ThermostatSetpointCC.js

@@ -5,6 +5,7 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     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 ThermostatSetpointCCSet_1, ThermostatSetpointCCReport_1, ThermostatSetpointCCGet_1, ThermostatSetpointCCCapabilitiesReport_1, ThermostatSetpointCCCapabilitiesGet_1, ThermostatSetpointCCSupportedReport_1;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ThermostatSetpointCCSupportedGet = exports.ThermostatSetpointCCSupportedReport = exports.ThermostatSetpointCCCapabilitiesGet = exports.ThermostatSetpointCCCapabilitiesReport = exports.ThermostatSetpointCCGet = exports.ThermostatSetpointCCReport = exports.ThermostatSetpointCCSet = exports.ThermostatSetpointCC = exports.ThermostatSetpointCCAPI = exports.ThermostatSetpointCCValues = void 0;
 function __assertType(argName, typeName, boundHasError) {
@@ -54,9 +55,6 @@ exports.ThermostatSetpointCCValues = Object.freeze({
         ...Values_1.V.staticProperty("supportedSetpointTypes", undefined, {
             internal: true,
         }),
-        ...Values_1.V.staticProperty("setpointTypesInterpretation", undefined, {
-            internal: true,
-        }),
     }),
     ...Values_1.V.defineDynamicCCValues(safe_1.CommandClasses["Thermostat Setpoint"], {
         ...Values_1.V.dynamicPropertyAndKeyWithName("setpoint", "setpoint", (setpointType) => setpointType, ({ property, propertyKey }) => property === "setpoint" && typeof propertyKey === "number", (setpointType) => ({
@@ -121,12 +119,12 @@ let ThermostatSetpointCCAPI = class ThermostatSetpointCCAPI extends API_1.CCAPI
     async get(setpointType) {
         __assertType("setpointType", "ThermostatSetpointType", __assertType__number.bind(void 0, setpointType));
         this.assertSupportsCommand(_Types_1.ThermostatSetpointCommand, _Types_1.ThermostatSetpointCommand.Get);
-        const cc = new ThermostatSetpointCCGet(this.applHost, {
+        const cc = new ThermostatSetpointCCGet({
             nodeId: this.endpoint.nodeId,
-            endpoint: this.endpoint.index,
+            endpointIndex: this.endpoint.index,
             setpointType,
         });
-        const response = await this.applHost.sendCommand(cc, this.commandOptions);
+        const response = await this.host.sendCommand(cc, this.commandOptions);
         if (!response)
             return;
         if (response.type !== _Types_1.ThermostatSetpointType["N/A"]) {
@@ -143,24 +141,24 @@ let ThermostatSetpointCCAPI = class ThermostatSetpointCCAPI extends API_1.CCAPI
         __assertType("value", "number", __assertType__number.bind(void 0, value));
         __assertType("scale", "number", __assertType__number.bind(void 0, scale));
         this.assertSupportsCommand(_Types_1.ThermostatSetpointCommand, _Types_1.ThermostatSetpointCommand.Set);
-        const cc = new ThermostatSetpointCCSet(this.applHost, {
+        const cc = new ThermostatSetpointCCSet({
             nodeId: this.endpoint.nodeId,
-            endpoint: this.endpoint.index,
+            endpointIndex: this.endpoint.index,
             setpointType,
             value,
             scale,
         });
-        return this.applHost.sendCommand(cc, this.commandOptions);
+        return this.host.sendCommand(cc, this.commandOptions);
     }
     async getCapabilities(setpointType) {
         __assertType("setpointType", "ThermostatSetpointType", __assertType__number.bind(void 0, setpointType));
         this.assertSupportsCommand(_Types_1.ThermostatSetpointCommand, _Types_1.ThermostatSetpointCommand.CapabilitiesGet);
-        const cc = new ThermostatSetpointCCCapabilitiesGet(this.applHost, {
+        const cc = new ThermostatSetpointCCCapabilitiesGet({
             nodeId: this.endpoint.nodeId,
-            endpoint: this.endpoint.index,
+            endpointIndex: this.endpoint.index,
             setpointType,
         });
-        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, [
                 "minValue",
@@ -177,11 +175,11 @@ let ThermostatSetpointCCAPI = class ThermostatSetpointCCAPI extends API_1.CCAPI
      */
     async getSupportedSetpointTypes() {
         this.assertSupportsCommand(_Types_1.ThermostatSetpointCommand, _Types_1.ThermostatSetpointCommand.SupportedGet);
-        const cc = new ThermostatSetpointCCSupportedGet(this.applHost, {
+        const cc = new ThermostatSetpointCCSupportedGet({
             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);
         return response?.supportedSetpointTypes;
     }
 };
@@ -190,77 +188,42 @@ exports.ThermostatSetpointCCAPI = ThermostatSetpointCCAPI = __decorate([
     (0, CommandClassDecorators_1.API)(safe_1.CommandClasses["Thermostat Setpoint"])
 ], ThermostatSetpointCCAPI);
 let ThermostatSetpointCC = class ThermostatSetpointCC extends CommandClass_1.CommandClass {
-    translatePropertyKey(applHost, property, propertyKey) {
+    translatePropertyKey(ctx, property, propertyKey) {
         if (property === "setpoint") {
             return (0, safe_2.getEnumMemberName)(_Types_1.ThermostatSetpointType, propertyKey);
         }
         else {
-            return super.translatePropertyKey(applHost, property, propertyKey);
+            return super.translatePropertyKey(ctx, property, propertyKey);
         }
     }
-    async interview(applHost) {
-        const node = this.getNode(applHost);
-        const endpoint = this.getEndpoint(applHost);
-        const api = API_1.CCAPI.create(safe_1.CommandClasses["Thermostat Setpoint"], 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["Thermostat Setpoint"], 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",
         });
-        if (this.version <= 2) {
-            let setpointTypes;
-            let interpretation;
-            // Whether our tests changed the assumed bitmask interpretation
-            let interpretationChanged = false;
-            // Query the supported setpoint types
-            applHost.controllerLog.logNode(node.id, {
-                endpoint: this.endpointIndex,
-                message: "retrieving supported setpoint types...",
-                direction: "outbound",
-            });
-            const resp = await api.getSupportedSetpointTypes();
-            if (!resp) {
-                applHost.controllerLog.logNode(node.id, {
-                    endpoint: this.endpointIndex,
-                    message: "Querying supported setpoint types timed out, skipping interview...",
-                    level: "warn",
-                });
-                return;
-            }
-            setpointTypes = [...resp];
-            interpretation = undefined; // we don't know yet which interpretation the device uses
-            // If necessary, test which interpretation the device follows
-            // Assume interpretation B
-            // --> If setpoints 3,4,5 or 6 are supported, the assumption is wrong ==> A
-            function switchToInterpretationA() {
-                setpointTypes = setpointTypes.map((i) => thermostatSetpointTypeMap[i]);
-                interpretation = "A";
-                interpretationChanged = true;
-            }
-            if ([3, 4, 5, 6].some((type) => setpointTypes.includes(type))) {
-                applHost.controllerLog.logNode(node.id, {
-                    endpoint: this.endpointIndex,
-                    message: "uses Thermostat Setpoint bitmap interpretation A",
-                    direction: "none",
-                });
-                switchToInterpretationA();
-            }
-            else {
-                applHost.controllerLog.logNode(node.id, {
-                    endpoint: this.endpointIndex,
-                    message: "Thermostat Setpoint bitmap interpretation is unknown, assuming B for now",
-                    direction: "none",
-                });
-            }
+        if (api.version <= 2) {
+            // It has been found that early implementations of this Command Class applied two non-interoperable
+            // interpretations of the bit mask advertising the support for specific Setpoint Types in the Thermostat
+            // Setpoint Supported Report Command.
+            // A controlling node SHOULD determine the supported Setpoint Types of a version 1 and version 2
+            // supporting node by sending one Thermostat Setpoint Get Command at a time while incrementing
+            // the requested Setpoint Type.
+            // If the same Setpoint Type is advertised in the returned Thermostat Setpoint Report Command, the
+            // controlling node MUST conclude that the actual Setpoint Type is supported.
+            // If the Setpoint Type 0x00 (type N/A) is advertised in the returned Thermostat Setpoint Report
+            // Command, the controlling node MUST conclude that the actual Setpoint Type is not supported.
             // Now scan all endpoints. Each type we received a value for gets marked as supported
             const supportedSetpointTypes = [];
-            for (let i = 0; i < setpointTypes.length; i++) {
-                const type = setpointTypes[i];
+            for (let type = _Types_1.ThermostatSetpointType.Heating; type <= _Types_1.ThermostatSetpointType["Full Power"]; type++) {
                 const setpointName = (0, safe_2.getEnumMemberName)(_Types_1.ThermostatSetpointType, type);
                 // Every time, query the current value
-                applHost.controllerLog.logNode(node.id, {
+                ctx.logNode(node.id, {
                     endpoint: this.endpointIndex,
                     message: `querying current value of setpoint ${setpointName}...`,
                     direction: "outbound",
@@ -274,48 +237,24 @@ let ThermostatSetpointCC = class ThermostatSetpointCC extends CommandClass_1.Com
                     logMessage =
                         `received current value of setpoint ${setpointName}: ${setpoint.value} ${setpoint.scale.unit ?? ""}`;
                 }
-                else if (!interpretation) {
-                    // The setpoint type is not supported, switch to interpretation A
-                    applHost.controllerLog.logNode(node.id, {
-                        endpoint: this.endpointIndex,
-                        message: `the setpoint type ${type} is unsupported, switching to interpretation A`,
-                        direction: "none",
-                    });
-                    switchToInterpretationA();
-                    // retry the current type and scan the remaining types as A
-                    i--;
-                    continue;
-                }
                 else {
                     // We're sure about the interpretation - this should not happen
-                    logMessage = `Setpoint ${setpointName} is not supported`;
+                    logMessage = `setpoint ${setpointName} is not supported`;
                 }
-                applHost.controllerLog.logNode(node.id, {
+                ctx.logNode(node.id, {
                     endpoint: this.endpointIndex,
                     message: logMessage,
                     direction: "inbound",
                 });
             }
-            // If we made an assumption and did not switch to interpretation A,
-            // the device adheres to interpretation B
-            if (!interpretation && !interpretationChanged) {
-                // our assumption about interpretation B was correct
-                interpretation = "B";
-                interpretationChanged = true;
-            }
-            // Remember which setpoint types are actually supported, so we don't
-            // need to do this guesswork again
-            this.setValue(applHost, exports.ThermostatSetpointCCValues.supportedSetpointTypes, supportedSetpointTypes);
-            // Also save the bitmap interpretation if we know it now
-            if (interpretationChanged) {
-                this.setValue(applHost, exports.ThermostatSetpointCCValues.setpointTypesInterpretation, interpretation);
-            }
+            // Remember which setpoint types are actually supported
+            this.setValue(ctx, exports.ThermostatSetpointCCValues.supportedSetpointTypes, supportedSetpointTypes);
         }
         else {
             // Versions >= 3 adhere to bitmap interpretation A, so we can rely on getSupportedSetpointTypes
             // Query the supported setpoint types
             let setpointTypes = [];
-            applHost.controllerLog.logNode(node.id, {
+            ctx.logNode(node.id, {
                 endpoint: this.endpointIndex,
                 message: "retrieving supported setpoint types...",
                 direction: "outbound",
@@ -328,14 +267,14 @@ let ThermostatSetpointCC = class ThermostatSetpointCC extends CommandClass_1.Com
                         .map((type) => (0, safe_2.getEnumMemberName)(_Types_1.ThermostatSetpointType, type))
                         .map((name) => `· ${name}`)
                         .join("\n");
-                applHost.controllerLog.logNode(node.id, {
+                ctx.logNode(node.id, {
                     endpoint: this.endpointIndex,
                     message: logMessage,
                     direction: "inbound",
                 });
             }
             else {
-                applHost.controllerLog.logNode(node.id, {
+                ctx.logNode(node.id, {
                     endpoint: this.endpointIndex,
                     message: "Querying supported setpoint types timed out, skipping interview...",
                     level: "warn",
@@ -345,7 +284,7 @@ let ThermostatSetpointCC = class ThermostatSetpointCC extends CommandClass_1.Com
             for (const type of setpointTypes) {
                 const setpointName = (0, safe_2.getEnumMemberName)(_Types_1.ThermostatSetpointType, type);
                 // Find out the capabilities of this setpoint
-                applHost.controllerLog.logNode(node.id, {
+                ctx.logNode(node.id, {
                     endpoint: this.endpointIndex,
                     message: `retrieving capabilities for setpoint ${setpointName}...`,
                     direction: "outbound",
@@ -357,7 +296,7 @@ let ThermostatSetpointCC = class ThermostatSetpointCC extends CommandClass_1.Com
                     const logMessage = `received capabilities for setpoint ${setpointName}:
 minimum value: ${setpointCaps.minValue} ${minValueUnit}
 maximum value: ${setpointCaps.maxValue} ${maxValueUnit}`;
-                    applHost.controllerLog.logNode(node.id, {
+                    ctx.logNode(node.id, {
                         endpoint: this.endpointIndex,
                         message: logMessage,
                         direction: "inbound",
@@ -365,23 +304,23 @@ maximum value: ${setpointCaps.maxValue} ${maxValueUnit}`;
                 }
             }
             // Query the current value for all setpoint types
-            await this.refreshValues(applHost);
+            await this.refreshValues(ctx);
         }
         // Remember that the interview is complete
-        this.setInterviewComplete(applHost, true);
+        this.setInterviewComplete(ctx, true);
     }
-    async refreshValues(applHost) {
-        const node = this.getNode(applHost);
-        const endpoint = this.getEndpoint(applHost);
-        const api = API_1.CCAPI.create(safe_1.CommandClasses["Thermostat Setpoint"], applHost, endpoint).withOptions({
+    async refreshValues(ctx) {
+        const node = this.getNode(ctx);
+        const endpoint = this.getEndpoint(ctx);
+        const api = API_1.CCAPI.create(safe_1.CommandClasses["Thermostat Setpoint"], ctx, endpoint).withOptions({
             priority: safe_1.MessagePriority.NodeQuery,
         });
-        const setpointTypes = this.getValue(applHost, exports.ThermostatSetpointCCValues.supportedSetpointTypes) ?? [];
+        const setpointTypes = this.getValue(ctx, exports.ThermostatSetpointCCValues.supportedSetpointTypes) ?? [];
         // Query each setpoint's current value
         for (const type of setpointTypes) {
             const setpointName = (0, safe_2.getEnumMemberName)(_Types_1.ThermostatSetpointType, type);
             // Every time, query the current value
-            applHost.controllerLog.logNode(node.id, {
+            ctx.logNode(node.id, {
                 endpoint: this.endpointIndex,
                 message: `querying current value of setpoint ${setpointName}...`,
                 direction: "outbound",
@@ -389,7 +328,7 @@ maximum value: ${setpointCaps.maxValue} ${maxValueUnit}`;
             const setpoint = await api.get(type);
             if (setpoint) {
                 const logMessage = `received current value of setpoint ${setpointName}: ${setpoint.value} ${setpoint.scale.unit ?? ""}`;
-                applHost.controllerLog.logNode(node.id, {
+                ctx.logNode(node.id, {
                     endpoint: this.endpointIndex,
                     message: logMessage,
                     direction: "inbound",
@@ -404,40 +343,42 @@ exports.ThermostatSetpointCC = ThermostatSetpointCC = __decorate([
     (0, CommandClassDecorators_1.implementedVersion)(3),
     (0, CommandClassDecorators_1.ccValues)(exports.ThermostatSetpointCCValues)
 ], ThermostatSetpointCC);
-let ThermostatSetpointCCSet = class ThermostatSetpointCCSet extends ThermostatSetpointCC {
-    constructor(host, options) {
-        super(host, options);
-        if ((0, CommandClass_1.gotDeserializationOptions)(options)) {
-            (0, safe_1.validatePayload)(this.payload.length >= 1);
-            this.setpointType = this.payload[0] & 0b1111;
-            // parseFloatWithScale does its own validation
-            const { value, scale } = (0, safe_1.parseFloatWithScale)(this.payload.subarray(1));
-            this.value = value;
-            this.scale = scale;
-        }
-        else {
-            this.setpointType = options.setpointType;
-            this.value = options.value;
-            this.scale = options.scale;
-        }
+let ThermostatSetpointCCSet = ThermostatSetpointCCSet_1 = class ThermostatSetpointCCSet extends ThermostatSetpointCC {
+    constructor(options) {
+        super(options);
+        this.setpointType = options.setpointType;
+        this.value = options.value;
+        this.scale = options.scale;
+    }
+    static from(raw, ctx) {
+        (0, safe_1.validatePayload)(raw.payload.length >= 1);
+        const setpointType = raw.payload[0] & 0b1111;
+        // parseFloatWithScale does its own validation
+        const { value, scale } = (0, safe_1.parseFloatWithScale)(raw.payload.subarray(1));
+        return new ThermostatSetpointCCSet_1({
+            nodeId: ctx.sourceNodeId,
+            setpointType,
+            value,
+            scale,
+        });
     }
     setpointType;
     value;
     scale;
-    serialize() {
+    serialize(ctx) {
         // If a config file overwrites how the float should be encoded, use that information
-        const override = this.host.getDeviceConfig?.(this.nodeId)
+        const override = ctx.getDeviceConfig?.(this.nodeId)
             ?.compat?.overrideFloatEncoding;
         this.payload = Buffer.concat([
             Buffer.from([this.setpointType & 0b1111]),
             (0, safe_1.encodeFloatWithScale)(this.value, this.scale, override),
         ]);
-        return super.serialize();
+        return super.serialize(ctx);
     }
-    toLogEntry(host) {
+    toLogEntry(ctx) {
         const scale = getScale(this.scale);
         return {
-            ...super.toLogEntry(host),
+            ...super.toLogEntry(ctx),
             message: {
                 "setpoint type": (0, safe_2.getEnumMemberName)(_Types_1.ThermostatSetpointType, this.setpointType),
                 value: `${this.value} ${scale.unit}`,
@@ -446,65 +387,70 @@ let ThermostatSetpointCCSet = class ThermostatSetpointCCSet extends ThermostatSe
     }
 };
 exports.ThermostatSetpointCCSet = ThermostatSetpointCCSet;
-exports.ThermostatSetpointCCSet = ThermostatSetpointCCSet = __decorate([
+exports.ThermostatSetpointCCSet = ThermostatSetpointCCSet = ThermostatSetpointCCSet_1 = __decorate([
     (0, CommandClassDecorators_1.CCCommand)(_Types_1.ThermostatSetpointCommand.Set),
     (0, CommandClassDecorators_1.useSupervision)()
 ], ThermostatSetpointCCSet);
-let ThermostatSetpointCCReport = class ThermostatSetpointCCReport extends ThermostatSetpointCC {
-    constructor(host, options) {
-        super(host, options);
-        if ((0, CommandClass_1.gotDeserializationOptions)(options)) {
-            (0, safe_1.validatePayload)(this.payload.length >= 1);
-            this.type = this.payload[0] & 0b1111;
-            if (this.type === 0) {
-                // Not supported
-                this.value = 0;
-                this.scale = 0;
-                return;
-            }
-            // parseFloatWithScale does its own validation
-            const { value, scale } = (0, safe_1.parseFloatWithScale)(this.payload.subarray(1));
-            this.value = value;
-            this.scale = scale;
-        }
-        else {
-            this.type = options.type;
-            this.value = options.value;
-            this.scale = options.scale;
+let ThermostatSetpointCCReport = ThermostatSetpointCCReport_1 = class ThermostatSetpointCCReport extends ThermostatSetpointCC {
+    constructor(options) {
+        super(options);
+        this.type = options.type;
+        this.value = options.value;
+        this.scale = options.scale;
+    }
+    static from(raw, ctx) {
+        (0, safe_1.validatePayload)(raw.payload.length >= 1);
+        const type = raw.payload[0] & 0b1111;
+        if (type === 0) {
+            // Not supported
+            return new ThermostatSetpointCCReport_1({
+                nodeId: ctx.sourceNodeId,
+                type,
+                value: 0,
+                scale: 0,
+            });
         }
+        // parseFloatWithScale does its own validation
+        const { value, scale } = (0, safe_1.parseFloatWithScale)(raw.payload.subarray(1));
+        return new ThermostatSetpointCCReport_1({
+            nodeId: ctx.sourceNodeId,
+            type,
+            value,
+            scale,
+        });
     }
-    persistValues(applHost) {
-        if (!super.persistValues(applHost))
+    persistValues(ctx) {
+        if (!super.persistValues(ctx))
             return false;
         const scale = getScale(this.scale);
         const setpointValue = exports.ThermostatSetpointCCValues.setpoint(this.type);
-        const existingMetadata = this.getMetadata(applHost, setpointValue);
+        const existingMetadata = this.getMetadata(ctx, setpointValue);
         // Update the metadata when it is missing or the unit has changed
         if (existingMetadata?.unit !== scale.unit) {
-            this.setMetadata(applHost, setpointValue, {
+            this.setMetadata(ctx, setpointValue, {
                 ...(existingMetadata ?? setpointValue.meta),
                 unit: scale.unit,
             });
         }
-        this.setValue(applHost, setpointValue, this.value);
+        this.setValue(ctx, setpointValue, this.value);
         // Remember the device-preferred setpoint scale so it can be used in SET commands
-        this.setValue(applHost, exports.ThermostatSetpointCCValues.setpointScale(this.type), scale.key);
+        this.setValue(ctx, exports.ThermostatSetpointCCValues.setpointScale(this.type), scale.key);
         return true;
     }
     type;
     scale;
     value;
-    serialize() {
+    serialize(ctx) {
         this.payload = Buffer.concat([
             Buffer.from([this.type & 0b1111]),
             (0, safe_1.encodeFloatWithScale)(this.value, this.scale),
         ]);
-        return super.serialize();
+        return super.serialize(ctx);
     }
-    toLogEntry(host) {
+    toLogEntry(ctx) {
         const scale = getScale(this.scale);
         return {
-            ...super.toLogEntry(host),
+            ...super.toLogEntry(ctx),
             message: {
                 "setpoint type": (0, safe_2.getEnumMemberName)(_Types_1.ThermostatSetpointType, this.type),
                 value: `${this.value} ${scale.unit}`,
@@ -513,32 +459,34 @@ let ThermostatSetpointCCReport = class ThermostatSetpointCCReport extends Thermo
     }
 };
 exports.ThermostatSetpointCCReport = ThermostatSetpointCCReport;
-exports.ThermostatSetpointCCReport = ThermostatSetpointCCReport = __decorate([
+exports.ThermostatSetpointCCReport = ThermostatSetpointCCReport = ThermostatSetpointCCReport_1 = __decorate([
     (0, CommandClassDecorators_1.CCCommand)(_Types_1.ThermostatSetpointCommand.Report)
 ], ThermostatSetpointCCReport);
 function testResponseForThermostatSetpointGet(sent, received) {
     // We expect a Thermostat Setpoint Report that matches the requested setpoint type
     return received.type === sent.setpointType;
 }
-let ThermostatSetpointCCGet = class ThermostatSetpointCCGet extends ThermostatSetpointCC {
-    constructor(host, options) {
-        super(host, options);
-        if ((0, CommandClass_1.gotDeserializationOptions)(options)) {
-            (0, safe_1.validatePayload)(this.payload.length >= 1);
-            this.setpointType = this.payload[0] & 0b1111;
-        }
-        else {
-            this.setpointType = options.setpointType;
-        }
+let ThermostatSetpointCCGet = ThermostatSetpointCCGet_1 = class ThermostatSetpointCCGet extends ThermostatSetpointCC {
+    constructor(options) {
+        super(options);
+        this.setpointType = options.setpointType;
+    }
+    static from(raw, ctx) {
+        (0, safe_1.validatePayload)(raw.payload.length >= 1);
+        const setpointType = raw.payload[0] & 0b1111;
+        return new ThermostatSetpointCCGet_1({
+            nodeId: ctx.sourceNodeId,
+            setpointType,
+        });
     }
     setpointType;
-    serialize() {
+    serialize(ctx) {
         this.payload = Buffer.from([this.setpointType & 0b1111]);
-        return super.serialize();
+        return super.serialize(ctx);
     }
-    toLogEntry(host) {
+    toLogEntry(ctx) {
         return {
-            ...super.toLogEntry(host),
+            ...super.toLogEntry(ctx),
             message: {
                 "setpoint type": (0, safe_2.getEnumMemberName)(_Types_1.ThermostatSetpointType, this.setpointType),
             },
@@ -546,40 +494,40 @@ let ThermostatSetpointCCGet = class ThermostatSetpointCCGet extends ThermostatSe
     }
 };
 exports.ThermostatSetpointCCGet = ThermostatSetpointCCGet;
-exports.ThermostatSetpointCCGet = ThermostatSetpointCCGet = __decorate([
+exports.ThermostatSetpointCCGet = ThermostatSetpointCCGet = ThermostatSetpointCCGet_1 = __decorate([
     (0, CommandClassDecorators_1.CCCommand)(_Types_1.ThermostatSetpointCommand.Get),
     (0, CommandClassDecorators_1.expectedCCResponse)(ThermostatSetpointCCReport, testResponseForThermostatSetpointGet)
 ], ThermostatSetpointCCGet);
-let ThermostatSetpointCCCapabilitiesReport = class ThermostatSetpointCCCapabilitiesReport extends ThermostatSetpointCC {
-    constructor(host, options) {
-        super(host, options);
-        if ((0, CommandClass_1.gotDeserializationOptions)(options)) {
-            (0, safe_1.validatePayload)(this.payload.length >= 1);
-            this.type = this.payload[0];
-            let bytesRead;
-            // parseFloatWithScale does its own validation
-            ({
-                value: this.minValue,
-                scale: this.minValueScale,
-                bytesRead,
-            } = (0, safe_1.parseFloatWithScale)(this.payload.subarray(1)));
-            ({ value: this.maxValue, scale: this.maxValueScale } =
-                (0, safe_1.parseFloatWithScale)(this.payload.subarray(1 + bytesRead)));
-        }
-        else {
-            this.type = options.type;
-            this.minValue = options.minValue;
-            this.minValueScale = options.minValueScale;
-            this.maxValue = options.maxValue;
-            this.maxValueScale = options.maxValueScale;
-        }
+let ThermostatSetpointCCCapabilitiesReport = ThermostatSetpointCCCapabilitiesReport_1 = class ThermostatSetpointCCCapabilitiesReport extends ThermostatSetpointCC {
+    constructor(options) {
+        super(options);
+        this.type = options.type;
+        this.minValue = options.minValue;
+        this.minValueScale = options.minValueScale;
+        this.maxValue = options.maxValue;
+        this.maxValueScale = options.maxValueScale;
+    }
+    static from(raw, ctx) {
+        (0, safe_1.validatePayload)(raw.payload.length >= 1);
+        const type = raw.payload[0];
+        // parseFloatWithScale does its own validation
+        const { value: minValue, scale: minValueScale, bytesRead, } = (0, safe_1.parseFloatWithScale)(raw.payload.subarray(1));
+        const { value: maxValue, scale: maxValueScale } = (0, safe_1.parseFloatWithScale)(raw.payload.subarray(1 + bytesRead));
+        return new ThermostatSetpointCCCapabilitiesReport_1({
+            nodeId: ctx.sourceNodeId,
+            type,
+            minValue,
+            minValueScale,
+            maxValue,
+            maxValueScale,
+        });
     }
-    persistValues(applHost) {
-        if (!super.persistValues(applHost))
+    persistValues(ctx) {
+        if (!super.persistValues(ctx))
             return false;
         // Predefine the metadata
         const setpointValue = exports.ThermostatSetpointCCValues.setpoint(this.type);
-        this.setMetadata(applHost, setpointValue, {
+        this.setMetadata(ctx, setpointValue, {
             ...setpointValue.meta,
             min: this.minValue,
             max: this.maxValue,
@@ -593,17 +541,17 @@ let ThermostatSetpointCCCapabilitiesReport = class ThermostatSetpointCCCapabilit
     maxValue;
     minValueScale;
     maxValueScale;
-    serialize() {
+    serialize(ctx) {
         const min = (0, safe_1.encodeFloatWithScale)(this.minValue, this.minValueScale);
         const max = (0, safe_1.encodeFloatWithScale)(this.maxValue, this.maxValueScale);
         this.payload = Buffer.concat([Buffer.from([this.type]), min, max]);
-        return super.serialize();
+        return super.serialize(ctx);
     }
-    toLogEntry(host) {
+    toLogEntry(ctx) {
         const minValueScale = getScale(this.minValueScale);
         const maxValueScale = getScale(this.maxValueScale);
         return {
-            ...super.toLogEntry(host),
+            ...super.toLogEntry(ctx),
             message: {
                 "setpoint type": (0, safe_2.getEnumMemberName)(_Types_1.ThermostatSetpointType, this.type),
                 "min value": `${this.minValue} ${minValueScale.unit}`,
@@ -613,28 +561,30 @@ let ThermostatSetpointCCCapabilitiesReport = class ThermostatSetpointCCCapabilit
     }
 };
 exports.ThermostatSetpointCCCapabilitiesReport = ThermostatSetpointCCCapabilitiesReport;
-exports.ThermostatSetpointCCCapabilitiesReport = ThermostatSetpointCCCapabilitiesReport = __decorate([
+exports.ThermostatSetpointCCCapabilitiesReport = ThermostatSetpointCCCapabilitiesReport = ThermostatSetpointCCCapabilitiesReport_1 = __decorate([
     (0, CommandClassDecorators_1.CCCommand)(_Types_1.ThermostatSetpointCommand.CapabilitiesReport)
 ], ThermostatSetpointCCCapabilitiesReport);
-let ThermostatSetpointCCCapabilitiesGet = class ThermostatSetpointCCCapabilitiesGet extends ThermostatSetpointCC {
-    constructor(host, options) {
-        super(host, options);
-        if ((0, CommandClass_1.gotDeserializationOptions)(options)) {
-            (0, safe_1.validatePayload)(this.payload.length >= 1);
-            this.setpointType = this.payload[0] & 0b1111;
-        }
-        else {
-            this.setpointType = options.setpointType;
-        }
+let ThermostatSetpointCCCapabilitiesGet = ThermostatSetpointCCCapabilitiesGet_1 = class ThermostatSetpointCCCapabilitiesGet extends ThermostatSetpointCC {
+    constructor(options) {
+        super(options);
+        this.setpointType = options.setpointType;
+    }
+    static from(raw, ctx) {
+        (0, safe_1.validatePayload)(raw.payload.length >= 1);
+        const setpointType = raw.payload[0] & 0b1111;
+        return new ThermostatSetpointCCCapabilitiesGet_1({
+            nodeId: ctx.sourceNodeId,
+            setpointType,
+        });
     }
     setpointType;
-    serialize() {
+    serialize(ctx) {
         this.payload = Buffer.from([this.setpointType & 0b1111]);
-        return super.serialize();
+        return super.serialize(ctx);
     }
-    toLogEntry(host) {
+    toLogEntry(ctx) {
         return {
-            ...super.toLogEntry(host),
+            ...super.toLogEntry(ctx),
             message: {
                 "setpoint type": (0, safe_2.getEnumMemberName)(_Types_1.ThermostatSetpointType, this.setpointType),
             },
@@ -642,56 +592,42 @@ let ThermostatSetpointCCCapabilitiesGet = class ThermostatSetpointCCCapabilities
     }
 };
 exports.ThermostatSetpointCCCapabilitiesGet = ThermostatSetpointCCCapabilitiesGet;
-exports.ThermostatSetpointCCCapabilitiesGet = ThermostatSetpointCCCapabilitiesGet = __decorate([
+exports.ThermostatSetpointCCCapabilitiesGet = ThermostatSetpointCCCapabilitiesGet = ThermostatSetpointCCCapabilitiesGet_1 = __decorate([
     (0, CommandClassDecorators_1.CCCommand)(_Types_1.ThermostatSetpointCommand.CapabilitiesGet),
     (0, CommandClassDecorators_1.expectedCCResponse)(ThermostatSetpointCCCapabilitiesReport)
 ], ThermostatSetpointCCCapabilitiesGet);
-let ThermostatSetpointCCSupportedReport = class ThermostatSetpointCCSupportedReport extends ThermostatSetpointCC {
-    constructor(host, options) {
-        super(host, options);
-        if ((0, CommandClass_1.gotDeserializationOptions)(options)) {
-            (0, safe_1.validatePayload)(this.payload.length >= 1);
-            const bitMask = this.payload;
-            const supported = (0, safe_1.parseBitMask)(bitMask, _Types_1.ThermostatSetpointType["N/A"]);
-            if (this.version >= 3) {
-                // Interpretation A
-                this.supportedSetpointTypes = supported.map((i) => thermostatSetpointTypeMap[i]);
-            }
-            else {
-                // It is unknown which interpretation the device complies to.
-                // This must be tested during the interview
-                this.supportedSetpointTypes = supported;
-            }
-            // TODO:
-            // Some devices skip the gaps in the ThermostatSetpointType (Interpretation A), some don't (Interpretation B)
-            // Devices with V3+ must comply with Interpretation A
-            // It is RECOMMENDED that a controlling node determines supported Setpoint Types
-            // by sending one Thermostat Setpoint Get Command at a time while incrementing
-            // the requested Setpoint Type. If the same Setpoint Type is advertised in the
-            // resulting Thermostat Setpoint Report Command, the controlling node MAY conclude
-            // that the actual Setpoint Type is supported. If the Setpoint Type 0x00 (type N/A)
-            // is advertised in the resulting Thermostat Setpoint Report Command, the controlling
-            // node MUST conclude that the actual Setpoint Type is not supported.
-        }
-        else {
-            if (options.supportedSetpointTypes.length === 0) {
-                throw new safe_1.ZWaveError(`At least one setpoint type must be supported`, safe_1.ZWaveErrorCodes.Argument_Invalid);
-            }
-            this.supportedSetpointTypes = options.supportedSetpointTypes;
+let ThermostatSetpointCCSupportedReport = ThermostatSetpointCCSupportedReport_1 = class ThermostatSetpointCCSupportedReport extends ThermostatSetpointCC {
+    constructor(options) {
+        super(options);
+        if (options.supportedSetpointTypes.length === 0) {
+            throw new safe_1.ZWaveError(`At least one setpoint type must be supported`, safe_1.ZWaveErrorCodes.Argument_Invalid);
         }
+        this.supportedSetpointTypes = options.supportedSetpointTypes;
+    }
+    static from(raw, ctx) {
+        (0, safe_1.validatePayload)(raw.payload.length >= 1);
+        const bitMask = raw.payload;
+        const supported = (0, safe_1.parseBitMask)(bitMask, _Types_1.ThermostatSetpointType["N/A"]);
+        // We use this command only when we are sure that bitmask interpretation A is used
+        // FIXME: Figure out if we can do this without the CC version
+        const supportedSetpointTypes = supported.map((i) => thermostatSetpointTypeMap[i]);
+        return new ThermostatSetpointCCSupportedReport_1({
+            nodeId: ctx.sourceNodeId,
+            supportedSetpointTypes,
+        });
     }
     supportedSetpointTypes;
-    serialize() {
+    serialize(ctx) {
         this.payload = (0, safe_1.encodeBitMask)(
         // Encode as interpretation A
         this.supportedSetpointTypes
             .map((t) => thermostatSetpointTypeMap.indexOf(t))
             .filter((t) => t !== -1), undefined, _Types_1.ThermostatSetpointType["N/A"]);
-        return super.serialize();
+        return super.serialize(ctx);
     }
-    toLogEntry(host) {
+    toLogEntry(ctx) {
         return {
-            ...super.toLogEntry(host),
+            ...super.toLogEntry(ctx),
             message: {
                 "supported setpoint types": this.supportedSetpointTypes
                     .map((t) => `\n· ${(0, safe_2.getEnumMemberName)(_Types_1.ThermostatSetpointType, t)}`)
@@ -704,7 +640,7 @@ exports.ThermostatSetpointCCSupportedReport = ThermostatSetpointCCSupportedRepor
 __decorate([
     (0, CommandClassDecorators_1.ccValue)(exports.ThermostatSetpointCCValues.supportedSetpointTypes)
 ], ThermostatSetpointCCSupportedReport.prototype, "supportedSetpointTypes", void 0);
-exports.ThermostatSetpointCCSupportedReport = ThermostatSetpointCCSupportedReport = __decorate([
+exports.ThermostatSetpointCCSupportedReport = ThermostatSetpointCCSupportedReport = ThermostatSetpointCCSupportedReport_1 = __decorate([
     (0, CommandClassDecorators_1.CCCommand)(_Types_1.ThermostatSetpointCommand.SupportedReport)
 ], ThermostatSetpointCCSupportedReport);
 let ThermostatSetpointCCSupportedGet = class ThermostatSetpointCCSupportedGet extends ThermostatSetpointCC {