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

package/build/esm/cc/HumidityControlSetpointCC.js

@@ -0,0 +1,645 @@
+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 HumidityControlSetpointCCReport_1, HumidityControlSetpointCCSupportedReport_1, HumidityControlSetpointCCScaleSupportedReport_1, HumidityControlSetpointCCCapabilitiesReport_1;
+function __assertType(argName, typeName, boundHasError) {
+    const { ZWaveError, ZWaveErrorCodes } = require("@zwave-js/core");
+    if (boundHasError()) {
+        throw new ZWaveError(typeName ? `${argName} is not a ${typeName}` : `${argName} has the wrong type`, ZWaveErrorCodes.Argument_Invalid);
+    }
+}
+const __assertType__number = $o => {
+    function _number($o) {
+        return typeof $o !== "number" ? {} : null;
+    }
+    return _number($o);
+};
+import { CommandClasses, MessagePriority, ValueMetadata, ZWaveError, ZWaveErrorCodes, encodeFloatWithScale, getNamedScale, getUnknownScale, parseBitMask, parseFloatWithScale, supervisedCommandSucceeded, validatePayload, } from "@zwave-js/core/safe";
+import { Bytes } from "@zwave-js/shared/safe";
+import { getEnumMemberName, pick } from "@zwave-js/shared/safe";
+import { CCAPI, POLL_VALUE, SET_VALUE, throwUnsupportedProperty, throwWrongValueType, } from "../lib/API.js";
+import { CommandClass, } from "../lib/CommandClass.js";
+import { API, CCCommand, ccValue, ccValues, commandClass, expectedCCResponse, implementedVersion, useSupervision, } from "../lib/CommandClassDecorators.js";
+import { V } from "../lib/Values.js";
+import { HumidityControlSetpointCommand, HumidityControlSetpointType, } from "../lib/_Types.js";
+export const HumidityControlSetpointCCValues = Object.freeze({
+    ...V.defineStaticCCValues(CommandClasses["Humidity Control Setpoint"], {
+        ...V.staticProperty("supportedSetpointTypes", undefined, {
+            internal: true,
+        }),
+    }),
+    ...V.defineDynamicCCValues(CommandClasses["Humidity Control Setpoint"], {
+        ...V.dynamicPropertyAndKeyWithName("setpoint", "setpoint", (setpointType) => setpointType, ({ property, propertyKey }) => property === "setpoint" && typeof propertyKey === "number", (setpointType) => ({
+            // This is the base metadata that will be extended on the fly
+            ...ValueMetadata.Number,
+            label: `Setpoint (${getEnumMemberName(HumidityControlSetpointType, setpointType)})`,
+            ccSpecific: { setpointType },
+        })),
+        ...V.dynamicPropertyAndKeyWithName("setpointScale", "setpointScale", (setpointType) => setpointType, ({ property, propertyKey }) => property === "setpointScale" && typeof propertyKey === "number", (setpointType) => ({
+            ...ValueMetadata.ReadOnlyUInt8,
+            label: `Setpoint scale (${getEnumMemberName(HumidityControlSetpointType, setpointType)})`,
+        })),
+    }),
+});
+function getScale(scale) {
+    return getNamedScale("humidity", scale) ?? getUnknownScale(scale);
+}
+function getSetpointUnit(scale) {
+    return getScale(scale).unit ?? "";
+}
+let HumidityControlSetpointCCAPI = class HumidityControlSetpointCCAPI extends CCAPI {
+    supportsCommand(cmd) {
+        switch (cmd) {
+            case HumidityControlSetpointCommand.Get:
+            case HumidityControlSetpointCommand.SupportedGet:
+            case HumidityControlSetpointCommand.CapabilitiesGet:
+                return this.isSinglecast();
+            case HumidityControlSetpointCommand.Set:
+                return true; // This is mandatory
+        }
+        return super.supportsCommand(cmd);
+    }
+    get [SET_VALUE]() {
+        return async function ({ property, propertyKey }, value) {
+            if (property !== "setpoint") {
+                throwUnsupportedProperty(this.ccId, property);
+            }
+            if (typeof propertyKey !== "number") {
+                throw new ZWaveError(`${CommandClasses[this.ccId]}: "${property}" must be further specified by a numeric property key`, ZWaveErrorCodes.Argument_Invalid);
+            }
+            if (typeof value !== "number") {
+                throwWrongValueType(this.ccId, property, "number", typeof value);
+            }
+            const scaleValueId = HumidityControlSetpointCCValues.setpointScale(propertyKey).endpoint(this.endpoint.index);
+            const preferredScale = this.tryGetValueDB()?.getValue(scaleValueId);
+            const result = await this.set(propertyKey, value, preferredScale ?? 0);
+            // Verify the change after a delay, unless the command was supervised and successful
+            if (this.isSinglecast() && !supervisedCommandSucceeded(result)) {
+                this.schedulePoll({ property, propertyKey }, value);
+            }
+            return result;
+        };
+    }
+    get [POLL_VALUE]() {
+        return async function ({ property, propertyKey }) {
+            switch (property) {
+                case "setpoint":
+                    if (typeof propertyKey !== "number") {
+                        throw new ZWaveError(`${CommandClasses[this.ccId]}: "${property}" must be further specified by a numeric property key`, ZWaveErrorCodes.Argument_Invalid);
+                    }
+                    return (await this.get(propertyKey))?.value;
+                default:
+                    throwUnsupportedProperty(this.ccId, property);
+            }
+        };
+    }
+    async get(setpointType) {
+        __assertType("setpointType", "HumidityControlSetpointType", __assertType__number.bind(void 0, setpointType));
+        this.assertSupportsCommand(HumidityControlSetpointCommand, HumidityControlSetpointCommand.Get);
+        const cc = new HumidityControlSetpointCCGet({
+            nodeId: this.endpoint.nodeId,
+            endpointIndex: this.endpoint.index,
+            setpointType,
+        });
+        const response = await this.host.sendCommand(cc, this.commandOptions);
+        if (!response)
+            return;
+        return response.type === HumidityControlSetpointType["N/A"]
+            // not supported
+            ? undefined
+            // supported
+            : {
+                value: response.value,
+                scale: response.scale,
+            };
+    }
+    async set(setpointType, value, scale) {
+        __assertType("setpointType", "HumidityControlSetpointType", __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(HumidityControlSetpointCommand, HumidityControlSetpointCommand.Set);
+        const cc = new HumidityControlSetpointCCSet({
+            nodeId: this.endpoint.nodeId,
+            endpointIndex: this.endpoint.index,
+            setpointType,
+            value,
+            scale,
+        });
+        return this.host.sendCommand(cc, this.commandOptions);
+    }
+    async getCapabilities(setpointType) {
+        __assertType("setpointType", "HumidityControlSetpointType", __assertType__number.bind(void 0, setpointType));
+        this.assertSupportsCommand(HumidityControlSetpointCommand, HumidityControlSetpointCommand.CapabilitiesGet);
+        const cc = new HumidityControlSetpointCCCapabilitiesGet({
+            nodeId: this.endpoint.nodeId,
+            endpointIndex: this.endpoint.index,
+            setpointType,
+        });
+        const response = await this.host.sendCommand(cc, this.commandOptions);
+        if (response) {
+            return pick(response, [
+                "minValue",
+                "maxValue",
+                "minValueScale",
+                "maxValueScale",
+            ]);
+        }
+    }
+    async getSupportedSetpointTypes() {
+        this.assertSupportsCommand(HumidityControlSetpointCommand, HumidityControlSetpointCommand.SupportedGet);
+        const cc = new HumidityControlSetpointCCSupportedGet({
+            nodeId: this.endpoint.nodeId,
+            endpointIndex: this.endpoint.index,
+        });
+        const response = await this.host.sendCommand(cc, this.commandOptions);
+        return response?.supportedSetpointTypes;
+    }
+    async getSupportedScales(setpointType) {
+        __assertType("setpointType", "HumidityControlSetpointType", __assertType__number.bind(void 0, setpointType));
+        this.assertSupportsCommand(HumidityControlSetpointCommand, HumidityControlSetpointCommand.SupportedGet);
+        const cc = new HumidityControlSetpointCCScaleSupportedGet({
+            nodeId: this.endpoint.nodeId,
+            endpointIndex: this.endpoint.index,
+            setpointType,
+        });
+        const response = await this.host.sendCommand(cc, this.commandOptions);
+        if (response) {
+            return response.supportedScales.map((scale) => getScale(scale));
+        }
+    }
+};
+HumidityControlSetpointCCAPI = __decorate([
+    API(CommandClasses["Humidity Control Setpoint"])
+], HumidityControlSetpointCCAPI);
+export { HumidityControlSetpointCCAPI };
+let HumidityControlSetpointCC = class HumidityControlSetpointCC extends CommandClass {
+    translatePropertyKey(ctx, property, propertyKey) {
+        if (property === "setpoint") {
+            return getEnumMemberName(HumidityControlSetpointType, propertyKey);
+        }
+        else {
+            return super.translatePropertyKey(ctx, property, propertyKey);
+        }
+    }
+    async interview(ctx) {
+        const node = this.getNode(ctx);
+        const endpoint = this.getEndpoint(ctx);
+        const api = CCAPI.create(CommandClasses["Humidity Control Setpoint"], ctx, endpoint).withOptions({
+            priority: MessagePriority.NodeQuery,
+        });
+        ctx.logNode(node.id, {
+            endpoint: this.endpointIndex,
+            message: `Interviewing ${this.ccName}...`,
+            direction: "none",
+        });
+        // 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) => getEnumMemberName(HumidityControlSetpointType, 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 = getEnumMemberName(HumidityControlSetpointType, type);
+            // Find out the capabilities of this setpoint
+            ctx.logNode(node.id, {
+                endpoint: this.endpointIndex,
+                message: `retrieving capabilities for setpoint ${setpointName}...`,
+                direction: "outbound",
+            });
+            const setpointScaleSupported = await api.getSupportedScales(type);
+            if (setpointScaleSupported) {
+                const logMessage = `received supported scales for setpoint ${setpointName}: 
+${setpointScaleSupported
+                    .map((t) => `\n· ${t.key} ${t.unit} - ${t.label}`)
+                    .join("")}`;
+                ctx.logNode(node.id, {
+                    endpoint: this.endpointIndex,
+                    message: logMessage,
+                    direction: "inbound",
+                });
+                const scaleValue = HumidityControlSetpointCCValues
+                    .setpointScale(type);
+                const states = {};
+                for (const scale of setpointScaleSupported) {
+                    if (scale.unit)
+                        states[scale.key] = scale.unit;
+                }
+                this.setMetadata(ctx, scaleValue, {
+                    ...scaleValue.meta,
+                    states,
+                });
+            }
+            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 = CCAPI.create(CommandClasses["Humidity Control Setpoint"], ctx, endpoint).withOptions({
+            priority: MessagePriority.NodeQuery,
+        });
+        const setpointTypes = this.getValue(ctx, HumidityControlSetpointCCValues.supportedSetpointTypes) ?? [];
+        // Query each setpoint's current value
+        for (const type of setpointTypes) {
+            const setpointName = getEnumMemberName(HumidityControlSetpointType, 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} ${getScale(setpoint.scale).unit ?? ""}`;
+                ctx.logNode(node.id, {
+                    endpoint: this.endpointIndex,
+                    message: logMessage,
+                    direction: "inbound",
+                });
+            }
+        }
+    }
+};
+HumidityControlSetpointCC = __decorate([
+    commandClass(CommandClasses["Humidity Control Setpoint"]),
+    implementedVersion(2),
+    ccValues(HumidityControlSetpointCCValues)
+], HumidityControlSetpointCC);
+export { HumidityControlSetpointCC };
+let HumidityControlSetpointCCSet = class HumidityControlSetpointCCSet extends HumidityControlSetpointCC {
+    constructor(options) {
+        super(options);
+        this.setpointType = options.setpointType;
+        this.value = options.value;
+        this.scale = options.scale;
+    }
+    static from(_raw, _ctx) {
+        // TODO: Deserialize payload
+        throw new ZWaveError(`${this.name}: deserialization not implemented`, ZWaveErrorCodes.Deserialization_NotImplemented);
+        // return new HumidityControlSetpointCCSet({
+        // 	nodeId: ctx.sourceNodeId,
+        // });
+    }
+    setpointType;
+    value;
+    scale;
+    serialize(ctx) {
+        this.payload = Bytes.concat([
+            Bytes.from([this.setpointType & 0b1111]),
+            encodeFloatWithScale(this.value, this.scale),
+        ]);
+        return super.serialize(ctx);
+    }
+    toLogEntry(ctx) {
+        const scale = getScale(this.scale);
+        return {
+            ...super.toLogEntry(ctx),
+            message: {
+                "setpoint type": getEnumMemberName(HumidityControlSetpointType, this.setpointType),
+                value: `${this.value} ${scale.unit}`,
+            },
+        };
+    }
+};
+HumidityControlSetpointCCSet = __decorate([
+    CCCommand(HumidityControlSetpointCommand.Set),
+    useSupervision()
+], HumidityControlSetpointCCSet);
+export { HumidityControlSetpointCCSet };
+let HumidityControlSetpointCCReport = HumidityControlSetpointCCReport_1 = class HumidityControlSetpointCCReport extends HumidityControlSetpointCC {
+    constructor(options) {
+        super(options);
+        // TODO: Check implementation:
+        this.type = options.type;
+        this.value = options.value;
+        this.scale = options.scale;
+    }
+    static from(raw, ctx) {
+        validatePayload(raw.payload.length >= 1);
+        const type = raw.payload[0] & 0b1111;
+        // Setpoint type 0 is not defined in the spec, prevent devices from using it.
+        if (type === 0) {
+            // Not supported
+            return new HumidityControlSetpointCCReport_1({
+                nodeId: ctx.sourceNodeId,
+                type,
+                value: 0,
+                scale: 0,
+            });
+        }
+        // parseFloatWithScale does its own validation
+        const { value, scale } = parseFloatWithScale(raw.payload.subarray(1));
+        return new HumidityControlSetpointCCReport_1({
+            nodeId: ctx.sourceNodeId,
+            type,
+            value,
+            scale,
+        });
+    }
+    persistValues(ctx) {
+        if (!super.persistValues(ctx))
+            return false;
+        const scale = getScale(this.scale);
+        const setpointValue = HumidityControlSetpointCCValues.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, HumidityControlSetpointCCValues.setpointScale(this.type), this.scale);
+        return true;
+    }
+    type;
+    scale;
+    value;
+    toLogEntry(ctx) {
+        const scale = getScale(this.scale);
+        return {
+            ...super.toLogEntry(ctx),
+            message: {
+                "setpoint type": getEnumMemberName(HumidityControlSetpointType, this.type),
+                value: `${this.value} ${scale.unit}`,
+            },
+        };
+    }
+};
+HumidityControlSetpointCCReport = HumidityControlSetpointCCReport_1 = __decorate([
+    CCCommand(HumidityControlSetpointCommand.Report)
+], HumidityControlSetpointCCReport);
+export { HumidityControlSetpointCCReport };
+function testResponseForHumidityControlSetpointGet(sent, received) {
+    // We expect a Humidity Control Setpoint Report that matches the requested setpoint type
+    return received.type === sent.setpointType;
+}
+let HumidityControlSetpointCCGet = class HumidityControlSetpointCCGet extends HumidityControlSetpointCC {
+    constructor(options) {
+        super(options);
+        this.setpointType = options.setpointType;
+    }
+    static from(_raw, _ctx) {
+        // TODO: Deserialize payload
+        throw new ZWaveError(`${this.name}: deserialization not implemented`, ZWaveErrorCodes.Deserialization_NotImplemented);
+        // return new HumidityControlSetpointCCGet({
+        // 	nodeId: ctx.sourceNodeId,
+        // });
+    }
+    setpointType;
+    serialize(ctx) {
+        this.payload = Bytes.from([this.setpointType & 0b1111]);
+        return super.serialize(ctx);
+    }
+    toLogEntry(ctx) {
+        return {
+            ...super.toLogEntry(ctx),
+            message: {
+                "setpoint type": getEnumMemberName(HumidityControlSetpointType, this.setpointType),
+            },
+        };
+    }
+};
+HumidityControlSetpointCCGet = __decorate([
+    CCCommand(HumidityControlSetpointCommand.Get),
+    expectedCCResponse(HumidityControlSetpointCCReport, testResponseForHumidityControlSetpointGet)
+], HumidityControlSetpointCCGet);
+export { HumidityControlSetpointCCGet };
+let HumidityControlSetpointCCSupportedReport = HumidityControlSetpointCCSupportedReport_1 = class HumidityControlSetpointCCSupportedReport extends HumidityControlSetpointCC {
+    constructor(options) {
+        super(options);
+        // TODO: Check implementation:
+        this.supportedSetpointTypes = options.supportedSetpointTypes;
+    }
+    static from(raw, ctx) {
+        validatePayload(raw.payload.length >= 1);
+        const supportedSetpointTypes = parseBitMask(raw.payload, HumidityControlSetpointType["N/A"]);
+        return new HumidityControlSetpointCCSupportedReport_1({
+            nodeId: ctx.sourceNodeId,
+            supportedSetpointTypes,
+        });
+    }
+    supportedSetpointTypes;
+    toLogEntry(ctx) {
+        return {
+            ...super.toLogEntry(ctx),
+            message: {
+                "supported setpoint types": this.supportedSetpointTypes
+                    .map((t) => `\n· ${getEnumMemberName(HumidityControlSetpointType, t)}`)
+                    .join(""),
+            },
+        };
+    }
+};
+__decorate([
+    ccValue(HumidityControlSetpointCCValues.supportedSetpointTypes)
+], HumidityControlSetpointCCSupportedReport.prototype, "supportedSetpointTypes", void 0);
+HumidityControlSetpointCCSupportedReport = HumidityControlSetpointCCSupportedReport_1 = __decorate([
+    CCCommand(HumidityControlSetpointCommand.SupportedReport)
+], HumidityControlSetpointCCSupportedReport);
+export { HumidityControlSetpointCCSupportedReport };
+let HumidityControlSetpointCCSupportedGet = class HumidityControlSetpointCCSupportedGet extends HumidityControlSetpointCC {
+};
+HumidityControlSetpointCCSupportedGet = __decorate([
+    CCCommand(HumidityControlSetpointCommand.SupportedGet),
+    expectedCCResponse(HumidityControlSetpointCCSupportedReport)
+], HumidityControlSetpointCCSupportedGet);
+export { HumidityControlSetpointCCSupportedGet };
+let HumidityControlSetpointCCScaleSupportedReport = HumidityControlSetpointCCScaleSupportedReport_1 = class HumidityControlSetpointCCScaleSupportedReport extends HumidityControlSetpointCC {
+    constructor(options) {
+        super(options);
+        // TODO: Check implementation:
+        this.supportedScales = options.supportedScales;
+    }
+    static from(raw, ctx) {
+        validatePayload(raw.payload.length >= 1);
+        const supportedScales = parseBitMask(Bytes.from([raw.payload[0] & 0b1111]), 0);
+        return new HumidityControlSetpointCCScaleSupportedReport_1({
+            nodeId: ctx.sourceNodeId,
+            supportedScales,
+        });
+    }
+    supportedScales;
+    toLogEntry(ctx) {
+        const supportedScales = this.supportedScales.map((scale) => getScale(scale));
+        return {
+            ...super.toLogEntry(ctx),
+            message: {
+                "scale supported": supportedScales
+                    .map((t) => `\n· ${t.key} ${t.unit} - ${t.label}`)
+                    .join(""),
+            },
+        };
+    }
+};
+HumidityControlSetpointCCScaleSupportedReport = HumidityControlSetpointCCScaleSupportedReport_1 = __decorate([
+    CCCommand(HumidityControlSetpointCommand.ScaleSupportedReport)
+], HumidityControlSetpointCCScaleSupportedReport);
+export { HumidityControlSetpointCCScaleSupportedReport };
+let HumidityControlSetpointCCScaleSupportedGet = class HumidityControlSetpointCCScaleSupportedGet extends HumidityControlSetpointCC {
+    constructor(options) {
+        super(options);
+        this.setpointType = options.setpointType;
+    }
+    static from(_raw, _ctx) {
+        // TODO: Deserialize payload
+        throw new ZWaveError(`${this.name}: deserialization not implemented`, ZWaveErrorCodes.Deserialization_NotImplemented);
+        // return new HumidityControlSetpointCCScaleSupportedGet({
+        // 	nodeId: ctx.sourceNodeId,
+        // });
+    }
+    setpointType;
+    serialize(ctx) {
+        this.payload = Bytes.from([this.setpointType & 0b1111]);
+        return super.serialize(ctx);
+    }
+    toLogEntry(ctx) {
+        return {
+            ...super.toLogEntry(ctx),
+            message: {
+                "setpoint type": getEnumMemberName(HumidityControlSetpointType, this.setpointType),
+            },
+        };
+    }
+};
+HumidityControlSetpointCCScaleSupportedGet = __decorate([
+    CCCommand(HumidityControlSetpointCommand.ScaleSupportedGet),
+    expectedCCResponse(HumidityControlSetpointCCScaleSupportedReport)
+], HumidityControlSetpointCCScaleSupportedGet);
+export { HumidityControlSetpointCCScaleSupportedGet };
+let HumidityControlSetpointCCCapabilitiesReport = HumidityControlSetpointCCCapabilitiesReport_1 = class HumidityControlSetpointCCCapabilitiesReport extends HumidityControlSetpointCC {
+    constructor(options) {
+        super(options);
+        this.type = options.type;
+        this.minValue = options.minValue;
+        this.maxValue = options.maxValue;
+        this.minValueScale = options.minValueScale;
+        this.maxValueScale = options.maxValueScale;
+    }
+    static from(raw, ctx) {
+        validatePayload(raw.payload.length >= 1);
+        const type = raw.payload[0] & 0b1111;
+        // parseFloatWithScale does its own validation
+        const { value: minValue, scale: minValueScale, bytesRead, } = parseFloatWithScale(raw.payload.subarray(1));
+        const { value: maxValue, scale: maxValueScale } = parseFloatWithScale(raw.payload.subarray(1 + bytesRead));
+        return new HumidityControlSetpointCCCapabilitiesReport_1({
+            nodeId: ctx.sourceNodeId,
+            type,
+            minValue,
+            minValueScale,
+            maxValue,
+            maxValueScale,
+        });
+    }
+    persistValues(ctx) {
+        if (!super.persistValues(ctx))
+            return false;
+        // Predefine the metadata
+        const setpointValue = HumidityControlSetpointCCValues.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;
+    toLogEntry(ctx) {
+        const minValueScale = getScale(this.minValueScale);
+        const maxValueScale = getScale(this.maxValueScale);
+        return {
+            ...super.toLogEntry(ctx),
+            message: {
+                "setpoint type": getEnumMemberName(HumidityControlSetpointType, this.type),
+                "min value": `${this.minValue} ${minValueScale.unit}`,
+                "max value": `${this.maxValue} ${maxValueScale.unit}`,
+            },
+        };
+    }
+};
+HumidityControlSetpointCCCapabilitiesReport = HumidityControlSetpointCCCapabilitiesReport_1 = __decorate([
+    CCCommand(HumidityControlSetpointCommand.CapabilitiesReport)
+], HumidityControlSetpointCCCapabilitiesReport);
+export { HumidityControlSetpointCCCapabilitiesReport };
+let HumidityControlSetpointCCCapabilitiesGet = class HumidityControlSetpointCCCapabilitiesGet extends HumidityControlSetpointCC {
+    constructor(options) {
+        super(options);
+        this.setpointType = options.setpointType;
+    }
+    static from(_raw, _ctx) {
+        // TODO: Deserialize payload
+        throw new ZWaveError(`${this.name}: deserialization not implemented`, ZWaveErrorCodes.Deserialization_NotImplemented);
+        // return new HumidityControlSetpointCCCapabilitiesGet({
+        // 	nodeId: ctx.sourceNodeId,
+        // });
+    }
+    setpointType;
+    serialize(ctx) {
+        this.payload = Bytes.from([this.setpointType & 0b1111]);
+        return super.serialize(ctx);
+    }
+    toLogEntry(ctx) {
+        return {
+            ...super.toLogEntry(ctx),
+            message: {
+                "setpoint type": getEnumMemberName(HumidityControlSetpointType, this.setpointType),
+            },
+        };
+    }
+};
+HumidityControlSetpointCCCapabilitiesGet = __decorate([
+    CCCommand(HumidityControlSetpointCommand.CapabilitiesGet),
+    expectedCCResponse(HumidityControlSetpointCCCapabilitiesReport)
+], HumidityControlSetpointCCCapabilitiesGet);
+export { HumidityControlSetpointCCCapabilitiesGet };
+//# sourceMappingURL=HumidityControlSetpointCC.js.map