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

package/build/cjs/cc/IrrigationCC.js

@@ -0,0 +1,1978 @@
+"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 IrrigationCC_exports = {};
+__export(IrrigationCC_exports, {
+  IrrigationCC: () => IrrigationCC,
+  IrrigationCCAPI: () => IrrigationCCAPI,
+  IrrigationCCSystemConfigGet: () => IrrigationCCSystemConfigGet,
+  IrrigationCCSystemConfigReport: () => IrrigationCCSystemConfigReport,
+  IrrigationCCSystemConfigSet: () => IrrigationCCSystemConfigSet,
+  IrrigationCCSystemInfoGet: () => IrrigationCCSystemInfoGet,
+  IrrigationCCSystemInfoReport: () => IrrigationCCSystemInfoReport,
+  IrrigationCCSystemShutoff: () => IrrigationCCSystemShutoff,
+  IrrigationCCSystemStatusGet: () => IrrigationCCSystemStatusGet,
+  IrrigationCCSystemStatusReport: () => IrrigationCCSystemStatusReport,
+  IrrigationCCValues: () => IrrigationCCValues,
+  IrrigationCCValveConfigGet: () => IrrigationCCValveConfigGet,
+  IrrigationCCValveConfigReport: () => IrrigationCCValveConfigReport,
+  IrrigationCCValveConfigSet: () => IrrigationCCValveConfigSet,
+  IrrigationCCValveInfoGet: () => IrrigationCCValveInfoGet,
+  IrrigationCCValveInfoReport: () => IrrigationCCValveInfoReport,
+  IrrigationCCValveRun: () => IrrigationCCValveRun,
+  IrrigationCCValveTableGet: () => IrrigationCCValveTableGet,
+  IrrigationCCValveTableReport: () => IrrigationCCValveTableReport,
+  IrrigationCCValveTableRun: () => IrrigationCCValveTableRun,
+  IrrigationCCValveTableSet: () => IrrigationCCValveTableSet
+});
+module.exports = __toCommonJS(IrrigationCC_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_strings = require("alcalzone-shared/strings/index.js");
+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 IrrigationCC_1, IrrigationCCSystemInfoReport_1, IrrigationCCSystemStatusReport_1, IrrigationCCSystemConfigReport_1, IrrigationCCValveInfoReport_1, IrrigationCCValveConfigReport_1, IrrigationCCValveTableReport_1;
+function __assertType(argName, typeName, boundHasError) {
+  const { ZWaveError: ZWaveError2, ZWaveErrorCodes: ZWaveErrorCodes2 } = require("@zwave-js/core");
+  if (boundHasError()) {
+    throw new ZWaveError2(typeName ? `${argName} is not a ${typeName}` : `${argName} has the wrong type`, ZWaveErrorCodes2.Argument_Invalid);
+  }
+}
+const __assertType__IrrigationCCSystemConfigSetOptions = ($o) => {
+  function _number($o2) {
+    return typeof $o2 !== "number" ? {} : null;
+  }
+  function su__2__3_eu($o2) {
+    return ![0, 1].includes($o2) ? {} : null;
+  }
+  function _0($o2) {
+    if (typeof $o2 !== "object" || $o2 === null || Array.isArray($o2))
+      return {};
+    if ("masterValveDelay" in $o2 && $o2["masterValveDelay"] !== void 0) {
+      const error = _number($o2["masterValveDelay"]);
+      if (error)
+        return error;
+    } else
+      return {};
+    if ("highPressureThreshold" in $o2 && $o2["highPressureThreshold"] !== void 0) {
+      const error = _number($o2["highPressureThreshold"]);
+      if (error)
+        return error;
+    } else
+      return {};
+    if ("lowPressureThreshold" in $o2 && $o2["lowPressureThreshold"] !== void 0) {
+      const error = _number($o2["lowPressureThreshold"]);
+      if (error)
+        return error;
+    } else
+      return {};
+    if ("rainSensorPolarity" in $o2 && $o2["rainSensorPolarity"] !== void 0) {
+      const error = su__2__3_eu($o2["rainSensorPolarity"]);
+      if (error)
+        return error;
+    }
+    if ("moistureSensorPolarity" in $o2 && $o2["moistureSensorPolarity"] !== void 0) {
+      const error = su__2__3_eu($o2["moistureSensorPolarity"]);
+      if (error)
+        return error;
+    }
+    return null;
+  }
+  return _0($o);
+};
+const __assertType__ValveId = ($o) => {
+  function _number($o2) {
+    return typeof $o2 !== "number" ? {} : null;
+  }
+  function _2($o2) {
+    return $o2 !== "master" ? {} : null;
+  }
+  function su__number__2_eu($o2) {
+    const conditions = [_number, _2];
+    for (const condition of conditions) {
+      const error = condition($o2);
+      if (!error)
+        return null;
+    }
+    return {};
+  }
+  return su__number__2_eu($o);
+};
+const __assertType__IrrigationCCValveConfigSetOptions = ($o) => {
+  function _number($o2) {
+    return typeof $o2 !== "number" ? {} : null;
+  }
+  function _3($o2) {
+    return $o2 !== "master" ? {} : null;
+  }
+  function su__number__3_eu($o2) {
+    const conditions = [_number, _3];
+    for (const condition of conditions) {
+      const error = condition($o2);
+      if (!error)
+        return null;
+    }
+    return {};
+  }
+  function _boolean($o2) {
+    return typeof $o2 !== "boolean" ? {} : null;
+  }
+  function _0($o2) {
+    if (typeof $o2 !== "object" || $o2 === null || Array.isArray($o2))
+      return {};
+    if ("valveId" in $o2 && $o2["valveId"] !== void 0) {
+      const error = su__number__3_eu($o2["valveId"]);
+      if (error)
+        return error;
+    } else
+      return {};
+    if ("nominalCurrentHighThreshold" in $o2 && $o2["nominalCurrentHighThreshold"] !== void 0) {
+      const error = _number($o2["nominalCurrentHighThreshold"]);
+      if (error)
+        return error;
+    } else
+      return {};
+    if ("nominalCurrentLowThreshold" in $o2 && $o2["nominalCurrentLowThreshold"] !== void 0) {
+      const error = _number($o2["nominalCurrentLowThreshold"]);
+      if (error)
+        return error;
+    } else
+      return {};
+    if ("maximumFlow" in $o2 && $o2["maximumFlow"] !== void 0) {
+      const error = _number($o2["maximumFlow"]);
+      if (error)
+        return error;
+    } else
+      return {};
+    if ("highFlowThreshold" in $o2 && $o2["highFlowThreshold"] !== void 0) {
+      const error = _number($o2["highFlowThreshold"]);
+      if (error)
+        return error;
+    } else
+      return {};
+    if ("lowFlowThreshold" in $o2 && $o2["lowFlowThreshold"] !== void 0) {
+      const error = _number($o2["lowFlowThreshold"]);
+      if (error)
+        return error;
+    } else
+      return {};
+    if ("useRainSensor" in $o2 && $o2["useRainSensor"] !== void 0) {
+      const error = _boolean($o2["useRainSensor"]);
+      if (error)
+        return error;
+    } else
+      return {};
+    if ("useMoistureSensor" in $o2 && $o2["useMoistureSensor"] !== void 0) {
+      const error = _boolean($o2["useMoistureSensor"]);
+      if (error)
+        return error;
+    } else
+      return {};
+    return null;
+  }
+  return _0($o);
+};
+const __assertType__number = ($o) => {
+  function _number($o2) {
+    return typeof $o2 !== "number" ? {} : null;
+  }
+  return _number($o);
+};
+const __assertType__sa__2_ea_2 = ($o) => {
+  function _number($o2) {
+    return typeof $o2 !== "number" ? {} : null;
+  }
+  function _2($o2) {
+    if (typeof $o2 !== "object" || $o2 === null || Array.isArray($o2))
+      return {};
+    if ("valveId" in $o2 && $o2["valveId"] !== void 0) {
+      const error = _number($o2["valveId"]);
+      if (error)
+        return error;
+    } else
+      return {};
+    if ("duration" in $o2 && $o2["duration"] !== void 0) {
+      const error = _number($o2["duration"]);
+      if (error)
+        return error;
+    } else
+      return {};
+    return null;
+  }
+  function sa__2_ea_2($o2) {
+    if (!Array.isArray($o2))
+      return {};
+    for (let i = 0; i < $o2.length; i++) {
+      const error = _2($o2[i]);
+      if (error)
+        return error;
+    }
+    return null;
+  }
+  return sa__2_ea_2($o);
+};
+const __assertType__sa__number_ea_2 = ($o) => {
+  function _number($o2) {
+    return typeof $o2 !== "number" ? {} : null;
+  }
+  function sa__number_ea_2($o2) {
+    if (!Array.isArray($o2))
+      return {};
+    for (let i = 0; i < $o2.length; i++) {
+      const error = _number($o2[i]);
+      if (error)
+        return error;
+    }
+    return null;
+  }
+  return sa__number_ea_2($o);
+};
+const IrrigationCCValues = Object.freeze({
+  ...import_Values.V.defineStaticCCValues(import_safe.CommandClasses.Irrigation, {
+    ...import_Values.V.staticProperty("numValves", void 0, { internal: true }),
+    ...import_Values.V.staticProperty("numValveTables", void 0, { internal: true }),
+    ...import_Values.V.staticProperty("supportsMasterValve", void 0, {
+      internal: true
+    }),
+    ...import_Values.V.staticProperty("maxValveTableSize", void 0, { internal: true }),
+    ...import_Values.V.staticProperty("systemVoltage", {
+      ...import_safe.ValueMetadata.ReadOnlyUInt8,
+      label: "System voltage",
+      unit: "V"
+    }),
+    ...import_Values.V.staticProperty("masterValveDelay", {
+      ...import_safe.ValueMetadata.UInt8,
+      label: "Master valve delay",
+      description: "The delay between turning on the master valve and turning on any zone valve",
+      unit: "seconds"
+    }),
+    ...import_Values.V.staticProperty("flowSensorActive", {
+      ...import_safe.ValueMetadata.ReadOnlyBoolean,
+      label: "Flow sensor active"
+    }),
+    ...import_Values.V.staticProperty("pressureSensorActive", {
+      ...import_safe.ValueMetadata.ReadOnlyBoolean,
+      label: "Pressure sensor active"
+    }),
+    ...import_Values.V.staticProperty("rainSensorActive", {
+      ...import_safe.ValueMetadata.ReadOnlyBoolean,
+      label: "Rain sensor attached and active"
+    }),
+    ...import_Values.V.staticProperty("rainSensorPolarity", {
+      ...import_safe.ValueMetadata.Number,
+      label: "Rain sensor polarity",
+      min: 0,
+      max: 1,
+      states: (0, import_safe.enumValuesToMetadataStates)(import_Types.IrrigationSensorPolarity)
+    }),
+    ...import_Values.V.staticProperty("moistureSensorActive", {
+      ...import_safe.ValueMetadata.ReadOnlyBoolean,
+      label: "Moisture sensor attached and active"
+    }),
+    ...import_Values.V.staticProperty("moistureSensorPolarity", {
+      ...import_safe.ValueMetadata.Number,
+      label: "Moisture sensor polarity",
+      min: 0,
+      max: 1,
+      states: (0, import_safe.enumValuesToMetadataStates)(import_Types.IrrigationSensorPolarity)
+    }),
+    ...import_Values.V.staticProperty("flow", {
+      ...import_safe.ValueMetadata.ReadOnlyNumber,
+      label: "Flow",
+      unit: "l/h"
+    }),
+    ...import_Values.V.staticProperty("pressure", {
+      ...import_safe.ValueMetadata.ReadOnlyNumber,
+      label: "Pressure",
+      unit: "kPa"
+    }),
+    ...import_Values.V.staticProperty("shutoffDuration", {
+      ...import_safe.ValueMetadata.ReadOnlyUInt8,
+      label: "Remaining shutoff duration",
+      unit: "hours"
+    }),
+    ...import_Values.V.staticProperty("errorNotProgrammed", {
+      ...import_safe.ValueMetadata.ReadOnlyBoolean,
+      label: "Error: device not programmed"
+    }),
+    ...import_Values.V.staticProperty("errorEmergencyShutdown", {
+      ...import_safe.ValueMetadata.ReadOnlyBoolean,
+      label: "Error: emergency shutdown"
+    }),
+    ...import_Values.V.staticProperty("errorHighPressure", {
+      ...import_safe.ValueMetadata.ReadOnlyBoolean,
+      label: "Error: high pressure"
+    }),
+    ...import_Values.V.staticProperty("highPressureThreshold", {
+      ...import_safe.ValueMetadata.Number,
+      label: "High pressure threshold",
+      unit: "kPa"
+    }),
+    ...import_Values.V.staticProperty("errorLowPressure", {
+      ...import_safe.ValueMetadata.ReadOnlyBoolean,
+      label: "Error: low pressure"
+    }),
+    ...import_Values.V.staticProperty("lowPressureThreshold", {
+      ...import_safe.ValueMetadata.Number,
+      label: "Low pressure threshold",
+      unit: "kPa"
+    }),
+    ...import_Values.V.staticProperty("errorValve", {
+      ...import_safe.ValueMetadata.ReadOnlyBoolean,
+      label: "Error: valve reporting error"
+    }),
+    ...import_Values.V.staticProperty("masterValveOpen", {
+      ...import_safe.ValueMetadata.ReadOnlyBoolean,
+      label: "Master valve is open"
+    }),
+    ...import_Values.V.staticProperty("firstOpenZoneId", {
+      ...import_safe.ValueMetadata.ReadOnlyNumber,
+      label: "First open zone valve ID"
+    }),
+    ...import_Values.V.staticPropertyWithName("shutoffSystem", "shutoff", {
+      ...import_safe.ValueMetadata.WriteOnlyBoolean,
+      label: `Shutoff system`,
+      states: {
+        true: "Shutoff"
+      }
+    })
+  }),
+  ...import_Values.V.defineDynamicCCValues(import_safe.CommandClasses.Irrigation, {
+    ...import_Values.V.dynamicPropertyAndKeyWithName("valveConnected", (valveId) => valveId, "valveConnected", ({ property, propertyKey }) => (typeof property === "number" || property === "master") && propertyKey === "valveConnected", (valveId) => ({
+      ...import_safe.ValueMetadata.ReadOnlyBoolean,
+      label: `${valveIdToMetadataPrefix(valveId)}: Connected`
+    })),
+    ...import_Values.V.dynamicPropertyAndKeyWithName("nominalCurrent", (valveId) => valveId, "nominalCurrent", ({ property, propertyKey }) => (typeof property === "number" || property === "master") && propertyKey === "nominalCurrent", (valveId) => ({
+      ...import_safe.ValueMetadata.ReadOnlyBoolean,
+      label: `${valveIdToMetadataPrefix(valveId)}: Nominal current`,
+      unit: "mA"
+    })),
+    ...import_Values.V.dynamicPropertyAndKeyWithName("nominalCurrentHighThreshold", (valveId) => valveId, "nominalCurrentHighThreshold", ({ property, propertyKey }) => (typeof property === "number" || property === "master") && propertyKey === "nominalCurrentHighThreshold", (valveId) => ({
+      ...import_safe.ValueMetadata.Number,
+      label: `${valveIdToMetadataPrefix(valveId)}: Nominal current - high threshold`,
+      min: 0,
+      max: 2550,
+      unit: "mA"
+    })),
+    ...import_Values.V.dynamicPropertyAndKeyWithName("nominalCurrentLowThreshold", (valveId) => valveId, "nominalCurrentLowThreshold", ({ property, propertyKey }) => (typeof property === "number" || property === "master") && propertyKey === "nominalCurrentLowThreshold", (valveId) => ({
+      ...import_safe.ValueMetadata.Number,
+      label: `${valveIdToMetadataPrefix(valveId)}: Nominal current - low threshold`,
+      min: 0,
+      max: 2550,
+      unit: "mA"
+    })),
+    ...import_Values.V.dynamicPropertyAndKeyWithName("errorShortCircuit", (valveId) => valveId, "errorShortCircuit", ({ property, propertyKey }) => (typeof property === "number" || property === "master") && propertyKey === "errorShortCircuit", (valveId) => ({
+      ...import_safe.ValueMetadata.ReadOnlyBoolean,
+      label: `${valveIdToMetadataPrefix(valveId)}: Error - Short circuit detected`
+    })),
+    ...import_Values.V.dynamicPropertyAndKeyWithName("errorHighCurrent", (valveId) => valveId, "errorHighCurrent", ({ property, propertyKey }) => (typeof property === "number" || property === "master") && propertyKey === "errorHighCurrent", (valveId) => ({
+      ...import_safe.ValueMetadata.ReadOnlyBoolean,
+      label: `${valveIdToMetadataPrefix(valveId)}: Error - Current above high threshold`
+    })),
+    ...import_Values.V.dynamicPropertyAndKeyWithName("errorLowCurrent", (valveId) => valveId, "errorLowCurrent", ({ property, propertyKey }) => (typeof property === "number" || property === "master") && propertyKey === "errorLowCurrent", (valveId) => ({
+      ...import_safe.ValueMetadata.ReadOnlyBoolean,
+      label: `${valveIdToMetadataPrefix(valveId)}: Error - Current below low threshold`
+    })),
+    ...import_Values.V.dynamicPropertyAndKeyWithName("maximumFlow", (valveId) => valveId, "maximumFlow", ({ property, propertyKey }) => (typeof property === "number" || property === "master") && propertyKey === "maximumFlow", (valveId) => ({
+      ...import_safe.ValueMetadata.Number,
+      label: `${valveIdToMetadataPrefix(valveId)}: Maximum flow`,
+      min: 0,
+      unit: "l/h"
+    })),
+    ...import_Values.V.dynamicPropertyAndKeyWithName("errorMaximumFlow", (valveId) => valveId, "errorMaximumFlow", ({ property, propertyKey }) => (typeof property === "number" || property === "master") && propertyKey === "errorMaximumFlow", (valveId) => ({
+      ...import_safe.ValueMetadata.ReadOnlyBoolean,
+      label: `${valveIdToMetadataPrefix(valveId)}: Error - Maximum flow detected`
+    })),
+    ...import_Values.V.dynamicPropertyAndKeyWithName("highFlowThreshold", (valveId) => valveId, "highFlowThreshold", ({ property, propertyKey }) => (typeof property === "number" || property === "master") && propertyKey === "highFlowThreshold", (valveId) => ({
+      ...import_safe.ValueMetadata.Number,
+      label: `${valveIdToMetadataPrefix(valveId)}: High flow threshold`,
+      min: 0,
+      unit: "l/h"
+    })),
+    ...import_Values.V.dynamicPropertyAndKeyWithName("errorHighFlow", (valveId) => valveId, "errorHighFlow", ({ property, propertyKey }) => (typeof property === "number" || property === "master") && propertyKey === "errorHighFlow", (valveId) => ({
+      ...import_safe.ValueMetadata.ReadOnlyBoolean,
+      label: `${valveIdToMetadataPrefix(valveId)}: Error - Flow above high threshold`
+    })),
+    ...import_Values.V.dynamicPropertyAndKeyWithName("lowFlowThreshold", (valveId) => valveId, "lowFlowThreshold", ({ property, propertyKey }) => (typeof property === "number" || property === "master") && propertyKey === "lowFlowThreshold", (valveId) => ({
+      ...import_safe.ValueMetadata.Number,
+      label: `${valveIdToMetadataPrefix(valveId)}: Low flow threshold`,
+      min: 0,
+      unit: "l/h"
+    })),
+    ...import_Values.V.dynamicPropertyAndKeyWithName("errorLowFlow", (valveId) => valveId, "errorLowFlow", ({ property, propertyKey }) => (typeof property === "number" || property === "master") && propertyKey === "errorLowFlow", (valveId) => ({
+      ...import_safe.ValueMetadata.ReadOnlyBoolean,
+      label: `${valveIdToMetadataPrefix(valveId)}: Error - Flow below high threshold`
+    })),
+    ...import_Values.V.dynamicPropertyAndKeyWithName("useRainSensor", (valveId) => valveId, "useRainSensor", ({ property, propertyKey }) => (typeof property === "number" || property === "master") && propertyKey === "useRainSensor", (valveId) => ({
+      ...import_safe.ValueMetadata.Boolean,
+      label: `${valveIdToMetadataPrefix(valveId)}: Use rain sensor`
+    })),
+    ...import_Values.V.dynamicPropertyAndKeyWithName("useMoistureSensor", (valveId) => valveId, "useMoistureSensor", ({ property, propertyKey }) => (typeof property === "number" || property === "master") && propertyKey === "useMoistureSensor", (valveId) => ({
+      ...import_safe.ValueMetadata.Boolean,
+      label: `${valveIdToMetadataPrefix(valveId)}: Use moisture sensor`
+    })),
+    ...import_Values.V.dynamicPropertyAndKeyWithName("valveRunDuration", (valveId) => valveId, "duration", ({ property, propertyKey }) => (typeof property === "number" || property === "master") && propertyKey === "duration", (valveId) => ({
+      ...import_safe.ValueMetadata.UInt16,
+      label: `${valveIdToMetadataPrefix(valveId)}: Run duration`,
+      min: 1,
+      unit: "s"
+    })),
+    ...import_Values.V.dynamicPropertyAndKeyWithName("valveRunStartStop", (valveId) => valveId, "startStop", ({ property, propertyKey }) => (typeof property === "number" || property === "master") && propertyKey === "startStop", (valveId) => ({
+      ...import_safe.ValueMetadata.Boolean,
+      label: `${valveIdToMetadataPrefix(valveId)}: Start/Stop`,
+      states: {
+        true: "Start",
+        false: "Stop"
+      }
+    }))
+  })
+});
+function valveIdToMetadataPrefix(valveId) {
+  if (valveId === "master")
+    return "Master valve";
+  return `Valve ${(0, import_strings.padStart)(valveId.toString(), 3, "0")}`;
+}
+const systemConfigProperties = [
+  "masterValveDelay",
+  "highPressureThreshold",
+  "lowPressureThreshold",
+  "rainSensorPolarity",
+  "moistureSensorPolarity"
+];
+const valveConfigPropertyKeys = [
+  "nominalCurrentHighThreshold",
+  "nominalCurrentLowThreshold",
+  "maximumFlow",
+  "highFlowThreshold",
+  "lowFlowThreshold",
+  "useRainSensor",
+  "useMoistureSensor"
+];
+let IrrigationCCAPI = class IrrigationCCAPI2 extends import_API.CCAPI {
+  supportsCommand(cmd) {
+    switch (cmd) {
+      case import_Types.IrrigationCommand.SystemInfoGet:
+      case import_Types.IrrigationCommand.SystemStatusGet:
+      case import_Types.IrrigationCommand.SystemConfigSet:
+      case import_Types.IrrigationCommand.SystemConfigGet:
+      case import_Types.IrrigationCommand.ValveInfoGet:
+      case import_Types.IrrigationCommand.ValveConfigSet:
+      case import_Types.IrrigationCommand.ValveConfigGet:
+      case import_Types.IrrigationCommand.ValveRun:
+      case import_Types.IrrigationCommand.ValveTableSet:
+      case import_Types.IrrigationCommand.ValveTableGet:
+      case import_Types.IrrigationCommand.ValveTableRun:
+      case import_Types.IrrigationCommand.SystemShutoff:
+        return true;
+    }
+    return super.supportsCommand(cmd);
+  }
+  // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
+  async getSystemInfo() {
+    this.assertSupportsCommand(import_Types.IrrigationCommand, import_Types.IrrigationCommand.SystemInfoGet);
+    const cc = new IrrigationCCSystemInfoGet({
+      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, [
+        "numValves",
+        "numValveTables",
+        "supportsMasterValve",
+        "maxValveTableSize"
+      ]);
+    }
+  }
+  // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
+  async getSystemStatus() {
+    this.assertSupportsCommand(import_Types.IrrigationCommand, import_Types.IrrigationCommand.SystemStatusGet);
+    const cc = new IrrigationCCSystemStatusGet({
+      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, [
+        "systemVoltage",
+        "flowSensorActive",
+        "pressureSensorActive",
+        "rainSensorActive",
+        "moistureSensorActive",
+        "flow",
+        "pressure",
+        "shutoffDuration",
+        "errorNotProgrammed",
+        "errorEmergencyShutdown",
+        "errorHighPressure",
+        "errorLowPressure",
+        "errorValve",
+        "masterValveOpen",
+        "firstOpenZoneId"
+      ]);
+    }
+  }
+  // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
+  async getSystemConfig() {
+    this.assertSupportsCommand(import_Types.IrrigationCommand, import_Types.IrrigationCommand.SystemConfigGet);
+    const cc = new IrrigationCCSystemConfigGet({
+      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, [
+        "masterValveDelay",
+        "highPressureThreshold",
+        "lowPressureThreshold",
+        "rainSensorPolarity",
+        "moistureSensorPolarity"
+      ]);
+    }
+  }
+  async setSystemConfig(config) {
+    __assertType("config", "IrrigationCCSystemConfigSetOptions", __assertType__IrrigationCCSystemConfigSetOptions.bind(void 0, config));
+    this.assertSupportsCommand(import_Types.IrrigationCommand, import_Types.IrrigationCommand.SystemConfigSet);
+    const cc = new IrrigationCCSystemConfigSet({
+      nodeId: this.endpoint.nodeId,
+      endpointIndex: this.endpoint.index,
+      ...config
+    });
+    return this.host.sendCommand(cc, this.commandOptions);
+  }
+  async getValveInfo(valveId) {
+    __assertType("valveId", "ValveId", __assertType__ValveId.bind(void 0, valveId));
+    this.assertSupportsCommand(import_Types.IrrigationCommand, import_Types.IrrigationCommand.ValveInfoGet);
+    const cc = new IrrigationCCValveInfoGet({
+      nodeId: this.endpoint.nodeId,
+      endpointIndex: this.endpoint.index,
+      valveId
+    });
+    const response = await this.host.sendCommand(cc, this.commandOptions);
+    if (response) {
+      return (0, import_safe3.pick)(response, [
+        "connected",
+        "nominalCurrent",
+        "errorShortCircuit",
+        "errorHighCurrent",
+        "errorLowCurrent",
+        "errorMaximumFlow",
+        "errorHighFlow",
+        "errorLowFlow"
+      ]);
+    }
+  }
+  async setValveConfig(options) {
+    __assertType("options", "IrrigationCCValveConfigSetOptions", __assertType__IrrigationCCValveConfigSetOptions.bind(void 0, options));
+    this.assertSupportsCommand(import_Types.IrrigationCommand, import_Types.IrrigationCommand.ValveConfigSet);
+    const cc = new IrrigationCCValveConfigSet({
+      nodeId: this.endpoint.nodeId,
+      endpointIndex: this.endpoint.index,
+      ...options
+    });
+    return this.host.sendCommand(cc, this.commandOptions);
+  }
+  async getValveConfig(valveId) {
+    __assertType("valveId", "ValveId", __assertType__ValveId.bind(void 0, valveId));
+    this.assertSupportsCommand(import_Types.IrrigationCommand, import_Types.IrrigationCommand.ValveConfigGet);
+    const cc = new IrrigationCCValveConfigGet({
+      nodeId: this.endpoint.nodeId,
+      endpointIndex: this.endpoint.index,
+      valveId
+    });
+    const response = await this.host.sendCommand(cc, this.commandOptions);
+    if (response) {
+      return (0, import_safe3.pick)(response, [
+        "nominalCurrentHighThreshold",
+        "nominalCurrentLowThreshold",
+        "maximumFlow",
+        "highFlowThreshold",
+        "lowFlowThreshold",
+        "useRainSensor",
+        "useMoistureSensor"
+      ]);
+    }
+  }
+  async runValve(valveId, duration) {
+    __assertType("valveId", "ValveId", __assertType__ValveId.bind(void 0, valveId));
+    __assertType("duration", "number", __assertType__number.bind(void 0, duration));
+    this.assertSupportsCommand(import_Types.IrrigationCommand, import_Types.IrrigationCommand.ValveRun);
+    const cc = new IrrigationCCValveRun({
+      nodeId: this.endpoint.nodeId,
+      endpointIndex: this.endpoint.index,
+      valveId,
+      duration
+    });
+    return this.host.sendCommand(cc, this.commandOptions);
+  }
+  shutoffValve(valveId) {
+    __assertType("valveId", "ValveId", __assertType__ValveId.bind(void 0, valveId));
+    return this.runValve(valveId, 0);
+  }
+  async setValveTable(tableId, entries) {
+    __assertType("tableId", "number", __assertType__number.bind(void 0, tableId));
+    __assertType("entries", void 0, __assertType__sa__2_ea_2.bind(void 0, entries));
+    this.assertSupportsCommand(import_Types.IrrigationCommand, import_Types.IrrigationCommand.ValveTableSet);
+    if (!this.endpoint.virtual) {
+      const maxValveTableSize = IrrigationCC.getMaxValveTableSizeCached(this.host, this.endpoint);
+      if (maxValveTableSize != void 0 && entries.length > maxValveTableSize) {
+        throw new import_safe.ZWaveError(`The number of valve table entries must not exceed ${maxValveTableSize}.`, import_safe.ZWaveErrorCodes.Argument_Invalid);
+      }
+    }
+    const cc = new IrrigationCCValveTableSet({
+      nodeId: this.endpoint.nodeId,
+      endpointIndex: this.endpoint.index,
+      tableId,
+      entries
+    });
+    return this.host.sendCommand(cc, this.commandOptions);
+  }
+  async getValveTable(tableId) {
+    __assertType("tableId", "number", __assertType__number.bind(void 0, tableId));
+    this.assertSupportsCommand(import_Types.IrrigationCommand, import_Types.IrrigationCommand.ValveTableGet);
+    const cc = new IrrigationCCValveTableGet({
+      nodeId: this.endpoint.nodeId,
+      endpointIndex: this.endpoint.index,
+      tableId
+    });
+    const response = await this.host.sendCommand(cc, this.commandOptions);
+    if (response) {
+      return response?.entries;
+    }
+  }
+  async runTables(tableIDs) {
+    __assertType("tableIDs", void 0, __assertType__sa__number_ea_2.bind(void 0, tableIDs));
+    this.assertSupportsCommand(import_Types.IrrigationCommand, import_Types.IrrigationCommand.ValveTableRun);
+    const cc = new IrrigationCCValveTableRun({
+      nodeId: this.endpoint.nodeId,
+      endpointIndex: this.endpoint.index,
+      tableIDs
+    });
+    return this.host.sendCommand(cc, this.commandOptions);
+  }
+  /**
+   * Shuts off the entire system for the given duration.
+   * @param duration Shutoff duration in hours. A value of 255 will shut off the entire system permanently and prevents schedules from running.
+   */
+  async shutoffSystem(duration) {
+    __assertType("duration", "number", __assertType__number.bind(void 0, duration));
+    this.assertSupportsCommand(import_Types.IrrigationCommand, import_Types.IrrigationCommand.SystemShutoff);
+    const cc = new IrrigationCCSystemShutoff({
+      nodeId: this.endpoint.nodeId,
+      endpointIndex: this.endpoint.index,
+      duration
+    });
+    return this.host.sendCommand(cc, this.commandOptions);
+  }
+  /** Shuts off the entire system permanently and prevents schedules from running */
+  shutoffSystemPermanently() {
+    return this.shutoffSystem(255);
+  }
+  get [import_API.SET_VALUE]() {
+    return async function({ property, propertyKey }, value) {
+      const valueDB = this.getValueDB();
+      if (systemConfigProperties.includes(property)) {
+        const options = {};
+        for (const prop of systemConfigProperties) {
+          if (prop === property)
+            continue;
+          const valueId = {
+            commandClass: this.ccId,
+            endpoint: this.endpoint.index,
+            property: prop
+          };
+          const cachedVal = valueDB.getValue(valueId);
+          if (cachedVal == void 0) {
+            throw new import_safe.ZWaveError(`The "${property}" property cannot be changed before ${prop} is known!`, import_safe.ZWaveErrorCodes.Argument_Invalid);
+          }
+          options[prop] = cachedVal;
+        }
+        options[property] = value;
+        return this.setSystemConfig(options);
+      } else if (property === "shutoff") {
+        return this.shutoffSystem(0);
+      } else if (property === "master" || typeof property === "number" && property >= 1) {
+        if (propertyKey == void 0) {
+          (0, import_API.throwMissingPropertyKey)(this.ccId, property);
+        }
+        if (valveConfigPropertyKeys.includes(propertyKey)) {
+          const options = {
+            valveId: property
+          };
+          for (const prop of valveConfigPropertyKeys) {
+            if (prop === propertyKey)
+              continue;
+            const valueId = {
+              commandClass: this.ccId,
+              endpoint: this.endpoint.index,
+              property,
+              propertyKey: prop
+            };
+            const cachedVal = valueDB.getValue(valueId);
+            if (cachedVal == void 0) {
+              throw new import_safe.ZWaveError(`The "${property}_${propertyKey}" property cannot be changed before ${property}_${prop} is known!`, import_safe.ZWaveErrorCodes.Argument_Invalid);
+            }
+            options[prop] = cachedVal;
+          }
+          options[propertyKey] = value;
+          return this.setValveConfig(options);
+        } else if (propertyKey === "duration") {
+          return;
+        } else if (propertyKey === "startStop") {
+          if (typeof value !== "boolean") {
+            (0, import_API.throwWrongValueType)(this.ccId, property, "boolean", typeof value);
+          }
+          if (value) {
+            const duration = valueDB.getValue(IrrigationCCValues.valveRunDuration(property).endpoint(this.endpoint.index));
+            if (duration == void 0) {
+              throw new import_safe.ZWaveError(`Cannot start a valve run without specifying a duration first!`, import_safe.ZWaveErrorCodes.Argument_Invalid);
+            }
+            return this.runValve(property, duration);
+          } else {
+            return this.shutoffValve(property);
+          }
+        } else {
+          (0, import_API.throwUnsupportedPropertyKey)(this.ccId, property, propertyKey);
+        }
+      }
+    };
+  }
+  get [import_API.POLL_VALUE]() {
+    return async function({ property, propertyKey }) {
+      switch (property) {
+        case "systemVoltage":
+        case "flowSensorActive":
+        case "pressureSensorActive":
+        case "rainSensorActive":
+        case "moistureSensorActive":
+        case "flow":
+        case "pressure":
+        case "shutoffDuration":
+        case "errorNotProgrammed":
+        case "errorEmergencyShutdown":
+        case "errorHighPressure":
+        case "errorLowPressure":
+        case "errorValve":
+        case "masterValveOpen":
+        case "firstOpenZoneId":
+          return (await this.getSystemStatus())?.[property];
+        case "masterValveDelay":
+        case "highPressureThreshold":
+        case "lowPressureThreshold":
+        case "rainSensorPolarity":
+        case "moistureSensorPolarity":
+          return (await this.getSystemConfig())?.[property];
+      }
+      if (property === "master" || typeof property === "number" && property >= 1) {
+        switch (propertyKey) {
+          case "connected":
+          case "nominalCurrent":
+          case "errorShortCircuit":
+          case "errorHighCurrent":
+          case "errorLowCurrent":
+          case "errorMaximumFlow":
+          case "errorHighFlow":
+          case "errorLowFlow":
+            return (await this.getValveInfo(property))?.[propertyKey];
+          case "nominalCurrentHighThreshold":
+          case "nominalCurrentLowThreshold":
+          case "maximumFlow":
+          case "highFlowThreshold":
+          case "lowFlowThreshold":
+          case "useRainSensor":
+          case "useMoistureSensor":
+            return (await this.getValveConfig(property))?.[propertyKey];
+          case void 0:
+            (0, import_API.throwMissingPropertyKey)(this.ccId, property);
+          default:
+            (0, import_API.throwUnsupportedPropertyKey)(this.ccId, property, propertyKey);
+        }
+      }
+      (0, import_API.throwUnsupportedProperty)(this.ccId, property);
+    };
+  }
+};
+IrrigationCCAPI = __decorate([
+  (0, import_CommandClassDecorators.API)(import_safe.CommandClasses.Irrigation)
+], IrrigationCCAPI);
+let IrrigationCC = IrrigationCC_1 = class IrrigationCC2 extends import_CommandClass.CommandClass {
+  /**
+   * Returns the maximum number of valve table entries reported by the node.
+   * This only works AFTER the node has been interviewed.
+   */
+  static getMaxValveTableSizeCached(ctx, endpoint) {
+    return ctx.getValueDB(endpoint.nodeId).getValue(IrrigationCCValues.maxValveTableSize.endpoint(endpoint.index));
+  }
+  /**
+   * Returns the number of zone valves reported by the node.
+   * This only works AFTER the node has been interviewed.
+   */
+  static getNumValvesCached(ctx, endpoint) {
+    return ctx.getValueDB(endpoint.nodeId).getValue(IrrigationCCValues.numValves.endpoint(endpoint.index));
+  }
+  /**
+   * Returns whether the node supports a master valve
+   * This only works AFTER the node has been interviewed.
+   */
+  static supportsMasterValveCached(ctx, endpoint) {
+    return !!ctx.getValueDB(endpoint.nodeId).getValue(IrrigationCCValues.supportsMasterValve.endpoint(endpoint.index));
+  }
+  async interview(ctx) {
+    const node = this.getNode(ctx);
+    const endpoint = this.getEndpoint(ctx);
+    const api = import_API.CCAPI.create(import_safe.CommandClasses.Irrigation, ctx, endpoint).withOptions({
+      priority: import_safe.MessagePriority.NodeQuery
+    });
+    ctx.logNode(node.id, {
+      endpoint: this.endpointIndex,
+      message: `Interviewing ${this.ccName}...`,
+      direction: "none"
+    });
+    ctx.logNode(node.id, {
+      endpoint: this.endpointIndex,
+      message: "Querying irrigation system info...",
+      direction: "outbound"
+    });
+    const systemInfo = await api.getSystemInfo();
+    if (!systemInfo) {
+      ctx.logNode(node.id, {
+        endpoint: this.endpointIndex,
+        message: "Time out while querying irrigation system info, skipping interview...",
+        level: "warn"
+      });
+      return;
+    }
+    const logMessage = `received irrigation system info:
+supports master valve: ${systemInfo.supportsMasterValve}
+no. of valves:         ${systemInfo.numValves}
+no. of valve tables:   ${systemInfo.numValveTables}
+max. valve table size: ${systemInfo.maxValveTableSize}`;
+    ctx.logNode(node.id, {
+      endpoint: this.endpointIndex,
+      message: logMessage,
+      direction: "inbound"
+    });
+    for (let i = 1; i <= systemInfo.numValves; i++) {
+      this.ensureMetadata(ctx, IrrigationCCValues.valveRunDuration(i));
+      this.ensureMetadata(ctx, IrrigationCCValues.valveRunStartStop(i));
+    }
+    this.ensureMetadata(ctx, IrrigationCCValues.shutoffSystem);
+    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.Irrigation, ctx, endpoint).withOptions({
+      priority: import_safe.MessagePriority.NodeQuery
+    });
+    ctx.logNode(node.id, {
+      endpoint: this.endpointIndex,
+      message: "Querying irrigation system configuration...",
+      direction: "outbound"
+    });
+    const systemConfig = await api.getSystemConfig();
+    if (systemConfig) {
+      let logMessage = `received irrigation system configuration:
+master valve delay:       ${systemConfig.masterValveDelay} seconds
+high pressure threshold:  ${systemConfig.highPressureThreshold} kPa
+low pressure threshold:   ${systemConfig.lowPressureThreshold} kPa`;
+      if (systemConfig.rainSensorPolarity != void 0) {
+        logMessage += `
+rain sensor polarity:     ${(0, import_safe3.getEnumMemberName)(import_Types.IrrigationSensorPolarity, systemConfig.rainSensorPolarity)}`;
+      }
+      if (systemConfig.moistureSensorPolarity != void 0) {
+        logMessage += `
+moisture sensor polarity: ${(0, import_safe3.getEnumMemberName)(import_Types.IrrigationSensorPolarity, systemConfig.moistureSensorPolarity)}`;
+      }
+      ctx.logNode(node.id, {
+        endpoint: this.endpointIndex,
+        message: logMessage,
+        direction: "inbound"
+      });
+    }
+    ctx.logNode(node.id, {
+      endpoint: this.endpointIndex,
+      message: "Querying irrigation system status...",
+      direction: "outbound"
+    });
+    await api.getSystemStatus();
+    if (IrrigationCC_1.supportsMasterValveCached(ctx, endpoint)) {
+      ctx.logNode(node.id, {
+        endpoint: this.endpointIndex,
+        message: "Querying master valve configuration...",
+        direction: "outbound"
+      });
+      await api.getValveConfig("master");
+      ctx.logNode(node.id, {
+        endpoint: this.endpointIndex,
+        message: "Querying master valve status...",
+        direction: "outbound"
+      });
+      await api.getValveInfo("master");
+    }
+    for (let i = 1; i <= (IrrigationCC_1.getNumValvesCached(ctx, endpoint) ?? 0); i++) {
+      ctx.logNode(node.id, {
+        endpoint: this.endpointIndex,
+        message: `Querying configuration for valve ${(0, import_strings.padStart)(i.toString(), 3, "0")}...`,
+        direction: "outbound"
+      });
+      await api.getValveConfig(i);
+      ctx.logNode(node.id, {
+        endpoint: this.endpointIndex,
+        message: `Querying status for valve ${(0, import_strings.padStart)(i.toString(), 3, "0")}...`,
+        direction: "outbound"
+      });
+      await api.getValveInfo(i);
+    }
+  }
+  translateProperty(ctx, property, propertyKey) {
+    if (property === "master") {
+      return "Master valve";
+    } else if (typeof property === "number") {
+      return `Valve ${(0, import_strings.padStart)(property.toString(), 3, "0")}`;
+    }
+    return super.translateProperty(ctx, property, propertyKey);
+  }
+};
+IrrigationCC = IrrigationCC_1 = __decorate([
+  (0, import_CommandClassDecorators.commandClass)(import_safe.CommandClasses.Irrigation),
+  (0, import_CommandClassDecorators.implementedVersion)(1),
+  (0, import_CommandClassDecorators.ccValues)(IrrigationCCValues)
+], IrrigationCC);
+let IrrigationCCSystemInfoReport = IrrigationCCSystemInfoReport_1 = class IrrigationCCSystemInfoReport2 extends IrrigationCC {
+  constructor(options) {
+    super(options);
+    this.supportsMasterValve = options.supportsMasterValve;
+    this.numValves = options.numValves;
+    this.numValveTables = options.numValveTables;
+    this.maxValveTableSize = options.maxValveTableSize;
+  }
+  static from(raw, ctx) {
+    (0, import_safe.validatePayload)(raw.payload.length >= 4);
+    const supportsMasterValve = !!(raw.payload[0] & 1);
+    const numValves = raw.payload[1];
+    const numValveTables = raw.payload[2];
+    const maxValveTableSize = raw.payload[3] & 15;
+    return new IrrigationCCSystemInfoReport_1({
+      nodeId: ctx.sourceNodeId,
+      supportsMasterValve,
+      numValves,
+      numValveTables,
+      maxValveTableSize
+    });
+  }
+  numValves;
+  numValveTables;
+  supportsMasterValve;
+  maxValveTableSize;
+  toLogEntry(ctx) {
+    return {
+      ...super.toLogEntry(ctx),
+      message: {
+        "supports master valve": this.supportsMasterValve,
+        "no. of valves": this.numValves,
+        "no. of valve tables": this.numValveTables,
+        "max. valve table size": this.maxValveTableSize
+      }
+    };
+  }
+};
+__decorate([
+  (0, import_CommandClassDecorators.ccValue)(IrrigationCCValues.numValves)
+], IrrigationCCSystemInfoReport.prototype, "numValves", void 0);
+__decorate([
+  (0, import_CommandClassDecorators.ccValue)(IrrigationCCValues.numValveTables)
+], IrrigationCCSystemInfoReport.prototype, "numValveTables", void 0);
+__decorate([
+  (0, import_CommandClassDecorators.ccValue)(IrrigationCCValues.supportsMasterValve)
+], IrrigationCCSystemInfoReport.prototype, "supportsMasterValve", void 0);
+__decorate([
+  (0, import_CommandClassDecorators.ccValue)(IrrigationCCValues.maxValveTableSize)
+], IrrigationCCSystemInfoReport.prototype, "maxValveTableSize", void 0);
+IrrigationCCSystemInfoReport = IrrigationCCSystemInfoReport_1 = __decorate([
+  (0, import_CommandClassDecorators.CCCommand)(import_Types.IrrigationCommand.SystemInfoReport)
+], IrrigationCCSystemInfoReport);
+let IrrigationCCSystemInfoGet = class IrrigationCCSystemInfoGet2 extends IrrigationCC {
+};
+IrrigationCCSystemInfoGet = __decorate([
+  (0, import_CommandClassDecorators.CCCommand)(import_Types.IrrigationCommand.SystemInfoGet),
+  (0, import_CommandClassDecorators.expectedCCResponse)(IrrigationCCSystemInfoReport)
+], IrrigationCCSystemInfoGet);
+let IrrigationCCSystemStatusReport = IrrigationCCSystemStatusReport_1 = class IrrigationCCSystemStatusReport2 extends IrrigationCC {
+  constructor(options) {
+    super(options);
+    this.systemVoltage = options.systemVoltage;
+    this.flowSensorActive = options.flowSensorActive;
+    this.pressureSensorActive = options.pressureSensorActive;
+    this.rainSensorActive = options.rainSensorActive;
+    this.moistureSensorActive = options.moistureSensorActive;
+    this.flow = options.flow;
+    this.pressure = options.pressure;
+    this.shutoffDuration = options.shutoffDuration;
+    this.errorNotProgrammed = options.errorNotProgrammed;
+    this.errorEmergencyShutdown = options.errorEmergencyShutdown;
+    this.errorHighPressure = options.errorHighPressure;
+    this.errorLowPressure = options.errorLowPressure;
+    this.errorValve = options.errorValve;
+    this.masterValveOpen = options.masterValveOpen;
+    this.firstOpenZoneId = options.firstOpenZoneId;
+  }
+  static from(raw, ctx) {
+    (0, import_safe.validatePayload)(raw.payload.length >= 2);
+    const systemVoltage = raw.payload[0];
+    const flowSensorActive = !!(raw.payload[1] & 1);
+    const pressureSensorActive = !!(raw.payload[1] & 2);
+    const rainSensorActive = !!(raw.payload[1] & 4);
+    const moistureSensorActive = !!(raw.payload[1] & 8);
+    let offset = 2;
+    let flow;
+    {
+      const { value, scale, bytesRead } = (0, import_safe.parseFloatWithScale)(raw.payload.subarray(offset));
+      (0, import_safe.validatePayload)(scale === 0);
+      if (flowSensorActive)
+        flow = value;
+      offset += bytesRead;
+    }
+    let pressure;
+    {
+      const { value, scale, bytesRead } = (0, import_safe.parseFloatWithScale)(raw.payload.subarray(offset));
+      (0, import_safe.validatePayload)(scale === 0);
+      if (pressureSensorActive)
+        pressure = value;
+      offset += bytesRead;
+    }
+    (0, import_safe.validatePayload)(raw.payload.length >= offset + 4);
+    const shutoffDuration = raw.payload[offset];
+    const errorNotProgrammed = !!(raw.payload[offset + 1] & 1);
+    const errorEmergencyShutdown = !!(raw.payload[offset + 1] & 2);
+    const errorHighPressure = !!(raw.payload[offset + 1] & 4);
+    const errorLowPressure = !!(raw.payload[offset + 1] & 8);
+    const errorValve = !!(raw.payload[offset + 1] & 16);
+    const masterValveOpen = !!(raw.payload[offset + 2] & 1);
+    let firstOpenZoneId;
+    if (raw.payload[offset + 3]) {
+      firstOpenZoneId = raw.payload[offset + 3];
+    }
+    return new IrrigationCCSystemStatusReport_1({
+      nodeId: ctx.sourceNodeId,
+      systemVoltage,
+      flowSensorActive,
+      pressureSensorActive,
+      rainSensorActive,
+      moistureSensorActive,
+      flow,
+      pressure,
+      shutoffDuration,
+      errorNotProgrammed,
+      errorEmergencyShutdown,
+      errorHighPressure,
+      errorLowPressure,
+      errorValve,
+      masterValveOpen,
+      firstOpenZoneId
+    });
+  }
+  systemVoltage;
+  flowSensorActive;
+  pressureSensorActive;
+  rainSensorActive;
+  moistureSensorActive;
+  flow;
+  pressure;
+  shutoffDuration;
+  errorNotProgrammed;
+  errorEmergencyShutdown;
+  errorHighPressure;
+  errorLowPressure;
+  errorValve;
+  masterValveOpen;
+  firstOpenZoneId;
+  toLogEntry(ctx) {
+    const message = {
+      "system voltage": `${this.systemVoltage} V`,
+      "active sensors": [
+        this.flowSensorActive ? "flow" : void 0,
+        this.pressureSensorActive ? "pressure" : void 0,
+        this.rainSensorActive ? "rain" : void 0,
+        this.moistureSensorActive ? "moisture" : void 0
+      ].filter(Boolean).join(", ")
+    };
+    if (this.flow != void 0) {
+      message.flow = `${this.flow} l/h`;
+    }
+    if (this.pressure != void 0) {
+      message.pressure = `${this.pressure} kPa`;
+    }
+    message["remaining shutoff duration"] = `${this.shutoffDuration} hours`;
+    message["master valve status"] = this.masterValveOpen ? "open" : "closed";
+    message["first open zone valve"] = this.firstOpenZoneId || "none";
+    const errors = [
+      this.errorNotProgrammed ? "device not programmed" : void 0,
+      this.errorEmergencyShutdown ? "emergency shutdown" : void 0,
+      this.errorHighPressure ? "high pressure threshold triggered" : void 0,
+      this.errorLowPressure ? "low pressure threshold triggered" : void 0,
+      this.errorValve ? "a valve or the master valve has an error" : void 0
+    ].filter(Boolean);
+    if (errors.length > 0) {
+      message.errors = errors.map((e) => `
+\xB7 ${e}`).join("");
+    }
+    return {
+      ...super.toLogEntry(ctx),
+      message
+    };
+  }
+};
+__decorate([
+  (0, import_CommandClassDecorators.ccValue)(IrrigationCCValues.systemVoltage)
+], IrrigationCCSystemStatusReport.prototype, "systemVoltage", void 0);
+__decorate([
+  (0, import_CommandClassDecorators.ccValue)(IrrigationCCValues.flowSensorActive)
+], IrrigationCCSystemStatusReport.prototype, "flowSensorActive", void 0);
+__decorate([
+  (0, import_CommandClassDecorators.ccValue)(IrrigationCCValues.pressureSensorActive)
+], IrrigationCCSystemStatusReport.prototype, "pressureSensorActive", void 0);
+__decorate([
+  (0, import_CommandClassDecorators.ccValue)(IrrigationCCValues.rainSensorActive)
+], IrrigationCCSystemStatusReport.prototype, "rainSensorActive", void 0);
+__decorate([
+  (0, import_CommandClassDecorators.ccValue)(IrrigationCCValues.moistureSensorActive)
+], IrrigationCCSystemStatusReport.prototype, "moistureSensorActive", void 0);
+__decorate([
+  (0, import_CommandClassDecorators.ccValue)(IrrigationCCValues.flow)
+], IrrigationCCSystemStatusReport.prototype, "flow", void 0);
+__decorate([
+  (0, import_CommandClassDecorators.ccValue)(IrrigationCCValues.pressure)
+], IrrigationCCSystemStatusReport.prototype, "pressure", void 0);
+__decorate([
+  (0, import_CommandClassDecorators.ccValue)(IrrigationCCValues.shutoffDuration)
+], IrrigationCCSystemStatusReport.prototype, "shutoffDuration", void 0);
+__decorate([
+  (0, import_CommandClassDecorators.ccValue)(IrrigationCCValues.errorNotProgrammed)
+], IrrigationCCSystemStatusReport.prototype, "errorNotProgrammed", void 0);
+__decorate([
+  (0, import_CommandClassDecorators.ccValue)(IrrigationCCValues.errorEmergencyShutdown)
+], IrrigationCCSystemStatusReport.prototype, "errorEmergencyShutdown", void 0);
+__decorate([
+  (0, import_CommandClassDecorators.ccValue)(IrrigationCCValues.errorHighPressure)
+], IrrigationCCSystemStatusReport.prototype, "errorHighPressure", void 0);
+__decorate([
+  (0, import_CommandClassDecorators.ccValue)(IrrigationCCValues.errorLowPressure)
+], IrrigationCCSystemStatusReport.prototype, "errorLowPressure", void 0);
+__decorate([
+  (0, import_CommandClassDecorators.ccValue)(IrrigationCCValues.errorValve)
+], IrrigationCCSystemStatusReport.prototype, "errorValve", void 0);
+__decorate([
+  (0, import_CommandClassDecorators.ccValue)(IrrigationCCValues.masterValveOpen)
+], IrrigationCCSystemStatusReport.prototype, "masterValveOpen", void 0);
+__decorate([
+  (0, import_CommandClassDecorators.ccValue)(IrrigationCCValues.firstOpenZoneId)
+], IrrigationCCSystemStatusReport.prototype, "firstOpenZoneId", void 0);
+IrrigationCCSystemStatusReport = IrrigationCCSystemStatusReport_1 = __decorate([
+  (0, import_CommandClassDecorators.CCCommand)(import_Types.IrrigationCommand.SystemStatusReport)
+], IrrigationCCSystemStatusReport);
+let IrrigationCCSystemStatusGet = class IrrigationCCSystemStatusGet2 extends IrrigationCC {
+};
+IrrigationCCSystemStatusGet = __decorate([
+  (0, import_CommandClassDecorators.CCCommand)(import_Types.IrrigationCommand.SystemStatusGet),
+  (0, import_CommandClassDecorators.expectedCCResponse)(IrrigationCCSystemStatusReport)
+], IrrigationCCSystemStatusGet);
+let IrrigationCCSystemConfigSet = class IrrigationCCSystemConfigSet2 extends IrrigationCC {
+  constructor(options) {
+    super(options);
+    this.masterValveDelay = options.masterValveDelay;
+    this.highPressureThreshold = options.highPressureThreshold;
+    this.lowPressureThreshold = options.lowPressureThreshold;
+    this.rainSensorPolarity = options.rainSensorPolarity;
+    this.moistureSensorPolarity = options.moistureSensorPolarity;
+  }
+  static from(_raw, _ctx) {
+    throw new import_safe.ZWaveError(`${this.name}: deserialization not implemented`, import_safe.ZWaveErrorCodes.Deserialization_NotImplemented);
+  }
+  masterValveDelay;
+  highPressureThreshold;
+  lowPressureThreshold;
+  rainSensorPolarity;
+  moistureSensorPolarity;
+  serialize(ctx) {
+    let polarity = 0;
+    if (this.rainSensorPolarity != void 0)
+      polarity |= 1;
+    if (this.moistureSensorPolarity != void 0)
+      polarity |= 2;
+    if (this.rainSensorPolarity == void 0 && this.moistureSensorPolarity == void 0) {
+      polarity |= 128;
+    }
+    this.payload = import_safe2.Bytes.concat([
+      import_safe2.Bytes.from([this.masterValveDelay]),
+      (0, import_safe.encodeFloatWithScale)(
+        this.highPressureThreshold,
+        0
+        /* kPa */
+      ),
+      (0, import_safe.encodeFloatWithScale)(
+        this.lowPressureThreshold,
+        0
+        /* kPa */
+      ),
+      import_safe2.Bytes.from([polarity])
+    ]);
+    return super.serialize(ctx);
+  }
+  toLogEntry(ctx) {
+    const message = {
+      "master valve delay": `${this.masterValveDelay} s`,
+      "high pressure threshold": `${this.highPressureThreshold} kPa`,
+      "low pressure threshold": `${this.lowPressureThreshold} kPa`
+    };
+    if (this.rainSensorPolarity != void 0) {
+      message["rain sensor polarity"] = (0, import_safe3.getEnumMemberName)(import_Types.IrrigationSensorPolarity, this.rainSensorPolarity);
+    }
+    if (this.moistureSensorPolarity != void 0) {
+      message["moisture sensor polarity"] = (0, import_safe3.getEnumMemberName)(import_Types.IrrigationSensorPolarity, this.moistureSensorPolarity);
+    }
+    return {
+      ...super.toLogEntry(ctx),
+      message
+    };
+  }
+};
+IrrigationCCSystemConfigSet = __decorate([
+  (0, import_CommandClassDecorators.CCCommand)(import_Types.IrrigationCommand.SystemConfigSet),
+  (0, import_CommandClassDecorators.useSupervision)()
+], IrrigationCCSystemConfigSet);
+let IrrigationCCSystemConfigReport = IrrigationCCSystemConfigReport_1 = class IrrigationCCSystemConfigReport2 extends IrrigationCC {
+  constructor(options) {
+    super(options);
+    this.masterValveDelay = options.masterValveDelay;
+    this.highPressureThreshold = options.highPressureThreshold;
+    this.lowPressureThreshold = options.lowPressureThreshold;
+    this.rainSensorPolarity = options.rainSensorPolarity;
+    this.moistureSensorPolarity = options.moistureSensorPolarity;
+  }
+  static from(raw, ctx) {
+    (0, import_safe.validatePayload)(raw.payload.length >= 2);
+    const masterValveDelay = raw.payload[0];
+    let offset = 1;
+    let highPressureThreshold;
+    {
+      const { value, scale, bytesRead } = (0, import_safe.parseFloatWithScale)(raw.payload.subarray(offset));
+      (0, import_safe.validatePayload)(
+        scale === 0
+        /* kPa */
+      );
+      highPressureThreshold = value;
+      offset += bytesRead;
+    }
+    let lowPressureThreshold;
+    {
+      const { value, scale, bytesRead } = (0, import_safe.parseFloatWithScale)(raw.payload.subarray(offset));
+      (0, import_safe.validatePayload)(
+        scale === 0
+        /* kPa */
+      );
+      lowPressureThreshold = value;
+      offset += bytesRead;
+    }
+    (0, import_safe.validatePayload)(raw.payload.length >= offset + 1);
+    const polarity = raw.payload[offset];
+    let rainSensorPolarity;
+    let moistureSensorPolarity;
+    if (!!(polarity & 128)) {
+      rainSensorPolarity = polarity & 1;
+      moistureSensorPolarity = (polarity & 2) >>> 1;
+    }
+    return new IrrigationCCSystemConfigReport_1({
+      nodeId: ctx.sourceNodeId,
+      masterValveDelay,
+      highPressureThreshold,
+      lowPressureThreshold,
+      rainSensorPolarity,
+      moistureSensorPolarity
+    });
+  }
+  masterValveDelay;
+  highPressureThreshold;
+  lowPressureThreshold;
+  rainSensorPolarity;
+  moistureSensorPolarity;
+  toLogEntry(ctx) {
+    const message = {
+      "master valve delay": `${this.masterValveDelay} s`,
+      "high pressure threshold": `${this.highPressureThreshold} kPa`,
+      "low pressure threshold": `${this.lowPressureThreshold} kPa`
+    };
+    if (this.rainSensorPolarity != void 0) {
+      message["rain sensor polarity"] = (0, import_safe3.getEnumMemberName)(import_Types.IrrigationSensorPolarity, this.rainSensorPolarity);
+    }
+    if (this.moistureSensorPolarity != void 0) {
+      message["moisture sensor polarity"] = (0, import_safe3.getEnumMemberName)(import_Types.IrrigationSensorPolarity, this.moistureSensorPolarity);
+    }
+    return {
+      ...super.toLogEntry(ctx),
+      message
+    };
+  }
+};
+__decorate([
+  (0, import_CommandClassDecorators.ccValue)(IrrigationCCValues.masterValveDelay)
+], IrrigationCCSystemConfigReport.prototype, "masterValveDelay", void 0);
+__decorate([
+  (0, import_CommandClassDecorators.ccValue)(IrrigationCCValues.highPressureThreshold)
+], IrrigationCCSystemConfigReport.prototype, "highPressureThreshold", void 0);
+__decorate([
+  (0, import_CommandClassDecorators.ccValue)(IrrigationCCValues.lowPressureThreshold)
+], IrrigationCCSystemConfigReport.prototype, "lowPressureThreshold", void 0);
+__decorate([
+  (0, import_CommandClassDecorators.ccValue)(IrrigationCCValues.rainSensorPolarity)
+], IrrigationCCSystemConfigReport.prototype, "rainSensorPolarity", void 0);
+__decorate([
+  (0, import_CommandClassDecorators.ccValue)(IrrigationCCValues.moistureSensorPolarity)
+], IrrigationCCSystemConfigReport.prototype, "moistureSensorPolarity", void 0);
+IrrigationCCSystemConfigReport = IrrigationCCSystemConfigReport_1 = __decorate([
+  (0, import_CommandClassDecorators.CCCommand)(import_Types.IrrigationCommand.SystemConfigReport)
+], IrrigationCCSystemConfigReport);
+let IrrigationCCSystemConfigGet = class IrrigationCCSystemConfigGet2 extends IrrigationCC {
+};
+IrrigationCCSystemConfigGet = __decorate([
+  (0, import_CommandClassDecorators.CCCommand)(import_Types.IrrigationCommand.SystemConfigGet),
+  (0, import_CommandClassDecorators.expectedCCResponse)(IrrigationCCSystemConfigReport)
+], IrrigationCCSystemConfigGet);
+let IrrigationCCValveInfoReport = IrrigationCCValveInfoReport_1 = class IrrigationCCValveInfoReport2 extends IrrigationCC {
+  constructor(options) {
+    super(options);
+    this.valveId = options.valveId;
+    this.connected = options.connected;
+    this.nominalCurrent = options.nominalCurrent;
+    this.errorShortCircuit = options.errorShortCircuit;
+    this.errorHighCurrent = options.errorHighCurrent;
+    this.errorLowCurrent = options.errorLowCurrent;
+    this.errorMaximumFlow = options.errorMaximumFlow;
+    this.errorHighFlow = options.errorHighFlow;
+    this.errorLowFlow = options.errorLowFlow;
+  }
+  static from(raw, ctx) {
+    (0, import_safe.validatePayload)(raw.payload.length >= 4);
+    let valveId;
+    if ((raw.payload[0] & 1) === import_Types.ValveType.MasterValve) {
+      valveId = "master";
+    } else {
+      valveId = raw.payload[1];
+    }
+    const connected = !!(raw.payload[0] & 2);
+    const nominalCurrent = 10 * raw.payload[2];
+    const errorShortCircuit = !!(raw.payload[3] & 1);
+    const errorHighCurrent = !!(raw.payload[3] & 2);
+    const errorLowCurrent = !!(raw.payload[3] & 4);
+    let errorMaximumFlow;
+    let errorHighFlow;
+    let errorLowFlow;
+    if (valveId === "master") {
+      errorMaximumFlow = !!(raw.payload[3] & 8);
+      errorHighFlow = !!(raw.payload[3] & 16);
+      errorLowFlow = !!(raw.payload[3] & 32);
+    }
+    return new IrrigationCCValveInfoReport_1({
+      nodeId: ctx.sourceNodeId,
+      valveId,
+      connected,
+      nominalCurrent,
+      errorShortCircuit,
+      errorHighCurrent,
+      errorLowCurrent,
+      errorMaximumFlow,
+      errorHighFlow,
+      errorLowFlow
+    });
+  }
+  valveId;
+  connected;
+  nominalCurrent;
+  errorShortCircuit;
+  errorHighCurrent;
+  errorLowCurrent;
+  errorMaximumFlow;
+  errorHighFlow;
+  errorLowFlow;
+  persistValues(ctx) {
+    if (!super.persistValues(ctx))
+      return false;
+    const valveConnectedValue = IrrigationCCValues.valveConnected(this.valveId);
+    this.ensureMetadata(ctx, valveConnectedValue);
+    this.setValue(ctx, valveConnectedValue, this.connected);
+    const nominalCurrentValue = IrrigationCCValues.nominalCurrent(this.valveId);
+    this.ensureMetadata(ctx, nominalCurrentValue);
+    this.setValue(ctx, nominalCurrentValue, this.nominalCurrent);
+    const errorShortCircuitValue = IrrigationCCValues.errorShortCircuit(this.valveId);
+    this.ensureMetadata(ctx, errorShortCircuitValue);
+    this.setValue(ctx, errorShortCircuitValue, this.errorShortCircuit);
+    const errorHighCurrentValue = IrrigationCCValues.errorHighCurrent(this.valveId);
+    this.ensureMetadata(ctx, errorHighCurrentValue);
+    this.setValue(ctx, errorHighCurrentValue, this.errorHighCurrent);
+    const errorLowCurrentValue = IrrigationCCValues.errorLowCurrent(this.valveId);
+    this.ensureMetadata(ctx, errorLowCurrentValue);
+    this.setValue(ctx, errorLowCurrentValue, this.errorLowCurrent);
+    if (this.errorMaximumFlow != void 0) {
+      const errorMaximumFlowValue = IrrigationCCValues.errorMaximumFlow(this.valveId);
+      this.ensureMetadata(ctx, errorMaximumFlowValue);
+      this.setValue(ctx, errorMaximumFlowValue, this.errorMaximumFlow);
+    }
+    if (this.errorHighFlow != void 0) {
+      const errorHighFlowValue = IrrigationCCValues.errorHighFlow(this.valveId);
+      this.ensureMetadata(ctx, errorHighFlowValue);
+      this.setValue(ctx, errorHighFlowValue, this.errorHighFlow);
+    }
+    if (this.errorLowFlow != void 0) {
+      const errorLowFlowValue = IrrigationCCValues.errorLowFlow(this.valveId);
+      this.ensureMetadata(ctx, errorLowFlowValue);
+      this.setValue(ctx, errorLowFlowValue, this.errorLowFlow);
+    }
+    return true;
+  }
+  toLogEntry(ctx) {
+    const message = {
+      "valve ID": this.valveId,
+      connected: this.connected,
+      "nominal current": `${this.nominalCurrent} mA`
+    };
+    const errors = [
+      this.errorShortCircuit ? "short circuit" : void 0,
+      this.errorHighCurrent ? "current above high threshold" : void 0,
+      this.errorLowCurrent ? "current below low threshold" : void 0,
+      this.errorMaximumFlow ? "maximum flow" : void 0,
+      this.errorHighFlow ? "flow above high threshold" : void 0,
+      this.errorLowFlow ? "flow below low threshold" : void 0
+    ].filter(Boolean);
+    if (errors.length > 0) {
+      message.errors = errors.map((e) => `
+\xB7 ${e}`).join("");
+    }
+    return {
+      ...super.toLogEntry(ctx),
+      message
+    };
+  }
+};
+IrrigationCCValveInfoReport = IrrigationCCValveInfoReport_1 = __decorate([
+  (0, import_CommandClassDecorators.CCCommand)(import_Types.IrrigationCommand.ValveInfoReport)
+], IrrigationCCValveInfoReport);
+function testResponseForIrrigationCommandWithValveId(sent, received) {
+  return received.valveId === sent.valveId;
+}
+let IrrigationCCValveInfoGet = class IrrigationCCValveInfoGet2 extends IrrigationCC {
+  constructor(options) {
+    super(options);
+    this.valveId = options.valveId;
+  }
+  static from(_raw, _ctx) {
+    throw new import_safe.ZWaveError(`${this.name}: deserialization not implemented`, import_safe.ZWaveErrorCodes.Deserialization_NotImplemented);
+  }
+  valveId;
+  serialize(ctx) {
+    this.payload = import_safe2.Bytes.from([
+      this.valveId === "master" ? 1 : 0,
+      this.valveId === "master" ? 1 : this.valveId || 1
+    ]);
+    return super.serialize(ctx);
+  }
+  toLogEntry(ctx) {
+    return {
+      ...super.toLogEntry(ctx),
+      message: {
+        "valve ID": this.valveId
+      }
+    };
+  }
+};
+IrrigationCCValveInfoGet = __decorate([
+  (0, import_CommandClassDecorators.CCCommand)(import_Types.IrrigationCommand.ValveInfoGet),
+  (0, import_CommandClassDecorators.expectedCCResponse)(IrrigationCCValveInfoReport, testResponseForIrrigationCommandWithValveId)
+], IrrigationCCValveInfoGet);
+let IrrigationCCValveConfigSet = class IrrigationCCValveConfigSet2 extends IrrigationCC {
+  constructor(options) {
+    super(options);
+    this.valveId = options.valveId;
+    this.nominalCurrentHighThreshold = options.nominalCurrentHighThreshold;
+    this.nominalCurrentLowThreshold = options.nominalCurrentLowThreshold;
+    this.maximumFlow = options.maximumFlow;
+    this.highFlowThreshold = options.highFlowThreshold;
+    this.lowFlowThreshold = options.lowFlowThreshold;
+    this.useRainSensor = options.useRainSensor;
+    this.useMoistureSensor = options.useMoistureSensor;
+  }
+  static from(_raw, _ctx) {
+    throw new import_safe.ZWaveError(`${this.name}: deserialization not implemented`, import_safe.ZWaveErrorCodes.Deserialization_NotImplemented);
+  }
+  valveId;
+  nominalCurrentHighThreshold;
+  nominalCurrentLowThreshold;
+  maximumFlow;
+  highFlowThreshold;
+  lowFlowThreshold;
+  useRainSensor;
+  useMoistureSensor;
+  serialize(ctx) {
+    this.payload = import_safe2.Bytes.concat([
+      import_safe2.Bytes.from([
+        this.valveId === "master" ? 1 : 0,
+        this.valveId === "master" ? 1 : this.valveId || 1,
+        Math.floor(this.nominalCurrentHighThreshold / 10),
+        Math.floor(this.nominalCurrentLowThreshold / 10)
+      ]),
+      (0, import_safe.encodeFloatWithScale)(
+        this.maximumFlow,
+        0
+        /* l/h */
+      ),
+      (0, import_safe.encodeFloatWithScale)(
+        this.highFlowThreshold,
+        0
+        /* l/h */
+      ),
+      (0, import_safe.encodeFloatWithScale)(
+        this.lowFlowThreshold,
+        0
+        /* l/h */
+      ),
+      import_safe2.Bytes.from([
+        (this.useRainSensor ? 1 : 0) | (this.useMoistureSensor ? 2 : 0)
+      ])
+    ]);
+    return super.serialize(ctx);
+  }
+  toLogEntry(ctx) {
+    return {
+      ...super.toLogEntry(ctx),
+      message: {
+        "valve ID": this.valveId,
+        "nominal current high threshold": `${this.nominalCurrentHighThreshold} mA`,
+        "nominal current low threshold": `${this.nominalCurrentLowThreshold} mA`,
+        "maximum flow": `${this.maximumFlow} l/h`,
+        "high flow threshold": `${this.highFlowThreshold} l/h`,
+        "low flow threshold": `${this.lowFlowThreshold} l/h`,
+        "use rain sensor": this.useRainSensor,
+        "use moisture sensor": this.useMoistureSensor
+      }
+    };
+  }
+};
+IrrigationCCValveConfigSet = __decorate([
+  (0, import_CommandClassDecorators.CCCommand)(import_Types.IrrigationCommand.ValveConfigSet),
+  (0, import_CommandClassDecorators.useSupervision)()
+], IrrigationCCValveConfigSet);
+let IrrigationCCValveConfigReport = IrrigationCCValveConfigReport_1 = class IrrigationCCValveConfigReport2 extends IrrigationCC {
+  constructor(options) {
+    super(options);
+    this.valveId = options.valveId;
+    this.nominalCurrentHighThreshold = options.nominalCurrentHighThreshold;
+    this.nominalCurrentLowThreshold = options.nominalCurrentLowThreshold;
+    this.maximumFlow = options.maximumFlow;
+    this.highFlowThreshold = options.highFlowThreshold;
+    this.lowFlowThreshold = options.lowFlowThreshold;
+    this.useRainSensor = options.useRainSensor;
+    this.useMoistureSensor = options.useMoistureSensor;
+  }
+  static from(raw, ctx) {
+    (0, import_safe.validatePayload)(raw.payload.length >= 4);
+    let valveId;
+    if ((raw.payload[0] & 1) === import_Types.ValveType.MasterValve) {
+      valveId = "master";
+    } else {
+      valveId = raw.payload[1];
+    }
+    const nominalCurrentHighThreshold = 10 * raw.payload[2];
+    const nominalCurrentLowThreshold = 10 * raw.payload[3];
+    let offset = 4;
+    let maximumFlow;
+    {
+      const { value, scale, bytesRead } = (0, import_safe.parseFloatWithScale)(raw.payload.subarray(offset));
+      (0, import_safe.validatePayload)(
+        scale === 0
+        /* l/h */
+      );
+      maximumFlow = value;
+      offset += bytesRead;
+    }
+    let highFlowThreshold;
+    {
+      const { value, scale, bytesRead } = (0, import_safe.parseFloatWithScale)(raw.payload.subarray(offset));
+      (0, import_safe.validatePayload)(
+        scale === 0
+        /* l/h */
+      );
+      highFlowThreshold = value;
+      offset += bytesRead;
+    }
+    let lowFlowThreshold;
+    {
+      const { value, scale, bytesRead } = (0, import_safe.parseFloatWithScale)(raw.payload.subarray(offset));
+      (0, import_safe.validatePayload)(
+        scale === 0
+        /* l/h */
+      );
+      lowFlowThreshold = value;
+      offset += bytesRead;
+    }
+    (0, import_safe.validatePayload)(raw.payload.length >= offset + 1);
+    const useRainSensor = !!(raw.payload[offset] & 1);
+    const useMoistureSensor = !!(raw.payload[offset] & 2);
+    return new IrrigationCCValveConfigReport_1({
+      nodeId: ctx.sourceNodeId,
+      valveId,
+      nominalCurrentHighThreshold,
+      nominalCurrentLowThreshold,
+      maximumFlow,
+      highFlowThreshold,
+      lowFlowThreshold,
+      useRainSensor,
+      useMoistureSensor
+    });
+  }
+  persistValues(ctx) {
+    if (!super.persistValues(ctx))
+      return false;
+    const nominalCurrentHighThresholdValue = IrrigationCCValues.nominalCurrentHighThreshold(this.valveId);
+    this.ensureMetadata(ctx, nominalCurrentHighThresholdValue);
+    this.setValue(ctx, nominalCurrentHighThresholdValue, this.nominalCurrentHighThreshold);
+    const nominalCurrentLowThresholdValue = IrrigationCCValues.nominalCurrentLowThreshold(this.valveId);
+    this.ensureMetadata(ctx, nominalCurrentLowThresholdValue);
+    this.setValue(ctx, nominalCurrentLowThresholdValue, this.nominalCurrentLowThreshold);
+    const maximumFlowValue = IrrigationCCValues.maximumFlow(this.valveId);
+    this.ensureMetadata(ctx, maximumFlowValue);
+    this.setValue(ctx, maximumFlowValue, this.maximumFlow);
+    const highFlowThresholdValue = IrrigationCCValues.highFlowThreshold(this.valveId);
+    this.ensureMetadata(ctx, highFlowThresholdValue);
+    this.setValue(ctx, highFlowThresholdValue, this.highFlowThreshold);
+    const lowFlowThresholdValue = IrrigationCCValues.lowFlowThreshold(this.valveId);
+    this.ensureMetadata(ctx, lowFlowThresholdValue);
+    this.setValue(ctx, lowFlowThresholdValue, this.lowFlowThreshold);
+    const useRainSensorValue = IrrigationCCValues.useRainSensor(this.valveId);
+    this.ensureMetadata(ctx, useRainSensorValue);
+    this.setValue(ctx, useRainSensorValue, this.useRainSensor);
+    const useMoistureSensorValue = IrrigationCCValues.useMoistureSensor(this.valveId);
+    this.ensureMetadata(ctx, useMoistureSensorValue);
+    this.setValue(ctx, useMoistureSensorValue, this.useMoistureSensor);
+    return true;
+  }
+  valveId;
+  nominalCurrentHighThreshold;
+  nominalCurrentLowThreshold;
+  maximumFlow;
+  highFlowThreshold;
+  lowFlowThreshold;
+  useRainSensor;
+  useMoistureSensor;
+  toLogEntry(ctx) {
+    return {
+      ...super.toLogEntry(ctx),
+      message: {
+        "valve ID": this.valveId,
+        "nominal current high threshold": `${this.nominalCurrentHighThreshold} mA`,
+        "nominal current low threshold": `${this.nominalCurrentLowThreshold} mA`,
+        "maximum flow": `${this.maximumFlow} l/h`,
+        "high flow threshold": `${this.highFlowThreshold} l/h`,
+        "low flow threshold": `${this.lowFlowThreshold} l/h`,
+        "use rain sensor": this.useRainSensor,
+        "use moisture sensor": this.useMoistureSensor
+      }
+    };
+  }
+};
+IrrigationCCValveConfigReport = IrrigationCCValveConfigReport_1 = __decorate([
+  (0, import_CommandClassDecorators.CCCommand)(import_Types.IrrigationCommand.ValveConfigReport)
+], IrrigationCCValveConfigReport);
+let IrrigationCCValveConfigGet = class IrrigationCCValveConfigGet2 extends IrrigationCC {
+  constructor(options) {
+    super(options);
+    this.valveId = options.valveId;
+  }
+  static from(_raw, _ctx) {
+    throw new import_safe.ZWaveError(`${this.name}: deserialization not implemented`, import_safe.ZWaveErrorCodes.Deserialization_NotImplemented);
+  }
+  valveId;
+  serialize(ctx) {
+    this.payload = import_safe2.Bytes.from([
+      this.valveId === "master" ? 1 : 0,
+      this.valveId === "master" ? 1 : this.valveId || 1
+    ]);
+    return super.serialize(ctx);
+  }
+  toLogEntry(ctx) {
+    return {
+      ...super.toLogEntry(ctx),
+      message: {
+        "valve ID": this.valveId
+      }
+    };
+  }
+};
+IrrigationCCValveConfigGet = __decorate([
+  (0, import_CommandClassDecorators.CCCommand)(import_Types.IrrigationCommand.ValveConfigGet),
+  (0, import_CommandClassDecorators.expectedCCResponse)(IrrigationCCValveConfigReport, testResponseForIrrigationCommandWithValveId)
+], IrrigationCCValveConfigGet);
+let IrrigationCCValveRun = class IrrigationCCValveRun2 extends IrrigationCC {
+  constructor(options) {
+    super(options);
+    this.valveId = options.valveId;
+    this.duration = options.duration;
+  }
+  static from(_raw, _ctx) {
+    throw new import_safe.ZWaveError(`${this.name}: deserialization not implemented`, import_safe.ZWaveErrorCodes.Deserialization_NotImplemented);
+  }
+  valveId;
+  duration;
+  serialize(ctx) {
+    this.payload = import_safe2.Bytes.from([
+      this.valveId === "master" ? 1 : 0,
+      this.valveId === "master" ? 1 : this.valveId || 1,
+      0,
+      0
+    ]);
+    this.payload.writeUInt16BE(this.duration, 2);
+    return super.serialize(ctx);
+  }
+  toLogEntry(ctx) {
+    const message = {
+      "valve ID": this.valveId
+    };
+    if (this.duration) {
+      message.duration = `${this.duration} s`;
+    } else {
+      message.action = "turn off";
+    }
+    return {
+      ...super.toLogEntry(ctx),
+      message
+    };
+  }
+};
+IrrigationCCValveRun = __decorate([
+  (0, import_CommandClassDecorators.CCCommand)(import_Types.IrrigationCommand.ValveRun),
+  (0, import_CommandClassDecorators.useSupervision)()
+], IrrigationCCValveRun);
+let IrrigationCCValveTableSet = class IrrigationCCValveTableSet2 extends IrrigationCC {
+  constructor(options) {
+    super(options);
+    this.tableId = options.tableId;
+    this.entries = options.entries;
+  }
+  static from(_raw, _ctx) {
+    throw new import_safe.ZWaveError(`${this.name}: deserialization not implemented`, import_safe.ZWaveErrorCodes.Deserialization_NotImplemented);
+  }
+  tableId;
+  entries;
+  serialize(ctx) {
+    this.payload = new import_safe2.Bytes(1 + this.entries.length * 3);
+    this.payload[0] = this.tableId;
+    for (let i = 0; i < this.entries.length; i++) {
+      const entry = this.entries[i];
+      const offset = 1 + i * 3;
+      this.payload[offset] = entry.valveId;
+      this.payload.writeUInt16BE(entry.duration, offset + 1);
+    }
+    return super.serialize(ctx);
+  }
+  toLogEntry(ctx) {
+    const message = {
+      "table ID": this.tableId
+    };
+    for (let i = 0; i < this.entries.length; i++) {
+      const entry = this.entries[i];
+      const valveLabel = (0, import_strings.padStart)(entry.valveId.toString(), 3, "0");
+      if (entry.duration) {
+        message[`valve ${valveLabel} duration`] = `${entry.duration} s`;
+      } else {
+        message[`valve ${valveLabel} action`] = `turn off`;
+      }
+    }
+    return {
+      ...super.toLogEntry(ctx),
+      message
+    };
+  }
+};
+IrrigationCCValveTableSet = __decorate([
+  (0, import_CommandClassDecorators.CCCommand)(import_Types.IrrigationCommand.ValveTableSet),
+  (0, import_CommandClassDecorators.useSupervision)()
+], IrrigationCCValveTableSet);
+let IrrigationCCValveTableReport = IrrigationCCValveTableReport_1 = class IrrigationCCValveTableReport2 extends IrrigationCC {
+  constructor(options) {
+    super(options);
+    this.tableId = options.tableId;
+    this.entries = options.entries;
+  }
+  static from(raw, ctx) {
+    (0, import_safe.validatePayload)((raw.payload.length - 1) % 3 === 0);
+    const tableId = raw.payload[0];
+    const entries = [];
+    for (let offset = 1; offset < raw.payload.length; offset += 3) {
+      entries.push({
+        valveId: raw.payload[offset],
+        duration: raw.payload.readUInt16BE(offset + 1)
+      });
+    }
+    return new IrrigationCCValveTableReport_1({
+      nodeId: ctx.sourceNodeId,
+      tableId,
+      entries
+    });
+  }
+  tableId;
+  entries;
+  toLogEntry(ctx) {
+    const message = {
+      "table ID": this.tableId
+    };
+    for (let i = 0; i < this.entries.length; i++) {
+      const entry = this.entries[i];
+      const valveLabel = (0, import_strings.padStart)(entry.valveId.toString(), 3, "0");
+      if (entry.duration) {
+        message[`valve ${valveLabel} duration`] = `${entry.duration} s`;
+      } else {
+        message[`valve ${valveLabel} action`] = `turn off`;
+      }
+    }
+    return {
+      ...super.toLogEntry(ctx),
+      message
+    };
+  }
+};
+IrrigationCCValveTableReport = IrrigationCCValveTableReport_1 = __decorate([
+  (0, import_CommandClassDecorators.CCCommand)(import_Types.IrrigationCommand.ValveTableReport)
+], IrrigationCCValveTableReport);
+function testResponseForIrrigationValveTableGet(sent, received) {
+  return received.tableId === sent.tableId;
+}
+let IrrigationCCValveTableGet = class IrrigationCCValveTableGet2 extends IrrigationCC {
+  constructor(options) {
+    super(options);
+    this.tableId = options.tableId;
+  }
+  static from(_raw, _ctx) {
+    throw new import_safe.ZWaveError(`${this.name}: deserialization not implemented`, import_safe.ZWaveErrorCodes.Deserialization_NotImplemented);
+  }
+  tableId;
+  serialize(ctx) {
+    this.payload = import_safe2.Bytes.from([this.tableId]);
+    return super.serialize(ctx);
+  }
+  toLogEntry(ctx) {
+    return {
+      ...super.toLogEntry(ctx),
+      message: {
+        "table ID": this.tableId
+      }
+    };
+  }
+};
+IrrigationCCValveTableGet = __decorate([
+  (0, import_CommandClassDecorators.CCCommand)(import_Types.IrrigationCommand.ValveTableGet),
+  (0, import_CommandClassDecorators.expectedCCResponse)(IrrigationCCValveTableReport, testResponseForIrrigationValveTableGet)
+], IrrigationCCValveTableGet);
+let IrrigationCCValveTableRun = class IrrigationCCValveTableRun2 extends IrrigationCC {
+  constructor(options) {
+    super(options);
+    this.tableIDs = options.tableIDs;
+    if (this.tableIDs.length < 1) {
+      throw new import_safe.ZWaveError(`${this.constructor.name}: At least one table ID must be specified.`, import_safe.ZWaveErrorCodes.Argument_Invalid);
+    }
+  }
+  static from(_raw, _ctx) {
+    throw new import_safe.ZWaveError(`${this.name}: deserialization not implemented`, import_safe.ZWaveErrorCodes.Deserialization_NotImplemented);
+  }
+  tableIDs;
+  serialize(ctx) {
+    this.payload = import_safe2.Bytes.from(this.tableIDs);
+    return super.serialize(ctx);
+  }
+  toLogEntry(ctx) {
+    return {
+      ...super.toLogEntry(ctx),
+      message: {
+        "table IDs": this.tableIDs.map((id) => (0, import_strings.padStart)(id.toString(), 3, "0")).join(", ")
+      }
+    };
+  }
+};
+IrrigationCCValveTableRun = __decorate([
+  (0, import_CommandClassDecorators.CCCommand)(import_Types.IrrigationCommand.ValveTableRun),
+  (0, import_CommandClassDecorators.useSupervision)()
+], IrrigationCCValveTableRun);
+let IrrigationCCSystemShutoff = class IrrigationCCSystemShutoff2 extends IrrigationCC {
+  constructor(options) {
+    super(options);
+    this.duration = options.duration;
+  }
+  static from(_raw, _ctx) {
+    throw new import_safe.ZWaveError(`${this.name}: deserialization not implemented`, import_safe.ZWaveErrorCodes.Deserialization_NotImplemented);
+  }
+  duration;
+  serialize(ctx) {
+    this.payload = import_safe2.Bytes.from([this.duration ?? 255]);
+    return super.serialize(ctx);
+  }
+  toLogEntry(ctx) {
+    return {
+      ...super.toLogEntry(ctx),
+      message: {
+        duration: this.duration === 0 ? "temporarily" : this.duration === 255 || this.duration === void 0 ? "permanently" : `${this.duration} hours`
+      }
+    };
+  }
+};
+IrrigationCCSystemShutoff = __decorate([
+  (0, import_CommandClassDecorators.CCCommand)(import_Types.IrrigationCommand.SystemShutoff),
+  (0, import_CommandClassDecorators.useSupervision)()
+], IrrigationCCSystemShutoff);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  IrrigationCC,
+  IrrigationCCAPI,
+  IrrigationCCSystemConfigGet,
+  IrrigationCCSystemConfigReport,
+  IrrigationCCSystemConfigSet,
+  IrrigationCCSystemInfoGet,
+  IrrigationCCSystemInfoReport,
+  IrrigationCCSystemShutoff,
+  IrrigationCCSystemStatusGet,
+  IrrigationCCSystemStatusReport,
+  IrrigationCCValues,
+  IrrigationCCValveConfigGet,
+  IrrigationCCValveConfigReport,
+  IrrigationCCValveConfigSet,
+  IrrigationCCValveInfoGet,
+  IrrigationCCValveInfoReport,
+  IrrigationCCValveRun,
+  IrrigationCCValveTableGet,
+  IrrigationCCValveTableReport,
+  IrrigationCCValveTableRun,
+  IrrigationCCValveTableSet
+});
+//# sourceMappingURL=IrrigationCC.js.map