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

package/build/esm/cc/IrrigationCC.js

@@ -0,0 +1,2038 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var IrrigationCC_1, IrrigationCCSystemInfoReport_1, IrrigationCCSystemStatusReport_1, IrrigationCCSystemConfigReport_1, IrrigationCCValveInfoReport_1, IrrigationCCValveConfigReport_1, IrrigationCCValveTableReport_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__IrrigationCCSystemConfigSetOptions = $o => {
+    function _number($o) {
+        return typeof $o !== "number" ? {} : null;
+    }
+    function su__2__3_eu($o) {
+        return ![0, 1].includes($o) ? {} : null;
+    }
+    function _0($o) {
+        if (typeof $o !== "object" || $o === null || Array.isArray($o))
+            return {};
+        if ("masterValveDelay" in $o && $o["masterValveDelay"] !== undefined) {
+            const error = _number($o["masterValveDelay"]);
+            if (error)
+                return error;
+        }
+        else
+            return {};
+        if ("highPressureThreshold" in $o && $o["highPressureThreshold"] !== undefined) {
+            const error = _number($o["highPressureThreshold"]);
+            if (error)
+                return error;
+        }
+        else
+            return {};
+        if ("lowPressureThreshold" in $o && $o["lowPressureThreshold"] !== undefined) {
+            const error = _number($o["lowPressureThreshold"]);
+            if (error)
+                return error;
+        }
+        else
+            return {};
+        if ("rainSensorPolarity" in $o && $o["rainSensorPolarity"] !== undefined) {
+            const error = su__2__3_eu($o["rainSensorPolarity"]);
+            if (error)
+                return error;
+        }
+        if ("moistureSensorPolarity" in $o && $o["moistureSensorPolarity"] !== undefined) {
+            const error = su__2__3_eu($o["moistureSensorPolarity"]);
+            if (error)
+                return error;
+        }
+        return null;
+    }
+    return _0($o);
+};
+const __assertType__ValveId = $o => {
+    function _number($o) {
+        return typeof $o !== "number" ? {} : null;
+    }
+    function _2($o) {
+        return $o !== "master" ? {} : null;
+    }
+    function su__number__2_eu($o) {
+        const conditions = [_number, _2];
+        for (const condition of conditions) {
+            const error = condition($o);
+            if (!error)
+                return null;
+        }
+        return {};
+    }
+    return su__number__2_eu($o);
+};
+const __assertType__IrrigationCCValveConfigSetOptions = $o => {
+    function _number($o) {
+        return typeof $o !== "number" ? {} : null;
+    }
+    function _3($o) {
+        return $o !== "master" ? {} : null;
+    }
+    function su__number__3_eu($o) {
+        const conditions = [_number, _3];
+        for (const condition of conditions) {
+            const error = condition($o);
+            if (!error)
+                return null;
+        }
+        return {};
+    }
+    function _boolean($o) {
+        return typeof $o !== "boolean" ? {} : null;
+    }
+    function _0($o) {
+        if (typeof $o !== "object" || $o === null || Array.isArray($o))
+            return {};
+        if ("valveId" in $o && $o["valveId"] !== undefined) {
+            const error = su__number__3_eu($o["valveId"]);
+            if (error)
+                return error;
+        }
+        else
+            return {};
+        if ("nominalCurrentHighThreshold" in $o && $o["nominalCurrentHighThreshold"] !== undefined) {
+            const error = _number($o["nominalCurrentHighThreshold"]);
+            if (error)
+                return error;
+        }
+        else
+            return {};
+        if ("nominalCurrentLowThreshold" in $o && $o["nominalCurrentLowThreshold"] !== undefined) {
+            const error = _number($o["nominalCurrentLowThreshold"]);
+            if (error)
+                return error;
+        }
+        else
+            return {};
+        if ("maximumFlow" in $o && $o["maximumFlow"] !== undefined) {
+            const error = _number($o["maximumFlow"]);
+            if (error)
+                return error;
+        }
+        else
+            return {};
+        if ("highFlowThreshold" in $o && $o["highFlowThreshold"] !== undefined) {
+            const error = _number($o["highFlowThreshold"]);
+            if (error)
+                return error;
+        }
+        else
+            return {};
+        if ("lowFlowThreshold" in $o && $o["lowFlowThreshold"] !== undefined) {
+            const error = _number($o["lowFlowThreshold"]);
+            if (error)
+                return error;
+        }
+        else
+            return {};
+        if ("useRainSensor" in $o && $o["useRainSensor"] !== undefined) {
+            const error = _boolean($o["useRainSensor"]);
+            if (error)
+                return error;
+        }
+        else
+            return {};
+        if ("useMoistureSensor" in $o && $o["useMoistureSensor"] !== undefined) {
+            const error = _boolean($o["useMoistureSensor"]);
+            if (error)
+                return error;
+        }
+        else
+            return {};
+        return null;
+    }
+    return _0($o);
+};
+const __assertType__number = $o => {
+    function _number($o) {
+        return typeof $o !== "number" ? {} : null;
+    }
+    return _number($o);
+};
+const __assertType__sa__2_ea_2 = $o => {
+    function _number($o) {
+        return typeof $o !== "number" ? {} : null;
+    }
+    function _2($o) {
+        if (typeof $o !== "object" || $o === null || Array.isArray($o))
+            return {};
+        if ("valveId" in $o && $o["valveId"] !== undefined) {
+            const error = _number($o["valveId"]);
+            if (error)
+                return error;
+        }
+        else
+            return {};
+        if ("duration" in $o && $o["duration"] !== undefined) {
+            const error = _number($o["duration"]);
+            if (error)
+                return error;
+        }
+        else
+            return {};
+        return null;
+    }
+    function sa__2_ea_2($o) {
+        if (!Array.isArray($o))
+            return {};
+        for (let i = 0; i < $o.length; i++) {
+            const error = _2($o[i]);
+            if (error)
+                return error;
+        }
+        return null;
+    }
+    return sa__2_ea_2($o);
+};
+const __assertType__sa__number_ea_2 = $o => {
+    function _number($o) {
+        return typeof $o !== "number" ? {} : null;
+    }
+    function sa__number_ea_2($o) {
+        if (!Array.isArray($o))
+            return {};
+        for (let i = 0; i < $o.length; i++) {
+            const error = _number($o[i]);
+            if (error)
+                return error;
+        }
+        return null;
+    }
+    return sa__number_ea_2($o);
+};
+import { CommandClasses, MessagePriority, ValueMetadata, ZWaveError, ZWaveErrorCodes, encodeFloatWithScale, enumValuesToMetadataStates, parseFloatWithScale, validatePayload, } from "@zwave-js/core/safe";
+import { Bytes } from "@zwave-js/shared/safe";
+import { getEnumMemberName, pick } from "@zwave-js/shared/safe";
+import { padStart } from "alcalzone-shared/strings/index.js";
+import { CCAPI, POLL_VALUE, SET_VALUE, throwMissingPropertyKey, throwUnsupportedProperty, throwUnsupportedPropertyKey, throwWrongValueType, } from "../lib/API.js";
+import { CommandClass, } from "../lib/CommandClass.js";
+import { API, CCCommand, ccValue, ccValues, commandClass, expectedCCResponse, implementedVersion, useSupervision, } from "../lib/CommandClassDecorators.js";
+import { V } from "../lib/Values.js";
+import { IrrigationCommand, IrrigationSensorPolarity, ValveType, } from "../lib/_Types.js";
+export const IrrigationCCValues = Object.freeze({
+    ...V.defineStaticCCValues(CommandClasses.Irrigation, {
+        ...V.staticProperty("numValves", undefined, { internal: true }),
+        ...V.staticProperty("numValveTables", undefined, { internal: true }),
+        ...V.staticProperty("supportsMasterValve", undefined, {
+            internal: true,
+        }),
+        ...V.staticProperty("maxValveTableSize", undefined, { internal: true }),
+        ...V.staticProperty("systemVoltage", {
+            ...ValueMetadata.ReadOnlyUInt8,
+            label: "System voltage",
+            unit: "V",
+        }),
+        ...V.staticProperty("masterValveDelay", {
+            ...ValueMetadata.UInt8,
+            label: "Master valve delay",
+            description: "The delay between turning on the master valve and turning on any zone valve",
+            unit: "seconds",
+        }),
+        ...V.staticProperty("flowSensorActive", {
+            ...ValueMetadata.ReadOnlyBoolean,
+            label: "Flow sensor active",
+        }),
+        ...V.staticProperty("pressureSensorActive", {
+            ...ValueMetadata.ReadOnlyBoolean,
+            label: "Pressure sensor active",
+        }),
+        ...V.staticProperty("rainSensorActive", {
+            ...ValueMetadata.ReadOnlyBoolean,
+            label: "Rain sensor attached and active",
+        }),
+        ...V.staticProperty("rainSensorPolarity", {
+            ...ValueMetadata.Number,
+            label: "Rain sensor polarity",
+            min: 0,
+            max: 1,
+            states: enumValuesToMetadataStates(IrrigationSensorPolarity),
+        }),
+        ...V.staticProperty("moistureSensorActive", {
+            ...ValueMetadata.ReadOnlyBoolean,
+            label: "Moisture sensor attached and active",
+        }),
+        ...V.staticProperty("moistureSensorPolarity", {
+            ...ValueMetadata.Number,
+            label: "Moisture sensor polarity",
+            min: 0,
+            max: 1,
+            states: enumValuesToMetadataStates(IrrigationSensorPolarity),
+        }),
+        ...V.staticProperty("flow", {
+            ...ValueMetadata.ReadOnlyNumber,
+            label: "Flow",
+            unit: "l/h",
+        }),
+        ...V.staticProperty("pressure", {
+            ...ValueMetadata.ReadOnlyNumber,
+            label: "Pressure",
+            unit: "kPa",
+        }),
+        ...V.staticProperty("shutoffDuration", {
+            ...ValueMetadata.ReadOnlyUInt8,
+            label: "Remaining shutoff duration",
+            unit: "hours",
+        }),
+        ...V.staticProperty("errorNotProgrammed", {
+            ...ValueMetadata.ReadOnlyBoolean,
+            label: "Error: device not programmed",
+        }),
+        ...V.staticProperty("errorEmergencyShutdown", {
+            ...ValueMetadata.ReadOnlyBoolean,
+            label: "Error: emergency shutdown",
+        }),
+        ...V.staticProperty("errorHighPressure", {
+            ...ValueMetadata.ReadOnlyBoolean,
+            label: "Error: high pressure",
+        }),
+        ...V.staticProperty("highPressureThreshold", {
+            ...ValueMetadata.Number,
+            label: "High pressure threshold",
+            unit: "kPa",
+        }),
+        ...V.staticProperty("errorLowPressure", {
+            ...ValueMetadata.ReadOnlyBoolean,
+            label: "Error: low pressure",
+        }),
+        ...V.staticProperty("lowPressureThreshold", {
+            ...ValueMetadata.Number,
+            label: "Low pressure threshold",
+            unit: "kPa",
+        }),
+        ...V.staticProperty("errorValve", {
+            ...ValueMetadata.ReadOnlyBoolean,
+            label: "Error: valve reporting error",
+        }),
+        ...V.staticProperty("masterValveOpen", {
+            ...ValueMetadata.ReadOnlyBoolean,
+            label: "Master valve is open",
+        }),
+        ...V.staticProperty("firstOpenZoneId", {
+            ...ValueMetadata.ReadOnlyNumber,
+            label: "First open zone valve ID",
+        }),
+        ...V.staticPropertyWithName("shutoffSystem", "shutoff", {
+            ...ValueMetadata.WriteOnlyBoolean,
+            label: `Shutoff system`,
+            states: {
+                true: "Shutoff",
+            },
+        }),
+    }),
+    ...V.defineDynamicCCValues(CommandClasses.Irrigation, {
+        ...V.dynamicPropertyAndKeyWithName("valveConnected", (valveId) => valveId, "valveConnected", ({ property, propertyKey }) => (typeof property === "number" || property === "master")
+            && propertyKey === "valveConnected", (valveId) => ({
+            ...ValueMetadata.ReadOnlyBoolean,
+            label: `${valveIdToMetadataPrefix(valveId)}: Connected`,
+        })),
+        ...V.dynamicPropertyAndKeyWithName("nominalCurrent", (valveId) => valveId, "nominalCurrent", ({ property, propertyKey }) => (typeof property === "number" || property === "master")
+            && propertyKey === "nominalCurrent", (valveId) => ({
+            ...ValueMetadata.ReadOnlyBoolean,
+            label: `${valveIdToMetadataPrefix(valveId)}: Nominal current`,
+            unit: "mA",
+        })),
+        ...V.dynamicPropertyAndKeyWithName("nominalCurrentHighThreshold", (valveId) => valveId, "nominalCurrentHighThreshold", ({ property, propertyKey }) => (typeof property === "number" || property === "master")
+            && propertyKey === "nominalCurrentHighThreshold", (valveId) => ({
+            ...ValueMetadata.Number,
+            label: `${valveIdToMetadataPrefix(valveId)}: Nominal current - high threshold`,
+            min: 0,
+            max: 2550,
+            unit: "mA",
+        })),
+        ...V.dynamicPropertyAndKeyWithName("nominalCurrentLowThreshold", (valveId) => valveId, "nominalCurrentLowThreshold", ({ property, propertyKey }) => (typeof property === "number" || property === "master")
+            && propertyKey === "nominalCurrentLowThreshold", (valveId) => ({
+            ...ValueMetadata.Number,
+            label: `${valveIdToMetadataPrefix(valveId)}: Nominal current - low threshold`,
+            min: 0,
+            max: 2550,
+            unit: "mA",
+        })),
+        ...V.dynamicPropertyAndKeyWithName("errorShortCircuit", (valveId) => valveId, "errorShortCircuit", ({ property, propertyKey }) => (typeof property === "number" || property === "master")
+            && propertyKey === "errorShortCircuit", (valveId) => ({
+            ...ValueMetadata.ReadOnlyBoolean,
+            label: `${valveIdToMetadataPrefix(valveId)}: Error - Short circuit detected`,
+        })),
+        ...V.dynamicPropertyAndKeyWithName("errorHighCurrent", (valveId) => valveId, "errorHighCurrent", ({ property, propertyKey }) => (typeof property === "number" || property === "master")
+            && propertyKey === "errorHighCurrent", (valveId) => ({
+            ...ValueMetadata.ReadOnlyBoolean,
+            label: `${valveIdToMetadataPrefix(valveId)}: Error - Current above high threshold`,
+        })),
+        ...V.dynamicPropertyAndKeyWithName("errorLowCurrent", (valveId) => valveId, "errorLowCurrent", ({ property, propertyKey }) => (typeof property === "number" || property === "master")
+            && propertyKey === "errorLowCurrent", (valveId) => ({
+            ...ValueMetadata.ReadOnlyBoolean,
+            label: `${valveIdToMetadataPrefix(valveId)}: Error - Current below low threshold`,
+        })),
+        ...V.dynamicPropertyAndKeyWithName("maximumFlow", (valveId) => valveId, "maximumFlow", ({ property, propertyKey }) => (typeof property === "number" || property === "master")
+            && propertyKey === "maximumFlow", (valveId) => ({
+            ...ValueMetadata.Number,
+            label: `${valveIdToMetadataPrefix(valveId)}: Maximum flow`,
+            min: 0,
+            unit: "l/h",
+        })),
+        ...V.dynamicPropertyAndKeyWithName("errorMaximumFlow", (valveId) => valveId, "errorMaximumFlow", ({ property, propertyKey }) => (typeof property === "number" || property === "master")
+            && propertyKey === "errorMaximumFlow", (valveId) => ({
+            ...ValueMetadata.ReadOnlyBoolean,
+            label: `${valveIdToMetadataPrefix(valveId)}: Error - Maximum flow detected`,
+        })),
+        ...V.dynamicPropertyAndKeyWithName("highFlowThreshold", (valveId) => valveId, "highFlowThreshold", ({ property, propertyKey }) => (typeof property === "number" || property === "master")
+            && propertyKey === "highFlowThreshold", (valveId) => ({
+            ...ValueMetadata.Number,
+            label: `${valveIdToMetadataPrefix(valveId)}: High flow threshold`,
+            min: 0,
+            unit: "l/h",
+        })),
+        ...V.dynamicPropertyAndKeyWithName("errorHighFlow", (valveId) => valveId, "errorHighFlow", ({ property, propertyKey }) => (typeof property === "number" || property === "master")
+            && propertyKey === "errorHighFlow", (valveId) => ({
+            ...ValueMetadata.ReadOnlyBoolean,
+            label: `${valveIdToMetadataPrefix(valveId)}: Error - Flow above high threshold`,
+        })),
+        ...V.dynamicPropertyAndKeyWithName("lowFlowThreshold", (valveId) => valveId, "lowFlowThreshold", ({ property, propertyKey }) => (typeof property === "number" || property === "master")
+            && propertyKey === "lowFlowThreshold", (valveId) => ({
+            ...ValueMetadata.Number,
+            label: `${valveIdToMetadataPrefix(valveId)}: Low flow threshold`,
+            min: 0,
+            unit: "l/h",
+        })),
+        ...V.dynamicPropertyAndKeyWithName("errorLowFlow", (valveId) => valveId, "errorLowFlow", ({ property, propertyKey }) => (typeof property === "number" || property === "master")
+            && propertyKey === "errorLowFlow", (valveId) => ({
+            ...ValueMetadata.ReadOnlyBoolean,
+            label: `${valveIdToMetadataPrefix(valveId)}: Error - Flow below high threshold`,
+        })),
+        ...V.dynamicPropertyAndKeyWithName("useRainSensor", (valveId) => valveId, "useRainSensor", ({ property, propertyKey }) => (typeof property === "number" || property === "master")
+            && propertyKey === "useRainSensor", (valveId) => ({
+            ...ValueMetadata.Boolean,
+            label: `${valveIdToMetadataPrefix(valveId)}: Use rain sensor`,
+        })),
+        ...V.dynamicPropertyAndKeyWithName("useMoistureSensor", (valveId) => valveId, "useMoistureSensor", ({ property, propertyKey }) => (typeof property === "number" || property === "master")
+            && propertyKey === "useMoistureSensor", (valveId) => ({
+            ...ValueMetadata.Boolean,
+            label: `${valveIdToMetadataPrefix(valveId)}: Use moisture sensor`,
+        })),
+        ...V.dynamicPropertyAndKeyWithName("valveRunDuration", (valveId) => valveId, "duration", ({ property, propertyKey }) => (typeof property === "number" || property === "master")
+            && propertyKey === "duration", (valveId) => ({
+            ...ValueMetadata.UInt16,
+            label: `${valveIdToMetadataPrefix(valveId)}: Run duration`,
+            min: 1,
+            unit: "s",
+        })),
+        ...V.dynamicPropertyAndKeyWithName("valveRunStartStop", (valveId) => valveId, "startStop", ({ property, propertyKey }) => (typeof property === "number" || property === "master")
+            && propertyKey === "startStop", (valveId) => ({
+            ...ValueMetadata.Boolean,
+            label: `${valveIdToMetadataPrefix(valveId)}: Start/Stop`,
+            states: {
+                true: "Start",
+                false: "Stop",
+            },
+        })),
+    }),
+});
+function valveIdToMetadataPrefix(valveId) {
+    if (valveId === "master")
+        return "Master valve";
+    return `Valve ${padStart(valveId.toString(), 3, "0")}`;
+}
+const systemConfigProperties = [
+    "masterValveDelay",
+    "highPressureThreshold",
+    "lowPressureThreshold",
+    "rainSensorPolarity",
+    "moistureSensorPolarity",
+];
+const valveConfigPropertyKeys = [
+    "nominalCurrentHighThreshold",
+    "nominalCurrentLowThreshold",
+    "maximumFlow",
+    "highFlowThreshold",
+    "lowFlowThreshold",
+    "useRainSensor",
+    "useMoistureSensor",
+];
+let IrrigationCCAPI = class IrrigationCCAPI extends CCAPI {
+    supportsCommand(cmd) {
+        switch (cmd) {
+            case IrrigationCommand.SystemInfoGet:
+            case IrrigationCommand.SystemStatusGet:
+            case IrrigationCommand.SystemConfigSet:
+            case IrrigationCommand.SystemConfigGet:
+            case IrrigationCommand.ValveInfoGet:
+            case IrrigationCommand.ValveConfigSet:
+            case IrrigationCommand.ValveConfigGet:
+            case IrrigationCommand.ValveRun:
+            case IrrigationCommand.ValveTableSet:
+            case IrrigationCommand.ValveTableGet:
+            case IrrigationCommand.ValveTableRun:
+            case IrrigationCommand.SystemShutoff:
+                // These are all mandatory in V1
+                return true;
+        }
+        return super.supportsCommand(cmd);
+    }
+    // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
+    async getSystemInfo() {
+        this.assertSupportsCommand(IrrigationCommand, 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 pick(response, [
+                "numValves",
+                "numValveTables",
+                "supportsMasterValve",
+                "maxValveTableSize",
+            ]);
+        }
+    }
+    // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
+    async getSystemStatus() {
+        this.assertSupportsCommand(IrrigationCommand, 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 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(IrrigationCommand, 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 pick(response, [
+                "masterValveDelay",
+                "highPressureThreshold",
+                "lowPressureThreshold",
+                "rainSensorPolarity",
+                "moistureSensorPolarity",
+            ]);
+        }
+    }
+    async setSystemConfig(config) {
+        __assertType("config", "IrrigationCCSystemConfigSetOptions", __assertType__IrrigationCCSystemConfigSetOptions.bind(void 0, config));
+        this.assertSupportsCommand(IrrigationCommand, 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(IrrigationCommand, 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 pick(response, [
+                "connected",
+                "nominalCurrent",
+                "errorShortCircuit",
+                "errorHighCurrent",
+                "errorLowCurrent",
+                "errorMaximumFlow",
+                "errorHighFlow",
+                "errorLowFlow",
+            ]);
+        }
+    }
+    async setValveConfig(options) {
+        __assertType("options", "IrrigationCCValveConfigSetOptions", __assertType__IrrigationCCValveConfigSetOptions.bind(void 0, options));
+        this.assertSupportsCommand(IrrigationCommand, 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(IrrigationCommand, 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 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(IrrigationCommand, 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", undefined, __assertType__sa__2_ea_2.bind(void 0, entries));
+        this.assertSupportsCommand(IrrigationCommand, IrrigationCommand.ValveTableSet);
+        if (!this.endpoint.virtual) {
+            const maxValveTableSize = IrrigationCC.getMaxValveTableSizeCached(this.host, this.endpoint);
+            if (maxValveTableSize != undefined
+                && entries.length > maxValveTableSize) {
+                throw new ZWaveError(`The number of valve table entries must not exceed ${maxValveTableSize}.`, 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(IrrigationCommand, 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", undefined, __assertType__sa__number_ea_2.bind(void 0, tableIDs));
+        this.assertSupportsCommand(IrrigationCommand, 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(IrrigationCommand, 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 [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 == undefined) {
+                        throw new ZWaveError(`The "${property}" property cannot be changed before ${prop} is known!`, 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)) {
+                // This is a value of a valve
+                if (propertyKey == undefined) {
+                    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 == undefined) {
+                            throw new ZWaveError(`The "${property}_${propertyKey}" property cannot be changed before ${property}_${prop} is known!`, ZWaveErrorCodes.Argument_Invalid);
+                        }
+                        options[prop] = cachedVal;
+                    }
+                    options[propertyKey] = value;
+                    return this.setValveConfig(options);
+                }
+                else if (propertyKey === "duration") {
+                    // The run duration needs to be set separately from triggering the run
+                    // So this is okay
+                    return;
+                }
+                else if (propertyKey === "startStop") {
+                    // Trigger or stop a valve run, depending on the value
+                    if (typeof value !== "boolean") {
+                        throwWrongValueType(this.ccId, property, "boolean", typeof value);
+                    }
+                    if (value) {
+                        // Start a valve run
+                        const duration = valueDB.getValue(IrrigationCCValues.valveRunDuration(property).endpoint(this.endpoint.index));
+                        if (duration == undefined) {
+                            throw new ZWaveError(`Cannot start a valve run without specifying a duration first!`, ZWaveErrorCodes.Argument_Invalid);
+                        }
+                        return this.runValve(property, duration);
+                    }
+                    else {
+                        // Stop a valve run
+                        return this.shutoffValve(property);
+                    }
+                }
+                else {
+                    throwUnsupportedPropertyKey(this.ccId, property, propertyKey);
+                }
+            }
+        };
+    }
+    get [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)) {
+                // This is a value of a valve
+                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 undefined:
+                        throwMissingPropertyKey(this.ccId, property);
+                    default:
+                        throwUnsupportedPropertyKey(this.ccId, property, propertyKey);
+                }
+            }
+            throwUnsupportedProperty(this.ccId, property);
+        };
+    }
+};
+IrrigationCCAPI = __decorate([
+    API(CommandClasses.Irrigation)
+], IrrigationCCAPI);
+export { IrrigationCCAPI };
+let IrrigationCC = IrrigationCC_1 = class IrrigationCC extends 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 = CCAPI.create(CommandClasses.Irrigation, ctx, endpoint).withOptions({
+            priority: MessagePriority.NodeQuery,
+        });
+        ctx.logNode(node.id, {
+            endpoint: this.endpointIndex,
+            message: `Interviewing ${this.ccName}...`,
+            direction: "none",
+        });
+        ctx.logNode(node.id, {
+            endpoint: this.endpointIndex,
+            message: "Querying 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 each valve, create the values to start/stop a run
+        for (let i = 1; i <= systemInfo.numValves; i++) {
+            this.ensureMetadata(ctx, IrrigationCCValues.valveRunDuration(i));
+            this.ensureMetadata(ctx, IrrigationCCValues.valveRunStartStop(i));
+        }
+        // And create a shutoff value
+        this.ensureMetadata(ctx, IrrigationCCValues.shutoffSystem);
+        // Query current values
+        await this.refreshValues(ctx);
+        // Remember that the interview is complete
+        this.setInterviewComplete(ctx, true);
+    }
+    async refreshValues(ctx) {
+        const node = this.getNode(ctx);
+        const endpoint = this.getEndpoint(ctx);
+        const api = CCAPI.create(CommandClasses.Irrigation, ctx, endpoint).withOptions({
+            priority: MessagePriority.NodeQuery,
+        });
+        // Query the current system config
+        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 != undefined) {
+                logMessage += `
+rain sensor polarity:     ${getEnumMemberName(IrrigationSensorPolarity, systemConfig.rainSensorPolarity)}`;
+            }
+            if (systemConfig.moistureSensorPolarity != undefined) {
+                logMessage += `
+moisture sensor polarity: ${getEnumMemberName(IrrigationSensorPolarity, systemConfig.moistureSensorPolarity)}`;
+            }
+            ctx.logNode(node.id, {
+                endpoint: this.endpointIndex,
+                message: logMessage,
+                direction: "inbound",
+            });
+        }
+        // and status
+        // Query the current system config
+        ctx.logNode(node.id, {
+            endpoint: this.endpointIndex,
+            message: "Querying irrigation system status...",
+            direction: "outbound",
+        });
+        await api.getSystemStatus();
+        // for each valve, query the current status and configuration
+        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 ${padStart(i.toString(), 3, "0")}...`,
+                direction: "outbound",
+            });
+            await api.getValveConfig(i);
+            ctx.logNode(node.id, {
+                endpoint: this.endpointIndex,
+                message: `Querying status for valve ${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 ${padStart(property.toString(), 3, "0")}`;
+        }
+        return super.translateProperty(ctx, property, propertyKey);
+    }
+};
+IrrigationCC = IrrigationCC_1 = __decorate([
+    commandClass(CommandClasses.Irrigation),
+    implementedVersion(1),
+    ccValues(IrrigationCCValues)
+], IrrigationCC);
+export { IrrigationCC };
+let IrrigationCCSystemInfoReport = IrrigationCCSystemInfoReport_1 = class IrrigationCCSystemInfoReport extends IrrigationCC {
+    constructor(options) {
+        super(options);
+        // TODO: Check implementation:
+        this.supportsMasterValve = options.supportsMasterValve;
+        this.numValves = options.numValves;
+        this.numValveTables = options.numValveTables;
+        this.maxValveTableSize = options.maxValveTableSize;
+    }
+    static from(raw, ctx) {
+        validatePayload(raw.payload.length >= 4);
+        const supportsMasterValve = !!(raw.payload[0] & 0x01);
+        const numValves = raw.payload[1];
+        const numValveTables = raw.payload[2];
+        const maxValveTableSize = raw.payload[3] & 0b1111;
+        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([
+    ccValue(IrrigationCCValues.numValves)
+], IrrigationCCSystemInfoReport.prototype, "numValves", void 0);
+__decorate([
+    ccValue(IrrigationCCValues.numValveTables)
+], IrrigationCCSystemInfoReport.prototype, "numValveTables", void 0);
+__decorate([
+    ccValue(IrrigationCCValues.supportsMasterValve)
+], IrrigationCCSystemInfoReport.prototype, "supportsMasterValve", void 0);
+__decorate([
+    ccValue(IrrigationCCValues.maxValveTableSize)
+], IrrigationCCSystemInfoReport.prototype, "maxValveTableSize", void 0);
+IrrigationCCSystemInfoReport = IrrigationCCSystemInfoReport_1 = __decorate([
+    CCCommand(IrrigationCommand.SystemInfoReport)
+], IrrigationCCSystemInfoReport);
+export { IrrigationCCSystemInfoReport };
+let IrrigationCCSystemInfoGet = class IrrigationCCSystemInfoGet extends IrrigationCC {
+};
+IrrigationCCSystemInfoGet = __decorate([
+    CCCommand(IrrigationCommand.SystemInfoGet),
+    expectedCCResponse(IrrigationCCSystemInfoReport)
+], IrrigationCCSystemInfoGet);
+export { IrrigationCCSystemInfoGet };
+let IrrigationCCSystemStatusReport = IrrigationCCSystemStatusReport_1 = class IrrigationCCSystemStatusReport extends IrrigationCC {
+    constructor(options) {
+        super(options);
+        // TODO: Check implementation:
+        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) {
+        validatePayload(raw.payload.length >= 2);
+        const systemVoltage = raw.payload[0];
+        const flowSensorActive = !!(raw.payload[1] & 0x01);
+        const pressureSensorActive = !!(raw.payload[1] & 0x02);
+        const rainSensorActive = !!(raw.payload[1] & 0x04);
+        const moistureSensorActive = !!(raw.payload[1] & 0x08);
+        let offset = 2;
+        let flow;
+        {
+            const { value, scale, bytesRead } = parseFloatWithScale(raw.payload.subarray(offset));
+            validatePayload(scale === 0);
+            if (flowSensorActive)
+                flow = value;
+            offset += bytesRead;
+        }
+        let pressure;
+        {
+            const { value, scale, bytesRead } = parseFloatWithScale(raw.payload.subarray(offset));
+            validatePayload(scale === 0);
+            if (pressureSensorActive)
+                pressure = value;
+            offset += bytesRead;
+        }
+        validatePayload(raw.payload.length >= offset + 4);
+        const shutoffDuration = raw.payload[offset];
+        const errorNotProgrammed = !!(raw.payload[offset + 1] & 0x01);
+        const errorEmergencyShutdown = !!(raw.payload[offset + 1] & 0x02);
+        const errorHighPressure = !!(raw.payload[offset + 1] & 0x04);
+        const errorLowPressure = !!(raw.payload[offset + 1] & 0x08);
+        const errorValve = !!(raw.payload[offset + 1] & 0x10);
+        const masterValveOpen = !!(raw.payload[offset + 2] & 0x01);
+        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" : undefined,
+                this.pressureSensorActive ? "pressure" : undefined,
+                this.rainSensorActive ? "rain" : undefined,
+                this.moistureSensorActive ? "moisture" : undefined,
+            ]
+                .filter(Boolean)
+                .join(", "),
+        };
+        if (this.flow != undefined) {
+            message.flow = `${this.flow} l/h`;
+        }
+        if (this.pressure != undefined) {
+            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" : undefined,
+            this.errorEmergencyShutdown ? "emergency shutdown" : undefined,
+            this.errorHighPressure
+                ? "high pressure threshold triggered"
+                : undefined,
+            this.errorLowPressure
+                ? "low pressure threshold triggered"
+                : undefined,
+            this.errorValve
+                ? "a valve or the master valve has an error"
+                : undefined,
+        ].filter(Boolean);
+        if (errors.length > 0) {
+            message.errors = errors.map((e) => `\n· ${e}`).join("");
+        }
+        return {
+            ...super.toLogEntry(ctx),
+            message,
+        };
+    }
+};
+__decorate([
+    ccValue(IrrigationCCValues.systemVoltage)
+], IrrigationCCSystemStatusReport.prototype, "systemVoltage", void 0);
+__decorate([
+    ccValue(IrrigationCCValues.flowSensorActive)
+], IrrigationCCSystemStatusReport.prototype, "flowSensorActive", void 0);
+__decorate([
+    ccValue(IrrigationCCValues.pressureSensorActive)
+], IrrigationCCSystemStatusReport.prototype, "pressureSensorActive", void 0);
+__decorate([
+    ccValue(IrrigationCCValues.rainSensorActive)
+], IrrigationCCSystemStatusReport.prototype, "rainSensorActive", void 0);
+__decorate([
+    ccValue(IrrigationCCValues.moistureSensorActive)
+], IrrigationCCSystemStatusReport.prototype, "moistureSensorActive", void 0);
+__decorate([
+    ccValue(IrrigationCCValues.flow)
+], IrrigationCCSystemStatusReport.prototype, "flow", void 0);
+__decorate([
+    ccValue(IrrigationCCValues.pressure)
+], IrrigationCCSystemStatusReport.prototype, "pressure", void 0);
+__decorate([
+    ccValue(IrrigationCCValues.shutoffDuration)
+], IrrigationCCSystemStatusReport.prototype, "shutoffDuration", void 0);
+__decorate([
+    ccValue(IrrigationCCValues.errorNotProgrammed)
+], IrrigationCCSystemStatusReport.prototype, "errorNotProgrammed", void 0);
+__decorate([
+    ccValue(IrrigationCCValues.errorEmergencyShutdown)
+], IrrigationCCSystemStatusReport.prototype, "errorEmergencyShutdown", void 0);
+__decorate([
+    ccValue(IrrigationCCValues.errorHighPressure)
+], IrrigationCCSystemStatusReport.prototype, "errorHighPressure", void 0);
+__decorate([
+    ccValue(IrrigationCCValues.errorLowPressure)
+], IrrigationCCSystemStatusReport.prototype, "errorLowPressure", void 0);
+__decorate([
+    ccValue(IrrigationCCValues.errorValve)
+], IrrigationCCSystemStatusReport.prototype, "errorValve", void 0);
+__decorate([
+    ccValue(IrrigationCCValues.masterValveOpen)
+], IrrigationCCSystemStatusReport.prototype, "masterValveOpen", void 0);
+__decorate([
+    ccValue(IrrigationCCValues.firstOpenZoneId)
+], IrrigationCCSystemStatusReport.prototype, "firstOpenZoneId", void 0);
+IrrigationCCSystemStatusReport = IrrigationCCSystemStatusReport_1 = __decorate([
+    CCCommand(IrrigationCommand.SystemStatusReport)
+], IrrigationCCSystemStatusReport);
+export { IrrigationCCSystemStatusReport };
+let IrrigationCCSystemStatusGet = class IrrigationCCSystemStatusGet extends IrrigationCC {
+};
+IrrigationCCSystemStatusGet = __decorate([
+    CCCommand(IrrigationCommand.SystemStatusGet),
+    expectedCCResponse(IrrigationCCSystemStatusReport)
+], IrrigationCCSystemStatusGet);
+export { IrrigationCCSystemStatusGet };
+let IrrigationCCSystemConfigSet = class IrrigationCCSystemConfigSet 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) {
+        // TODO: Deserialize payload
+        throw new ZWaveError(`${this.name}: deserialization not implemented`, ZWaveErrorCodes.Deserialization_NotImplemented);
+        // return new IrrigationCCSystemConfigSet({
+        // 	nodeId: ctx.sourceNodeId,
+        // });
+    }
+    masterValveDelay;
+    highPressureThreshold;
+    lowPressureThreshold;
+    rainSensorPolarity;
+    moistureSensorPolarity;
+    serialize(ctx) {
+        let polarity = 0;
+        if (this.rainSensorPolarity != undefined)
+            polarity |= 0b1;
+        if (this.moistureSensorPolarity != undefined)
+            polarity |= 0b10;
+        if (this.rainSensorPolarity == undefined
+            && this.moistureSensorPolarity == undefined) {
+            // Valid bit
+            polarity |= 0b1000_0000;
+        }
+        this.payload = Bytes.concat([
+            Bytes.from([this.masterValveDelay]),
+            encodeFloatWithScale(this.highPressureThreshold, 0 /* kPa */),
+            encodeFloatWithScale(this.lowPressureThreshold, 0 /* kPa */),
+            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 != undefined) {
+            message["rain sensor polarity"] = getEnumMemberName(IrrigationSensorPolarity, this.rainSensorPolarity);
+        }
+        if (this.moistureSensorPolarity != undefined) {
+            message["moisture sensor polarity"] = getEnumMemberName(IrrigationSensorPolarity, this.moistureSensorPolarity);
+        }
+        return {
+            ...super.toLogEntry(ctx),
+            message,
+        };
+    }
+};
+IrrigationCCSystemConfigSet = __decorate([
+    CCCommand(IrrigationCommand.SystemConfigSet),
+    useSupervision()
+], IrrigationCCSystemConfigSet);
+export { IrrigationCCSystemConfigSet };
+let IrrigationCCSystemConfigReport = IrrigationCCSystemConfigReport_1 = class IrrigationCCSystemConfigReport extends IrrigationCC {
+    constructor(options) {
+        super(options);
+        // TODO: Check implementation:
+        this.masterValveDelay = options.masterValveDelay;
+        this.highPressureThreshold = options.highPressureThreshold;
+        this.lowPressureThreshold = options.lowPressureThreshold;
+        this.rainSensorPolarity = options.rainSensorPolarity;
+        this.moistureSensorPolarity = options.moistureSensorPolarity;
+    }
+    static from(raw, ctx) {
+        validatePayload(raw.payload.length >= 2);
+        const masterValveDelay = raw.payload[0];
+        let offset = 1;
+        let highPressureThreshold;
+        {
+            const { value, scale, bytesRead } = parseFloatWithScale(raw.payload.subarray(offset));
+            validatePayload(scale === 0 /* kPa */);
+            highPressureThreshold = value;
+            offset += bytesRead;
+        }
+        let lowPressureThreshold;
+        {
+            const { value, scale, bytesRead } = parseFloatWithScale(raw.payload.subarray(offset));
+            validatePayload(scale === 0 /* kPa */);
+            lowPressureThreshold = value;
+            offset += bytesRead;
+        }
+        validatePayload(raw.payload.length >= offset + 1);
+        const polarity = raw.payload[offset];
+        let rainSensorPolarity;
+        let moistureSensorPolarity;
+        if (!!(polarity & 0b1000_0000)) {
+            // The valid bit is set
+            rainSensorPolarity = polarity & 0b1;
+            moistureSensorPolarity = (polarity & 0b10) >>> 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 != undefined) {
+            message["rain sensor polarity"] = getEnumMemberName(IrrigationSensorPolarity, this.rainSensorPolarity);
+        }
+        if (this.moistureSensorPolarity != undefined) {
+            message["moisture sensor polarity"] = getEnumMemberName(IrrigationSensorPolarity, this.moistureSensorPolarity);
+        }
+        return {
+            ...super.toLogEntry(ctx),
+            message,
+        };
+    }
+};
+__decorate([
+    ccValue(IrrigationCCValues.masterValveDelay)
+], IrrigationCCSystemConfigReport.prototype, "masterValveDelay", void 0);
+__decorate([
+    ccValue(IrrigationCCValues.highPressureThreshold)
+], IrrigationCCSystemConfigReport.prototype, "highPressureThreshold", void 0);
+__decorate([
+    ccValue(IrrigationCCValues.lowPressureThreshold)
+], IrrigationCCSystemConfigReport.prototype, "lowPressureThreshold", void 0);
+__decorate([
+    ccValue(IrrigationCCValues.rainSensorPolarity)
+], IrrigationCCSystemConfigReport.prototype, "rainSensorPolarity", void 0);
+__decorate([
+    ccValue(IrrigationCCValues.moistureSensorPolarity)
+], IrrigationCCSystemConfigReport.prototype, "moistureSensorPolarity", void 0);
+IrrigationCCSystemConfigReport = IrrigationCCSystemConfigReport_1 = __decorate([
+    CCCommand(IrrigationCommand.SystemConfigReport)
+], IrrigationCCSystemConfigReport);
+export { IrrigationCCSystemConfigReport };
+let IrrigationCCSystemConfigGet = class IrrigationCCSystemConfigGet extends IrrigationCC {
+};
+IrrigationCCSystemConfigGet = __decorate([
+    CCCommand(IrrigationCommand.SystemConfigGet),
+    expectedCCResponse(IrrigationCCSystemConfigReport)
+], IrrigationCCSystemConfigGet);
+export { IrrigationCCSystemConfigGet };
+let IrrigationCCValveInfoReport = IrrigationCCValveInfoReport_1 = class IrrigationCCValveInfoReport extends IrrigationCC {
+    constructor(options) {
+        super(options);
+        // TODO: Check implementation:
+        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) {
+        validatePayload(raw.payload.length >= 4);
+        let valveId;
+        if ((raw.payload[0] & 0b1) === ValveType.MasterValve) {
+            valveId = "master";
+        }
+        else {
+            valveId = raw.payload[1];
+        }
+        const connected = !!(raw.payload[0] & 0b10);
+        const nominalCurrent = 10 * raw.payload[2];
+        const errorShortCircuit = !!(raw.payload[3] & 0b1);
+        const errorHighCurrent = !!(raw.payload[3] & 0b10);
+        const errorLowCurrent = !!(raw.payload[3] & 0b100);
+        let errorMaximumFlow;
+        let errorHighFlow;
+        let errorLowFlow;
+        if (valveId === "master") {
+            errorMaximumFlow = !!(raw.payload[3] & 0b1000);
+            errorHighFlow = !!(raw.payload[3] & 0b1_0000);
+            errorLowFlow = !!(raw.payload[3] & 0b10_0000);
+        }
+        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;
+        // connected
+        const valveConnectedValue = IrrigationCCValues.valveConnected(this.valveId);
+        this.ensureMetadata(ctx, valveConnectedValue);
+        this.setValue(ctx, valveConnectedValue, this.connected);
+        // nominalCurrent
+        const nominalCurrentValue = IrrigationCCValues.nominalCurrent(this.valveId);
+        this.ensureMetadata(ctx, nominalCurrentValue);
+        this.setValue(ctx, nominalCurrentValue, this.nominalCurrent);
+        // errorShortCircuit
+        const errorShortCircuitValue = IrrigationCCValues.errorShortCircuit(this.valveId);
+        this.ensureMetadata(ctx, errorShortCircuitValue);
+        this.setValue(ctx, errorShortCircuitValue, this.errorShortCircuit);
+        // errorHighCurrent
+        const errorHighCurrentValue = IrrigationCCValues.errorHighCurrent(this.valveId);
+        this.ensureMetadata(ctx, errorHighCurrentValue);
+        this.setValue(ctx, errorHighCurrentValue, this.errorHighCurrent);
+        // errorLowCurrent
+        const errorLowCurrentValue = IrrigationCCValues.errorLowCurrent(this.valveId);
+        this.ensureMetadata(ctx, errorLowCurrentValue);
+        this.setValue(ctx, errorLowCurrentValue, this.errorLowCurrent);
+        if (this.errorMaximumFlow != undefined) {
+            const errorMaximumFlowValue = IrrigationCCValues.errorMaximumFlow(this.valveId);
+            this.ensureMetadata(ctx, errorMaximumFlowValue);
+            this.setValue(ctx, errorMaximumFlowValue, this.errorMaximumFlow);
+        }
+        if (this.errorHighFlow != undefined) {
+            const errorHighFlowValue = IrrigationCCValues.errorHighFlow(this.valveId);
+            this.ensureMetadata(ctx, errorHighFlowValue);
+            this.setValue(ctx, errorHighFlowValue, this.errorHighFlow);
+        }
+        if (this.errorLowFlow != undefined) {
+            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" : undefined,
+            this.errorHighCurrent ? "current above high threshold" : undefined,
+            this.errorLowCurrent ? "current below low threshold" : undefined,
+            this.errorMaximumFlow ? "maximum flow" : undefined,
+            this.errorHighFlow ? "flow above high threshold" : undefined,
+            this.errorLowFlow ? "flow below low threshold" : undefined,
+        ].filter(Boolean);
+        if (errors.length > 0) {
+            message.errors = errors.map((e) => `\n· ${e}`).join("");
+        }
+        return {
+            ...super.toLogEntry(ctx),
+            message,
+        };
+    }
+};
+IrrigationCCValveInfoReport = IrrigationCCValveInfoReport_1 = __decorate([
+    CCCommand(IrrigationCommand.ValveInfoReport)
+], IrrigationCCValveInfoReport);
+export { IrrigationCCValveInfoReport };
+function testResponseForIrrigationCommandWithValveId(sent, received) {
+    return received.valveId === sent.valveId;
+}
+let IrrigationCCValveInfoGet = class IrrigationCCValveInfoGet extends IrrigationCC {
+    constructor(options) {
+        super(options);
+        this.valveId = options.valveId;
+    }
+    static from(_raw, _ctx) {
+        // TODO: Deserialize payload
+        throw new ZWaveError(`${this.name}: deserialization not implemented`, ZWaveErrorCodes.Deserialization_NotImplemented);
+        // return new IrrigationCCValveInfoGet({
+        // 	nodeId: ctx.sourceNodeId,
+        // });
+    }
+    valveId;
+    serialize(ctx) {
+        this.payload = 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([
+    CCCommand(IrrigationCommand.ValveInfoGet),
+    expectedCCResponse(IrrigationCCValveInfoReport, testResponseForIrrigationCommandWithValveId)
+], IrrigationCCValveInfoGet);
+export { IrrigationCCValveInfoGet };
+let IrrigationCCValveConfigSet = class IrrigationCCValveConfigSet 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) {
+        // TODO: Deserialize payload
+        throw new ZWaveError(`${this.name}: deserialization not implemented`, ZWaveErrorCodes.Deserialization_NotImplemented);
+        // return new IrrigationCCValveConfigSet({
+        // 	nodeId: ctx.sourceNodeId,
+        // });
+    }
+    valveId;
+    nominalCurrentHighThreshold;
+    nominalCurrentLowThreshold;
+    maximumFlow;
+    highFlowThreshold;
+    lowFlowThreshold;
+    useRainSensor;
+    useMoistureSensor;
+    serialize(ctx) {
+        this.payload = Bytes.concat([
+            Bytes.from([
+                this.valveId === "master" ? 1 : 0,
+                this.valveId === "master" ? 1 : this.valveId || 1,
+                Math.floor(this.nominalCurrentHighThreshold / 10),
+                Math.floor(this.nominalCurrentLowThreshold / 10),
+            ]),
+            encodeFloatWithScale(this.maximumFlow, 0 /* l/h */),
+            encodeFloatWithScale(this.highFlowThreshold, 0 /* l/h */),
+            encodeFloatWithScale(this.lowFlowThreshold, 0 /* l/h */),
+            Bytes.from([
+                (this.useRainSensor ? 0b1 : 0)
+                    | (this.useMoistureSensor ? 0b10 : 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([
+    CCCommand(IrrigationCommand.ValveConfigSet),
+    useSupervision()
+], IrrigationCCValveConfigSet);
+export { IrrigationCCValveConfigSet };
+let IrrigationCCValveConfigReport = IrrigationCCValveConfigReport_1 = class IrrigationCCValveConfigReport extends IrrigationCC {
+    constructor(options) {
+        super(options);
+        // TODO: Check implementation:
+        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) {
+        validatePayload(raw.payload.length >= 4);
+        let valveId;
+        if ((raw.payload[0] & 0b1) === 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 } = parseFloatWithScale(raw.payload.subarray(offset));
+            validatePayload(scale === 0 /* l/h */);
+            maximumFlow = value;
+            offset += bytesRead;
+        }
+        let highFlowThreshold;
+        {
+            const { value, scale, bytesRead } = parseFloatWithScale(raw.payload.subarray(offset));
+            validatePayload(scale === 0 /* l/h */);
+            highFlowThreshold = value;
+            offset += bytesRead;
+        }
+        let lowFlowThreshold;
+        {
+            const { value, scale, bytesRead } = parseFloatWithScale(raw.payload.subarray(offset));
+            validatePayload(scale === 0 /* l/h */);
+            lowFlowThreshold = value;
+            offset += bytesRead;
+        }
+        validatePayload(raw.payload.length >= offset + 1);
+        const useRainSensor = !!(raw.payload[offset] & 0b1);
+        const useMoistureSensor = !!(raw.payload[offset] & 0b10);
+        return new IrrigationCCValveConfigReport_1({
+            nodeId: ctx.sourceNodeId,
+            valveId,
+            nominalCurrentHighThreshold,
+            nominalCurrentLowThreshold,
+            maximumFlow,
+            highFlowThreshold,
+            lowFlowThreshold,
+            useRainSensor,
+            useMoistureSensor,
+        });
+    }
+    persistValues(ctx) {
+        if (!super.persistValues(ctx))
+            return false;
+        // nominalCurrentHighThreshold
+        const nominalCurrentHighThresholdValue = IrrigationCCValues
+            .nominalCurrentHighThreshold(this.valveId);
+        this.ensureMetadata(ctx, nominalCurrentHighThresholdValue);
+        this.setValue(ctx, nominalCurrentHighThresholdValue, this.nominalCurrentHighThreshold);
+        // nominalCurrentLowThreshold
+        const nominalCurrentLowThresholdValue = IrrigationCCValues
+            .nominalCurrentLowThreshold(this.valveId);
+        this.ensureMetadata(ctx, nominalCurrentLowThresholdValue);
+        this.setValue(ctx, nominalCurrentLowThresholdValue, this.nominalCurrentLowThreshold);
+        // maximumFlow
+        const maximumFlowValue = IrrigationCCValues.maximumFlow(this.valveId);
+        this.ensureMetadata(ctx, maximumFlowValue);
+        this.setValue(ctx, maximumFlowValue, this.maximumFlow);
+        // highFlowThreshold
+        const highFlowThresholdValue = IrrigationCCValues.highFlowThreshold(this.valveId);
+        this.ensureMetadata(ctx, highFlowThresholdValue);
+        this.setValue(ctx, highFlowThresholdValue, this.highFlowThreshold);
+        // lowFlowThreshold
+        const lowFlowThresholdValue = IrrigationCCValues.lowFlowThreshold(this.valveId);
+        this.ensureMetadata(ctx, lowFlowThresholdValue);
+        this.setValue(ctx, lowFlowThresholdValue, this.lowFlowThreshold);
+        // useRainSensor
+        const useRainSensorValue = IrrigationCCValues.useRainSensor(this.valveId);
+        this.ensureMetadata(ctx, useRainSensorValue);
+        this.setValue(ctx, useRainSensorValue, this.useRainSensor);
+        // useMoistureSensor
+        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([
+    CCCommand(IrrigationCommand.ValveConfigReport)
+], IrrigationCCValveConfigReport);
+export { IrrigationCCValveConfigReport };
+let IrrigationCCValveConfigGet = class IrrigationCCValveConfigGet extends IrrigationCC {
+    constructor(options) {
+        super(options);
+        this.valveId = options.valveId;
+    }
+    static from(_raw, _ctx) {
+        // TODO: Deserialize payload
+        throw new ZWaveError(`${this.name}: deserialization not implemented`, ZWaveErrorCodes.Deserialization_NotImplemented);
+        // return new IrrigationCCValveConfigGet({
+        // 	nodeId: ctx.sourceNodeId,
+        // });
+    }
+    valveId;
+    serialize(ctx) {
+        this.payload = 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([
+    CCCommand(IrrigationCommand.ValveConfigGet),
+    expectedCCResponse(IrrigationCCValveConfigReport, testResponseForIrrigationCommandWithValveId)
+], IrrigationCCValveConfigGet);
+export { IrrigationCCValveConfigGet };
+let IrrigationCCValveRun = class IrrigationCCValveRun extends IrrigationCC {
+    constructor(options) {
+        super(options);
+        this.valveId = options.valveId;
+        this.duration = options.duration;
+    }
+    static from(_raw, _ctx) {
+        // TODO: Deserialize payload
+        throw new ZWaveError(`${this.name}: deserialization not implemented`, ZWaveErrorCodes.Deserialization_NotImplemented);
+        // return new IrrigationCCValveRun({
+        // 	nodeId: ctx.sourceNodeId,
+        // });
+    }
+    valveId;
+    duration;
+    serialize(ctx) {
+        this.payload = 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([
+    CCCommand(IrrigationCommand.ValveRun),
+    useSupervision()
+], IrrigationCCValveRun);
+export { IrrigationCCValveRun };
+let IrrigationCCValveTableSet = class IrrigationCCValveTableSet extends IrrigationCC {
+    constructor(options) {
+        super(options);
+        this.tableId = options.tableId;
+        this.entries = options.entries;
+    }
+    static from(_raw, _ctx) {
+        // TODO: Deserialize payload
+        throw new ZWaveError(`${this.name}: deserialization not implemented`, ZWaveErrorCodes.Deserialization_NotImplemented);
+        // return new IrrigationCCValveTableSet({
+        // 	nodeId: ctx.sourceNodeId,
+        // });
+    }
+    tableId;
+    entries;
+    serialize(ctx) {
+        this.payload = new 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 = 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([
+    CCCommand(IrrigationCommand.ValveTableSet),
+    useSupervision()
+], IrrigationCCValveTableSet);
+export { IrrigationCCValveTableSet };
+let IrrigationCCValveTableReport = IrrigationCCValveTableReport_1 = class IrrigationCCValveTableReport extends IrrigationCC {
+    constructor(options) {
+        super(options);
+        // TODO: Check implementation:
+        this.tableId = options.tableId;
+        this.entries = options.entries;
+    }
+    static from(raw, ctx) {
+        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 = 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([
+    CCCommand(IrrigationCommand.ValveTableReport)
+], IrrigationCCValveTableReport);
+export { IrrigationCCValveTableReport };
+function testResponseForIrrigationValveTableGet(sent, received) {
+    return received.tableId === sent.tableId;
+}
+let IrrigationCCValveTableGet = class IrrigationCCValveTableGet extends IrrigationCC {
+    constructor(options) {
+        super(options);
+        this.tableId = options.tableId;
+    }
+    static from(_raw, _ctx) {
+        // TODO: Deserialize payload
+        throw new ZWaveError(`${this.name}: deserialization not implemented`, ZWaveErrorCodes.Deserialization_NotImplemented);
+        // return new IrrigationCCValveTableGet({
+        // 	nodeId: ctx.sourceNodeId,
+        // });
+    }
+    tableId;
+    serialize(ctx) {
+        this.payload = Bytes.from([this.tableId]);
+        return super.serialize(ctx);
+    }
+    toLogEntry(ctx) {
+        return {
+            ...super.toLogEntry(ctx),
+            message: {
+                "table ID": this.tableId,
+            },
+        };
+    }
+};
+IrrigationCCValveTableGet = __decorate([
+    CCCommand(IrrigationCommand.ValveTableGet),
+    expectedCCResponse(IrrigationCCValveTableReport, testResponseForIrrigationValveTableGet)
+], IrrigationCCValveTableGet);
+export { IrrigationCCValveTableGet };
+let IrrigationCCValveTableRun = class IrrigationCCValveTableRun extends IrrigationCC {
+    constructor(options) {
+        super(options);
+        this.tableIDs = options.tableIDs;
+        if (this.tableIDs.length < 1) {
+            throw new ZWaveError(`${this.constructor.name}: At least one table ID must be specified.`, ZWaveErrorCodes.Argument_Invalid);
+        }
+    }
+    static from(_raw, _ctx) {
+        // TODO: Deserialize payload
+        throw new ZWaveError(`${this.name}: deserialization not implemented`, ZWaveErrorCodes.Deserialization_NotImplemented);
+        // return new IrrigationCCValveTableRun({
+        // 	nodeId: ctx.sourceNodeId,
+        // });
+    }
+    tableIDs;
+    serialize(ctx) {
+        this.payload = Bytes.from(this.tableIDs);
+        return super.serialize(ctx);
+    }
+    toLogEntry(ctx) {
+        return {
+            ...super.toLogEntry(ctx),
+            message: {
+                "table IDs": this.tableIDs
+                    .map((id) => padStart(id.toString(), 3, "0"))
+                    .join(", "),
+            },
+        };
+    }
+};
+IrrigationCCValveTableRun = __decorate([
+    CCCommand(IrrigationCommand.ValveTableRun),
+    useSupervision()
+], IrrigationCCValveTableRun);
+export { IrrigationCCValveTableRun };
+let IrrigationCCSystemShutoff = class IrrigationCCSystemShutoff extends IrrigationCC {
+    constructor(options) {
+        super(options);
+        this.duration = options.duration;
+    }
+    static from(_raw, _ctx) {
+        // TODO: Deserialize payload
+        throw new ZWaveError(`${this.name}: deserialization not implemented`, ZWaveErrorCodes.Deserialization_NotImplemented);
+        // return new IrrigationCCSystemShutoff({
+        // 	nodeId: ctx.sourceNodeId,
+        // });
+    }
+    duration;
+    serialize(ctx) {
+        this.payload = 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 === undefined
+                        ? "permanently"
+                        : `${this.duration} hours`,
+            },
+        };
+    }
+};
+IrrigationCCSystemShutoff = __decorate([
+    CCCommand(IrrigationCommand.SystemShutoff),
+    useSupervision()
+], IrrigationCCSystemShutoff);
+export { IrrigationCCSystemShutoff };
+//# sourceMappingURL=IrrigationCC.js.map