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

package/build/cc/ThermostatSetpointCC.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ThermostatSetpointCC.d.ts","sourceRoot":"","sources":["../../src/cc/ThermostatSetpointCC.ts"],"names":[],"mappings":"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"}

package/build/cc/ThermostatSetpointCC.js

@@ -1,658 +0,0 @@
-"use strict";
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-var 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) {
-    const { ZWaveError, ZWaveErrorCodes } = require("@zwave-js/core");
-    if (boundHasError()) {
-        throw new ZWaveError(typeName ? `${argName} is not a ${typeName}` : `${argName} has the wrong type`, ZWaveErrorCodes.Argument_Invalid);
-    }
-}
-const __assertType__number = $o => {
-    function _number($o) {
-        return typeof $o !== "number" ? {} : null;
-    }
-    return _number($o);
-};
-const safe_1 = require("@zwave-js/core/safe");
-const safe_2 = require("@zwave-js/shared/safe");
-const safe_3 = require("@zwave-js/shared/safe");
-const API_1 = require("../lib/API");
-const CommandClass_1 = require("../lib/CommandClass");
-const CommandClassDecorators_1 = require("../lib/CommandClassDecorators");
-const Values_1 = require("../lib/Values");
-const _Types_1 = require("../lib/_Types");
-// This array is used to map the advertised supported types (interpretation A)
-// to the actual enum values
-const thermostatSetpointTypeMap = [
-    0x00,
-    0x01,
-    0x02,
-    0x07,
-    0x08,
-    0x09,
-    0x0a,
-    0x0b,
-    0x0c,
-    0x0d,
-    0x0e,
-    0x0f,
-];
-function getScale(scale) {
-    return (0, safe_1.getNamedScale)("temperature", scale)
-        ?? (0, safe_1.getUnknownScale)(scale);
-}
-function getSetpointUnit(scale) {
-    return getScale(scale).unit ?? "";
-}
-exports.ThermostatSetpointCCValues = Object.freeze({
-    ...Values_1.V.defineStaticCCValues(safe_1.CommandClasses["Thermostat Setpoint"], {
-        ...Values_1.V.staticProperty("supportedSetpointTypes", 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) => ({
-            ...safe_1.ValueMetadata.Number,
-            label: `Setpoint (${(0, safe_3.getEnumMemberName)(_Types_1.ThermostatSetpointType, setpointType)})`,
-            ccSpecific: { setpointType },
-        })),
-        // The setpoint scale is only used internally
-        ...Values_1.V.dynamicPropertyAndKeyWithName("setpointScale", "setpointScale", (setpointType) => setpointType, ({ property, propertyKey }) => property === "setpointScale" && typeof propertyKey === "number", undefined, { internal: true }),
-    }),
-});
-let ThermostatSetpointCCAPI = class ThermostatSetpointCCAPI extends API_1.CCAPI {
-    supportsCommand(cmd) {
-        switch (cmd) {
-            case _Types_1.ThermostatSetpointCommand.Get:
-            case _Types_1.ThermostatSetpointCommand.SupportedGet:
-                return this.isSinglecast();
-            case _Types_1.ThermostatSetpointCommand.Set:
-                return true; // This is mandatory
-            case _Types_1.ThermostatSetpointCommand.CapabilitiesGet:
-                return this.version >= 3 && this.isSinglecast();
-        }
-        return super.supportsCommand(cmd);
-    }
-    get [API_1.SET_VALUE]() {
-        return async function ({ property, propertyKey }, value) {
-            if (property !== "setpoint") {
-                (0, API_1.throwUnsupportedProperty)(this.ccId, property);
-            }
-            if (typeof propertyKey !== "number") {
-                throw new safe_1.ZWaveError(`${safe_1.CommandClasses[this.ccId]}: "${property}" must be further specified by a numeric property key`, safe_1.ZWaveErrorCodes.Argument_Invalid);
-            }
-            if (typeof value !== "number") {
-                (0, API_1.throwWrongValueType)(this.ccId, property, "number", typeof value);
-            }
-            // SDS14223: The Scale field value MUST be identical to the value received in the Thermostat Setpoint Report for the
-            // actual Setpoint Type during the node interview. Fall back to the first scale if none is known
-            const preferredScale = this.tryGetValueDB()?.getValue(exports.ThermostatSetpointCCValues.setpointScale(propertyKey).endpoint(this.endpoint.index));
-            const result = await this.set(propertyKey, value, preferredScale ?? 0);
-            // Verify the current value after a delay, unless the command was supervised and successful
-            if (this.isSinglecast() && !(0, safe_1.supervisedCommandSucceeded)(result)) {
-                // TODO: Ideally this would be a short delay, but some thermostats like Remotec ZXT-600
-                // aren't able to handle the GET this quickly.
-                this.schedulePoll({ property, propertyKey }, value);
-            }
-            return result;
-        };
-    }
-    get [API_1.POLL_VALUE]() {
-        return async function ({ property, propertyKey }) {
-            switch (property) {
-                case "setpoint":
-                    if (typeof propertyKey !== "number") {
-                        throw new safe_1.ZWaveError(`${safe_1.CommandClasses[this.ccId]}: "${property}" must be further specified by a numeric property key`, safe_1.ZWaveErrorCodes.Argument_Invalid);
-                    }
-                    return (await this.get(propertyKey))?.value;
-                default:
-                    (0, API_1.throwUnsupportedProperty)(this.ccId, property);
-            }
-        };
-    }
-    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({
-            nodeId: this.endpoint.nodeId,
-            endpointIndex: this.endpoint.index,
-            setpointType,
-        });
-        const response = await this.host.sendCommand(cc, this.commandOptions);
-        if (!response)
-            return;
-        if (response.type !== _Types_1.ThermostatSetpointType["N/A"]) {
-            // This is a supported setpoint
-            const scale = getScale(response.scale);
-            return {
-                value: response.value,
-                scale,
-            };
-        }
-    }
-    async set(setpointType, value, scale) {
-        __assertType("setpointType", "ThermostatSetpointType", __assertType__number.bind(void 0, setpointType));
-        __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({
-            nodeId: this.endpoint.nodeId,
-            endpointIndex: this.endpoint.index,
-            setpointType,
-            value,
-            scale,
-        });
-        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({
-            nodeId: this.endpoint.nodeId,
-            endpointIndex: this.endpoint.index,
-            setpointType,
-        });
-        const response = await this.host.sendCommand(cc, this.commandOptions);
-        if (response) {
-            return (0, safe_3.pick)(response, [
-                "minValue",
-                "maxValue",
-                "minValueScale",
-                "maxValueScale",
-            ]);
-        }
-    }
-    /**
-     * Requests the supported setpoint types from the node. Due to inconsistencies it is NOT recommended
-     * to use this method on nodes with CC versions 1 and 2. Instead rely on the information determined
-     * during node interview.
-     */
-    async getSupportedSetpointTypes() {
-        this.assertSupportsCommand(_Types_1.ThermostatSetpointCommand, _Types_1.ThermostatSetpointCommand.SupportedGet);
-        const cc = new ThermostatSetpointCCSupportedGet({
-            nodeId: this.endpoint.nodeId,
-            endpointIndex: this.endpoint.index,
-        });
-        const response = await this.host.sendCommand(cc, this.commandOptions);
-        return response?.supportedSetpointTypes;
-    }
-};
-exports.ThermostatSetpointCCAPI = ThermostatSetpointCCAPI;
-exports.ThermostatSetpointCCAPI = ThermostatSetpointCCAPI = __decorate([
-    (0, CommandClassDecorators_1.API)(safe_1.CommandClasses["Thermostat Setpoint"])
-], ThermostatSetpointCCAPI);
-let ThermostatSetpointCC = class ThermostatSetpointCC extends CommandClass_1.CommandClass {
-    translatePropertyKey(ctx, property, propertyKey) {
-        if (property === "setpoint") {
-            return (0, safe_3.getEnumMemberName)(_Types_1.ThermostatSetpointType, propertyKey);
-        }
-        else {
-            return super.translatePropertyKey(ctx, property, propertyKey);
-        }
-    }
-    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,
-        });
-        ctx.logNode(node.id, {
-            endpoint: this.endpointIndex,
-            message: `Interviewing ${this.ccName}...`,
-            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 type = _Types_1.ThermostatSetpointType.Heating; type <= _Types_1.ThermostatSetpointType["Full Power"]; type++) {
-                const setpointName = (0, safe_3.getEnumMemberName)(_Types_1.ThermostatSetpointType, type);
-                // Every time, query the current value
-                ctx.logNode(node.id, {
-                    endpoint: this.endpointIndex,
-                    message: `querying current value of setpoint ${setpointName}...`,
-                    direction: "outbound",
-                });
-                const setpoint = await api.get(type);
-                // If the node did not respond, assume the setpoint type is not supported
-                let logMessage;
-                if (setpoint) {
-                    // Setpoint supported, remember the type
-                    supportedSetpointTypes.push(type);
-                    logMessage =
-                        `received current value of setpoint ${setpointName}: ${setpoint.value} ${setpoint.scale.unit ?? ""}`;
-                }
-                else {
-                    // We're sure about the interpretation - this should not happen
-                    logMessage = `setpoint ${setpointName} is not supported`;
-                }
-                ctx.logNode(node.id, {
-                    endpoint: this.endpointIndex,
-                    message: logMessage,
-                    direction: "inbound",
-                });
-            }
-            // 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 = [];
-            ctx.logNode(node.id, {
-                endpoint: this.endpointIndex,
-                message: "retrieving supported setpoint types...",
-                direction: "outbound",
-            });
-            const resp = await api.getSupportedSetpointTypes();
-            if (resp) {
-                setpointTypes = [...resp];
-                const logMessage = "received supported setpoint types:\n"
-                    + setpointTypes
-                        .map((type) => (0, safe_3.getEnumMemberName)(_Types_1.ThermostatSetpointType, type))
-                        .map((name) => `· ${name}`)
-                        .join("\n");
-                ctx.logNode(node.id, {
-                    endpoint: this.endpointIndex,
-                    message: logMessage,
-                    direction: "inbound",
-                });
-            }
-            else {
-                ctx.logNode(node.id, {
-                    endpoint: this.endpointIndex,
-                    message: "Querying supported setpoint types timed out, skipping interview...",
-                    level: "warn",
-                });
-                return;
-            }
-            for (const type of setpointTypes) {
-                const setpointName = (0, safe_3.getEnumMemberName)(_Types_1.ThermostatSetpointType, type);
-                // Find out the capabilities of this setpoint
-                ctx.logNode(node.id, {
-                    endpoint: this.endpointIndex,
-                    message: `retrieving capabilities for setpoint ${setpointName}...`,
-                    direction: "outbound",
-                });
-                const setpointCaps = await api.getCapabilities(type);
-                if (setpointCaps) {
-                    const minValueUnit = getSetpointUnit(setpointCaps.minValueScale);
-                    const maxValueUnit = getSetpointUnit(setpointCaps.maxValueScale);
-                    const logMessage = `received capabilities for setpoint ${setpointName}:
-minimum value: ${setpointCaps.minValue} ${minValueUnit}
-maximum value: ${setpointCaps.maxValue} ${maxValueUnit}`;
-                    ctx.logNode(node.id, {
-                        endpoint: this.endpointIndex,
-                        message: logMessage,
-                        direction: "inbound",
-                    });
-                }
-            }
-            // Query the current value for all setpoint types
-            await this.refreshValues(ctx);
-        }
-        // Remember that the interview is complete
-        this.setInterviewComplete(ctx, true);
-    }
-    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(ctx, exports.ThermostatSetpointCCValues.supportedSetpointTypes) ?? [];
-        // Query each setpoint's current value
-        for (const type of setpointTypes) {
-            const setpointName = (0, safe_3.getEnumMemberName)(_Types_1.ThermostatSetpointType, type);
-            // Every time, query the current value
-            ctx.logNode(node.id, {
-                endpoint: this.endpointIndex,
-                message: `querying current value of setpoint ${setpointName}...`,
-                direction: "outbound",
-            });
-            const setpoint = await api.get(type);
-            if (setpoint) {
-                const logMessage = `received current value of setpoint ${setpointName}: ${setpoint.value} ${setpoint.scale.unit ?? ""}`;
-                ctx.logNode(node.id, {
-                    endpoint: this.endpointIndex,
-                    message: logMessage,
-                    direction: "inbound",
-                });
-            }
-        }
-    }
-};
-exports.ThermostatSetpointCC = ThermostatSetpointCC;
-exports.ThermostatSetpointCC = ThermostatSetpointCC = __decorate([
-    (0, CommandClassDecorators_1.commandClass)(safe_1.CommandClasses["Thermostat Setpoint"]),
-    (0, CommandClassDecorators_1.implementedVersion)(3),
-    (0, CommandClassDecorators_1.ccValues)(exports.ThermostatSetpointCCValues)
-], ThermostatSetpointCC);
-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(ctx) {
-        // If a config file overwrites how the float should be encoded, use that information
-        const override = ctx.getDeviceConfig?.(this.nodeId)
-            ?.compat?.overrideFloatEncoding;
-        this.payload = safe_2.Bytes.concat([
-            safe_2.Bytes.from([this.setpointType & 0b1111]),
-            (0, safe_1.encodeFloatWithScale)(this.value, this.scale, override),
-        ]);
-        return super.serialize(ctx);
-    }
-    toLogEntry(ctx) {
-        const scale = getScale(this.scale);
-        return {
-            ...super.toLogEntry(ctx),
-            message: {
-                "setpoint type": (0, safe_3.getEnumMemberName)(_Types_1.ThermostatSetpointType, this.setpointType),
-                value: `${this.value} ${scale.unit}`,
-            },
-        };
-    }
-};
-exports.ThermostatSetpointCCSet = ThermostatSetpointCCSet;
-exports.ThermostatSetpointCCSet = ThermostatSetpointCCSet = ThermostatSetpointCCSet_1 = __decorate([
-    (0, CommandClassDecorators_1.CCCommand)(_Types_1.ThermostatSetpointCommand.Set),
-    (0, CommandClassDecorators_1.useSupervision)()
-], ThermostatSetpointCCSet);
-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(ctx) {
-        if (!super.persistValues(ctx))
-            return false;
-        const scale = getScale(this.scale);
-        const setpointValue = exports.ThermostatSetpointCCValues.setpoint(this.type);
-        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(ctx, setpointValue, {
-                ...(existingMetadata ?? setpointValue.meta),
-                unit: scale.unit,
-            });
-        }
-        this.setValue(ctx, setpointValue, this.value);
-        // Remember the device-preferred setpoint scale so it can be used in SET commands
-        this.setValue(ctx, exports.ThermostatSetpointCCValues.setpointScale(this.type), scale.key);
-        return true;
-    }
-    type;
-    scale;
-    value;
-    serialize(ctx) {
-        this.payload = safe_2.Bytes.concat([
-            safe_2.Bytes.from([this.type & 0b1111]),
-            (0, safe_1.encodeFloatWithScale)(this.value, this.scale),
-        ]);
-        return super.serialize(ctx);
-    }
-    toLogEntry(ctx) {
-        const scale = getScale(this.scale);
-        return {
-            ...super.toLogEntry(ctx),
-            message: {
-                "setpoint type": (0, safe_3.getEnumMemberName)(_Types_1.ThermostatSetpointType, this.type),
-                value: `${this.value} ${scale.unit}`,
-            },
-        };
-    }
-};
-exports.ThermostatSetpointCCReport = ThermostatSetpointCCReport;
-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 = 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(ctx) {
-        this.payload = safe_2.Bytes.from([this.setpointType & 0b1111]);
-        return super.serialize(ctx);
-    }
-    toLogEntry(ctx) {
-        return {
-            ...super.toLogEntry(ctx),
-            message: {
-                "setpoint type": (0, safe_3.getEnumMemberName)(_Types_1.ThermostatSetpointType, this.setpointType),
-            },
-        };
-    }
-};
-exports.ThermostatSetpointCCGet = ThermostatSetpointCCGet;
-exports.ThermostatSetpointCCGet = ThermostatSetpointCCGet = ThermostatSetpointCCGet_1 = __decorate([
-    (0, CommandClassDecorators_1.CCCommand)(_Types_1.ThermostatSetpointCommand.Get),
-    (0, CommandClassDecorators_1.expectedCCResponse)(ThermostatSetpointCCReport, testResponseForThermostatSetpointGet)
-], ThermostatSetpointCCGet);
-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(ctx) {
-        if (!super.persistValues(ctx))
-            return false;
-        // Predefine the metadata
-        const setpointValue = exports.ThermostatSetpointCCValues.setpoint(this.type);
-        this.setMetadata(ctx, setpointValue, {
-            ...setpointValue.meta,
-            min: this.minValue,
-            max: this.maxValue,
-            unit: getSetpointUnit(this.minValueScale)
-                || getSetpointUnit(this.maxValueScale),
-        });
-        return true;
-    }
-    type;
-    minValue;
-    maxValue;
-    minValueScale;
-    maxValueScale;
-    serialize(ctx) {
-        const min = (0, safe_1.encodeFloatWithScale)(this.minValue, this.minValueScale);
-        const max = (0, safe_1.encodeFloatWithScale)(this.maxValue, this.maxValueScale);
-        this.payload = safe_2.Bytes.concat([safe_2.Bytes.from([this.type]), min, max]);
-        return super.serialize(ctx);
-    }
-    toLogEntry(ctx) {
-        const minValueScale = getScale(this.minValueScale);
-        const maxValueScale = getScale(this.maxValueScale);
-        return {
-            ...super.toLogEntry(ctx),
-            message: {
-                "setpoint type": (0, safe_3.getEnumMemberName)(_Types_1.ThermostatSetpointType, this.type),
-                "min value": `${this.minValue} ${minValueScale.unit}`,
-                "max value": `${this.maxValue} ${maxValueScale.unit}`,
-            },
-        };
-    }
-};
-exports.ThermostatSetpointCCCapabilitiesReport = ThermostatSetpointCCCapabilitiesReport;
-exports.ThermostatSetpointCCCapabilitiesReport = ThermostatSetpointCCCapabilitiesReport = ThermostatSetpointCCCapabilitiesReport_1 = __decorate([
-    (0, CommandClassDecorators_1.CCCommand)(_Types_1.ThermostatSetpointCommand.CapabilitiesReport)
-], ThermostatSetpointCCCapabilitiesReport);
-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(ctx) {
-        this.payload = safe_2.Bytes.from([this.setpointType & 0b1111]);
-        return super.serialize(ctx);
-    }
-    toLogEntry(ctx) {
-        return {
-            ...super.toLogEntry(ctx),
-            message: {
-                "setpoint type": (0, safe_3.getEnumMemberName)(_Types_1.ThermostatSetpointType, this.setpointType),
-            },
-        };
-    }
-};
-exports.ThermostatSetpointCCCapabilitiesGet = ThermostatSetpointCCCapabilitiesGet;
-exports.ThermostatSetpointCCCapabilitiesGet = ThermostatSetpointCCCapabilitiesGet = ThermostatSetpointCCCapabilitiesGet_1 = __decorate([
-    (0, CommandClassDecorators_1.CCCommand)(_Types_1.ThermostatSetpointCommand.CapabilitiesGet),
-    (0, CommandClassDecorators_1.expectedCCResponse)(ThermostatSetpointCCCapabilitiesReport)
-], ThermostatSetpointCCCapabilitiesGet);
-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(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(ctx);
-    }
-    toLogEntry(ctx) {
-        return {
-            ...super.toLogEntry(ctx),
-            message: {
-                "supported setpoint types": this.supportedSetpointTypes
-                    .map((t) => `\n· ${(0, safe_3.getEnumMemberName)(_Types_1.ThermostatSetpointType, t)}`)
-                    .join(""),
-            },
-        };
-    }
-};
-exports.ThermostatSetpointCCSupportedReport = ThermostatSetpointCCSupportedReport;
-__decorate([
-    (0, CommandClassDecorators_1.ccValue)(exports.ThermostatSetpointCCValues.supportedSetpointTypes)
-], ThermostatSetpointCCSupportedReport.prototype, "supportedSetpointTypes", void 0);
-exports.ThermostatSetpointCCSupportedReport = ThermostatSetpointCCSupportedReport = ThermostatSetpointCCSupportedReport_1 = __decorate([
-    (0, CommandClassDecorators_1.CCCommand)(_Types_1.ThermostatSetpointCommand.SupportedReport)
-], ThermostatSetpointCCSupportedReport);
-let ThermostatSetpointCCSupportedGet = class ThermostatSetpointCCSupportedGet extends ThermostatSetpointCC {
-};
-exports.ThermostatSetpointCCSupportedGet = ThermostatSetpointCCSupportedGet;
-exports.ThermostatSetpointCCSupportedGet = ThermostatSetpointCCSupportedGet = __decorate([
-    (0, CommandClassDecorators_1.CCCommand)(_Types_1.ThermostatSetpointCommand.SupportedGet),
-    (0, CommandClassDecorators_1.expectedCCResponse)(ThermostatSetpointCCSupportedReport)
-    /**
-     * Issues a SupportedGet command to the node. Due to inconsistencies in interpretation,
-     * this command should not be used for nodes with CC versions 1 or 2
-     */
-], ThermostatSetpointCCSupportedGet);
-//# sourceMappingURL=ThermostatSetpointCC.js.map