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

package/build/cjs/cc/ProtectionCC.js

@@ -0,0 +1,859 @@
+"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 __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 = 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;
+};
+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 = (() => {
+  let _classDecorators = [(0, import_CommandClassDecorators.API)(import_safe.CommandClasses.Protection)];
+  let _classDescriptor;
+  let _classExtraInitializers = [];
+  let _classThis;
+  let _classSuper = import_API.CCAPI;
+  var ProtectionCCAPI2 = 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);
+      ProtectionCCAPI2 = _classThis = _classDescriptor.value;
+      if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+      __runInitializers(_classThis, _classExtraInitializers);
+    }
+    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);
+    }
+  };
+  return ProtectionCCAPI2 = _classThis;
+})();
+let ProtectionCC = (() => {
+  let _classDecorators = [(0, import_CommandClassDecorators.commandClass)(import_safe.CommandClasses.Protection), (0, import_CommandClassDecorators.implementedVersion)(2), (0, import_CommandClassDecorators.ccValues)(ProtectionCCValues)];
+  let _classDescriptor;
+  let _classExtraInitializers = [];
+  let _classThis;
+  let _classSuper = import_CommandClass.CommandClass;
+  var ProtectionCC2 = 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);
+      ProtectionCC2 = _classThis = _classDescriptor.value;
+      if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+      __runInitializers(_classThis, _classExtraInitializers);
+    }
+    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"
+          });
+        }
+      }
+    }
+  };
+  return ProtectionCC2 = _classThis;
+})();
+let ProtectionCCSet = (() => {
+  let _classDecorators = [(0, import_CommandClassDecorators.CCCommand)(import_Types.ProtectionCommand.Set), (0, import_CommandClassDecorators.useSupervision)()];
+  let _classDescriptor;
+  let _classExtraInitializers = [];
+  let _classThis;
+  let _classSuper = ProtectionCC;
+  var ProtectionCCSet2 = 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);
+      ProtectionCCSet2 = _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.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
+      };
+    }
+  };
+  return ProtectionCCSet2 = _classThis;
+})();
+let ProtectionCCReport = (() => {
+  let _classDecorators = [(0, import_CommandClassDecorators.CCCommand)(import_Types.ProtectionCommand.Report), (0, import_CommandClassDecorators.ccValueProperty)("local", ProtectionCCValues.localProtectionState), (0, import_CommandClassDecorators.ccValueProperty)("rf", ProtectionCCValues.rfProtectionState)];
+  let _classDescriptor;
+  let _classExtraInitializers = [];
+  let _classThis;
+  let _classSuper = ProtectionCC;
+  var ProtectionCCReport2 = 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);
+      ProtectionCCReport2 = _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.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 this({
+        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
+      };
+    }
+  };
+  return ProtectionCCReport2 = _classThis;
+})();
+let ProtectionCCGet = (() => {
+  let _classDecorators = [(0, import_CommandClassDecorators.CCCommand)(import_Types.ProtectionCommand.Get), (0, import_CommandClassDecorators.expectedCCResponse)(ProtectionCCReport)];
+  let _classDescriptor;
+  let _classExtraInitializers = [];
+  let _classThis;
+  let _classSuper = ProtectionCC;
+  var ProtectionCCGet2 = 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);
+      ProtectionCCGet2 = _classThis = _classDescriptor.value;
+      if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+      __runInitializers(_classThis, _classExtraInitializers);
+    }
+  };
+  return ProtectionCCGet2 = _classThis;
+})();
+let ProtectionCCSupportedReport = (() => {
+  let _classDecorators = [(0, import_CommandClassDecorators.CCCommand)(import_Types.ProtectionCommand.SupportedReport), (0, import_CommandClassDecorators.ccValueProperty)("supportsExclusiveControl", ProtectionCCValues.supportsExclusiveControl), (0, import_CommandClassDecorators.ccValueProperty)("supportsTimeout", ProtectionCCValues.supportsTimeout), (0, import_CommandClassDecorators.ccValueProperty)("supportedLocalStates", ProtectionCCValues.supportedLocalStates), (0, import_CommandClassDecorators.ccValueProperty)("supportedRFStates", ProtectionCCValues.supportedRFStates)];
+  let _classDescriptor;
+  let _classExtraInitializers = [];
+  let _classThis;
+  let _classSuper = ProtectionCC;
+  var ProtectionCCSupportedReport2 = 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);
+      ProtectionCCSupportedReport2 = _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.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 this({
+        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("")
+        }
+      };
+    }
+  };
+  return ProtectionCCSupportedReport2 = _classThis;
+})();
+let ProtectionCCSupportedGet = (() => {
+  let _classDecorators = [(0, import_CommandClassDecorators.CCCommand)(import_Types.ProtectionCommand.SupportedGet), (0, import_CommandClassDecorators.expectedCCResponse)(ProtectionCCSupportedReport)];
+  let _classDescriptor;
+  let _classExtraInitializers = [];
+  let _classThis;
+  let _classSuper = ProtectionCC;
+  var ProtectionCCSupportedGet2 = 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);
+      ProtectionCCSupportedGet2 = _classThis = _classDescriptor.value;
+      if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+      __runInitializers(_classThis, _classExtraInitializers);
+    }
+  };
+  return ProtectionCCSupportedGet2 = _classThis;
+})();
+let ProtectionCCExclusiveControlReport = (() => {
+  let _classDecorators = [(0, import_CommandClassDecorators.CCCommand)(import_Types.ProtectionCommand.ExclusiveControlReport), (0, import_CommandClassDecorators.ccValueProperty)("exclusiveControlNodeId", ProtectionCCValues.exclusiveControlNodeId)];
+  let _classDescriptor;
+  let _classExtraInitializers = [];
+  let _classThis;
+  let _classSuper = ProtectionCC;
+  var ProtectionCCExclusiveControlReport2 = 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);
+      ProtectionCCExclusiveControlReport2 = _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.exclusiveControlNodeId = options.exclusiveControlNodeId;
+    }
+    static from(raw, ctx) {
+      (0, import_safe.validatePayload)(raw.payload.length >= 1);
+      const exclusiveControlNodeId = raw.payload[0];
+      return new this({
+        nodeId: ctx.sourceNodeId,
+        exclusiveControlNodeId
+      });
+    }
+    exclusiveControlNodeId;
+    toLogEntry(ctx) {
+      return {
+        ...super.toLogEntry(ctx),
+        message: {
+          "exclusive control node id": this.exclusiveControlNodeId
+        }
+      };
+    }
+  };
+  return ProtectionCCExclusiveControlReport2 = _classThis;
+})();
+let ProtectionCCExclusiveControlGet = (() => {
+  let _classDecorators = [(0, import_CommandClassDecorators.CCCommand)(import_Types.ProtectionCommand.ExclusiveControlGet), (0, import_CommandClassDecorators.expectedCCResponse)(ProtectionCCExclusiveControlReport)];
+  let _classDescriptor;
+  let _classExtraInitializers = [];
+  let _classThis;
+  let _classSuper = ProtectionCC;
+  var ProtectionCCExclusiveControlGet2 = 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);
+      ProtectionCCExclusiveControlGet2 = _classThis = _classDescriptor.value;
+      if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+      __runInitializers(_classThis, _classExtraInitializers);
+    }
+  };
+  return ProtectionCCExclusiveControlGet2 = _classThis;
+})();
+let ProtectionCCExclusiveControlSet = (() => {
+  let _classDecorators = [(0, import_CommandClassDecorators.CCCommand)(import_Types.ProtectionCommand.ExclusiveControlSet), (0, import_CommandClassDecorators.expectedCCResponse)(ProtectionCCReport), (0, import_CommandClassDecorators.useSupervision)()];
+  let _classDescriptor;
+  let _classExtraInitializers = [];
+  let _classThis;
+  let _classSuper = ProtectionCC;
+  var ProtectionCCExclusiveControlSet2 = 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);
+      ProtectionCCExclusiveControlSet2 = _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.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
+        }
+      };
+    }
+  };
+  return ProtectionCCExclusiveControlSet2 = _classThis;
+})();
+let ProtectionCCTimeoutReport = (() => {
+  let _classDecorators = [(0, import_CommandClassDecorators.CCCommand)(import_Types.ProtectionCommand.TimeoutReport), (0, import_CommandClassDecorators.ccValueProperty)("timeout", ProtectionCCValues.timeout)];
+  let _classDescriptor;
+  let _classExtraInitializers = [];
+  let _classThis;
+  let _classSuper = ProtectionCC;
+  var ProtectionCCTimeoutReport2 = 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);
+      ProtectionCCTimeoutReport2 = _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.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 this({
+        nodeId: ctx.sourceNodeId,
+        timeout
+      });
+    }
+    timeout;
+    toLogEntry(ctx) {
+      return {
+        ...super.toLogEntry(ctx),
+        message: { timeout: this.timeout.toString() }
+      };
+    }
+  };
+  return ProtectionCCTimeoutReport2 = _classThis;
+})();
+let ProtectionCCTimeoutGet = (() => {
+  let _classDecorators = [(0, import_CommandClassDecorators.CCCommand)(import_Types.ProtectionCommand.TimeoutGet), (0, import_CommandClassDecorators.expectedCCResponse)(ProtectionCCTimeoutReport)];
+  let _classDescriptor;
+  let _classExtraInitializers = [];
+  let _classThis;
+  let _classSuper = ProtectionCC;
+  var ProtectionCCTimeoutGet2 = 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);
+      ProtectionCCTimeoutGet2 = _classThis = _classDescriptor.value;
+      if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+      __runInitializers(_classThis, _classExtraInitializers);
+    }
+  };
+  return ProtectionCCTimeoutGet2 = _classThis;
+})();
+let ProtectionCCTimeoutSet = (() => {
+  let _classDecorators = [(0, import_CommandClassDecorators.CCCommand)(import_Types.ProtectionCommand.TimeoutSet), (0, import_CommandClassDecorators.expectedCCResponse)(ProtectionCCReport), (0, import_CommandClassDecorators.useSupervision)()];
+  let _classDescriptor;
+  let _classExtraInitializers = [];
+  let _classThis;
+  let _classSuper = ProtectionCC;
+  var ProtectionCCTimeoutSet2 = 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);
+      ProtectionCCTimeoutSet2 = _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.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() }
+      };
+    }
+  };
+  return ProtectionCCTimeoutSet2 = _classThis;
+})();
+// 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