@zwave-js/cc 9.3.1-0-pr-4662-79458fb

package/build/cc/MeterCC.js

@@ -0,0 +1,820 @@
+"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 _a, _b;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MeterCCReset = exports.MeterCCSupportedGet = exports.MeterCCSupportedReport = exports.MeterCCGet = exports.MeterCCReport = exports.MeterCC = exports.MeterCCAPI = exports.getResetValueId = exports.getSupportedRateTypesValueId = exports.getSupportedScalesValueId = exports.getSupportsResetValueId = exports.getTypeValueId = 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_MeterCCGetOptions = $o => {
+    function _number($o) {
+        return typeof $o !== "number" ? {} : null;
+    }
+    function su__2__3__4_eu($o) {
+        return ![0, 1, 2].includes($o) ? {} : null;
+    }
+    function _0($o) {
+        if (typeof $o !== "object" || $o === null || Array.isArray($o))
+            return {};
+        if ("scale" in $o && $o["scale"] !== undefined) {
+            const error = _number($o["scale"]);
+            if (error)
+                return error;
+        }
+        if ("rateType" in $o && $o["rateType"] !== undefined) {
+            const error = su__2__3__4_eu($o["rateType"]);
+            if (error)
+                return error;
+        }
+        return null;
+    }
+    function optional__0($o) {
+        if ($o !== undefined) {
+            const error = _0($o);
+            if (error)
+                return error;
+        }
+        return null;
+    }
+    return optional__0($o);
+};
+const __assertType__optional_MeterCCResetOptions = $o => {
+    function _undefined($o) {
+        return $o !== undefined ? {} : null;
+    }
+    function _1($o) {
+        if (typeof $o !== "object" || $o === null || Array.isArray($o))
+            return {};
+        if ("type" in $o && $o["type"] !== undefined) {
+            const error = _undefined($o["type"]);
+            if (error)
+                return error;
+        }
+        if ("targetValue" in $o && $o["targetValue"] !== undefined) {
+            const error = _undefined($o["targetValue"]);
+            if (error)
+                return error;
+        }
+        return null;
+    }
+    function _number($o) {
+        return typeof $o !== "number" ? {} : null;
+    }
+    function _2($o) {
+        if (typeof $o !== "object" || $o === null || Array.isArray($o))
+            return {};
+        if ("type" in $o && $o["type"] !== undefined) {
+            const error = _number($o["type"]);
+            if (error)
+                return error;
+        }
+        else
+            return {};
+        if ("targetValue" in $o && $o["targetValue"] !== undefined) {
+            const error = _number($o["targetValue"]);
+            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 {};
+    }
+    function optional_su__1__2_eu($o) {
+        if ($o !== undefined) {
+            const error = su__1__2_eu($o);
+            if (error)
+                return error;
+        }
+        return null;
+    }
+    return optional_su__1__2_eu($o);
+};
+const config_1 = require("@zwave-js/config");
+const safe_1 = require("@zwave-js/core/safe");
+const safe_2 = require("@zwave-js/shared/safe");
+const API_1 = require("../lib/API");
+const CommandClass_1 = require("../lib/CommandClass");
+const _Types_1 = require("../lib/_Types");
+function toPropertyKey(meterType, rateType, scale) {
+    return (meterType << 16) | (scale << 8) | rateType;
+}
+function splitPropertyKey(key) {
+    return {
+        rateType: key & 0xff,
+        scale: (key >>> 8) & 0xff,
+        meterType: key >>> 16,
+    };
+}
+function getMeterTypeName(configManager, type) {
+    var _c, _d;
+    return ((_d = (_c = configManager.lookupMeter(type)) === null || _c === void 0 ? void 0 : _c.name) !== null && _d !== void 0 ? _d : `UNKNOWN (${(0, safe_2.num2hex)(type)})`);
+}
+function getTypeValueId(endpoint) {
+    return {
+        commandClass: safe_1.CommandClasses.Meter,
+        endpoint,
+        property: "type",
+    };
+}
+exports.getTypeValueId = getTypeValueId;
+function getSupportsResetValueId(endpoint) {
+    return {
+        commandClass: safe_1.CommandClasses.Meter,
+        endpoint,
+        property: "supportsReset",
+    };
+}
+exports.getSupportsResetValueId = getSupportsResetValueId;
+function getSupportedScalesValueId(endpoint) {
+    return {
+        commandClass: safe_1.CommandClasses.Meter,
+        endpoint,
+        property: "supportedScales",
+    };
+}
+exports.getSupportedScalesValueId = getSupportedScalesValueId;
+function getSupportedRateTypesValueId(endpoint) {
+    return {
+        commandClass: safe_1.CommandClasses.Meter,
+        endpoint,
+        property: "supportedRateTypes",
+    };
+}
+exports.getSupportedRateTypesValueId = getSupportedRateTypesValueId;
+function getResetValueId(endpoint, type) {
+    return {
+        commandClass: safe_1.CommandClasses.Meter,
+        endpoint,
+        property: "reset",
+        propertyKey: type,
+    };
+}
+exports.getResetValueId = getResetValueId;
+function getValueLabel(configManager, meterType, scale, rateType, suffix) {
+    let ret = getMeterTypeName(configManager, meterType);
+    switch (rateType) {
+        case _Types_1.RateType.Consumed:
+            ret += ` Consumption [${scale.label}]`;
+            break;
+        case _Types_1.RateType.Produced:
+            ret += ` Production [${scale.label}]`;
+            break;
+        default:
+            ret += ` [${scale.label}]`;
+    }
+    if (suffix) {
+        ret += ` (${suffix})`;
+    }
+    return ret;
+}
+let MeterCCAPI = class MeterCCAPI extends API_1.PhysicalCCAPI {
+    constructor() {
+        super(...arguments);
+        this[_a] = async ({ property, propertyKey, }) => {
+            var _c;
+            switch (property) {
+                case "value":
+                case "previousValue":
+                case "deltaTime": {
+                    if (propertyKey == undefined) {
+                        (0, API_1.throwMissingPropertyKey)(this.ccId, property);
+                    }
+                    else if (typeof propertyKey !== "number") {
+                        (0, API_1.throwUnsupportedPropertyKey)(this.ccId, property, propertyKey);
+                    }
+                    const { rateType, scale } = splitPropertyKey(propertyKey);
+                    return (_c = (await this.get({
+                        rateType,
+                        scale,
+                    }))) === null || _c === void 0 ? void 0 : _c[property];
+                }
+                default:
+                    (0, API_1.throwUnsupportedProperty)(this.ccId, property);
+            }
+        };
+        this[_b] = async ({ property, propertyKey }, value) => {
+            if (property !== "reset") {
+                (0, API_1.throwUnsupportedProperty)(this.ccId, property);
+            }
+            else if (propertyKey != undefined &&
+                typeof propertyKey !== "number") {
+                (0, API_1.throwUnsupportedPropertyKey)(this.ccId, property, propertyKey);
+            }
+            else if (value !== true) {
+                (0, API_1.throwWrongValueType)(this.ccId, property, "true", value === false ? "false" : typeof value);
+            }
+            const resetOptions = propertyKey != undefined
+                ? {
+                    type: propertyKey,
+                    targetValue: 0,
+                }
+                : {};
+            await this.reset(resetOptions);
+            // Refresh values
+            await this.getAll();
+        };
+    }
+    supportsCommand(cmd) {
+        var _c;
+        switch (cmd) {
+            case _Types_1.MeterCommand.Get:
+                return true; // This is mandatory
+            case _Types_1.MeterCommand.SupportedGet:
+                return this.version >= 2;
+            case _Types_1.MeterCommand.Reset: {
+                const ret = (_c = this.tryGetValueDB()) === null || _c === void 0 ? void 0 : _c.getValue({
+                    commandClass: (0, CommandClass_1.getCommandClass)(this),
+                    endpoint: this.endpoint.index,
+                    property: "supportsReset",
+                });
+                return ret === true;
+            }
+        }
+        return super.supportsCommand(cmd);
+    }
+    async get(options) {
+        __assertType("options", "(optional) MeterCCGetOptions", __assertType__optional_MeterCCGetOptions.bind(void 0, options));
+        this.assertSupportsCommand(_Types_1.MeterCommand, _Types_1.MeterCommand.Get);
+        const cc = new MeterCCGet(this.applHost, {
+            nodeId: this.endpoint.nodeId,
+            endpoint: this.endpoint.index,
+            ...options,
+        });
+        const response = await this.applHost.sendCommand(cc, this.commandOptions);
+        if (response) {
+            return {
+                type: response.type,
+                scale: this.applHost.configManager.lookupMeterScale(response.type, response.scale),
+                ...(0, safe_2.pick)(response, [
+                    "value",
+                    "previousValue",
+                    "rateType",
+                    "deltaTime",
+                ]),
+            };
+        }
+    }
+    // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
+    async getAll() {
+        var _c, _d;
+        const valueDB = this.tryGetValueDB();
+        if (this.version >= 2) {
+            const supportedScales = (_c = valueDB === null || valueDB === void 0 ? void 0 : valueDB.getValue(getSupportedScalesValueId(this.endpoint.index))) !== null && _c !== void 0 ? _c : [];
+            const supportedRateTypes = (_d = valueDB === null || valueDB === void 0 ? void 0 : valueDB.getValue(getSupportedRateTypesValueId(this.endpoint.index))) !== null && _d !== void 0 ? _d : [];
+            const rateTypes = supportedRateTypes.length
+                ? supportedRateTypes
+                : [undefined];
+            const ret = [];
+            for (const rateType of rateTypes) {
+                for (const scale of supportedScales) {
+                    const response = await this.get({
+                        scale,
+                        rateType,
+                    });
+                    if (response)
+                        ret.push(response);
+                }
+            }
+            return ret;
+        }
+        else {
+            const response = await this.get();
+            return response ? [response] : [];
+        }
+    }
+    // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
+    async getSupported() {
+        this.assertSupportsCommand(_Types_1.MeterCommand, _Types_1.MeterCommand.SupportedGet);
+        const cc = new MeterCCSupportedGet(this.applHost, {
+            nodeId: this.endpoint.nodeId,
+            endpoint: this.endpoint.index,
+        });
+        const response = await this.applHost.sendCommand(cc, this.commandOptions);
+        if (response) {
+            return (0, safe_2.pick)(response, [
+                "type",
+                "supportsReset",
+                "supportedScales",
+                "supportedRateTypes",
+            ]);
+        }
+    }
+    async reset(options) {
+        __assertType("options", "(optional) MeterCCResetOptions", __assertType__optional_MeterCCResetOptions.bind(void 0, options));
+        this.assertSupportsCommand(_Types_1.MeterCommand, _Types_1.MeterCommand.Reset);
+        const cc = new MeterCCReset(this.applHost, {
+            nodeId: this.endpoint.nodeId,
+            endpoint: this.endpoint.index,
+            ...options,
+        });
+        await this.applHost.sendCommand(cc, this.commandOptions);
+    }
+};
+_a = API_1.POLL_VALUE, _b = API_1.SET_VALUE;
+MeterCCAPI = __decorate([
+    (0, CommandClass_1.API)(safe_1.CommandClasses.Meter)
+], MeterCCAPI);
+exports.MeterCCAPI = MeterCCAPI;
+let MeterCC = class MeterCC extends CommandClass_1.CommandClass {
+    async interview(applHost) {
+        const node = this.getNode(applHost);
+        const endpoint = this.getEndpoint(applHost);
+        const api = API_1.CCAPI.create(safe_1.CommandClasses.Meter, applHost, endpoint).withOptions({
+            priority: safe_1.MessagePriority.NodeQuery,
+        });
+        applHost.controllerLog.logNode(node.id, {
+            endpoint: this.endpointIndex,
+            message: `Interviewing ${this.ccName}...`,
+            direction: "none",
+        });
+        if (this.version >= 2) {
+            applHost.controllerLog.logNode(node.id, {
+                endpoint: this.endpointIndex,
+                message: "querying meter support...",
+                direction: "outbound",
+            });
+            const suppResp = await api.getSupported();
+            if (suppResp) {
+                const logMessage = `received meter support:
+type:                 ${getMeterTypeName(applHost.configManager, suppResp.type)}
+supported scales:     ${suppResp.supportedScales
+                    .map((s) => applHost.configManager.lookupMeterScale(suppResp.type, s).label)
+                    .map((label) => `\n· ${label}`)
+                    .join("")}
+supported rate types: ${suppResp.supportedRateTypes
+                    .map((rt) => (0, safe_2.getEnumMemberName)(_Types_1.RateType, rt))
+                    .map((label) => `\n· ${label}`)
+                    .join("")}
+supports reset:       ${suppResp.supportsReset}`;
+                applHost.controllerLog.logNode(node.id, {
+                    endpoint: this.endpointIndex,
+                    message: logMessage,
+                    direction: "inbound",
+                });
+            }
+            else {
+                applHost.controllerLog.logNode(node.id, {
+                    endpoint: this.endpointIndex,
+                    message: "Querying meter support timed out, skipping interview...",
+                    level: "warn",
+                });
+                return;
+            }
+        }
+        // Query current meter values
+        await this.refreshValues(applHost);
+        // Remember that the interview is complete
+        this.setInterviewComplete(applHost, true);
+    }
+    async refreshValues(applHost) {
+        var _c, _d, _e;
+        const node = this.getNode(applHost);
+        const endpoint = this.getEndpoint(applHost);
+        const api = API_1.CCAPI.create(safe_1.CommandClasses.Meter, applHost, endpoint).withOptions({
+            priority: safe_1.MessagePriority.NodeQuery,
+        });
+        const valueDB = this.getValueDB(applHost);
+        if (this.version === 1) {
+            applHost.controllerLog.logNode(node.id, {
+                endpoint: this.endpointIndex,
+                message: `querying default meter value...`,
+                direction: "outbound",
+            });
+            await api.get();
+        }
+        else {
+            const type = (_c = valueDB.getValue(getTypeValueId(this.endpointIndex))) !== null && _c !== void 0 ? _c : 0;
+            const supportedScales = (_d = valueDB.getValue(getSupportedScalesValueId(this.endpointIndex))) !== null && _d !== void 0 ? _d : [];
+            const supportedRateTypes = (_e = valueDB.getValue(getSupportedRateTypesValueId(this.endpointIndex))) !== null && _e !== void 0 ? _e : [];
+            const rateTypes = supportedRateTypes.length
+                ? supportedRateTypes
+                : [undefined];
+            for (const rateType of rateTypes) {
+                for (const scale of supportedScales) {
+                    applHost.controllerLog.logNode(node.id, {
+                        endpoint: this.endpointIndex,
+                        message: `querying meter value (type = ${getMeterTypeName(applHost.configManager, type)}, scale = ${applHost.configManager.lookupMeterScale(type, scale)
+                            .label}${rateType != undefined
+                            ? `, rate type = ${(0, safe_2.getEnumMemberName)(_Types_1.RateType, rateType)}`
+                            : ""})...`,
+                        direction: "outbound",
+                    });
+                    await api.get({ scale, rateType });
+                }
+            }
+        }
+    }
+    translatePropertyKey(applHost, property, propertyKey) {
+        if (property === "value" && typeof propertyKey === "number") {
+            const { meterType, rateType, scale } = splitPropertyKey(propertyKey);
+            let ret;
+            if (meterType !== 0) {
+                ret = `${applHost.configManager.getMeterName(meterType)}_${applHost.configManager.lookupMeterScale(meterType, scale)
+                    .label}`;
+            }
+            else {
+                ret = "default";
+            }
+            if (rateType !== _Types_1.RateType.Unspecified) {
+                ret += "_" + (0, safe_2.getEnumMemberName)(_Types_1.RateType, rateType);
+            }
+            return ret;
+        }
+        else if (property === "reset" && typeof propertyKey === "number") {
+            return getMeterTypeName(applHost.configManager, propertyKey);
+        }
+        return super.translatePropertyKey(applHost, property, propertyKey);
+    }
+};
+MeterCC = __decorate([
+    (0, CommandClass_1.commandClass)(safe_1.CommandClasses.Meter),
+    (0, CommandClass_1.implementedVersion)(6)
+], MeterCC);
+exports.MeterCC = MeterCC;
+let MeterCCReport = class MeterCCReport extends MeterCC {
+    constructor(host, options) {
+        super(host, options);
+        (0, safe_1.validatePayload)(this.payload.length >= 2);
+        this._type = this.payload[0] & 31;
+        this._rateType = (this.payload[0] & 96) >>> 5;
+        const scale1Bit2 = (this.payload[0] & 128) >>> 7;
+        const { scale: scale1Bits10, value, bytesRead, } = (0, safe_1.parseFloatWithScale)(this.payload.slice(1));
+        let offset = 2 + (bytesRead - 1);
+        // The scale is composed of two fields (see SDS13781)
+        const scale1 = (scale1Bit2 << 2) | scale1Bits10;
+        let scale2 = 0;
+        this._value = value;
+        if (this.version >= 2 && this.payload.length >= offset + 2) {
+            this._deltaTime = this.payload.readUInt16BE(offset);
+            offset += 2;
+            if (this._deltaTime === 0xffff) {
+                this._deltaTime = safe_1.unknownNumber;
+            }
+            if (
+            // 0 means that no previous value is included
+            this.deltaTime !== 0 &&
+                this.payload.length >= offset + (bytesRead - 1)) {
+                const { value: prevValue } = (0, safe_1.parseFloatWithScale)(
+                // This float is split in the payload
+                Buffer.concat([
+                    Buffer.from([this.payload[1]]),
+                    this.payload.slice(offset),
+                ]));
+                offset += bytesRead - 1;
+                this._previousValue = prevValue;
+            }
+            if (this.version >= 4 &&
+                scale1 === 7 &&
+                this.payload.length >= offset + 1) {
+                scale2 = this.payload[offset];
+            }
+        }
+        else {
+            // 0 means that no previous value is included
+            this._deltaTime = 0;
+        }
+        this.scale = scale1 === 7 ? scale1 + scale2 : scale1;
+    }
+    persistValues(applHost) {
+        var _c, _d, _e, _f;
+        if (!super.persistValues(applHost))
+            return false;
+        const valueDB = this.getValueDB(applHost);
+        const meterType = applHost.configManager.lookupMeter(this._type);
+        const scale = applHost.configManager.lookupMeterScale(this._type, this.scale);
+        // Filter out unknown meter types and scales, unless the strict validation is disabled
+        const measurementValidation = !((_f = (_e = (_d = (_c = this.host).getDeviceConfig) === null || _d === void 0 ? void 0 : _d.call(_c, this.nodeId)) === null || _e === void 0 ? void 0 : _e.compat) === null || _f === void 0 ? void 0 : _f.disableStrictMeasurementValidation);
+        if (measurementValidation) {
+            safe_1.validatePayload.withReason(`Unknown meter type ${(0, safe_2.num2hex)(this.type)} or corrupted data`)(!!meterType);
+            safe_1.validatePayload.withReason(`Unknown meter scale ${(0, safe_2.num2hex)(this.scale)} or corrupted data`)(scale.label !== (0, config_1.getDefaultMeterScale)(this.scale).label);
+            // Filter out unsupported meter types, scales and rate types if possible
+            if (this.version >= 2) {
+                const expectedType = valueDB.getValue(getTypeValueId(this.endpointIndex));
+                if (expectedType != undefined) {
+                    safe_1.validatePayload.withReason("Unexpected meter type or corrupted data")(this._type === expectedType);
+                }
+                const supportedScales = valueDB.getValue(getSupportedScalesValueId(this.endpointIndex));
+                if (supportedScales === null || supportedScales === void 0 ? void 0 : supportedScales.length) {
+                    safe_1.validatePayload.withReason(`Unsupported meter scale ${scale.label} or corrupted data`)(supportedScales.includes(this.scale));
+                }
+                const supportedRateTypes = valueDB.getValue(getSupportedRateTypesValueId(this.endpointIndex));
+                if (supportedRateTypes === null || supportedRateTypes === void 0 ? void 0 : supportedRateTypes.length) {
+                    safe_1.validatePayload.withReason(`Unsupported rate type ${(0, safe_2.getEnumMemberName)(_Types_1.RateType, this._rateType)} or corrupted data`)(supportedRateTypes.includes(this._rateType));
+                }
+            }
+        }
+        const valueId = {
+            commandClass: this.ccId,
+            endpoint: this.endpointIndex,
+            property: "value",
+            propertyKey: toPropertyKey(this._type, this._rateType, this.scale),
+        };
+        // Always create metadata if it does not exist
+        if (!valueDB.hasMetadata(valueId)) {
+            valueDB.setMetadata(valueId, {
+                ...safe_1.ValueMetadata.ReadOnlyNumber,
+                label: getValueLabel(applHost.configManager, this._type, scale, this._rateType),
+                unit: scale.label,
+                ccSpecific: {
+                    meterType: this._type,
+                    rateType: this._rateType,
+                    scale: this.scale,
+                },
+            });
+        }
+        valueDB.setValue(valueId, this._value);
+        return true;
+    }
+    get type() {
+        return this._type;
+    }
+    get value() {
+        return this._value;
+    }
+    get previousValue() {
+        return this._previousValue;
+    }
+    get rateType() {
+        return this._rateType;
+    }
+    get deltaTime() {
+        return this._deltaTime;
+    }
+    toLogEntry(applHost) {
+        var _c;
+        const meterType = applHost.configManager.lookupMeter(this._type);
+        const scale = applHost.configManager.lookupMeterScale(this._type, this.scale);
+        const message = {
+            type: (_c = meterType === null || meterType === void 0 ? void 0 : meterType.name) !== null && _c !== void 0 ? _c : `Unknown (${(0, safe_2.num2hex)(this._type)})`,
+            scale: scale.label,
+            "rate type": (0, safe_2.getEnumMemberName)(_Types_1.RateType, this._rateType),
+            value: this.value,
+        };
+        if (this._deltaTime !== "unknown") {
+            message["time delta"] = `${this.deltaTime} seconds`;
+        }
+        if (this._previousValue != undefined) {
+            message["prev. value"] = this._previousValue;
+        }
+        return {
+            ...super.toLogEntry(applHost),
+            message,
+        };
+    }
+};
+MeterCCReport = __decorate([
+    (0, CommandClass_1.CCCommand)(_Types_1.MeterCommand.Report)
+], MeterCCReport);
+exports.MeterCCReport = MeterCCReport;
+function testResponseForMeterGet(sent, received) {
+    // We expect a Meter Report that matches the requested scale and rate type
+    // (if they were requested)
+    return ((sent.scale == undefined || sent.scale === received.scale) &&
+        (sent.rateType == undefined || sent.rateType == received.rateType));
+}
+let MeterCCGet = class MeterCCGet extends MeterCC {
+    constructor(host, options) {
+        super(host, options);
+        if ((0, CommandClass_1.gotDeserializationOptions)(options)) {
+            // TODO: Deserialize payload
+            throw new safe_1.ZWaveError(`${this.constructor.name}: deserialization not implemented`, safe_1.ZWaveErrorCodes.Deserialization_NotImplemented);
+        }
+        else {
+            this.rateType = options.rateType;
+            this.scale = options.scale;
+        }
+    }
+    serialize() {
+        let scale1;
+        let scale2;
+        let bufferLength = 0;
+        if (this.scale == undefined) {
+            scale1 = 0;
+        }
+        else if (this.version >= 4 && this.scale >= 7) {
+            scale1 = 7;
+            scale2 = this.scale >>> 3;
+            bufferLength = 2;
+        }
+        else if (this.version >= 3) {
+            scale1 = this.scale & 0b111;
+            bufferLength = 1;
+        }
+        else if (this.version >= 2) {
+            scale1 = this.scale & 0b11;
+            bufferLength = 1;
+        }
+        else {
+            scale1 = 0;
+        }
+        let rateTypeFlags = 0;
+        if (this.version >= 4 && this.rateType != undefined) {
+            rateTypeFlags = this.rateType & 0b11;
+            bufferLength = Math.max(bufferLength, 1);
+        }
+        this.payload = Buffer.alloc(bufferLength, 0);
+        this.payload[0] = (rateTypeFlags << 6) | (scale1 << 3);
+        if (scale2)
+            this.payload[1] = scale2;
+        return super.serialize();
+    }
+    toLogEntry(applHost) {
+        const message = {};
+        if (this.rateType != undefined) {
+            message["rate type"] = (0, safe_2.getEnumMemberName)(_Types_1.RateType, this.rateType);
+        }
+        if (this.scale != undefined) {
+            // Try to lookup the meter type to translate the scale
+            const type = this.getValueDB(applHost).getValue(getTypeValueId(this.endpointIndex));
+            if (type != undefined) {
+                message.scale = applHost.configManager.lookupMeterScale(type, this.scale).label;
+            }
+        }
+        return {
+            ...super.toLogEntry(applHost),
+            message,
+        };
+    }
+};
+MeterCCGet = __decorate([
+    (0, CommandClass_1.CCCommand)(_Types_1.MeterCommand.Get),
+    (0, CommandClass_1.expectedCCResponse)(MeterCCReport, testResponseForMeterGet)
+], MeterCCGet);
+exports.MeterCCGet = MeterCCGet;
+let MeterCCSupportedReport = class MeterCCSupportedReport extends MeterCC {
+    constructor(host, options) {
+        super(host, options);
+        (0, safe_1.validatePayload)(this.payload.length >= 2);
+        this._type = this.payload[0] & 31;
+        this._supportsReset = !!(this.payload[0] & 128);
+        const hasMoreScales = !!(this.payload[1] & 128);
+        if (hasMoreScales) {
+            // The bitmask is spread out
+            (0, safe_1.validatePayload)(this.payload.length >= 3);
+            const extraBytes = this.payload[2];
+            (0, safe_1.validatePayload)(this.payload.length >= 3 + extraBytes);
+            // The bitmask is the original payload byte plus all following bytes
+            // Since the first byte only has 7 bits, we need to reduce all following bits by 1
+            this._supportedScales = (0, safe_1.parseBitMask)(Buffer.concat([
+                Buffer.from([this.payload[1] & 127]),
+                this.payload.slice(3, 3 + extraBytes),
+            ]), 0).map((scale) => (scale >= 8 ? scale - 1 : scale));
+        }
+        else {
+            // only 7 bits in the bitmask. Bit 7 is 0, so no need to mask it out
+            this._supportedScales = (0, safe_1.parseBitMask)(Buffer.from([this.payload[1]]), 0);
+        }
+        // This is only present in V4+
+        this._supportedRateTypes = (0, safe_1.parseBitMask)(Buffer.from([(this.payload[0] & 96) >>> 5]), 1);
+    }
+    get type() {
+        return this._type;
+    }
+    get supportsReset() {
+        return this._supportsReset;
+    }
+    get supportedScales() {
+        return this._supportedScales;
+    }
+    get supportedRateTypes() {
+        return this._supportedRateTypes;
+    }
+    persistValues(applHost) {
+        if (!super.persistValues(applHost))
+            return false;
+        if (!this._supportsReset)
+            return true;
+        const valueDB = this.getValueDB(applHost);
+        // Create reset values
+        if (this.version < 6) {
+            const resetAllValueId = getResetValueId(this.endpointIndex);
+            if (!valueDB.hasMetadata(resetAllValueId)) {
+                valueDB.setMetadata(resetAllValueId, {
+                    ...safe_1.ValueMetadata.WriteOnlyBoolean,
+                    label: `Reset accumulated values`,
+                });
+            }
+        }
+        else {
+            const resetSingle = getResetValueId(this.endpointIndex, this._type);
+            if (!valueDB.hasMetadata(resetSingle)) {
+                valueDB.setMetadata(resetSingle, {
+                    ...safe_1.ValueMetadata.WriteOnlyBoolean,
+                    label: `Reset (${getMeterTypeName(applHost.configManager, this._type)})`,
+                    ccSpecific: {
+                        meterType: this._type,
+                    },
+                });
+            }
+        }
+        return true;
+    }
+    toLogEntry(applHost) {
+        var _c, _d;
+        const message = {
+            type: `${(_d = (_c = applHost.configManager.lookupMeter(this.type)) === null || _c === void 0 ? void 0 : _c.name) !== null && _d !== void 0 ? _d : `Unknown (${(0, safe_2.num2hex)(this.type)})`}`,
+            "supports reset": this._supportsReset,
+            "supported scales": `${this._supportedScales
+                .map((scale) => `
+· ${applHost.configManager.lookupMeterScale(this.type, scale).label}`)
+                .join("")}`,
+            "supported rate types": this._supportedRateTypes
+                .map((rt) => (0, safe_2.getEnumMemberName)(_Types_1.RateType, rt))
+                .join(", "),
+        };
+        return {
+            ...super.toLogEntry(applHost),
+            message,
+        };
+    }
+};
+__decorate([
+    (0, CommandClass_1.ccValue)({ internal: true })
+], MeterCCSupportedReport.prototype, "type", null);
+__decorate([
+    (0, CommandClass_1.ccValue)({ internal: true })
+], MeterCCSupportedReport.prototype, "supportsReset", null);
+__decorate([
+    (0, CommandClass_1.ccValue)({ internal: true })
+], MeterCCSupportedReport.prototype, "supportedScales", null);
+__decorate([
+    (0, CommandClass_1.ccValue)({ internal: true })
+], MeterCCSupportedReport.prototype, "supportedRateTypes", null);
+MeterCCSupportedReport = __decorate([
+    (0, CommandClass_1.CCCommand)(_Types_1.MeterCommand.SupportedReport)
+], MeterCCSupportedReport);
+exports.MeterCCSupportedReport = MeterCCSupportedReport;
+let MeterCCSupportedGet = class MeterCCSupportedGet extends MeterCC {
+};
+MeterCCSupportedGet = __decorate([
+    (0, CommandClass_1.CCCommand)(_Types_1.MeterCommand.SupportedGet),
+    (0, CommandClass_1.expectedCCResponse)(MeterCCSupportedReport)
+], MeterCCSupportedGet);
+exports.MeterCCSupportedGet = MeterCCSupportedGet;
+let MeterCCReset = class MeterCCReset extends MeterCC {
+    constructor(host, options) {
+        super(host, options);
+        if ((0, CommandClass_1.gotDeserializationOptions)(options)) {
+            // TODO: Deserialize payload
+            throw new safe_1.ZWaveError(`${this.constructor.name}: deserialization not implemented`, safe_1.ZWaveErrorCodes.Deserialization_NotImplemented);
+        }
+        else {
+            this.type = options.type;
+            this.targetValue = options.targetValue;
+            // Test if this is a valid target value
+            if (this.targetValue != undefined &&
+                !(0, safe_1.getMinIntegerSize)(this.targetValue, true)) {
+                throw new safe_1.ZWaveError(`${this.targetValue} is not a valid target value!`, safe_1.ZWaveErrorCodes.Argument_Invalid);
+            }
+        }
+    }
+    serialize() {
+        if (this.version >= 6 && this.targetValue != undefined && this.type) {
+            const size = (this.targetValue &&
+                (0, safe_1.getMinIntegerSize)(this.targetValue, true)) ||
+                0;
+            if (size > 0) {
+                this.payload = Buffer.allocUnsafe(1 + size);
+                this.payload[0] = (size << 5) | (this.type & 0b11111);
+                this.payload.writeIntBE(this.targetValue, 1, size);
+            }
+        }
+        return super.serialize();
+    }
+    toLogEntry(applHost) {
+        var _c, _d;
+        const message = {};
+        if (this.type != undefined) {
+            message.type = `${(_d = (_c = applHost.configManager.lookupMeter(this.type)) === null || _c === void 0 ? void 0 : _c.name) !== null && _d !== void 0 ? _d : `Unknown (${(0, safe_2.num2hex)(this.type)})`}`;
+        }
+        if (this.targetValue != undefined) {
+            message["target value"] = this.targetValue;
+        }
+        return {
+            ...super.toLogEntry(applHost),
+            message,
+        };
+    }
+};
+MeterCCReset = __decorate([
+    (0, CommandClass_1.CCCommand)(_Types_1.MeterCommand.Reset)
+], MeterCCReset);
+exports.MeterCCReset = MeterCCReset;
+//# sourceMappingURL=MeterCC.js.map