@zwave-js/cc 10.15.0 → 10.17.0

package/build/cc/WindowCoveringCC.js

@@ -0,0 +1,760 @@
+"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 _a, _b;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WindowCoveringCCStopLevelChange = exports.WindowCoveringCCStartLevelChange = exports.WindowCoveringCCSet = exports.WindowCoveringCCGet = exports.WindowCoveringCCReport = exports.WindowCoveringCCSupportedGet = exports.WindowCoveringCCSupportedReport = exports.WindowCoveringCC = exports.WindowCoveringCCAPI = exports.WindowCoveringCCValues = 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__WindowCoveringParameter = $o => {
+    function su__1__2__3__4__5__6__7__8__9__10__11__12__13__14__15__16__17__18__19__20__21__22__23__24_eu($o) {
+        return ![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23].includes($o) ? {} : null;
+    }
+    return su__1__2__3__4__5__6__7__8__9__10__11__12__13__14__15__16__17__18__19__20__21__22__23__24_eu($o);
+};
+const __assertType__sa__2_ea_2 = $o => {
+    function su__4__5__6__7__8__9__10__11__12__13__14__15__16__17__18__19__20__21__22__23__24__25__26__27_eu($o) {
+        return ![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23].includes($o) ? {} : null;
+    }
+    function _number($o) {
+        return typeof $o !== "number" ? {} : null;
+    }
+    function _2($o) {
+        if (typeof $o !== "object" || $o === null || Array.isArray($o))
+            return {};
+        if ("parameter" in $o && $o["parameter"] !== undefined) {
+            const error = su__4__5__6__7__8__9__10__11__12__13__14__15__16__17__18__19__20__21__22__23__24__25__26__27_eu($o["parameter"]);
+            if (error)
+                return error;
+        }
+        else
+            return {};
+        if ("value" in $o && $o["value"] !== undefined) {
+            const error = _number($o["value"]);
+            if (error)
+                return error;
+        }
+        else
+            return {};
+        return null;
+    }
+    function sa__2_ea_2($o) {
+        if (!Array.isArray($o))
+            return {};
+        for (let i = 0; i < $o.length; i++) {
+            const error = _2($o[i]);
+            if (error)
+                return error;
+        }
+        return null;
+    }
+    return sa__2_ea_2($o);
+};
+const __assertType__optional_su__string__2_eu = $o => {
+    function _string($o) {
+        return typeof $o !== "string" ? {} : null;
+    }
+    function _2($o) {
+        return !($o instanceof require("@zwave-js/core").Duration) ? {} : null;
+    }
+    function su__string__2_eu($o) {
+        const conditions = [_string, _2];
+        for (const condition of conditions) {
+            const error = condition($o);
+            if (!error)
+                return null;
+        }
+        return {};
+    }
+    function optional_su__string__2_eu($o) {
+        if ($o !== undefined) {
+            const error = su__string__2_eu($o);
+            if (error)
+                return error;
+        }
+        return null;
+    }
+    return optional_su__string__2_eu($o);
+};
+const __assertType__su__1__2_eu = $o => {
+    function _1($o) {
+        return $o !== "up" ? {} : null;
+    }
+    function _2($o) {
+        return $o !== "down" ? {} : null;
+    }
+    function su__1__2_eu($o) {
+        const conditions = [_1, _2];
+        for (const condition of conditions) {
+            const error = condition($o);
+            if (!error)
+                return null;
+        }
+        return {};
+    }
+    return su__1__2_eu($o);
+};
+const core_1 = require("@zwave-js/core");
+const safe_1 = 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");
+function parameterToMetadataStates(parameter, isTargetValue) {
+    switch (parameter) {
+        case _Types_1.WindowCoveringParameter["Vertical Slats Angle (no position)"]:
+            if (isTargetValue)
+                return undefined;
+            return {
+                0: "Closing (right)",
+                50: "Opening",
+                99: "Closing (left)",
+            };
+        case _Types_1.WindowCoveringParameter["Vertical Slats Angle"]:
+            return {
+                0: "Closed (right)",
+                50: "Open",
+                99: "Closed (left)",
+            };
+        case _Types_1.WindowCoveringParameter["Horizontal Slats Angle (no position)"]:
+            if (isTargetValue)
+                return undefined;
+            return {
+                0: "Closing (up)",
+                50: "Opening",
+                99: "Closing (down)",
+            };
+        case _Types_1.WindowCoveringParameter["Horizontal Slats Angle"]:
+            return {
+                0: "Closed (up)",
+                50: "Open",
+                99: "Closed (down)",
+            };
+    }
+    if (parameter % 2 === 1) {
+        // Odd-numbered parameters have position support
+        return {
+            0: "Closed",
+            99: "Open",
+        };
+    }
+    else {
+        if (isTargetValue)
+            return undefined;
+        return {
+            0: "Closing",
+            99: "Opening",
+        };
+    }
+}
+function isTiltParameter(parameter) {
+    return (parameter === _Types_1.WindowCoveringParameter["Vertical Slats Angle"] ||
+        parameter ===
+            _Types_1.WindowCoveringParameter["Vertical Slats Angle (no position)"] ||
+        parameter === _Types_1.WindowCoveringParameter["Horizontal Slats Angle"] ||
+        parameter ===
+            _Types_1.WindowCoveringParameter["Horizontal Slats Angle (no position)"]);
+}
+exports.WindowCoveringCCValues = Object.freeze({
+    ...Values_1.V.defineStaticCCValues(core_1.CommandClasses["Window Covering"], {
+        ...Values_1.V.staticProperty("supportedParameters", undefined, // meta
+        { internal: true }),
+    }),
+    ...Values_1.V.defineDynamicCCValues(core_1.CommandClasses["Window Covering"], {
+        ...Values_1.V.dynamicPropertyAndKeyWithName("currentValue", "currentValue", (parameter) => parameter, ({ property, propertyKey }) => property === "currentValue" && typeof propertyKey === "number", (parameter) => {
+            const states = parameterToMetadataStates(parameter, false);
+            return {
+                ...core_1.ValueMetadata.ReadOnlyLevel,
+                label: `Current value - ${(0, safe_1.getEnumMemberName)(_Types_1.WindowCoveringParameter, parameter)}`,
+                ...(states ? { states } : {}),
+                ccSpecific: {
+                    parameter,
+                },
+            };
+        }),
+        ...Values_1.V.dynamicPropertyAndKeyWithName("targetValue", "targetValue", (parameter) => parameter, ({ property, propertyKey }) => property === "targetValue" && typeof propertyKey === "number", (parameter) => {
+            const states = parameterToMetadataStates(parameter, false);
+            return {
+                ...core_1.ValueMetadata.Level,
+                label: `Target value - ${(0, safe_1.getEnumMemberName)(_Types_1.WindowCoveringParameter, parameter)}`,
+                // Only odd-numbered parameters have position support and are writable
+                writeable: parameter % 2 === 1,
+                ...(states ? { states } : {}),
+                ccSpecific: {
+                    parameter,
+                },
+                valueChangeOptions: ["transitionDuration"],
+            };
+        }),
+        ...Values_1.V.dynamicPropertyAndKeyWithName("duration", "duration", (parameter) => parameter, ({ property, propertyKey }) => property === "duration" && typeof propertyKey === "number", (parameter) => ({
+            ...core_1.ValueMetadata.ReadOnlyDuration,
+            label: `Remaining duration - ${(0, safe_1.getEnumMemberName)(_Types_1.WindowCoveringParameter, parameter)}`,
+            ccSpecific: {
+                parameter,
+            },
+        })),
+        // Convenience values to control the different parameters
+        // Open all parameters
+        ...Values_1.V.dynamicPropertyAndKeyWithName("open", "open", (parameter) => parameter, ({ property, propertyKey }) => property === "open" && typeof propertyKey === "number", (parameter) => ({
+            ...core_1.ValueMetadata.WriteOnlyBoolean,
+            label: `Open - ${(0, safe_1.getEnumMemberName)(_Types_1.WindowCoveringParameter, parameter)}`,
+            ccSpecific: {
+                parameter,
+            },
+            valueChangeOptions: ["transitionDuration"],
+        })),
+        // Close positional parameters
+        ...Values_1.V.dynamicPropertyAndKeyWithName("positionClose", "close", (parameter) => parameter, ({ property, propertyKey }) => property === "close" &&
+            typeof propertyKey === "number" &&
+            !isTiltParameter(propertyKey), (parameter) => ({
+            ...core_1.ValueMetadata.WriteOnlyBoolean,
+            label: `Close - ${(0, safe_1.getEnumMemberName)(_Types_1.WindowCoveringParameter, parameter)}`,
+            ccSpecific: {
+                parameter,
+            },
+            valueChangeOptions: ["transitionDuration"],
+        })),
+        // Close vertical slats to the right, horizontal to the top
+        ...Values_1.V.dynamicPropertyAndKeyWithName("tiltClose0", "close0", (parameter) => parameter, ({ property, propertyKey }) => property === "close0" &&
+            typeof propertyKey === "number" &&
+            isTiltParameter(propertyKey), (parameter) => {
+            const direction = parameter ===
+                _Types_1.WindowCoveringParameter["Vertical Slats Angle"] ||
+                parameter ===
+                    _Types_1.WindowCoveringParameter["Vertical Slats Angle (no position)"]
+                ? "Right"
+                : "Up";
+            return {
+                ...core_1.ValueMetadata.WriteOnlyBoolean,
+                label: `Close ${direction} - ${(0, safe_1.getEnumMemberName)(_Types_1.WindowCoveringParameter, parameter)}`,
+                ccSpecific: {
+                    parameter,
+                },
+                valueChangeOptions: ["transitionDuration"],
+            };
+        }),
+        // Close vertical slats to the left, horizontal to the bottom
+        ...Values_1.V.dynamicPropertyAndKeyWithName("tiltClose99", "close99", (parameter) => parameter, ({ property, propertyKey }) => property === "close99" &&
+            typeof propertyKey === "number" &&
+            isTiltParameter(propertyKey), (parameter) => {
+            const direction = parameter ===
+                _Types_1.WindowCoveringParameter["Vertical Slats Angle"] ||
+                parameter ===
+                    _Types_1.WindowCoveringParameter["Vertical Slats Angle (no position)"]
+                ? "Left"
+                : "Down";
+            return {
+                ...core_1.ValueMetadata.WriteOnlyBoolean,
+                label: `Close ${direction} - ${(0, safe_1.getEnumMemberName)(_Types_1.WindowCoveringParameter, parameter)}`,
+                ccSpecific: {
+                    parameter,
+                },
+                valueChangeOptions: ["transitionDuration"],
+            };
+        }),
+    }),
+});
+let WindowCoveringCCAPI = class WindowCoveringCCAPI extends API_1.CCAPI {
+    constructor() {
+        super(...arguments);
+        this[_a] = async ({ property, propertyKey }, value, options) => {
+            const valueId = {
+                commandClass: this.ccId,
+                property,
+                propertyKey,
+            };
+            let targetValue;
+            if (exports.WindowCoveringCCValues.targetValue.is(valueId)) {
+                if (typeof propertyKey !== "number" ||
+                    // Only odd-numbered parameters have position support and are writable
+                    propertyKey % 2 === 0) {
+                    (0, API_1.throwUnsupportedPropertyKey)(this.ccId, property, propertyKey);
+                }
+                if (typeof value !== "number") {
+                    (0, API_1.throwWrongValueType)(this.ccId, property, "number", typeof value);
+                }
+                targetValue = value;
+            }
+            else if (
+            // Opening a positional parameter is the same as closing a tilt parameter to one side (99)
+            (exports.WindowCoveringCCValues.open.is(valueId) &&
+                !isTiltParameter(propertyKey)) ||
+                exports.WindowCoveringCCValues.tiltClose99.is(valueId)) {
+                if (!value) {
+                    (0, API_1.throwWrongValueType)(this.ccId, property, "true", typeof value);
+                }
+                targetValue = 99;
+            }
+            else if (
+            // Opening a tilt parameter means setting it to 50
+            exports.WindowCoveringCCValues.open.is(valueId) &&
+                isTiltParameter(propertyKey)) {
+                if (!value) {
+                    (0, API_1.throwWrongValueType)(this.ccId, property, "true", typeof value);
+                }
+                targetValue = 50;
+            }
+            else if (exports.WindowCoveringCCValues.positionClose.is(valueId) ||
+                exports.WindowCoveringCCValues.tiltClose0.is(valueId)) {
+                if (!value) {
+                    (0, API_1.throwWrongValueType)(this.ccId, property, "true", typeof value);
+                }
+                // Closing a positional parameter is the same as closing a tilt parameter to the other side
+                targetValue = 0;
+            }
+            else {
+                (0, API_1.throwUnsupportedProperty)(this.ccId, property);
+            }
+            const parameter = propertyKey;
+            const currentValueValueId = exports.WindowCoveringCCValues.currentValue(parameter).endpoint(this.endpoint.index);
+            const targetValueValueId = exports.WindowCoveringCCValues.targetValue(parameter).endpoint(this.endpoint.index);
+            // If we have set the value via one of the convenience properties,
+            // we need to update the targetValue value ID
+            if (targetValue !== value) {
+                this.tryGetValueDB()?.setValue(targetValueValueId, targetValue);
+            }
+            const duration = core_1.Duration.from(options?.transitionDuration);
+            // Window Covering commands may take some time to be executed.
+            // Therefore we try to supervise the command execution and delay the
+            // optimistic update until the final result is received.
+            const result = await this.withOptions({
+                requestStatusUpdates: true,
+                onUpdate: (update) => {
+                    if (update.status === core_1.SupervisionStatus.Success) {
+                        this.tryGetValueDB()?.setValue(currentValueValueId, targetValue);
+                    }
+                    else if (update.status === core_1.SupervisionStatus.Fail) {
+                        // The transition failed, so now we don't know the status
+                        // Refresh the current value
+                        // eslint-disable-next-line @typescript-eslint/no-empty-function
+                        void this.get(parameter).catch(() => { });
+                    }
+                },
+            }).set([{ parameter: propertyKey, value: targetValue }], duration);
+            // If the command did not fail, assume that it succeeded and update the currentValue accordingly
+            // so UIs have immediate feedback
+            const shouldUpdateOptimistically = 
+            // For unsupervised commands, make the choice to update optimistically dependent on the driver options
+            (!this.applHost.options.disableOptimisticValueUpdate &&
+                result == undefined) ||
+                ((0, core_1.isSupervisionResult)(result) &&
+                    result.status === core_1.SupervisionStatus.Success);
+            if (this.isSinglecast()) {
+                // Only update currentValue for valid target values
+                if (shouldUpdateOptimistically &&
+                    targetValue >= 0 &&
+                    targetValue <= 99) {
+                    this.tryGetValueDB()?.setValue(currentValueValueId, targetValue);
+                }
+                // Verify the current value after a delay, unless...
+                // ...the command was supervised and successful
+                // ...and we know the actual value
+                if (!(0, core_1.supervisedCommandSucceeded)(result)) {
+                    this.schedulePoll({
+                        property: currentValueValueId.property,
+                        propertyKey: currentValueValueId.propertyKey,
+                    }, targetValue, { duration });
+                }
+            }
+            return result;
+        };
+        this[_b] = async ({ property, propertyKey, }) => {
+            switch (property) {
+                case "currentValue":
+                case "targetValue":
+                case "duration":
+                    if (propertyKey == undefined) {
+                        (0, API_1.throwMissingPropertyKey)(this.ccId, property);
+                    }
+                    else if (typeof propertyKey !== "number") {
+                        (0, API_1.throwUnsupportedPropertyKey)(this.ccId, property, propertyKey);
+                    }
+                    return (await this.get(propertyKey))?.[property];
+                default:
+                    (0, API_1.throwUnsupportedProperty)(this.ccId, property);
+            }
+        };
+    }
+    supportsCommand(cmd) {
+        switch (cmd) {
+            case _Types_1.WindowCoveringCommand.Get:
+            case _Types_1.WindowCoveringCommand.Set:
+            case _Types_1.WindowCoveringCommand.SupportedGet:
+            case _Types_1.WindowCoveringCommand.StartLevelChange:
+            case _Types_1.WindowCoveringCommand.StopLevelChange:
+                return true; // This is mandatory
+        }
+        return super.supportsCommand(cmd);
+    }
+    async getSupported() {
+        this.assertSupportsCommand(_Types_1.WindowCoveringCommand, _Types_1.WindowCoveringCommand.SupportedGet);
+        const cc = new WindowCoveringCCSupportedGet(this.applHost, {
+            nodeId: this.endpoint.nodeId,
+            endpoint: this.endpoint.index,
+        });
+        const response = await this.applHost.sendCommand(cc, this.commandOptions);
+        return response?.supportedParameters;
+    }
+    async get(parameter) {
+        __assertType("parameter", "WindowCoveringParameter", __assertType__WindowCoveringParameter.bind(void 0, parameter));
+        this.assertSupportsCommand(_Types_1.WindowCoveringCommand, _Types_1.WindowCoveringCommand.Get);
+        const cc = new WindowCoveringCCGet(this.applHost, {
+            nodeId: this.endpoint.nodeId,
+            endpoint: this.endpoint.index,
+            parameter,
+        });
+        const response = await this.applHost.sendCommand(cc, this.commandOptions);
+        if (response) {
+            return (0, safe_1.pick)(response, ["currentValue", "targetValue", "duration"]);
+        }
+    }
+    async set(targetValues, duration) {
+        __assertType("targetValues", undefined, __assertType__sa__2_ea_2.bind(void 0, targetValues));
+        __assertType("duration", undefined, __assertType__optional_su__string__2_eu.bind(void 0, duration));
+        this.assertSupportsCommand(_Types_1.WindowCoveringCommand, _Types_1.WindowCoveringCommand.StartLevelChange);
+        const cc = new WindowCoveringCCSet(this.applHost, {
+            nodeId: this.endpoint.nodeId,
+            endpoint: this.endpoint.index,
+            targetValues,
+            duration,
+        });
+        return this.applHost.sendCommand(cc, this.commandOptions);
+    }
+    async startLevelChange(parameter, direction, duration) {
+        __assertType("parameter", "WindowCoveringParameter", __assertType__WindowCoveringParameter.bind(void 0, parameter));
+        __assertType("direction", undefined, __assertType__su__1__2_eu.bind(void 0, direction));
+        __assertType("duration", undefined, __assertType__optional_su__string__2_eu.bind(void 0, duration));
+        this.assertSupportsCommand(_Types_1.WindowCoveringCommand, _Types_1.WindowCoveringCommand.StartLevelChange);
+        const cc = new WindowCoveringCCStartLevelChange(this.applHost, {
+            nodeId: this.endpoint.nodeId,
+            endpoint: this.endpoint.index,
+            parameter,
+            direction,
+            duration,
+        });
+        return this.applHost.sendCommand(cc, this.commandOptions);
+    }
+    async stopLevelChange(parameter) {
+        __assertType("parameter", "WindowCoveringParameter", __assertType__WindowCoveringParameter.bind(void 0, parameter));
+        this.assertSupportsCommand(_Types_1.WindowCoveringCommand, _Types_1.WindowCoveringCommand.StopLevelChange);
+        const cc = new WindowCoveringCCStopLevelChange(this.applHost, {
+            nodeId: this.endpoint.nodeId,
+            endpoint: this.endpoint.index,
+            parameter,
+        });
+        return this.applHost.sendCommand(cc, this.commandOptions);
+    }
+};
+_a = API_1.SET_VALUE, _b = API_1.POLL_VALUE;
+WindowCoveringCCAPI = __decorate([
+    (0, CommandClassDecorators_1.API)(core_1.CommandClasses["Window Covering"])
+], WindowCoveringCCAPI);
+exports.WindowCoveringCCAPI = WindowCoveringCCAPI;
+let WindowCoveringCC = class WindowCoveringCC extends CommandClass_1.CommandClass {
+    async interview(applHost) {
+        const node = this.getNode(applHost);
+        const endpoint = this.getEndpoint(applHost);
+        const api = API_1.CCAPI.create(core_1.CommandClasses["Window Covering"], applHost, endpoint).withOptions({
+            priority: core_1.MessagePriority.NodeQuery,
+        });
+        applHost.controllerLog.logNode(node.id, {
+            endpoint: this.endpointIndex,
+            message: `Interviewing ${this.ccName}...`,
+            direction: "none",
+        });
+        applHost.controllerLog.logNode(node.id, {
+            endpoint: this.endpointIndex,
+            message: "querying supported window covering parameters...",
+            direction: "outbound",
+        });
+        const supported = await api.getSupported();
+        if (supported?.length) {
+            const logMessage = `supported window covering parameters:
+${supported
+                .map((p) => `· ${(0, safe_1.getEnumMemberName)(_Types_1.WindowCoveringParameter, p)}`)
+                .join("\n")}`;
+            applHost.controllerLog.logNode(node.id, {
+                endpoint: this.endpointIndex,
+                message: logMessage,
+                direction: "inbound",
+            });
+            // Create metadata for all supported parameters
+            for (const param of supported) {
+                // Default values
+                this.setMetadata(applHost, exports.WindowCoveringCCValues.currentValue(param));
+                this.setMetadata(applHost, exports.WindowCoveringCCValues.targetValue(param));
+                this.setMetadata(applHost, exports.WindowCoveringCCValues.duration(param));
+                // Convenience values
+                this.setMetadata(applHost, exports.WindowCoveringCCValues.open(param));
+                if (isTiltParameter(param)) {
+                    this.setMetadata(applHost, exports.WindowCoveringCCValues.tiltClose0(param));
+                    this.setMetadata(applHost, exports.WindowCoveringCCValues.tiltClose99(param));
+                }
+                else {
+                    this.setMetadata(applHost, exports.WindowCoveringCCValues.positionClose(param));
+                }
+                // And for the odd parameters (with position support), query the position
+                if (param % 2 === 1) {
+                    applHost.controllerLog.logNode(node.id, {
+                        endpoint: this.endpointIndex,
+                        message: `querying position for parameter ${(0, safe_1.getEnumMemberName)(_Types_1.WindowCoveringParameter, param)}...`,
+                        direction: "outbound",
+                    });
+                    await api.get(param);
+                }
+            }
+        }
+        // Remember that the interview is complete
+        this.setInterviewComplete(applHost, true);
+    }
+    translatePropertyKey(_applHost, _property, propertyKey) {
+        if (typeof propertyKey === "number") {
+            return (0, safe_1.getEnumMemberName)(_Types_1.WindowCoveringParameter, propertyKey);
+        }
+        return super.translatePropertyKey(_applHost, _property, propertyKey);
+    }
+};
+WindowCoveringCC = __decorate([
+    (0, CommandClassDecorators_1.commandClass)(core_1.CommandClasses["Window Covering"]),
+    (0, CommandClassDecorators_1.implementedVersion)(1),
+    (0, CommandClassDecorators_1.ccValues)(exports.WindowCoveringCCValues)
+], WindowCoveringCC);
+exports.WindowCoveringCC = WindowCoveringCC;
+let WindowCoveringCCSupportedReport = class WindowCoveringCCSupportedReport extends WindowCoveringCC {
+    constructor(host, options) {
+        super(host, options);
+        if ((0, CommandClass_1.gotDeserializationOptions)(options)) {
+            (0, core_1.validatePayload)(this.payload.length >= 1);
+            const numBitmaskBytes = this.payload[0] & 0b1111;
+            (0, core_1.validatePayload)(this.payload.length >= 1 + numBitmaskBytes);
+            const bitmask = this.payload.slice(1, 1 + numBitmaskBytes);
+            this.supportedParameters = (0, core_1.parseBitMask)(bitmask, _Types_1.WindowCoveringParameter["Outbound Left (no position)"]);
+        }
+        else {
+            this.supportedParameters = options.supportedParameters;
+        }
+    }
+    serialize() {
+        const bitmask = (0, core_1.encodeBitMask)(this.supportedParameters, undefined, _Types_1.WindowCoveringParameter["Outbound Left (no position)"]).slice(0, 15);
+        const numBitmaskBytes = bitmask.length & 0b1111;
+        this.payload = Buffer.concat([
+            Buffer.from([numBitmaskBytes]),
+            bitmask.slice(0, numBitmaskBytes),
+        ]);
+        return super.serialize();
+    }
+    toLogEntry(applHost) {
+        return {
+            ...super.toLogEntry(applHost),
+            message: {
+                "supported parameters": this.supportedParameters
+                    .map((p) => `\n· ${(0, safe_1.getEnumMemberName)(_Types_1.WindowCoveringParameter, p)}`)
+                    .join(""),
+            },
+        };
+    }
+};
+__decorate([
+    (0, CommandClassDecorators_1.ccValue)(exports.WindowCoveringCCValues.supportedParameters)
+], WindowCoveringCCSupportedReport.prototype, "supportedParameters", void 0);
+WindowCoveringCCSupportedReport = __decorate([
+    (0, CommandClassDecorators_1.CCCommand)(_Types_1.WindowCoveringCommand.SupportedReport)
+], WindowCoveringCCSupportedReport);
+exports.WindowCoveringCCSupportedReport = WindowCoveringCCSupportedReport;
+let WindowCoveringCCSupportedGet = class WindowCoveringCCSupportedGet extends WindowCoveringCC {
+};
+WindowCoveringCCSupportedGet = __decorate([
+    (0, CommandClassDecorators_1.CCCommand)(_Types_1.WindowCoveringCommand.SupportedGet),
+    (0, CommandClassDecorators_1.expectedCCResponse)(WindowCoveringCCSupportedReport)
+], WindowCoveringCCSupportedGet);
+exports.WindowCoveringCCSupportedGet = WindowCoveringCCSupportedGet;
+let WindowCoveringCCReport = class WindowCoveringCCReport extends WindowCoveringCC {
+    constructor(host, options) {
+        super(host, options);
+        (0, core_1.validatePayload)(this.payload.length >= 4);
+        this.parameter = this.payload[0];
+        this.currentValue = this.payload[1];
+        this.targetValue = this.payload[2];
+        this.duration =
+            core_1.Duration.parseReport(this.payload[3]) ?? core_1.Duration.unknown();
+    }
+    toLogEntry(applHost) {
+        return {
+            ...super.toLogEntry(applHost),
+            message: {
+                parameter: (0, safe_1.getEnumMemberName)(_Types_1.WindowCoveringParameter, this.parameter),
+                "current value": this.currentValue,
+                "target value": this.targetValue,
+                duration: this.duration.toString(),
+            },
+        };
+    }
+};
+__decorate([
+    (0, CommandClassDecorators_1.ccValue)(exports.WindowCoveringCCValues.currentValue, (self) => [self.parameter])
+], WindowCoveringCCReport.prototype, "currentValue", void 0);
+__decorate([
+    (0, CommandClassDecorators_1.ccValue)(exports.WindowCoveringCCValues.targetValue, (self) => [self.parameter])
+], WindowCoveringCCReport.prototype, "targetValue", void 0);
+__decorate([
+    (0, CommandClassDecorators_1.ccValue)(exports.WindowCoveringCCValues.duration, (self) => [self.parameter])
+], WindowCoveringCCReport.prototype, "duration", void 0);
+WindowCoveringCCReport = __decorate([
+    (0, CommandClassDecorators_1.CCCommand)(_Types_1.WindowCoveringCommand.Report)
+], WindowCoveringCCReport);
+exports.WindowCoveringCCReport = WindowCoveringCCReport;
+function testResponseForWindowCoveringGet(sent, received) {
+    return received.parameter === sent.parameter;
+}
+let WindowCoveringCCGet = class WindowCoveringCCGet extends WindowCoveringCC {
+    constructor(host, options) {
+        super(host, options);
+        if ((0, CommandClass_1.gotDeserializationOptions)(options)) {
+            (0, core_1.validatePayload)(this.payload.length >= 1);
+            this.parameter = this.payload[0];
+        }
+        else {
+            this.parameter = options.parameter;
+        }
+    }
+    serialize() {
+        this.payload = Buffer.from([this.parameter]);
+        return super.serialize();
+    }
+    toLogEntry(applHost) {
+        return {
+            ...super.toLogEntry(applHost),
+            message: {
+                parameter: (0, safe_1.getEnumMemberName)(_Types_1.WindowCoveringParameter, this.parameter),
+            },
+        };
+    }
+};
+WindowCoveringCCGet = __decorate([
+    (0, CommandClassDecorators_1.CCCommand)(_Types_1.WindowCoveringCommand.Get),
+    (0, CommandClassDecorators_1.expectedCCResponse)(WindowCoveringCCReport, testResponseForWindowCoveringGet)
+], WindowCoveringCCGet);
+exports.WindowCoveringCCGet = WindowCoveringCCGet;
+let WindowCoveringCCSet = class WindowCoveringCCSet extends WindowCoveringCC {
+    constructor(host, options) {
+        super(host, options);
+        if ((0, CommandClass_1.gotDeserializationOptions)(options)) {
+            // TODO: Deserialize payload
+            throw new core_1.ZWaveError(`${this.constructor.name}: deserialization not implemented`, core_1.ZWaveErrorCodes.Deserialization_NotImplemented);
+        }
+        else {
+            this.targetValues = options.targetValues;
+            this.duration = core_1.Duration.from(options.duration);
+        }
+    }
+    serialize() {
+        const numEntries = this.targetValues.length & 0b11111;
+        this.payload = Buffer.allocUnsafe(2 + numEntries * 2);
+        this.payload[0] = numEntries;
+        for (let i = 0; i < numEntries; i++) {
+            const offset = 1 + i * 2;
+            this.payload[offset] = this.targetValues[i].parameter;
+            this.payload[offset + 1] = this.targetValues[i].value;
+        }
+        this.payload[this.payload.length - 1] = (this.duration ?? core_1.Duration.default()).serializeSet();
+        return super.serialize();
+    }
+    toLogEntry(applHost) {
+        const message = {};
+        for (const { parameter, value } of this.targetValues) {
+            message[(0, safe_1.getEnumMemberName)(_Types_1.WindowCoveringParameter, parameter)] =
+                value;
+        }
+        if (this.duration) {
+            message.duration = this.duration.toString();
+        }
+        return {
+            ...super.toLogEntry(applHost),
+            message,
+        };
+    }
+};
+WindowCoveringCCSet = __decorate([
+    (0, CommandClassDecorators_1.CCCommand)(_Types_1.WindowCoveringCommand.Set),
+    (0, CommandClassDecorators_1.useSupervision)()
+], WindowCoveringCCSet);
+exports.WindowCoveringCCSet = WindowCoveringCCSet;
+let WindowCoveringCCStartLevelChange = class WindowCoveringCCStartLevelChange extends WindowCoveringCC {
+    constructor(host, options) {
+        super(host, options);
+        if ((0, CommandClass_1.gotDeserializationOptions)(options)) {
+            // TODO: Deserialize payload
+            throw new core_1.ZWaveError(`${this.constructor.name}: deserialization not implemented`, core_1.ZWaveErrorCodes.Deserialization_NotImplemented);
+        }
+        else {
+            this.parameter = options.parameter;
+            this.direction = options.direction;
+            this.duration = core_1.Duration.from(options.duration);
+        }
+    }
+    serialize() {
+        this.payload = Buffer.from([
+            this.direction === "up" ? 64 : 0,
+            this.parameter,
+            (this.duration ?? core_1.Duration.default()).serializeSet(),
+        ]);
+        return super.serialize();
+    }
+    toLogEntry(applHost) {
+        const message = {
+            parameter: (0, safe_1.getEnumMemberName)(_Types_1.WindowCoveringParameter, this.parameter),
+            direction: this.direction,
+        };
+        if (this.duration) {
+            message.duration = this.duration.toString();
+        }
+        return {
+            ...super.toLogEntry(applHost),
+            message,
+        };
+    }
+};
+WindowCoveringCCStartLevelChange = __decorate([
+    (0, CommandClassDecorators_1.CCCommand)(_Types_1.WindowCoveringCommand.StartLevelChange),
+    (0, CommandClassDecorators_1.useSupervision)()
+], WindowCoveringCCStartLevelChange);
+exports.WindowCoveringCCStartLevelChange = WindowCoveringCCStartLevelChange;
+let WindowCoveringCCStopLevelChange = class WindowCoveringCCStopLevelChange extends WindowCoveringCC {
+    constructor(host, options) {
+        super(host, options);
+        if ((0, CommandClass_1.gotDeserializationOptions)(options)) {
+            // TODO: Deserialize payload
+            throw new core_1.ZWaveError(`${this.constructor.name}: deserialization not implemented`, core_1.ZWaveErrorCodes.Deserialization_NotImplemented);
+        }
+        else {
+            this.parameter = options.parameter;
+        }
+    }
+    serialize() {
+        this.payload = Buffer.from([this.parameter]);
+        return super.serialize();
+    }
+    toLogEntry(applHost) {
+        return {
+            ...super.toLogEntry(applHost),
+            message: {
+                parameter: (0, safe_1.getEnumMemberName)(_Types_1.WindowCoveringParameter, this.parameter),
+            },
+        };
+    }
+};
+WindowCoveringCCStopLevelChange = __decorate([
+    (0, CommandClassDecorators_1.CCCommand)(_Types_1.WindowCoveringCommand.StopLevelChange),
+    (0, CommandClassDecorators_1.useSupervision)()
+], WindowCoveringCCStopLevelChange);
+exports.WindowCoveringCCStopLevelChange = WindowCoveringCCStopLevelChange;
+//# sourceMappingURL=WindowCoveringCC.js.map