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

package/build/cjs/cc/ProtectionCC.js

@@ -0,0 +1,667 @@
+"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 ProtectionCC_exports = {};
+__export(ProtectionCC_exports, {
+  ProtectionCC: () => ProtectionCC,
+  ProtectionCCAPI: () => ProtectionCCAPI,
+  ProtectionCCExclusiveControlGet: () => ProtectionCCExclusiveControlGet,
+  ProtectionCCExclusiveControlReport: () => ProtectionCCExclusiveControlReport,
+  ProtectionCCExclusiveControlSet: () => ProtectionCCExclusiveControlSet,
+  ProtectionCCGet: () => ProtectionCCGet,
+  ProtectionCCReport: () => ProtectionCCReport,
+  ProtectionCCSet: () => ProtectionCCSet,
+  ProtectionCCSupportedGet: () => ProtectionCCSupportedGet,
+  ProtectionCCSupportedReport: () => ProtectionCCSupportedReport,
+  ProtectionCCTimeoutGet: () => ProtectionCCTimeoutGet,
+  ProtectionCCTimeoutReport: () => ProtectionCCTimeoutReport,
+  ProtectionCCTimeoutSet: () => ProtectionCCTimeoutSet,
+  ProtectionCCValues: () => ProtectionCCValues
+});
+module.exports = __toCommonJS(ProtectionCC_exports);
+var import_safe = require("@zwave-js/core/safe");
+var import_safe2 = require("@zwave-js/shared/safe");
+var import_safe3 = require("@zwave-js/shared/safe");
+var import_strings = require("alcalzone-shared/strings/index.js");
+var import_API = require("../lib/API.js");
+var import_CommandClass = require("../lib/CommandClass.js");
+var import_CommandClassDecorators = require("../lib/CommandClassDecorators.js");
+var import_Values = require("../lib/Values.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 ProtectionCCReport_1, ProtectionCCSupportedReport_1, ProtectionCCExclusiveControlReport_1, ProtectionCCTimeoutReport_1;
+function __assertType(argName, typeName, boundHasError) {
+  const { ZWaveError: ZWaveError2, ZWaveErrorCodes: ZWaveErrorCodes2 } = require("@zwave-js/core");
+  if (boundHasError()) {
+    throw new ZWaveError2(typeName ? `${argName} is not a ${typeName}` : `${argName} has the wrong type`, ZWaveErrorCodes2.Argument_Invalid);
+  }
+}
+const __assertType__LocalProtectionState = ($o) => {
+  function su__1__2__3_eu($o2) {
+    return ![0, 1, 2].includes($o2) ? {} : null;
+  }
+  return su__1__2__3_eu($o);
+};
+const __assertType__optional_RFProtectionState = ($o) => {
+  function su__1__2__3_eu($o2) {
+    return ![0, 1, 2].includes($o2) ? {} : null;
+  }
+  function optional_su__1__2__3_eu($o2) {
+    if ($o2 !== void 0) {
+      const error = su__1__2__3_eu($o2);
+      if (error)
+        return error;
+    }
+    return null;
+  }
+  return optional_su__1__2__3_eu($o);
+};
+const __assertType__number = ($o) => {
+  function _number($o2) {
+    return typeof $o2 !== "number" ? {} : null;
+  }
+  return _number($o);
+};
+const __assertType__Timeout = ($o) => {
+  function _0($o2) {
+    return !($o2 instanceof require("@zwave-js/core/safe").Timeout) ? {} : null;
+  }
+  return _0($o);
+};
+const ProtectionCCValues = Object.freeze({
+  ...import_Values.V.defineStaticCCValues(import_safe.CommandClasses.Protection, {
+    ...import_Values.V.staticProperty("exclusiveControlNodeId", {
+      ...import_safe.ValueMetadata.UInt8,
+      min: 1,
+      max: import_safe.MAX_NODES,
+      label: "Node ID with exclusive control"
+    }, { minVersion: 2 }),
+    ...import_Values.V.staticPropertyWithName("localProtectionState", "local", {
+      ...import_safe.ValueMetadata.Number,
+      label: "Local protection state",
+      states: (0, import_safe.enumValuesToMetadataStates)(import_Types.LocalProtectionState)
+    }),
+    ...import_Values.V.staticPropertyWithName("rfProtectionState", "rf", {
+      ...import_safe.ValueMetadata.Number,
+      label: "RF protection state",
+      states: (0, import_safe.enumValuesToMetadataStates)(import_Types.RFProtectionState)
+    }, { minVersion: 2 }),
+    ...import_Values.V.staticProperty("timeout", {
+      ...import_safe.ValueMetadata.UInt8,
+      label: "RF protection timeout"
+    }, { minVersion: 2 }),
+    ...import_Values.V.staticProperty("supportsExclusiveControl", void 0, {
+      internal: true
+    }),
+    ...import_Values.V.staticProperty("supportsTimeout", void 0, {
+      internal: true
+    }),
+    ...import_Values.V.staticProperty("supportedLocalStates", void 0, {
+      internal: true
+    }),
+    ...import_Values.V.staticProperty("supportedRFStates", void 0, {
+      internal: true
+    })
+  })
+});
+let ProtectionCCAPI = class ProtectionCCAPI2 extends import_API.CCAPI {
+  supportsCommand(cmd) {
+    switch (cmd) {
+      case import_Types.ProtectionCommand.Get:
+        return this.isSinglecast();
+      case import_Types.ProtectionCommand.Set:
+        return true;
+      // This is mandatory
+      case import_Types.ProtectionCommand.SupportedGet:
+        return this.version >= 2 && this.isSinglecast();
+      case import_Types.ProtectionCommand.TimeoutGet:
+      case import_Types.ProtectionCommand.TimeoutSet: {
+        return this.isSinglecast() && this.tryGetValueDB()?.getValue(ProtectionCCValues.supportsTimeout.endpoint(this.endpoint.index));
+      }
+      case import_Types.ProtectionCommand.ExclusiveControlGet:
+      case import_Types.ProtectionCommand.ExclusiveControlSet: {
+        return this.isSinglecast() && this.tryGetValueDB()?.getValue(ProtectionCCValues.supportsExclusiveControl.endpoint(this.endpoint.index));
+      }
+    }
+    return super.supportsCommand(cmd);
+  }
+  get [import_API.SET_VALUE]() {
+    return async function({ property }, value) {
+      const valueDB = this.tryGetValueDB();
+      if (property === "local") {
+        if (typeof value !== "number") {
+          (0, import_API.throwWrongValueType)(this.ccId, property, "number", typeof value);
+        }
+        const rf = valueDB?.getValue(ProtectionCCValues.rfProtectionState.endpoint(this.endpoint.index));
+        return this.set(value, rf);
+      } else if (property === "rf") {
+        if (typeof value !== "number") {
+          (0, import_API.throwWrongValueType)(this.ccId, property, "number", typeof value);
+        }
+        const local = valueDB?.getValue(ProtectionCCValues.localProtectionState.endpoint(this.endpoint.index));
+        return this.set(local ?? import_Types.LocalProtectionState.Unprotected, value);
+      } else if (property === "exclusiveControlNodeId") {
+        if (typeof value !== "number") {
+          (0, import_API.throwWrongValueType)(this.ccId, property, "number", typeof value);
+        }
+        return this.setExclusiveControl(value);
+      } else {
+        (0, import_API.throwUnsupportedProperty)(this.ccId, property);
+      }
+    };
+  }
+  get [import_API.POLL_VALUE]() {
+    return async function({ property }) {
+      switch (property) {
+        case "local":
+        case "rf":
+          return (await this.get())?.[property];
+        case "exclusiveControlNodeId":
+          return this.getExclusiveControl();
+        default:
+          (0, import_API.throwUnsupportedProperty)(this.ccId, property);
+      }
+    };
+  }
+  // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
+  async get() {
+    this.assertSupportsCommand(import_Types.ProtectionCommand, import_Types.ProtectionCommand.Get);
+    const cc = new ProtectionCCGet({
+      nodeId: this.endpoint.nodeId,
+      endpointIndex: this.endpoint.index
+    });
+    const response = await this.host.sendCommand(cc, this.commandOptions);
+    if (response) {
+      return (0, import_safe3.pick)(response, ["local", "rf"]);
+    }
+  }
+  async set(local, rf) {
+    __assertType("local", "LocalProtectionState", __assertType__LocalProtectionState.bind(void 0, local));
+    __assertType("rf", "(optional) RFProtectionState", __assertType__optional_RFProtectionState.bind(void 0, rf));
+    this.assertSupportsCommand(import_Types.ProtectionCommand, import_Types.ProtectionCommand.Set);
+    const cc = new ProtectionCCSet({
+      nodeId: this.endpoint.nodeId,
+      endpointIndex: this.endpoint.index,
+      local,
+      rf
+    });
+    return this.host.sendCommand(cc, this.commandOptions);
+  }
+  // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
+  async getSupported() {
+    this.assertSupportsCommand(import_Types.ProtectionCommand, import_Types.ProtectionCommand.SupportedGet);
+    const cc = new ProtectionCCSupportedGet({
+      nodeId: this.endpoint.nodeId,
+      endpointIndex: this.endpoint.index
+    });
+    const response = await this.host.sendCommand(cc, this.commandOptions);
+    if (response) {
+      return (0, import_safe3.pick)(response, [
+        "supportsExclusiveControl",
+        "supportsTimeout",
+        "supportedLocalStates",
+        "supportedRFStates"
+      ]);
+    }
+  }
+  async getExclusiveControl() {
+    this.assertSupportsCommand(import_Types.ProtectionCommand, import_Types.ProtectionCommand.ExclusiveControlGet);
+    const cc = new ProtectionCCExclusiveControlGet({
+      nodeId: this.endpoint.nodeId,
+      endpointIndex: this.endpoint.index
+    });
+    const response = await this.host.sendCommand(cc, this.commandOptions);
+    return response?.exclusiveControlNodeId;
+  }
+  async setExclusiveControl(nodeId) {
+    __assertType("nodeId", "number", __assertType__number.bind(void 0, nodeId));
+    this.assertSupportsCommand(import_Types.ProtectionCommand, import_Types.ProtectionCommand.ExclusiveControlSet);
+    const cc = new ProtectionCCExclusiveControlSet({
+      nodeId: this.endpoint.nodeId,
+      endpointIndex: this.endpoint.index,
+      exclusiveControlNodeId: nodeId
+    });
+    return this.host.sendCommand(cc, this.commandOptions);
+  }
+  async getTimeout() {
+    this.assertSupportsCommand(import_Types.ProtectionCommand, import_Types.ProtectionCommand.TimeoutGet);
+    const cc = new ProtectionCCTimeoutGet({
+      nodeId: this.endpoint.nodeId,
+      endpointIndex: this.endpoint.index
+    });
+    const response = await this.host.sendCommand(cc, this.commandOptions);
+    return response?.timeout;
+  }
+  async setTimeout(timeout) {
+    __assertType("timeout", "Timeout", __assertType__Timeout.bind(void 0, timeout));
+    this.assertSupportsCommand(import_Types.ProtectionCommand, import_Types.ProtectionCommand.TimeoutSet);
+    const cc = new ProtectionCCTimeoutSet({
+      nodeId: this.endpoint.nodeId,
+      endpointIndex: this.endpoint.index,
+      timeout
+    });
+    return this.host.sendCommand(cc, this.commandOptions);
+  }
+};
+ProtectionCCAPI = __decorate([
+  (0, import_CommandClassDecorators.API)(import_safe.CommandClasses.Protection)
+], ProtectionCCAPI);
+let ProtectionCC = class ProtectionCC2 extends import_CommandClass.CommandClass {
+  async interview(ctx) {
+    const node = this.getNode(ctx);
+    const endpoint = this.getEndpoint(ctx);
+    const api = import_API.CCAPI.create(import_safe.CommandClasses.Protection, ctx, endpoint).withOptions({
+      priority: import_safe.MessagePriority.NodeQuery
+    });
+    ctx.logNode(node.id, {
+      endpoint: this.endpointIndex,
+      message: `Interviewing ${this.ccName}...`,
+      direction: "none"
+    });
+    let hadCriticalTimeout = false;
+    if (api.version >= 2) {
+      ctx.logNode(node.id, {
+        message: "querying protection capabilities...",
+        direction: "outbound"
+      });
+      const resp = await api.getSupported();
+      if (resp) {
+        const logMessage = `received protection capabilities:
+exclusive control:       ${resp.supportsExclusiveControl}
+timeout:                 ${resp.supportsTimeout}
+local protection states: ${resp.supportedLocalStates.map((local) => (0, import_safe3.getEnumMemberName)(import_Types.LocalProtectionState, local)).map((str) => `
+\xB7 ${str}`).join("")}
+RF protection states:    ${resp.supportedRFStates.map((local) => (0, import_safe3.getEnumMemberName)(import_Types.RFProtectionState, local)).map((str) => `
+\xB7 ${str}`).join("")}`;
+        ctx.logNode(node.id, {
+          message: logMessage,
+          direction: "inbound"
+        });
+      } else {
+        hadCriticalTimeout = true;
+      }
+    }
+    await this.refreshValues(ctx);
+    if (!hadCriticalTimeout)
+      this.setInterviewComplete(ctx, true);
+  }
+  async refreshValues(ctx) {
+    const node = this.getNode(ctx);
+    const endpoint = this.getEndpoint(ctx);
+    const api = import_API.CCAPI.create(import_safe.CommandClasses.Protection, ctx, endpoint).withOptions({
+      priority: import_safe.MessagePriority.NodeQuery
+    });
+    const supportsExclusiveControl = !!this.getValue(ctx, ProtectionCCValues.supportsExclusiveControl);
+    const supportsTimeout = !!this.getValue(ctx, ProtectionCCValues.supportsTimeout);
+    ctx.logNode(node.id, {
+      message: "querying protection status...",
+      direction: "outbound"
+    });
+    const protectionResp = await api.get();
+    if (protectionResp) {
+      let logMessage = `received protection status:
+local: ${(0, import_safe3.getEnumMemberName)(import_Types.LocalProtectionState, protectionResp.local)}`;
+      if (protectionResp.rf != void 0) {
+        logMessage += `
+rf     ${(0, import_safe3.getEnumMemberName)(import_Types.RFProtectionState, protectionResp.rf)}`;
+      }
+      ctx.logNode(node.id, {
+        message: logMessage,
+        direction: "inbound"
+      });
+    }
+    if (supportsTimeout) {
+      ctx.logNode(node.id, {
+        message: "querying protection timeout...",
+        direction: "outbound"
+      });
+      const timeout = await api.getTimeout();
+      if (timeout) {
+        ctx.logNode(node.id, {
+          message: `received timeout: ${timeout.toString()}`,
+          direction: "inbound"
+        });
+      }
+    }
+    if (supportsExclusiveControl) {
+      ctx.logNode(node.id, {
+        message: "querying exclusive control node...",
+        direction: "outbound"
+      });
+      const nodeId = await api.getExclusiveControl();
+      if (nodeId != void 0) {
+        ctx.logNode(node.id, {
+          message: (nodeId !== 0 ? `Node ${(0, import_strings.padStart)(nodeId.toString(), 3, "0")}` : `no node`) + ` has exclusive control`,
+          direction: "inbound"
+        });
+      }
+    }
+  }
+};
+ProtectionCC = __decorate([
+  (0, import_CommandClassDecorators.commandClass)(import_safe.CommandClasses.Protection),
+  (0, import_CommandClassDecorators.implementedVersion)(2),
+  (0, import_CommandClassDecorators.ccValues)(ProtectionCCValues)
+], ProtectionCC);
+let ProtectionCCSet = class ProtectionCCSet2 extends ProtectionCC {
+  constructor(options) {
+    super(options);
+    this.local = options.local;
+    this.rf = options.rf;
+  }
+  static from(_raw, _ctx) {
+    throw new import_safe.ZWaveError(`${this.name}: deserialization not implemented`, import_safe.ZWaveErrorCodes.Deserialization_NotImplemented);
+  }
+  local;
+  rf;
+  serialize(ctx) {
+    this.payload = import_safe2.Bytes.from([
+      this.local & 15,
+      (this.rf ?? import_Types.RFProtectionState.Unprotected) & 15
+    ]);
+    const ccVersion = (0, import_CommandClass.getEffectiveCCVersion)(ctx, this);
+    if (ccVersion < 2 && ctx.getDeviceConfig?.(this.nodeId)?.compat?.encodeCCsUsingTargetVersion) {
+      this.payload = this.payload.subarray(0, 1);
+    }
+    return super.serialize(ctx);
+  }
+  toLogEntry(ctx) {
+    const message = {
+      local: (0, import_safe3.getEnumMemberName)(import_Types.LocalProtectionState, this.local)
+    };
+    if (this.rf != void 0) {
+      message.rf = (0, import_safe3.getEnumMemberName)(import_Types.RFProtectionState, this.rf);
+    }
+    return {
+      ...super.toLogEntry(ctx),
+      message
+    };
+  }
+};
+ProtectionCCSet = __decorate([
+  (0, import_CommandClassDecorators.CCCommand)(import_Types.ProtectionCommand.Set),
+  (0, import_CommandClassDecorators.useSupervision)()
+], ProtectionCCSet);
+let ProtectionCCReport = ProtectionCCReport_1 = class ProtectionCCReport2 extends ProtectionCC {
+  constructor(options) {
+    super(options);
+    this.local = options.local;
+    this.rf = options.rf;
+  }
+  static from(raw, ctx) {
+    (0, import_safe.validatePayload)(raw.payload.length >= 1);
+    const local = raw.payload[0] & 15;
+    let rf;
+    if (raw.payload.length >= 2) {
+      rf = raw.payload[1] & 15;
+    }
+    return new ProtectionCCReport_1({
+      nodeId: ctx.sourceNodeId,
+      local,
+      rf
+    });
+  }
+  local;
+  rf;
+  toLogEntry(ctx) {
+    const message = {
+      local: (0, import_safe3.getEnumMemberName)(import_Types.LocalProtectionState, this.local)
+    };
+    if (this.rf != void 0) {
+      message.rf = (0, import_safe3.getEnumMemberName)(import_Types.RFProtectionState, this.rf);
+    }
+    return {
+      ...super.toLogEntry(ctx),
+      message
+    };
+  }
+};
+__decorate([
+  (0, import_CommandClassDecorators.ccValue)(ProtectionCCValues.localProtectionState)
+], ProtectionCCReport.prototype, "local", void 0);
+__decorate([
+  (0, import_CommandClassDecorators.ccValue)(ProtectionCCValues.rfProtectionState)
+], ProtectionCCReport.prototype, "rf", void 0);
+ProtectionCCReport = ProtectionCCReport_1 = __decorate([
+  (0, import_CommandClassDecorators.CCCommand)(import_Types.ProtectionCommand.Report)
+], ProtectionCCReport);
+let ProtectionCCGet = class ProtectionCCGet2 extends ProtectionCC {
+};
+ProtectionCCGet = __decorate([
+  (0, import_CommandClassDecorators.CCCommand)(import_Types.ProtectionCommand.Get),
+  (0, import_CommandClassDecorators.expectedCCResponse)(ProtectionCCReport)
+], ProtectionCCGet);
+let ProtectionCCSupportedReport = ProtectionCCSupportedReport_1 = class ProtectionCCSupportedReport2 extends ProtectionCC {
+  constructor(options) {
+    super(options);
+    this.supportsTimeout = options.supportsTimeout;
+    this.supportsExclusiveControl = options.supportsExclusiveControl;
+    this.supportedLocalStates = options.supportedLocalStates;
+    this.supportedRFStates = options.supportedRFStates;
+  }
+  static from(raw, ctx) {
+    (0, import_safe.validatePayload)(raw.payload.length >= 5);
+    const supportsTimeout = !!(raw.payload[0] & 1);
+    const supportsExclusiveControl = !!(raw.payload[0] & 2);
+    const supportedLocalStates = (0, import_safe.parseBitMask)(raw.payload.subarray(1, 3), import_Types.LocalProtectionState.Unprotected);
+    const supportedRFStates = (0, import_safe.parseBitMask)(raw.payload.subarray(3, 5), import_Types.RFProtectionState.Unprotected);
+    return new ProtectionCCSupportedReport_1({
+      nodeId: ctx.sourceNodeId,
+      supportsTimeout,
+      supportsExclusiveControl,
+      supportedLocalStates,
+      supportedRFStates
+    });
+  }
+  persistValues(ctx) {
+    if (!super.persistValues(ctx))
+      return false;
+    const localStateValue = ProtectionCCValues.localProtectionState;
+    this.setMetadata(ctx, localStateValue, {
+      ...localStateValue.meta,
+      states: (0, import_safe.enumValuesToMetadataStates)(import_Types.LocalProtectionState, this.supportedLocalStates)
+    });
+    const rfStateValue = ProtectionCCValues.rfProtectionState;
+    this.setMetadata(ctx, rfStateValue, {
+      ...rfStateValue.meta,
+      states: (0, import_safe.enumValuesToMetadataStates)(import_Types.RFProtectionState, this.supportedRFStates)
+    });
+    return true;
+  }
+  supportsExclusiveControl;
+  supportsTimeout;
+  supportedLocalStates;
+  supportedRFStates;
+  toLogEntry(ctx) {
+    return {
+      ...super.toLogEntry(ctx),
+      message: {
+        "supports exclusive control": this.supportsExclusiveControl,
+        "supports timeout": this.supportsTimeout,
+        "local protection states": this.supportedLocalStates.map((local) => (0, import_safe3.getEnumMemberName)(import_Types.LocalProtectionState, local)).map((str) => `
+\xB7 ${str}`).join(""),
+        "RF protection states": this.supportedRFStates.map((rf) => (0, import_safe3.getEnumMemberName)(import_Types.RFProtectionState, rf)).map((str) => `
+\xB7 ${str}`).join("")
+      }
+    };
+  }
+};
+__decorate([
+  (0, import_CommandClassDecorators.ccValue)(ProtectionCCValues.supportsExclusiveControl)
+], ProtectionCCSupportedReport.prototype, "supportsExclusiveControl", void 0);
+__decorate([
+  (0, import_CommandClassDecorators.ccValue)(ProtectionCCValues.supportsTimeout)
+], ProtectionCCSupportedReport.prototype, "supportsTimeout", void 0);
+__decorate([
+  (0, import_CommandClassDecorators.ccValue)(ProtectionCCValues.supportedLocalStates)
+], ProtectionCCSupportedReport.prototype, "supportedLocalStates", void 0);
+__decorate([
+  (0, import_CommandClassDecorators.ccValue)(ProtectionCCValues.supportedRFStates)
+], ProtectionCCSupportedReport.prototype, "supportedRFStates", void 0);
+ProtectionCCSupportedReport = ProtectionCCSupportedReport_1 = __decorate([
+  (0, import_CommandClassDecorators.CCCommand)(import_Types.ProtectionCommand.SupportedReport)
+], ProtectionCCSupportedReport);
+let ProtectionCCSupportedGet = class ProtectionCCSupportedGet2 extends ProtectionCC {
+};
+ProtectionCCSupportedGet = __decorate([
+  (0, import_CommandClassDecorators.CCCommand)(import_Types.ProtectionCommand.SupportedGet),
+  (0, import_CommandClassDecorators.expectedCCResponse)(ProtectionCCSupportedReport)
+], ProtectionCCSupportedGet);
+let ProtectionCCExclusiveControlReport = ProtectionCCExclusiveControlReport_1 = class ProtectionCCExclusiveControlReport2 extends ProtectionCC {
+  constructor(options) {
+    super(options);
+    this.exclusiveControlNodeId = options.exclusiveControlNodeId;
+  }
+  static from(raw, ctx) {
+    (0, import_safe.validatePayload)(raw.payload.length >= 1);
+    const exclusiveControlNodeId = raw.payload[0];
+    return new ProtectionCCExclusiveControlReport_1({
+      nodeId: ctx.sourceNodeId,
+      exclusiveControlNodeId
+    });
+  }
+  exclusiveControlNodeId;
+  toLogEntry(ctx) {
+    return {
+      ...super.toLogEntry(ctx),
+      message: {
+        "exclusive control node id": this.exclusiveControlNodeId
+      }
+    };
+  }
+};
+__decorate([
+  (0, import_CommandClassDecorators.ccValue)(ProtectionCCValues.exclusiveControlNodeId)
+], ProtectionCCExclusiveControlReport.prototype, "exclusiveControlNodeId", void 0);
+ProtectionCCExclusiveControlReport = ProtectionCCExclusiveControlReport_1 = __decorate([
+  (0, import_CommandClassDecorators.CCCommand)(import_Types.ProtectionCommand.ExclusiveControlReport)
+], ProtectionCCExclusiveControlReport);
+let ProtectionCCExclusiveControlGet = class ProtectionCCExclusiveControlGet2 extends ProtectionCC {
+};
+ProtectionCCExclusiveControlGet = __decorate([
+  (0, import_CommandClassDecorators.CCCommand)(import_Types.ProtectionCommand.ExclusiveControlGet),
+  (0, import_CommandClassDecorators.expectedCCResponse)(ProtectionCCExclusiveControlReport)
+], ProtectionCCExclusiveControlGet);
+let ProtectionCCExclusiveControlSet = class ProtectionCCExclusiveControlSet2 extends ProtectionCC {
+  constructor(options) {
+    super(options);
+    this.exclusiveControlNodeId = options.exclusiveControlNodeId;
+  }
+  static from(_raw, _ctx) {
+    throw new import_safe.ZWaveError(`${this.name}: deserialization not implemented`, import_safe.ZWaveErrorCodes.Deserialization_NotImplemented);
+  }
+  exclusiveControlNodeId;
+  serialize(ctx) {
+    this.payload = import_safe2.Bytes.from([this.exclusiveControlNodeId]);
+    return super.serialize(ctx);
+  }
+  toLogEntry(ctx) {
+    return {
+      ...super.toLogEntry(ctx),
+      message: {
+        "exclusive control node id": this.exclusiveControlNodeId
+      }
+    };
+  }
+};
+ProtectionCCExclusiveControlSet = __decorate([
+  (0, import_CommandClassDecorators.CCCommand)(import_Types.ProtectionCommand.ExclusiveControlSet),
+  (0, import_CommandClassDecorators.expectedCCResponse)(ProtectionCCReport),
+  (0, import_CommandClassDecorators.useSupervision)()
+], ProtectionCCExclusiveControlSet);
+let ProtectionCCTimeoutReport = ProtectionCCTimeoutReport_1 = class ProtectionCCTimeoutReport2 extends ProtectionCC {
+  constructor(options) {
+    super(options);
+    this.timeout = options.timeout;
+  }
+  static from(raw, ctx) {
+    (0, import_safe.validatePayload)(raw.payload.length >= 1);
+    const timeout = import_safe.Timeout.parse(raw.payload[0]);
+    return new ProtectionCCTimeoutReport_1({
+      nodeId: ctx.sourceNodeId,
+      timeout
+    });
+  }
+  timeout;
+  toLogEntry(ctx) {
+    return {
+      ...super.toLogEntry(ctx),
+      message: { timeout: this.timeout.toString() }
+    };
+  }
+};
+__decorate([
+  (0, import_CommandClassDecorators.ccValue)(ProtectionCCValues.timeout)
+], ProtectionCCTimeoutReport.prototype, "timeout", void 0);
+ProtectionCCTimeoutReport = ProtectionCCTimeoutReport_1 = __decorate([
+  (0, import_CommandClassDecorators.CCCommand)(import_Types.ProtectionCommand.TimeoutReport)
+], ProtectionCCTimeoutReport);
+let ProtectionCCTimeoutGet = class ProtectionCCTimeoutGet2 extends ProtectionCC {
+};
+ProtectionCCTimeoutGet = __decorate([
+  (0, import_CommandClassDecorators.CCCommand)(import_Types.ProtectionCommand.TimeoutGet),
+  (0, import_CommandClassDecorators.expectedCCResponse)(ProtectionCCTimeoutReport)
+], ProtectionCCTimeoutGet);
+let ProtectionCCTimeoutSet = class ProtectionCCTimeoutSet2 extends ProtectionCC {
+  constructor(options) {
+    super(options);
+    this.timeout = options.timeout;
+  }
+  static from(_raw, _ctx) {
+    throw new import_safe.ZWaveError(`${this.name}: deserialization not implemented`, import_safe.ZWaveErrorCodes.Deserialization_NotImplemented);
+  }
+  timeout;
+  serialize(ctx) {
+    this.payload = import_safe2.Bytes.from([this.timeout.serialize()]);
+    return super.serialize(ctx);
+  }
+  toLogEntry(ctx) {
+    return {
+      ...super.toLogEntry(ctx),
+      message: { timeout: this.timeout.toString() }
+    };
+  }
+};
+ProtectionCCTimeoutSet = __decorate([
+  (0, import_CommandClassDecorators.CCCommand)(import_Types.ProtectionCommand.TimeoutSet),
+  (0, import_CommandClassDecorators.expectedCCResponse)(ProtectionCCReport),
+  (0, import_CommandClassDecorators.useSupervision)()
+], ProtectionCCTimeoutSet);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ProtectionCC,
+  ProtectionCCAPI,
+  ProtectionCCExclusiveControlGet,
+  ProtectionCCExclusiveControlReport,
+  ProtectionCCExclusiveControlSet,
+  ProtectionCCGet,
+  ProtectionCCReport,
+  ProtectionCCSet,
+  ProtectionCCSupportedGet,
+  ProtectionCCSupportedReport,
+  ProtectionCCTimeoutGet,
+  ProtectionCCTimeoutReport,
+  ProtectionCCTimeoutSet,
+  ProtectionCCValues
+});
+//# sourceMappingURL=ProtectionCC.js.map