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

package/build/esm/cc/VersionCC.js

@@ -0,0 +1,862 @@
+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 VersionCCReport_1, VersionCCCommandClassReport_1, VersionCCCommandClassGet_1, VersionCCCapabilitiesReport_1, VersionCCZWaveSoftwareReport_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__VersionCCReportOptions = $o => {
+    function su__2__3__4__5__6__7__8__9__10__11__12__13_eu($o) {
+        return ![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11].includes($o) ? {} : null;
+    }
+    function _string($o) {
+        return typeof $o !== "string" ? {} : null;
+    }
+    function sa__string_ea_16($o) {
+        if (!Array.isArray($o))
+            return {};
+        for (let i = 0; i < $o.length; i++) {
+            const error = _string($o[i]);
+            if (error)
+                return error;
+        }
+        return null;
+    }
+    function _number($o) {
+        return typeof $o !== "number" ? {} : null;
+    }
+    function _0($o) {
+        if (typeof $o !== "object" || $o === null || Array.isArray($o))
+            return {};
+        if ("libraryType" in $o && $o["libraryType"] !== undefined) {
+            const error = su__2__3__4__5__6__7__8__9__10__11__12__13_eu($o["libraryType"]);
+            if (error)
+                return error;
+        }
+        else
+            return {};
+        if ("protocolVersion" in $o && $o["protocolVersion"] !== undefined) {
+            const error = _string($o["protocolVersion"]);
+            if (error)
+                return error;
+        }
+        else
+            return {};
+        if ("firmwareVersions" in $o && $o["firmwareVersions"] !== undefined) {
+            const error = sa__string_ea_16($o["firmwareVersions"]);
+            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);
+};
+const __assertType__number = $o => {
+    function _number($o) {
+        return typeof $o !== "number" ? {} : null;
+    }
+    return _number($o);
+};
+import { CommandClasses, MessagePriority, SecurityClass, ValueMetadata, ZWaveError, ZWaveErrorCodes, ZWaveLibraryTypes, enumValuesToMetadataStates, getCCName, securityClassIsS2, securityClassOrder, 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, } from "../lib/CommandClass.js";
+import { API, CCCommand, ccValue, ccValues, commandClass, expectedCCResponse, getImplementedVersion, implementedVersion, } from "../lib/CommandClassDecorators.js";
+import { V } from "../lib/Values.js";
+import { VersionCommand } from "../lib/_Types.js";
+export const VersionCCValues = Object.freeze({
+    ...V.defineStaticCCValues(CommandClasses.Version, {
+        ...V.staticProperty("firmwareVersions", {
+            ...ValueMetadata.ReadOnly,
+            type: "string[]",
+            label: "Z-Wave chip firmware versions",
+        }, { supportsEndpoints: false }),
+        ...V.staticProperty("libraryType", {
+            ...ValueMetadata.ReadOnlyNumber,
+            label: "Library type",
+            states: enumValuesToMetadataStates(ZWaveLibraryTypes),
+        }, { supportsEndpoints: false }),
+        ...V.staticProperty("protocolVersion", {
+            ...ValueMetadata.ReadOnlyString,
+            label: "Z-Wave protocol version",
+        }, { supportsEndpoints: false }),
+        ...V.staticProperty("hardwareVersion", {
+            ...ValueMetadata.ReadOnlyNumber,
+            label: "Z-Wave chip hardware version",
+        }, {
+            minVersion: 2,
+            supportsEndpoints: false,
+        }),
+        ...V.staticProperty("supportsZWaveSoftwareGet", undefined, {
+            minVersion: 3,
+            internal: true,
+        }),
+        ...V.staticProperty("sdkVersion", {
+            ...ValueMetadata.ReadOnlyString,
+            label: "SDK version",
+        }, {
+            minVersion: 3,
+            supportsEndpoints: false,
+        }),
+        ...V.staticProperty("applicationFrameworkAPIVersion", {
+            ...ValueMetadata.ReadOnlyString,
+            label: "Z-Wave application framework API version",
+        }, {
+            minVersion: 3,
+            supportsEndpoints: false,
+        }),
+        ...V.staticProperty("applicationFrameworkBuildNumber", {
+            ...ValueMetadata.ReadOnlyString,
+            label: "Z-Wave application framework API build number",
+        }, {
+            minVersion: 3,
+            supportsEndpoints: false,
+        }),
+        ...V.staticPropertyWithName("serialAPIVersion", "hostInterfaceVersion", {
+            ...ValueMetadata.ReadOnlyString,
+            label: "Serial API version",
+        }, {
+            minVersion: 3,
+            supportsEndpoints: false,
+        }),
+        ...V.staticPropertyWithName("serialAPIBuildNumber", "hostInterfaceBuildNumber", {
+            ...ValueMetadata.ReadOnlyString,
+            label: "Serial API build number",
+        }, {
+            minVersion: 3,
+            supportsEndpoints: false,
+        }),
+        ...V.staticProperty("zWaveProtocolVersion", {
+            ...ValueMetadata.ReadOnlyString,
+            label: "Z-Wave protocol version",
+        }, {
+            minVersion: 3,
+            supportsEndpoints: false,
+        }),
+        ...V.staticProperty("zWaveProtocolBuildNumber", {
+            ...ValueMetadata.ReadOnlyString,
+            label: "Z-Wave protocol build number",
+        }, {
+            minVersion: 3,
+            supportsEndpoints: false,
+        }),
+        ...V.staticProperty("applicationVersion", {
+            ...ValueMetadata.ReadOnlyString,
+            label: "Application version",
+        }, {
+            minVersion: 3,
+            supportsEndpoints: false,
+        }),
+        ...V.staticProperty("applicationBuildNumber", {
+            ...ValueMetadata.ReadOnlyString,
+            label: "Application build number",
+        }, {
+            minVersion: 3,
+            supportsEndpoints: false,
+        }),
+    }),
+});
+function parseVersion(buffer) {
+    if (buffer[0] === 0 && buffer[1] === 0 && buffer[2] === 0)
+        return "unused";
+    return `${buffer[0]}.${buffer[1]}.${buffer[2]}`;
+}
+// @noSetValueAPI This CC is read-only
+let VersionCCAPI = class VersionCCAPI extends PhysicalCCAPI {
+    supportsCommand(cmd) {
+        switch (cmd) {
+            case VersionCommand.Get:
+            case VersionCommand.Report:
+            case VersionCommand.CommandClassGet:
+            case VersionCommand.CommandClassReport:
+                return true; // This is mandatory
+            case VersionCommand.CapabilitiesGet:
+            case VersionCommand.CapabilitiesReport:
+            case VersionCommand.ZWaveSoftwareReport:
+                return this.version >= 3;
+            case VersionCommand.ZWaveSoftwareGet: {
+                return this.getValueDB().getValue(VersionCCValues.supportsZWaveSoftwareGet.endpoint(this.endpoint.index));
+            }
+        }
+        return super.supportsCommand(cmd);
+    }
+    // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
+    async get() {
+        this.assertSupportsCommand(VersionCommand, VersionCommand.Get);
+        const cc = new VersionCCGet({
+            nodeId: this.endpoint.nodeId,
+            endpointIndex: this.endpoint.index,
+        });
+        const response = await this.host.sendCommand(cc, this.commandOptions);
+        if (response) {
+            return pick(response, [
+                "libraryType",
+                "protocolVersion",
+                "firmwareVersions",
+                "hardwareVersion",
+            ]);
+        }
+    }
+    async sendReport(options) {
+        __assertType("options", "VersionCCReportOptions", __assertType__VersionCCReportOptions.bind(void 0, options));
+        this.assertSupportsCommand(VersionCommand, VersionCommand.Report);
+        const cc = new VersionCCReport({
+            nodeId: this.endpoint.nodeId,
+            endpointIndex: this.endpoint.index,
+            ...options,
+        });
+        await this.host.sendCommand(cc, this.commandOptions);
+    }
+    async getCCVersion(requestedCC) {
+        __assertType("requestedCC", "CommandClasses", __assertType__number.bind(void 0, requestedCC));
+        this.assertSupportsCommand(VersionCommand, VersionCommand.CommandClassGet);
+        const cc = new VersionCCCommandClassGet({
+            nodeId: this.endpoint.nodeId,
+            endpointIndex: this.endpoint.index,
+            requestedCC,
+        });
+        const response = await this.host.sendCommand(cc, this.commandOptions);
+        return response?.ccVersion;
+    }
+    async reportCCVersion(requestedCC) {
+        __assertType("requestedCC", "CommandClasses", __assertType__number.bind(void 0, requestedCC));
+        this.assertSupportsCommand(VersionCommand, VersionCommand.CommandClassReport);
+        let ccVersion;
+        switch (requestedCC) {
+            case CommandClasses["Z-Wave Protocol"]:
+            case CommandClasses["Z-Wave Long Range"]:
+                // These two are only for internal use
+                ccVersion = 0;
+                break;
+            case CommandClasses.Hail:
+            case CommandClasses["Manufacturer Proprietary"]:
+                // These CCs are obsolete, we cannot enter them in the certification portal
+                // but not doing so fails a certification test. Just respond that they
+                // are not supported or controlled
+                ccVersion = 0;
+                break;
+            default:
+                ccVersion = getImplementedVersion(requestedCC);
+                break;
+        }
+        const cc = new VersionCCCommandClassReport({
+            nodeId: this.endpoint.nodeId,
+            endpointIndex: this.endpoint.index,
+            requestedCC,
+            ccVersion,
+        });
+        await this.host.sendCommand(cc, this.commandOptions);
+    }
+    // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
+    async getCapabilities() {
+        this.assertSupportsCommand(VersionCommand, VersionCommand.CapabilitiesGet);
+        const cc = new VersionCCCapabilitiesGet({
+            nodeId: this.endpoint.nodeId,
+            endpointIndex: this.endpoint.index,
+        });
+        const response = await this.host.sendCommand(cc, this.commandOptions);
+        if (response) {
+            return pick(response, ["supportsZWaveSoftwareGet"]);
+        }
+    }
+    async reportCapabilities() {
+        this.assertSupportsCommand(VersionCommand, VersionCommand.CapabilitiesReport);
+        const cc = new VersionCCCapabilitiesReport({
+            nodeId: this.endpoint.nodeId,
+            endpointIndex: this.endpoint.index,
+            // At this time, we do not support responding to Z-Wave Software Get
+            supportsZWaveSoftwareGet: false,
+        });
+        await this.host.sendCommand(cc, this.commandOptions);
+    }
+    // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
+    async getZWaveSoftware() {
+        this.assertSupportsCommand(VersionCommand, VersionCommand.ZWaveSoftwareGet);
+        const cc = new VersionCCZWaveSoftwareGet({
+            nodeId: this.endpoint.nodeId,
+            endpointIndex: this.endpoint.index,
+        });
+        const response = await this.host.sendCommand(cc, this.commandOptions);
+        if (response) {
+            return pick(response, [
+                "sdkVersion",
+                "applicationFrameworkAPIVersion",
+                "applicationFrameworkBuildNumber",
+                "hostInterfaceVersion",
+                "hostInterfaceBuildNumber",
+                "zWaveProtocolVersion",
+                "zWaveProtocolBuildNumber",
+                "applicationVersion",
+                "applicationBuildNumber",
+            ]);
+        }
+    }
+};
+VersionCCAPI = __decorate([
+    API(CommandClasses.Version)
+], VersionCCAPI);
+export { VersionCCAPI };
+let VersionCC = class VersionCC extends CommandClass {
+    determineRequiredCCInterviews() {
+        // VersionCC must be the 2nd CC after ManufacturerSpecificCC
+        return [CommandClasses["Manufacturer Specific"]];
+    }
+    async interview(ctx) {
+        const node = this.getNode(ctx);
+        // SDS13782: In a Multi Channel device, the Version Command Class MUST be supported by the Root Device, while
+        // the Version Command Class SHOULD NOT be supported by individual End Points.
+        //
+        // There may be cases where a given Command Class is not implemented by the Root Device of a Multi
+        // Channel device. However, the Root Device MUST respond to Version requests for any Command Class
+        // implemented by the Multi Channel device; also in cases where the actual Command Class is only
+        // provided by an End Point.
+        const endpoint = this.getEndpoint(ctx);
+        // Use the CC API of the root device for all queries
+        const api = CCAPI.create(CommandClasses.Version, ctx, node).withOptions({
+            priority: MessagePriority.NodeQuery,
+        });
+        ctx.logNode(node.id, {
+            endpoint: this.endpointIndex,
+            message: `Interviewing ${this.ccName}...`,
+            direction: "none",
+        });
+        const queryCCVersion = async (cc) => {
+            // Only query CCs we support. Theoretically we could skip queries where we support only V1,
+            // but there are Z-Wave certification tests that require us to query all CCs
+            const maxImplemented = getImplementedVersion(cc);
+            if (maxImplemented === 0) {
+                ctx.logNode(node.id, `  skipping query for ${CommandClasses[cc]} (${num2hex(cc)}) because max implemented version is ${maxImplemented}`);
+                return;
+            }
+            ctx.logNode(node.id, {
+                endpoint: this.endpointIndex,
+                message: `  querying the CC version for ${getCCName(cc)}...`,
+                direction: "outbound",
+            });
+            // query the CC version
+            const supportedVersion = await api.getCCVersion(cc);
+            if (supportedVersion != undefined) {
+                // Remember which CC version this endpoint supports
+                let logMessage;
+                if (supportedVersion > 0) {
+                    // Basic CC has special rules for when it is considered supported
+                    // Therefore we mark all other CCs as supported, but not Basic CC,
+                    // for which support is determined later.
+                    if (cc === CommandClasses.Basic) {
+                        endpoint.addCC(cc, { version: supportedVersion });
+                    }
+                    else {
+                        endpoint.addCC(cc, {
+                            isSupported: true,
+                            version: supportedVersion,
+                        });
+                    }
+                    logMessage = `  supports CC ${CommandClasses[cc]} (${num2hex(cc)}) in version ${supportedVersion}`;
+                }
+                else {
+                    // We were lied to - the NIF said this CC is supported, now the node claims it isn't
+                    // Make sure this is not a critical CC, which must be supported though
+                    if (cc === CommandClasses.Version
+                        || cc === CommandClasses["Manufacturer Specific"]) {
+                        logMessage = `  claims NOT to support CC ${CommandClasses[cc]} (${num2hex(cc)}), but it must. Assuming the ${this.endpointIndex === 0 ? "node" : "endpoint"} supports version 1...`;
+                        endpoint.addCC(cc, { version: 1 });
+                    }
+                    else if ((cc === CommandClasses.Security
+                        && node.hasSecurityClass(SecurityClass.S0_Legacy))
+                        || (cc === CommandClasses["Security 2"]
+                            && securityClassOrder.some((sc) => securityClassIsS2(sc)
+                                && node.hasSecurityClass(sc)))) {
+                        logMessage = `  claims NOT to support CC ${CommandClasses[cc]} (${num2hex(cc)}), but it is known to support it. Assuming the ${this.endpointIndex === 0 ? "node" : "endpoint"} supports version 1...`;
+                        endpoint.addCC(cc, { version: 1 });
+                    }
+                    else {
+                        logMessage = `  does NOT support CC ${CommandClasses[cc]} (${num2hex(cc)})`;
+                        endpoint.removeCC(cc);
+                    }
+                }
+                ctx.logNode(node.id, {
+                    endpoint: this.endpointIndex,
+                    message: logMessage,
+                });
+            }
+            else {
+                ctx.logNode(node.id, {
+                    endpoint: this.endpointIndex,
+                    message: `CC version query for ${getCCName(cc)} timed out - assuming the ${this.endpointIndex === 0 ? "node" : "endpoint"} supports version 1...`,
+                    level: "warn",
+                });
+                endpoint.addCC(cc, { version: 1 });
+            }
+        };
+        // Version information should not change (except for firmware updates)
+        // And it is only relevant on the root endpoint (the node)
+        if (this.endpointIndex === 0) {
+            // Step 1: Query Version CC version
+            await queryCCVersion(CommandClasses.Version);
+            // Step 2: Query node versions
+            ctx.logNode(node.id, {
+                endpoint: this.endpointIndex,
+                message: "querying node versions...",
+                direction: "outbound",
+            });
+            const versionGetResponse = await api.get();
+            if (versionGetResponse) {
+                let logMessage = `received response for node versions:
+  library type:      ${ZWaveLibraryTypes[versionGetResponse.libraryType]} (${num2hex(versionGetResponse.libraryType)})
+  protocol version:  ${versionGetResponse.protocolVersion}
+  firmware versions: ${versionGetResponse.firmwareVersions.join(", ")}`;
+                if (versionGetResponse.hardwareVersion != undefined) {
+                    logMessage +=
+                        `\n  hardware version:  ${versionGetResponse.hardwareVersion}`;
+                }
+                ctx.logNode(node.id, {
+                    endpoint: this.endpointIndex,
+                    message: logMessage,
+                    direction: "inbound",
+                });
+            }
+        }
+        // Step 3: Query all other CC versions
+        ctx.logNode(node.id, {
+            endpoint: this.endpointIndex,
+            message: "querying CC versions...",
+            direction: "outbound",
+        });
+        // Basic CC is not included in the NIF, so it won't be returned by endpoint.getCCs() at this point
+        {
+            const cc = CommandClasses.Basic;
+            // Skip the query of endpoint CCs that are also supported by the root device
+            if (this.endpointIndex === 0 || node.getCCVersion(cc) === 0) {
+                await queryCCVersion(cc);
+            }
+        }
+        for (const [cc] of endpoint.getCCs()) {
+            // We already queried the Version CC version at the start of this interview
+            if (cc === CommandClasses.Version)
+                continue;
+            // And we queried Basic CC just before this
+            if (cc === CommandClasses.Basic)
+                continue;
+            // Skip the query of endpoint CCs that are also supported by the root device
+            if (this.endpointIndex > 0 && node.getCCVersion(cc) > 0)
+                continue;
+            await queryCCVersion(cc);
+        }
+        // Step 4: Query VersionCC capabilities (root device only)
+        if (this.endpointIndex === 0 && api.version >= 3) {
+            // Step 4a: Support for SoftwareGet
+            ctx.logNode(node.id, {
+                endpoint: this.endpointIndex,
+                message: "querying if Z-Wave Software Get is supported...",
+                direction: "outbound",
+            });
+            const capsResponse = await api.getCapabilities();
+            if (capsResponse) {
+                const { supportsZWaveSoftwareGet } = capsResponse;
+                ctx.logNode(node.id, {
+                    endpoint: this.endpointIndex,
+                    message: `Z-Wave Software Get is${supportsZWaveSoftwareGet ? "" : " not"} supported`,
+                    direction: "inbound",
+                });
+                if (supportsZWaveSoftwareGet) {
+                    // Step 4b: Query Z-Wave Software versions
+                    ctx.logNode(node.id, {
+                        endpoint: this.endpointIndex,
+                        message: "querying Z-Wave software versions...",
+                        direction: "outbound",
+                    });
+                    await api.getZWaveSoftware();
+                    ctx.logNode(node.id, {
+                        endpoint: this.endpointIndex,
+                        message: "received Z-Wave software versions",
+                        direction: "inbound",
+                    });
+                }
+            }
+        }
+        // Remember that the interview is complete
+        this.setInterviewComplete(ctx, true);
+    }
+};
+VersionCC = __decorate([
+    commandClass(CommandClasses.Version),
+    implementedVersion(3),
+    ccValues(VersionCCValues)
+], VersionCC);
+export { VersionCC };
+let VersionCCReport = VersionCCReport_1 = class VersionCCReport extends VersionCC {
+    constructor(options) {
+        super(options);
+        if (!/^\d+\.\d+(\.\d+)?$/.test(options.protocolVersion)) {
+            throw new ZWaveError(`protocolVersion must be a string in the format "major.minor" or "major.minor.patch", received "${options.protocolVersion}"`, ZWaveErrorCodes.Argument_Invalid);
+        }
+        else if (!options.firmwareVersions.every((fw) => /^\d+\.\d+(\.\d+)?$/.test(fw))) {
+            throw new ZWaveError(`firmwareVersions must be an array of strings in the format "major.minor" or "major.minor.patch", received "${JSON.stringify(options.firmwareVersions)}"`, ZWaveErrorCodes.Argument_Invalid);
+        }
+        this.libraryType = options.libraryType;
+        this.protocolVersion = options.protocolVersion;
+        this.firmwareVersions = options.firmwareVersions;
+        this.hardwareVersion = options.hardwareVersion;
+    }
+    static from(raw, ctx) {
+        validatePayload(raw.payload.length >= 5);
+        const libraryType = raw.payload[0];
+        const protocolVersion = `${raw.payload[1]}.${raw.payload[2]}`;
+        const firmwareVersions = [`${raw.payload[3]}.${raw.payload[4]}`];
+        let hardwareVersion;
+        if (raw.payload.length >= 7) {
+            // V2+
+            hardwareVersion = raw.payload[5];
+            const additionalFirmwares = raw.payload[6];
+            validatePayload(raw.payload.length >= 7 + 2 * additionalFirmwares);
+            for (let i = 0; i < additionalFirmwares; i++) {
+                firmwareVersions.push(`${raw.payload[7 + 2 * i]}.${raw.payload[7 + 2 * i + 1]}`);
+            }
+        }
+        return new VersionCCReport_1({
+            nodeId: ctx.sourceNodeId,
+            libraryType,
+            protocolVersion,
+            firmwareVersions,
+            hardwareVersion,
+        });
+    }
+    libraryType;
+    protocolVersion;
+    firmwareVersions;
+    hardwareVersion;
+    serialize(ctx) {
+        this.payload = Bytes.from([
+            this.libraryType,
+            ...this.protocolVersion
+                .split(".")
+                .map((n) => parseInt(n))
+                .slice(0, 2),
+            ...this.firmwareVersions[0]
+                .split(".")
+                .map((n) => parseInt(n))
+                .slice(0, 2),
+            this.hardwareVersion ?? 0x00,
+            this.firmwareVersions.length - 1,
+        ]);
+        if (this.firmwareVersions.length > 1) {
+            const firmwaresBuffer = new Bytes((this.firmwareVersions.length - 1) * 2);
+            for (let i = 1; i < this.firmwareVersions.length; i++) {
+                const [major, minor] = this.firmwareVersions[i]
+                    .split(".")
+                    .map((n) => parseInt(n));
+                firmwaresBuffer[2 * (i - 1)] = major;
+                firmwaresBuffer[2 * (i - 1) + 1] = minor;
+            }
+            this.payload = Bytes.concat([this.payload, firmwaresBuffer]);
+        }
+        return super.serialize(ctx);
+    }
+    toLogEntry(ctx) {
+        const message = {
+            "library type": getEnumMemberName(ZWaveLibraryTypes, this.libraryType),
+            "protocol version": this.protocolVersion,
+            "firmware versions": this.firmwareVersions.join(", "),
+        };
+        if (this.hardwareVersion != undefined) {
+            message["hardware version"] = this.hardwareVersion;
+        }
+        return {
+            ...super.toLogEntry(ctx),
+            message,
+        };
+    }
+};
+__decorate([
+    ccValue(VersionCCValues.libraryType)
+], VersionCCReport.prototype, "libraryType", void 0);
+__decorate([
+    ccValue(VersionCCValues.protocolVersion)
+], VersionCCReport.prototype, "protocolVersion", void 0);
+__decorate([
+    ccValue(VersionCCValues.firmwareVersions)
+], VersionCCReport.prototype, "firmwareVersions", void 0);
+__decorate([
+    ccValue(VersionCCValues.hardwareVersion)
+], VersionCCReport.prototype, "hardwareVersion", void 0);
+VersionCCReport = VersionCCReport_1 = __decorate([
+    CCCommand(VersionCommand.Report)
+], VersionCCReport);
+export { VersionCCReport };
+let VersionCCGet = class VersionCCGet extends VersionCC {
+};
+VersionCCGet = __decorate([
+    CCCommand(VersionCommand.Get),
+    expectedCCResponse(VersionCCReport)
+], VersionCCGet);
+export { VersionCCGet };
+let VersionCCCommandClassReport = VersionCCCommandClassReport_1 = class VersionCCCommandClassReport extends VersionCC {
+    constructor(options) {
+        super(options);
+        this.requestedCC = options.requestedCC;
+        this.ccVersion = options.ccVersion;
+    }
+    static from(raw, ctx) {
+        validatePayload(raw.payload.length >= 2);
+        const requestedCC = raw.payload[0];
+        const ccVersion = raw.payload[1];
+        return new VersionCCCommandClassReport_1({
+            nodeId: ctx.sourceNodeId,
+            requestedCC,
+            ccVersion,
+        });
+    }
+    ccVersion;
+    requestedCC;
+    serialize(ctx) {
+        this.payload = Bytes.from([this.requestedCC, this.ccVersion]);
+        return super.serialize(ctx);
+    }
+    toLogEntry(ctx) {
+        return {
+            ...super.toLogEntry(ctx),
+            message: {
+                CC: getCCName(this.requestedCC),
+                version: this.ccVersion,
+            },
+        };
+    }
+};
+VersionCCCommandClassReport = VersionCCCommandClassReport_1 = __decorate([
+    CCCommand(VersionCommand.CommandClassReport)
+], VersionCCCommandClassReport);
+export { VersionCCCommandClassReport };
+function testResponseForVersionCommandClassGet(sent, received) {
+    // We expect a Version CommandClass Report that matches the requested CC
+    return sent.requestedCC === received.requestedCC;
+}
+let VersionCCCommandClassGet = VersionCCCommandClassGet_1 = class VersionCCCommandClassGet extends VersionCC {
+    constructor(options) {
+        super(options);
+        this.requestedCC = options.requestedCC;
+    }
+    static from(raw, ctx) {
+        validatePayload(raw.payload.length >= 1);
+        const requestedCC = raw.payload[0];
+        return new VersionCCCommandClassGet_1({
+            nodeId: ctx.sourceNodeId,
+            requestedCC,
+        });
+    }
+    requestedCC;
+    serialize(ctx) {
+        this.payload = Bytes.from([this.requestedCC]);
+        return super.serialize(ctx);
+    }
+    toLogEntry(ctx) {
+        return {
+            ...super.toLogEntry(ctx),
+            message: { CC: getCCName(this.requestedCC) },
+        };
+    }
+};
+VersionCCCommandClassGet = VersionCCCommandClassGet_1 = __decorate([
+    CCCommand(VersionCommand.CommandClassGet),
+    expectedCCResponse(VersionCCCommandClassReport, testResponseForVersionCommandClassGet)
+], VersionCCCommandClassGet);
+export { VersionCCCommandClassGet };
+let VersionCCCapabilitiesReport = VersionCCCapabilitiesReport_1 = class VersionCCCapabilitiesReport extends VersionCC {
+    constructor(options) {
+        super(options);
+        this.supportsZWaveSoftwareGet = options.supportsZWaveSoftwareGet;
+    }
+    static from(raw, ctx) {
+        validatePayload(raw.payload.length >= 1);
+        const capabilities = raw.payload[0];
+        const supportsZWaveSoftwareGet = !!(capabilities & 0b100);
+        return new VersionCCCapabilitiesReport_1({
+            nodeId: ctx.sourceNodeId,
+            supportsZWaveSoftwareGet,
+        });
+    }
+    supportsZWaveSoftwareGet;
+    serialize(ctx) {
+        this.payload = Bytes.from([
+            (this.supportsZWaveSoftwareGet ? 0b100 : 0) | 0b11,
+        ]);
+        return super.serialize(ctx);
+    }
+    toLogEntry(ctx) {
+        return {
+            ...super.toLogEntry(ctx),
+            message: {
+                "supports Z-Wave Software Get command": this.supportsZWaveSoftwareGet,
+            },
+        };
+    }
+};
+__decorate([
+    ccValue(VersionCCValues.supportsZWaveSoftwareGet)
+], VersionCCCapabilitiesReport.prototype, "supportsZWaveSoftwareGet", void 0);
+VersionCCCapabilitiesReport = VersionCCCapabilitiesReport_1 = __decorate([
+    CCCommand(VersionCommand.CapabilitiesReport)
+], VersionCCCapabilitiesReport);
+export { VersionCCCapabilitiesReport };
+let VersionCCCapabilitiesGet = class VersionCCCapabilitiesGet extends VersionCC {
+};
+VersionCCCapabilitiesGet = __decorate([
+    CCCommand(VersionCommand.CapabilitiesGet),
+    expectedCCResponse(VersionCCCapabilitiesReport)
+], VersionCCCapabilitiesGet);
+export { VersionCCCapabilitiesGet };
+let VersionCCZWaveSoftwareReport = VersionCCZWaveSoftwareReport_1 = class VersionCCZWaveSoftwareReport extends VersionCC {
+    constructor(options) {
+        super(options);
+        // TODO: Check implementation:
+        this.sdkVersion = options.sdkVersion;
+        this.applicationFrameworkAPIVersion =
+            options.applicationFrameworkAPIVersion;
+        this.applicationFrameworkBuildNumber =
+            options.applicationFrameworkBuildNumber;
+        this.hostInterfaceVersion = options.hostInterfaceVersion;
+        this.hostInterfaceBuildNumber = options.hostInterfaceBuildNumber;
+        this.zWaveProtocolVersion = options.zWaveProtocolVersion;
+        this.zWaveProtocolBuildNumber = options.zWaveProtocolBuildNumber;
+        this.applicationVersion = options.applicationVersion;
+        this.applicationBuildNumber = options.applicationBuildNumber;
+    }
+    static from(raw, ctx) {
+        validatePayload(raw.payload.length >= 23);
+        const sdkVersion = parseVersion(raw.payload);
+        const applicationFrameworkAPIVersion = parseVersion(raw.payload.subarray(3));
+        let applicationFrameworkBuildNumber;
+        if (applicationFrameworkAPIVersion !== "unused") {
+            applicationFrameworkBuildNumber = raw.payload.readUInt16BE(6);
+        }
+        else {
+            applicationFrameworkBuildNumber = 0;
+        }
+        const hostInterfaceVersion = parseVersion(raw.payload.subarray(8));
+        let hostInterfaceBuildNumber;
+        if (hostInterfaceVersion !== "unused") {
+            hostInterfaceBuildNumber = raw.payload.readUInt16BE(11);
+        }
+        else {
+            hostInterfaceBuildNumber = 0;
+        }
+        const zWaveProtocolVersion = parseVersion(raw.payload.subarray(13));
+        let zWaveProtocolBuildNumber;
+        if (zWaveProtocolVersion !== "unused") {
+            zWaveProtocolBuildNumber = raw.payload.readUInt16BE(16);
+        }
+        else {
+            zWaveProtocolBuildNumber = 0;
+        }
+        const applicationVersion = parseVersion(raw.payload.subarray(18));
+        let applicationBuildNumber;
+        if (applicationVersion !== "unused") {
+            applicationBuildNumber = raw.payload.readUInt16BE(21);
+        }
+        else {
+            applicationBuildNumber = 0;
+        }
+        return new VersionCCZWaveSoftwareReport_1({
+            nodeId: ctx.sourceNodeId,
+            sdkVersion,
+            applicationFrameworkAPIVersion,
+            applicationFrameworkBuildNumber,
+            hostInterfaceVersion,
+            hostInterfaceBuildNumber,
+            zWaveProtocolVersion,
+            zWaveProtocolBuildNumber,
+            applicationVersion,
+            applicationBuildNumber,
+        });
+    }
+    sdkVersion;
+    applicationFrameworkAPIVersion;
+    applicationFrameworkBuildNumber;
+    hostInterfaceVersion;
+    hostInterfaceBuildNumber;
+    zWaveProtocolVersion;
+    zWaveProtocolBuildNumber;
+    applicationVersion;
+    applicationBuildNumber;
+    toLogEntry(ctx) {
+        const message = {
+            "SDK version": this.sdkVersion,
+        };
+        message["appl. framework API version"] =
+            this.applicationFrameworkAPIVersion;
+        if (this.applicationFrameworkAPIVersion !== "unused") {
+            message["appl. framework build number"] =
+                this.applicationFrameworkBuildNumber;
+        }
+        message["host interface version"] = this.hostInterfaceVersion;
+        if (this.hostInterfaceVersion !== "unused") {
+            message["host interface  build number"] =
+                this.hostInterfaceBuildNumber;
+        }
+        message["Z-Wave protocol version"] = this.zWaveProtocolVersion;
+        if (this.zWaveProtocolVersion !== "unused") {
+            message["Z-Wave protocol build number"] =
+                this.zWaveProtocolBuildNumber;
+        }
+        message["application version"] = this.applicationVersion;
+        if (this.applicationVersion !== "unused") {
+            message["application build number"] = this.applicationBuildNumber;
+        }
+        return {
+            ...super.toLogEntry(ctx),
+            message,
+        };
+    }
+};
+__decorate([
+    ccValue(VersionCCValues.sdkVersion)
+], VersionCCZWaveSoftwareReport.prototype, "sdkVersion", void 0);
+__decorate([
+    ccValue(VersionCCValues.applicationFrameworkAPIVersion)
+], VersionCCZWaveSoftwareReport.prototype, "applicationFrameworkAPIVersion", void 0);
+__decorate([
+    ccValue(VersionCCValues.applicationFrameworkBuildNumber)
+], VersionCCZWaveSoftwareReport.prototype, "applicationFrameworkBuildNumber", void 0);
+__decorate([
+    ccValue(VersionCCValues.serialAPIVersion)
+], VersionCCZWaveSoftwareReport.prototype, "hostInterfaceVersion", void 0);
+__decorate([
+    ccValue(VersionCCValues.serialAPIBuildNumber)
+], VersionCCZWaveSoftwareReport.prototype, "hostInterfaceBuildNumber", void 0);
+__decorate([
+    ccValue(VersionCCValues.zWaveProtocolVersion)
+], VersionCCZWaveSoftwareReport.prototype, "zWaveProtocolVersion", void 0);
+__decorate([
+    ccValue(VersionCCValues.zWaveProtocolBuildNumber)
+], VersionCCZWaveSoftwareReport.prototype, "zWaveProtocolBuildNumber", void 0);
+__decorate([
+    ccValue(VersionCCValues.applicationVersion)
+], VersionCCZWaveSoftwareReport.prototype, "applicationVersion", void 0);
+__decorate([
+    ccValue(VersionCCValues.applicationBuildNumber)
+], VersionCCZWaveSoftwareReport.prototype, "applicationBuildNumber", void 0);
+VersionCCZWaveSoftwareReport = VersionCCZWaveSoftwareReport_1 = __decorate([
+    CCCommand(VersionCommand.ZWaveSoftwareReport)
+], VersionCCZWaveSoftwareReport);
+export { VersionCCZWaveSoftwareReport };
+let VersionCCZWaveSoftwareGet = class VersionCCZWaveSoftwareGet extends VersionCC {
+};
+VersionCCZWaveSoftwareGet = __decorate([
+    CCCommand(VersionCommand.ZWaveSoftwareGet),
+    expectedCCResponse(VersionCCZWaveSoftwareReport)
+], VersionCCZWaveSoftwareGet);
+export { VersionCCZWaveSoftwareGet };
+//# sourceMappingURL=VersionCC.js.map