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

package/build/esm/cc/IndicatorCC.js

@@ -0,0 +1,1317 @@
+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 IndicatorCCSet_1, IndicatorCCReport_1, IndicatorCCGet_1, IndicatorCCSupportedReport_1, IndicatorCCSupportedGet_1, IndicatorCCDescriptionReport_1, IndicatorCCDescriptionGet_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__optional_number = $o => {
+    function _number($o) {
+        return typeof $o !== "number" ? {} : null;
+    }
+    function optional__number($o) {
+        if ($o !== undefined) {
+            const error = _number($o);
+            if (error)
+                return error;
+        }
+        return null;
+    }
+    return optional__number($o);
+};
+const __assertType__su__number_sa__5_ea_5_5_5_eu = $o => {
+    function _number($o) {
+        return typeof $o !== "number" ? {} : null;
+    }
+    function _false($o) {
+        return $o !== false ? {} : null;
+    }
+    function _true($o) {
+        return $o !== true ? {} : null;
+    }
+    function su__number__7__8_eu($o) {
+        const conditions = [_number, _false, _true];
+        for (const condition of conditions) {
+            const error = condition($o);
+            if (!error)
+                return null;
+        }
+        return {};
+    }
+    function _5($o) {
+        if (typeof $o !== "object" || $o === null || Array.isArray($o))
+            return {};
+        if ("indicatorId" in $o && $o["indicatorId"] !== undefined) {
+            const error = _number($o["indicatorId"]);
+            if (error)
+                return error;
+        }
+        else
+            return {};
+        if ("propertyId" in $o && $o["propertyId"] !== undefined) {
+            const error = _number($o["propertyId"]);
+            if (error)
+                return error;
+        }
+        else
+            return {};
+        if ("value" in $o && $o["value"] !== undefined) {
+            const error = su__number__7__8_eu($o["value"]);
+            if (error)
+                return error;
+        }
+        else
+            return {};
+        return null;
+    }
+    function sa__5_ea_5($o) {
+        if (!Array.isArray($o))
+            return {};
+        for (let i = 0; i < $o.length; i++) {
+            const error = _5($o[i]);
+            if (error)
+                return error;
+        }
+        return null;
+    }
+    function su__number_sa__5_ea_5_5_5_eu($o) {
+        const conditions = [_number, sa__5_ea_5];
+        for (const condition of conditions) {
+            const error = condition($o);
+            if (!error)
+                return null;
+        }
+        return {};
+    }
+    return su__number_sa__5_ea_5_5_5_eu($o);
+};
+const __assertType__IndicatorCCReportOptions = $o => {
+    function _number($o) {
+        return typeof $o !== "number" ? {} : null;
+    }
+    function _1($o) {
+        if (typeof $o !== "object" || $o === null || Array.isArray($o))
+            return {};
+        if ("value" in $o && $o["value"] !== undefined) {
+            const error = _number($o["value"]);
+            if (error)
+                return error;
+        }
+        else
+            return {};
+        return null;
+    }
+    function _false($o) {
+        return $o !== false ? {} : null;
+    }
+    function _true($o) {
+        return $o !== true ? {} : null;
+    }
+    function su__number__8__9_eu($o) {
+        const conditions = [_number, _false, _true];
+        for (const condition of conditions) {
+            const error = condition($o);
+            if (!error)
+                return null;
+        }
+        return {};
+    }
+    function _5($o) {
+        if (typeof $o !== "object" || $o === null || Array.isArray($o))
+            return {};
+        if ("indicatorId" in $o && $o["indicatorId"] !== undefined) {
+            const error = _number($o["indicatorId"]);
+            if (error)
+                return error;
+        }
+        else
+            return {};
+        if ("propertyId" in $o && $o["propertyId"] !== undefined) {
+            const error = _number($o["propertyId"]);
+            if (error)
+                return error;
+        }
+        else
+            return {};
+        if ("value" in $o && $o["value"] !== undefined) {
+            const error = su__number__8__9_eu($o["value"]);
+            if (error)
+                return error;
+        }
+        else
+            return {};
+        return null;
+    }
+    function sa__5_ea_5($o) {
+        if (!Array.isArray($o))
+            return {};
+        for (let i = 0; i < $o.length; i++) {
+            const error = _5($o[i]);
+            if (error)
+                return error;
+        }
+        return null;
+    }
+    function _2($o) {
+        if (typeof $o !== "object" || $o === null || Array.isArray($o))
+            return {};
+        if ("values" in $o && $o["values"] !== undefined) {
+            const error = sa__5_ea_5($o["values"]);
+            if (error)
+                return error;
+        }
+        else
+            return {};
+        return null;
+    }
+    function su__1__2_eu($o) {
+        const conditions = [_1, _2];
+        for (const condition of conditions) {
+            const error = condition($o);
+            if (!error)
+                return null;
+        }
+        return {};
+    }
+    return su__1__2_eu($o);
+};
+const __assertType__number = $o => {
+    function _number($o) {
+        return typeof $o !== "number" ? {} : null;
+    }
+    return _number($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);
+};
+const __assertType__string = $o => {
+    function _string($o) {
+        return typeof $o !== "string" ? {} : null;
+    }
+    return _string($o);
+};
+const __assertType__su__undefined__string__3_eu = $o => {
+    function _undefined($o) {
+        return $o !== undefined ? {} : null;
+    }
+    function _string($o) {
+        return typeof $o !== "string" ? {} : null;
+    }
+    function _number($o) {
+        return typeof $o !== "number" ? {} : null;
+    }
+    function _3($o) {
+        if (typeof $o !== "object" || $o === null || Array.isArray($o))
+            return {};
+        if ("hours" in $o && $o["hours"] !== undefined) {
+            const error = _number($o["hours"]);
+            if (error)
+                return error;
+        }
+        if ("minutes" in $o && $o["minutes"] !== undefined) {
+            const error = _number($o["minutes"]);
+            if (error)
+                return error;
+        }
+        if ("seconds" in $o && $o["seconds"] !== undefined) {
+            const error = _number($o["seconds"]);
+            if (error)
+                return error;
+        }
+        return null;
+    }
+    function su__undefined__string__3_eu($o) {
+        const conditions = [_undefined, _string, _3];
+        for (const condition of conditions) {
+            const error = condition($o);
+            if (!error)
+                return null;
+        }
+        return {};
+    }
+    return su__undefined__string__3_eu($o);
+};
+import { CommandClasses, Indicator, MessagePriority, ValueMetadata, ZWaveError, ZWaveErrorCodes, encodeBitMask, getIndicatorProperty, parseBitMask, validatePayload, } from "@zwave-js/core/safe";
+import { Bytes } from "@zwave-js/shared/safe";
+import { num2hex } from "@zwave-js/shared/safe";
+import { clamp, roundTo } from "alcalzone-shared/math/index.js";
+import { isArray } from "alcalzone-shared/typeguards/index.js";
+import { CCAPI, POLL_VALUE, SET_VALUE, throwUnsupportedProperty, throwWrongValueType, } from "../lib/API.js";
+import { CommandClass, } from "../lib/CommandClass.js";
+import { API, CCCommand, ccValues, commandClass, expectedCCResponse, implementedVersion, useSupervision, } from "../lib/CommandClassDecorators.js";
+import { V } from "../lib/Values.js";
+import { IndicatorCommand } from "../lib/_Types.js";
+function isManufacturerDefinedIndicator(indicatorId) {
+    return indicatorId >= 0x80 && indicatorId <= 0x9f;
+}
+const timeoutStringRegex = /^(?:(?<hoursStr>\d+)h)?(?:(?<minutesStr>\d+)m)?(?:(?<secondsStr>\d+(?:\.\d+)?)s)?$/i;
+function parseIndicatorTimeoutString(text) {
+    if (!text.length)
+        return undefined;
+    // Try to parse the numeric parts from a timeout
+    const match = timeoutStringRegex.exec(text);
+    if (!match)
+        return undefined;
+    const { hoursStr, minutesStr, secondsStr } = match.groups;
+    if (!hoursStr && !minutesStr && !secondsStr)
+        return undefined;
+    const ret = {};
+    if (hoursStr) {
+        ret.hours = clamp(parseInt(hoursStr, 10), 0, 255);
+    }
+    if (minutesStr) {
+        ret.minutes = clamp(parseInt(minutesStr, 10), 0, 255);
+    }
+    if (secondsStr) {
+        ret.seconds = clamp(roundTo(parseFloat(secondsStr), 2), 0, 59.99);
+    }
+    return ret;
+}
+function indicatorObjectsToTimeout(values) {
+    const timeoutValues = values.filter((v) => [0x0a, 0x06, 0x07, 0x08].includes(v.propertyId));
+    if (!timeoutValues.length)
+        return undefined;
+    const hours = (timeoutValues.find((v) => v.propertyId === 0x0a)?.value
+        ?? 0);
+    const minutes = (timeoutValues.find((v) => v.propertyId === 0x06)?.value
+        ?? 0);
+    const seconds = clamp(timeoutValues.find((v) => v.propertyId === 0x07)
+        ?.value ?? 0, 0, 59)
+        + clamp(timeoutValues.find((v) => v.propertyId === 0x08)
+            ?.value ?? 0, 0, 99)
+            / 100;
+    return {
+        hours,
+        minutes,
+        seconds,
+    };
+}
+export const IndicatorCCValues = Object.freeze({
+    ...V.defineStaticCCValues(CommandClasses.Indicator, {
+        ...V.staticProperty("supportedIndicatorIds", undefined, {
+            internal: true,
+        }),
+        ...V.staticPropertyWithName("valueV1", "value", {
+            ...ValueMetadata.UInt8,
+            label: "Indicator value",
+            ccSpecific: {
+                indicatorId: 0,
+            },
+        }),
+        // Convenience values for indicators that are split across multiple properties
+        ...V.staticProperty("identify", {
+            ...ValueMetadata.WriteOnlyBoolean,
+            label: "Identify",
+            states: {
+                true: "Identify",
+            },
+        }, { minVersion: 3 }),
+        ...V.staticProperty("timeout", {
+            ...ValueMetadata.String,
+            label: "Timeout",
+        }, { minVersion: 3 }),
+    }),
+    ...V.defineDynamicCCValues(CommandClasses.Indicator, {
+        ...V.dynamicPropertyAndKeyWithName("supportedPropertyIDs", "supportedPropertyIDs", (indicatorId) => indicatorId, ({ property, propertyKey }) => property === "supportedPropertyIDs"
+            && typeof propertyKey === "number", undefined, { internal: true }),
+        ...V.dynamicPropertyAndKeyWithName("valueV2", 
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        (indicatorId, propertyId) => indicatorId, (indicatorId, propertyId) => propertyId, ({ property, propertyKey }) => typeof property === "number" && typeof propertyKey === "number", 
+        // The metadata is highly dependent on the indicator and property
+        // so this is just a baseline
+        (indicatorId, propertyId) => ({
+            ...ValueMetadata.Any,
+            ccSpecific: {
+                indicatorId,
+                propertyId,
+            },
+        }), { minVersion: 2 }),
+        ...V.dynamicPropertyWithName("indicatorDescription", (indicatorId) => indicatorId, ({ property }) => typeof property === "number", undefined, { internal: true, minVersion: 4 }),
+    }),
+});
+/**
+ * Looks up the configured metadata for the given indicator and property
+ */
+function getIndicatorMetadata(indicatorId, propertyId, overrideIndicatorLabel) {
+    const label = overrideIndicatorLabel
+        || getIndicatorName(indicatorId);
+    const prop = getIndicatorProperty(propertyId);
+    const baseMetadata = IndicatorCCValues.valueV2(indicatorId, propertyId).meta;
+    if (!label && !prop) {
+        return {
+            ...baseMetadata,
+            ...ValueMetadata.UInt8,
+        };
+    }
+    else if (!prop) {
+        return {
+            ...baseMetadata,
+            ...ValueMetadata.UInt8,
+            label,
+        };
+    }
+    else {
+        if (prop.type === "boolean") {
+            return {
+                ...baseMetadata,
+                ...ValueMetadata.Boolean,
+                label: `${label} - ${prop.label}`,
+                description: prop.description,
+                readable: !prop.readonly,
+            };
+        }
+        else {
+            // UInt8
+            return {
+                ...baseMetadata,
+                ...ValueMetadata.UInt8,
+                label: `${label} - ${prop.label}`,
+                description: prop.description,
+                min: prop.min,
+                max: prop.max,
+                readable: !prop.readonly,
+            };
+        }
+    }
+}
+function getIndicatorName(indicatorId) {
+    if (indicatorId) {
+        return `${num2hex(indicatorId)} (${indicatorId in Indicator ? Indicator[indicatorId] : "Unknown"})`;
+    }
+    else {
+        return "0 (default)";
+    }
+}
+const MAX_INDICATOR_OBJECTS = 31;
+let IndicatorCCAPI = class IndicatorCCAPI extends CCAPI {
+    supportsCommand(cmd) {
+        switch (cmd) {
+            case IndicatorCommand.Get:
+            case IndicatorCommand.Report:
+                return this.isSinglecast();
+            case IndicatorCommand.Set:
+                return true; // This is mandatory
+            case IndicatorCommand.SupportedGet:
+            case IndicatorCommand.SupportedReport:
+                return this.version >= 2 && this.isSinglecast();
+            case IndicatorCommand.DescriptionGet:
+            case IndicatorCommand.DescriptionReport:
+                return this.version >= 4 && this.isSinglecast();
+        }
+        return super.supportsCommand(cmd);
+    }
+    get [SET_VALUE]() {
+        return async function ({ property, propertyKey }, value) {
+            if (property === "value") {
+                // V1 value
+                if (typeof value !== "number") {
+                    throwWrongValueType(this.ccId, property, "number", typeof value);
+                }
+                return this.set(value);
+            }
+            else if (typeof property === "number"
+                && typeof propertyKey === "number") {
+                const indicatorId = property;
+                const propertyId = propertyKey;
+                const expectedType = getIndicatorMetadata(indicatorId, propertyId).type;
+                // V2+ value
+                if (typeof value !== expectedType) {
+                    throwWrongValueType(this.ccId, property, expectedType, typeof value);
+                }
+                return this.set([
+                    {
+                        indicatorId: property,
+                        propertyId: propertyKey,
+                        value: value,
+                    },
+                ]);
+            }
+            else if (property === "identify") {
+                if (typeof value !== "boolean") {
+                    throwWrongValueType(this.ccId, property, "boolean", typeof value);
+                }
+                return this.identify();
+            }
+            else {
+                throwUnsupportedProperty(this.ccId, property);
+            }
+        };
+    }
+    get [POLL_VALUE]() {
+        return async function ({ property }) {
+            if (property === "value")
+                return this.get();
+            if (typeof property === "number") {
+                return this.get(property);
+            }
+            throwUnsupportedProperty(this.ccId, property);
+        };
+    }
+    async get(indicatorId) {
+        __assertType("indicatorId", "(optional) number", __assertType__optional_number.bind(void 0, indicatorId));
+        this.assertSupportsCommand(IndicatorCommand, IndicatorCommand.Get);
+        const cc = new IndicatorCCGet({
+            nodeId: this.endpoint.nodeId,
+            endpointIndex: this.endpoint.index,
+            indicatorId,
+        });
+        const response = await this.host.sendCommand(cc, this.commandOptions);
+        if (!response)
+            return;
+        if (response.values)
+            return response.values;
+        return response.indicator0Value;
+    }
+    async set(value) {
+        __assertType("value", undefined, __assertType__su__number_sa__5_ea_5_5_5_eu.bind(void 0, value));
+        this.assertSupportsCommand(IndicatorCommand, IndicatorCommand.Set);
+        if (this.version === 1 && typeof value !== "number") {
+            throw new ZWaveError(`Node ${this.endpoint
+                .nodeId} only supports IndicatorCC V1 which requires a single value to be set`, ZWaveErrorCodes.Argument_Invalid);
+        }
+        else if (this.version >= 2
+            && isArray(value)
+            && value.length > MAX_INDICATOR_OBJECTS) {
+            throw new ZWaveError(`Only ${MAX_INDICATOR_OBJECTS} indicator values can be set at a time!`, ZWaveErrorCodes.Argument_Invalid);
+        }
+        const cc = new IndicatorCCSet({
+            nodeId: this.endpoint.nodeId,
+            endpointIndex: this.endpoint.index,
+            ...(typeof value === "number" ? { value } : { values: value }),
+        });
+        return this.host.sendCommand(cc, this.commandOptions);
+    }
+    async sendReport(options) {
+        __assertType("options", "IndicatorCCReportOptions", __assertType__IndicatorCCReportOptions.bind(void 0, options));
+        this.assertSupportsCommand(IndicatorCommand, IndicatorCommand.Report);
+        const cc = new IndicatorCCReport({
+            nodeId: this.endpoint.nodeId,
+            endpointIndex: this.endpoint.index,
+            ...options,
+        });
+        await this.host.sendCommand(cc, this.commandOptions);
+    }
+    async getSupported(indicatorId) {
+        __assertType("indicatorId", "number", __assertType__number.bind(void 0, indicatorId));
+        this.assertSupportsCommand(IndicatorCommand, IndicatorCommand.SupportedGet);
+        const cc = new IndicatorCCSupportedGet({
+            nodeId: this.endpoint.nodeId,
+            endpointIndex: this.endpoint.index,
+            indicatorId,
+        });
+        const response = await this.host.sendCommand(cc, this.commandOptions);
+        if (response) {
+            return {
+                // Include the actual indicator ID if 0x00 was requested
+                ...(indicatorId === 0x00
+                    ? { indicatorId: response.indicatorId }
+                    : undefined),
+                supportedProperties: response.supportedProperties,
+                nextIndicatorId: response.nextIndicatorId,
+            };
+        }
+    }
+    async reportSupported(indicatorId, supportedProperties, nextIndicatorId) {
+        __assertType("indicatorId", "number", __assertType__number.bind(void 0, indicatorId));
+        __assertType("supportedProperties", undefined, __assertType__sa__number_ea_2.bind(void 0, supportedProperties));
+        __assertType("nextIndicatorId", "number", __assertType__number.bind(void 0, nextIndicatorId));
+        this.assertSupportsCommand(IndicatorCommand, IndicatorCommand.SupportedReport);
+        const cc = new IndicatorCCSupportedReport({
+            nodeId: this.endpoint.nodeId,
+            endpointIndex: this.endpoint.index,
+            indicatorId,
+            supportedProperties,
+            nextIndicatorId,
+        });
+        await this.host.sendCommand(cc, this.commandOptions);
+    }
+    async reportDescription(indicatorId, description) {
+        __assertType("indicatorId", "number", __assertType__number.bind(void 0, indicatorId));
+        __assertType("description", "string", __assertType__string.bind(void 0, description));
+        this.assertSupportsCommand(IndicatorCommand, IndicatorCommand.DescriptionReport);
+        const cc = new IndicatorCCDescriptionReport({
+            nodeId: this.endpoint.nodeId,
+            endpointIndex: this.endpoint.index,
+            indicatorId,
+            description,
+        });
+        await this.host.sendCommand(cc, this.commandOptions);
+    }
+    /**
+     * Instructs the node to identify itself. Available starting with V3 of this CC.
+     */
+    async identify() {
+        if (this.version < 3) {
+            throw new ZWaveError(`The identify command is only supported in Indicator CC version 3 and above`, ZWaveErrorCodes.CC_NotSupported);
+        }
+        return this.set([
+            {
+                indicatorId: 0x50,
+                propertyId: 0x03,
+                value: 0x08,
+            },
+            {
+                indicatorId: 0x50,
+                propertyId: 0x04,
+                value: 0x03,
+            },
+            {
+                indicatorId: 0x50,
+                propertyId: 0x05,
+                value: 0x06,
+            },
+        ]);
+    }
+    /**
+     * Set a timeout for a given indicator ID after which the indicator will be turned off.
+     * @param timeout The timeout in one of the supported forms:
+     * 	- a timeout string in the form `12h18m17.59s`. All parts (hours, minutes, seconds, hundredths) are optional, but must be specified in this order. An empty string will be treated like `undefined`.
+     * 	- an object specifying the timeout parts. An empty object will be treated like `undefined`.
+     * 	- `undefined` to disable the timeout.
+     */
+    async setTimeout(indicatorId, timeout) {
+        __assertType("indicatorId", "number", __assertType__number.bind(void 0, indicatorId));
+        __assertType("timeout", undefined, __assertType__su__undefined__string__3_eu.bind(void 0, timeout));
+        this.assertPhysicalEndpoint(this.endpoint);
+        if (this.version < 3) {
+            throw new ZWaveError(`The setTimeout command is only supported in Indicator CC version 3 and above`, ZWaveErrorCodes.CC_NotSupported);
+        }
+        if (typeof timeout === "string") {
+            if (timeout === "") {
+                timeout = undefined;
+            }
+            else {
+                const parsed = parseIndicatorTimeoutString(timeout);
+                if (!parsed) {
+                    throw new ZWaveError(`The timeout string "${timeout}" is not valid`, ZWaveErrorCodes.Argument_Invalid);
+                }
+                timeout = parsed;
+            }
+        }
+        const supportedPropertyIDs = IndicatorCC.getSupportedPropertyIDsCached(this.host, this.endpoint, indicatorId);
+        const objects = [];
+        if (timeout) {
+            const hours = timeout.hours ?? 0;
+            const minutes = timeout.minutes ?? 0;
+            const seconds = Math.floor(timeout.seconds ?? 0);
+            const hundredths = Math.round(((timeout.seconds ?? 0) % 1) * 100);
+            if (hours) {
+                if (!supportedPropertyIDs?.includes(0x0a)) {
+                    throw new ZWaveError(`The indicator ${indicatorId} does not support setting the timeout in hours`, ZWaveErrorCodes.Argument_Invalid);
+                }
+                objects.push({
+                    indicatorId,
+                    propertyId: 0x0a,
+                    value: hours,
+                });
+            }
+            if (minutes) {
+                if (!supportedPropertyIDs?.includes(0x06)) {
+                    throw new ZWaveError(`The indicator ${indicatorId} does not support setting the timeout in minutes`, ZWaveErrorCodes.Argument_Invalid);
+                }
+                objects.push({
+                    indicatorId,
+                    propertyId: 0x06,
+                    value: minutes,
+                });
+            }
+            if (seconds) {
+                if (!supportedPropertyIDs?.includes(0x07)) {
+                    throw new ZWaveError(`The indicator ${indicatorId} does not support setting the timeout in seconds`, ZWaveErrorCodes.Argument_Invalid);
+                }
+                objects.push({
+                    indicatorId,
+                    propertyId: 0x07,
+                    value: seconds,
+                });
+            }
+            if (hundredths) {
+                if (!supportedPropertyIDs?.includes(0x08)) {
+                    throw new ZWaveError(`The indicator ${indicatorId} does not support setting the timeout in 1/100 seconds`, ZWaveErrorCodes.Argument_Invalid);
+                }
+                objects.push({
+                    indicatorId,
+                    propertyId: 0x08,
+                    value: hundredths,
+                });
+            }
+        }
+        if (!objects.length) {
+            objects.push(...(supportedPropertyIDs ?? []).map((p) => ({
+                indicatorId,
+                propertyId: p,
+                value: 0,
+            })));
+        }
+        return this.set(objects);
+    }
+    /**
+     * Returns the timeout after which the given indicator will be turned off.
+     */
+    async getTimeout(indicatorId) {
+        __assertType("indicatorId", "number", __assertType__number.bind(void 0, indicatorId));
+        const values = await this.get(indicatorId);
+        if (!isArray(values))
+            return;
+        return indicatorObjectsToTimeout(values);
+    }
+    async getDescription(indicatorId) {
+        __assertType("indicatorId", "number", __assertType__number.bind(void 0, indicatorId));
+        this.assertSupportsCommand(IndicatorCommand, IndicatorCommand.DescriptionGet);
+        const cc = new IndicatorCCDescriptionGet({
+            nodeId: this.endpoint.nodeId,
+            endpointIndex: this.endpoint.index,
+            indicatorId,
+        });
+        const response = await this.host.sendCommand(cc, this.commandOptions);
+        return response?.description;
+    }
+};
+IndicatorCCAPI = __decorate([
+    API(CommandClasses.Indicator)
+], IndicatorCCAPI);
+export { IndicatorCCAPI };
+let IndicatorCC = class IndicatorCC extends CommandClass {
+    async interview(ctx) {
+        const node = this.getNode(ctx);
+        const endpoint = this.getEndpoint(ctx);
+        const api = CCAPI.create(CommandClasses.Indicator, ctx, endpoint).withOptions({
+            priority: MessagePriority.NodeQuery,
+        });
+        ctx.logNode(node.id, {
+            endpoint: this.endpointIndex,
+            message: `Interviewing ${this.ccName}...`,
+            direction: "none",
+        });
+        if (api.version > 1) {
+            ctx.logNode(node.id, {
+                endpoint: this.endpointIndex,
+                message: "scanning supported indicator IDs...",
+                direction: "outbound",
+            });
+            // Query ID 0 to get the first supported ID
+            let curId = 0x00;
+            const supportedIndicatorIds = [];
+            do {
+                const supportedResponse = await api.getSupported(curId);
+                if (!supportedResponse) {
+                    ctx.logNode(node.id, {
+                        endpoint: this.endpointIndex,
+                        message: "Time out while scanning supported indicator IDs, skipping interview...",
+                        level: "warn",
+                    });
+                    return;
+                }
+                supportedIndicatorIds.push(supportedResponse.indicatorId ?? curId);
+                curId = supportedResponse.nextIndicatorId;
+            } while (curId !== 0x00);
+            // The IDs are not stored by the report CCs so store them here once we have all of them
+            this.setValue(ctx, IndicatorCCValues.supportedIndicatorIds, supportedIndicatorIds);
+            const logMessage = `supported indicator IDs: ${supportedIndicatorIds.join(", ")}`;
+            ctx.logNode(node.id, {
+                endpoint: this.endpointIndex,
+                message: logMessage,
+                direction: "inbound",
+            });
+            if (api.version >= 4) {
+                const manufacturerDefinedIndicatorIds = supportedIndicatorIds
+                    .filter((id) => isManufacturerDefinedIndicator(id));
+                if (manufacturerDefinedIndicatorIds.length > 0) {
+                    ctx.logNode(node.id, {
+                        endpoint: this.endpointIndex,
+                        message: "retrieving description for manufacturer-defined indicator IDs...",
+                        direction: "outbound",
+                    });
+                    for (const id of manufacturerDefinedIndicatorIds) {
+                        await api.getDescription(id);
+                    }
+                }
+            }
+        }
+        // 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.Indicator, ctx, endpoint).withOptions({
+            priority: MessagePriority.NodeQuery,
+        });
+        if (api.version === 1) {
+            ctx.logNode(node.id, {
+                endpoint: this.endpointIndex,
+                message: "requesting current indicator value...",
+                direction: "outbound",
+            });
+            await api.get();
+        }
+        else {
+            const supportedIndicatorIds = this.getValue(ctx, IndicatorCCValues.supportedIndicatorIds) ?? [];
+            for (const indicatorId of supportedIndicatorIds) {
+                ctx.logNode(node.id, {
+                    endpoint: this.endpointIndex,
+                    message: `requesting current indicator value (id = ${num2hex(indicatorId)})...`,
+                    direction: "outbound",
+                });
+                await api.get(indicatorId);
+            }
+        }
+    }
+    translatePropertyKey(ctx, property, propertyKey) {
+        if (property === "value") {
+            // CC version 1 only has a single value that doesn't need to be translated
+            return undefined;
+        }
+        else if (typeof property === "number"
+            && typeof propertyKey === "number") {
+            // The indicator property is our property key
+            const prop = getIndicatorProperty(propertyKey);
+            if (prop)
+                return prop.label;
+        }
+        return super.translatePropertyKey(ctx, property, propertyKey);
+    }
+    translateProperty(ctx, property, propertyKey) {
+        if (typeof property === "number" && typeof propertyKey === "number") {
+            // The indicator corresponds to our property
+            if (property in Indicator)
+                return Indicator[property];
+        }
+        return super.translateProperty(ctx, property, propertyKey);
+    }
+    supportsV2Indicators(ctx) {
+        // First test if there are any indicator ids defined
+        const supportedIndicatorIds = this.getValue(ctx, IndicatorCCValues.supportedIndicatorIds);
+        if (!supportedIndicatorIds?.length)
+            return false;
+        // Then test if there are any property ids defined
+        return supportedIndicatorIds.some((indicatorId) => !!this.getValue(ctx, IndicatorCCValues.supportedPropertyIDs(indicatorId))?.length);
+    }
+    static getSupportedPropertyIDsCached(ctx, endpoint, indicatorId) {
+        return ctx
+            .getValueDB(endpoint.nodeId)
+            .getValue(IndicatorCCValues.supportedPropertyIDs(indicatorId).endpoint(endpoint.index));
+    }
+};
+IndicatorCC = __decorate([
+    commandClass(CommandClasses.Indicator),
+    implementedVersion(4),
+    ccValues(IndicatorCCValues)
+], IndicatorCC);
+export { IndicatorCC };
+let IndicatorCCSet = IndicatorCCSet_1 = class IndicatorCCSet extends IndicatorCC {
+    constructor(options) {
+        super(options);
+        if ("value" in options) {
+            this.indicator0Value = options.value;
+        }
+        else {
+            this.values = options.values;
+        }
+    }
+    static from(raw, ctx) {
+        validatePayload(raw.payload.length >= 1);
+        const objCount = raw.payload.length >= 2
+            ? raw.payload[1] & 0b11111
+            : 0;
+        if (objCount === 0) {
+            const indicator0Value = raw.payload[0];
+            return new IndicatorCCSet_1({
+                nodeId: ctx.sourceNodeId,
+                value: indicator0Value,
+            });
+        }
+        validatePayload(raw.payload.length >= 2 + 3 * objCount);
+        const values = [];
+        for (let i = 0; i < objCount; i++) {
+            const offset = 2 + 3 * i;
+            const value = {
+                indicatorId: raw.payload[offset],
+                propertyId: raw.payload[offset + 1],
+                value: raw.payload[offset + 2],
+            };
+            values.push(value);
+        }
+        return new IndicatorCCSet_1({
+            nodeId: ctx.sourceNodeId,
+            values,
+        });
+    }
+    indicator0Value;
+    values;
+    serialize(ctx) {
+        if (this.values != undefined) {
+            // V2+
+            this.payload = Bytes.alloc(2 + 3 * this.values.length, 0);
+            // Byte 0 is the legacy value
+            const objCount = this.values.length & MAX_INDICATOR_OBJECTS;
+            this.payload[1] = objCount;
+            for (let i = 0; i < objCount; i++) {
+                const offset = 2 + 3 * i;
+                this.payload[offset] = this.values[i].indicatorId;
+                this.payload[offset + 1] = this.values[i].propertyId;
+                const value = this.values[i].value;
+                this.payload[offset + 2] = value === true
+                    ? 0xff
+                    : value === false
+                        ? 0x00
+                        : value;
+            }
+        }
+        else {
+            // V1
+            this.payload = Bytes.from([this.indicator0Value ?? 0]);
+        }
+        return super.serialize(ctx);
+    }
+    toLogEntry(ctx) {
+        const message = {};
+        if (this.indicator0Value != undefined) {
+            message["indicator 0 value"] = this.indicator0Value;
+        }
+        if (this.values != undefined) {
+            message.values = `${this.values
+                .map((v) => `
+· indicatorId: ${v.indicatorId}
+  propertyId:  ${v.propertyId}
+  value:       ${v.value}`)
+                .join("")}`;
+        }
+        return {
+            ...super.toLogEntry(ctx),
+            message,
+        };
+    }
+};
+IndicatorCCSet = IndicatorCCSet_1 = __decorate([
+    CCCommand(IndicatorCommand.Set),
+    useSupervision()
+], IndicatorCCSet);
+export { IndicatorCCSet };
+let IndicatorCCReport = IndicatorCCReport_1 = class IndicatorCCReport extends IndicatorCC {
+    constructor(options) {
+        super(options);
+        if ("value" in options) {
+            this.indicator0Value = options.value;
+        }
+        else if ("values" in options) {
+            if (options.values.length > MAX_INDICATOR_OBJECTS) {
+                throw new ZWaveError(`Only ${MAX_INDICATOR_OBJECTS} indicator values can be set at a time!`, ZWaveErrorCodes.Argument_Invalid);
+            }
+            this.values = options.values;
+        }
+    }
+    static from(raw, ctx) {
+        validatePayload(raw.payload.length >= 1);
+        const objCount = raw.payload.length >= 2
+            ? raw.payload[1] & 0b11111
+            : 0;
+        if (objCount === 0) {
+            const indicator0Value = raw.payload[0];
+            return new IndicatorCCReport_1({
+                nodeId: ctx.sourceNodeId,
+                value: indicator0Value,
+            });
+        }
+        validatePayload(raw.payload.length >= 2 + 3 * objCount);
+        const values = [];
+        for (let i = 0; i < objCount; i++) {
+            const offset = 2 + 3 * i;
+            const value = {
+                indicatorId: raw.payload[offset],
+                propertyId: raw.payload[offset + 1],
+                value: raw.payload[offset + 2],
+            };
+            values.push(value);
+        }
+        return new IndicatorCCReport_1({
+            nodeId: ctx.sourceNodeId,
+            values,
+        });
+        // TODO: Think if we want this:
+        // // If not all Property IDs are included in the command for the actual Indicator ID,
+        // // a controlling node MUST assume non-specified Property IDs values to be 0x00.
+        // const indicatorId = this.values[0].indicatorId;
+        // const supportedIndicatorProperties =
+        // 	valueDB.getValue<number[]>(
+        // 		getSupportedPropertyIDsValueID(
+        // 			this.endpointIndex,
+        // 			indicatorId,
+        // 		),
+        // 	) ?? [];
+        // // Find out which ones are missing
+        // const missingIndicatorProperties = supportedIndicatorProperties.filter(
+        // 	prop =>
+        // 		!this.values!.find(({ propertyId }) => prop === propertyId),
+        // );
+        // // And assume they are 0 (false)
+        // for (const missing of missingIndicatorProperties) {
+        // 	this.setIndicatorValue({
+        // 		indicatorId,
+        // 		propertyId: missing,
+        // 		value: 0,
+        // 	});
+        // }
+    }
+    persistValues(ctx) {
+        if (!super.persistValues(ctx))
+            return false;
+        if (this.indicator0Value != undefined) {
+            if (!this.supportsV2Indicators(ctx)) {
+                // Publish the value
+                const valueV1 = IndicatorCCValues.valueV1;
+                this.setMetadata(ctx, valueV1);
+                this.setValue(ctx, valueV1, this.indicator0Value);
+            }
+            else {
+                if (this.isSinglecast()) {
+                    // Don't!
+                    ctx.logNode(this.nodeId, {
+                        message: `ignoring V1 indicator report because the node supports V2 indicators`,
+                        direction: "none",
+                        endpoint: this.endpointIndex,
+                    });
+                }
+            }
+        }
+        else if (this.values) {
+            // Store the simple values first
+            for (const value of this.values) {
+                this.setIndicatorValue(ctx, value);
+            }
+            // Then group values into the convenience properties
+            // ... timeout
+            const timeout = indicatorObjectsToTimeout(this.values);
+            if (timeout) {
+                let timeoutString = "";
+                if (timeout?.hours)
+                    timeoutString += `${timeout.hours}h`;
+                if (timeout?.minutes)
+                    timeoutString += `${timeout.minutes}m`;
+                if (timeout?.seconds)
+                    timeoutString += `${timeout.seconds}s`;
+                this.setValue(ctx, IndicatorCCValues.timeout, timeoutString);
+            }
+        }
+        return true;
+    }
+    indicator0Value;
+    values;
+    setIndicatorValue(ctx, value) {
+        // Manufacturer-defined indicators may need a custom label
+        const overrideIndicatorLabel = isManufacturerDefinedIndicator(value.indicatorId)
+            ? this.getValue(ctx, IndicatorCCValues.indicatorDescription(value.indicatorId))
+            : undefined;
+        const metadata = getIndicatorMetadata(value.indicatorId, value.propertyId, overrideIndicatorLabel);
+        // Some values need to be converted
+        if (metadata.type === "boolean") {
+            value.value = !!value.value;
+        }
+        // Publish the value
+        const valueV2 = IndicatorCCValues.valueV2(value.indicatorId, value.propertyId);
+        this.setMetadata(ctx, valueV2, metadata);
+        this.setValue(ctx, valueV2, value.value);
+    }
+    serialize(ctx) {
+        if (this.values != undefined) {
+            // V2+
+            this.payload = Bytes.alloc(2 + 3 * this.values.length, 0);
+            // Byte 0 is the legacy value
+            const objCount = this.values.length & MAX_INDICATOR_OBJECTS;
+            this.payload[1] = objCount;
+            for (let i = 0; i < objCount; i++) {
+                const offset = 2 + 3 * i;
+                this.payload[offset] = this.values[i].indicatorId;
+                this.payload[offset + 1] = this.values[i].propertyId;
+                const value = this.values[i].value;
+                this.payload[offset + 2] = value === true
+                    ? 0xff
+                    : value === false
+                        ? 0x00
+                        : value;
+            }
+        }
+        else {
+            // V1
+            this.payload = Bytes.from([this.indicator0Value ?? 0]);
+        }
+        return super.serialize(ctx);
+    }
+    toLogEntry(ctx) {
+        const message = {};
+        if (this.indicator0Value != undefined) {
+            message["indicator 0 value"] = this.indicator0Value;
+        }
+        if (this.values != undefined) {
+            message.values = `${this.values
+                .map((v) => `
+· indicatorId: ${v.indicatorId}
+  propertyId:  ${v.propertyId}
+  value:       ${v.value}`)
+                .join("")}`;
+        }
+        return {
+            ...super.toLogEntry(ctx),
+            message,
+        };
+    }
+};
+IndicatorCCReport = IndicatorCCReport_1 = __decorate([
+    CCCommand(IndicatorCommand.Report)
+], IndicatorCCReport);
+export { IndicatorCCReport };
+let IndicatorCCGet = IndicatorCCGet_1 = class IndicatorCCGet extends IndicatorCC {
+    constructor(options) {
+        super(options);
+        this.indicatorId = options.indicatorId;
+    }
+    static from(raw, ctx) {
+        let indicatorId;
+        if (raw.payload.length > 0) {
+            indicatorId = raw.payload[0];
+        }
+        return new IndicatorCCGet_1({
+            nodeId: ctx.sourceNodeId,
+            indicatorId,
+        });
+    }
+    indicatorId;
+    serialize(ctx) {
+        if (this.indicatorId != undefined) {
+            this.payload = Bytes.from([this.indicatorId]);
+        }
+        return super.serialize(ctx);
+    }
+    toLogEntry(ctx) {
+        return {
+            ...super.toLogEntry(ctx),
+            message: {
+                indicator: getIndicatorName(this.indicatorId),
+            },
+        };
+    }
+};
+IndicatorCCGet = IndicatorCCGet_1 = __decorate([
+    CCCommand(IndicatorCommand.Get),
+    expectedCCResponse(IndicatorCCReport)
+], IndicatorCCGet);
+export { IndicatorCCGet };
+let IndicatorCCSupportedReport = IndicatorCCSupportedReport_1 = class IndicatorCCSupportedReport extends IndicatorCC {
+    constructor(options) {
+        super(options);
+        this.indicatorId = options.indicatorId;
+        this.nextIndicatorId = options.nextIndicatorId;
+        this.supportedProperties = options.supportedProperties;
+    }
+    static from(raw, ctx) {
+        validatePayload(raw.payload.length >= 3);
+        const indicatorId = raw.payload[0];
+        const nextIndicatorId = raw.payload[1];
+        const bitMaskLength = raw.payload[2] & 0b11111;
+        let supportedProperties;
+        if (bitMaskLength === 0) {
+            supportedProperties = [];
+        }
+        else {
+            validatePayload(raw.payload.length >= 3 + bitMaskLength);
+            // The bit mask starts at 0, but bit 0 is not used
+            supportedProperties = parseBitMask(raw.payload.subarray(3, 3 + bitMaskLength), 0).filter((v) => v !== 0);
+        }
+        return new IndicatorCCSupportedReport_1({
+            nodeId: ctx.sourceNodeId,
+            indicatorId,
+            nextIndicatorId,
+            supportedProperties,
+        });
+    }
+    persistValues(ctx) {
+        if (!super.persistValues(ctx))
+            return false;
+        if (this.indicatorId !== 0x00) {
+            // Remember which property IDs are supported
+            this.setValue(ctx, IndicatorCCValues.supportedPropertyIDs(this.indicatorId), this.supportedProperties);
+        }
+        return true;
+    }
+    indicatorId;
+    nextIndicatorId;
+    supportedProperties;
+    serialize(ctx) {
+        const bitmask = this.supportedProperties.length > 0
+            ? encodeBitMask(this.supportedProperties, undefined, 0)
+            : new Bytes();
+        this.payload = Bytes.concat([
+            Bytes.from([
+                this.indicatorId,
+                this.nextIndicatorId,
+                bitmask.length,
+            ]),
+            bitmask,
+        ]);
+        return super.serialize(ctx);
+    }
+    toLogEntry(ctx) {
+        return {
+            ...super.toLogEntry(ctx),
+            message: {
+                indicator: getIndicatorName(this.indicatorId),
+                "supported properties": `${this.supportedProperties
+                    .map((id) => getIndicatorProperty(id)?.label
+                    ?? `Unknown (${num2hex(id)})`)
+                    .join(", ")}`,
+                "next indicator": getIndicatorName(this.nextIndicatorId),
+            },
+        };
+    }
+};
+IndicatorCCSupportedReport = IndicatorCCSupportedReport_1 = __decorate([
+    CCCommand(IndicatorCommand.SupportedReport)
+], IndicatorCCSupportedReport);
+export { IndicatorCCSupportedReport };
+function testResponseForIndicatorSupportedGet(sent, received) {
+    return sent.indicatorId === 0 || received.indicatorId === sent.indicatorId;
+}
+let IndicatorCCSupportedGet = IndicatorCCSupportedGet_1 = class IndicatorCCSupportedGet extends IndicatorCC {
+    constructor(options) {
+        super(options);
+        this.indicatorId = options.indicatorId;
+    }
+    static from(raw, ctx) {
+        validatePayload(raw.payload.length >= 1);
+        const indicatorId = raw.payload[0];
+        return new IndicatorCCSupportedGet_1({
+            nodeId: ctx.sourceNodeId,
+            indicatorId,
+        });
+    }
+    indicatorId;
+    serialize(ctx) {
+        this.payload = Bytes.from([this.indicatorId]);
+        return super.serialize(ctx);
+    }
+    toLogEntry(ctx) {
+        return {
+            ...super.toLogEntry(ctx),
+            message: {
+                indicator: getIndicatorName(this.indicatorId),
+            },
+        };
+    }
+};
+IndicatorCCSupportedGet = IndicatorCCSupportedGet_1 = __decorate([
+    CCCommand(IndicatorCommand.SupportedGet),
+    expectedCCResponse(IndicatorCCSupportedReport, testResponseForIndicatorSupportedGet)
+], IndicatorCCSupportedGet);
+export { IndicatorCCSupportedGet };
+let IndicatorCCDescriptionReport = IndicatorCCDescriptionReport_1 = class IndicatorCCDescriptionReport extends IndicatorCC {
+    constructor(options) {
+        super(options);
+        this.indicatorId = options.indicatorId;
+        this.description = options.description;
+    }
+    static from(raw, ctx) {
+        validatePayload(raw.payload.length >= 2);
+        const indicatorId = raw.payload[0];
+        const descrptionLength = raw.payload[1];
+        validatePayload(raw.payload.length >= 2 + descrptionLength);
+        const description = raw.payload
+            .subarray(2, 2 + descrptionLength)
+            .toString("utf8");
+        return new IndicatorCCDescriptionReport_1({
+            nodeId: ctx.sourceNodeId,
+            indicatorId,
+            description,
+        });
+    }
+    indicatorId;
+    description;
+    persistValues(ctx) {
+        if (!super.persistValues(ctx))
+            return false;
+        if (this.description) {
+            this.setValue(ctx, IndicatorCCValues.indicatorDescription(this.indicatorId), this.description);
+        }
+        return true;
+    }
+    serialize(ctx) {
+        const description = Bytes.from(this.description, "utf8");
+        this.payload = Bytes.concat([
+            Bytes.from([this.indicatorId, description.length]),
+            description,
+        ]);
+        return super.serialize(ctx);
+    }
+    toLogEntry(ctx) {
+        return {
+            ...super.toLogEntry(ctx),
+            message: {
+                "indicator ID": this.indicatorId,
+                description: this.description || "(none)",
+            },
+        };
+    }
+};
+IndicatorCCDescriptionReport = IndicatorCCDescriptionReport_1 = __decorate([
+    CCCommand(IndicatorCommand.DescriptionReport)
+], IndicatorCCDescriptionReport);
+export { IndicatorCCDescriptionReport };
+function testResponseForIndicatorDescriptionGet(sent, received) {
+    return received.indicatorId === sent.indicatorId;
+}
+let IndicatorCCDescriptionGet = IndicatorCCDescriptionGet_1 = class IndicatorCCDescriptionGet extends IndicatorCC {
+    constructor(options) {
+        super(options);
+        this.indicatorId = options.indicatorId;
+        if (!isManufacturerDefinedIndicator(this.indicatorId)) {
+            throw new ZWaveError("The indicator ID must be between 0x80 and 0x9f", ZWaveErrorCodes.Argument_Invalid);
+        }
+    }
+    static from(raw, ctx) {
+        validatePayload(raw.payload.length >= 1);
+        const indicatorId = raw.payload[0];
+        return new IndicatorCCDescriptionGet_1({
+            nodeId: ctx.sourceNodeId,
+            indicatorId,
+        });
+    }
+    indicatorId;
+    serialize(ctx) {
+        this.payload = Bytes.from([this.indicatorId]);
+        return super.serialize(ctx);
+    }
+    toLogEntry(ctx) {
+        return {
+            ...super.toLogEntry(ctx),
+            message: {
+                "indicator ID": this.indicatorId,
+            },
+        };
+    }
+};
+IndicatorCCDescriptionGet = IndicatorCCDescriptionGet_1 = __decorate([
+    CCCommand(IndicatorCommand.DescriptionGet),
+    expectedCCResponse(IndicatorCCDescriptionReport, testResponseForIndicatorDescriptionGet)
+], IndicatorCCDescriptionGet);
+export { IndicatorCCDescriptionGet };
+//# sourceMappingURL=IndicatorCC.js.map