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

package/build/esm/cc/FirmwareUpdateMetaDataCC.js

@@ -0,0 +1,1142 @@
+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 FirmwareUpdateMetaDataCCMetaDataReport_1, FirmwareUpdateMetaDataCCRequestReport_1, FirmwareUpdateMetaDataCCGet_1, FirmwareUpdateMetaDataCCStatusReport_1, FirmwareUpdateMetaDataCCActivationReport_1, FirmwareUpdateMetaDataCCPrepareReport_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__FirmwareUpdateMetaDataCCMetaDataReportOptions = $o => {
+    function _number($o) {
+        return typeof $o !== "number" ? {} : null;
+    }
+    function _boolean($o) {
+        return typeof $o !== "boolean" ? {} : null;
+    }
+    function sa__number_ea_3($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;
+    }
+    function _undefined($o) {
+        return $o !== undefined ? {} : null;
+    }
+    function _false($o) {
+        return $o !== false ? {} : null;
+    }
+    function _true($o) {
+        return $o !== true ? {} : null;
+    }
+    function su__undefined__6__7_eu($o) {
+        const conditions = [_undefined, _false, _true];
+        for (const condition of conditions) {
+            const error = condition($o);
+            if (!error)
+                return null;
+        }
+        return {};
+    }
+    function _0($o) {
+        if (typeof $o !== "object" || $o === null || Array.isArray($o))
+            return {};
+        if ("manufacturerId" in $o && $o["manufacturerId"] !== undefined) {
+            const error = _number($o["manufacturerId"]);
+            if (error)
+                return error;
+        }
+        else
+            return {};
+        if ("firmwareId" in $o && $o["firmwareId"] !== undefined) {
+            const error = _number($o["firmwareId"]);
+            if (error)
+                return error;
+        }
+        if ("checksum" in $o && $o["checksum"] !== undefined) {
+            const error = _number($o["checksum"]);
+            if (error)
+                return error;
+        }
+        if ("firmwareUpgradable" in $o && $o["firmwareUpgradable"] !== undefined) {
+            const error = _boolean($o["firmwareUpgradable"]);
+            if (error)
+                return error;
+        }
+        else
+            return {};
+        if ("maxFragmentSize" in $o && $o["maxFragmentSize"] !== undefined) {
+            const error = _number($o["maxFragmentSize"]);
+            if (error)
+                return error;
+        }
+        if ("additionalFirmwareIDs" in $o && $o["additionalFirmwareIDs"] !== undefined) {
+            const error = sa__number_ea_3($o["additionalFirmwareIDs"]);
+            if (error)
+                return error;
+        }
+        if ("hardwareVersion" in $o && $o["hardwareVersion"] !== undefined) {
+            const error = _number($o["hardwareVersion"]);
+            if (error)
+                return error;
+        }
+        if ("continuesToFunction" in $o && $o["continuesToFunction"] !== undefined) {
+            const error = su__undefined__6__7_eu($o["continuesToFunction"]);
+            if (error)
+                return error;
+        }
+        if ("supportsActivation" in $o && $o["supportsActivation"] !== undefined) {
+            const error = su__undefined__6__7_eu($o["supportsActivation"]);
+            if (error)
+                return error;
+        }
+        if ("supportsResuming" in $o && $o["supportsResuming"] !== undefined) {
+            const error = su__undefined__6__7_eu($o["supportsResuming"]);
+            if (error)
+                return error;
+        }
+        if ("supportsNonSecureTransfer" in $o && $o["supportsNonSecureTransfer"] !== undefined) {
+            const error = su__undefined__6__7_eu($o["supportsNonSecureTransfer"]);
+            if (error)
+                return error;
+        }
+        return null;
+    }
+    return _0($o);
+};
+const __assertType__FirmwareUpdateMetaDataCCRequestGetOptions = $o => {
+    function _number($o) {
+        return typeof $o !== "number" ? {} : null;
+    }
+    function _2($o) {
+        if (typeof $o !== "object" || $o === null || Array.isArray($o))
+            return {};
+        if ("manufacturerId" in $o && $o["manufacturerId"] !== undefined) {
+            const error = _number($o["manufacturerId"]);
+            if (error)
+                return error;
+        }
+        else
+            return {};
+        if ("firmwareId" in $o && $o["firmwareId"] !== undefined) {
+            const error = _number($o["firmwareId"]);
+            if (error)
+                return error;
+        }
+        else
+            return {};
+        if ("checksum" in $o && $o["checksum"] !== undefined) {
+            const error = _number($o["checksum"]);
+            if (error)
+                return error;
+        }
+        else
+            return {};
+        return null;
+    }
+    function _boolean($o) {
+        return typeof $o !== "boolean" ? {} : null;
+    }
+    function _3($o) {
+        if (typeof $o !== "object" || $o === null || Array.isArray($o))
+            return {};
+        if ("firmwareTarget" in $o && $o["firmwareTarget"] !== undefined) {
+            const error = _number($o["firmwareTarget"]);
+            if (error)
+                return error;
+        }
+        else
+            return {};
+        if ("fragmentSize" in $o && $o["fragmentSize"] !== undefined) {
+            const error = _number($o["fragmentSize"]);
+            if (error)
+                return error;
+        }
+        else
+            return {};
+        if ("activation" in $o && $o["activation"] !== undefined) {
+            const error = _boolean($o["activation"]);
+            if (error)
+                return error;
+        }
+        if ("hardwareVersion" in $o && $o["hardwareVersion"] !== undefined) {
+            const error = _number($o["hardwareVersion"]);
+            if (error)
+                return error;
+        }
+        if ("resume" in $o && $o["resume"] !== undefined) {
+            const error = _boolean($o["resume"]);
+            if (error)
+                return error;
+        }
+        if ("nonSecureTransfer" in $o && $o["nonSecureTransfer"] !== undefined) {
+            const error = _boolean($o["nonSecureTransfer"]);
+            if (error)
+                return error;
+        }
+        return null;
+    }
+    function si__2__3_ei($o) {
+        const conditions = [_2, _3];
+        for (const condition of conditions) {
+            const error = condition($o);
+            if (error)
+                return error;
+        }
+        return null;
+    }
+    function _undefined($o) {
+        return $o !== undefined ? {} : null;
+    }
+    function _5($o) {
+        if (typeof $o !== "object" || $o === null || Array.isArray($o))
+            return {};
+        if ("firmwareTarget" in $o && $o["firmwareTarget"] !== undefined) {
+            const error = _undefined($o["firmwareTarget"]);
+            if (error)
+                return error;
+        }
+        if ("fragmentSize" in $o && $o["fragmentSize"] !== undefined) {
+            const error = _undefined($o["fragmentSize"]);
+            if (error)
+                return error;
+        }
+        if ("activation" in $o && $o["activation"] !== undefined) {
+            const error = _undefined($o["activation"]);
+            if (error)
+                return error;
+        }
+        if ("hardwareVersion" in $o && $o["hardwareVersion"] !== undefined) {
+            const error = _undefined($o["hardwareVersion"]);
+            if (error)
+                return error;
+        }
+        if ("resume" in $o && $o["resume"] !== undefined) {
+            const error = _undefined($o["resume"]);
+            if (error)
+                return error;
+        }
+        if ("nonSecureTransfer" in $o && $o["nonSecureTransfer"] !== undefined) {
+            const error = _undefined($o["nonSecureTransfer"]);
+            if (error)
+                return error;
+        }
+        return null;
+    }
+    function si__2__5_ei($o) {
+        const conditions = [_2, _5];
+        for (const condition of conditions) {
+            const error = condition($o);
+            if (error)
+                return error;
+        }
+        return null;
+    }
+    function su_si__2__3_ei_si__2__5_ei_eu($o) {
+        const conditions = [si__2__3_ei, si__2__5_ei];
+        for (const condition of conditions) {
+            const error = condition($o);
+            if (!error)
+                return null;
+        }
+        return {};
+    }
+    return su_si__2__3_ei_si__2__5_ei_eu($o);
+};
+const __assertType__number = $o => {
+    function _number($o) {
+        return typeof $o !== "number" ? {} : null;
+    }
+    return _number($o);
+};
+const __assertType__boolean = $o => {
+    function _boolean($o) {
+        return typeof $o !== "boolean" ? {} : null;
+    }
+    return _boolean($o);
+};
+const __assertType__Uint8Array = $o => {
+    function _uint8array($o) {
+        return !require("@zwave-js/shared/safe").isUint8Array($o) ? {} : null;
+    }
+    return _uint8array($o);
+};
+const __assertType__FirmwareUpdateMetaDataCCActivationSetOptions = $o => {
+    function _number($o) {
+        return typeof $o !== "number" ? {} : null;
+    }
+    function _0($o) {
+        if (typeof $o !== "object" || $o === null || Array.isArray($o))
+            return {};
+        if ("manufacturerId" in $o && $o["manufacturerId"] !== undefined) {
+            const error = _number($o["manufacturerId"]);
+            if (error)
+                return error;
+        }
+        else
+            return {};
+        if ("firmwareId" in $o && $o["firmwareId"] !== undefined) {
+            const error = _number($o["firmwareId"]);
+            if (error)
+                return error;
+        }
+        else
+            return {};
+        if ("checksum" in $o && $o["checksum"] !== undefined) {
+            const error = _number($o["checksum"]);
+            if (error)
+                return error;
+        }
+        else
+            return {};
+        if ("firmwareTarget" in $o && $o["firmwareTarget"] !== undefined) {
+            const error = _number($o["firmwareTarget"]);
+            if (error)
+                return error;
+        }
+        else
+            return {};
+        if ("hardwareVersion" in $o && $o["hardwareVersion"] !== undefined) {
+            const error = _number($o["hardwareVersion"]);
+            if (error)
+                return error;
+        }
+        return null;
+    }
+    return _0($o);
+};
+import { CRC16_CCITT, CommandClasses, MessagePriority, ZWaveError, ZWaveErrorCodes, validatePayload, } from "@zwave-js/core/safe";
+import { Bytes } from "@zwave-js/shared/safe";
+import { getEnumMemberName, num2hex, pick, } from "@zwave-js/shared/safe";
+import { CCAPI, PhysicalCCAPI } from "../lib/API.js";
+import { CommandClass, getEffectiveCCVersion, } from "../lib/CommandClass.js";
+import { API, CCCommand, ccValue, ccValues, commandClass, expectedCCResponse, implementedVersion, } from "../lib/CommandClassDecorators.js";
+import { V } from "../lib/Values.js";
+import { FirmwareDownloadStatus, FirmwareUpdateActivationStatus, FirmwareUpdateMetaDataCommand, FirmwareUpdateRequestStatus, FirmwareUpdateStatus, } from "../lib/_Types.js";
+// @noSetValueAPI There are no values to set here
+export const FirmwareUpdateMetaDataCCValues = Object.freeze({
+    ...V.defineStaticCCValues(CommandClasses["Firmware Update Meta Data"], {
+        ...V.staticProperty("supportsActivation", undefined, {
+            internal: true,
+        }),
+        ...V.staticProperty("firmwareUpgradable", undefined, {
+            internal: true,
+        }),
+        ...V.staticProperty("additionalFirmwareIDs", undefined, {
+            internal: true,
+        }),
+        ...V.staticProperty("continuesToFunction", undefined, {
+            internal: true,
+        }),
+        ...V.staticProperty("supportsResuming", undefined, {
+            internal: true,
+        }),
+        ...V.staticProperty("supportsNonSecureTransfer", undefined, {
+            internal: true,
+        }),
+    }),
+});
+let FirmwareUpdateMetaDataCCAPI = class FirmwareUpdateMetaDataCCAPI extends PhysicalCCAPI {
+    supportsCommand(cmd) {
+        switch (cmd) {
+            case FirmwareUpdateMetaDataCommand.MetaDataGet:
+            case FirmwareUpdateMetaDataCommand.MetaDataReport:
+            case FirmwareUpdateMetaDataCommand.RequestGet:
+            case FirmwareUpdateMetaDataCommand.Report:
+            case FirmwareUpdateMetaDataCommand.StatusReport:
+                return true;
+            case FirmwareUpdateMetaDataCommand.ActivationSet:
+                return (this.version >= 4
+                    && (this.version < 7
+                        || this.tryGetValueDB()?.getValue(FirmwareUpdateMetaDataCCValues
+                            .supportsActivation.endpoint(this.endpoint.index)) === true));
+            case FirmwareUpdateMetaDataCommand.PrepareGet:
+                return this.version >= 5;
+        }
+        return super.supportsCommand(cmd);
+    }
+    /**
+     * Requests information about the current firmware on the device
+     */
+    async getMetaData() {
+        this.assertSupportsCommand(FirmwareUpdateMetaDataCommand, FirmwareUpdateMetaDataCommand.MetaDataGet);
+        const cc = new FirmwareUpdateMetaDataCCMetaDataGet({
+            nodeId: this.endpoint.nodeId,
+            endpointIndex: this.endpoint.index,
+        });
+        const response = await this.host.sendCommand(cc, this.commandOptions);
+        if (response) {
+            return pick(response, [
+                "manufacturerId",
+                "firmwareId",
+                "checksum",
+                "firmwareUpgradable",
+                "maxFragmentSize",
+                "additionalFirmwareIDs",
+                "hardwareVersion",
+                "continuesToFunction",
+                "supportsActivation",
+                "supportsResuming",
+                "supportsNonSecureTransfer",
+            ]);
+        }
+    }
+    async reportMetaData(options) {
+        __assertType("options", "FirmwareUpdateMetaDataCCMetaDataReportOptions", __assertType__FirmwareUpdateMetaDataCCMetaDataReportOptions.bind(void 0, options));
+        this.assertSupportsCommand(FirmwareUpdateMetaDataCommand, FirmwareUpdateMetaDataCommand.Report);
+        const cc = new FirmwareUpdateMetaDataCCMetaDataReport({
+            nodeId: this.endpoint.nodeId,
+            endpointIndex: this.endpoint.index,
+            ...options,
+        });
+        await this.host.sendCommand(cc, this.commandOptions);
+    }
+    /**
+     * Requests the device to start the firmware update process.
+     * This does not wait for the reply - that is up to the caller of this method.
+     */
+    async requestUpdate(options) {
+        __assertType("options", "FirmwareUpdateMetaDataCCRequestGetOptions", __assertType__FirmwareUpdateMetaDataCCRequestGetOptions.bind(void 0, options));
+        this.assertSupportsCommand(FirmwareUpdateMetaDataCommand, FirmwareUpdateMetaDataCommand.RequestGet);
+        const cc = new FirmwareUpdateMetaDataCCRequestGet({
+            nodeId: this.endpoint.nodeId,
+            endpointIndex: this.endpoint.index,
+            ...options,
+        });
+        await this.host.sendCommand(cc, {
+            ...this.commandOptions,
+            // Do not wait for Nonce Reports
+            s2VerifyDelivery: false,
+        });
+    }
+    /**
+     * Sends a fragment of the new firmware to the device
+     */
+    async sendFirmwareFragment(fragmentNumber, isLastFragment, data) {
+        __assertType("fragmentNumber", "number", __assertType__number.bind(void 0, fragmentNumber));
+        __assertType("isLastFragment", "boolean", __assertType__boolean.bind(void 0, isLastFragment));
+        __assertType("data", "Uint8Array", __assertType__Uint8Array.bind(void 0, data));
+        this.assertSupportsCommand(FirmwareUpdateMetaDataCommand, FirmwareUpdateMetaDataCommand.Report);
+        const cc = new FirmwareUpdateMetaDataCCReport({
+            nodeId: this.endpoint.nodeId,
+            endpointIndex: this.endpoint.index,
+            reportNumber: fragmentNumber,
+            isLast: isLastFragment,
+            firmwareData: data,
+        });
+        await this.host.sendCommand(cc, {
+            ...this.commandOptions,
+            // Do not wait for Nonce Reports
+            s2VerifyDelivery: false,
+        });
+    }
+    /** Activates a previously transferred firmware image */
+    async activateFirmware(options) {
+        __assertType("options", "FirmwareUpdateMetaDataCCActivationSetOptions", __assertType__FirmwareUpdateMetaDataCCActivationSetOptions.bind(void 0, options));
+        this.assertSupportsCommand(FirmwareUpdateMetaDataCommand, FirmwareUpdateMetaDataCommand.ActivationSet);
+        const cc = new FirmwareUpdateMetaDataCCActivationSet({
+            nodeId: this.endpoint.nodeId,
+            endpointIndex: this.endpoint.index,
+            ...options,
+        });
+        const response = await this.host.sendCommand(cc, this.commandOptions);
+        return response?.activationStatus;
+    }
+};
+FirmwareUpdateMetaDataCCAPI = __decorate([
+    API(CommandClasses["Firmware Update Meta Data"])
+], FirmwareUpdateMetaDataCCAPI);
+export { FirmwareUpdateMetaDataCCAPI };
+let FirmwareUpdateMetaDataCC = class FirmwareUpdateMetaDataCC extends CommandClass {
+    skipEndpointInterview() {
+        return true;
+    }
+    async interview(ctx) {
+        const node = this.getNode(ctx);
+        const endpoint = this.getEndpoint(ctx);
+        const api = CCAPI.create(CommandClasses["Firmware Update Meta Data"], ctx, endpoint).withOptions({
+            priority: MessagePriority.NodeQuery,
+        });
+        ctx.logNode(node.id, {
+            endpoint: this.endpointIndex,
+            message: `Interviewing ${this.ccName}...`,
+            direction: "none",
+        });
+        ctx.logNode(node.id, {
+            endpoint: this.endpointIndex,
+            message: "Querying firmware update capabilities...",
+            direction: "outbound",
+        });
+        const caps = await api.getMetaData();
+        if (caps) {
+            let logMessage = `Received firmware update capabilities:`;
+            if (caps.firmwareUpgradable) {
+                logMessage += `
+  firmware targets:             ${[0, ...caps.additionalFirmwareIDs].join(", ")}
+  continues to function:        ${caps.continuesToFunction}
+  supports activation:          ${caps.supportsActivation}`;
+                if (caps.supportsResuming != undefined) {
+                    logMessage += `
+  supports resuming:            ${caps.supportsResuming}`;
+                }
+                if (caps.supportsNonSecureTransfer != undefined) {
+                    logMessage += `
+  supports non-secure transfer: ${caps.supportsNonSecureTransfer}`;
+                }
+            }
+            else {
+                logMessage += `\nfirmware upgradeable: false`;
+            }
+            ctx.logNode(node.id, {
+                endpoint: this.endpointIndex,
+                message: logMessage,
+                direction: "inbound",
+            });
+        }
+        else {
+            ctx.logNode(node.id, {
+                endpoint: this.endpointIndex,
+                message: "Firmware update capability query timed out",
+                direction: "inbound",
+            });
+        }
+        // Remember that the interview is complete
+        this.setInterviewComplete(ctx, true);
+    }
+};
+FirmwareUpdateMetaDataCC = __decorate([
+    commandClass(CommandClasses["Firmware Update Meta Data"]),
+    implementedVersion(8),
+    ccValues(FirmwareUpdateMetaDataCCValues)
+], FirmwareUpdateMetaDataCC);
+export { FirmwareUpdateMetaDataCC };
+let FirmwareUpdateMetaDataCCMetaDataReport = FirmwareUpdateMetaDataCCMetaDataReport_1 = class FirmwareUpdateMetaDataCCMetaDataReport extends FirmwareUpdateMetaDataCC {
+    constructor(options) {
+        super(options);
+        this.manufacturerId = options.manufacturerId;
+        this.firmwareId = options.firmwareId ?? 0;
+        this.checksum = options.checksum ?? 0;
+        this.firmwareUpgradable = options.firmwareUpgradable;
+        this.maxFragmentSize = options.maxFragmentSize;
+        this.additionalFirmwareIDs = options.additionalFirmwareIDs ?? [];
+        this.hardwareVersion = options.hardwareVersion;
+        this.continuesToFunction = options.continuesToFunction;
+        this.supportsActivation = options.supportsActivation;
+        this.supportsResuming = options.supportsResuming;
+        this.supportsNonSecureTransfer = options.supportsNonSecureTransfer;
+    }
+    static from(raw, ctx) {
+        validatePayload(raw.payload.length >= 6);
+        const manufacturerId = raw.payload.readUInt16BE(0);
+        const firmwareId = raw.payload.readUInt16BE(2);
+        const checksum = raw.payload.readUInt16BE(4);
+        // V1/V2 only have a single firmware which must be upgradable
+        const firmwareUpgradable = raw.payload[6] === 0xff
+            || raw.payload[6] == undefined;
+        let maxFragmentSize;
+        let additionalFirmwareIDs;
+        let hardwareVersion;
+        let continuesToFunction;
+        let supportsActivation;
+        let supportsResuming;
+        let supportsNonSecureTransfer;
+        if (raw.payload.length >= 10) {
+            // V3+
+            maxFragmentSize = raw.payload.readUInt16BE(8);
+            // Read variable length list of additional firmwares
+            const numAdditionalFirmwares = raw.payload[7];
+            additionalFirmwareIDs = [];
+            validatePayload(raw.payload.length >= 10 + 2 * numAdditionalFirmwares);
+            for (let i = 0; i < numAdditionalFirmwares; i++) {
+                additionalFirmwareIDs.push(raw.payload.readUInt16BE(10 + 2 * i));
+            }
+            // Read hardware version (if it exists)
+            let offset = 10 + 2 * numAdditionalFirmwares;
+            if (raw.payload.length >= offset + 1) {
+                // V5+
+                hardwareVersion = raw.payload[offset];
+                offset++;
+                if (raw.payload.length >= offset + 1) {
+                    // V6+
+                    const capabilities = raw.payload[offset];
+                    offset++;
+                    continuesToFunction = !!(capabilities & 0b1);
+                    // V7+
+                    supportsActivation = !!(capabilities & 0b10);
+                    // V8+
+                    supportsResuming = !!(capabilities & 0b1000);
+                    supportsNonSecureTransfer = !!(capabilities & 0b100);
+                }
+            }
+        }
+        return new FirmwareUpdateMetaDataCCMetaDataReport_1({
+            nodeId: ctx.sourceNodeId,
+            manufacturerId,
+            firmwareId,
+            checksum,
+            firmwareUpgradable,
+            maxFragmentSize,
+            additionalFirmwareIDs,
+            hardwareVersion,
+            continuesToFunction,
+            supportsActivation,
+            supportsResuming,
+            supportsNonSecureTransfer,
+        });
+    }
+    manufacturerId;
+    firmwareId;
+    checksum;
+    firmwareUpgradable;
+    maxFragmentSize;
+    additionalFirmwareIDs = [];
+    hardwareVersion;
+    continuesToFunction;
+    supportsActivation;
+    supportsResuming;
+    supportsNonSecureTransfer;
+    serialize(ctx) {
+        this.payload = Bytes.alloc(12 + 2 * this.additionalFirmwareIDs.length);
+        this.payload.writeUInt16BE(this.manufacturerId, 0);
+        this.payload.writeUInt16BE(this.firmwareId, 2);
+        this.payload.writeUInt16BE(this.checksum, 4);
+        this.payload[6] = this.firmwareUpgradable ? 0xff : 0;
+        this.payload[7] = this.additionalFirmwareIDs.length;
+        this.payload.writeUInt16BE(this.maxFragmentSize ?? 0xff, 8);
+        let offset = 10;
+        for (const id of this.additionalFirmwareIDs) {
+            this.payload.writeUInt16BE(id, offset);
+            offset += 2;
+        }
+        this.payload[offset++] = this.hardwareVersion ?? 0xff;
+        this.payload[offset++] = (this.continuesToFunction ? 0b1 : 0)
+            | (this.supportsActivation ? 0b10 : 0)
+            | (this.supportsNonSecureTransfer ? 0b100 : 0)
+            | (this.supportsResuming ? 0b1000 : 0);
+        return super.serialize(ctx);
+    }
+    toLogEntry(ctx) {
+        const message = {
+            "manufacturer id": this.manufacturerId,
+            "firmware id": this.firmwareId,
+            checksum: this.checksum,
+            "firmware upgradable": this.firmwareUpgradable,
+        };
+        if (this.maxFragmentSize != undefined) {
+            message["max fragment size"] = this.maxFragmentSize;
+        }
+        if (this.additionalFirmwareIDs.length) {
+            message["additional firmware IDs"] = JSON.stringify(this.additionalFirmwareIDs);
+        }
+        if (this.hardwareVersion != undefined) {
+            message["hardware version"] = this.hardwareVersion;
+        }
+        if (this.continuesToFunction != undefined) {
+            message["continues to function"] = this.continuesToFunction;
+        }
+        if (this.supportsActivation != undefined) {
+            message["supports activation"] = this.supportsActivation;
+        }
+        if (this.supportsResuming != undefined) {
+            message["supports resuming"] = this.supportsResuming;
+        }
+        if (this.supportsNonSecureTransfer != undefined) {
+            message["supports non-secure transfer"] =
+                this.supportsNonSecureTransfer;
+        }
+        return {
+            ...super.toLogEntry(ctx),
+            message,
+        };
+    }
+};
+__decorate([
+    ccValue(FirmwareUpdateMetaDataCCValues.firmwareUpgradable)
+], FirmwareUpdateMetaDataCCMetaDataReport.prototype, "firmwareUpgradable", void 0);
+__decorate([
+    ccValue(FirmwareUpdateMetaDataCCValues.additionalFirmwareIDs)
+], FirmwareUpdateMetaDataCCMetaDataReport.prototype, "additionalFirmwareIDs", void 0);
+__decorate([
+    ccValue(FirmwareUpdateMetaDataCCValues.continuesToFunction)
+], FirmwareUpdateMetaDataCCMetaDataReport.prototype, "continuesToFunction", void 0);
+__decorate([
+    ccValue(FirmwareUpdateMetaDataCCValues.supportsActivation)
+], FirmwareUpdateMetaDataCCMetaDataReport.prototype, "supportsActivation", void 0);
+__decorate([
+    ccValue(FirmwareUpdateMetaDataCCValues.supportsResuming)
+], FirmwareUpdateMetaDataCCMetaDataReport.prototype, "supportsResuming", void 0);
+__decorate([
+    ccValue(FirmwareUpdateMetaDataCCValues.supportsNonSecureTransfer)
+], FirmwareUpdateMetaDataCCMetaDataReport.prototype, "supportsNonSecureTransfer", void 0);
+FirmwareUpdateMetaDataCCMetaDataReport = FirmwareUpdateMetaDataCCMetaDataReport_1 = __decorate([
+    CCCommand(FirmwareUpdateMetaDataCommand.MetaDataReport)
+], FirmwareUpdateMetaDataCCMetaDataReport);
+export { FirmwareUpdateMetaDataCCMetaDataReport };
+let FirmwareUpdateMetaDataCCMetaDataGet = class FirmwareUpdateMetaDataCCMetaDataGet extends FirmwareUpdateMetaDataCC {
+};
+FirmwareUpdateMetaDataCCMetaDataGet = __decorate([
+    CCCommand(FirmwareUpdateMetaDataCommand.MetaDataGet),
+    expectedCCResponse(FirmwareUpdateMetaDataCCMetaDataReport)
+], FirmwareUpdateMetaDataCCMetaDataGet);
+export { FirmwareUpdateMetaDataCCMetaDataGet };
+let FirmwareUpdateMetaDataCCRequestReport = FirmwareUpdateMetaDataCCRequestReport_1 = class FirmwareUpdateMetaDataCCRequestReport extends FirmwareUpdateMetaDataCC {
+    constructor(options) {
+        super(options);
+        // TODO: Check implementation:
+        this.status = options.status;
+        this.resume = options.resume;
+        this.nonSecureTransfer = options.nonSecureTransfer;
+    }
+    static from(raw, ctx) {
+        validatePayload(raw.payload.length >= 1);
+        const status = raw.payload[0];
+        let resume;
+        let nonSecureTransfer;
+        if (raw.payload.length >= 2) {
+            resume = !!(raw.payload[1] & 0b100);
+            nonSecureTransfer = !!(raw.payload[1] & 0b10);
+        }
+        return new FirmwareUpdateMetaDataCCRequestReport_1({
+            nodeId: ctx.sourceNodeId,
+            status,
+            resume,
+            nonSecureTransfer,
+        });
+    }
+    status;
+    resume;
+    nonSecureTransfer;
+    toLogEntry(ctx) {
+        const message = {
+            status: getEnumMemberName(FirmwareUpdateRequestStatus, this.status),
+        };
+        if (this.resume != undefined) {
+            message.resume = this.resume;
+        }
+        if (this.nonSecureTransfer != undefined) {
+            message["non-secure transfer"] = this.nonSecureTransfer;
+        }
+        return {
+            ...super.toLogEntry(ctx),
+            message,
+        };
+    }
+};
+FirmwareUpdateMetaDataCCRequestReport = FirmwareUpdateMetaDataCCRequestReport_1 = __decorate([
+    CCCommand(FirmwareUpdateMetaDataCommand.RequestReport)
+], FirmwareUpdateMetaDataCCRequestReport);
+export { FirmwareUpdateMetaDataCCRequestReport };
+let FirmwareUpdateMetaDataCCRequestGet = class FirmwareUpdateMetaDataCCRequestGet extends FirmwareUpdateMetaDataCC {
+    constructor(options) {
+        super(options);
+        this.manufacturerId = options.manufacturerId;
+        this.firmwareId = options.firmwareId;
+        this.checksum = options.checksum;
+        if ("firmwareTarget" in options) {
+            this.firmwareTarget = options.firmwareTarget;
+            this.fragmentSize = options.fragmentSize;
+            this.activation = options.activation ?? false;
+            this.hardwareVersion = options.hardwareVersion;
+            this.resume = options.resume;
+            this.nonSecureTransfer = options.nonSecureTransfer;
+        }
+    }
+    static from(_raw, _ctx) {
+        // TODO: Deserialize payload
+        throw new ZWaveError(`${this.name}: deserialization not implemented`, ZWaveErrorCodes.Deserialization_NotImplemented);
+        // return new FirmwareUpdateMetaDataCCRequestGet({
+        // 	nodeId: ctx.sourceNodeId,
+        // });
+    }
+    manufacturerId;
+    firmwareId;
+    checksum;
+    firmwareTarget;
+    fragmentSize;
+    activation;
+    hardwareVersion;
+    resume;
+    nonSecureTransfer;
+    serialize(ctx) {
+        this.payload = Bytes.alloc(11, 0);
+        this.payload.writeUInt16BE(this.manufacturerId, 0);
+        this.payload.writeUInt16BE(this.firmwareId, 2);
+        this.payload.writeUInt16BE(this.checksum, 4);
+        this.payload[6] = this.firmwareTarget ?? 0;
+        // 32 seems like a reasonable default fragment size,
+        // but it should be specified anyways
+        this.payload.writeUInt16BE(this.fragmentSize ?? 32, 7);
+        this.payload[9] = (this.activation ? 0b1 : 0)
+            | (this.nonSecureTransfer ? 0b10 : 0)
+            | (this.resume ? 0b100 : 0);
+        this.payload[10] = this.hardwareVersion ?? 0x00;
+        return super.serialize(ctx);
+    }
+    toLogEntry(ctx) {
+        const message = {
+            "manufacturer id": num2hex(this.manufacturerId),
+            "firmware id": num2hex(this.firmwareId),
+            checksum: num2hex(this.checksum),
+        };
+        if (this.firmwareTarget != undefined) {
+            message["firmware target"] = this.firmwareTarget;
+        }
+        if (this.fragmentSize != undefined) {
+            message["fragment size"] = this.fragmentSize;
+        }
+        if (this.activation != undefined) {
+            message.activation = this.activation;
+        }
+        if (this.resume != undefined) {
+            message.resume = this.resume;
+        }
+        if (this.nonSecureTransfer != undefined) {
+            message["non-secure transfer"] = this.nonSecureTransfer;
+        }
+        if (this.hardwareVersion != undefined) {
+            message["hardware version"] = this.hardwareVersion;
+        }
+        return {
+            ...super.toLogEntry(ctx),
+            message,
+        };
+    }
+};
+FirmwareUpdateMetaDataCCRequestGet = __decorate([
+    CCCommand(FirmwareUpdateMetaDataCommand.RequestGet)
+    // This would expect a FirmwareUpdateMetaDataCCRequestReport, but the response may take
+    // a while to come. We don't want to block communication, so we don't expect a response here
+], FirmwareUpdateMetaDataCCRequestGet);
+export { FirmwareUpdateMetaDataCCRequestGet };
+let FirmwareUpdateMetaDataCCGet = FirmwareUpdateMetaDataCCGet_1 = class FirmwareUpdateMetaDataCCGet extends FirmwareUpdateMetaDataCC {
+    constructor(options) {
+        super(options);
+        // TODO: Check implementation:
+        this.numReports = options.numReports;
+        this.reportNumber = options.reportNumber;
+    }
+    static from(raw, ctx) {
+        validatePayload(raw.payload.length >= 3);
+        const numReports = raw.payload[0];
+        const reportNumber = raw.payload.readUInt16BE(1) & 0x7fff;
+        return new FirmwareUpdateMetaDataCCGet_1({
+            nodeId: ctx.sourceNodeId,
+            numReports,
+            reportNumber,
+        });
+    }
+    numReports;
+    reportNumber;
+    toLogEntry(ctx) {
+        return {
+            ...super.toLogEntry(ctx),
+            message: {
+                "total # of reports": this.numReports,
+                "report number": this.reportNumber,
+            },
+        };
+    }
+};
+FirmwareUpdateMetaDataCCGet = FirmwareUpdateMetaDataCCGet_1 = __decorate([
+    CCCommand(FirmwareUpdateMetaDataCommand.Get)
+    // This is sent to us from the node, so we expect no response
+], FirmwareUpdateMetaDataCCGet);
+export { FirmwareUpdateMetaDataCCGet };
+let FirmwareUpdateMetaDataCCReport = class FirmwareUpdateMetaDataCCReport extends FirmwareUpdateMetaDataCC {
+    constructor(options) {
+        super(options);
+        this.reportNumber = options.reportNumber;
+        this.firmwareData = options.firmwareData;
+        this.isLast = options.isLast;
+    }
+    static from(_raw, _ctx) {
+        // TODO: Deserialize payload
+        throw new ZWaveError(`${this.name}: deserialization not implemented`, ZWaveErrorCodes.Deserialization_NotImplemented);
+        // return new FirmwareUpdateMetaDataCCReport({
+        // 	nodeId: ctx.sourceNodeId,
+        // });
+    }
+    isLast;
+    reportNumber;
+    firmwareData;
+    serialize(ctx) {
+        const commandBuffer = Bytes.concat([
+            new Bytes(2), // placeholder for report number
+            this.firmwareData,
+        ]);
+        commandBuffer.writeUInt16BE((this.reportNumber & 0x7fff) | (this.isLast ? 0x8000 : 0), 0);
+        // V1 devices would consider the checksum to be part of the firmware data
+        // so it must not be included for those
+        const ccVersion = getEffectiveCCVersion(ctx, this);
+        if (ccVersion >= 2) {
+            // Compute and save the CRC16 in the payload
+            // The CC header is included in the CRC computation
+            let crc = CRC16_CCITT(Bytes.from([this.ccId, this.ccCommand]));
+            crc = CRC16_CCITT(commandBuffer, crc);
+            this.payload = Bytes.concat([
+                commandBuffer,
+                new Bytes(2),
+            ]);
+            this.payload.writeUInt16BE(crc, this.payload.length - 2);
+        }
+        else {
+            this.payload = commandBuffer;
+        }
+        return super.serialize(ctx);
+    }
+    toLogEntry(ctx) {
+        return {
+            ...super.toLogEntry(ctx),
+            message: {
+                "report #": this.reportNumber,
+                "is last": this.isLast,
+            },
+        };
+    }
+};
+FirmwareUpdateMetaDataCCReport = __decorate([
+    CCCommand(FirmwareUpdateMetaDataCommand.Report)
+    // We send this in reply to the Get command and expect no response
+], FirmwareUpdateMetaDataCCReport);
+export { FirmwareUpdateMetaDataCCReport };
+let FirmwareUpdateMetaDataCCStatusReport = FirmwareUpdateMetaDataCCStatusReport_1 = class FirmwareUpdateMetaDataCCStatusReport extends FirmwareUpdateMetaDataCC {
+    constructor(options) {
+        super(options);
+        // TODO: Check implementation:
+        this.status = options.status;
+        this.waitTime = options.waitTime;
+    }
+    static from(raw, ctx) {
+        validatePayload(raw.payload.length >= 1);
+        const status = raw.payload[0];
+        let waitTime;
+        if (raw.payload.length >= 3) {
+            waitTime = raw.payload.readUInt16BE(1);
+        }
+        return new FirmwareUpdateMetaDataCCStatusReport_1({
+            nodeId: ctx.sourceNodeId,
+            status,
+            waitTime,
+        });
+    }
+    status;
+    /** The wait time in seconds before the node becomes available for communication after the update */
+    waitTime;
+    toLogEntry(ctx) {
+        const message = {
+            status: getEnumMemberName(FirmwareUpdateStatus, this.status),
+        };
+        if (this.waitTime != undefined) {
+            message["wait time"] = `${this.waitTime} seconds`;
+        }
+        return {
+            ...super.toLogEntry(ctx),
+            message,
+        };
+    }
+};
+FirmwareUpdateMetaDataCCStatusReport = FirmwareUpdateMetaDataCCStatusReport_1 = __decorate([
+    CCCommand(FirmwareUpdateMetaDataCommand.StatusReport)
+], FirmwareUpdateMetaDataCCStatusReport);
+export { FirmwareUpdateMetaDataCCStatusReport };
+let FirmwareUpdateMetaDataCCActivationReport = FirmwareUpdateMetaDataCCActivationReport_1 = class FirmwareUpdateMetaDataCCActivationReport extends FirmwareUpdateMetaDataCC {
+    constructor(options) {
+        super(options);
+        // TODO: Check implementation:
+        this.manufacturerId = options.manufacturerId;
+        this.firmwareId = options.firmwareId;
+        this.checksum = options.checksum;
+        this.firmwareTarget = options.firmwareTarget;
+        this.activationStatus = options.activationStatus;
+        this.hardwareVersion = options.hardwareVersion;
+    }
+    static from(raw, ctx) {
+        validatePayload(raw.payload.length >= 8);
+        const manufacturerId = raw.payload.readUInt16BE(0);
+        const firmwareId = raw.payload.readUInt16BE(2);
+        const checksum = raw.payload.readUInt16BE(4);
+        const firmwareTarget = raw.payload[6];
+        const activationStatus = raw.payload[7];
+        let hardwareVersion;
+        if (raw.payload.length >= 9) {
+            // V5+
+            hardwareVersion = raw.payload[8];
+        }
+        return new FirmwareUpdateMetaDataCCActivationReport_1({
+            nodeId: ctx.sourceNodeId,
+            manufacturerId,
+            firmwareId,
+            checksum,
+            firmwareTarget,
+            activationStatus,
+            hardwareVersion,
+        });
+    }
+    manufacturerId;
+    firmwareId;
+    checksum;
+    firmwareTarget;
+    activationStatus;
+    hardwareVersion;
+    toLogEntry(ctx) {
+        const message = {
+            "manufacturer id": num2hex(this.manufacturerId),
+            "firmware id": num2hex(this.firmwareId),
+            checksum: num2hex(this.checksum),
+            "firmware target": this.firmwareTarget,
+            "activation status": getEnumMemberName(FirmwareUpdateActivationStatus, this.activationStatus),
+        };
+        if (this.hardwareVersion != undefined) {
+            message.hardwareVersion = this.hardwareVersion;
+        }
+        return {
+            ...super.toLogEntry(ctx),
+            message,
+        };
+    }
+};
+FirmwareUpdateMetaDataCCActivationReport = FirmwareUpdateMetaDataCCActivationReport_1 = __decorate([
+    CCCommand(FirmwareUpdateMetaDataCommand.ActivationReport)
+], FirmwareUpdateMetaDataCCActivationReport);
+export { FirmwareUpdateMetaDataCCActivationReport };
+let FirmwareUpdateMetaDataCCActivationSet = class FirmwareUpdateMetaDataCCActivationSet extends FirmwareUpdateMetaDataCC {
+    constructor(options) {
+        super(options);
+        this.manufacturerId = options.manufacturerId;
+        this.firmwareId = options.firmwareId;
+        this.checksum = options.checksum;
+        this.firmwareTarget = options.firmwareTarget;
+        this.hardwareVersion = options.hardwareVersion;
+    }
+    static from(_raw, _ctx) {
+        // TODO: Deserialize payload
+        throw new ZWaveError(`${this.name}: deserialization not implemented`, ZWaveErrorCodes.Deserialization_NotImplemented);
+        // return new FirmwareUpdateMetaDataCCActivationSet({
+        // 	nodeId: ctx.sourceNodeId,
+        // });
+    }
+    manufacturerId;
+    firmwareId;
+    checksum;
+    firmwareTarget;
+    hardwareVersion;
+    serialize(ctx) {
+        this.payload = new Bytes(8);
+        this.payload.writeUInt16BE(this.manufacturerId, 0);
+        this.payload.writeUInt16BE(this.firmwareId, 2);
+        this.payload.writeUInt16BE(this.checksum, 4);
+        this.payload[6] = this.firmwareTarget;
+        this.payload[7] = this.hardwareVersion ?? 0x00;
+        return super.serialize(ctx);
+    }
+    toLogEntry(ctx) {
+        const message = {
+            "manufacturer id": num2hex(this.manufacturerId),
+            "firmware id": num2hex(this.firmwareId),
+            checksum: num2hex(this.checksum),
+            "firmware target": this.firmwareTarget,
+        };
+        if (this.hardwareVersion != undefined) {
+            message["hardware version"] = this.hardwareVersion;
+        }
+        return {
+            ...super.toLogEntry(ctx),
+            message,
+        };
+    }
+};
+FirmwareUpdateMetaDataCCActivationSet = __decorate([
+    CCCommand(FirmwareUpdateMetaDataCommand.ActivationSet),
+    expectedCCResponse(FirmwareUpdateMetaDataCCActivationReport)
+], FirmwareUpdateMetaDataCCActivationSet);
+export { FirmwareUpdateMetaDataCCActivationSet };
+let FirmwareUpdateMetaDataCCPrepareReport = FirmwareUpdateMetaDataCCPrepareReport_1 = class FirmwareUpdateMetaDataCCPrepareReport extends FirmwareUpdateMetaDataCC {
+    constructor(options) {
+        super(options);
+        // TODO: Check implementation:
+        this.status = options.status;
+        this.checksum = options.checksum;
+    }
+    static from(raw, ctx) {
+        validatePayload(raw.payload.length >= 3);
+        const status = raw.payload[0];
+        const checksum = raw.payload.readUInt16BE(1);
+        return new FirmwareUpdateMetaDataCCPrepareReport_1({
+            nodeId: ctx.sourceNodeId,
+            status,
+            checksum,
+        });
+    }
+    status;
+    checksum;
+    toLogEntry(ctx) {
+        return {
+            ...super.toLogEntry(ctx),
+            message: {
+                status: getEnumMemberName(FirmwareDownloadStatus, this.status),
+                checksum: num2hex(this.checksum),
+            },
+        };
+    }
+};
+FirmwareUpdateMetaDataCCPrepareReport = FirmwareUpdateMetaDataCCPrepareReport_1 = __decorate([
+    CCCommand(FirmwareUpdateMetaDataCommand.PrepareReport)
+], FirmwareUpdateMetaDataCCPrepareReport);
+export { FirmwareUpdateMetaDataCCPrepareReport };
+let FirmwareUpdateMetaDataCCPrepareGet = class FirmwareUpdateMetaDataCCPrepareGet extends FirmwareUpdateMetaDataCC {
+    constructor(options) {
+        super(options);
+        this.manufacturerId = options.manufacturerId;
+        this.firmwareId = options.firmwareId;
+        this.firmwareTarget = options.firmwareTarget;
+        this.fragmentSize = options.fragmentSize;
+        this.hardwareVersion = options.hardwareVersion;
+    }
+    static from(_raw, _ctx) {
+        // TODO: Deserialize payload
+        throw new ZWaveError(`${this.name}: deserialization not implemented`, ZWaveErrorCodes.Deserialization_NotImplemented);
+        // return new FirmwareUpdateMetaDataCCPrepareGet({
+        // 	nodeId: ctx.sourceNodeId,
+        // });
+    }
+    manufacturerId;
+    firmwareId;
+    firmwareTarget;
+    fragmentSize;
+    hardwareVersion;
+    serialize(ctx) {
+        this.payload = new Bytes(8);
+        this.payload.writeUInt16BE(this.manufacturerId, 0);
+        this.payload.writeUInt16BE(this.firmwareId, 2);
+        this.payload[4] = this.firmwareTarget;
+        this.payload.writeUInt16BE(this.fragmentSize, 5);
+        this.payload[7] = this.hardwareVersion;
+        return super.serialize(ctx);
+    }
+    toLogEntry(ctx) {
+        return {
+            ...super.toLogEntry(ctx),
+            message: {
+                "manufacturer id": num2hex(this.manufacturerId),
+                "firmware id": num2hex(this.firmwareId),
+                "firmware target": this.firmwareTarget,
+                "fragment size": this.fragmentSize,
+                "hardware version": this.hardwareVersion,
+            },
+        };
+    }
+};
+FirmwareUpdateMetaDataCCPrepareGet = __decorate([
+    CCCommand(FirmwareUpdateMetaDataCommand.PrepareGet),
+    expectedCCResponse(FirmwareUpdateMetaDataCCReport)
+], FirmwareUpdateMetaDataCCPrepareGet);
+export { FirmwareUpdateMetaDataCCPrepareGet };
+//# sourceMappingURL=FirmwareUpdateMetaDataCC.js.map