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

package/build/esm/cc/WindowCoveringCC.js

@@ -0,0 +1,780 @@
+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 WindowCoveringCCSupportedReport_1, WindowCoveringCCReport_1, WindowCoveringCCGet_1, WindowCoveringCCSet_1, WindowCoveringCCStartLevelChange_1, WindowCoveringCCStopLevelChange_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__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);
+};
+import { CommandClasses, Duration, MessagePriority, ValueMetadata, encodeBitMask, parseBitMask, validatePayload, } from "@zwave-js/core";
+import { Bytes } from "@zwave-js/shared/safe";
+import { getEnumMemberName, pick } from "@zwave-js/shared/safe";
+import { CCAPI, POLL_VALUE, SET_VALUE, SET_VALUE_HOOKS, throwMissingPropertyKey, throwUnsupportedProperty, throwUnsupportedPropertyKey, 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 { WindowCoveringCommand, WindowCoveringParameter, } from "../lib/_Types.js";
+function parameterToMetadataStates(parameter) {
+    switch (parameter) {
+        case WindowCoveringParameter["Vertical Slats Angle (no position)"]:
+        case WindowCoveringParameter["Vertical Slats Angle"]:
+            return {
+                0: "Closed (right inside)",
+                50: "Open",
+                99: "Closed (left inside)",
+            };
+        case WindowCoveringParameter["Horizontal Slats Angle (no position)"]:
+        case WindowCoveringParameter["Horizontal Slats Angle"]:
+            return {
+                0: "Closed (up inside)",
+                50: "Open",
+                99: "Closed (down inside)",
+            };
+    }
+    return {
+        0: "Closed",
+        99: "Open",
+    };
+}
+function parameterToLevelChangeLabel(parameter, direction) {
+    switch (parameter) {
+        // For angle control, both directions are closed, so we specify it explicitly
+        case WindowCoveringParameter["Vertical Slats Angle (no position)"]:
+        case WindowCoveringParameter["Vertical Slats Angle"]:
+            return `Change tilt (${direction === "up" ? "left inside" : "right inside"})`;
+        case WindowCoveringParameter["Horizontal Slats Angle (no position)"]:
+        case WindowCoveringParameter["Horizontal Slats Angle"]:
+            // Horizontal slats refer to the position of the inner side of the slats
+            // where a high level (99) actually means they face down
+            return `Change tilt (${direction === "up" ? "down inside" : "up inside"})`;
+    }
+    // For all other parameters, refer to the amount of light that is let in
+    return direction === "up" ? "Open" : "Close";
+}
+export const WindowCoveringCCValues = Object.freeze({
+    ...V.defineStaticCCValues(CommandClasses["Window Covering"], {
+        ...V.staticProperty("supportedParameters", undefined, // meta
+        { internal: true }),
+    }),
+    ...V.defineDynamicCCValues(CommandClasses["Window Covering"], {
+        ...V.dynamicPropertyAndKeyWithName("currentValue", "currentValue", (parameter) => parameter, ({ property, propertyKey }) => property === "currentValue" && typeof propertyKey === "number", (parameter) => {
+            return {
+                ...ValueMetadata.ReadOnlyLevel,
+                label: `Current value - ${getEnumMemberName(WindowCoveringParameter, parameter)}`,
+                states: parameterToMetadataStates(parameter),
+                ccSpecific: { parameter },
+            };
+        }),
+        ...V.dynamicPropertyAndKeyWithName("targetValue", "targetValue", (parameter) => parameter, ({ property, propertyKey }) => property === "targetValue" && typeof propertyKey === "number", (parameter) => {
+            // Only odd-numbered parameters have position support and are writable
+            const writeable = parameter % 2 === 1;
+            return {
+                ...ValueMetadata.Level,
+                label: `Target value - ${getEnumMemberName(WindowCoveringParameter, parameter)}`,
+                // Only odd-numbered parameters have position support and are writable
+                writeable: parameter % 2 === 1,
+                states: parameterToMetadataStates(parameter),
+                allowManualEntry: writeable,
+                ccSpecific: { parameter },
+                valueChangeOptions: ["transitionDuration"],
+            };
+        }),
+        ...V.dynamicPropertyAndKeyWithName("duration", "duration", (parameter) => parameter, ({ property, propertyKey }) => property === "duration" && typeof propertyKey === "number", (parameter) => ({
+            ...ValueMetadata.ReadOnlyDuration,
+            label: `Remaining duration - ${getEnumMemberName(WindowCoveringParameter, parameter)}`,
+            ccSpecific: {
+                parameter,
+            },
+        })),
+        ...V.dynamicPropertyAndKeyWithName("levelChangeUp", 
+        // The direction refers to the change in level, not the physical location
+        "levelChangeUp", (parameter) => parameter, ({ property, propertyKey }) => property === "levelChangeUp" && typeof propertyKey === "number", (parameter) => {
+            return {
+                ...ValueMetadata.WriteOnlyBoolean,
+                label: `${parameterToLevelChangeLabel(parameter, "up")} - ${getEnumMemberName(WindowCoveringParameter, parameter)}`,
+                valueChangeOptions: ["transitionDuration"],
+                states: {
+                    true: "Start",
+                    false: "Stop",
+                },
+                ccSpecific: { parameter },
+            };
+        }),
+        ...V.dynamicPropertyAndKeyWithName("levelChangeDown", 
+        // The direction refers to the change in level, not the physical location
+        "levelChangeDown", (parameter) => parameter, ({ property, propertyKey }) => property === "levelChangeDown"
+            && typeof propertyKey === "number", (parameter) => {
+            return {
+                ...ValueMetadata.WriteOnlyBoolean,
+                label: `${parameterToLevelChangeLabel(parameter, "down")} - ${getEnumMemberName(WindowCoveringParameter, parameter)}`,
+                valueChangeOptions: ["transitionDuration"],
+                states: {
+                    true: "Start",
+                    false: "Stop",
+                },
+                ccSpecific: { parameter },
+            };
+        }),
+    }),
+});
+let WindowCoveringCCAPI = class WindowCoveringCCAPI extends CCAPI {
+    supportsCommand(cmd) {
+        switch (cmd) {
+            case WindowCoveringCommand.Get:
+            case WindowCoveringCommand.Set:
+            case WindowCoveringCommand.SupportedGet:
+            case WindowCoveringCommand.StartLevelChange:
+            case WindowCoveringCommand.StopLevelChange:
+                return true; // This is mandatory
+        }
+        return super.supportsCommand(cmd);
+    }
+    get [SET_VALUE]() {
+        return async function ({ property, propertyKey }, value, options) {
+            const valueId = {
+                commandClass: this.ccId,
+                property,
+                propertyKey,
+            };
+            if (WindowCoveringCCValues.targetValue.is(valueId)) {
+                if (typeof propertyKey !== "number"
+                    // Only odd-numbered parameters have position support and are writable
+                    || propertyKey % 2 === 0) {
+                    throwUnsupportedPropertyKey(this.ccId, property, propertyKey);
+                }
+                if (typeof value !== "number") {
+                    throwWrongValueType(this.ccId, property, "number", typeof value);
+                }
+                const parameter = propertyKey;
+                const duration = Duration.from(options?.transitionDuration);
+                return this.set([{ parameter, value }], duration);
+            }
+            else if (WindowCoveringCCValues.levelChangeUp.is(valueId)
+                || WindowCoveringCCValues.levelChangeDown.is(valueId)) {
+                if (typeof value !== "boolean") {
+                    throwWrongValueType(this.ccId, property, "boolean", typeof value);
+                }
+                const parameter = propertyKey;
+                const direction = WindowCoveringCCValues.levelChangeUp.is(valueId)
+                    ? "up"
+                    : "down";
+                if (value) {
+                    // Perform the level change
+                    const duration = Duration.from(options?.transitionDuration);
+                    return this.startLevelChange(parameter, direction, duration);
+                }
+                else {
+                    return this.stopLevelChange(parameter);
+                }
+            }
+            else {
+                throwUnsupportedProperty(this.ccId, property);
+            }
+        };
+    }
+    [SET_VALUE_HOOKS] = ({ property, propertyKey }, value, options) => {
+        const valueId = {
+            commandClass: this.ccId,
+            property,
+            propertyKey,
+        };
+        if (WindowCoveringCCValues.targetValue.is(valueId)) {
+            if (typeof propertyKey !== "number")
+                return;
+            const parameter = propertyKey;
+            const duration = Duration.from(options?.transitionDuration);
+            const currentValueValueId = WindowCoveringCCValues.currentValue(parameter).endpoint(this.endpoint.index);
+            return {
+                // 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.
+                supervisionDelayedUpdates: true,
+                supervisionOnSuccess: async () => {
+                    // Only update currentValue for valid target values
+                    if (typeof value === "number"
+                        && value >= 0
+                        && value <= 99) {
+                        this.tryGetValueDB()?.setValue(currentValueValueId, value);
+                    }
+                    else if (value === 255) {
+                        // We don't know the status now, so refresh the current value
+                        try {
+                            await this.get(parameter);
+                        }
+                        catch {
+                            // ignore
+                        }
+                    }
+                },
+                supervisionOnFailure: async () => {
+                    // The transition failed, so now we don't know the status - refresh the current value
+                    try {
+                        await this.get(parameter);
+                    }
+                    catch {
+                        // ignore
+                    }
+                },
+                optimisticallyUpdateRelatedValues: (_supervisedAndSuccessful) => {
+                    // Only update currentValue for valid target values
+                    if (typeof value === "number"
+                        && value >= 0
+                        && value <= 99) {
+                        if (this.isSinglecast()) {
+                            this.tryGetValueDB()?.setValue(currentValueValueId, value);
+                        }
+                        else if (this.isMulticast()) {
+                            // Figure out which nodes were affected by this command
+                            const affectedNodes = this.endpoint.node
+                                .physicalNodes.filter((node) => node
+                                .getEndpoint(this.endpoint.index)
+                                ?.supportsCC(this.ccId));
+                            // and optimistically update the currentValue
+                            for (const node of affectedNodes) {
+                                this.host
+                                    .tryGetValueDB(node.id)
+                                    ?.setValue(currentValueValueId, value);
+                            }
+                        }
+                    }
+                },
+                verifyChanges: () => {
+                    if (this.isSinglecast()) {
+                        // We query currentValue instead of targetValue to make sure that unsolicited updates cancel the scheduled poll
+                        this.schedulePoll(currentValueValueId, value, {
+                            duration,
+                        });
+                    }
+                    else {
+                        // For multicasts, do not schedule a refresh - this could cause a LOT of traffic
+                    }
+                },
+            };
+        }
+    };
+    get [POLL_VALUE]() {
+        return async function ({ property, propertyKey }) {
+            switch (property) {
+                case "currentValue":
+                case "targetValue":
+                case "duration":
+                    if (propertyKey == undefined) {
+                        throwMissingPropertyKey(this.ccId, property);
+                    }
+                    else if (typeof propertyKey !== "number") {
+                        throwUnsupportedPropertyKey(this.ccId, property, propertyKey);
+                    }
+                    return (await this.get(propertyKey))?.[property];
+                default:
+                    throwUnsupportedProperty(this.ccId, property);
+            }
+        };
+    }
+    async getSupported() {
+        this.assertSupportsCommand(WindowCoveringCommand, WindowCoveringCommand.SupportedGet);
+        const cc = new WindowCoveringCCSupportedGet({
+            nodeId: this.endpoint.nodeId,
+            endpointIndex: this.endpoint.index,
+        });
+        const response = await this.host.sendCommand(cc, this.commandOptions);
+        return response?.supportedParameters;
+    }
+    async get(parameter) {
+        __assertType("parameter", "WindowCoveringParameter", __assertType__WindowCoveringParameter.bind(void 0, parameter));
+        this.assertSupportsCommand(WindowCoveringCommand, WindowCoveringCommand.Get);
+        const cc = new WindowCoveringCCGet({
+            nodeId: this.endpoint.nodeId,
+            endpointIndex: this.endpoint.index,
+            parameter,
+        });
+        const response = await this.host.sendCommand(cc, this.commandOptions);
+        if (response) {
+            return 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(WindowCoveringCommand, WindowCoveringCommand.StartLevelChange);
+        const cc = new WindowCoveringCCSet({
+            nodeId: this.endpoint.nodeId,
+            endpointIndex: this.endpoint.index,
+            targetValues,
+            duration,
+        });
+        return this.host.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(WindowCoveringCommand, WindowCoveringCommand.StartLevelChange);
+        const cc = new WindowCoveringCCStartLevelChange({
+            nodeId: this.endpoint.nodeId,
+            endpointIndex: this.endpoint.index,
+            parameter,
+            direction,
+            duration,
+        });
+        return this.host.sendCommand(cc, this.commandOptions);
+    }
+    async stopLevelChange(parameter) {
+        __assertType("parameter", "WindowCoveringParameter", __assertType__WindowCoveringParameter.bind(void 0, parameter));
+        this.assertSupportsCommand(WindowCoveringCommand, WindowCoveringCommand.StopLevelChange);
+        const cc = new WindowCoveringCCStopLevelChange({
+            nodeId: this.endpoint.nodeId,
+            endpointIndex: this.endpoint.index,
+            parameter,
+        });
+        return this.host.sendCommand(cc, this.commandOptions);
+    }
+};
+WindowCoveringCCAPI = __decorate([
+    API(CommandClasses["Window Covering"])
+], WindowCoveringCCAPI);
+export { WindowCoveringCCAPI };
+let WindowCoveringCC = class WindowCoveringCC extends CommandClass {
+    async interview(ctx) {
+        const node = this.getNode(ctx);
+        const endpoint = this.getEndpoint(ctx);
+        const api = CCAPI.create(CommandClasses["Window Covering"], ctx, endpoint).withOptions({
+            priority: MessagePriority.NodeQuery,
+        });
+        ctx.logNode(node.id, {
+            endpoint: this.endpointIndex,
+            message: `Interviewing ${this.ccName}...`,
+            direction: "none",
+        });
+        ctx.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) => `· ${getEnumMemberName(WindowCoveringParameter, p)}`)
+                .join("\n")}`;
+            ctx.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(ctx, WindowCoveringCCValues.currentValue(param));
+                this.setMetadata(ctx, WindowCoveringCCValues.targetValue(param));
+                this.setMetadata(ctx, WindowCoveringCCValues.duration(param));
+                // Level change values
+                this.setMetadata(ctx, WindowCoveringCCValues.levelChangeUp(param));
+                this.setMetadata(ctx, WindowCoveringCCValues.levelChangeDown(param));
+                // And for the odd parameters (with position support), query the position
+                if (param % 2 === 1) {
+                    ctx.logNode(node.id, {
+                        endpoint: this.endpointIndex,
+                        message: `querying position for parameter ${getEnumMemberName(WindowCoveringParameter, param)}...`,
+                        direction: "outbound",
+                    });
+                    await api.get(param);
+                }
+            }
+        }
+        // Remember that the interview is complete
+        this.setInterviewComplete(ctx, true);
+    }
+    translatePropertyKey(ctx, property, propertyKey) {
+        if (typeof propertyKey === "number") {
+            return getEnumMemberName(WindowCoveringParameter, propertyKey);
+        }
+        return super.translatePropertyKey(ctx, property, propertyKey);
+    }
+};
+WindowCoveringCC = __decorate([
+    commandClass(CommandClasses["Window Covering"]),
+    implementedVersion(1),
+    ccValues(WindowCoveringCCValues)
+], WindowCoveringCC);
+export { WindowCoveringCC };
+let WindowCoveringCCSupportedReport = WindowCoveringCCSupportedReport_1 = class WindowCoveringCCSupportedReport extends WindowCoveringCC {
+    constructor(options) {
+        super(options);
+        this.supportedParameters = options.supportedParameters;
+    }
+    static from(raw, ctx) {
+        validatePayload(raw.payload.length >= 1);
+        const numBitmaskBytes = raw.payload[0] & 0b1111;
+        validatePayload(raw.payload.length >= 1 + numBitmaskBytes);
+        const bitmask = raw.payload.subarray(1, 1 + numBitmaskBytes);
+        const supportedParameters = parseBitMask(bitmask, WindowCoveringParameter["Outbound Left (no position)"]);
+        return new WindowCoveringCCSupportedReport_1({
+            nodeId: ctx.sourceNodeId,
+            supportedParameters,
+        });
+    }
+    supportedParameters;
+    serialize(ctx) {
+        const bitmask = encodeBitMask(this.supportedParameters, undefined, WindowCoveringParameter["Outbound Left (no position)"]).subarray(0, 15);
+        const numBitmaskBytes = bitmask.length & 0b1111;
+        this.payload = Bytes.concat([
+            Bytes.from([numBitmaskBytes]),
+            bitmask.subarray(0, numBitmaskBytes),
+        ]);
+        return super.serialize(ctx);
+    }
+    toLogEntry(ctx) {
+        return {
+            ...super.toLogEntry(ctx),
+            message: {
+                "supported parameters": this.supportedParameters
+                    .map((p) => `\n· ${getEnumMemberName(WindowCoveringParameter, p)}`)
+                    .join(""),
+            },
+        };
+    }
+};
+__decorate([
+    ccValue(WindowCoveringCCValues.supportedParameters)
+], WindowCoveringCCSupportedReport.prototype, "supportedParameters", void 0);
+WindowCoveringCCSupportedReport = WindowCoveringCCSupportedReport_1 = __decorate([
+    CCCommand(WindowCoveringCommand.SupportedReport)
+], WindowCoveringCCSupportedReport);
+export { WindowCoveringCCSupportedReport };
+let WindowCoveringCCSupportedGet = class WindowCoveringCCSupportedGet extends WindowCoveringCC {
+};
+WindowCoveringCCSupportedGet = __decorate([
+    CCCommand(WindowCoveringCommand.SupportedGet),
+    expectedCCResponse(WindowCoveringCCSupportedReport)
+], WindowCoveringCCSupportedGet);
+export { WindowCoveringCCSupportedGet };
+let WindowCoveringCCReport = WindowCoveringCCReport_1 = class WindowCoveringCCReport extends WindowCoveringCC {
+    constructor(options) {
+        super(options);
+        // TODO: Check implementation:
+        this.parameter = options.parameter;
+        this.currentValue = options.currentValue;
+        this.targetValue = options.targetValue;
+        this.duration = options.duration;
+    }
+    static from(raw, ctx) {
+        validatePayload(raw.payload.length >= 4);
+        const parameter = raw.payload[0];
+        const currentValue = raw.payload[1];
+        const targetValue = raw.payload[2];
+        const duration = Duration.parseReport(raw.payload[3])
+            ?? Duration.unknown();
+        return new WindowCoveringCCReport_1({
+            nodeId: ctx.sourceNodeId,
+            parameter,
+            currentValue,
+            targetValue,
+            duration,
+        });
+    }
+    parameter;
+    currentValue;
+    targetValue;
+    duration;
+    toLogEntry(ctx) {
+        return {
+            ...super.toLogEntry(ctx),
+            message: {
+                parameter: getEnumMemberName(WindowCoveringParameter, this.parameter),
+                "current value": this.currentValue,
+                "target value": this.targetValue,
+                duration: this.duration.toString(),
+            },
+        };
+    }
+};
+__decorate([
+    ccValue(WindowCoveringCCValues.currentValue, (self) => [self.parameter])
+], WindowCoveringCCReport.prototype, "currentValue", void 0);
+__decorate([
+    ccValue(WindowCoveringCCValues.targetValue, (self) => [self.parameter])
+], WindowCoveringCCReport.prototype, "targetValue", void 0);
+__decorate([
+    ccValue(WindowCoveringCCValues.duration, (self) => [self.parameter])
+], WindowCoveringCCReport.prototype, "duration", void 0);
+WindowCoveringCCReport = WindowCoveringCCReport_1 = __decorate([
+    CCCommand(WindowCoveringCommand.Report)
+], WindowCoveringCCReport);
+export { WindowCoveringCCReport };
+function testResponseForWindowCoveringGet(sent, received) {
+    return received.parameter === sent.parameter;
+}
+let WindowCoveringCCGet = WindowCoveringCCGet_1 = class WindowCoveringCCGet extends WindowCoveringCC {
+    constructor(options) {
+        super(options);
+        this.parameter = options.parameter;
+    }
+    static from(raw, ctx) {
+        validatePayload(raw.payload.length >= 1);
+        const parameter = raw.payload[0];
+        return new WindowCoveringCCGet_1({
+            nodeId: ctx.sourceNodeId,
+            parameter,
+        });
+    }
+    parameter;
+    serialize(ctx) {
+        this.payload = Bytes.from([this.parameter]);
+        return super.serialize(ctx);
+    }
+    toLogEntry(ctx) {
+        return {
+            ...super.toLogEntry(ctx),
+            message: {
+                parameter: getEnumMemberName(WindowCoveringParameter, this.parameter),
+            },
+        };
+    }
+};
+WindowCoveringCCGet = WindowCoveringCCGet_1 = __decorate([
+    CCCommand(WindowCoveringCommand.Get),
+    expectedCCResponse(WindowCoveringCCReport, testResponseForWindowCoveringGet)
+], WindowCoveringCCGet);
+export { WindowCoveringCCGet };
+let WindowCoveringCCSet = WindowCoveringCCSet_1 = class WindowCoveringCCSet extends WindowCoveringCC {
+    constructor(options) {
+        super(options);
+        this.targetValues = options.targetValues;
+        this.duration = Duration.from(options.duration);
+    }
+    static from(raw, ctx) {
+        validatePayload(raw.payload.length >= 1);
+        const numEntries = raw.payload[0] & 0b11111;
+        validatePayload(raw.payload.length >= 1 + numEntries * 2);
+        const targetValues = [];
+        for (let i = 0; i < numEntries; i++) {
+            const offset = 1 + i * 2;
+            targetValues.push({
+                parameter: raw.payload[offset],
+                value: raw.payload[offset + 1],
+            });
+        }
+        let duration;
+        if (raw.payload.length >= 2 + numEntries * 2) {
+            duration = Duration.parseSet(raw.payload[1 + numEntries * 2]);
+        }
+        return new WindowCoveringCCSet_1({
+            nodeId: ctx.sourceNodeId,
+            targetValues,
+            duration,
+        });
+    }
+    targetValues;
+    duration;
+    serialize(ctx) {
+        const numEntries = this.targetValues.length & 0b11111;
+        this.payload = new Bytes(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 ?? Duration.default()).serializeSet();
+        return super.serialize(ctx);
+    }
+    toLogEntry(ctx) {
+        const message = {};
+        for (const { parameter, value } of this.targetValues) {
+            message[getEnumMemberName(WindowCoveringParameter, parameter)] =
+                value;
+        }
+        if (this.duration) {
+            message.duration = this.duration.toString();
+        }
+        return {
+            ...super.toLogEntry(ctx),
+            message,
+        };
+    }
+};
+WindowCoveringCCSet = WindowCoveringCCSet_1 = __decorate([
+    CCCommand(WindowCoveringCommand.Set),
+    useSupervision()
+], WindowCoveringCCSet);
+export { WindowCoveringCCSet };
+let WindowCoveringCCStartLevelChange = WindowCoveringCCStartLevelChange_1 = class WindowCoveringCCStartLevelChange extends WindowCoveringCC {
+    constructor(options) {
+        super(options);
+        this.parameter = options.parameter;
+        this.direction = options.direction;
+        this.duration = Duration.from(options.duration);
+    }
+    static from(raw, ctx) {
+        validatePayload(raw.payload.length >= 2);
+        const direction = !!(raw.payload[0] & 0b0100_0000)
+            ? "down"
+            : "up";
+        const parameter = raw.payload[1];
+        let duration;
+        if (raw.payload.length >= 3) {
+            duration = Duration.parseSet(raw.payload[2]);
+        }
+        return new WindowCoveringCCStartLevelChange_1({
+            nodeId: ctx.sourceNodeId,
+            direction,
+            parameter,
+            duration,
+        });
+    }
+    parameter;
+    direction;
+    duration;
+    serialize(ctx) {
+        this.payload = Bytes.from([
+            this.direction === "down" ? 0b0100_0000 : 0b0000_0000,
+            this.parameter,
+            (this.duration ?? Duration.default()).serializeSet(),
+        ]);
+        return super.serialize(ctx);
+    }
+    toLogEntry(ctx) {
+        const message = {
+            parameter: getEnumMemberName(WindowCoveringParameter, this.parameter),
+            direction: this.direction,
+        };
+        if (this.duration) {
+            message.duration = this.duration.toString();
+        }
+        return {
+            ...super.toLogEntry(ctx),
+            message,
+        };
+    }
+};
+WindowCoveringCCStartLevelChange = WindowCoveringCCStartLevelChange_1 = __decorate([
+    CCCommand(WindowCoveringCommand.StartLevelChange),
+    useSupervision()
+], WindowCoveringCCStartLevelChange);
+export { WindowCoveringCCStartLevelChange };
+let WindowCoveringCCStopLevelChange = WindowCoveringCCStopLevelChange_1 = class WindowCoveringCCStopLevelChange extends WindowCoveringCC {
+    constructor(options) {
+        super(options);
+        this.parameter = options.parameter;
+    }
+    static from(raw, ctx) {
+        validatePayload(raw.payload.length >= 1);
+        const parameter = raw.payload[0];
+        return new WindowCoveringCCStopLevelChange_1({
+            nodeId: ctx.sourceNodeId,
+            parameter,
+        });
+    }
+    parameter;
+    serialize(ctx) {
+        this.payload = Bytes.from([this.parameter]);
+        return super.serialize(ctx);
+    }
+    toLogEntry(ctx) {
+        return {
+            ...super.toLogEntry(ctx),
+            message: {
+                parameter: getEnumMemberName(WindowCoveringParameter, this.parameter),
+            },
+        };
+    }
+};
+WindowCoveringCCStopLevelChange = WindowCoveringCCStopLevelChange_1 = __decorate([
+    CCCommand(WindowCoveringCommand.StopLevelChange),
+    useSupervision()
+], WindowCoveringCCStopLevelChange);
+export { WindowCoveringCCStopLevelChange };
+//# sourceMappingURL=WindowCoveringCC.js.map