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

package/build/esm/cc/ZWaveProtocolCC.js

@@ -0,0 +1,1030 @@
+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 ZWaveProtocolCCNodeInformationFrame_1, ZWaveProtocolCCAssignIDs_1, ZWaveProtocolCCFindNodesInRange_1, ZWaveProtocolCCRangeInfo_1, ZWaveProtocolCCCommandComplete_1, ZWaveProtocolCCTransferPresentation_1, ZWaveProtocolCCTransferNodeInformation_1, ZWaveProtocolCCTransferRangeInformation_1, ZWaveProtocolCCTransferEnd_1, ZWaveProtocolCCAssignReturnRoute_1, ZWaveProtocolCCNewNodeRegistered_1, ZWaveProtocolCCNewRangeRegistered_1, ZWaveProtocolCCTransferNewPrimaryControllerComplete_1, ZWaveProtocolCCSUCNodeID_1, ZWaveProtocolCCSetSUC_1, ZWaveProtocolCCSetSUCAck_1, ZWaveProtocolCCStaticRouteRequest_1, ZWaveProtocolCCLost_1, ZWaveProtocolCCAcceptLost_1, ZWaveProtocolCCNOPPower_1, ZWaveProtocolCCReservedIDs_1, ZWaveProtocolCCReserveNodeIDs_1, ZWaveProtocolCCNodesExistReply_1, ZWaveProtocolCCNodesExist_1, ZWaveProtocolCCSetNWIMode_1, ZWaveProtocolCCAssignReturnRoutePriority_1, ZWaveProtocolCCSmartStartIncludedNodeInformation_1;
+import { CommandClasses, MAX_NODES, MAX_REPEATERS, ZWaveDataRate, ZWaveError, ZWaveErrorCodes, encodeBitMask, encodeNodeInformationFrame, encodeNodeProtocolInfoAndDeviceClass, parseBitMask, parseNodeInformationFrame, parseNodeProtocolInfoAndDeviceClass, validatePayload, } from "@zwave-js/core";
+import { Bytes } from "@zwave-js/shared/safe";
+import { CommandClass } from "../lib/CommandClass.js";
+import { CCCommand, commandClass, expectedCCResponse, implementedVersion, } from "../lib/CommandClassDecorators.js";
+import { WakeUpTime, ZWaveProtocolCommand, parseWakeUpTime, } from "../lib/_Types.js";
+var DataRateBitmask;
+(function (DataRateBitmask) {
+    DataRateBitmask[DataRateBitmask["9k6"] = 1] = "9k6";
+    DataRateBitmask[DataRateBitmask["40k"] = 2] = "40k";
+    DataRateBitmask[DataRateBitmask["100k"] = 4] = "100k";
+})(DataRateBitmask || (DataRateBitmask = {}));
+function dataRate2Bitmask(dataRate) {
+    return dataRate === ZWaveDataRate["100k"]
+        ? DataRateBitmask["100k"]
+        : dataRate === ZWaveDataRate["40k"]
+            ? DataRateBitmask["40k"]
+            : DataRateBitmask["9k6"];
+}
+function bitmask2DataRate(mask) {
+    return mask === DataRateBitmask["100k"]
+        ? ZWaveDataRate["100k"]
+        : mask === DataRateBitmask["40k"]
+            ? ZWaveDataRate["40k"]
+            : ZWaveDataRate["9k6"];
+}
+let ZWaveProtocolCC = class ZWaveProtocolCC extends CommandClass {
+};
+ZWaveProtocolCC = __decorate([
+    commandClass(CommandClasses["Z-Wave Protocol"]),
+    implementedVersion(1)
+], ZWaveProtocolCC);
+export { ZWaveProtocolCC };
+let ZWaveProtocolCCNodeInformationFrame = ZWaveProtocolCCNodeInformationFrame_1 = class ZWaveProtocolCCNodeInformationFrame extends ZWaveProtocolCC {
+    constructor(options) {
+        super(options);
+        this.basicDeviceClass = options.basicDeviceClass;
+        this.genericDeviceClass = options.genericDeviceClass;
+        this.specificDeviceClass = options.specificDeviceClass;
+        this.isListening = options.isListening;
+        this.isFrequentListening = options.isFrequentListening;
+        this.isRouting = options.isRouting;
+        this.supportedDataRates = options.supportedDataRates;
+        this.protocolVersion = options.protocolVersion;
+        this.optionalFunctionality = options.optionalFunctionality;
+        this.nodeType = options.nodeType;
+        this.supportsSecurity = options.supportsSecurity;
+        this.supportsBeaming = options.supportsBeaming;
+        this.supportedCCs = options.supportedCCs;
+    }
+    static from(raw, ctx) {
+        const nif = parseNodeInformationFrame(raw.payload);
+        return new ZWaveProtocolCCNodeInformationFrame_1({
+            nodeId: ctx.sourceNodeId,
+            ...nif,
+        });
+    }
+    basicDeviceClass;
+    genericDeviceClass;
+    specificDeviceClass;
+    isListening;
+    isFrequentListening;
+    isRouting;
+    supportedDataRates;
+    protocolVersion;
+    optionalFunctionality;
+    nodeType;
+    supportsSecurity;
+    supportsBeaming;
+    supportedCCs;
+    serialize(ctx) {
+        this.payload = encodeNodeInformationFrame(this);
+        return super.serialize(ctx);
+    }
+};
+ZWaveProtocolCCNodeInformationFrame = ZWaveProtocolCCNodeInformationFrame_1 = __decorate([
+    CCCommand(ZWaveProtocolCommand.NodeInformationFrame)
+], ZWaveProtocolCCNodeInformationFrame);
+export { ZWaveProtocolCCNodeInformationFrame };
+let ZWaveProtocolCCRequestNodeInformationFrame = class ZWaveProtocolCCRequestNodeInformationFrame extends ZWaveProtocolCC {
+};
+ZWaveProtocolCCRequestNodeInformationFrame = __decorate([
+    CCCommand(ZWaveProtocolCommand.RequestNodeInformationFrame),
+    expectedCCResponse(ZWaveProtocolCCNodeInformationFrame)
+], ZWaveProtocolCCRequestNodeInformationFrame);
+export { ZWaveProtocolCCRequestNodeInformationFrame };
+let ZWaveProtocolCCAssignIDs = ZWaveProtocolCCAssignIDs_1 = class ZWaveProtocolCCAssignIDs extends ZWaveProtocolCC {
+    constructor(options) {
+        super(options);
+        this.assignedNodeId = options.assignedNodeId;
+        this.homeId = options.homeId;
+    }
+    static from(raw, ctx) {
+        validatePayload(raw.payload.length >= 5);
+        const assignedNodeId = raw.payload[0];
+        const homeId = raw.payload.readUInt32BE(1);
+        return new ZWaveProtocolCCAssignIDs_1({
+            nodeId: ctx.sourceNodeId,
+            assignedNodeId,
+            homeId,
+        });
+    }
+    assignedNodeId;
+    homeId;
+    serialize(ctx) {
+        this.payload = new Bytes(5);
+        this.payload[0] = this.assignedNodeId;
+        this.payload.writeUInt32BE(this.homeId, 1);
+        return super.serialize(ctx);
+    }
+};
+ZWaveProtocolCCAssignIDs = ZWaveProtocolCCAssignIDs_1 = __decorate([
+    CCCommand(ZWaveProtocolCommand.AssignIDs)
+], ZWaveProtocolCCAssignIDs);
+export { ZWaveProtocolCCAssignIDs };
+let ZWaveProtocolCCFindNodesInRange = ZWaveProtocolCCFindNodesInRange_1 = class ZWaveProtocolCCFindNodesInRange extends ZWaveProtocolCC {
+    constructor(options) {
+        super(options);
+        this.candidateNodeIds = options.candidateNodeIds;
+        this.wakeUpTime = options.wakeUpTime;
+        this.dataRate = options.dataRate ?? ZWaveDataRate["9k6"];
+    }
+    static from(raw, ctx) {
+        validatePayload(raw.payload.length >= 1);
+        const speedPresent = raw.payload[0] & 0b1000_0000;
+        const bitmaskLength = raw.payload[0] & 0b0001_1111;
+        validatePayload(raw.payload.length >= 1 + bitmaskLength);
+        const candidateNodeIds = parseBitMask(raw.payload.subarray(1, 1 + bitmaskLength));
+        const rest = raw.payload.subarray(1 + bitmaskLength);
+        let dataRate;
+        let wakeUpTime;
+        if (speedPresent) {
+            validatePayload(rest.length >= 1);
+            if (rest.length === 1) {
+                dataRate = rest[0] & 0b111;
+                wakeUpTime = WakeUpTime.None;
+            }
+            else if (rest.length === 2) {
+                wakeUpTime = parseWakeUpTime(rest[0]);
+                dataRate = rest[1] & 0b111;
+            }
+            else {
+                validatePayload.fail("Invalid payload length");
+            }
+        }
+        else if (rest.length >= 1) {
+            wakeUpTime = parseWakeUpTime(rest[0]);
+            dataRate = ZWaveDataRate["9k6"];
+        }
+        else {
+            wakeUpTime = WakeUpTime.None;
+            dataRate = ZWaveDataRate["9k6"];
+        }
+        return new ZWaveProtocolCCFindNodesInRange_1({
+            nodeId: ctx.sourceNodeId,
+            candidateNodeIds,
+            dataRate,
+            wakeUpTime,
+        });
+    }
+    candidateNodeIds;
+    wakeUpTime;
+    dataRate;
+    serialize(ctx) {
+        const nodesBitmask = encodeBitMask(this.candidateNodeIds, MAX_NODES);
+        const speedAndLength = 0b1000_0000 | nodesBitmask.length;
+        this.payload = Bytes.concat([
+            Bytes.from([speedAndLength]),
+            nodesBitmask,
+            Bytes.from([this.wakeUpTime, this.dataRate]),
+        ]);
+        return super.serialize(ctx);
+    }
+};
+ZWaveProtocolCCFindNodesInRange = ZWaveProtocolCCFindNodesInRange_1 = __decorate([
+    CCCommand(ZWaveProtocolCommand.FindNodesInRange)
+], ZWaveProtocolCCFindNodesInRange);
+export { ZWaveProtocolCCFindNodesInRange };
+let ZWaveProtocolCCRangeInfo = ZWaveProtocolCCRangeInfo_1 = class ZWaveProtocolCCRangeInfo extends ZWaveProtocolCC {
+    constructor(options) {
+        super(options);
+        this.neighborNodeIds = options.neighborNodeIds;
+        this.wakeUpTime = options.wakeUpTime;
+    }
+    static from(raw, ctx) {
+        validatePayload(raw.payload.length >= 1);
+        const bitmaskLength = raw.payload[0] & 0b0001_1111;
+        validatePayload(raw.payload.length >= 1 + bitmaskLength);
+        const neighborNodeIds = parseBitMask(raw.payload.subarray(1, 1 + bitmaskLength));
+        let wakeUpTime;
+        if (raw.payload.length >= 2 + bitmaskLength) {
+            wakeUpTime = parseWakeUpTime(raw.payload[1 + bitmaskLength]);
+        }
+        return new ZWaveProtocolCCRangeInfo_1({
+            nodeId: ctx.sourceNodeId,
+            neighborNodeIds,
+            wakeUpTime,
+        });
+    }
+    neighborNodeIds;
+    wakeUpTime;
+    serialize(ctx) {
+        const nodesBitmask = encodeBitMask(this.neighborNodeIds, MAX_NODES);
+        this.payload = Bytes.concat([
+            Bytes.from([nodesBitmask.length]),
+            nodesBitmask,
+            this.wakeUpTime != undefined
+                ? Bytes.from([this.wakeUpTime])
+                : new Bytes(),
+        ]);
+        return super.serialize(ctx);
+    }
+};
+ZWaveProtocolCCRangeInfo = ZWaveProtocolCCRangeInfo_1 = __decorate([
+    CCCommand(ZWaveProtocolCommand.RangeInfo)
+], ZWaveProtocolCCRangeInfo);
+export { ZWaveProtocolCCRangeInfo };
+let ZWaveProtocolCCGetNodesInRange = class ZWaveProtocolCCGetNodesInRange extends ZWaveProtocolCC {
+};
+ZWaveProtocolCCGetNodesInRange = __decorate([
+    CCCommand(ZWaveProtocolCommand.GetNodesInRange),
+    expectedCCResponse(ZWaveProtocolCCRangeInfo)
+], ZWaveProtocolCCGetNodesInRange);
+export { ZWaveProtocolCCGetNodesInRange };
+let ZWaveProtocolCCCommandComplete = ZWaveProtocolCCCommandComplete_1 = class ZWaveProtocolCCCommandComplete extends ZWaveProtocolCC {
+    constructor(options) {
+        super(options);
+        this.sequenceNumber = options.sequenceNumber;
+    }
+    static from(raw, ctx) {
+        validatePayload(raw.payload.length >= 1);
+        const sequenceNumber = raw.payload[0];
+        return new ZWaveProtocolCCCommandComplete_1({
+            nodeId: ctx.sourceNodeId,
+            sequenceNumber,
+        });
+    }
+    sequenceNumber;
+    serialize(ctx) {
+        this.payload = Bytes.from([this.sequenceNumber]);
+        return super.serialize(ctx);
+    }
+};
+ZWaveProtocolCCCommandComplete = ZWaveProtocolCCCommandComplete_1 = __decorate([
+    CCCommand(ZWaveProtocolCommand.CommandComplete)
+], ZWaveProtocolCCCommandComplete);
+export { ZWaveProtocolCCCommandComplete };
+let ZWaveProtocolCCTransferPresentation = ZWaveProtocolCCTransferPresentation_1 = class ZWaveProtocolCCTransferPresentation extends ZWaveProtocolCC {
+    constructor(options) {
+        super(options);
+        if (options.includeNode && options.excludeNode) {
+            throw new ZWaveError(`${this.constructor.name}: the includeNode and excludeNode options cannot both be true`, ZWaveErrorCodes.Argument_Invalid);
+        }
+        this.supportsNWI = options.supportsNWI;
+        this.includeNode = options.includeNode;
+        this.excludeNode = options.excludeNode;
+    }
+    static from(raw, ctx) {
+        validatePayload(raw.payload.length >= 1);
+        const option = raw.payload[0];
+        const supportsNWI = !!(option & 0b0001);
+        const excludeNode = !!(option & 0b0010);
+        const includeNode = !!(option & 0b0100);
+        return new ZWaveProtocolCCTransferPresentation_1({
+            nodeId: ctx.sourceNodeId,
+            supportsNWI,
+            excludeNode,
+            includeNode,
+        });
+    }
+    supportsNWI;
+    includeNode;
+    excludeNode;
+    serialize(ctx) {
+        this.payload = Bytes.from([
+            (this.supportsNWI ? 0b0001 : 0)
+                | (this.excludeNode ? 0b0010 : 0)
+                | (this.includeNode ? 0b0100 : 0),
+        ]);
+        return super.serialize(ctx);
+    }
+};
+ZWaveProtocolCCTransferPresentation = ZWaveProtocolCCTransferPresentation_1 = __decorate([
+    CCCommand(ZWaveProtocolCommand.TransferPresentation)
+], ZWaveProtocolCCTransferPresentation);
+export { ZWaveProtocolCCTransferPresentation };
+let ZWaveProtocolCCTransferNodeInformation = ZWaveProtocolCCTransferNodeInformation_1 = class ZWaveProtocolCCTransferNodeInformation extends ZWaveProtocolCC {
+    constructor(options) {
+        super(options);
+        this.sequenceNumber = options.sequenceNumber;
+        this.sourceNodeId = options.sourceNodeId;
+        this.basicDeviceClass = options.basicDeviceClass;
+        this.genericDeviceClass = options.genericDeviceClass;
+        this.specificDeviceClass = options.specificDeviceClass;
+        this.isListening = options.isListening;
+        this.isFrequentListening = options.isFrequentListening;
+        this.isRouting = options.isRouting;
+        this.supportedDataRates = options.supportedDataRates;
+        this.protocolVersion = options.protocolVersion;
+        this.optionalFunctionality = options.optionalFunctionality;
+        this.nodeType = options.nodeType;
+        this.supportsSecurity = options.supportsSecurity;
+        this.supportsBeaming = options.supportsBeaming;
+    }
+    static from(raw, ctx) {
+        validatePayload(raw.payload.length >= 2);
+        const sequenceNumber = raw.payload[0];
+        const sourceNodeId = raw.payload[1];
+        const { info } = parseNodeProtocolInfoAndDeviceClass(raw.payload.subarray(2));
+        return new ZWaveProtocolCCTransferNodeInformation_1({
+            nodeId: ctx.sourceNodeId,
+            sequenceNumber,
+            sourceNodeId,
+            ...info,
+        });
+    }
+    sequenceNumber;
+    sourceNodeId;
+    basicDeviceClass;
+    genericDeviceClass;
+    specificDeviceClass;
+    isListening;
+    isFrequentListening;
+    isRouting;
+    supportedDataRates;
+    protocolVersion;
+    optionalFunctionality;
+    nodeType;
+    supportsSecurity;
+    supportsBeaming;
+    serialize(ctx) {
+        this.payload = Bytes.concat([
+            Bytes.from([this.sequenceNumber, this.sourceNodeId]),
+            encodeNodeProtocolInfoAndDeviceClass(this),
+        ]);
+        return super.serialize(ctx);
+    }
+};
+ZWaveProtocolCCTransferNodeInformation = ZWaveProtocolCCTransferNodeInformation_1 = __decorate([
+    CCCommand(ZWaveProtocolCommand.TransferNodeInformation)
+], ZWaveProtocolCCTransferNodeInformation);
+export { ZWaveProtocolCCTransferNodeInformation };
+let ZWaveProtocolCCTransferRangeInformation = ZWaveProtocolCCTransferRangeInformation_1 = class ZWaveProtocolCCTransferRangeInformation extends ZWaveProtocolCC {
+    constructor(options) {
+        super(options);
+        this.sequenceNumber = options.sequenceNumber;
+        this.testedNodeId = options.testedNodeId;
+        this.neighborNodeIds = options.neighborNodeIds;
+    }
+    static from(raw, ctx) {
+        validatePayload(raw.payload.length >= 3);
+        const sequenceNumber = raw.payload[0];
+        const testedNodeId = raw.payload[1];
+        const bitmaskLength = raw.payload[2];
+        validatePayload(raw.payload.length >= 3 + bitmaskLength);
+        const neighborNodeIds = parseBitMask(raw.payload.subarray(3, 3 + bitmaskLength));
+        return new ZWaveProtocolCCTransferRangeInformation_1({
+            nodeId: ctx.sourceNodeId,
+            sequenceNumber,
+            testedNodeId,
+            neighborNodeIds,
+        });
+    }
+    sequenceNumber;
+    testedNodeId;
+    neighborNodeIds;
+    serialize(ctx) {
+        const nodesBitmask = encodeBitMask(this.neighborNodeIds, MAX_NODES);
+        this.payload = Bytes.concat([
+            Bytes.from([
+                this.sequenceNumber,
+                this.testedNodeId,
+                nodesBitmask.length,
+            ]),
+            nodesBitmask,
+        ]);
+        return super.serialize(ctx);
+    }
+};
+ZWaveProtocolCCTransferRangeInformation = ZWaveProtocolCCTransferRangeInformation_1 = __decorate([
+    CCCommand(ZWaveProtocolCommand.TransferRangeInformation)
+], ZWaveProtocolCCTransferRangeInformation);
+export { ZWaveProtocolCCTransferRangeInformation };
+let ZWaveProtocolCCTransferEnd = ZWaveProtocolCCTransferEnd_1 = class ZWaveProtocolCCTransferEnd extends ZWaveProtocolCC {
+    constructor(options) {
+        super(options);
+        this.status = options.status;
+    }
+    static from(raw, ctx) {
+        validatePayload(raw.payload.length >= 1);
+        const status = raw.payload[0];
+        return new ZWaveProtocolCCTransferEnd_1({
+            nodeId: ctx.sourceNodeId,
+            status,
+        });
+    }
+    status;
+    serialize(ctx) {
+        this.payload = Bytes.from([this.status]);
+        return super.serialize(ctx);
+    }
+};
+ZWaveProtocolCCTransferEnd = ZWaveProtocolCCTransferEnd_1 = __decorate([
+    CCCommand(ZWaveProtocolCommand.TransferEnd)
+], ZWaveProtocolCCTransferEnd);
+export { ZWaveProtocolCCTransferEnd };
+let ZWaveProtocolCCAssignReturnRoute = ZWaveProtocolCCAssignReturnRoute_1 = class ZWaveProtocolCCAssignReturnRoute extends ZWaveProtocolCC {
+    constructor(options) {
+        super(options);
+        if (options.repeaters.length > MAX_REPEATERS) {
+            throw new ZWaveError(`${this.constructor.name}: too many repeaters`, ZWaveErrorCodes.Argument_Invalid);
+        }
+        this.destinationNodeId = options.destinationNodeId;
+        this.routeIndex = options.routeIndex;
+        this.repeaters = options.repeaters;
+        this.destinationWakeUp = options.destinationWakeUp;
+        this.destinationSpeed = options.destinationSpeed;
+    }
+    static from(raw, ctx) {
+        validatePayload(raw.payload.length >= 7);
+        const destinationNodeId = raw.payload[0];
+        const routeIndex = raw.payload[1] >>> 4;
+        const numRepeaters = raw.payload[1] & 0b1111;
+        const repeaters = [...raw.payload.subarray(2, 2 + numRepeaters)];
+        const speedAndWakeup = raw.payload[2 + numRepeaters];
+        const destinationSpeed = bitmask2DataRate((speedAndWakeup >>> 3) & 0b111);
+        const destinationWakeUp = (speedAndWakeup >>> 1) & 0b11;
+        return new ZWaveProtocolCCAssignReturnRoute_1({
+            nodeId: ctx.sourceNodeId,
+            destinationNodeId,
+            routeIndex,
+            repeaters,
+            destinationSpeed,
+            destinationWakeUp,
+        });
+    }
+    destinationNodeId;
+    routeIndex;
+    repeaters;
+    destinationWakeUp;
+    destinationSpeed;
+    serialize(ctx) {
+        const routeByte = (this.routeIndex << 4) | this.repeaters.length;
+        const speedMask = dataRate2Bitmask(this.destinationSpeed);
+        const speedByte = (speedMask << 3) | (this.destinationWakeUp << 1);
+        this.payload = Bytes.from([
+            this.destinationNodeId,
+            routeByte,
+            ...this.repeaters,
+            speedByte,
+        ]);
+        return super.serialize(ctx);
+    }
+};
+ZWaveProtocolCCAssignReturnRoute = ZWaveProtocolCCAssignReturnRoute_1 = __decorate([
+    CCCommand(ZWaveProtocolCommand.AssignReturnRoute)
+], ZWaveProtocolCCAssignReturnRoute);
+export { ZWaveProtocolCCAssignReturnRoute };
+let ZWaveProtocolCCNewNodeRegistered = ZWaveProtocolCCNewNodeRegistered_1 = class ZWaveProtocolCCNewNodeRegistered extends ZWaveProtocolCC {
+    constructor(options) {
+        super(options);
+        this.newNodeId = options.newNodeId;
+        this.basicDeviceClass = options.basicDeviceClass;
+        this.genericDeviceClass = options.genericDeviceClass;
+        this.specificDeviceClass = options.specificDeviceClass;
+        this.isListening = options.isListening;
+        this.isFrequentListening = options.isFrequentListening;
+        this.isRouting = options.isRouting;
+        this.supportedDataRates = options.supportedDataRates;
+        this.protocolVersion = options.protocolVersion;
+        this.optionalFunctionality = options.optionalFunctionality;
+        this.nodeType = options.nodeType;
+        this.supportsSecurity = options.supportsSecurity;
+        this.supportsBeaming = options.supportsBeaming;
+        this.supportedCCs = options.supportedCCs;
+    }
+    static from(raw, ctx) {
+        validatePayload(raw.payload.length >= 1);
+        const newNodeId = raw.payload[0];
+        const nif = parseNodeInformationFrame(raw.payload.subarray(1));
+        return new ZWaveProtocolCCNewNodeRegistered_1({
+            nodeId: ctx.sourceNodeId,
+            newNodeId,
+            ...nif,
+        });
+    }
+    newNodeId;
+    basicDeviceClass;
+    genericDeviceClass;
+    specificDeviceClass;
+    isListening;
+    isFrequentListening;
+    isRouting;
+    supportedDataRates;
+    protocolVersion;
+    optionalFunctionality;
+    nodeType;
+    supportsSecurity;
+    supportsBeaming;
+    supportedCCs;
+    serialize(ctx) {
+        this.payload = Bytes.concat([
+            Bytes.from([this.newNodeId]),
+            encodeNodeInformationFrame(this),
+        ]);
+        return super.serialize(ctx);
+    }
+};
+ZWaveProtocolCCNewNodeRegistered = ZWaveProtocolCCNewNodeRegistered_1 = __decorate([
+    CCCommand(ZWaveProtocolCommand.NewNodeRegistered)
+], ZWaveProtocolCCNewNodeRegistered);
+export { ZWaveProtocolCCNewNodeRegistered };
+let ZWaveProtocolCCNewRangeRegistered = ZWaveProtocolCCNewRangeRegistered_1 = class ZWaveProtocolCCNewRangeRegistered extends ZWaveProtocolCC {
+    constructor(options) {
+        super(options);
+        this.testedNodeId = options.testedNodeId;
+        this.neighborNodeIds = options.neighborNodeIds;
+    }
+    static from(raw, ctx) {
+        validatePayload(raw.payload.length >= 2);
+        const testedNodeId = raw.payload[0];
+        const numNeighbors = raw.payload[1];
+        const neighborNodeIds = [
+            ...raw.payload.subarray(2, 2 + numNeighbors),
+        ];
+        return new ZWaveProtocolCCNewRangeRegistered_1({
+            nodeId: ctx.sourceNodeId,
+            testedNodeId,
+            neighborNodeIds,
+        });
+    }
+    testedNodeId;
+    neighborNodeIds;
+    serialize(ctx) {
+        const nodesBitmask = encodeBitMask(this.neighborNodeIds, MAX_NODES);
+        this.payload = Bytes.concat([
+            Bytes.from([this.testedNodeId, nodesBitmask.length]),
+            nodesBitmask,
+        ]);
+        return super.serialize(ctx);
+    }
+};
+ZWaveProtocolCCNewRangeRegistered = ZWaveProtocolCCNewRangeRegistered_1 = __decorate([
+    CCCommand(ZWaveProtocolCommand.NewRangeRegistered)
+], ZWaveProtocolCCNewRangeRegistered);
+export { ZWaveProtocolCCNewRangeRegistered };
+let ZWaveProtocolCCTransferNewPrimaryControllerComplete = ZWaveProtocolCCTransferNewPrimaryControllerComplete_1 = class ZWaveProtocolCCTransferNewPrimaryControllerComplete extends ZWaveProtocolCC {
+    constructor(options) {
+        super(options);
+        this.genericDeviceClass = options.genericDeviceClass;
+    }
+    static from(raw, ctx) {
+        validatePayload(raw.payload.length >= 1);
+        const genericDeviceClass = raw.payload[0];
+        return new ZWaveProtocolCCTransferNewPrimaryControllerComplete_1({
+            nodeId: ctx.sourceNodeId,
+            genericDeviceClass,
+        });
+    }
+    genericDeviceClass;
+    serialize(ctx) {
+        this.payload = Bytes.from([this.genericDeviceClass]);
+        return super.serialize(ctx);
+    }
+};
+ZWaveProtocolCCTransferNewPrimaryControllerComplete = ZWaveProtocolCCTransferNewPrimaryControllerComplete_1 = __decorate([
+    CCCommand(ZWaveProtocolCommand.TransferNewPrimaryControllerComplete)
+], ZWaveProtocolCCTransferNewPrimaryControllerComplete);
+export { ZWaveProtocolCCTransferNewPrimaryControllerComplete };
+let ZWaveProtocolCCAutomaticControllerUpdateStart = class ZWaveProtocolCCAutomaticControllerUpdateStart extends ZWaveProtocolCC {
+};
+ZWaveProtocolCCAutomaticControllerUpdateStart = __decorate([
+    CCCommand(ZWaveProtocolCommand.AutomaticControllerUpdateStart)
+], ZWaveProtocolCCAutomaticControllerUpdateStart);
+export { ZWaveProtocolCCAutomaticControllerUpdateStart };
+let ZWaveProtocolCCSUCNodeID = ZWaveProtocolCCSUCNodeID_1 = class ZWaveProtocolCCSUCNodeID extends ZWaveProtocolCC {
+    constructor(options) {
+        super(options);
+        this.sucNodeId = options.sucNodeId;
+        this.isSIS = options.isSIS;
+    }
+    static from(raw, ctx) {
+        validatePayload(raw.payload.length >= 1);
+        const sucNodeId = raw.payload[0];
+        const capabilities = raw.payload[1] ?? 0;
+        const isSIS = !!(capabilities & 0b1);
+        return new ZWaveProtocolCCSUCNodeID_1({
+            nodeId: ctx.sourceNodeId,
+            sucNodeId,
+            isSIS,
+        });
+    }
+    sucNodeId;
+    isSIS;
+    serialize(ctx) {
+        this.payload = Bytes.from([this.sucNodeId, this.isSIS ? 0b1 : 0]);
+        return super.serialize(ctx);
+    }
+};
+ZWaveProtocolCCSUCNodeID = ZWaveProtocolCCSUCNodeID_1 = __decorate([
+    CCCommand(ZWaveProtocolCommand.SUCNodeID)
+], ZWaveProtocolCCSUCNodeID);
+export { ZWaveProtocolCCSUCNodeID };
+let ZWaveProtocolCCSetSUC = ZWaveProtocolCCSetSUC_1 = class ZWaveProtocolCCSetSUC extends ZWaveProtocolCC {
+    constructor(options) {
+        super(options);
+        this.enableSIS = options.enableSIS;
+    }
+    static from(raw, ctx) {
+        validatePayload(raw.payload.length >= 2);
+        // Byte 0 must be 0x01 or ignored
+        const capabilities = raw.payload[1] ?? 0;
+        const enableSIS = !!(capabilities & 0b1);
+        return new ZWaveProtocolCCSetSUC_1({
+            nodeId: ctx.sourceNodeId,
+            enableSIS,
+        });
+    }
+    enableSIS;
+    serialize(ctx) {
+        this.payload = Bytes.from([0x01, this.enableSIS ? 0b1 : 0]);
+        return super.serialize(ctx);
+    }
+};
+ZWaveProtocolCCSetSUC = ZWaveProtocolCCSetSUC_1 = __decorate([
+    CCCommand(ZWaveProtocolCommand.SetSUC)
+], ZWaveProtocolCCSetSUC);
+export { ZWaveProtocolCCSetSUC };
+let ZWaveProtocolCCSetSUCAck = ZWaveProtocolCCSetSUCAck_1 = class ZWaveProtocolCCSetSUCAck extends ZWaveProtocolCC {
+    constructor(options) {
+        super(options);
+        this.accepted = options.accepted;
+        this.isSIS = options.isSIS;
+    }
+    static from(raw, ctx) {
+        validatePayload(raw.payload.length >= 2);
+        const accepted = raw.payload[0] === 0x01;
+        const capabilities = raw.payload[1] ?? 0;
+        const isSIS = !!(capabilities & 0b1);
+        return new ZWaveProtocolCCSetSUCAck_1({
+            nodeId: ctx.sourceNodeId,
+            accepted,
+            isSIS,
+        });
+    }
+    accepted;
+    isSIS;
+    serialize(ctx) {
+        this.payload = Bytes.from([
+            this.accepted ? 0x01 : 0x00,
+            this.isSIS ? 0b1 : 0,
+        ]);
+        return super.serialize(ctx);
+    }
+};
+ZWaveProtocolCCSetSUCAck = ZWaveProtocolCCSetSUCAck_1 = __decorate([
+    CCCommand(ZWaveProtocolCommand.SetSUCAck)
+], ZWaveProtocolCCSetSUCAck);
+export { ZWaveProtocolCCSetSUCAck };
+let ZWaveProtocolCCAssignSUCReturnRoute = class ZWaveProtocolCCAssignSUCReturnRoute extends ZWaveProtocolCCAssignReturnRoute {
+};
+ZWaveProtocolCCAssignSUCReturnRoute = __decorate([
+    CCCommand(ZWaveProtocolCommand.AssignSUCReturnRoute)
+], ZWaveProtocolCCAssignSUCReturnRoute);
+export { ZWaveProtocolCCAssignSUCReturnRoute };
+let ZWaveProtocolCCStaticRouteRequest = ZWaveProtocolCCStaticRouteRequest_1 = class ZWaveProtocolCCStaticRouteRequest extends ZWaveProtocolCC {
+    constructor(options) {
+        super(options);
+        if (options.nodeIds.some((n) => n < 1 || n > MAX_NODES)) {
+            throw new ZWaveError(`All node IDs must be between 1 and ${MAX_NODES}!`, ZWaveErrorCodes.Argument_Invalid);
+        }
+        this.nodeIds = options.nodeIds;
+    }
+    static from(raw, ctx) {
+        validatePayload(raw.payload.length >= 5);
+        const nodeIds = [...raw.payload.subarray(0, 5)].filter((id) => id > 0 && id <= MAX_NODES);
+        return new ZWaveProtocolCCStaticRouteRequest_1({
+            nodeId: ctx.sourceNodeId,
+            nodeIds,
+        });
+    }
+    nodeIds;
+    serialize(ctx) {
+        this.payload = Bytes.alloc(5, 0);
+        for (let i = 0; i < this.nodeIds.length && i < 5; i++) {
+            this.payload[i] = this.nodeIds[i];
+        }
+        return super.serialize(ctx);
+    }
+};
+ZWaveProtocolCCStaticRouteRequest = ZWaveProtocolCCStaticRouteRequest_1 = __decorate([
+    CCCommand(ZWaveProtocolCommand.StaticRouteRequest)
+], ZWaveProtocolCCStaticRouteRequest);
+export { ZWaveProtocolCCStaticRouteRequest };
+let ZWaveProtocolCCLost = ZWaveProtocolCCLost_1 = class ZWaveProtocolCCLost extends ZWaveProtocolCC {
+    constructor(options) {
+        super(options);
+        this.lostNodeId = options.lostNodeId;
+    }
+    static from(raw, ctx) {
+        validatePayload(raw.payload.length >= 1);
+        const lostNodeId = raw.payload[0];
+        return new ZWaveProtocolCCLost_1({
+            nodeId: ctx.sourceNodeId,
+            lostNodeId,
+        });
+    }
+    lostNodeId;
+    serialize(ctx) {
+        this.payload = Bytes.from([this.lostNodeId]);
+        return super.serialize(ctx);
+    }
+};
+ZWaveProtocolCCLost = ZWaveProtocolCCLost_1 = __decorate([
+    CCCommand(ZWaveProtocolCommand.Lost)
+], ZWaveProtocolCCLost);
+export { ZWaveProtocolCCLost };
+let ZWaveProtocolCCAcceptLost = ZWaveProtocolCCAcceptLost_1 = class ZWaveProtocolCCAcceptLost extends ZWaveProtocolCC {
+    constructor(options) {
+        super(options);
+        this.accepted = options.accepted;
+    }
+    static from(raw, ctx) {
+        validatePayload(raw.payload.length >= 1);
+        validatePayload(raw.payload[0] === 0x04 || raw.payload[0] === 0x05);
+        const accepted = raw.payload[0] === 0x05;
+        return new ZWaveProtocolCCAcceptLost_1({
+            nodeId: ctx.sourceNodeId,
+            accepted,
+        });
+    }
+    accepted;
+    serialize(ctx) {
+        this.payload = Bytes.from([this.accepted ? 0x05 : 0x04]);
+        return super.serialize(ctx);
+    }
+};
+ZWaveProtocolCCAcceptLost = ZWaveProtocolCCAcceptLost_1 = __decorate([
+    CCCommand(ZWaveProtocolCommand.AcceptLost)
+], ZWaveProtocolCCAcceptLost);
+export { ZWaveProtocolCCAcceptLost };
+let ZWaveProtocolCCNOPPower = ZWaveProtocolCCNOPPower_1 = class ZWaveProtocolCCNOPPower extends ZWaveProtocolCC {
+    constructor(options) {
+        super(options);
+        if (options.powerDampening < 0 || options.powerDampening > 14) {
+            throw new ZWaveError(`${this.constructor.name}: power dampening must be between 0 and 14 dBm!`, ZWaveErrorCodes.Argument_Invalid);
+        }
+        this.powerDampening = options.powerDampening;
+    }
+    static from(raw, ctx) {
+        let powerDampening;
+        if (raw.payload.length >= 2) {
+            // Ignore byte 0
+            powerDampening = raw.payload[1];
+        }
+        else if (raw.payload.length === 1) {
+            powerDampening = [
+                0xf0,
+                0xc8,
+                0xa7,
+                0x91,
+                0x77,
+                0x67,
+                0x60,
+                0x46,
+                0x38,
+                0x35,
+                0x32,
+                0x30,
+                0x24,
+                0x22,
+                0x20,
+            ].indexOf(raw.payload[0]);
+            if (powerDampening === -1)
+                powerDampening = 0;
+        }
+        else {
+            validatePayload.fail("Invalid payload length!");
+        }
+        return new ZWaveProtocolCCNOPPower_1({
+            nodeId: ctx.sourceNodeId,
+            powerDampening,
+        });
+    }
+    // Power dampening in (negative) dBm. A value of 2 means -2 dBm.
+    powerDampening;
+    serialize(ctx) {
+        this.payload = Bytes.from([0, this.powerDampening]);
+        return super.serialize(ctx);
+    }
+};
+ZWaveProtocolCCNOPPower = ZWaveProtocolCCNOPPower_1 = __decorate([
+    CCCommand(ZWaveProtocolCommand.NOPPower)
+], ZWaveProtocolCCNOPPower);
+export { ZWaveProtocolCCNOPPower };
+let ZWaveProtocolCCReservedIDs = ZWaveProtocolCCReservedIDs_1 = class ZWaveProtocolCCReservedIDs extends ZWaveProtocolCC {
+    constructor(options) {
+        super(options);
+        this.reservedNodeIDs = options.reservedNodeIDs;
+    }
+    static from(raw, ctx) {
+        validatePayload(raw.payload.length >= 1);
+        const numNodeIDs = raw.payload[0];
+        validatePayload(raw.payload.length >= 1 + numNodeIDs);
+        const reservedNodeIDs = [
+            ...raw.payload.subarray(1, 1 + numNodeIDs),
+        ];
+        return new ZWaveProtocolCCReservedIDs_1({
+            nodeId: ctx.sourceNodeId,
+            reservedNodeIDs,
+        });
+    }
+    reservedNodeIDs;
+    serialize(ctx) {
+        this.payload = Bytes.from([
+            this.reservedNodeIDs.length,
+            ...this.reservedNodeIDs,
+        ]);
+        return super.serialize(ctx);
+    }
+};
+ZWaveProtocolCCReservedIDs = ZWaveProtocolCCReservedIDs_1 = __decorate([
+    CCCommand(ZWaveProtocolCommand.ReservedIDs)
+], ZWaveProtocolCCReservedIDs);
+export { ZWaveProtocolCCReservedIDs };
+let ZWaveProtocolCCReserveNodeIDs = ZWaveProtocolCCReserveNodeIDs_1 = class ZWaveProtocolCCReserveNodeIDs extends ZWaveProtocolCC {
+    constructor(options) {
+        super(options);
+        this.numNodeIDs = options.numNodeIDs;
+    }
+    static from(raw, ctx) {
+        validatePayload(raw.payload.length >= 1);
+        const numNodeIDs = raw.payload[0];
+        return new ZWaveProtocolCCReserveNodeIDs_1({
+            nodeId: ctx.sourceNodeId,
+            numNodeIDs,
+        });
+    }
+    numNodeIDs;
+    serialize(ctx) {
+        this.payload = Bytes.from([this.numNodeIDs]);
+        return super.serialize(ctx);
+    }
+};
+ZWaveProtocolCCReserveNodeIDs = ZWaveProtocolCCReserveNodeIDs_1 = __decorate([
+    CCCommand(ZWaveProtocolCommand.ReserveNodeIDs),
+    expectedCCResponse(ZWaveProtocolCCReservedIDs)
+], ZWaveProtocolCCReserveNodeIDs);
+export { ZWaveProtocolCCReserveNodeIDs };
+let ZWaveProtocolCCNodesExistReply = ZWaveProtocolCCNodesExistReply_1 = class ZWaveProtocolCCNodesExistReply extends ZWaveProtocolCC {
+    constructor(options) {
+        super(options);
+        this.nodeMaskType = options.nodeMaskType;
+        this.nodeListUpdated = options.nodeListUpdated;
+    }
+    static from(raw, ctx) {
+        validatePayload(raw.payload.length >= 2);
+        const nodeMaskType = raw.payload[0];
+        const nodeListUpdated = raw.payload[1] === 0x01;
+        return new ZWaveProtocolCCNodesExistReply_1({
+            nodeId: ctx.sourceNodeId,
+            nodeMaskType,
+            nodeListUpdated,
+        });
+    }
+    nodeMaskType;
+    nodeListUpdated;
+    serialize(ctx) {
+        this.payload = Bytes.from([
+            this.nodeMaskType,
+            this.nodeListUpdated ? 0x01 : 0x00,
+        ]);
+        return super.serialize(ctx);
+    }
+};
+ZWaveProtocolCCNodesExistReply = ZWaveProtocolCCNodesExistReply_1 = __decorate([
+    CCCommand(ZWaveProtocolCommand.NodesExistReply)
+], ZWaveProtocolCCNodesExistReply);
+export { ZWaveProtocolCCNodesExistReply };
+function testResponseForZWaveProtocolNodesExist(sent, received) {
+    return received.nodeMaskType === sent.nodeMaskType;
+}
+let ZWaveProtocolCCNodesExist = ZWaveProtocolCCNodesExist_1 = class ZWaveProtocolCCNodesExist extends ZWaveProtocolCC {
+    constructor(options) {
+        super(options);
+        this.nodeMaskType = options.nodeMaskType;
+        this.nodeIDs = options.nodeIDs;
+    }
+    static from(raw, ctx) {
+        validatePayload(raw.payload.length >= 2);
+        const nodeMaskType = raw.payload[0];
+        const numNodeIDs = raw.payload[1];
+        validatePayload(raw.payload.length >= 2 + numNodeIDs);
+        const nodeIDs = [...raw.payload.subarray(2, 2 + numNodeIDs)];
+        return new ZWaveProtocolCCNodesExist_1({
+            nodeId: ctx.sourceNodeId,
+            nodeMaskType,
+            nodeIDs,
+        });
+    }
+    nodeMaskType;
+    nodeIDs;
+    serialize(ctx) {
+        this.payload = Bytes.from([
+            this.nodeMaskType,
+            this.nodeIDs.length,
+            ...this.nodeIDs,
+        ]);
+        return super.serialize(ctx);
+    }
+};
+ZWaveProtocolCCNodesExist = ZWaveProtocolCCNodesExist_1 = __decorate([
+    CCCommand(ZWaveProtocolCommand.NodesExist),
+    expectedCCResponse(ZWaveProtocolCCNodesExistReply, testResponseForZWaveProtocolNodesExist)
+], ZWaveProtocolCCNodesExist);
+export { ZWaveProtocolCCNodesExist };
+let ZWaveProtocolCCSetNWIMode = ZWaveProtocolCCSetNWIMode_1 = class ZWaveProtocolCCSetNWIMode extends ZWaveProtocolCC {
+    constructor(options) {
+        super(options);
+        this.enabled = options.enabled;
+        this.timeoutMinutes = options.timeoutMinutes;
+    }
+    static from(raw, ctx) {
+        validatePayload(raw.payload.length >= 2);
+        const enabled = raw.payload[0] === 0x01;
+        const timeoutMinutes = raw.payload[1] || undefined;
+        return new ZWaveProtocolCCSetNWIMode_1({
+            nodeId: ctx.sourceNodeId,
+            enabled,
+            timeoutMinutes,
+        });
+    }
+    enabled;
+    timeoutMinutes;
+    serialize(ctx) {
+        this.payload = Bytes.from([
+            this.enabled ? 0x01 : 0x00,
+            this.timeoutMinutes ?? 0x00,
+        ]);
+        return super.serialize(ctx);
+    }
+};
+ZWaveProtocolCCSetNWIMode = ZWaveProtocolCCSetNWIMode_1 = __decorate([
+    CCCommand(ZWaveProtocolCommand.SetNWIMode)
+], ZWaveProtocolCCSetNWIMode);
+export { ZWaveProtocolCCSetNWIMode };
+let ZWaveProtocolCCExcludeRequest = class ZWaveProtocolCCExcludeRequest extends ZWaveProtocolCCNodeInformationFrame {
+};
+ZWaveProtocolCCExcludeRequest = __decorate([
+    CCCommand(ZWaveProtocolCommand.ExcludeRequest)
+], ZWaveProtocolCCExcludeRequest);
+export { ZWaveProtocolCCExcludeRequest };
+let ZWaveProtocolCCAssignReturnRoutePriority = ZWaveProtocolCCAssignReturnRoutePriority_1 = class ZWaveProtocolCCAssignReturnRoutePriority extends ZWaveProtocolCC {
+    constructor(options) {
+        super(options);
+        this.targetNodeId = options.targetNodeId;
+        this.routeNumber = options.routeNumber;
+    }
+    static from(raw, ctx) {
+        validatePayload(raw.payload.length >= 2);
+        const targetNodeId = raw.payload[0];
+        const routeNumber = raw.payload[1];
+        return new ZWaveProtocolCCAssignReturnRoutePriority_1({
+            nodeId: ctx.sourceNodeId,
+            targetNodeId,
+            routeNumber,
+        });
+    }
+    targetNodeId;
+    routeNumber;
+    serialize(ctx) {
+        this.payload = Bytes.from([this.targetNodeId, this.routeNumber]);
+        return super.serialize(ctx);
+    }
+};
+ZWaveProtocolCCAssignReturnRoutePriority = ZWaveProtocolCCAssignReturnRoutePriority_1 = __decorate([
+    CCCommand(ZWaveProtocolCommand.AssignReturnRoutePriority)
+], ZWaveProtocolCCAssignReturnRoutePriority);
+export { ZWaveProtocolCCAssignReturnRoutePriority };
+let ZWaveProtocolCCAssignSUCReturnRoutePriority = class ZWaveProtocolCCAssignSUCReturnRoutePriority extends ZWaveProtocolCCAssignReturnRoutePriority {
+};
+ZWaveProtocolCCAssignSUCReturnRoutePriority = __decorate([
+    CCCommand(ZWaveProtocolCommand.AssignSUCReturnRoutePriority)
+], ZWaveProtocolCCAssignSUCReturnRoutePriority);
+export { ZWaveProtocolCCAssignSUCReturnRoutePriority };
+let ZWaveProtocolCCSmartStartIncludedNodeInformation = ZWaveProtocolCCSmartStartIncludedNodeInformation_1 = class ZWaveProtocolCCSmartStartIncludedNodeInformation extends ZWaveProtocolCC {
+    constructor(options) {
+        super(options);
+        if (options.nwiHomeId.length !== 4) {
+            throw new ZWaveError(`nwiHomeId must have length 4`, ZWaveErrorCodes.Argument_Invalid);
+        }
+        this.nwiHomeId = options.nwiHomeId;
+    }
+    static from(raw, ctx) {
+        validatePayload(raw.payload.length >= 4);
+        const nwiHomeId = raw.payload.subarray(0, 4);
+        return new ZWaveProtocolCCSmartStartIncludedNodeInformation_1({
+            nodeId: ctx.sourceNodeId,
+            nwiHomeId,
+        });
+    }
+    nwiHomeId;
+    serialize(ctx) {
+        this.payload = Bytes.from(this.nwiHomeId);
+        return super.serialize(ctx);
+    }
+};
+ZWaveProtocolCCSmartStartIncludedNodeInformation = ZWaveProtocolCCSmartStartIncludedNodeInformation_1 = __decorate([
+    CCCommand(ZWaveProtocolCommand.SmartStartIncludedNodeInformation)
+], ZWaveProtocolCCSmartStartIncludedNodeInformation);
+export { ZWaveProtocolCCSmartStartIncludedNodeInformation };
+let ZWaveProtocolCCSmartStartPrime = class ZWaveProtocolCCSmartStartPrime extends ZWaveProtocolCCNodeInformationFrame {
+};
+ZWaveProtocolCCSmartStartPrime = __decorate([
+    CCCommand(ZWaveProtocolCommand.SmartStartPrime)
+], ZWaveProtocolCCSmartStartPrime);
+export { ZWaveProtocolCCSmartStartPrime };
+let ZWaveProtocolCCSmartStartInclusionRequest = class ZWaveProtocolCCSmartStartInclusionRequest extends ZWaveProtocolCCNodeInformationFrame {
+};
+ZWaveProtocolCCSmartStartInclusionRequest = __decorate([
+    CCCommand(ZWaveProtocolCommand.SmartStartInclusionRequest)
+], ZWaveProtocolCCSmartStartInclusionRequest);
+export { ZWaveProtocolCCSmartStartInclusionRequest };
+//# sourceMappingURL=ZWaveProtocolCC.js.map