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

package/build/esm/cc/ZWaveProtocolCC.js

@@ -1,10 +1,37 @@
-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 __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
+};
+var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
 };
-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";
@@ -30,1001 +57,1464 @@ function bitmask2DataRate(mask) {
             ? ZWaveDataRate["40k"]
             : ZWaveDataRate["9k6"];
 }
-let ZWaveProtocolCC = class ZWaveProtocolCC extends CommandClass {
-};
-ZWaveProtocolCC = __decorate([
-    commandClass(CommandClasses["Z-Wave Protocol"]),
-    implementedVersion(1)
-], ZWaveProtocolCC);
+let ZWaveProtocolCC = (() => {
+    let _classDecorators = [commandClass(CommandClasses["Z-Wave Protocol"]), implementedVersion(1)];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = CommandClass;
+    var ZWaveProtocolCC = class extends _classSuper {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            ZWaveProtocolCC = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+    };
+    return ZWaveProtocolCC = _classThis;
+})();
 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);
+let ZWaveProtocolCCNodeInformationFrame = (() => {
+    let _classDecorators = [CCCommand(ZWaveProtocolCommand.NodeInformationFrame)];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = ZWaveProtocolCC;
+    var ZWaveProtocolCCNodeInformationFrame = class extends _classSuper {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            ZWaveProtocolCCNodeInformationFrame = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+        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 this({
+                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);
+        }
+    };
+    return ZWaveProtocolCCNodeInformationFrame = _classThis;
+})();
 export { ZWaveProtocolCCNodeInformationFrame };
-let ZWaveProtocolCCRequestNodeInformationFrame = class ZWaveProtocolCCRequestNodeInformationFrame extends ZWaveProtocolCC {
-};
-ZWaveProtocolCCRequestNodeInformationFrame = __decorate([
-    CCCommand(ZWaveProtocolCommand.RequestNodeInformationFrame),
-    expectedCCResponse(ZWaveProtocolCCNodeInformationFrame)
-], ZWaveProtocolCCRequestNodeInformationFrame);
+let ZWaveProtocolCCRequestNodeInformationFrame = (() => {
+    let _classDecorators = [CCCommand(ZWaveProtocolCommand.RequestNodeInformationFrame), expectedCCResponse(ZWaveProtocolCCNodeInformationFrame)];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = ZWaveProtocolCC;
+    var ZWaveProtocolCCRequestNodeInformationFrame = class extends _classSuper {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            ZWaveProtocolCCRequestNodeInformationFrame = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+    };
+    return ZWaveProtocolCCRequestNodeInformationFrame = _classThis;
+})();
 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);
+let ZWaveProtocolCCAssignIDs = (() => {
+    let _classDecorators = [CCCommand(ZWaveProtocolCommand.AssignIDs)];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = ZWaveProtocolCC;
+    var ZWaveProtocolCCAssignIDs = class extends _classSuper {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            ZWaveProtocolCCAssignIDs = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+        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 this({
+                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);
+        }
+    };
+    return ZWaveProtocolCCAssignIDs = _classThis;
+})();
 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;
+let ZWaveProtocolCCFindNodesInRange = (() => {
+    let _classDecorators = [CCCommand(ZWaveProtocolCommand.FindNodesInRange)];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = ZWaveProtocolCC;
+    var ZWaveProtocolCCFindNodesInRange = class extends _classSuper {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            ZWaveProtocolCCFindNodesInRange = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+        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 === 2) {
+            else if (rest.length >= 1) {
                 wakeUpTime = parseWakeUpTime(rest[0]);
-                dataRate = rest[1] & 0b111;
+                dataRate = ZWaveDataRate["9k6"];
             }
             else {
-                validatePayload.fail("Invalid payload length");
+                wakeUpTime = WakeUpTime.None;
+                dataRate = ZWaveDataRate["9k6"];
             }
+            return new this({
+                nodeId: ctx.sourceNodeId,
+                candidateNodeIds,
+                dataRate,
+                wakeUpTime,
+            });
         }
-        else if (rest.length >= 1) {
-            wakeUpTime = parseWakeUpTime(rest[0]);
-            dataRate = ZWaveDataRate["9k6"];
-        }
-        else {
-            wakeUpTime = WakeUpTime.None;
-            dataRate = ZWaveDataRate["9k6"];
+        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);
         }
-        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);
+    };
+    return ZWaveProtocolCCFindNodesInRange = _classThis;
+})();
 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);
+let ZWaveProtocolCCRangeInfo = (() => {
+    let _classDecorators = [CCCommand(ZWaveProtocolCommand.RangeInfo)];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = ZWaveProtocolCC;
+    var ZWaveProtocolCCRangeInfo = class extends _classSuper {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            ZWaveProtocolCCRangeInfo = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+        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 this({
+                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);
+        }
+    };
+    return ZWaveProtocolCCRangeInfo = _classThis;
+})();
 export { ZWaveProtocolCCRangeInfo };
-let ZWaveProtocolCCGetNodesInRange = class ZWaveProtocolCCGetNodesInRange extends ZWaveProtocolCC {
-};
-ZWaveProtocolCCGetNodesInRange = __decorate([
-    CCCommand(ZWaveProtocolCommand.GetNodesInRange),
-    expectedCCResponse(ZWaveProtocolCCRangeInfo)
-], ZWaveProtocolCCGetNodesInRange);
+let ZWaveProtocolCCGetNodesInRange = (() => {
+    let _classDecorators = [CCCommand(ZWaveProtocolCommand.GetNodesInRange), expectedCCResponse(ZWaveProtocolCCRangeInfo)];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = ZWaveProtocolCC;
+    var ZWaveProtocolCCGetNodesInRange = class extends _classSuper {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            ZWaveProtocolCCGetNodesInRange = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+    };
+    return ZWaveProtocolCCGetNodesInRange = _classThis;
+})();
 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);
+let ZWaveProtocolCCCommandComplete = (() => {
+    let _classDecorators = [CCCommand(ZWaveProtocolCommand.CommandComplete)];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = ZWaveProtocolCC;
+    var ZWaveProtocolCCCommandComplete = class extends _classSuper {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            ZWaveProtocolCCCommandComplete = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+        constructor(options) {
+            super(options);
+            this.sequenceNumber = options.sequenceNumber;
+        }
+        static from(raw, ctx) {
+            validatePayload(raw.payload.length >= 1);
+            const sequenceNumber = raw.payload[0];
+            return new this({
+                nodeId: ctx.sourceNodeId,
+                sequenceNumber,
+            });
+        }
+        sequenceNumber;
+        serialize(ctx) {
+            this.payload = Bytes.from([this.sequenceNumber]);
+            return super.serialize(ctx);
+        }
+    };
+    return ZWaveProtocolCCCommandComplete = _classThis;
+})();
 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);
+let ZWaveProtocolCCTransferPresentation = (() => {
+    let _classDecorators = [CCCommand(ZWaveProtocolCommand.TransferPresentation)];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = ZWaveProtocolCC;
+    var ZWaveProtocolCCTransferPresentation = class extends _classSuper {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            ZWaveProtocolCCTransferPresentation = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+        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 this({
+                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);
+        }
+    };
+    return ZWaveProtocolCCTransferPresentation = _classThis;
+})();
 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);
+let ZWaveProtocolCCTransferNodeInformation = (() => {
+    let _classDecorators = [CCCommand(ZWaveProtocolCommand.TransferNodeInformation)];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = ZWaveProtocolCC;
+    var ZWaveProtocolCCTransferNodeInformation = class extends _classSuper {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            ZWaveProtocolCCTransferNodeInformation = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+        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 this({
+                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);
+        }
+    };
+    return ZWaveProtocolCCTransferNodeInformation = _classThis;
+})();
 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);
+let ZWaveProtocolCCTransferRangeInformation = (() => {
+    let _classDecorators = [CCCommand(ZWaveProtocolCommand.TransferRangeInformation)];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = ZWaveProtocolCC;
+    var ZWaveProtocolCCTransferRangeInformation = class extends _classSuper {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            ZWaveProtocolCCTransferRangeInformation = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+        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 this({
+                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);
+        }
+    };
+    return ZWaveProtocolCCTransferRangeInformation = _classThis;
+})();
 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);
+let ZWaveProtocolCCTransferEnd = (() => {
+    let _classDecorators = [CCCommand(ZWaveProtocolCommand.TransferEnd)];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = ZWaveProtocolCC;
+    var ZWaveProtocolCCTransferEnd = class extends _classSuper {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            ZWaveProtocolCCTransferEnd = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+        constructor(options) {
+            super(options);
+            this.status = options.status;
+        }
+        static from(raw, ctx) {
+            validatePayload(raw.payload.length >= 1);
+            const status = raw.payload[0];
+            return new this({
+                nodeId: ctx.sourceNodeId,
+                status,
+            });
+        }
+        status;
+        serialize(ctx) {
+            this.payload = Bytes.from([this.status]);
+            return super.serialize(ctx);
+        }
+    };
+    return ZWaveProtocolCCTransferEnd = _classThis;
+})();
 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);
+let ZWaveProtocolCCAssignReturnRoute = (() => {
+    let _classDecorators = [CCCommand(ZWaveProtocolCommand.AssignReturnRoute)];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = ZWaveProtocolCC;
+    var ZWaveProtocolCCAssignReturnRoute = class extends _classSuper {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            ZWaveProtocolCCAssignReturnRoute = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+        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 this({
+                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);
+        }
+    };
+    return ZWaveProtocolCCAssignReturnRoute = _classThis;
+})();
 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);
+let ZWaveProtocolCCNewNodeRegistered = (() => {
+    let _classDecorators = [CCCommand(ZWaveProtocolCommand.NewNodeRegistered)];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = ZWaveProtocolCC;
+    var ZWaveProtocolCCNewNodeRegistered = class extends _classSuper {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            ZWaveProtocolCCNewNodeRegistered = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+        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 this({
+                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);
+        }
+    };
+    return ZWaveProtocolCCNewNodeRegistered = _classThis;
+})();
 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);
+let ZWaveProtocolCCNewRangeRegistered = (() => {
+    let _classDecorators = [CCCommand(ZWaveProtocolCommand.NewRangeRegistered)];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = ZWaveProtocolCC;
+    var ZWaveProtocolCCNewRangeRegistered = class extends _classSuper {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            ZWaveProtocolCCNewRangeRegistered = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+        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 this({
+                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);
+        }
+    };
+    return ZWaveProtocolCCNewRangeRegistered = _classThis;
+})();
 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);
+let ZWaveProtocolCCTransferNewPrimaryControllerComplete = (() => {
+    let _classDecorators = [CCCommand(ZWaveProtocolCommand.TransferNewPrimaryControllerComplete)];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = ZWaveProtocolCC;
+    var ZWaveProtocolCCTransferNewPrimaryControllerComplete = class extends _classSuper {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            ZWaveProtocolCCTransferNewPrimaryControllerComplete = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+        constructor(options) {
+            super(options);
+            this.genericDeviceClass = options.genericDeviceClass;
+        }
+        static from(raw, ctx) {
+            validatePayload(raw.payload.length >= 1);
+            const genericDeviceClass = raw.payload[0];
+            return new this({
+                nodeId: ctx.sourceNodeId,
+                genericDeviceClass,
+            });
+        }
+        genericDeviceClass;
+        serialize(ctx) {
+            this.payload = Bytes.from([this.genericDeviceClass]);
+            return super.serialize(ctx);
+        }
+    };
+    return ZWaveProtocolCCTransferNewPrimaryControllerComplete = _classThis;
+})();
 export { ZWaveProtocolCCTransferNewPrimaryControllerComplete };
-let ZWaveProtocolCCAutomaticControllerUpdateStart = class ZWaveProtocolCCAutomaticControllerUpdateStart extends ZWaveProtocolCC {
-};
-ZWaveProtocolCCAutomaticControllerUpdateStart = __decorate([
-    CCCommand(ZWaveProtocolCommand.AutomaticControllerUpdateStart)
-], ZWaveProtocolCCAutomaticControllerUpdateStart);
+let ZWaveProtocolCCAutomaticControllerUpdateStart = (() => {
+    let _classDecorators = [CCCommand(ZWaveProtocolCommand.AutomaticControllerUpdateStart)];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = ZWaveProtocolCC;
+    var ZWaveProtocolCCAutomaticControllerUpdateStart = class extends _classSuper {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            ZWaveProtocolCCAutomaticControllerUpdateStart = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+    };
+    return ZWaveProtocolCCAutomaticControllerUpdateStart = _classThis;
+})();
 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);
+let ZWaveProtocolCCSUCNodeID = (() => {
+    let _classDecorators = [CCCommand(ZWaveProtocolCommand.SUCNodeID)];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = ZWaveProtocolCC;
+    var ZWaveProtocolCCSUCNodeID = class extends _classSuper {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            ZWaveProtocolCCSUCNodeID = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+        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 this({
+                nodeId: ctx.sourceNodeId,
+                sucNodeId,
+                isSIS,
+            });
+        }
+        sucNodeId;
+        isSIS;
+        serialize(ctx) {
+            this.payload = Bytes.from([this.sucNodeId, this.isSIS ? 0b1 : 0]);
+            return super.serialize(ctx);
+        }
+    };
+    return ZWaveProtocolCCSUCNodeID = _classThis;
+})();
 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);
+let ZWaveProtocolCCSetSUC = (() => {
+    let _classDecorators = [CCCommand(ZWaveProtocolCommand.SetSUC)];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = ZWaveProtocolCC;
+    var ZWaveProtocolCCSetSUC = class extends _classSuper {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            ZWaveProtocolCCSetSUC = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+        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 this({
+                nodeId: ctx.sourceNodeId,
+                enableSIS,
+            });
+        }
+        enableSIS;
+        serialize(ctx) {
+            this.payload = Bytes.from([0x01, this.enableSIS ? 0b1 : 0]);
+            return super.serialize(ctx);
+        }
+    };
+    return ZWaveProtocolCCSetSUC = _classThis;
+})();
 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);
+let ZWaveProtocolCCSetSUCAck = (() => {
+    let _classDecorators = [CCCommand(ZWaveProtocolCommand.SetSUCAck)];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = ZWaveProtocolCC;
+    var ZWaveProtocolCCSetSUCAck = class extends _classSuper {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            ZWaveProtocolCCSetSUCAck = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+        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 this({
+                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);
+        }
+    };
+    return ZWaveProtocolCCSetSUCAck = _classThis;
+})();
 export { ZWaveProtocolCCSetSUCAck };
-let ZWaveProtocolCCAssignSUCReturnRoute = class ZWaveProtocolCCAssignSUCReturnRoute extends ZWaveProtocolCCAssignReturnRoute {
-};
-ZWaveProtocolCCAssignSUCReturnRoute = __decorate([
-    CCCommand(ZWaveProtocolCommand.AssignSUCReturnRoute)
-], ZWaveProtocolCCAssignSUCReturnRoute);
+let ZWaveProtocolCCAssignSUCReturnRoute = (() => {
+    let _classDecorators = [CCCommand(ZWaveProtocolCommand.AssignSUCReturnRoute)];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = ZWaveProtocolCCAssignReturnRoute;
+    var ZWaveProtocolCCAssignSUCReturnRoute = class extends _classSuper {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            ZWaveProtocolCCAssignSUCReturnRoute = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+    };
+    return ZWaveProtocolCCAssignSUCReturnRoute = _classThis;
+})();
 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);
+let ZWaveProtocolCCStaticRouteRequest = (() => {
+    let _classDecorators = [CCCommand(ZWaveProtocolCommand.StaticRouteRequest)];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = ZWaveProtocolCC;
+    var ZWaveProtocolCCStaticRouteRequest = class extends _classSuper {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            ZWaveProtocolCCStaticRouteRequest = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
         }
-        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];
+        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;
         }
-        return super.serialize(ctx);
-    }
-};
-ZWaveProtocolCCStaticRouteRequest = ZWaveProtocolCCStaticRouteRequest_1 = __decorate([
-    CCCommand(ZWaveProtocolCommand.StaticRouteRequest)
-], ZWaveProtocolCCStaticRouteRequest);
+        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 this({
+                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);
+        }
+    };
+    return ZWaveProtocolCCStaticRouteRequest = _classThis;
+})();
 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);
+let ZWaveProtocolCCLost = (() => {
+    let _classDecorators = [CCCommand(ZWaveProtocolCommand.Lost)];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = ZWaveProtocolCC;
+    var ZWaveProtocolCCLost = class extends _classSuper {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            ZWaveProtocolCCLost = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+        constructor(options) {
+            super(options);
+            this.lostNodeId = options.lostNodeId;
+        }
+        static from(raw, ctx) {
+            validatePayload(raw.payload.length >= 1);
+            const lostNodeId = raw.payload[0];
+            return new this({
+                nodeId: ctx.sourceNodeId,
+                lostNodeId,
+            });
+        }
+        lostNodeId;
+        serialize(ctx) {
+            this.payload = Bytes.from([this.lostNodeId]);
+            return super.serialize(ctx);
+        }
+    };
+    return ZWaveProtocolCCLost = _classThis;
+})();
 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);
+let ZWaveProtocolCCAcceptLost = (() => {
+    let _classDecorators = [CCCommand(ZWaveProtocolCommand.AcceptLost)];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = ZWaveProtocolCC;
+    var ZWaveProtocolCCAcceptLost = class extends _classSuper {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            ZWaveProtocolCCAcceptLost = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+        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 this({
+                nodeId: ctx.sourceNodeId,
+                accepted,
+            });
+        }
+        accepted;
+        serialize(ctx) {
+            this.payload = Bytes.from([this.accepted ? 0x05 : 0x04]);
+            return super.serialize(ctx);
+        }
+    };
+    return ZWaveProtocolCCAcceptLost = _classThis;
+})();
 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);
+let ZWaveProtocolCCNOPPower = (() => {
+    let _classDecorators = [CCCommand(ZWaveProtocolCommand.NOPPower)];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = ZWaveProtocolCC;
+    var ZWaveProtocolCCNOPPower = class extends _classSuper {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            ZWaveProtocolCCNOPPower = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
         }
-        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);
+        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 this({
+                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);
+        }
+    };
+    return ZWaveProtocolCCNOPPower = _classThis;
+})();
 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);
+let ZWaveProtocolCCReservedIDs = (() => {
+    let _classDecorators = [CCCommand(ZWaveProtocolCommand.ReservedIDs)];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = ZWaveProtocolCC;
+    var ZWaveProtocolCCReservedIDs = class extends _classSuper {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            ZWaveProtocolCCReservedIDs = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+        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 this({
+                nodeId: ctx.sourceNodeId,
+                reservedNodeIDs,
+            });
+        }
+        reservedNodeIDs;
+        serialize(ctx) {
+            this.payload = Bytes.from([
+                this.reservedNodeIDs.length,
+                ...this.reservedNodeIDs,
+            ]);
+            return super.serialize(ctx);
+        }
+    };
+    return ZWaveProtocolCCReservedIDs = _classThis;
+})();
 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);
+let ZWaveProtocolCCReserveNodeIDs = (() => {
+    let _classDecorators = [CCCommand(ZWaveProtocolCommand.ReserveNodeIDs), expectedCCResponse(ZWaveProtocolCCReservedIDs)];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = ZWaveProtocolCC;
+    var ZWaveProtocolCCReserveNodeIDs = class extends _classSuper {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            ZWaveProtocolCCReserveNodeIDs = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+        constructor(options) {
+            super(options);
+            this.numNodeIDs = options.numNodeIDs;
+        }
+        static from(raw, ctx) {
+            validatePayload(raw.payload.length >= 1);
+            const numNodeIDs = raw.payload[0];
+            return new this({
+                nodeId: ctx.sourceNodeId,
+                numNodeIDs,
+            });
+        }
+        numNodeIDs;
+        serialize(ctx) {
+            this.payload = Bytes.from([this.numNodeIDs]);
+            return super.serialize(ctx);
+        }
+    };
+    return ZWaveProtocolCCReserveNodeIDs = _classThis;
+})();
 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);
+let ZWaveProtocolCCNodesExistReply = (() => {
+    let _classDecorators = [CCCommand(ZWaveProtocolCommand.NodesExistReply)];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = ZWaveProtocolCC;
+    var ZWaveProtocolCCNodesExistReply = class extends _classSuper {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            ZWaveProtocolCCNodesExistReply = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+        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 this({
+                nodeId: ctx.sourceNodeId,
+                nodeMaskType,
+                nodeListUpdated,
+            });
+        }
+        nodeMaskType;
+        nodeListUpdated;
+        serialize(ctx) {
+            this.payload = Bytes.from([
+                this.nodeMaskType,
+                this.nodeListUpdated ? 0x01 : 0x00,
+            ]);
+            return super.serialize(ctx);
+        }
+    };
+    return ZWaveProtocolCCNodesExistReply = _classThis;
+})();
 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);
+let ZWaveProtocolCCNodesExist = (() => {
+    let _classDecorators = [CCCommand(ZWaveProtocolCommand.NodesExist), expectedCCResponse(ZWaveProtocolCCNodesExistReply, testResponseForZWaveProtocolNodesExist)];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = ZWaveProtocolCC;
+    var ZWaveProtocolCCNodesExist = class extends _classSuper {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            ZWaveProtocolCCNodesExist = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+        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 this({
+                nodeId: ctx.sourceNodeId,
+                nodeMaskType,
+                nodeIDs,
+            });
+        }
+        nodeMaskType;
+        nodeIDs;
+        serialize(ctx) {
+            this.payload = Bytes.from([
+                this.nodeMaskType,
+                this.nodeIDs.length,
+                ...this.nodeIDs,
+            ]);
+            return super.serialize(ctx);
+        }
+    };
+    return ZWaveProtocolCCNodesExist = _classThis;
+})();
 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);
+let ZWaveProtocolCCSetNWIMode = (() => {
+    let _classDecorators = [CCCommand(ZWaveProtocolCommand.SetNWIMode)];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = ZWaveProtocolCC;
+    var ZWaveProtocolCCSetNWIMode = class extends _classSuper {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            ZWaveProtocolCCSetNWIMode = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+        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 this({
+                nodeId: ctx.sourceNodeId,
+                enabled,
+                timeoutMinutes,
+            });
+        }
+        enabled;
+        timeoutMinutes;
+        serialize(ctx) {
+            this.payload = Bytes.from([
+                this.enabled ? 0x01 : 0x00,
+                this.timeoutMinutes ?? 0x00,
+            ]);
+            return super.serialize(ctx);
+        }
+    };
+    return ZWaveProtocolCCSetNWIMode = _classThis;
+})();
 export { ZWaveProtocolCCSetNWIMode };
-let ZWaveProtocolCCExcludeRequest = class ZWaveProtocolCCExcludeRequest extends ZWaveProtocolCCNodeInformationFrame {
-};
-ZWaveProtocolCCExcludeRequest = __decorate([
-    CCCommand(ZWaveProtocolCommand.ExcludeRequest)
-], ZWaveProtocolCCExcludeRequest);
+let ZWaveProtocolCCExcludeRequest = (() => {
+    let _classDecorators = [CCCommand(ZWaveProtocolCommand.ExcludeRequest)];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = ZWaveProtocolCCNodeInformationFrame;
+    var ZWaveProtocolCCExcludeRequest = class extends _classSuper {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            ZWaveProtocolCCExcludeRequest = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+    };
+    return ZWaveProtocolCCExcludeRequest = _classThis;
+})();
 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);
+let ZWaveProtocolCCAssignReturnRoutePriority = (() => {
+    let _classDecorators = [CCCommand(ZWaveProtocolCommand.AssignReturnRoutePriority)];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = ZWaveProtocolCC;
+    var ZWaveProtocolCCAssignReturnRoutePriority = class extends _classSuper {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            ZWaveProtocolCCAssignReturnRoutePriority = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+        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 this({
+                nodeId: ctx.sourceNodeId,
+                targetNodeId,
+                routeNumber,
+            });
+        }
+        targetNodeId;
+        routeNumber;
+        serialize(ctx) {
+            this.payload = Bytes.from([this.targetNodeId, this.routeNumber]);
+            return super.serialize(ctx);
+        }
+    };
+    return ZWaveProtocolCCAssignReturnRoutePriority = _classThis;
+})();
 export { ZWaveProtocolCCAssignReturnRoutePriority };
-let ZWaveProtocolCCAssignSUCReturnRoutePriority = class ZWaveProtocolCCAssignSUCReturnRoutePriority extends ZWaveProtocolCCAssignReturnRoutePriority {
-};
-ZWaveProtocolCCAssignSUCReturnRoutePriority = __decorate([
-    CCCommand(ZWaveProtocolCommand.AssignSUCReturnRoutePriority)
-], ZWaveProtocolCCAssignSUCReturnRoutePriority);
+let ZWaveProtocolCCAssignSUCReturnRoutePriority = (() => {
+    let _classDecorators = [CCCommand(ZWaveProtocolCommand.AssignSUCReturnRoutePriority)];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = ZWaveProtocolCCAssignReturnRoutePriority;
+    var ZWaveProtocolCCAssignSUCReturnRoutePriority = class extends _classSuper {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            ZWaveProtocolCCAssignSUCReturnRoutePriority = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+    };
+    return ZWaveProtocolCCAssignSUCReturnRoutePriority = _classThis;
+})();
 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);
+let ZWaveProtocolCCSmartStartIncludedNodeInformation = (() => {
+    let _classDecorators = [CCCommand(ZWaveProtocolCommand.SmartStartIncludedNodeInformation)];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = ZWaveProtocolCC;
+    var ZWaveProtocolCCSmartStartIncludedNodeInformation = class extends _classSuper {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            ZWaveProtocolCCSmartStartIncludedNodeInformation = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
         }
-        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);
+        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 this({
+                nodeId: ctx.sourceNodeId,
+                nwiHomeId,
+            });
+        }
+        nwiHomeId;
+        serialize(ctx) {
+            this.payload = Bytes.from(this.nwiHomeId);
+            return super.serialize(ctx);
+        }
+    };
+    return ZWaveProtocolCCSmartStartIncludedNodeInformation = _classThis;
+})();
 export { ZWaveProtocolCCSmartStartIncludedNodeInformation };
-let ZWaveProtocolCCSmartStartPrime = class ZWaveProtocolCCSmartStartPrime extends ZWaveProtocolCCNodeInformationFrame {
-};
-ZWaveProtocolCCSmartStartPrime = __decorate([
-    CCCommand(ZWaveProtocolCommand.SmartStartPrime)
-], ZWaveProtocolCCSmartStartPrime);
+let ZWaveProtocolCCSmartStartPrime = (() => {
+    let _classDecorators = [CCCommand(ZWaveProtocolCommand.SmartStartPrime)];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = ZWaveProtocolCCNodeInformationFrame;
+    var ZWaveProtocolCCSmartStartPrime = class extends _classSuper {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            ZWaveProtocolCCSmartStartPrime = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+    };
+    return ZWaveProtocolCCSmartStartPrime = _classThis;
+})();
 export { ZWaveProtocolCCSmartStartPrime };
-let ZWaveProtocolCCSmartStartInclusionRequest = class ZWaveProtocolCCSmartStartInclusionRequest extends ZWaveProtocolCCNodeInformationFrame {
-};
-ZWaveProtocolCCSmartStartInclusionRequest = __decorate([
-    CCCommand(ZWaveProtocolCommand.SmartStartInclusionRequest)
-], ZWaveProtocolCCSmartStartInclusionRequest);
+let ZWaveProtocolCCSmartStartInclusionRequest = (() => {
+    let _classDecorators = [CCCommand(ZWaveProtocolCommand.SmartStartInclusionRequest)];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = ZWaveProtocolCCNodeInformationFrame;
+    var ZWaveProtocolCCSmartStartInclusionRequest = class extends _classSuper {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            ZWaveProtocolCCSmartStartInclusionRequest = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+    };
+    return ZWaveProtocolCCSmartStartInclusionRequest = _classThis;
+})();
 export { ZWaveProtocolCCSmartStartInclusionRequest };
 //# sourceMappingURL=ZWaveProtocolCC.js.map