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

package/build/cc/MultilevelSensorCC.js

@@ -1,756 +0,0 @@
-"use strict";
-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 MultilevelSensorCCReport_1, MultilevelSensorCCGet_1, MultilevelSensorCCSupportedSensorReport_1, MultilevelSensorCCSupportedScaleReport_1, MultilevelSensorCCGetSupportedScale_1;
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MultilevelSensorCCGetSupportedScale = exports.MultilevelSensorCCSupportedScaleReport = exports.MultilevelSensorCCGetSupportedSensor = exports.MultilevelSensorCCSupportedSensorReport = exports.MultilevelSensorCCGet = exports.MultilevelSensorCCReport = exports.MultilevelSensorCC = exports.MultilevelSensorCCAPI = exports.MultilevelSensorCCValues = void 0;
-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__number = $o => {
-    function _number($o) {
-        return typeof $o !== "number" ? {} : null;
-    }
-    return _number($o);
-};
-const __assertType__su__number__2_eu = $o => {
-    function _number($o) {
-        return typeof $o !== "number" ? {} : null;
-    }
-    function _string($o) {
-        return typeof $o !== "string" ? {} : null;
-    }
-    function _2($o) {
-        if (typeof $o !== "object" || $o === null || Array.isArray($o))
-            return {};
-        if ("key" in $o && $o["key"] !== undefined) {
-            const error = _number($o["key"]);
-            if (error)
-                return error;
-        }
-        else
-            return {};
-        if ("label" in $o && $o["label"] !== undefined) {
-            const error = _string($o["label"]);
-            if (error)
-                return error;
-        }
-        else
-            return {};
-        if ("unit" in $o && $o["unit"] !== undefined) {
-            const error = _string($o["unit"]);
-            if (error)
-                return error;
-        }
-        if ("description" in $o && $o["description"] !== undefined) {
-            const error = _string($o["description"]);
-            if (error)
-                return error;
-        }
-        return 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 core_1 = require("@zwave-js/core");
-const safe_1 = require("@zwave-js/core/safe");
-const safe_2 = require("@zwave-js/shared/safe");
-const safe_3 = require("@zwave-js/shared/safe");
-const API_1 = require("../lib/API");
-const CommandClass_1 = require("../lib/CommandClass");
-const CommandClassDecorators_1 = require("../lib/CommandClassDecorators");
-const Values_1 = require("../lib/Values");
-const _Types_1 = require("../lib/_Types");
-exports.MultilevelSensorCCValues = Object.freeze({
-    ...Values_1.V.defineStaticCCValues(safe_1.CommandClasses["Multilevel Sensor"], {
-        ...Values_1.V.staticProperty("supportedSensorTypes", undefined, {
-            internal: true,
-        }),
-    }),
-    ...Values_1.V.defineDynamicCCValues(safe_1.CommandClasses["Multilevel Sensor"], {
-        ...Values_1.V.dynamicPropertyAndKeyWithName("supportedScales", "supportedScales", (sensorType) => sensorType, ({ property, propertyKey }) => property === "supportedScales"
-            && typeof propertyKey === "number", undefined, { internal: true }),
-        ...Values_1.V.dynamicPropertyWithName("value", 
-        // This should have been the sensor type, but it is too late to change now
-        // Maybe we can migrate this without breaking in the future
-        (sensorTypeName) => sensorTypeName, ({ property, propertyKey }) => typeof property === "string"
-            && property !== "supportedSensorTypes"
-            && property !== "supportedScales"
-            && propertyKey == undefined, (sensorTypeName) => ({
-            // Just the base metadata, to be extended using a config manager
-            ...safe_1.ValueMetadata.ReadOnlyNumber,
-            label: sensorTypeName,
-        })),
-    }),
-});
-/**
- * Determine the scale to use to query a sensor reading. Uses the user-preferred scale if given,
- * followed by the most recently used scale, otherwile falls back to the first supported one.
- */
-function getPreferredSensorScale(ctx, nodeId, endpointIndex, sensorType, supportedScales) {
-    const preferences = ctx.getUserPreferences();
-    const sensor = (0, core_1.getSensor)(sensorType);
-    // If the sensor type is unknown, we have no default. Use the user-provided scale or 0
-    if (!sensor) {
-        const preferred = preferences?.scales[sensorType];
-        // We cannot look up strings for unknown sensor types, so this must be a number or we use the fallback
-        if (typeof preferred !== "number")
-            return 0;
-        return preferred;
-    }
-    // Look up the preference for the scale
-    let preferred;
-    // Named scales apply to multiple sensor types. To be able to override the scale for single types
-    // we need to look at the preferences by sensor type first
-    preferred = preferences?.scales[sensorType];
-    // If the scale is named, we can then try to use the named preference
-    const scaleGroupName = sensor.scaleGroupName;
-    if (preferred == undefined && scaleGroupName) {
-        preferred = preferences?.scales[scaleGroupName];
-    }
-    // Then attempt reading the scale from the corresponding value
-    if (preferred == undefined) {
-        const sensorName = (0, core_1.getSensorName)(sensorType);
-        const sensorValue = exports.MultilevelSensorCCValues.value(sensorName);
-        const metadata = ctx
-            .tryGetValueDB(nodeId)
-            ?.getMetadata(sensorValue.endpoint(endpointIndex));
-        const scale = metadata?.ccSpecific?.scale;
-        if (typeof scale === "number" && supportedScales.includes(scale)) {
-            preferred = scale;
-            ctx.logNode(nodeId, {
-                endpoint: endpointIndex,
-                message: `No scale preference for sensor type ${sensorType}, using the last-used scale ${preferred}`,
-            });
-        }
-    }
-    // Then fall back to the first supported scale
-    if (preferred == undefined) {
-        preferred = supportedScales[0] ?? 0;
-        ctx.logNode(nodeId, {
-            endpoint: endpointIndex,
-            message: `No scale preference for sensor type ${sensorType}, using the first supported scale ${preferred}`,
-        });
-        return preferred;
-    }
-    // If the scale name or unit was given, try to look it up
-    if (typeof preferred === "string") {
-        for (const [key, scale] of Object.entries(sensor.scales)) {
-            if (scale.label === preferred || scale.unit === preferred) {
-                preferred = parseInt(key, 10);
-                break;
-            }
-        }
-    }
-    if (typeof preferred === "string") {
-        // Looking up failed
-        ctx.logNode(nodeId, {
-            endpoint: endpointIndex,
-            message: `Preferred scale "${preferred}" for sensor type ${sensorType} not found, using the first supported scale ${supportedScales[0] ?? 0}`,
-        });
-        return supportedScales[0] ?? 0;
-    }
-    // We have a numeric scale key, nothing to look up. Make sure it is supported though
-    if (!supportedScales.length) {
-        // No info about supported scales, just use the preferred one
-        return preferred;
-    }
-    else if (!supportedScales.includes(preferred)) {
-        ctx.logNode(nodeId, {
-            endpoint: endpointIndex,
-            message: `Preferred scale ${preferred} not supported for sensor type ${sensorType}, using the first supported scale`,
-        });
-        return supportedScales[0];
-    }
-    else {
-        return preferred;
-    }
-}
-// @noSetValueAPI This CC is read-only
-let MultilevelSensorCCAPI = class MultilevelSensorCCAPI extends API_1.PhysicalCCAPI {
-    supportsCommand(cmd) {
-        switch (cmd) {
-            case _Types_1.MultilevelSensorCommand.Get:
-            case _Types_1.MultilevelSensorCommand.Report:
-                return true; // This is mandatory
-            case _Types_1.MultilevelSensorCommand.GetSupportedSensor:
-            case _Types_1.MultilevelSensorCommand.GetSupportedScale:
-                return this.version >= 5;
-        }
-        return super.supportsCommand(cmd);
-    }
-    get [API_1.POLL_VALUE]() {
-        return async function ({ property }) {
-            // Look up the necessary information
-            const valueId = {
-                commandClass: safe_1.CommandClasses["Multilevel Sensor"],
-                endpoint: this.endpoint.index,
-                property,
-            };
-            const ccSpecific = this.tryGetValueDB()?.getMetadata(valueId)
-                ?.ccSpecific;
-            if (!ccSpecific) {
-                (0, API_1.throwUnsupportedProperty)(this.ccId, property);
-            }
-            const { sensorType, scale } = ccSpecific;
-            return this.get(sensorType, scale);
-        };
-    }
-    async get(sensorType, scale) {
-        __assertType("sensorType", "(optional) number", __assertType__optional_number.bind(void 0, sensorType));
-        __assertType("scale", "(optional) number", __assertType__optional_number.bind(void 0, scale));
-        this.assertSupportsCommand(_Types_1.MultilevelSensorCommand, _Types_1.MultilevelSensorCommand.Get);
-        // Figure out the preferred scale if none was given
-        let preferredScale;
-        if (sensorType != undefined && scale == undefined) {
-            const supportedScales = this.tryGetValueDB()?.getValue({
-                commandClass: this.ccId,
-                endpoint: this.endpoint.index,
-                property: "supportedScales",
-                propertyKey: sensorType,
-            }) ?? [];
-            preferredScale = getPreferredSensorScale(this.host, this.endpoint.nodeId, this.endpoint.index, sensorType, supportedScales);
-        }
-        const cc = new MultilevelSensorCCGet({
-            nodeId: this.endpoint.nodeId,
-            endpointIndex: this.endpoint.index,
-            sensorType: sensorType,
-            scale: (scale ?? preferredScale),
-        });
-        const response = await this.host.sendCommand(cc, this.commandOptions);
-        if (!response)
-            return;
-        const responseScale = (0, core_1.getSensorScale)(response.type, response.scale);
-        if (sensorType == undefined) {
-            // Overload #1: return the full response
-            return {
-                type: response.type,
-                value: response.value,
-                scale: responseScale,
-            };
-        }
-        else if (scale == undefined) {
-            // Overload #2: return value and scale
-            return {
-                value: response.value,
-                scale: responseScale,
-            };
-        }
-        else {
-            // Overload #3: return only the value
-            return response.value;
-        }
-    }
-    async getSupportedSensorTypes() {
-        this.assertSupportsCommand(_Types_1.MultilevelSensorCommand, _Types_1.MultilevelSensorCommand.GetSupportedSensor);
-        const cc = new MultilevelSensorCCGetSupportedSensor({
-            nodeId: this.endpoint.nodeId,
-            endpointIndex: this.endpoint.index,
-        });
-        const response = await this.host.sendCommand(cc, this.commandOptions);
-        return response?.supportedSensorTypes;
-    }
-    async getSupportedScales(sensorType) {
-        __assertType("sensorType", "number", __assertType__number.bind(void 0, sensorType));
-        this.assertSupportsCommand(_Types_1.MultilevelSensorCommand, _Types_1.MultilevelSensorCommand.GetSupportedScale);
-        const cc = new MultilevelSensorCCGetSupportedScale({
-            nodeId: this.endpoint.nodeId,
-            endpointIndex: this.endpoint.index,
-            sensorType,
-        });
-        const response = await this.host.sendCommand(cc, this.commandOptions);
-        return response?.supportedScales;
-    }
-    async sendReport(sensorType, scale, value) {
-        __assertType("sensorType", "number", __assertType__number.bind(void 0, sensorType));
-        __assertType("scale", undefined, __assertType__su__number__2_eu.bind(void 0, scale));
-        __assertType("value", "number", __assertType__number.bind(void 0, value));
-        this.assertSupportsCommand(_Types_1.MultilevelSensorCommand, _Types_1.MultilevelSensorCommand.Report);
-        const cc = new MultilevelSensorCCReport({
-            nodeId: this.endpoint.nodeId,
-            endpointIndex: this.endpoint.index,
-            type: sensorType,
-            scale,
-            value,
-        });
-        return this.host.sendCommand(cc, this.commandOptions);
-    }
-};
-exports.MultilevelSensorCCAPI = MultilevelSensorCCAPI;
-exports.MultilevelSensorCCAPI = MultilevelSensorCCAPI = __decorate([
-    (0, CommandClassDecorators_1.API)(safe_1.CommandClasses["Multilevel Sensor"])
-], MultilevelSensorCCAPI);
-let MultilevelSensorCC = class MultilevelSensorCC extends CommandClass_1.CommandClass {
-    async interview(ctx) {
-        const node = this.getNode(ctx);
-        const endpoint = this.getEndpoint(ctx);
-        const api = API_1.CCAPI.create(safe_1.CommandClasses["Multilevel Sensor"], ctx, endpoint).withOptions({
-            priority: safe_1.MessagePriority.NodeQuery,
-        });
-        ctx.logNode(node.id, {
-            endpoint: this.endpointIndex,
-            message: `Interviewing ${this.ccName}...`,
-            direction: "none",
-        });
-        if (api.version >= 5) {
-            // Query the supported sensor types
-            ctx.logNode(node.id, {
-                endpoint: this.endpointIndex,
-                message: "retrieving supported sensor types...",
-                direction: "outbound",
-            });
-            const sensorTypes = await api.getSupportedSensorTypes();
-            if (sensorTypes) {
-                const logMessage = "received supported sensor types:\n"
-                    + sensorTypes
-                        .map((t) => (0, core_1.getSensorName)(t))
-                        .map((name) => `· ${name}`)
-                        .join("\n");
-                ctx.logNode(node.id, {
-                    endpoint: this.endpointIndex,
-                    message: logMessage,
-                    direction: "inbound",
-                });
-            }
-            else {
-                ctx.logNode(node.id, {
-                    endpoint: this.endpointIndex,
-                    message: "Querying supported sensor types timed out, skipping interview...",
-                    level: "warn",
-                });
-                return;
-            }
-            // As well as the supported scales for each sensor
-            for (const type of sensorTypes) {
-                ctx.logNode(node.id, {
-                    endpoint: this.endpointIndex,
-                    message: `querying supported scales for ${(0, core_1.getSensorName)(type)} sensor`,
-                    direction: "outbound",
-                });
-                const sensorScales = await api.getSupportedScales(type);
-                if (sensorScales) {
-                    const logMessage = "received supported scales:\n"
-                        + sensorScales
-                            .map((s) => ((0, core_1.getSensorScale)(type, s)
-                            ?? (0, core_1.getUnknownScale)(s)).label)
-                            .map((name) => `· ${name}`)
-                            .join("\n");
-                    ctx.logNode(node.id, {
-                        endpoint: this.endpointIndex,
-                        message: logMessage,
-                        direction: "inbound",
-                    });
-                }
-                else {
-                    ctx.logNode(node.id, {
-                        endpoint: this.endpointIndex,
-                        message: "Querying supported scales timed out, skipping interview...",
-                        level: "warn",
-                    });
-                    return;
-                }
-            }
-        }
-        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 = API_1.CCAPI.create(safe_1.CommandClasses["Multilevel Sensor"], ctx, endpoint).withOptions({
-            priority: safe_1.MessagePriority.NodeQuery,
-        });
-        const valueDB = this.getValueDB(ctx);
-        if (api.version <= 4) {
-            // Sensors up to V4 only support a single value
-            ctx.logNode(node.id, {
-                endpoint: this.endpointIndex,
-                message: "querying current sensor reading...",
-                direction: "outbound",
-            });
-            const mlsResponse = await api.get();
-            if (mlsResponse) {
-                const sensorScale = (0, core_1.getSensorScale)(mlsResponse.type, mlsResponse.scale.key);
-                const logMessage = `received current sensor reading:
-sensor type: ${(0, core_1.getSensorName)(mlsResponse.type)}
-value:       ${mlsResponse.value}${sensorScale?.unit ? ` ${sensorScale.unit}` : ""}`;
-                ctx.logNode(node.id, {
-                    endpoint: this.endpointIndex,
-                    message: logMessage,
-                    direction: "inbound",
-                });
-            }
-        }
-        else {
-            // Query all sensor values
-            const sensorTypes = valueDB.getValue({
-                commandClass: this.ccId,
-                property: "supportedSensorTypes",
-                endpoint: this.endpointIndex,
-            }) || [];
-            for (const type of sensorTypes) {
-                ctx.logNode(node.id, {
-                    endpoint: this.endpointIndex,
-                    message: `querying ${(0, core_1.getSensorName)(type)} sensor reading...`,
-                    direction: "outbound",
-                });
-                const value = await api.get(type);
-                if (value) {
-                    const logMessage = `received current ${(0, core_1.getSensorName)(type)} sensor reading: ${value.value} ${value.scale.unit || ""}`;
-                    ctx.logNode(node.id, {
-                        endpoint: this.endpointIndex,
-                        message: logMessage,
-                        direction: "inbound",
-                    });
-                }
-            }
-        }
-    }
-    shouldRefreshValues(ctx) {
-        // Poll the device when all of the supported values were last updated longer than 6 hours ago.
-        // This may lead to some values not being updated, but the user may have disabled some unnecessary
-        // reports to reduce traffic.
-        const valueDB = ctx.tryGetValueDB(this.nodeId);
-        if (!valueDB)
-            return true;
-        const values = this.getDefinedValueIDs(ctx).filter((v) => exports.MultilevelSensorCCValues.value.is(v));
-        return values.every((v) => {
-            const lastUpdated = valueDB.getTimestamp(v);
-            return (lastUpdated == undefined
-                || Date.now() - lastUpdated > core_1.timespan.hours(6));
-        });
-    }
-    /**
-     * Returns which sensor types are supported.
-     * This only works AFTER the interview process
-     */
-    static getSupportedSensorTypesCached(ctx, endpoint) {
-        return ctx
-            .getValueDB(endpoint.nodeId)
-            .getValue(exports.MultilevelSensorCCValues.supportedSensorTypes.endpoint(endpoint.index));
-    }
-    /**
-     * Returns which scales are supported for a given sensor type.
-     * This only works AFTER the interview process
-     */
-    static getSupportedScalesCached(ctx, endpoint, sensorType) {
-        return ctx
-            .getValueDB(endpoint.nodeId)
-            .getValue(exports.MultilevelSensorCCValues.supportedScales(sensorType).endpoint(endpoint.index));
-    }
-    translatePropertyKey(ctx, property, propertyKey) {
-        // TODO: check this
-        if (property === "values" && typeof propertyKey === "number") {
-            const sensor = (0, core_1.getSensor)(propertyKey);
-            if (sensor)
-                return sensor.label;
-        }
-        return super.translatePropertyKey(ctx, property, propertyKey);
-    }
-};
-exports.MultilevelSensorCC = MultilevelSensorCC;
-exports.MultilevelSensorCC = MultilevelSensorCC = __decorate([
-    (0, CommandClassDecorators_1.commandClass)(safe_1.CommandClasses["Multilevel Sensor"]),
-    (0, CommandClassDecorators_1.implementedVersion)(11),
-    (0, CommandClassDecorators_1.ccValues)(exports.MultilevelSensorCCValues)
-], MultilevelSensorCC);
-let MultilevelSensorCCReport = MultilevelSensorCCReport_1 = class MultilevelSensorCCReport extends MultilevelSensorCC {
-    constructor(options) {
-        super(options);
-        this.type = options.type;
-        this.value = options.value;
-        this.scale = typeof options.scale === "number"
-            ? options.scale
-            : options.scale.key;
-    }
-    static from(raw, ctx) {
-        (0, safe_1.validatePayload)(raw.payload.length >= 1);
-        const type = raw.payload[0];
-        // parseFloatWithScale does its own validation
-        const { value, scale } = (0, safe_1.parseFloatWithScale)(raw.payload.subarray(1));
-        return new MultilevelSensorCCReport_1({
-            nodeId: ctx.sourceNodeId,
-            type,
-            value,
-            scale,
-        });
-    }
-    persistValues(ctx) {
-        if (!super.persistValues(ctx))
-            return false;
-        const sensor = (0, core_1.getSensor)(this.type);
-        const scale = (0, core_1.getSensorScale)(this.type, this.scale) ?? (0, core_1.getUnknownScale)(this.scale);
-        // Filter out unknown sensor types and scales, unless the strict validation is disabled
-        const measurementValidation = !ctx.getDeviceConfig?.(this.nodeId)?.compat?.disableStrictMeasurementValidation;
-        const ccVersion = (0, CommandClass_1.getEffectiveCCVersion)(ctx, this);
-        if (measurementValidation) {
-            // Filter out unsupported sensor types and scales if possible
-            if (ccVersion >= 5) {
-                const supportedSensorTypes = this.getValue(ctx, exports.MultilevelSensorCCValues.supportedSensorTypes);
-                if (supportedSensorTypes?.length) {
-                    safe_1.validatePayload.withReason(`Unsupported sensor type ${(0, core_1.getSensorName)(this.type)} or corrupted data`)(supportedSensorTypes.includes(this.type));
-                }
-                const supportedScales = this.getValue(ctx, exports.MultilevelSensorCCValues.supportedScales(this.type));
-                if (supportedScales?.length) {
-                    safe_1.validatePayload.withReason(`Unsupported scale ${scale.label} or corrupted data`)(supportedScales.includes(scale.key));
-                }
-            }
-            else {
-                // We support a higher CC version than the device, so any types and scales it uses should be known to us
-                // Filter out unknown ones.
-                safe_1.validatePayload.withReason(`Unknown sensor type ${(0, safe_3.num2hex)(this.type)} or corrupted data`)(!!sensor);
-                safe_1.validatePayload.withReason(`Unknown scale ${(0, safe_3.num2hex)(this.scale)} or corrupted data`)(scale.label !== (0, core_1.getUnknownScale)(this.scale).label);
-            }
-        }
-        const sensorName = (0, core_1.getSensorName)(this.type);
-        const sensorValue = exports.MultilevelSensorCCValues.value(sensorName);
-        this.setMetadata(ctx, sensorValue, {
-            ...sensorValue.meta,
-            unit: scale.unit,
-            ccSpecific: {
-                sensorType: this.type,
-                scale: scale.key,
-            },
-        });
-        this.setValue(ctx, sensorValue, this.value);
-        return true;
-    }
-    type;
-    scale;
-    value;
-    serialize(ctx) {
-        this.payload = safe_2.Bytes.concat([
-            safe_2.Bytes.from([this.type]),
-            (0, safe_1.encodeFloatWithScale)(this.value, this.scale),
-        ]);
-        return super.serialize(ctx);
-    }
-    toLogEntry(ctx) {
-        return {
-            ...super.toLogEntry(ctx),
-            message: {
-                "sensor type": (0, core_1.getSensorName)(this.type),
-                scale: ((0, core_1.getSensorScale)(this.type, this.scale)
-                    ?? (0, core_1.getUnknownScale)(this.scale)).label,
-                value: this.value,
-            },
-        };
-    }
-};
-exports.MultilevelSensorCCReport = MultilevelSensorCCReport;
-exports.MultilevelSensorCCReport = MultilevelSensorCCReport = MultilevelSensorCCReport_1 = __decorate([
-    (0, CommandClassDecorators_1.CCCommand)(_Types_1.MultilevelSensorCommand.Report),
-    (0, CommandClassDecorators_1.useSupervision)()
-], MultilevelSensorCCReport);
-const testResponseForMultilevelSensorGet = (sent, received) => {
-    // We expect a Multilevel Sensor Report that matches the requested sensor type (if a type was requested)
-    return sent.sensorType == undefined || received.type === sent.sensorType;
-};
-let MultilevelSensorCCGet = MultilevelSensorCCGet_1 = class MultilevelSensorCCGet extends MultilevelSensorCC {
-    constructor(options) {
-        super(options);
-        if ("sensorType" in options) {
-            this.sensorType = options.sensorType;
-            this.scale = options.scale;
-        }
-    }
-    static from(raw, ctx) {
-        if (raw.payload.length >= 2) {
-            const sensorType = raw.payload[0];
-            const scale = (raw.payload[1] >> 3) & 0b11;
-            return new MultilevelSensorCCGet_1({
-                nodeId: ctx.sourceNodeId,
-                sensorType,
-                scale,
-            });
-        }
-        else {
-            return new MultilevelSensorCCGet_1({
-                nodeId: ctx.sourceNodeId,
-            });
-        }
-    }
-    sensorType;
-    scale;
-    serialize(ctx) {
-        if (this.sensorType != undefined
-            && this.scale != undefined) {
-            this.payload = safe_2.Bytes.from([
-                this.sensorType,
-                (this.scale & 0b11) << 3,
-            ]);
-        }
-        return super.serialize(ctx);
-    }
-    toLogEntry(ctx) {
-        let message = {};
-        if (this.sensorType != undefined
-            && this.scale != undefined) {
-            message = {
-                "sensor type": (0, core_1.getSensorName)(this.sensorType),
-                scale: ((0, core_1.getSensorScale)(this.sensorType, this.scale) ?? (0, core_1.getUnknownScale)(this.scale)).label,
-            };
-        }
-        return {
-            ...super.toLogEntry(ctx),
-            message,
-        };
-    }
-};
-exports.MultilevelSensorCCGet = MultilevelSensorCCGet;
-exports.MultilevelSensorCCGet = MultilevelSensorCCGet = MultilevelSensorCCGet_1 = __decorate([
-    (0, CommandClassDecorators_1.CCCommand)(_Types_1.MultilevelSensorCommand.Get),
-    (0, CommandClassDecorators_1.expectedCCResponse)(MultilevelSensorCCReport, testResponseForMultilevelSensorGet)
-], MultilevelSensorCCGet);
-let MultilevelSensorCCSupportedSensorReport = MultilevelSensorCCSupportedSensorReport_1 = class MultilevelSensorCCSupportedSensorReport extends MultilevelSensorCC {
-    constructor(options) {
-        super(options);
-        this.supportedSensorTypes = options.supportedSensorTypes;
-    }
-    static from(raw, ctx) {
-        (0, safe_1.validatePayload)(raw.payload.length >= 1);
-        const supportedSensorTypes = (0, safe_1.parseBitMask)(raw.payload);
-        return new MultilevelSensorCCSupportedSensorReport_1({
-            nodeId: ctx.sourceNodeId,
-            supportedSensorTypes,
-        });
-    }
-    // TODO: Use this during interview to precreate values
-    supportedSensorTypes;
-    serialize(ctx) {
-        this.payload = (0, core_1.encodeBitMask)(this.supportedSensorTypes);
-        return super.serialize(ctx);
-    }
-    toLogEntry(ctx) {
-        return {
-            ...super.toLogEntry(ctx),
-            message: {
-                "supported sensor types": this.supportedSensorTypes
-                    .map((t) => `\n· ${(0, core_1.getSensorName)(t)}`)
-                    .join(""),
-            },
-        };
-    }
-};
-exports.MultilevelSensorCCSupportedSensorReport = MultilevelSensorCCSupportedSensorReport;
-__decorate([
-    (0, CommandClassDecorators_1.ccValue)(exports.MultilevelSensorCCValues.supportedSensorTypes)
-], MultilevelSensorCCSupportedSensorReport.prototype, "supportedSensorTypes", void 0);
-exports.MultilevelSensorCCSupportedSensorReport = MultilevelSensorCCSupportedSensorReport = MultilevelSensorCCSupportedSensorReport_1 = __decorate([
-    (0, CommandClassDecorators_1.CCCommand)(_Types_1.MultilevelSensorCommand.SupportedSensorReport)
-], MultilevelSensorCCSupportedSensorReport);
-let MultilevelSensorCCGetSupportedSensor = class MultilevelSensorCCGetSupportedSensor extends MultilevelSensorCC {
-};
-exports.MultilevelSensorCCGetSupportedSensor = MultilevelSensorCCGetSupportedSensor;
-exports.MultilevelSensorCCGetSupportedSensor = MultilevelSensorCCGetSupportedSensor = __decorate([
-    (0, CommandClassDecorators_1.CCCommand)(_Types_1.MultilevelSensorCommand.GetSupportedSensor),
-    (0, CommandClassDecorators_1.expectedCCResponse)(MultilevelSensorCCSupportedSensorReport)
-], MultilevelSensorCCGetSupportedSensor);
-let MultilevelSensorCCSupportedScaleReport = MultilevelSensorCCSupportedScaleReport_1 = class MultilevelSensorCCSupportedScaleReport extends MultilevelSensorCC {
-    constructor(options) {
-        super(options);
-        this.sensorType = options.sensorType;
-        this.supportedScales = options.supportedScales;
-    }
-    static from(raw, ctx) {
-        (0, safe_1.validatePayload)(raw.payload.length >= 2);
-        const sensorType = raw.payload[0];
-        const supportedScales = (0, safe_1.parseBitMask)(safe_2.Bytes.from([raw.payload[1] & 0b1111]), 0);
-        return new MultilevelSensorCCSupportedScaleReport_1({
-            nodeId: ctx.sourceNodeId,
-            sensorType,
-            supportedScales,
-        });
-    }
-    sensorType;
-    supportedScales;
-    serialize(ctx) {
-        this.payload = safe_2.Bytes.concat([
-            safe_2.Bytes.from([this.sensorType]),
-            (0, core_1.encodeBitMask)(this.supportedScales, 4, 0),
-        ]);
-        return super.serialize(ctx);
-    }
-    toLogEntry(ctx) {
-        return {
-            ...super.toLogEntry(ctx),
-            message: {
-                "sensor type": (0, core_1.getSensorName)(this.sensorType),
-                "supported scales": this.supportedScales
-                    .map((s) => `\n· ${((0, core_1.getSensorScale)(this.sensorType, s)
-                    ?? (0, core_1.getUnknownScale)(s)).label}`)
-                    .join(""),
-            },
-        };
-    }
-};
-exports.MultilevelSensorCCSupportedScaleReport = MultilevelSensorCCSupportedScaleReport;
-__decorate([
-    (0, CommandClassDecorators_1.ccValue)(exports.MultilevelSensorCCValues.supportedScales, (self) => [self.sensorType])
-], MultilevelSensorCCSupportedScaleReport.prototype, "supportedScales", void 0);
-exports.MultilevelSensorCCSupportedScaleReport = MultilevelSensorCCSupportedScaleReport = MultilevelSensorCCSupportedScaleReport_1 = __decorate([
-    (0, CommandClassDecorators_1.CCCommand)(_Types_1.MultilevelSensorCommand.SupportedScaleReport)
-], MultilevelSensorCCSupportedScaleReport);
-let MultilevelSensorCCGetSupportedScale = MultilevelSensorCCGetSupportedScale_1 = class MultilevelSensorCCGetSupportedScale extends MultilevelSensorCC {
-    constructor(options) {
-        super(options);
-        this.sensorType = options.sensorType;
-    }
-    static from(raw, ctx) {
-        (0, safe_1.validatePayload)(raw.payload.length >= 1);
-        const sensorType = raw.payload[0];
-        return new MultilevelSensorCCGetSupportedScale_1({
-            nodeId: ctx.sourceNodeId,
-            sensorType,
-        });
-    }
-    sensorType;
-    serialize(ctx) {
-        this.payload = safe_2.Bytes.from([this.sensorType]);
-        return super.serialize(ctx);
-    }
-    toLogEntry(ctx) {
-        return {
-            ...super.toLogEntry(ctx),
-            message: {
-                "sensor type": (0, core_1.getSensorName)(this.sensorType),
-            },
-        };
-    }
-};
-exports.MultilevelSensorCCGetSupportedScale = MultilevelSensorCCGetSupportedScale;
-exports.MultilevelSensorCCGetSupportedScale = MultilevelSensorCCGetSupportedScale = MultilevelSensorCCGetSupportedScale_1 = __decorate([
-    (0, CommandClassDecorators_1.CCCommand)(_Types_1.MultilevelSensorCommand.GetSupportedScale),
-    (0, CommandClassDecorators_1.expectedCCResponse)(MultilevelSensorCCSupportedScaleReport)
-], MultilevelSensorCCGetSupportedScale);
-//# sourceMappingURL=MultilevelSensorCC.js.map