@zwave-js/cc 10.19.0 → 10.21.0

package/build/cc/WindowCoveringCC.d.ts

@@ -1,96 +1,34 @@
 /// <reference types="node" />
 import { CommandClasses, Duration, Maybe, MessageOrCCLogEntry, SupervisionResult } from "@zwave-js/core";
 import type { ZWaveApplicationHost, ZWaveHost } from "@zwave-js/host";
-import { CCAPI, PollValueImplementation, POLL_VALUE, SetValueImplementation, SET_VALUE } from "../lib/API";
+import { CCAPI, PollValueImplementation, POLL_VALUE, SetValueImplementation, SetValueImplementationHooksFactory, SET_VALUE, SET_VALUE_HOOKS } from "../lib/API";
 import { CCCommandOptions, CommandClass, type CommandClassDeserializationOptions } from "../lib/CommandClass";
 import { LevelChangeDirection, WindowCoveringCommand, WindowCoveringParameter } from "../lib/_Types";
 export declare const WindowCoveringCCValues: Readonly<{
-    tiltClose99: ((parameter: WindowCoveringParameter) => {
+    levelChangeDown: ((parameter: WindowCoveringParameter) => {
         readonly meta: {
-            readonly label: `Close Left - ${string}` | `Close Down - ${string}`;
-            readonly ccSpecific: {
-                readonly parameter: WindowCoveringParameter;
-            };
+            readonly label: `${string} - ${string}`;
             readonly valueChangeOptions: readonly ["transitionDuration"];
-            readonly readable: false;
-            readonly type: "boolean";
-            readonly writeable: true;
-        };
-        readonly id: {
-            commandClass: (typeof CommandClasses)["Window Covering"];
-            property: "close99";
-            propertyKey: WindowCoveringParameter;
-        };
-        readonly endpoint: (endpoint?: number | undefined) => {
-            readonly commandClass: (typeof CommandClasses)["Window Covering"];
-            readonly endpoint: number;
-            readonly property: "close99";
-            readonly propertyKey: WindowCoveringParameter;
-        };
-    }) & {
-        is: (valueId: import("@zwave-js/core").ValueID) => boolean;
-        readonly options: {
-            readonly internal: false;
-            readonly minVersion: 1;
-            readonly secret: false;
-            readonly stateful: true;
-            readonly supportsEndpoints: true;
-            readonly autoCreate: true;
-        };
-    };
-    tiltClose0: ((parameter: WindowCoveringParameter) => {
-        readonly meta: {
-            readonly label: `Close Right - ${string}` | `Close Up - ${string}`;
-            readonly ccSpecific: {
-                readonly parameter: WindowCoveringParameter;
+            readonly states: {
+                readonly true: "Start";
+                readonly false: "Stop";
             };
-            readonly valueChangeOptions: readonly ["transitionDuration"];
-            readonly readable: false;
-            readonly type: "boolean";
-            readonly writeable: true;
-        };
-        readonly id: {
-            commandClass: (typeof CommandClasses)["Window Covering"];
-            property: "close0";
-            propertyKey: WindowCoveringParameter;
-        };
-        readonly endpoint: (endpoint?: number | undefined) => {
-            readonly commandClass: (typeof CommandClasses)["Window Covering"];
-            readonly endpoint: number;
-            readonly property: "close0";
-            readonly propertyKey: WindowCoveringParameter;
-        };
-    }) & {
-        is: (valueId: import("@zwave-js/core").ValueID) => boolean;
-        readonly options: {
-            readonly internal: false;
-            readonly minVersion: 1;
-            readonly secret: false;
-            readonly stateful: true;
-            readonly supportsEndpoints: true;
-            readonly autoCreate: true;
-        };
-    };
-    positionClose: ((parameter: WindowCoveringParameter) => {
-        readonly meta: {
-            readonly label: `Close - ${string}`;
             readonly ccSpecific: {
                 readonly parameter: WindowCoveringParameter;
             };
-            readonly valueChangeOptions: readonly ["transitionDuration"];
             readonly readable: false;
             readonly type: "boolean";
             readonly writeable: true;
         };
         readonly id: {
             commandClass: (typeof CommandClasses)["Window Covering"];
-            property: "close";
+            property: "levelChangeDown";
             propertyKey: WindowCoveringParameter;
         };
         readonly endpoint: (endpoint?: number | undefined) => {
             readonly commandClass: (typeof CommandClasses)["Window Covering"];
             readonly endpoint: number;
-            readonly property: "close";
+            readonly property: "levelChangeDown";
             readonly propertyKey: WindowCoveringParameter;
         };
     }) & {
@@ -104,26 +42,30 @@ export declare const WindowCoveringCCValues: Readonly<{
             readonly autoCreate: true;
         };
     };
-    open: ((parameter: WindowCoveringParameter) => {
+    levelChangeUp: ((parameter: WindowCoveringParameter) => {
         readonly meta: {
-            readonly label: `Open - ${string}`;
+            readonly label: `${string} - ${string}`;
+            readonly valueChangeOptions: readonly ["transitionDuration"];
+            readonly states: {
+                readonly true: "Start";
+                readonly false: "Stop";
+            };
             readonly ccSpecific: {
                 readonly parameter: WindowCoveringParameter;
             };
-            readonly valueChangeOptions: readonly ["transitionDuration"];
             readonly readable: false;
             readonly type: "boolean";
             readonly writeable: true;
         };
         readonly id: {
             commandClass: (typeof CommandClasses)["Window Covering"];
-            property: "open";
+            property: "levelChangeUp";
             propertyKey: WindowCoveringParameter;
         };
         readonly endpoint: (endpoint?: number | undefined) => {
             readonly commandClass: (typeof CommandClasses)["Window Covering"];
             readonly endpoint: number;
-            readonly property: "open";
+            readonly property: "levelChangeUp";
             readonly propertyKey: WindowCoveringParameter;
         };
     }) & {
@@ -171,12 +113,16 @@ export declare const WindowCoveringCCValues: Readonly<{
     };
     targetValue: ((parameter: WindowCoveringParameter) => {
         readonly meta: {
+            readonly label: `Target value - ${string}`;
+            readonly writeable: boolean;
+            readonly states: {
+                [x: number]: string;
+            };
+            readonly allowManualEntry: boolean;
             readonly ccSpecific: {
                 readonly parameter: WindowCoveringParameter;
             };
             readonly valueChangeOptions: readonly ["transitionDuration"];
-            readonly label: `Target value - ${string}`;
-            readonly writeable: boolean;
             readonly max: 99;
             readonly min: 0;
             readonly type: "number";
@@ -206,10 +152,13 @@ export declare const WindowCoveringCCValues: Readonly<{
     };
     currentValue: ((parameter: WindowCoveringParameter) => {
         readonly meta: {
+            readonly label: `Current value - ${string}`;
+            readonly states: {
+                [x: number]: string;
+            };
             readonly ccSpecific: {
                 readonly parameter: WindowCoveringParameter;
             };
-            readonly label: `Current value - ${string}`;
             readonly writeable: false;
             readonly max: 99;
             readonly min: 0;
@@ -267,6 +216,7 @@ export declare const WindowCoveringCCValues: Readonly<{
 export declare class WindowCoveringCCAPI extends CCAPI {
     supportsCommand(cmd: WindowCoveringCommand): Maybe<boolean>;
     protected [SET_VALUE]: SetValueImplementation;
+    protected [SET_VALUE_HOOKS]: SetValueImplementationHooksFactory;
     protected [POLL_VALUE]: PollValueImplementation;
     getSupported(): Promise<readonly WindowCoveringParameter[] | undefined>;
     get(parameter: WindowCoveringParameter): Promise<Pick<WindowCoveringCCReport, "duration" | "currentValue" | "targetValue"> | undefined>;

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

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

package/build/cc/WindowCoveringCC.js

@@ -5,7 +5,7 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
-var _a, _b;
+var _a, _b, _c;
 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) {
@@ -109,60 +109,42 @@ 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) {
+function parameterToMetadataStates(parameter) {
     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)",
+                0: "Closed (right inside)",
                 50: "Open",
-                99: "Closed (left)",
+                99: "Closed (left inside)",
             };
         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)",
+                0: "Closed (up inside)",
                 50: "Open",
-                99: "Closed (down)",
+                99: "Closed (down inside)",
             };
     }
-    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",
-        };
-    }
+    return {
+        0: "Closed",
+        99: "Open",
+    };
 }
-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)"]);
+function parameterToLevelChangeLabel(parameter, direction) {
+    switch (parameter) {
+        // For angle control, both directions are closed, so we specify it explicitly
+        case _Types_1.WindowCoveringParameter["Vertical Slats Angle (no position)"]:
+        case _Types_1.WindowCoveringParameter["Vertical Slats Angle"]:
+            return `Change tilt (${direction === "up" ? "left inside" : "right inside"})`;
+        case _Types_1.WindowCoveringParameter["Horizontal Slats Angle (no position)"]:
+        case _Types_1.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";
 }
 exports.WindowCoveringCCValues = Object.freeze({
     ...Values_1.V.defineStaticCCValues(core_1.CommandClasses["Window Covering"], {
@@ -171,27 +153,24 @@ exports.WindowCoveringCCValues = Object.freeze({
     }),
     ...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,
-                },
+                states: parameterToMetadataStates(parameter),
+                ccSpecific: { parameter },
             };
         }),
         ...Values_1.V.dynamicPropertyAndKeyWithName("targetValue", "targetValue", (parameter) => parameter, ({ property, propertyKey }) => property === "targetValue" && typeof propertyKey === "number", (parameter) => {
-            const states = parameterToMetadataStates(parameter, false);
+            // Only odd-numbered parameters have position support and are writable
+            const writeable = parameter % 2 === 1;
             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,
-                },
+                states: parameterToMetadataStates(parameter),
+                allowManualEntry: writeable,
+                ccSpecific: { parameter },
                 valueChangeOptions: ["transitionDuration"],
             };
         }),
@@ -202,63 +181,33 @@ exports.WindowCoveringCCValues = Object.freeze({
                 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";
+        ...Values_1.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 {
                 ...core_1.ValueMetadata.WriteOnlyBoolean,
-                label: `Close ${direction} - ${(0, safe_1.getEnumMemberName)(_Types_1.WindowCoveringParameter, parameter)}`,
-                ccSpecific: {
-                    parameter,
-                },
+                label: `${parameterToLevelChangeLabel(parameter, "up")} - ${(0, safe_1.getEnumMemberName)(_Types_1.WindowCoveringParameter, parameter)}`,
                 valueChangeOptions: ["transitionDuration"],
+                states: {
+                    true: "Start",
+                    false: "Stop",
+                },
+                ccSpecific: { parameter },
             };
         }),
-        // 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";
+        ...Values_1.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 {
                 ...core_1.ValueMetadata.WriteOnlyBoolean,
-                label: `Close ${direction} - ${(0, safe_1.getEnumMemberName)(_Types_1.WindowCoveringParameter, parameter)}`,
-                ccSpecific: {
-                    parameter,
-                },
+                label: `${parameterToLevelChangeLabel(parameter, "down")} - ${(0, safe_1.getEnumMemberName)(_Types_1.WindowCoveringParameter, parameter)}`,
                 valueChangeOptions: ["transitionDuration"],
+                states: {
+                    true: "Start",
+                    false: "Stop",
+                },
+                ccSpecific: { parameter },
             };
         }),
     }),
@@ -272,7 +221,6 @@ let WindowCoveringCCAPI = class WindowCoveringCCAPI extends API_1.CCAPI {
                 property,
                 propertyKey,
             };
-            let targetValue;
             if (exports.WindowCoveringCCValues.targetValue.is(valueId)) {
                 if (typeof propertyKey !== "number" ||
                     // Only odd-numbered parameters have position support and are writable
@@ -282,92 +230,98 @@ let WindowCoveringCCAPI = class WindowCoveringCCAPI extends API_1.CCAPI {
                 if (typeof value !== "number") {
                     (0, API_1.throwWrongValueType)(this.ccId, property, "number", typeof value);
                 }
-                targetValue = value;
+                const parameter = propertyKey;
+                const duration = core_1.Duration.from(options?.transitionDuration);
+                return this.set([{ parameter, value }], duration);
             }
-            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);
+            else if (exports.WindowCoveringCCValues.levelChangeUp.is(valueId) ||
+                exports.WindowCoveringCCValues.levelChangeDown.is(valueId)) {
+                if (typeof value !== "boolean") {
+                    (0, API_1.throwWrongValueType)(this.ccId, property, "boolean", 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);
+                const parameter = propertyKey;
+                const direction = exports.WindowCoveringCCValues.levelChangeUp.is(valueId)
+                    ? "up"
+                    : "down";
+                if (value) {
+                    // Perform the level change
+                    const duration = core_1.Duration.from(options?.transitionDuration);
+                    return this.startLevelChange(parameter, direction, duration);
                 }
-                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);
+                else {
+                    return this.stopLevelChange(parameter);
                 }
-                // 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 });
-                }
+        };
+        this[_b] = ({ property, propertyKey }, value, options) => {
+            const valueId = {
+                commandClass: this.ccId,
+                property,
+                propertyKey,
+            };
+            if (exports.WindowCoveringCCValues.targetValue.is(valueId)) {
+                if (typeof propertyKey !== "number")
+                    return;
+                const parameter = propertyKey;
+                const duration = core_1.Duration.from(options?.transitionDuration);
+                const currentValueValueId = exports.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: () => {
+                        this.tryGetValueDB()?.setValue(currentValueValueId, value);
+                    },
+                    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: () => {
+                        // 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.applHost
+                                        .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
+                        }
+                    },
+                };
             }
-            return result;
         };
-        this[_b] = async ({ property, propertyKey, }) => {
+        this[_c] = async ({ property, propertyKey, }) => {
             switch (property) {
                 case "currentValue":
                 case "targetValue":
@@ -454,7 +408,7 @@ let WindowCoveringCCAPI = class WindowCoveringCCAPI extends API_1.CCAPI {
         return this.applHost.sendCommand(cc, this.commandOptions);
     }
 };
-_a = API_1.SET_VALUE, _b = API_1.POLL_VALUE;
+_a = API_1.SET_VALUE, _b = API_1.SET_VALUE_HOOKS, _c = API_1.POLL_VALUE;
 WindowCoveringCCAPI = __decorate([
     (0, CommandClassDecorators_1.API)(core_1.CommandClasses["Window Covering"])
 ], WindowCoveringCCAPI);
@@ -493,15 +447,9 @@ ${supported
                 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));
-                }
+                // Level change values
+                this.setMetadata(applHost, exports.WindowCoveringCCValues.levelChangeUp(param));
+                this.setMetadata(applHost, exports.WindowCoveringCCValues.levelChangeDown(param));
                 // And for the odd parameters (with position support), query the position
                 if (param % 2 === 1) {
                     applHost.controllerLog.logNode(node.id, {