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

package/build/cjs/cc/MultilevelSwitchCC.js

@@ -0,0 +1,780 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var MultilevelSwitchCC_exports = {};
+__export(MultilevelSwitchCC_exports, {
+  MultilevelSwitchCC: () => MultilevelSwitchCC,
+  MultilevelSwitchCCAPI: () => MultilevelSwitchCCAPI,
+  MultilevelSwitchCCGet: () => MultilevelSwitchCCGet,
+  MultilevelSwitchCCReport: () => MultilevelSwitchCCReport,
+  MultilevelSwitchCCSet: () => MultilevelSwitchCCSet,
+  MultilevelSwitchCCStartLevelChange: () => MultilevelSwitchCCStartLevelChange,
+  MultilevelSwitchCCStopLevelChange: () => MultilevelSwitchCCStopLevelChange,
+  MultilevelSwitchCCSupportedGet: () => MultilevelSwitchCCSupportedGet,
+  MultilevelSwitchCCSupportedReport: () => MultilevelSwitchCCSupportedReport,
+  MultilevelSwitchCCValues: () => MultilevelSwitchCCValues
+});
+module.exports = __toCommonJS(MultilevelSwitchCC_exports);
+var import_safe = require("@zwave-js/core/safe");
+var import_safe2 = require("@zwave-js/shared/safe");
+var import_safe3 = require("@zwave-js/shared/safe");
+var import_API = require("../lib/API.js");
+var import_CommandClass = require("../lib/CommandClass.js");
+var import_CommandClassDecorators = require("../lib/CommandClassDecorators.js");
+var import_Values = require("../lib/Values.js");
+var import_Types = require("../lib/_Types.js");
+var __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 MultilevelSwitchCCSet_1, MultilevelSwitchCCReport_1, MultilevelSwitchCCStartLevelChange_1, MultilevelSwitchCCSupportedReport_1;
+function __assertType(argName, typeName, boundHasError) {
+  const { ZWaveError, ZWaveErrorCodes } = require("@zwave-js/core");
+  if (boundHasError()) {
+    throw new ZWaveError(typeName ? `${argName} is not a ${typeName}` : `${argName} has the wrong type`, ZWaveErrorCodes.Argument_Invalid);
+  }
+}
+const __assertType__number = ($o) => {
+  function _number($o2) {
+    return typeof $o2 !== "number" ? {} : null;
+  }
+  return _number($o);
+};
+const __assertType__optional_su__string__2_eu = ($o) => {
+  function _string($o2) {
+    return typeof $o2 !== "string" ? {} : null;
+  }
+  function _2($o2) {
+    return !($o2 instanceof require("@zwave-js/core/safe").Duration) ? {} : null;
+  }
+  function su__string__2_eu($o2) {
+    const conditions = [_string, _2];
+    for (const condition of conditions) {
+      const error = condition($o2);
+      if (!error)
+        return null;
+    }
+    return {};
+  }
+  function optional_su__string__2_eu($o2) {
+    if ($o2 !== void 0) {
+      const error = su__string__2_eu($o2);
+      if (error)
+        return error;
+    }
+    return null;
+  }
+  return optional_su__string__2_eu($o);
+};
+const __assertType__MultilevelSwitchCCStartLevelChangeOptions = ($o) => {
+  function _8($o2) {
+    return $o2 !== "up" ? {} : null;
+  }
+  function _9($o2) {
+    return $o2 !== "down" ? {} : null;
+  }
+  function su__8__9_eu($o2) {
+    const conditions = [_8, _9];
+    for (const condition of conditions) {
+      const error = condition($o2);
+      if (!error)
+        return null;
+    }
+    return {};
+  }
+  function _2($o2) {
+    if (typeof $o2 !== "object" || $o2 === null || Array.isArray($o2))
+      return {};
+    if ("direction" in $o2 && $o2["direction"] !== void 0) {
+      const error = su__8__9_eu($o2["direction"]);
+      if (error)
+        return error;
+    } else
+      return {};
+    return null;
+  }
+  function _true($o2) {
+    return $o2 !== true ? {} : null;
+  }
+  function _number($o2) {
+    return typeof $o2 !== "number" ? {} : null;
+  }
+  function _3($o2) {
+    if (typeof $o2 !== "object" || $o2 === null || Array.isArray($o2))
+      return {};
+    if ("ignoreStartLevel" in $o2 && $o2["ignoreStartLevel"] !== void 0) {
+      const error = _true($o2["ignoreStartLevel"]);
+      if (error)
+        return error;
+    } else
+      return {};
+    if ("startLevel" in $o2 && $o2["startLevel"] !== void 0) {
+      const error = _number($o2["startLevel"]);
+      if (error)
+        return error;
+    }
+    return null;
+  }
+  function _string($o2) {
+    return typeof $o2 !== "string" ? {} : null;
+  }
+  function _12($o2) {
+    return !($o2 instanceof require("@zwave-js/core/safe").Duration) ? {} : null;
+  }
+  function su__string__12_eu($o2) {
+    const conditions = [_string, _12];
+    for (const condition of conditions) {
+      const error = condition($o2);
+      if (!error)
+        return null;
+    }
+    return {};
+  }
+  function _4($o2) {
+    if (typeof $o2 !== "object" || $o2 === null || Array.isArray($o2))
+      return {};
+    if ("duration" in $o2 && $o2["duration"] !== void 0) {
+      const error = su__string__12_eu($o2["duration"]);
+      if (error)
+        return error;
+    }
+    return null;
+  }
+  function si__2__3__4_ei($o2) {
+    const conditions = [_2, _3, _4];
+    for (const condition of conditions) {
+      const error = condition($o2);
+      if (error)
+        return error;
+    }
+    return null;
+  }
+  function _false($o2) {
+    return $o2 !== false ? {} : null;
+  }
+  function _6($o2) {
+    if (typeof $o2 !== "object" || $o2 === null || Array.isArray($o2))
+      return {};
+    if ("ignoreStartLevel" in $o2 && $o2["ignoreStartLevel"] !== void 0) {
+      const error = _false($o2["ignoreStartLevel"]);
+      if (error)
+        return error;
+    } else
+      return {};
+    if ("startLevel" in $o2 && $o2["startLevel"] !== void 0) {
+      const error = _number($o2["startLevel"]);
+      if (error)
+        return error;
+    } else
+      return {};
+    return null;
+  }
+  function si__2__6__4_ei($o2) {
+    const conditions = [_2, _6, _4];
+    for (const condition of conditions) {
+      const error = condition($o2);
+      if (error)
+        return error;
+    }
+    return null;
+  }
+  function su_si__2__3__4_ei_si__2__6__4_ei_eu($o2) {
+    const conditions = [si__2__3__4_ei, si__2__6__4_ei];
+    for (const condition of conditions) {
+      const error = condition($o2);
+      if (!error)
+        return null;
+    }
+    return {};
+  }
+  return su_si__2__3__4_ei_si__2__6__4_ei_eu($o);
+};
+function switchTypeToActions(switchType) {
+  if (!switchType.includes("/"))
+    switchType = import_Types.SwitchType[2];
+  return switchType.split("/", 2);
+}
+const switchTypeProperties = Object.keys(import_Types.SwitchType).filter((key) => key.includes("/")).map((key) => switchTypeToActions(key)).reduce((acc, cur) => acc.concat(...cur), []);
+const MultilevelSwitchCCValues = Object.freeze({
+  ...import_Values.V.defineStaticCCValues(import_safe.CommandClasses["Multilevel Switch"], {
+    ...import_Values.V.staticProperty("currentValue", {
+      ...import_safe.ValueMetadata.ReadOnlyLevel,
+      label: "Current value"
+    }),
+    ...import_Values.V.staticProperty("targetValue", {
+      ...import_safe.ValueMetadata.Level,
+      label: "Target value",
+      valueChangeOptions: ["transitionDuration"]
+    }),
+    ...import_Values.V.staticProperty("duration", {
+      ...import_safe.ValueMetadata.ReadOnlyDuration,
+      label: "Remaining duration"
+    }),
+    ...import_Values.V.staticProperty("restorePrevious", {
+      ...import_safe.ValueMetadata.WriteOnlyBoolean,
+      label: "Restore previous value",
+      states: {
+        true: "Restore"
+      }
+    }),
+    ...import_Values.V.staticPropertyWithName("compatEvent", "event", {
+      ...import_safe.ValueMetadata.ReadOnlyUInt8,
+      label: "Event value"
+    }, {
+      stateful: false,
+      autoCreate: (applHost, endpoint) => !!applHost.getDeviceConfig?.(endpoint.nodeId)?.compat?.treatMultilevelSwitchSetAsEvent
+    }),
+    ...import_Values.V.staticProperty("switchType", void 0, { internal: true }),
+    // TODO: Solve this differently
+    ...import_Values.V.staticProperty("superviseStartStopLevelChange", void 0, {
+      internal: true,
+      supportsEndpoints: false
+    })
+  }),
+  ...import_Values.V.defineDynamicCCValues(import_safe.CommandClasses["Multilevel Switch"], {
+    ...import_Values.V.dynamicPropertyWithName(
+      "levelChangeUp",
+      // This is called "up" here, but the actual property name will depend on
+      // the given switch type
+      (switchType) => {
+        const switchTypeName = (0, import_safe3.getEnumMemberName)(import_Types.SwitchType, switchType);
+        const [, up] = switchTypeToActions(switchTypeName);
+        return up;
+      },
+      ({ property }) => typeof property === "string" && switchTypeProperties.indexOf(property) % 2 === 1,
+      (switchType) => {
+        const switchTypeName = (0, import_safe3.getEnumMemberName)(import_Types.SwitchType, switchType);
+        const [, up] = switchTypeToActions(switchTypeName);
+        return {
+          ...import_safe.ValueMetadata.WriteOnlyBoolean,
+          label: `Perform a level change (${up})`,
+          valueChangeOptions: ["transitionDuration"],
+          states: {
+            true: "Start",
+            false: "Stop"
+          },
+          ccSpecific: { switchType }
+        };
+      }
+    ),
+    ...import_Values.V.dynamicPropertyWithName(
+      "levelChangeDown",
+      // This is called "down" here, but the actual property name will depend on
+      // the given switch type
+      (switchType) => {
+        const switchTypeName = (0, import_safe3.getEnumMemberName)(import_Types.SwitchType, switchType);
+        const [down] = switchTypeToActions(switchTypeName);
+        return down;
+      },
+      ({ property }) => typeof property === "string" && switchTypeProperties.indexOf(property) % 2 === 0,
+      (switchType) => {
+        const switchTypeName = (0, import_safe3.getEnumMemberName)(import_Types.SwitchType, switchType);
+        const [down] = switchTypeToActions(switchTypeName);
+        return {
+          ...import_safe.ValueMetadata.WriteOnlyBoolean,
+          label: `Perform a level change (${down})`,
+          valueChangeOptions: ["transitionDuration"],
+          states: {
+            true: "Start",
+            false: "Stop"
+          },
+          ccSpecific: { switchType }
+        };
+      }
+    )
+  })
+});
+let MultilevelSwitchCCAPI = class MultilevelSwitchCCAPI2 extends import_API.CCAPI {
+  supportsCommand(cmd) {
+    switch (cmd) {
+      case import_Types.MultilevelSwitchCommand.Get:
+        return this.isSinglecast();
+      case import_Types.MultilevelSwitchCommand.Set:
+      case import_Types.MultilevelSwitchCommand.StartLevelChange:
+      case import_Types.MultilevelSwitchCommand.StopLevelChange:
+        return true;
+      // This is mandatory
+      case import_Types.MultilevelSwitchCommand.SupportedGet:
+        return this.version >= 3 && this.isSinglecast();
+    }
+    return super.supportsCommand(cmd);
+  }
+  // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
+  async get() {
+    this.assertSupportsCommand(import_Types.MultilevelSwitchCommand, import_Types.MultilevelSwitchCommand.Get);
+    const cc = new MultilevelSwitchCCGet({
+      nodeId: this.endpoint.nodeId,
+      endpointIndex: this.endpoint.index
+    });
+    const response = await this.host.sendCommand(cc, this.commandOptions);
+    if (response) {
+      return (0, import_safe3.pick)(response, ["currentValue", "targetValue", "duration"]);
+    }
+  }
+  /**
+   * Sets the switch to a new value
+   * @param targetValue The new target value for the switch
+   * @param duration The duration after which the target value should be reached. Can be a Duration instance or a user-friendly duration string like `"1m17s"`. Only supported in V2 and above.
+   * @returns A promise indicating whether the command was completed
+   */
+  async set(targetValue, duration) {
+    __assertType("targetValue", "number", __assertType__number.bind(void 0, targetValue));
+    __assertType("duration", void 0, __assertType__optional_su__string__2_eu.bind(void 0, duration));
+    this.assertSupportsCommand(import_Types.MultilevelSwitchCommand, import_Types.MultilevelSwitchCommand.Set);
+    const cc = new MultilevelSwitchCCSet({
+      nodeId: this.endpoint.nodeId,
+      endpointIndex: this.endpoint.index,
+      targetValue,
+      duration
+    });
+    return this.host.sendCommand(cc, this.commandOptions);
+  }
+  async startLevelChange(options) {
+    __assertType("options", "MultilevelSwitchCCStartLevelChangeOptions", __assertType__MultilevelSwitchCCStartLevelChangeOptions.bind(void 0, options));
+    this.assertSupportsCommand(import_Types.MultilevelSwitchCommand, import_Types.MultilevelSwitchCommand.StartLevelChange);
+    const cc = new MultilevelSwitchCCStartLevelChange({
+      nodeId: this.endpoint.nodeId,
+      endpointIndex: this.endpoint.index,
+      ...options
+    });
+    return this.host.sendCommand(cc, this.commandOptions);
+  }
+  async stopLevelChange() {
+    this.assertSupportsCommand(import_Types.MultilevelSwitchCommand, import_Types.MultilevelSwitchCommand.StopLevelChange);
+    const cc = new MultilevelSwitchCCStopLevelChange({
+      nodeId: this.endpoint.nodeId,
+      endpointIndex: this.endpoint.index
+    });
+    return this.host.sendCommand(cc, this.commandOptions);
+  }
+  async getSupported() {
+    this.assertSupportsCommand(import_Types.MultilevelSwitchCommand, import_Types.MultilevelSwitchCommand.SupportedGet);
+    const cc = new MultilevelSwitchCCSupportedGet({
+      nodeId: this.endpoint.nodeId,
+      endpointIndex: this.endpoint.index
+    });
+    const response = await this.host.sendCommand(cc, this.commandOptions);
+    return response?.switchType;
+  }
+  get [import_API.SET_VALUE]() {
+    return async function({ property }, value, options) {
+      if (property === "restorePrevious") {
+        property = "targetValue";
+        value = 255;
+      }
+      if (property === "targetValue") {
+        if (typeof value !== "number") {
+          (0, import_API.throwWrongValueType)(this.ccId, property, "number", typeof value);
+        }
+        const duration = import_safe.Duration.from(options?.transitionDuration);
+        return this.set(value, duration);
+      } else if (switchTypeProperties.includes(property)) {
+        if (typeof value !== "boolean") {
+          (0, import_API.throwWrongValueType)(this.ccId, property, "number", typeof value);
+        }
+        if (value) {
+          const direction = switchTypeProperties.indexOf(property) % 2 === 0 ? "down" : "up";
+          const startLevel = this.tryGetValueDB()?.getValue(MultilevelSwitchCCValues.currentValue.endpoint(this.endpoint.index));
+          const duration = import_safe.Duration.from(options?.transitionDuration);
+          return this.startLevelChange({
+            direction,
+            ignoreStartLevel: true,
+            startLevel: typeof startLevel === "number" ? startLevel : void 0,
+            duration
+          });
+        } else {
+          return this.stopLevelChange();
+        }
+      } else {
+        (0, import_API.throwUnsupportedProperty)(this.ccId, property);
+      }
+    };
+  }
+  [import_API.SET_VALUE_HOOKS] = ({ property }, value, options) => {
+    if (property === "restorePrevious") {
+      property = "targetValue";
+      value = 255;
+    }
+    if (property === "targetValue") {
+      const duration = import_safe.Duration.from(options?.transitionDuration);
+      const currentValueValueId = MultilevelSwitchCCValues.currentValue.endpoint(this.endpoint.index);
+      return {
+        // Multilevel Switch 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 () => {
+          if (typeof value === "number" && value >= 0 && value <= 99) {
+            this.tryGetValueDB()?.setValue(currentValueValueId, value);
+          } else if (value === 255) {
+            try {
+              await this.get();
+            } catch {
+            }
+          }
+        },
+        supervisionOnFailure: async () => {
+          try {
+            await this.get();
+          } catch {
+          }
+        },
+        optimisticallyUpdateRelatedValues: (_supervisedAndSuccessful) => {
+          if (typeof value === "number" && value >= 0 && value <= 99) {
+            if (this.isSinglecast()) {
+              this.tryGetValueDB()?.setValue(currentValueValueId, value);
+            } else if (this.isMulticast()) {
+              const affectedNodes = this.endpoint.node.physicalNodes.filter((node) => node.getEndpoint(this.endpoint.index)?.supportsCC(this.ccId));
+              for (const node of affectedNodes) {
+                this.host.tryGetValueDB(node.id)?.setValue(currentValueValueId, value);
+              }
+            }
+          }
+        },
+        forceVerifyChanges: () => {
+          return value === 255;
+        },
+        verifyChanges: () => {
+          if (this.isSinglecast() || this.isMulticast() && value === 255) {
+            this.schedulePoll(currentValueValueId, value === 255 ? void 0 : value, { duration });
+          }
+        }
+      };
+    }
+  };
+  get [import_API.POLL_VALUE]() {
+    return async function({ property }) {
+      switch (property) {
+        case "currentValue":
+        case "targetValue":
+        case "duration":
+          return (await this.get())?.[property];
+        default:
+          (0, import_API.throwUnsupportedProperty)(this.ccId, property);
+      }
+    };
+  }
+};
+MultilevelSwitchCCAPI = __decorate([
+  (0, import_CommandClassDecorators.API)(import_safe.CommandClasses["Multilevel Switch"])
+], MultilevelSwitchCCAPI);
+let MultilevelSwitchCC = class MultilevelSwitchCC2 extends import_CommandClass.CommandClass {
+  async interview(ctx) {
+    const node = this.getNode(ctx);
+    const endpoint = this.getEndpoint(ctx);
+    const api = import_API.CCAPI.create(import_safe.CommandClasses["Multilevel Switch"], ctx, endpoint).withOptions({
+      priority: import_safe.MessagePriority.NodeQuery
+    });
+    ctx.logNode(node.id, {
+      endpoint: this.endpointIndex,
+      message: `Interviewing ${this.ccName}...`,
+      direction: "none"
+    });
+    if (api.version >= 3) {
+      ctx.logNode(node.id, {
+        endpoint: this.endpointIndex,
+        message: "requesting switch type...",
+        direction: "outbound"
+      });
+      const switchType = await api.getSupported();
+      if (switchType != void 0) {
+        ctx.logNode(node.id, {
+          endpoint: this.endpointIndex,
+          message: `has switch type ${(0, import_safe3.getEnumMemberName)(import_Types.SwitchType, switchType)}`,
+          direction: "inbound"
+        });
+      }
+    } else {
+      this.createMetadataForLevelChangeActions(ctx);
+    }
+    await this.refreshValues(ctx);
+    this.setInterviewComplete(ctx, true);
+  }
+  async refreshValues(ctx) {
+    const node = this.getNode(ctx);
+    const endpoint = this.getEndpoint(ctx);
+    const api = import_API.CCAPI.create(import_safe.CommandClasses["Multilevel Switch"], ctx, endpoint).withOptions({
+      priority: import_safe.MessagePriority.NodeQuery
+    });
+    ctx.logNode(node.id, {
+      endpoint: this.endpointIndex,
+      message: "requesting current switch state...",
+      direction: "outbound"
+    });
+    await api.get();
+  }
+  setMappedBasicValue(ctx, value) {
+    this.setValue(ctx, MultilevelSwitchCCValues.currentValue, value);
+    return true;
+  }
+  createMetadataForLevelChangeActions(ctx, switchType = import_Types.SwitchType["Down/Up"]) {
+    this.ensureMetadata(ctx, MultilevelSwitchCCValues.levelChangeUp(switchType));
+    this.ensureMetadata(ctx, MultilevelSwitchCCValues.levelChangeDown(switchType));
+  }
+};
+MultilevelSwitchCC = __decorate([
+  (0, import_CommandClassDecorators.commandClass)(import_safe.CommandClasses["Multilevel Switch"]),
+  (0, import_CommandClassDecorators.implementedVersion)(4),
+  (0, import_CommandClassDecorators.ccValues)(MultilevelSwitchCCValues)
+], MultilevelSwitchCC);
+let MultilevelSwitchCCSet = MultilevelSwitchCCSet_1 = class MultilevelSwitchCCSet2 extends MultilevelSwitchCC {
+  constructor(options) {
+    super(options);
+    this.targetValue = options.targetValue;
+    this.duration = import_safe.Duration.from(options.duration);
+  }
+  static from(raw, ctx) {
+    (0, import_safe.validatePayload)(raw.payload.length >= 1);
+    const targetValue = raw.payload[0];
+    let duration;
+    if (raw.payload.length >= 2) {
+      duration = import_safe.Duration.parseReport(raw.payload[1]);
+    }
+    return new MultilevelSwitchCCSet_1({
+      nodeId: ctx.sourceNodeId,
+      targetValue,
+      duration
+    });
+  }
+  targetValue;
+  duration;
+  serialize(ctx) {
+    this.payload = import_safe2.Bytes.from([
+      this.targetValue,
+      (this.duration ?? import_safe.Duration.default()).serializeSet()
+    ]);
+    const ccVersion = (0, import_CommandClass.getEffectiveCCVersion)(ctx, this);
+    if (ccVersion < 2 && ctx.getDeviceConfig?.(this.nodeId)?.compat?.encodeCCsUsingTargetVersion) {
+      this.payload = this.payload.subarray(0, 1);
+    }
+    return super.serialize(ctx);
+  }
+  toLogEntry(ctx) {
+    const message = {
+      "target value": this.targetValue
+    };
+    if (this.duration) {
+      message.duration = this.duration.toString();
+    }
+    return {
+      ...super.toLogEntry(ctx),
+      message
+    };
+  }
+};
+MultilevelSwitchCCSet = MultilevelSwitchCCSet_1 = __decorate([
+  (0, import_CommandClassDecorators.CCCommand)(import_Types.MultilevelSwitchCommand.Set),
+  (0, import_CommandClassDecorators.useSupervision)()
+], MultilevelSwitchCCSet);
+let MultilevelSwitchCCReport = MultilevelSwitchCCReport_1 = class MultilevelSwitchCCReport2 extends MultilevelSwitchCC {
+  constructor(options) {
+    super(options);
+    this.currentValue = options.currentValue;
+    this.targetValue = options.targetValue;
+    this.duration = import_safe.Duration.from(options.duration);
+  }
+  static from(raw, ctx) {
+    (0, import_safe.validatePayload)(raw.payload.length >= 1);
+    const currentValue = (
+      // 0xff is a legacy value for 100% (99)
+      raw.payload[0] === 255 ? 99 : (0, import_safe.parseMaybeNumber)(raw.payload[0])
+    );
+    let targetValue;
+    let duration;
+    if (raw.payload.length >= 3) {
+      targetValue = (0, import_safe.parseMaybeNumber)(raw.payload[1]);
+      duration = import_safe.Duration.parseReport(raw.payload[2]);
+    }
+    return new MultilevelSwitchCCReport_1({
+      nodeId: ctx.sourceNodeId,
+      currentValue,
+      targetValue,
+      duration
+    });
+  }
+  targetValue;
+  duration;
+  currentValue;
+  serialize(ctx) {
+    this.payload = import_safe2.Bytes.from([
+      this.currentValue ?? 254,
+      this.targetValue ?? 254,
+      (this.duration ?? import_safe.Duration.default()).serializeReport()
+    ]);
+    return super.serialize(ctx);
+  }
+  toLogEntry(ctx) {
+    const message = {
+      "current value": (0, import_safe.maybeUnknownToString)(this.currentValue)
+    };
+    if (this.targetValue !== import_safe.NOT_KNOWN && this.duration) {
+      message["target value"] = (0, import_safe.maybeUnknownToString)(this.targetValue);
+      message.duration = this.duration.toString();
+    }
+    return {
+      ...super.toLogEntry(ctx),
+      message
+    };
+  }
+};
+__decorate([
+  (0, import_CommandClassDecorators.ccValue)(MultilevelSwitchCCValues.targetValue)
+], MultilevelSwitchCCReport.prototype, "targetValue", void 0);
+__decorate([
+  (0, import_CommandClassDecorators.ccValue)(MultilevelSwitchCCValues.duration)
+], MultilevelSwitchCCReport.prototype, "duration", void 0);
+__decorate([
+  (0, import_CommandClassDecorators.ccValue)(MultilevelSwitchCCValues.currentValue)
+], MultilevelSwitchCCReport.prototype, "currentValue", void 0);
+MultilevelSwitchCCReport = MultilevelSwitchCCReport_1 = __decorate([
+  (0, import_CommandClassDecorators.CCCommand)(import_Types.MultilevelSwitchCommand.Report)
+], MultilevelSwitchCCReport);
+let MultilevelSwitchCCGet = class MultilevelSwitchCCGet2 extends MultilevelSwitchCC {
+};
+MultilevelSwitchCCGet = __decorate([
+  (0, import_CommandClassDecorators.CCCommand)(import_Types.MultilevelSwitchCommand.Get),
+  (0, import_CommandClassDecorators.expectedCCResponse)(MultilevelSwitchCCReport)
+], MultilevelSwitchCCGet);
+let MultilevelSwitchCCStartLevelChange = MultilevelSwitchCCStartLevelChange_1 = class MultilevelSwitchCCStartLevelChange2 extends MultilevelSwitchCC {
+  constructor(options) {
+    super(options);
+    this.duration = import_safe.Duration.from(options.duration);
+    this.ignoreStartLevel = options.ignoreStartLevel;
+    this.startLevel = options.startLevel ?? 0;
+    this.direction = options.direction;
+  }
+  static from(raw, ctx) {
+    (0, import_safe.validatePayload)(raw.payload.length >= 2);
+    const ignoreStartLevel = !!((raw.payload[0] & 32) >>> 5);
+    const direction = (raw.payload[0] & 64) >>> 6 ? "down" : "up";
+    const startLevel = raw.payload[1];
+    let duration;
+    if (raw.payload.length >= 3) {
+      duration = import_safe.Duration.parseSet(raw.payload[2]);
+    }
+    return new MultilevelSwitchCCStartLevelChange_1({
+      nodeId: ctx.sourceNodeId,
+      ignoreStartLevel,
+      direction,
+      startLevel,
+      duration
+    });
+  }
+  duration;
+  startLevel;
+  ignoreStartLevel;
+  direction;
+  serialize(ctx) {
+    const controlByte = import_Types.LevelChangeDirection[this.direction] << 6 | (this.ignoreStartLevel ? 32 : 0);
+    this.payload = import_safe2.Bytes.from([
+      controlByte,
+      this.startLevel,
+      (this.duration ?? import_safe.Duration.default()).serializeSet()
+    ]);
+    const ccVersion = (0, import_CommandClass.getEffectiveCCVersion)(ctx, this);
+    if (ccVersion < 2 && ctx.getDeviceConfig?.(this.nodeId)?.compat?.encodeCCsUsingTargetVersion) {
+      this.payload = this.payload.subarray(0, -1);
+    }
+    return super.serialize(ctx);
+  }
+  toLogEntry(ctx) {
+    const message = {
+      startLevel: `${this.startLevel}${this.ignoreStartLevel ? " (ignored)" : ""}`,
+      direction: this.direction
+    };
+    if (this.duration) {
+      message.duration = this.duration.toString();
+    }
+    return {
+      ...super.toLogEntry(ctx),
+      message
+    };
+  }
+};
+MultilevelSwitchCCStartLevelChange = MultilevelSwitchCCStartLevelChange_1 = __decorate([
+  (0, import_CommandClassDecorators.CCCommand)(import_Types.MultilevelSwitchCommand.StartLevelChange),
+  (0, import_CommandClassDecorators.useSupervision)()
+], MultilevelSwitchCCStartLevelChange);
+let MultilevelSwitchCCStopLevelChange = class MultilevelSwitchCCStopLevelChange2 extends MultilevelSwitchCC {
+};
+MultilevelSwitchCCStopLevelChange = __decorate([
+  (0, import_CommandClassDecorators.CCCommand)(import_Types.MultilevelSwitchCommand.StopLevelChange),
+  (0, import_CommandClassDecorators.useSupervision)()
+], MultilevelSwitchCCStopLevelChange);
+let MultilevelSwitchCCSupportedReport = MultilevelSwitchCCSupportedReport_1 = class MultilevelSwitchCCSupportedReport2 extends MultilevelSwitchCC {
+  constructor(options) {
+    super(options);
+    this.switchType = options.switchType;
+  }
+  static from(raw, ctx) {
+    (0, import_safe.validatePayload)(raw.payload.length >= 1);
+    const switchType = raw.payload[0] & 31;
+    return new MultilevelSwitchCCSupportedReport_1({
+      nodeId: ctx.sourceNodeId,
+      switchType
+    });
+  }
+  // This is the primary switch type. We're not supporting secondary switch types
+  switchType;
+  persistValues(ctx) {
+    if (!super.persistValues(ctx))
+      return false;
+    this.createMetadataForLevelChangeActions(ctx, this.switchType);
+    return true;
+  }
+  serialize(ctx) {
+    this.payload = import_safe2.Bytes.from([this.switchType & 31]);
+    return super.serialize(ctx);
+  }
+  toLogEntry(ctx) {
+    return {
+      ...super.toLogEntry(ctx),
+      message: {
+        "switch type": (0, import_safe3.getEnumMemberName)(import_Types.SwitchType, this.switchType)
+      }
+    };
+  }
+};
+__decorate([
+  (0, import_CommandClassDecorators.ccValue)(MultilevelSwitchCCValues.switchType)
+], MultilevelSwitchCCSupportedReport.prototype, "switchType", void 0);
+MultilevelSwitchCCSupportedReport = MultilevelSwitchCCSupportedReport_1 = __decorate([
+  (0, import_CommandClassDecorators.CCCommand)(import_Types.MultilevelSwitchCommand.SupportedReport)
+], MultilevelSwitchCCSupportedReport);
+let MultilevelSwitchCCSupportedGet = class MultilevelSwitchCCSupportedGet2 extends MultilevelSwitchCC {
+};
+MultilevelSwitchCCSupportedGet = __decorate([
+  (0, import_CommandClassDecorators.CCCommand)(import_Types.MultilevelSwitchCommand.SupportedGet),
+  (0, import_CommandClassDecorators.expectedCCResponse)(MultilevelSwitchCCSupportedReport)
+], MultilevelSwitchCCSupportedGet);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MultilevelSwitchCC,
+  MultilevelSwitchCCAPI,
+  MultilevelSwitchCCGet,
+  MultilevelSwitchCCReport,
+  MultilevelSwitchCCSet,
+  MultilevelSwitchCCStartLevelChange,
+  MultilevelSwitchCCStopLevelChange,
+  MultilevelSwitchCCSupportedGet,
+  MultilevelSwitchCCSupportedReport,
+  MultilevelSwitchCCValues
+});
+//# sourceMappingURL=MultilevelSwitchCC.js.map