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

package/build/cjs/cc/ZWaveProtocolCC.js

@@ -0,0 +1,1071 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var ZWaveProtocolCC_exports = {};
+__export(ZWaveProtocolCC_exports, {
+  ZWaveProtocolCC: () => ZWaveProtocolCC,
+  ZWaveProtocolCCAcceptLost: () => ZWaveProtocolCCAcceptLost,
+  ZWaveProtocolCCAssignIDs: () => ZWaveProtocolCCAssignIDs,
+  ZWaveProtocolCCAssignReturnRoute: () => ZWaveProtocolCCAssignReturnRoute,
+  ZWaveProtocolCCAssignReturnRoutePriority: () => ZWaveProtocolCCAssignReturnRoutePriority,
+  ZWaveProtocolCCAssignSUCReturnRoute: () => ZWaveProtocolCCAssignSUCReturnRoute,
+  ZWaveProtocolCCAssignSUCReturnRoutePriority: () => ZWaveProtocolCCAssignSUCReturnRoutePriority,
+  ZWaveProtocolCCAutomaticControllerUpdateStart: () => ZWaveProtocolCCAutomaticControllerUpdateStart,
+  ZWaveProtocolCCCommandComplete: () => ZWaveProtocolCCCommandComplete,
+  ZWaveProtocolCCExcludeRequest: () => ZWaveProtocolCCExcludeRequest,
+  ZWaveProtocolCCFindNodesInRange: () => ZWaveProtocolCCFindNodesInRange,
+  ZWaveProtocolCCGetNodesInRange: () => ZWaveProtocolCCGetNodesInRange,
+  ZWaveProtocolCCLost: () => ZWaveProtocolCCLost,
+  ZWaveProtocolCCNOPPower: () => ZWaveProtocolCCNOPPower,
+  ZWaveProtocolCCNewNodeRegistered: () => ZWaveProtocolCCNewNodeRegistered,
+  ZWaveProtocolCCNewRangeRegistered: () => ZWaveProtocolCCNewRangeRegistered,
+  ZWaveProtocolCCNodeInformationFrame: () => ZWaveProtocolCCNodeInformationFrame,
+  ZWaveProtocolCCNodesExist: () => ZWaveProtocolCCNodesExist,
+  ZWaveProtocolCCNodesExistReply: () => ZWaveProtocolCCNodesExistReply,
+  ZWaveProtocolCCRangeInfo: () => ZWaveProtocolCCRangeInfo,
+  ZWaveProtocolCCRequestNodeInformationFrame: () => ZWaveProtocolCCRequestNodeInformationFrame,
+  ZWaveProtocolCCReserveNodeIDs: () => ZWaveProtocolCCReserveNodeIDs,
+  ZWaveProtocolCCReservedIDs: () => ZWaveProtocolCCReservedIDs,
+  ZWaveProtocolCCSUCNodeID: () => ZWaveProtocolCCSUCNodeID,
+  ZWaveProtocolCCSetNWIMode: () => ZWaveProtocolCCSetNWIMode,
+  ZWaveProtocolCCSetSUC: () => ZWaveProtocolCCSetSUC,
+  ZWaveProtocolCCSetSUCAck: () => ZWaveProtocolCCSetSUCAck,
+  ZWaveProtocolCCSmartStartIncludedNodeInformation: () => ZWaveProtocolCCSmartStartIncludedNodeInformation,
+  ZWaveProtocolCCSmartStartInclusionRequest: () => ZWaveProtocolCCSmartStartInclusionRequest,
+  ZWaveProtocolCCSmartStartPrime: () => ZWaveProtocolCCSmartStartPrime,
+  ZWaveProtocolCCStaticRouteRequest: () => ZWaveProtocolCCStaticRouteRequest,
+  ZWaveProtocolCCTransferEnd: () => ZWaveProtocolCCTransferEnd,
+  ZWaveProtocolCCTransferNewPrimaryControllerComplete: () => ZWaveProtocolCCTransferNewPrimaryControllerComplete,
+  ZWaveProtocolCCTransferNodeInformation: () => ZWaveProtocolCCTransferNodeInformation,
+  ZWaveProtocolCCTransferPresentation: () => ZWaveProtocolCCTransferPresentation,
+  ZWaveProtocolCCTransferRangeInformation: () => ZWaveProtocolCCTransferRangeInformation
+});
+module.exports = __toCommonJS(ZWaveProtocolCC_exports);
+var import_core = require("@zwave-js/core");
+var import_safe = require("@zwave-js/shared/safe");
+var import_CommandClass = require("../lib/CommandClass.js");
+var import_CommandClassDecorators = require("../lib/CommandClassDecorators.js");
+var import_Types = require("../lib/_Types.js");
+var __decorate = function(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var ZWaveProtocolCCNodeInformationFrame_1, ZWaveProtocolCCAssignIDs_1, ZWaveProtocolCCFindNodesInRange_1, ZWaveProtocolCCRangeInfo_1, ZWaveProtocolCCCommandComplete_1, ZWaveProtocolCCTransferPresentation_1, ZWaveProtocolCCTransferNodeInformation_1, ZWaveProtocolCCTransferRangeInformation_1, ZWaveProtocolCCTransferEnd_1, ZWaveProtocolCCAssignReturnRoute_1, ZWaveProtocolCCNewNodeRegistered_1, ZWaveProtocolCCNewRangeRegistered_1, ZWaveProtocolCCTransferNewPrimaryControllerComplete_1, ZWaveProtocolCCSUCNodeID_1, ZWaveProtocolCCSetSUC_1, ZWaveProtocolCCSetSUCAck_1, ZWaveProtocolCCStaticRouteRequest_1, ZWaveProtocolCCLost_1, ZWaveProtocolCCAcceptLost_1, ZWaveProtocolCCNOPPower_1, ZWaveProtocolCCReservedIDs_1, ZWaveProtocolCCReserveNodeIDs_1, ZWaveProtocolCCNodesExistReply_1, ZWaveProtocolCCNodesExist_1, ZWaveProtocolCCSetNWIMode_1, ZWaveProtocolCCAssignReturnRoutePriority_1, ZWaveProtocolCCSmartStartIncludedNodeInformation_1;
+var DataRateBitmask;
+(function(DataRateBitmask2) {
+  DataRateBitmask2[DataRateBitmask2["9k6"] = 1] = "9k6";
+  DataRateBitmask2[DataRateBitmask2["40k"] = 2] = "40k";
+  DataRateBitmask2[DataRateBitmask2["100k"] = 4] = "100k";
+})(DataRateBitmask || (DataRateBitmask = {}));
+function dataRate2Bitmask(dataRate) {
+  return dataRate === import_core.ZWaveDataRate["100k"] ? DataRateBitmask["100k"] : dataRate === import_core.ZWaveDataRate["40k"] ? DataRateBitmask["40k"] : DataRateBitmask["9k6"];
+}
+function bitmask2DataRate(mask) {
+  return mask === DataRateBitmask["100k"] ? import_core.ZWaveDataRate["100k"] : mask === DataRateBitmask["40k"] ? import_core.ZWaveDataRate["40k"] : import_core.ZWaveDataRate["9k6"];
+}
+let ZWaveProtocolCC = class ZWaveProtocolCC2 extends import_CommandClass.CommandClass {
+};
+ZWaveProtocolCC = __decorate([
+  (0, import_CommandClassDecorators.commandClass)(import_core.CommandClasses["Z-Wave Protocol"]),
+  (0, import_CommandClassDecorators.implementedVersion)(1)
+], ZWaveProtocolCC);
+let ZWaveProtocolCCNodeInformationFrame = ZWaveProtocolCCNodeInformationFrame_1 = class ZWaveProtocolCCNodeInformationFrame2 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 = (0, import_core.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 = (0, import_core.encodeNodeInformationFrame)(this);
+    return super.serialize(ctx);
+  }
+};
+ZWaveProtocolCCNodeInformationFrame = ZWaveProtocolCCNodeInformationFrame_1 = __decorate([
+  (0, import_CommandClassDecorators.CCCommand)(import_Types.ZWaveProtocolCommand.NodeInformationFrame)
+], ZWaveProtocolCCNodeInformationFrame);
+let ZWaveProtocolCCRequestNodeInformationFrame = class ZWaveProtocolCCRequestNodeInformationFrame2 extends ZWaveProtocolCC {
+};
+ZWaveProtocolCCRequestNodeInformationFrame = __decorate([
+  (0, import_CommandClassDecorators.CCCommand)(import_Types.ZWaveProtocolCommand.RequestNodeInformationFrame),
+  (0, import_CommandClassDecorators.expectedCCResponse)(ZWaveProtocolCCNodeInformationFrame)
+], ZWaveProtocolCCRequestNodeInformationFrame);
+let ZWaveProtocolCCAssignIDs = ZWaveProtocolCCAssignIDs_1 = class ZWaveProtocolCCAssignIDs2 extends ZWaveProtocolCC {
+  constructor(options) {
+    super(options);
+    this.assignedNodeId = options.assignedNodeId;
+    this.homeId = options.homeId;
+  }
+  static from(raw, ctx) {
+    (0, import_core.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 import_safe.Bytes(5);
+    this.payload[0] = this.assignedNodeId;
+    this.payload.writeUInt32BE(this.homeId, 1);
+    return super.serialize(ctx);
+  }
+};
+ZWaveProtocolCCAssignIDs = ZWaveProtocolCCAssignIDs_1 = __decorate([
+  (0, import_CommandClassDecorators.CCCommand)(import_Types.ZWaveProtocolCommand.AssignIDs)
+], ZWaveProtocolCCAssignIDs);
+let ZWaveProtocolCCFindNodesInRange = ZWaveProtocolCCFindNodesInRange_1 = class ZWaveProtocolCCFindNodesInRange2 extends ZWaveProtocolCC {
+  constructor(options) {
+    super(options);
+    this.candidateNodeIds = options.candidateNodeIds;
+    this.wakeUpTime = options.wakeUpTime;
+    this.dataRate = options.dataRate ?? import_core.ZWaveDataRate["9k6"];
+  }
+  static from(raw, ctx) {
+    (0, import_core.validatePayload)(raw.payload.length >= 1);
+    const speedPresent = raw.payload[0] & 128;
+    const bitmaskLength = raw.payload[0] & 31;
+    (0, import_core.validatePayload)(raw.payload.length >= 1 + bitmaskLength);
+    const candidateNodeIds = (0, import_core.parseBitMask)(raw.payload.subarray(1, 1 + bitmaskLength));
+    const rest = raw.payload.subarray(1 + bitmaskLength);
+    let dataRate;
+    let wakeUpTime;
+    if (speedPresent) {
+      (0, import_core.validatePayload)(rest.length >= 1);
+      if (rest.length === 1) {
+        dataRate = rest[0] & 7;
+        wakeUpTime = import_Types.WakeUpTime.None;
+      } else if (rest.length === 2) {
+        wakeUpTime = (0, import_Types.parseWakeUpTime)(rest[0]);
+        dataRate = rest[1] & 7;
+      } else {
+        import_core.validatePayload.fail("Invalid payload length");
+      }
+    } else if (rest.length >= 1) {
+      wakeUpTime = (0, import_Types.parseWakeUpTime)(rest[0]);
+      dataRate = import_core.ZWaveDataRate["9k6"];
+    } else {
+      wakeUpTime = import_Types.WakeUpTime.None;
+      dataRate = import_core.ZWaveDataRate["9k6"];
+    }
+    return new ZWaveProtocolCCFindNodesInRange_1({
+      nodeId: ctx.sourceNodeId,
+      candidateNodeIds,
+      dataRate,
+      wakeUpTime
+    });
+  }
+  candidateNodeIds;
+  wakeUpTime;
+  dataRate;
+  serialize(ctx) {
+    const nodesBitmask = (0, import_core.encodeBitMask)(this.candidateNodeIds, import_core.MAX_NODES);
+    const speedAndLength = 128 | nodesBitmask.length;
+    this.payload = import_safe.Bytes.concat([
+      import_safe.Bytes.from([speedAndLength]),
+      nodesBitmask,
+      import_safe.Bytes.from([this.wakeUpTime, this.dataRate])
+    ]);
+    return super.serialize(ctx);
+  }
+};
+ZWaveProtocolCCFindNodesInRange = ZWaveProtocolCCFindNodesInRange_1 = __decorate([
+  (0, import_CommandClassDecorators.CCCommand)(import_Types.ZWaveProtocolCommand.FindNodesInRange)
+], ZWaveProtocolCCFindNodesInRange);
+let ZWaveProtocolCCRangeInfo = ZWaveProtocolCCRangeInfo_1 = class ZWaveProtocolCCRangeInfo2 extends ZWaveProtocolCC {
+  constructor(options) {
+    super(options);
+    this.neighborNodeIds = options.neighborNodeIds;
+    this.wakeUpTime = options.wakeUpTime;
+  }
+  static from(raw, ctx) {
+    (0, import_core.validatePayload)(raw.payload.length >= 1);
+    const bitmaskLength = raw.payload[0] & 31;
+    (0, import_core.validatePayload)(raw.payload.length >= 1 + bitmaskLength);
+    const neighborNodeIds = (0, import_core.parseBitMask)(raw.payload.subarray(1, 1 + bitmaskLength));
+    let wakeUpTime;
+    if (raw.payload.length >= 2 + bitmaskLength) {
+      wakeUpTime = (0, import_Types.parseWakeUpTime)(raw.payload[1 + bitmaskLength]);
+    }
+    return new ZWaveProtocolCCRangeInfo_1({
+      nodeId: ctx.sourceNodeId,
+      neighborNodeIds,
+      wakeUpTime
+    });
+  }
+  neighborNodeIds;
+  wakeUpTime;
+  serialize(ctx) {
+    const nodesBitmask = (0, import_core.encodeBitMask)(this.neighborNodeIds, import_core.MAX_NODES);
+    this.payload = import_safe.Bytes.concat([
+      import_safe.Bytes.from([nodesBitmask.length]),
+      nodesBitmask,
+      this.wakeUpTime != void 0 ? import_safe.Bytes.from([this.wakeUpTime]) : new import_safe.Bytes()
+    ]);
+    return super.serialize(ctx);
+  }
+};
+ZWaveProtocolCCRangeInfo = ZWaveProtocolCCRangeInfo_1 = __decorate([
+  (0, import_CommandClassDecorators.CCCommand)(import_Types.ZWaveProtocolCommand.RangeInfo)
+], ZWaveProtocolCCRangeInfo);
+let ZWaveProtocolCCGetNodesInRange = class ZWaveProtocolCCGetNodesInRange2 extends ZWaveProtocolCC {
+};
+ZWaveProtocolCCGetNodesInRange = __decorate([
+  (0, import_CommandClassDecorators.CCCommand)(import_Types.ZWaveProtocolCommand.GetNodesInRange),
+  (0, import_CommandClassDecorators.expectedCCResponse)(ZWaveProtocolCCRangeInfo)
+], ZWaveProtocolCCGetNodesInRange);
+let ZWaveProtocolCCCommandComplete = ZWaveProtocolCCCommandComplete_1 = class ZWaveProtocolCCCommandComplete2 extends ZWaveProtocolCC {
+  constructor(options) {
+    super(options);
+    this.sequenceNumber = options.sequenceNumber;
+  }
+  static from(raw, ctx) {
+    (0, import_core.validatePayload)(raw.payload.length >= 1);
+    const sequenceNumber = raw.payload[0];
+    return new ZWaveProtocolCCCommandComplete_1({
+      nodeId: ctx.sourceNodeId,
+      sequenceNumber
+    });
+  }
+  sequenceNumber;
+  serialize(ctx) {
+    this.payload = import_safe.Bytes.from([this.sequenceNumber]);
+    return super.serialize(ctx);
+  }
+};
+ZWaveProtocolCCCommandComplete = ZWaveProtocolCCCommandComplete_1 = __decorate([
+  (0, import_CommandClassDecorators.CCCommand)(import_Types.ZWaveProtocolCommand.CommandComplete)
+], ZWaveProtocolCCCommandComplete);
+let ZWaveProtocolCCTransferPresentation = ZWaveProtocolCCTransferPresentation_1 = class ZWaveProtocolCCTransferPresentation2 extends ZWaveProtocolCC {
+  constructor(options) {
+    super(options);
+    if (options.includeNode && options.excludeNode) {
+      throw new import_core.ZWaveError(`${this.constructor.name}: the includeNode and excludeNode options cannot both be true`, import_core.ZWaveErrorCodes.Argument_Invalid);
+    }
+    this.supportsNWI = options.supportsNWI;
+    this.includeNode = options.includeNode;
+    this.excludeNode = options.excludeNode;
+  }
+  static from(raw, ctx) {
+    (0, import_core.validatePayload)(raw.payload.length >= 1);
+    const option = raw.payload[0];
+    const supportsNWI = !!(option & 1);
+    const excludeNode = !!(option & 2);
+    const includeNode = !!(option & 4);
+    return new ZWaveProtocolCCTransferPresentation_1({
+      nodeId: ctx.sourceNodeId,
+      supportsNWI,
+      excludeNode,
+      includeNode
+    });
+  }
+  supportsNWI;
+  includeNode;
+  excludeNode;
+  serialize(ctx) {
+    this.payload = import_safe.Bytes.from([
+      (this.supportsNWI ? 1 : 0) | (this.excludeNode ? 2 : 0) | (this.includeNode ? 4 : 0)
+    ]);
+    return super.serialize(ctx);
+  }
+};
+ZWaveProtocolCCTransferPresentation = ZWaveProtocolCCTransferPresentation_1 = __decorate([
+  (0, import_CommandClassDecorators.CCCommand)(import_Types.ZWaveProtocolCommand.TransferPresentation)
+], ZWaveProtocolCCTransferPresentation);
+let ZWaveProtocolCCTransferNodeInformation = ZWaveProtocolCCTransferNodeInformation_1 = class ZWaveProtocolCCTransferNodeInformation2 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) {
+    (0, import_core.validatePayload)(raw.payload.length >= 2);
+    const sequenceNumber = raw.payload[0];
+    const sourceNodeId = raw.payload[1];
+    const { info } = (0, import_core.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 = import_safe.Bytes.concat([
+      import_safe.Bytes.from([this.sequenceNumber, this.sourceNodeId]),
+      (0, import_core.encodeNodeProtocolInfoAndDeviceClass)(this)
+    ]);
+    return super.serialize(ctx);
+  }
+};
+ZWaveProtocolCCTransferNodeInformation = ZWaveProtocolCCTransferNodeInformation_1 = __decorate([
+  (0, import_CommandClassDecorators.CCCommand)(import_Types.ZWaveProtocolCommand.TransferNodeInformation)
+], ZWaveProtocolCCTransferNodeInformation);
+let ZWaveProtocolCCTransferRangeInformation = ZWaveProtocolCCTransferRangeInformation_1 = class ZWaveProtocolCCTransferRangeInformation2 extends ZWaveProtocolCC {
+  constructor(options) {
+    super(options);
+    this.sequenceNumber = options.sequenceNumber;
+    this.testedNodeId = options.testedNodeId;
+    this.neighborNodeIds = options.neighborNodeIds;
+  }
+  static from(raw, ctx) {
+    (0, import_core.validatePayload)(raw.payload.length >= 3);
+    const sequenceNumber = raw.payload[0];
+    const testedNodeId = raw.payload[1];
+    const bitmaskLength = raw.payload[2];
+    (0, import_core.validatePayload)(raw.payload.length >= 3 + bitmaskLength);
+    const neighborNodeIds = (0, import_core.parseBitMask)(raw.payload.subarray(3, 3 + bitmaskLength));
+    return new ZWaveProtocolCCTransferRangeInformation_1({
+      nodeId: ctx.sourceNodeId,
+      sequenceNumber,
+      testedNodeId,
+      neighborNodeIds
+    });
+  }
+  sequenceNumber;
+  testedNodeId;
+  neighborNodeIds;
+  serialize(ctx) {
+    const nodesBitmask = (0, import_core.encodeBitMask)(this.neighborNodeIds, import_core.MAX_NODES);
+    this.payload = import_safe.Bytes.concat([
+      import_safe.Bytes.from([
+        this.sequenceNumber,
+        this.testedNodeId,
+        nodesBitmask.length
+      ]),
+      nodesBitmask
+    ]);
+    return super.serialize(ctx);
+  }
+};
+ZWaveProtocolCCTransferRangeInformation = ZWaveProtocolCCTransferRangeInformation_1 = __decorate([
+  (0, import_CommandClassDecorators.CCCommand)(import_Types.ZWaveProtocolCommand.TransferRangeInformation)
+], ZWaveProtocolCCTransferRangeInformation);
+let ZWaveProtocolCCTransferEnd = ZWaveProtocolCCTransferEnd_1 = class ZWaveProtocolCCTransferEnd2 extends ZWaveProtocolCC {
+  constructor(options) {
+    super(options);
+    this.status = options.status;
+  }
+  static from(raw, ctx) {
+    (0, import_core.validatePayload)(raw.payload.length >= 1);
+    const status = raw.payload[0];
+    return new ZWaveProtocolCCTransferEnd_1({
+      nodeId: ctx.sourceNodeId,
+      status
+    });
+  }
+  status;
+  serialize(ctx) {
+    this.payload = import_safe.Bytes.from([this.status]);
+    return super.serialize(ctx);
+  }
+};
+ZWaveProtocolCCTransferEnd = ZWaveProtocolCCTransferEnd_1 = __decorate([
+  (0, import_CommandClassDecorators.CCCommand)(import_Types.ZWaveProtocolCommand.TransferEnd)
+], ZWaveProtocolCCTransferEnd);
+let ZWaveProtocolCCAssignReturnRoute = ZWaveProtocolCCAssignReturnRoute_1 = class ZWaveProtocolCCAssignReturnRoute2 extends ZWaveProtocolCC {
+  constructor(options) {
+    super(options);
+    if (options.repeaters.length > import_core.MAX_REPEATERS) {
+      throw new import_core.ZWaveError(`${this.constructor.name}: too many repeaters`, import_core.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) {
+    (0, import_core.validatePayload)(raw.payload.length >= 7);
+    const destinationNodeId = raw.payload[0];
+    const routeIndex = raw.payload[1] >>> 4;
+    const numRepeaters = raw.payload[1] & 15;
+    const repeaters = [...raw.payload.subarray(2, 2 + numRepeaters)];
+    const speedAndWakeup = raw.payload[2 + numRepeaters];
+    const destinationSpeed = bitmask2DataRate(speedAndWakeup >>> 3 & 7);
+    const destinationWakeUp = speedAndWakeup >>> 1 & 3;
+    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 = import_safe.Bytes.from([
+      this.destinationNodeId,
+      routeByte,
+      ...this.repeaters,
+      speedByte
+    ]);
+    return super.serialize(ctx);
+  }
+};
+ZWaveProtocolCCAssignReturnRoute = ZWaveProtocolCCAssignReturnRoute_1 = __decorate([
+  (0, import_CommandClassDecorators.CCCommand)(import_Types.ZWaveProtocolCommand.AssignReturnRoute)
+], ZWaveProtocolCCAssignReturnRoute);
+let ZWaveProtocolCCNewNodeRegistered = ZWaveProtocolCCNewNodeRegistered_1 = class ZWaveProtocolCCNewNodeRegistered2 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) {
+    (0, import_core.validatePayload)(raw.payload.length >= 1);
+    const newNodeId = raw.payload[0];
+    const nif = (0, import_core.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 = import_safe.Bytes.concat([
+      import_safe.Bytes.from([this.newNodeId]),
+      (0, import_core.encodeNodeInformationFrame)(this)
+    ]);
+    return super.serialize(ctx);
+  }
+};
+ZWaveProtocolCCNewNodeRegistered = ZWaveProtocolCCNewNodeRegistered_1 = __decorate([
+  (0, import_CommandClassDecorators.CCCommand)(import_Types.ZWaveProtocolCommand.NewNodeRegistered)
+], ZWaveProtocolCCNewNodeRegistered);
+let ZWaveProtocolCCNewRangeRegistered = ZWaveProtocolCCNewRangeRegistered_1 = class ZWaveProtocolCCNewRangeRegistered2 extends ZWaveProtocolCC {
+  constructor(options) {
+    super(options);
+    this.testedNodeId = options.testedNodeId;
+    this.neighborNodeIds = options.neighborNodeIds;
+  }
+  static from(raw, ctx) {
+    (0, import_core.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 = (0, import_core.encodeBitMask)(this.neighborNodeIds, import_core.MAX_NODES);
+    this.payload = import_safe.Bytes.concat([
+      import_safe.Bytes.from([this.testedNodeId, nodesBitmask.length]),
+      nodesBitmask
+    ]);
+    return super.serialize(ctx);
+  }
+};
+ZWaveProtocolCCNewRangeRegistered = ZWaveProtocolCCNewRangeRegistered_1 = __decorate([
+  (0, import_CommandClassDecorators.CCCommand)(import_Types.ZWaveProtocolCommand.NewRangeRegistered)
+], ZWaveProtocolCCNewRangeRegistered);
+let ZWaveProtocolCCTransferNewPrimaryControllerComplete = ZWaveProtocolCCTransferNewPrimaryControllerComplete_1 = class ZWaveProtocolCCTransferNewPrimaryControllerComplete2 extends ZWaveProtocolCC {
+  constructor(options) {
+    super(options);
+    this.genericDeviceClass = options.genericDeviceClass;
+  }
+  static from(raw, ctx) {
+    (0, import_core.validatePayload)(raw.payload.length >= 1);
+    const genericDeviceClass = raw.payload[0];
+    return new ZWaveProtocolCCTransferNewPrimaryControllerComplete_1({
+      nodeId: ctx.sourceNodeId,
+      genericDeviceClass
+    });
+  }
+  genericDeviceClass;
+  serialize(ctx) {
+    this.payload = import_safe.Bytes.from([this.genericDeviceClass]);
+    return super.serialize(ctx);
+  }
+};
+ZWaveProtocolCCTransferNewPrimaryControllerComplete = ZWaveProtocolCCTransferNewPrimaryControllerComplete_1 = __decorate([
+  (0, import_CommandClassDecorators.CCCommand)(import_Types.ZWaveProtocolCommand.TransferNewPrimaryControllerComplete)
+], ZWaveProtocolCCTransferNewPrimaryControllerComplete);
+let ZWaveProtocolCCAutomaticControllerUpdateStart = class ZWaveProtocolCCAutomaticControllerUpdateStart2 extends ZWaveProtocolCC {
+};
+ZWaveProtocolCCAutomaticControllerUpdateStart = __decorate([
+  (0, import_CommandClassDecorators.CCCommand)(import_Types.ZWaveProtocolCommand.AutomaticControllerUpdateStart)
+], ZWaveProtocolCCAutomaticControllerUpdateStart);
+let ZWaveProtocolCCSUCNodeID = ZWaveProtocolCCSUCNodeID_1 = class ZWaveProtocolCCSUCNodeID2 extends ZWaveProtocolCC {
+  constructor(options) {
+    super(options);
+    this.sucNodeId = options.sucNodeId;
+    this.isSIS = options.isSIS;
+  }
+  static from(raw, ctx) {
+    (0, import_core.validatePayload)(raw.payload.length >= 1);
+    const sucNodeId = raw.payload[0];
+    const capabilities = raw.payload[1] ?? 0;
+    const isSIS = !!(capabilities & 1);
+    return new ZWaveProtocolCCSUCNodeID_1({
+      nodeId: ctx.sourceNodeId,
+      sucNodeId,
+      isSIS
+    });
+  }
+  sucNodeId;
+  isSIS;
+  serialize(ctx) {
+    this.payload = import_safe.Bytes.from([this.sucNodeId, this.isSIS ? 1 : 0]);
+    return super.serialize(ctx);
+  }
+};
+ZWaveProtocolCCSUCNodeID = ZWaveProtocolCCSUCNodeID_1 = __decorate([
+  (0, import_CommandClassDecorators.CCCommand)(import_Types.ZWaveProtocolCommand.SUCNodeID)
+], ZWaveProtocolCCSUCNodeID);
+let ZWaveProtocolCCSetSUC = ZWaveProtocolCCSetSUC_1 = class ZWaveProtocolCCSetSUC2 extends ZWaveProtocolCC {
+  constructor(options) {
+    super(options);
+    this.enableSIS = options.enableSIS;
+  }
+  static from(raw, ctx) {
+    (0, import_core.validatePayload)(raw.payload.length >= 2);
+    const capabilities = raw.payload[1] ?? 0;
+    const enableSIS = !!(capabilities & 1);
+    return new ZWaveProtocolCCSetSUC_1({
+      nodeId: ctx.sourceNodeId,
+      enableSIS
+    });
+  }
+  enableSIS;
+  serialize(ctx) {
+    this.payload = import_safe.Bytes.from([1, this.enableSIS ? 1 : 0]);
+    return super.serialize(ctx);
+  }
+};
+ZWaveProtocolCCSetSUC = ZWaveProtocolCCSetSUC_1 = __decorate([
+  (0, import_CommandClassDecorators.CCCommand)(import_Types.ZWaveProtocolCommand.SetSUC)
+], ZWaveProtocolCCSetSUC);
+let ZWaveProtocolCCSetSUCAck = ZWaveProtocolCCSetSUCAck_1 = class ZWaveProtocolCCSetSUCAck2 extends ZWaveProtocolCC {
+  constructor(options) {
+    super(options);
+    this.accepted = options.accepted;
+    this.isSIS = options.isSIS;
+  }
+  static from(raw, ctx) {
+    (0, import_core.validatePayload)(raw.payload.length >= 2);
+    const accepted = raw.payload[0] === 1;
+    const capabilities = raw.payload[1] ?? 0;
+    const isSIS = !!(capabilities & 1);
+    return new ZWaveProtocolCCSetSUCAck_1({
+      nodeId: ctx.sourceNodeId,
+      accepted,
+      isSIS
+    });
+  }
+  accepted;
+  isSIS;
+  serialize(ctx) {
+    this.payload = import_safe.Bytes.from([
+      this.accepted ? 1 : 0,
+      this.isSIS ? 1 : 0
+    ]);
+    return super.serialize(ctx);
+  }
+};
+ZWaveProtocolCCSetSUCAck = ZWaveProtocolCCSetSUCAck_1 = __decorate([
+  (0, import_CommandClassDecorators.CCCommand)(import_Types.ZWaveProtocolCommand.SetSUCAck)
+], ZWaveProtocolCCSetSUCAck);
+let ZWaveProtocolCCAssignSUCReturnRoute = class ZWaveProtocolCCAssignSUCReturnRoute2 extends ZWaveProtocolCCAssignReturnRoute {
+};
+ZWaveProtocolCCAssignSUCReturnRoute = __decorate([
+  (0, import_CommandClassDecorators.CCCommand)(import_Types.ZWaveProtocolCommand.AssignSUCReturnRoute)
+], ZWaveProtocolCCAssignSUCReturnRoute);
+let ZWaveProtocolCCStaticRouteRequest = ZWaveProtocolCCStaticRouteRequest_1 = class ZWaveProtocolCCStaticRouteRequest2 extends ZWaveProtocolCC {
+  constructor(options) {
+    super(options);
+    if (options.nodeIds.some((n) => n < 1 || n > import_core.MAX_NODES)) {
+      throw new import_core.ZWaveError(`All node IDs must be between 1 and ${import_core.MAX_NODES}!`, import_core.ZWaveErrorCodes.Argument_Invalid);
+    }
+    this.nodeIds = options.nodeIds;
+  }
+  static from(raw, ctx) {
+    (0, import_core.validatePayload)(raw.payload.length >= 5);
+    const nodeIds = [...raw.payload.subarray(0, 5)].filter((id) => id > 0 && id <= import_core.MAX_NODES);
+    return new ZWaveProtocolCCStaticRouteRequest_1({
+      nodeId: ctx.sourceNodeId,
+      nodeIds
+    });
+  }
+  nodeIds;
+  serialize(ctx) {
+    this.payload = import_safe.Bytes.alloc(5, 0);
+    for (let i = 0; i < this.nodeIds.length && i < 5; i++) {
+      this.payload[i] = this.nodeIds[i];
+    }
+    return super.serialize(ctx);
+  }
+};
+ZWaveProtocolCCStaticRouteRequest = ZWaveProtocolCCStaticRouteRequest_1 = __decorate([
+  (0, import_CommandClassDecorators.CCCommand)(import_Types.ZWaveProtocolCommand.StaticRouteRequest)
+], ZWaveProtocolCCStaticRouteRequest);
+let ZWaveProtocolCCLost = ZWaveProtocolCCLost_1 = class ZWaveProtocolCCLost2 extends ZWaveProtocolCC {
+  constructor(options) {
+    super(options);
+    this.lostNodeId = options.lostNodeId;
+  }
+  static from(raw, ctx) {
+    (0, import_core.validatePayload)(raw.payload.length >= 1);
+    const lostNodeId = raw.payload[0];
+    return new ZWaveProtocolCCLost_1({
+      nodeId: ctx.sourceNodeId,
+      lostNodeId
+    });
+  }
+  lostNodeId;
+  serialize(ctx) {
+    this.payload = import_safe.Bytes.from([this.lostNodeId]);
+    return super.serialize(ctx);
+  }
+};
+ZWaveProtocolCCLost = ZWaveProtocolCCLost_1 = __decorate([
+  (0, import_CommandClassDecorators.CCCommand)(import_Types.ZWaveProtocolCommand.Lost)
+], ZWaveProtocolCCLost);
+let ZWaveProtocolCCAcceptLost = ZWaveProtocolCCAcceptLost_1 = class ZWaveProtocolCCAcceptLost2 extends ZWaveProtocolCC {
+  constructor(options) {
+    super(options);
+    this.accepted = options.accepted;
+  }
+  static from(raw, ctx) {
+    (0, import_core.validatePayload)(raw.payload.length >= 1);
+    (0, import_core.validatePayload)(raw.payload[0] === 4 || raw.payload[0] === 5);
+    const accepted = raw.payload[0] === 5;
+    return new ZWaveProtocolCCAcceptLost_1({
+      nodeId: ctx.sourceNodeId,
+      accepted
+    });
+  }
+  accepted;
+  serialize(ctx) {
+    this.payload = import_safe.Bytes.from([this.accepted ? 5 : 4]);
+    return super.serialize(ctx);
+  }
+};
+ZWaveProtocolCCAcceptLost = ZWaveProtocolCCAcceptLost_1 = __decorate([
+  (0, import_CommandClassDecorators.CCCommand)(import_Types.ZWaveProtocolCommand.AcceptLost)
+], ZWaveProtocolCCAcceptLost);
+let ZWaveProtocolCCNOPPower = ZWaveProtocolCCNOPPower_1 = class ZWaveProtocolCCNOPPower2 extends ZWaveProtocolCC {
+  constructor(options) {
+    super(options);
+    if (options.powerDampening < 0 || options.powerDampening > 14) {
+      throw new import_core.ZWaveError(`${this.constructor.name}: power dampening must be between 0 and 14 dBm!`, import_core.ZWaveErrorCodes.Argument_Invalid);
+    }
+    this.powerDampening = options.powerDampening;
+  }
+  static from(raw, ctx) {
+    let powerDampening;
+    if (raw.payload.length >= 2) {
+      powerDampening = raw.payload[1];
+    } else if (raw.payload.length === 1) {
+      powerDampening = [
+        240,
+        200,
+        167,
+        145,
+        119,
+        103,
+        96,
+        70,
+        56,
+        53,
+        50,
+        48,
+        36,
+        34,
+        32
+      ].indexOf(raw.payload[0]);
+      if (powerDampening === -1)
+        powerDampening = 0;
+    } else {
+      import_core.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 = import_safe.Bytes.from([0, this.powerDampening]);
+    return super.serialize(ctx);
+  }
+};
+ZWaveProtocolCCNOPPower = ZWaveProtocolCCNOPPower_1 = __decorate([
+  (0, import_CommandClassDecorators.CCCommand)(import_Types.ZWaveProtocolCommand.NOPPower)
+], ZWaveProtocolCCNOPPower);
+let ZWaveProtocolCCReservedIDs = ZWaveProtocolCCReservedIDs_1 = class ZWaveProtocolCCReservedIDs2 extends ZWaveProtocolCC {
+  constructor(options) {
+    super(options);
+    this.reservedNodeIDs = options.reservedNodeIDs;
+  }
+  static from(raw, ctx) {
+    (0, import_core.validatePayload)(raw.payload.length >= 1);
+    const numNodeIDs = raw.payload[0];
+    (0, import_core.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 = import_safe.Bytes.from([
+      this.reservedNodeIDs.length,
+      ...this.reservedNodeIDs
+    ]);
+    return super.serialize(ctx);
+  }
+};
+ZWaveProtocolCCReservedIDs = ZWaveProtocolCCReservedIDs_1 = __decorate([
+  (0, import_CommandClassDecorators.CCCommand)(import_Types.ZWaveProtocolCommand.ReservedIDs)
+], ZWaveProtocolCCReservedIDs);
+let ZWaveProtocolCCReserveNodeIDs = ZWaveProtocolCCReserveNodeIDs_1 = class ZWaveProtocolCCReserveNodeIDs2 extends ZWaveProtocolCC {
+  constructor(options) {
+    super(options);
+    this.numNodeIDs = options.numNodeIDs;
+  }
+  static from(raw, ctx) {
+    (0, import_core.validatePayload)(raw.payload.length >= 1);
+    const numNodeIDs = raw.payload[0];
+    return new ZWaveProtocolCCReserveNodeIDs_1({
+      nodeId: ctx.sourceNodeId,
+      numNodeIDs
+    });
+  }
+  numNodeIDs;
+  serialize(ctx) {
+    this.payload = import_safe.Bytes.from([this.numNodeIDs]);
+    return super.serialize(ctx);
+  }
+};
+ZWaveProtocolCCReserveNodeIDs = ZWaveProtocolCCReserveNodeIDs_1 = __decorate([
+  (0, import_CommandClassDecorators.CCCommand)(import_Types.ZWaveProtocolCommand.ReserveNodeIDs),
+  (0, import_CommandClassDecorators.expectedCCResponse)(ZWaveProtocolCCReservedIDs)
+], ZWaveProtocolCCReserveNodeIDs);
+let ZWaveProtocolCCNodesExistReply = ZWaveProtocolCCNodesExistReply_1 = class ZWaveProtocolCCNodesExistReply2 extends ZWaveProtocolCC {
+  constructor(options) {
+    super(options);
+    this.nodeMaskType = options.nodeMaskType;
+    this.nodeListUpdated = options.nodeListUpdated;
+  }
+  static from(raw, ctx) {
+    (0, import_core.validatePayload)(raw.payload.length >= 2);
+    const nodeMaskType = raw.payload[0];
+    const nodeListUpdated = raw.payload[1] === 1;
+    return new ZWaveProtocolCCNodesExistReply_1({
+      nodeId: ctx.sourceNodeId,
+      nodeMaskType,
+      nodeListUpdated
+    });
+  }
+  nodeMaskType;
+  nodeListUpdated;
+  serialize(ctx) {
+    this.payload = import_safe.Bytes.from([
+      this.nodeMaskType,
+      this.nodeListUpdated ? 1 : 0
+    ]);
+    return super.serialize(ctx);
+  }
+};
+ZWaveProtocolCCNodesExistReply = ZWaveProtocolCCNodesExistReply_1 = __decorate([
+  (0, import_CommandClassDecorators.CCCommand)(import_Types.ZWaveProtocolCommand.NodesExistReply)
+], ZWaveProtocolCCNodesExistReply);
+function testResponseForZWaveProtocolNodesExist(sent, received) {
+  return received.nodeMaskType === sent.nodeMaskType;
+}
+let ZWaveProtocolCCNodesExist = ZWaveProtocolCCNodesExist_1 = class ZWaveProtocolCCNodesExist2 extends ZWaveProtocolCC {
+  constructor(options) {
+    super(options);
+    this.nodeMaskType = options.nodeMaskType;
+    this.nodeIDs = options.nodeIDs;
+  }
+  static from(raw, ctx) {
+    (0, import_core.validatePayload)(raw.payload.length >= 2);
+    const nodeMaskType = raw.payload[0];
+    const numNodeIDs = raw.payload[1];
+    (0, import_core.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 = import_safe.Bytes.from([
+      this.nodeMaskType,
+      this.nodeIDs.length,
+      ...this.nodeIDs
+    ]);
+    return super.serialize(ctx);
+  }
+};
+ZWaveProtocolCCNodesExist = ZWaveProtocolCCNodesExist_1 = __decorate([
+  (0, import_CommandClassDecorators.CCCommand)(import_Types.ZWaveProtocolCommand.NodesExist),
+  (0, import_CommandClassDecorators.expectedCCResponse)(ZWaveProtocolCCNodesExistReply, testResponseForZWaveProtocolNodesExist)
+], ZWaveProtocolCCNodesExist);
+let ZWaveProtocolCCSetNWIMode = ZWaveProtocolCCSetNWIMode_1 = class ZWaveProtocolCCSetNWIMode2 extends ZWaveProtocolCC {
+  constructor(options) {
+    super(options);
+    this.enabled = options.enabled;
+    this.timeoutMinutes = options.timeoutMinutes;
+  }
+  static from(raw, ctx) {
+    (0, import_core.validatePayload)(raw.payload.length >= 2);
+    const enabled = raw.payload[0] === 1;
+    const timeoutMinutes = raw.payload[1] || void 0;
+    return new ZWaveProtocolCCSetNWIMode_1({
+      nodeId: ctx.sourceNodeId,
+      enabled,
+      timeoutMinutes
+    });
+  }
+  enabled;
+  timeoutMinutes;
+  serialize(ctx) {
+    this.payload = import_safe.Bytes.from([
+      this.enabled ? 1 : 0,
+      this.timeoutMinutes ?? 0
+    ]);
+    return super.serialize(ctx);
+  }
+};
+ZWaveProtocolCCSetNWIMode = ZWaveProtocolCCSetNWIMode_1 = __decorate([
+  (0, import_CommandClassDecorators.CCCommand)(import_Types.ZWaveProtocolCommand.SetNWIMode)
+], ZWaveProtocolCCSetNWIMode);
+let ZWaveProtocolCCExcludeRequest = class ZWaveProtocolCCExcludeRequest2 extends ZWaveProtocolCCNodeInformationFrame {
+};
+ZWaveProtocolCCExcludeRequest = __decorate([
+  (0, import_CommandClassDecorators.CCCommand)(import_Types.ZWaveProtocolCommand.ExcludeRequest)
+], ZWaveProtocolCCExcludeRequest);
+let ZWaveProtocolCCAssignReturnRoutePriority = ZWaveProtocolCCAssignReturnRoutePriority_1 = class ZWaveProtocolCCAssignReturnRoutePriority2 extends ZWaveProtocolCC {
+  constructor(options) {
+    super(options);
+    this.targetNodeId = options.targetNodeId;
+    this.routeNumber = options.routeNumber;
+  }
+  static from(raw, ctx) {
+    (0, import_core.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 = import_safe.Bytes.from([this.targetNodeId, this.routeNumber]);
+    return super.serialize(ctx);
+  }
+};
+ZWaveProtocolCCAssignReturnRoutePriority = ZWaveProtocolCCAssignReturnRoutePriority_1 = __decorate([
+  (0, import_CommandClassDecorators.CCCommand)(import_Types.ZWaveProtocolCommand.AssignReturnRoutePriority)
+], ZWaveProtocolCCAssignReturnRoutePriority);
+let ZWaveProtocolCCAssignSUCReturnRoutePriority = class ZWaveProtocolCCAssignSUCReturnRoutePriority2 extends ZWaveProtocolCCAssignReturnRoutePriority {
+};
+ZWaveProtocolCCAssignSUCReturnRoutePriority = __decorate([
+  (0, import_CommandClassDecorators.CCCommand)(import_Types.ZWaveProtocolCommand.AssignSUCReturnRoutePriority)
+], ZWaveProtocolCCAssignSUCReturnRoutePriority);
+let ZWaveProtocolCCSmartStartIncludedNodeInformation = ZWaveProtocolCCSmartStartIncludedNodeInformation_1 = class ZWaveProtocolCCSmartStartIncludedNodeInformation2 extends ZWaveProtocolCC {
+  constructor(options) {
+    super(options);
+    if (options.nwiHomeId.length !== 4) {
+      throw new import_core.ZWaveError(`nwiHomeId must have length 4`, import_core.ZWaveErrorCodes.Argument_Invalid);
+    }
+    this.nwiHomeId = options.nwiHomeId;
+  }
+  static from(raw, ctx) {
+    (0, import_core.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 = import_safe.Bytes.from(this.nwiHomeId);
+    return super.serialize(ctx);
+  }
+};
+ZWaveProtocolCCSmartStartIncludedNodeInformation = ZWaveProtocolCCSmartStartIncludedNodeInformation_1 = __decorate([
+  (0, import_CommandClassDecorators.CCCommand)(import_Types.ZWaveProtocolCommand.SmartStartIncludedNodeInformation)
+], ZWaveProtocolCCSmartStartIncludedNodeInformation);
+let ZWaveProtocolCCSmartStartPrime = class ZWaveProtocolCCSmartStartPrime2 extends ZWaveProtocolCCNodeInformationFrame {
+};
+ZWaveProtocolCCSmartStartPrime = __decorate([
+  (0, import_CommandClassDecorators.CCCommand)(import_Types.ZWaveProtocolCommand.SmartStartPrime)
+], ZWaveProtocolCCSmartStartPrime);
+let ZWaveProtocolCCSmartStartInclusionRequest = class ZWaveProtocolCCSmartStartInclusionRequest2 extends ZWaveProtocolCCNodeInformationFrame {
+};
+ZWaveProtocolCCSmartStartInclusionRequest = __decorate([
+  (0, import_CommandClassDecorators.CCCommand)(import_Types.ZWaveProtocolCommand.SmartStartInclusionRequest)
+], ZWaveProtocolCCSmartStartInclusionRequest);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ZWaveProtocolCC,
+  ZWaveProtocolCCAcceptLost,
+  ZWaveProtocolCCAssignIDs,
+  ZWaveProtocolCCAssignReturnRoute,
+  ZWaveProtocolCCAssignReturnRoutePriority,
+  ZWaveProtocolCCAssignSUCReturnRoute,
+  ZWaveProtocolCCAssignSUCReturnRoutePriority,
+  ZWaveProtocolCCAutomaticControllerUpdateStart,
+  ZWaveProtocolCCCommandComplete,
+  ZWaveProtocolCCExcludeRequest,
+  ZWaveProtocolCCFindNodesInRange,
+  ZWaveProtocolCCGetNodesInRange,
+  ZWaveProtocolCCLost,
+  ZWaveProtocolCCNOPPower,
+  ZWaveProtocolCCNewNodeRegistered,
+  ZWaveProtocolCCNewRangeRegistered,
+  ZWaveProtocolCCNodeInformationFrame,
+  ZWaveProtocolCCNodesExist,
+  ZWaveProtocolCCNodesExistReply,
+  ZWaveProtocolCCRangeInfo,
+  ZWaveProtocolCCRequestNodeInformationFrame,
+  ZWaveProtocolCCReserveNodeIDs,
+  ZWaveProtocolCCReservedIDs,
+  ZWaveProtocolCCSUCNodeID,
+  ZWaveProtocolCCSetNWIMode,
+  ZWaveProtocolCCSetSUC,
+  ZWaveProtocolCCSetSUCAck,
+  ZWaveProtocolCCSmartStartIncludedNodeInformation,
+  ZWaveProtocolCCSmartStartInclusionRequest,
+  ZWaveProtocolCCSmartStartPrime,
+  ZWaveProtocolCCStaticRouteRequest,
+  ZWaveProtocolCCTransferEnd,
+  ZWaveProtocolCCTransferNewPrimaryControllerComplete,
+  ZWaveProtocolCCTransferNodeInformation,
+  ZWaveProtocolCCTransferPresentation,
+  ZWaveProtocolCCTransferRangeInformation
+});
+//# sourceMappingURL=ZWaveProtocolCC.js.map