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

package/build/cjs/cc/DoorLockCC.js

@@ -0,0 +1,1366 @@
+"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 DoorLockCC_exports = {};
+__export(DoorLockCC_exports, {
+  DoorLockCC: () => DoorLockCC,
+  DoorLockCCAPI: () => DoorLockCCAPI,
+  DoorLockCCCapabilitiesGet: () => DoorLockCCCapabilitiesGet,
+  DoorLockCCCapabilitiesReport: () => DoorLockCCCapabilitiesReport,
+  DoorLockCCConfigurationGet: () => DoorLockCCConfigurationGet,
+  DoorLockCCConfigurationReport: () => DoorLockCCConfigurationReport,
+  DoorLockCCConfigurationSet: () => DoorLockCCConfigurationSet,
+  DoorLockCCOperationGet: () => DoorLockCCOperationGet,
+  DoorLockCCOperationReport: () => DoorLockCCOperationReport,
+  DoorLockCCOperationSet: () => DoorLockCCOperationSet,
+  DoorLockCCValues: () => DoorLockCCValues
+});
+module.exports = __toCommonJS(DoorLockCC_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_typeguards = require("alcalzone-shared/typeguards/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__DoorLockMode = ($o) => {
+  function su__1__2__3__4__5__6__7__8_eu($o2) {
+    return ![0, 1, 16, 17, 32, 33, 254, 255].includes($o2) ? {} : null;
+  }
+  return su__1__2__3__4__5__6__7__8_eu($o);
+};
+const __assertType__DoorLockCCConfigurationSetOptions = ($o) => {
+  function _6($o2) {
+    return $o2 !== 2 ? {} : null;
+  }
+  function _number($o2) {
+    return typeof $o2 !== "number" ? {} : null;
+  }
+  function _2($o2) {
+    if (typeof $o2 !== "object" || $o2 === null || Array.isArray($o2))
+      return {};
+    if ("operationType" in $o2 && $o2["operationType"] !== void 0) {
+      const error = _6($o2["operationType"]);
+      if (error)
+        return error;
+    } else
+      return {};
+    if ("lockTimeoutConfiguration" in $o2 && $o2["lockTimeoutConfiguration"] !== void 0) {
+      const error = _number($o2["lockTimeoutConfiguration"]);
+      if (error)
+        return error;
+    } else
+      return {};
+    return null;
+  }
+  function _boolean($o2) {
+    return typeof $o2 !== "boolean" ? {} : null;
+  }
+  function st__boolean__boolean__boolean__boolean_et_9_9_9_9($o2) {
+    if (!Array.isArray($o2) || $o2.length < 4 || 4 < $o2.length)
+      return {};
+    {
+      const error = _boolean($o2[0]);
+      if (error)
+        return error;
+    }
+    {
+      const error = _boolean($o2[1]);
+      if (error)
+        return error;
+    }
+    {
+      const error = _boolean($o2[2]);
+      if (error)
+        return error;
+    }
+    {
+      const error = _boolean($o2[3]);
+      if (error)
+        return error;
+    }
+    return null;
+  }
+  function _3($o2) {
+    if (typeof $o2 !== "object" || $o2 === null || Array.isArray($o2))
+      return {};
+    if ("outsideHandlesCanOpenDoorConfiguration" in $o2 && $o2["outsideHandlesCanOpenDoorConfiguration"] !== void 0) {
+      const error = st__boolean__boolean__boolean__boolean_et_9_9_9_9($o2["outsideHandlesCanOpenDoorConfiguration"]);
+      if (error)
+        return error;
+    } else
+      return {};
+    if ("insideHandlesCanOpenDoorConfiguration" in $o2 && $o2["insideHandlesCanOpenDoorConfiguration"] !== void 0) {
+      const error = st__boolean__boolean__boolean__boolean_et_9_9_9_9($o2["insideHandlesCanOpenDoorConfiguration"]);
+      if (error)
+        return error;
+    } else
+      return {};
+    if ("autoRelockTime" in $o2 && $o2["autoRelockTime"] !== void 0) {
+      const error = _number($o2["autoRelockTime"]);
+      if (error)
+        return error;
+    }
+    if ("holdAndReleaseTime" in $o2 && $o2["holdAndReleaseTime"] !== void 0) {
+      const error = _number($o2["holdAndReleaseTime"]);
+      if (error)
+        return error;
+    }
+    if ("twistAssist" in $o2 && $o2["twistAssist"] !== void 0) {
+      const error = _boolean($o2["twistAssist"]);
+      if (error)
+        return error;
+    }
+    if ("blockToBlock" in $o2 && $o2["blockToBlock"] !== void 0) {
+      const error = _boolean($o2["blockToBlock"]);
+      if (error)
+        return error;
+    }
+    return null;
+  }
+  function si__2__3_ei($o2) {
+    const conditions = [_2, _3];
+    for (const condition of conditions) {
+      const error = condition($o2);
+      if (error)
+        return error;
+    }
+    return null;
+  }
+  function _13($o2) {
+    return $o2 !== 1 ? {} : null;
+  }
+  function _undefined($o2) {
+    return $o2 !== void 0 ? {} : null;
+  }
+  function _5($o2) {
+    if (typeof $o2 !== "object" || $o2 === null || Array.isArray($o2))
+      return {};
+    if ("operationType" in $o2 && $o2["operationType"] !== void 0) {
+      const error = _13($o2["operationType"]);
+      if (error)
+        return error;
+    } else
+      return {};
+    if ("lockTimeoutConfiguration" in $o2 && $o2["lockTimeoutConfiguration"] !== void 0) {
+      const error = _undefined($o2["lockTimeoutConfiguration"]);
+      if (error)
+        return error;
+    }
+    return null;
+  }
+  function si__5__3_ei($o2) {
+    const conditions = [_5, _3];
+    for (const condition of conditions) {
+      const error = condition($o2);
+      if (error)
+        return error;
+    }
+    return null;
+  }
+  function su_si__2__3_ei_si__5__3_ei_eu($o2) {
+    const conditions = [si__2__3_ei, si__5__3_ei];
+    for (const condition of conditions) {
+      const error = condition($o2);
+      if (!error)
+        return null;
+    }
+    return {};
+  }
+  return su_si__2__3_ei_si__5__3_ei_eu($o);
+};
+const DoorLockCCValues = Object.freeze({
+  ...import_Values.V.defineStaticCCValues(import_safe.CommandClasses["Door Lock"], {
+    ...import_Values.V.staticProperty("targetMode", {
+      ...import_safe.ValueMetadata.UInt8,
+      label: "Target lock mode",
+      states: (0, import_safe.enumValuesToMetadataStates)(import_Types.DoorLockMode)
+    }),
+    ...import_Values.V.staticProperty("currentMode", {
+      ...import_safe.ValueMetadata.ReadOnlyUInt8,
+      label: "Current lock mode",
+      states: (0, import_safe.enumValuesToMetadataStates)(import_Types.DoorLockMode)
+    }),
+    ...import_Values.V.staticProperty("duration", {
+      ...import_safe.ValueMetadata.ReadOnlyDuration,
+      label: "Remaining duration until target lock mode"
+    }, { minVersion: 3 }),
+    ...import_Values.V.staticProperty("supportedOutsideHandles", void 0, {
+      internal: true,
+      minVersion: 4
+    }),
+    ...import_Values.V.staticProperty("outsideHandlesCanOpenDoorConfiguration", {
+      ...import_safe.ValueMetadata.Any,
+      label: "Which outside handles can open the door (configuration)"
+    }),
+    ...import_Values.V.staticProperty("outsideHandlesCanOpenDoor", {
+      ...import_safe.ValueMetadata.ReadOnly,
+      label: "Which outside handles can open the door (actual status)"
+    }),
+    ...import_Values.V.staticProperty("supportedInsideHandles", void 0, {
+      internal: true,
+      minVersion: 4
+    }),
+    ...import_Values.V.staticProperty("insideHandlesCanOpenDoorConfiguration", {
+      ...import_safe.ValueMetadata.Any,
+      label: "Which inside handles can open the door (configuration)"
+    }),
+    ...import_Values.V.staticProperty("insideHandlesCanOpenDoor", {
+      ...import_safe.ValueMetadata.ReadOnly,
+      label: "Which inside handles can open the door (actual status)"
+    }),
+    ...import_Values.V.staticProperty("operationType", {
+      ...import_safe.ValueMetadata.UInt8,
+      label: "Lock operation type",
+      states: (0, import_safe.enumValuesToMetadataStates)(import_Types.DoorLockOperationType)
+    }),
+    ...import_Values.V.staticProperty("lockTimeoutConfiguration", {
+      ...import_safe.ValueMetadata.UInt16,
+      label: "Duration of timed mode in seconds"
+    }),
+    ...import_Values.V.staticProperty("lockTimeout", {
+      ...import_safe.ValueMetadata.ReadOnlyUInt16,
+      label: "Seconds until lock mode times out"
+    }),
+    ...import_Values.V.staticProperty("autoRelockSupported", void 0, {
+      internal: true,
+      minVersion: 4
+    }),
+    ...import_Values.V.staticProperty("autoRelockTime", {
+      ...import_safe.ValueMetadata.UInt16,
+      label: "Duration in seconds until lock returns to secure state"
+    }, {
+      minVersion: 4,
+      autoCreate: shouldAutoCreateAutoRelockConfigValue
+    }),
+    ...import_Values.V.staticProperty("holdAndReleaseSupported", void 0, {
+      internal: true,
+      minVersion: 4
+    }),
+    ...import_Values.V.staticProperty("holdAndReleaseTime", {
+      ...import_safe.ValueMetadata.UInt16,
+      label: "Duration in seconds the latch stays retracted"
+    }, {
+      minVersion: 4,
+      autoCreate: shouldAutoCreateHoldAndReleaseConfigValue
+    }),
+    ...import_Values.V.staticProperty("twistAssistSupported", void 0, {
+      internal: true,
+      minVersion: 4
+    }),
+    ...import_Values.V.staticProperty("twistAssist", {
+      ...import_safe.ValueMetadata.Boolean,
+      label: "Twist Assist enabled"
+    }, {
+      minVersion: 4,
+      autoCreate: shouldAutoCreateTwistAssistConfigValue
+    }),
+    ...import_Values.V.staticProperty("blockToBlockSupported", void 0, {
+      internal: true,
+      minVersion: 4
+    }),
+    ...import_Values.V.staticProperty("blockToBlock", {
+      ...import_safe.ValueMetadata.Boolean,
+      label: "Block-to-block functionality enabled"
+    }, {
+      minVersion: 4,
+      autoCreate: shouldAutoCreateBlockToBlockConfigValue
+    }),
+    ...import_Values.V.staticProperty("latchSupported", void 0, { internal: true }),
+    ...import_Values.V.staticProperty("latchStatus", {
+      ...import_safe.ValueMetadata.ReadOnly,
+      label: "Current status of the latch"
+    }, {
+      autoCreate: shouldAutoCreateLatchStatusValue
+    }),
+    ...import_Values.V.staticProperty("boltSupported", void 0, { internal: true }),
+    ...import_Values.V.staticProperty("boltStatus", {
+      ...import_safe.ValueMetadata.ReadOnly,
+      label: "Current status of the bolt"
+    }, {
+      autoCreate: shouldAutoCreateBoltStatusValue
+    }),
+    ...import_Values.V.staticProperty("doorSupported", void 0, { internal: true }),
+    ...import_Values.V.staticProperty("doorStatus", {
+      ...import_safe.ValueMetadata.ReadOnly,
+      label: "Current status of the door"
+    }, {
+      autoCreate: shouldAutoCreateDoorStatusValue
+    })
+  })
+});
+function shouldAutoCreateLatchStatusValue(ctx, endpoint) {
+  const valueDB = ctx.tryGetValueDB(endpoint.nodeId);
+  if (!valueDB)
+    return false;
+  return !!valueDB.getValue(DoorLockCCValues.latchSupported.endpoint(endpoint.index));
+}
+function shouldAutoCreateBoltStatusValue(ctx, endpoint) {
+  const valueDB = ctx.tryGetValueDB(endpoint.nodeId);
+  if (!valueDB)
+    return false;
+  return !!valueDB.getValue(DoorLockCCValues.boltSupported.endpoint(endpoint.index));
+}
+function shouldAutoCreateDoorStatusValue(ctx, endpoint) {
+  const valueDB = ctx.tryGetValueDB(endpoint.nodeId);
+  if (!valueDB)
+    return false;
+  return !!valueDB.getValue(DoorLockCCValues.doorSupported.endpoint(endpoint.index));
+}
+function shouldAutoCreateTwistAssistConfigValue(ctx, endpoint) {
+  const valueDB = ctx.tryGetValueDB(endpoint.nodeId);
+  if (!valueDB)
+    return false;
+  return !!valueDB.getValue(DoorLockCCValues.twistAssistSupported.endpoint(endpoint.index));
+}
+function shouldAutoCreateBlockToBlockConfigValue(ctx, endpoint) {
+  const valueDB = ctx.tryGetValueDB(endpoint.nodeId);
+  if (!valueDB)
+    return false;
+  return !!valueDB.getValue(DoorLockCCValues.blockToBlockSupported.endpoint(endpoint.index));
+}
+function shouldAutoCreateAutoRelockConfigValue(ctx, endpoint) {
+  const valueDB = ctx.tryGetValueDB(endpoint.nodeId);
+  if (!valueDB)
+    return false;
+  return !!valueDB.getValue(DoorLockCCValues.autoRelockSupported.endpoint(endpoint.index));
+}
+function shouldAutoCreateHoldAndReleaseConfigValue(ctx, endpoint) {
+  const valueDB = ctx.tryGetValueDB(endpoint.nodeId);
+  if (!valueDB)
+    return false;
+  return !!valueDB.getValue(DoorLockCCValues.holdAndReleaseSupported.endpoint(endpoint.index));
+}
+const configurationSetParameters = [
+  "operationType",
+  "outsideHandlesCanOpenDoorConfiguration",
+  "insideHandlesCanOpenDoorConfiguration",
+  "lockTimeoutConfiguration",
+  "autoRelockTime",
+  "holdAndReleaseTime",
+  "twistAssist",
+  "blockToBlock"
+];
+let DoorLockCCAPI = (() => {
+  let _classDecorators = [(0, import_CommandClassDecorators.API)(import_safe.CommandClasses["Door Lock"])];
+  let _classDescriptor;
+  let _classExtraInitializers = [];
+  let _classThis;
+  let _classSuper = import_API.PhysicalCCAPI;
+  var DoorLockCCAPI2 = 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);
+      DoorLockCCAPI2 = _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.DoorLockCommand.OperationSet:
+        case import_Types.DoorLockCommand.OperationGet:
+        case import_Types.DoorLockCommand.ConfigurationSet:
+        case import_Types.DoorLockCommand.ConfigurationGet:
+          return true;
+        // This is mandatory
+        case import_Types.DoorLockCommand.CapabilitiesGet:
+          return this.version >= 4;
+      }
+      return super.supportsCommand(cmd);
+    }
+    get [import_API.SET_VALUE]() {
+      return async function({ property }, value) {
+        if (property === "targetMode") {
+          if (typeof value !== "number") {
+            (0, import_API.throwWrongValueType)(this.ccId, property, "number", typeof value);
+          }
+          const result = await this.set(value);
+          if ((0, import_safe.supervisedCommandSucceeded)(result)) {
+            this.getValueDB().setValue(DoorLockCCValues.currentMode.endpoint(this.endpoint.index), value);
+          } else {
+            this.schedulePoll({ property }, value);
+          }
+          return result;
+        } else if (typeof property === "string" && configurationSetParameters.includes(property)) {
+          const config = {
+            [property]: value
+          };
+          for (const param of configurationSetParameters) {
+            if (param !== property) {
+              config[param] = this.tryGetValueDB()?.getValue({
+                commandClass: this.ccId,
+                endpoint: this.endpoint.index,
+                property: param
+              });
+            }
+          }
+          const allTrue = [true, true, true, true];
+          if (!config.insideHandlesCanOpenDoorConfiguration) {
+            config.insideHandlesCanOpenDoorConfiguration = allTrue;
+          }
+          if (!config.outsideHandlesCanOpenDoorConfiguration) {
+            config.outsideHandlesCanOpenDoorConfiguration = allTrue;
+          }
+          const result = await this.setConfiguration(config);
+          if (!(0, import_safe.supervisedCommandSucceeded)(result)) {
+            this.schedulePoll({ property }, value);
+          }
+          return result;
+        } else {
+          (0, import_API.throwUnsupportedProperty)(this.ccId, property);
+        }
+      };
+    }
+    get [import_API.POLL_VALUE]() {
+      return async function({ property }) {
+        switch (property) {
+          case "currentMode":
+          case "targetMode":
+          case "duration":
+          case "outsideHandlesCanOpenDoor":
+          case "insideHandlesCanOpenDoor":
+          case "latchStatus":
+          case "boltStatus":
+          case "doorStatus":
+          case "lockTimeout":
+            return (await this.get())?.[property];
+          case "operationType":
+          case "outsideHandlesCanOpenDoorConfiguration":
+          case "insideHandlesCanOpenDoorConfiguration":
+          case "lockTimeoutConfiguration":
+          case "autoRelockTime":
+          case "holdAndReleaseTime":
+          case "twistAssist":
+          case "blockToBlock":
+            return (await this.getConfiguration())?.[property];
+          default:
+            (0, import_API.throwUnsupportedProperty)(this.ccId, property);
+        }
+      };
+    }
+    // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
+    async getCapabilities() {
+      this.assertSupportsCommand(import_Types.DoorLockCommand, import_Types.DoorLockCommand.CapabilitiesGet);
+      const cc = new DoorLockCCCapabilitiesGet({
+        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, [
+          "autoRelockSupported",
+          "blockToBlockSupported",
+          "boltSupported",
+          "doorSupported",
+          "holdAndReleaseSupported",
+          "latchSupported",
+          "twistAssistSupported",
+          "supportedDoorLockModes",
+          "supportedInsideHandles",
+          "supportedOperationTypes",
+          "supportedOutsideHandles"
+        ]);
+      }
+    }
+    // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
+    async get() {
+      this.assertSupportsCommand(import_Types.DoorLockCommand, import_Types.DoorLockCommand.OperationGet);
+      const cc = new DoorLockCCOperationGet({
+        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, [
+          "currentMode",
+          "targetMode",
+          "duration",
+          "outsideHandlesCanOpenDoor",
+          "insideHandlesCanOpenDoor",
+          "latchStatus",
+          "boltStatus",
+          "doorStatus",
+          "lockTimeout"
+        ]);
+      }
+    }
+    async set(mode) {
+      __assertType("mode", "DoorLockMode", __assertType__DoorLockMode.bind(void 0, mode));
+      this.assertSupportsCommand(import_Types.DoorLockCommand, import_Types.DoorLockCommand.OperationSet);
+      const cc = new DoorLockCCOperationSet({
+        nodeId: this.endpoint.nodeId,
+        endpointIndex: this.endpoint.index,
+        mode
+      });
+      return this.host.sendCommand(cc, this.commandOptions);
+    }
+    async setConfiguration(configuration) {
+      __assertType("configuration", "DoorLockCCConfigurationSetOptions", __assertType__DoorLockCCConfigurationSetOptions.bind(void 0, configuration));
+      this.assertSupportsCommand(import_Types.DoorLockCommand, import_Types.DoorLockCommand.ConfigurationSet);
+      const cc = new DoorLockCCConfigurationSet({
+        nodeId: this.endpoint.nodeId,
+        endpointIndex: this.endpoint.index,
+        ...configuration
+      });
+      return this.host.sendCommand(cc, this.commandOptions);
+    }
+    // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
+    async getConfiguration() {
+      this.assertSupportsCommand(import_Types.DoorLockCommand, import_Types.DoorLockCommand.ConfigurationGet);
+      const cc = new DoorLockCCConfigurationGet({
+        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, [
+          "operationType",
+          "outsideHandlesCanOpenDoorConfiguration",
+          "insideHandlesCanOpenDoorConfiguration",
+          "lockTimeoutConfiguration",
+          "autoRelockTime",
+          "holdAndReleaseTime",
+          "twistAssist",
+          "blockToBlock"
+        ]);
+      }
+    }
+  };
+  return DoorLockCCAPI2 = _classThis;
+})();
+let DoorLockCC = (() => {
+  let _classDecorators = [(0, import_CommandClassDecorators.commandClass)(import_safe.CommandClasses["Door Lock"]), (0, import_CommandClassDecorators.implementedVersion)(4), (0, import_CommandClassDecorators.ccValues)(DoorLockCCValues)];
+  let _classDescriptor;
+  let _classExtraInitializers = [];
+  let _classThis;
+  let _classSuper = import_CommandClass.CommandClass;
+  var DoorLockCC2 = 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);
+      DoorLockCC2 = _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["Door Lock"], ctx, endpoint).withOptions({
+        priority: import_safe.MessagePriority.NodeQuery
+      });
+      ctx.logNode(node.id, {
+        endpoint: this.endpointIndex,
+        message: `Interviewing ${this.ccName}...`,
+        direction: "none"
+      });
+      let hadCriticalTimeout = false;
+      let doorSupported = true;
+      let boltSupported = true;
+      let latchSupported = true;
+      if (api.version >= 4) {
+        ctx.logNode(node.id, {
+          endpoint: this.endpointIndex,
+          message: "requesting lock capabilities...",
+          direction: "outbound"
+        });
+        const resp = await api.getCapabilities();
+        if (resp) {
+          const logMessage = `received lock capabilities:
+supported operation types: ${resp.supportedOperationTypes.map((t) => (0, import_safe3.getEnumMemberName)(import_Types.DoorLockOperationType, t)).join(", ")}
+supported door lock modes: ${resp.supportedDoorLockModes.map((t) => (0, import_safe3.getEnumMemberName)(import_Types.DoorLockMode, t)).map((str) => `
+\xB7 ${str}`).join("")}
+supported outside handles: ${resp.supportedOutsideHandles.map(String).join(", ")}
+supported inside handles:  ${resp.supportedInsideHandles.map(String).join(", ")}
+supports door status:      ${resp.doorSupported}
+supports bolt status:      ${resp.boltSupported}
+supports latch status:     ${resp.latchSupported}
+supports auto-relock:      ${resp.autoRelockSupported}
+supports hold-and-release: ${resp.holdAndReleaseSupported}
+supports twist assist:     ${resp.twistAssistSupported}
+supports block to block:   ${resp.blockToBlockSupported}`;
+          ctx.logNode(node.id, {
+            endpoint: this.endpointIndex,
+            message: logMessage,
+            direction: "inbound"
+          });
+          doorSupported = resp.doorSupported;
+          boltSupported = resp.boltSupported;
+          latchSupported = resp.latchSupported;
+          const targetModeValue = DoorLockCCValues.targetMode;
+          this.setMetadata(ctx, targetModeValue, {
+            ...targetModeValue.meta,
+            states: (0, import_safe.enumValuesToMetadataStates)(import_Types.DoorLockMode, resp.supportedDoorLockModes)
+          });
+          const operationTypeValue = DoorLockCCValues.operationType;
+          this.setMetadata(ctx, operationTypeValue, {
+            ...operationTypeValue.meta,
+            states: (0, import_safe.enumValuesToMetadataStates)(import_Types.DoorLockOperationType, resp.supportedOperationTypes)
+          });
+        } else {
+          hadCriticalTimeout = true;
+        }
+      }
+      if (!hadCriticalTimeout) {
+        const doorStatusValue = DoorLockCCValues.doorStatus;
+        if (doorSupported)
+          this.setMetadata(ctx, doorStatusValue);
+        this.setValue(ctx, DoorLockCCValues.doorSupported, doorSupported);
+        const latchStatusValue = DoorLockCCValues.latchStatus;
+        if (latchSupported)
+          this.setMetadata(ctx, latchStatusValue);
+        this.setValue(ctx, DoorLockCCValues.latchSupported, latchSupported);
+        const boltStatusValue = DoorLockCCValues.boltStatus;
+        if (boltSupported)
+          this.setMetadata(ctx, boltStatusValue);
+        this.setValue(ctx, DoorLockCCValues.boltSupported, boltSupported);
+      }
+      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["Door Lock"], ctx, endpoint).withOptions({
+        priority: import_safe.MessagePriority.NodeQuery
+      });
+      ctx.logNode(node.id, {
+        endpoint: this.endpointIndex,
+        message: "requesting lock configuration...",
+        direction: "outbound"
+      });
+      const config = await api.getConfiguration();
+      if (config) {
+        let logMessage = `received lock configuration:
+operation type:                ${(0, import_safe3.getEnumMemberName)(import_Types.DoorLockOperationType, config.operationType)}`;
+        if (config.operationType === import_Types.DoorLockOperationType.Timed) {
+          logMessage += `
+lock timeout:                  ${config.lockTimeoutConfiguration} seconds
+`;
+        }
+        logMessage += `
+outside handles can open door: ${config.outsideHandlesCanOpenDoorConfiguration.map(String).join(", ")}
+inside handles can open door:  ${config.insideHandlesCanOpenDoorConfiguration.map(String).join(", ")}`;
+        if (api.version >= 4) {
+          logMessage += `
+auto-relock time               ${config.autoRelockTime ?? "-"} seconds
+hold-and-release time          ${config.holdAndReleaseTime ?? "-"} seconds
+twist assist                   ${!!config.twistAssist}
+block to block                 ${!!config.blockToBlock}`;
+        }
+        ctx.logNode(node.id, {
+          endpoint: this.endpointIndex,
+          message: logMessage,
+          direction: "inbound"
+        });
+      }
+      ctx.logNode(node.id, {
+        endpoint: this.endpointIndex,
+        message: "requesting current lock status...",
+        direction: "outbound"
+      });
+      const status = await api.get();
+      if (status) {
+        let logMessage = `received lock status:
+current mode:       ${(0, import_safe3.getEnumMemberName)(import_Types.DoorLockMode, status.currentMode)}`;
+        if (status.targetMode != void 0) {
+          logMessage += `
+target mode:        ${(0, import_safe3.getEnumMemberName)(import_Types.DoorLockMode, status.targetMode)}
+remaining duration: ${status.duration?.toString() ?? "undefined"}`;
+        }
+        if (status.lockTimeout != void 0) {
+          logMessage += `
+lock timeout:       ${status.lockTimeout} seconds`;
+        }
+        if (status.doorStatus != void 0) {
+          logMessage += `
+door status:        ${status.doorStatus}`;
+        }
+        if (status.boltStatus != void 0) {
+          logMessage += `
+bolt status:        ${status.boltStatus}`;
+        }
+        if (status.latchStatus != void 0) {
+          logMessage += `
+latch status:       ${status.latchStatus}`;
+        }
+        ctx.logNode(node.id, {
+          endpoint: this.endpointIndex,
+          message: logMessage,
+          direction: "inbound"
+        });
+      }
+    }
+  };
+  return DoorLockCC2 = _classThis;
+})();
+let DoorLockCCOperationSet = (() => {
+  let _classDecorators = [(0, import_CommandClassDecorators.CCCommand)(import_Types.DoorLockCommand.OperationSet), (0, import_CommandClassDecorators.useSupervision)()];
+  let _classDescriptor;
+  let _classExtraInitializers = [];
+  let _classThis;
+  let _classSuper = DoorLockCC;
+  var DoorLockCCOperationSet2 = 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);
+      DoorLockCCOperationSet2 = _classThis = _classDescriptor.value;
+      if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+      __runInitializers(_classThis, _classExtraInitializers);
+    }
+    constructor(options) {
+      super(options);
+      if (options.mode === import_Types.DoorLockMode.Unknown) {
+        throw new import_safe.ZWaveError(`Unknown is not a valid door lock target state!`, import_safe.ZWaveErrorCodes.Argument_Invalid);
+      }
+      this.mode = options.mode;
+    }
+    static from(_raw, _ctx) {
+      throw new import_safe.ZWaveError(`${this.name}: deserialization not implemented`, import_safe.ZWaveErrorCodes.Deserialization_NotImplemented);
+    }
+    mode;
+    serialize(ctx) {
+      this.payload = import_safe2.Bytes.from([this.mode]);
+      return super.serialize(ctx);
+    }
+    toLogEntry(ctx) {
+      return {
+        ...super.toLogEntry(ctx),
+        message: {
+          "target mode": (0, import_safe3.getEnumMemberName)(import_Types.DoorLockMode, this.mode)
+        }
+      };
+    }
+  };
+  return DoorLockCCOperationSet2 = _classThis;
+})();
+let DoorLockCCOperationReport = (() => {
+  let _classDecorators = [(0, import_CommandClassDecorators.CCCommand)(import_Types.DoorLockCommand.OperationReport), (0, import_CommandClassDecorators.ccValueProperty)("currentMode", DoorLockCCValues.currentMode), (0, import_CommandClassDecorators.ccValueProperty)("targetMode", DoorLockCCValues.targetMode), (0, import_CommandClassDecorators.ccValueProperty)("duration", DoorLockCCValues.duration), (0, import_CommandClassDecorators.ccValueProperty)("outsideHandlesCanOpenDoor", DoorLockCCValues.outsideHandlesCanOpenDoor), (0, import_CommandClassDecorators.ccValueProperty)("insideHandlesCanOpenDoor", DoorLockCCValues.insideHandlesCanOpenDoor), (0, import_CommandClassDecorators.ccValueProperty)("lockTimeout", DoorLockCCValues.lockTimeout)];
+  let _classDescriptor;
+  let _classExtraInitializers = [];
+  let _classThis;
+  let _classSuper = DoorLockCC;
+  var DoorLockCCOperationReport2 = 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);
+      DoorLockCCOperationReport2 = _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.currentMode = options.currentMode;
+      this.outsideHandlesCanOpenDoor = options.outsideHandlesCanOpenDoor;
+      this.insideHandlesCanOpenDoor = options.insideHandlesCanOpenDoor;
+      this.doorStatus = options.doorStatus;
+      this.boltStatus = options.boltStatus;
+      this.latchStatus = options.latchStatus;
+      this.lockTimeout = options.lockTimeout;
+      this.targetMode = options.targetMode;
+      this.duration = options.duration;
+    }
+    static from(raw, ctx) {
+      (0, import_safe.validatePayload)(raw.payload.length >= 5);
+      const currentMode = raw.payload[0];
+      const outsideHandlesCanOpenDoor = [
+        !!(raw.payload[1] & 16),
+        !!(raw.payload[1] & 32),
+        !!(raw.payload[1] & 64),
+        !!(raw.payload[1] & 128)
+      ];
+      const insideHandlesCanOpenDoor = [
+        !!(raw.payload[1] & 1),
+        !!(raw.payload[1] & 2),
+        !!(raw.payload[1] & 4),
+        !!(raw.payload[1] & 8)
+      ];
+      const doorStatus = !!(raw.payload[2] & 1) ? "closed" : "open";
+      const boltStatus = !!(raw.payload[2] & 2) ? "unlocked" : "locked";
+      const latchStatus = !!(raw.payload[2] & 4) ? "closed" : "open";
+      const lockTimeoutMinutes = raw.payload[3];
+      const lockTimeoutSeconds = raw.payload[4];
+      let lockTimeout;
+      if (lockTimeoutMinutes <= 253 && lockTimeoutSeconds <= 59) {
+        lockTimeout = lockTimeoutSeconds + lockTimeoutMinutes * 60;
+      }
+      let targetMode;
+      let duration;
+      if (raw.payload.length >= 7) {
+        targetMode = raw.payload[5];
+        duration = import_safe.Duration.parseReport(raw.payload[6]);
+      }
+      return new this({
+        nodeId: ctx.sourceNodeId,
+        currentMode,
+        outsideHandlesCanOpenDoor,
+        insideHandlesCanOpenDoor,
+        doorStatus,
+        boltStatus,
+        latchStatus,
+        lockTimeout,
+        targetMode,
+        duration
+      });
+    }
+    persistValues(ctx) {
+      if (!super.persistValues(ctx))
+        return false;
+      const supportsDoorStatus = !!this.getValue(ctx, DoorLockCCValues.doorSupported);
+      if (supportsDoorStatus) {
+        this.setValue(ctx, DoorLockCCValues.doorStatus, this.doorStatus);
+      }
+      const supportsBoltStatus = !!this.getValue(ctx, DoorLockCCValues.boltSupported);
+      if (supportsBoltStatus) {
+        this.setValue(ctx, DoorLockCCValues.boltStatus, this.boltStatus);
+      }
+      const supportsLatchStatus = !!this.getValue(ctx, DoorLockCCValues.latchSupported);
+      if (supportsLatchStatus) {
+        this.setValue(ctx, DoorLockCCValues.latchStatus, this.latchStatus);
+      }
+      return true;
+    }
+    currentMode;
+    targetMode;
+    duration;
+    outsideHandlesCanOpenDoor;
+    insideHandlesCanOpenDoor;
+    latchStatus;
+    boltStatus;
+    doorStatus;
+    lockTimeout;
+    // in seconds
+    toLogEntry(ctx) {
+      const message = {
+        "current mode": (0, import_safe3.getEnumMemberName)(import_Types.DoorLockMode, this.currentMode),
+        "active outside handles": this.outsideHandlesCanOpenDoor.join(", "),
+        "active inside handles": this.insideHandlesCanOpenDoor.join(", ")
+      };
+      if (this.latchStatus != void 0) {
+        message["latch status"] = this.latchStatus;
+      }
+      if (this.boltStatus != void 0) {
+        message["bolt status"] = this.boltStatus;
+      }
+      if (this.doorStatus != void 0) {
+        message["door status"] = this.doorStatus;
+      }
+      if (this.targetMode != void 0) {
+        message["target mode"] = (0, import_safe3.getEnumMemberName)(import_Types.DoorLockMode, this.targetMode);
+      }
+      if (this.duration != void 0) {
+        message["remaining duration"] = this.duration.toString();
+      }
+      if (this.lockTimeout != void 0) {
+        message["lock timeout"] = `${this.lockTimeout} seconds`;
+      }
+      return {
+        ...super.toLogEntry(ctx),
+        message
+      };
+    }
+  };
+  return DoorLockCCOperationReport2 = _classThis;
+})();
+let DoorLockCCOperationGet = (() => {
+  let _classDecorators = [(0, import_CommandClassDecorators.CCCommand)(import_Types.DoorLockCommand.OperationGet), (0, import_CommandClassDecorators.expectedCCResponse)(DoorLockCCOperationReport)];
+  let _classDescriptor;
+  let _classExtraInitializers = [];
+  let _classThis;
+  let _classSuper = DoorLockCC;
+  var DoorLockCCOperationGet2 = 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);
+      DoorLockCCOperationGet2 = _classThis = _classDescriptor.value;
+      if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+      __runInitializers(_classThis, _classExtraInitializers);
+    }
+  };
+  return DoorLockCCOperationGet2 = _classThis;
+})();
+let DoorLockCCConfigurationReport = (() => {
+  let _classDecorators = [(0, import_CommandClassDecorators.CCCommand)(import_Types.DoorLockCommand.ConfigurationReport), (0, import_CommandClassDecorators.ccValueProperty)("operationType", DoorLockCCValues.operationType), (0, import_CommandClassDecorators.ccValueProperty)("outsideHandlesCanOpenDoorConfiguration", DoorLockCCValues.outsideHandlesCanOpenDoorConfiguration), (0, import_CommandClassDecorators.ccValueProperty)("insideHandlesCanOpenDoorConfiguration", DoorLockCCValues.insideHandlesCanOpenDoorConfiguration), (0, import_CommandClassDecorators.ccValueProperty)("lockTimeoutConfiguration", DoorLockCCValues.lockTimeoutConfiguration)];
+  let _classDescriptor;
+  let _classExtraInitializers = [];
+  let _classThis;
+  let _classSuper = DoorLockCC;
+  var DoorLockCCConfigurationReport2 = 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);
+      DoorLockCCConfigurationReport2 = _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.operationType = options.operationType;
+      this.outsideHandlesCanOpenDoorConfiguration = options.outsideHandlesCanOpenDoorConfiguration;
+      this.insideHandlesCanOpenDoorConfiguration = options.insideHandlesCanOpenDoorConfiguration;
+      this.lockTimeoutConfiguration = options.lockTimeoutConfiguration;
+      this.autoRelockTime = options.autoRelockTime;
+      this.holdAndReleaseTime = options.holdAndReleaseTime;
+      this.twistAssist = options.twistAssist;
+      this.blockToBlock = options.blockToBlock;
+    }
+    static from(raw, ctx) {
+      (0, import_safe.validatePayload)(raw.payload.length >= 4);
+      const operationType = raw.payload[0];
+      const outsideHandlesCanOpenDoorConfiguration = [
+        !!(raw.payload[1] & 16),
+        !!(raw.payload[1] & 32),
+        !!(raw.payload[1] & 64),
+        !!(raw.payload[1] & 128)
+      ];
+      const insideHandlesCanOpenDoorConfiguration = [
+        !!(raw.payload[1] & 1),
+        !!(raw.payload[1] & 2),
+        !!(raw.payload[1] & 4),
+        !!(raw.payload[1] & 8)
+      ];
+      let lockTimeoutConfiguration;
+      if (operationType === import_Types.DoorLockOperationType.Timed) {
+        const lockTimeoutMinutes = raw.payload[2];
+        const lockTimeoutSeconds = raw.payload[3];
+        if (lockTimeoutMinutes <= 253 && lockTimeoutSeconds <= 59) {
+          lockTimeoutConfiguration = lockTimeoutSeconds + lockTimeoutMinutes * 60;
+        }
+      }
+      let autoRelockTime;
+      let holdAndReleaseTime;
+      let twistAssist;
+      let blockToBlock;
+      if (raw.payload.length >= 5) {
+        autoRelockTime = raw.payload.readUInt16BE(4);
+        holdAndReleaseTime = raw.payload.readUInt16BE(6);
+        const flags = raw.payload[8];
+        twistAssist = !!(flags & 1);
+        blockToBlock = !!(flags & 2);
+      }
+      return new this({
+        nodeId: ctx.sourceNodeId,
+        operationType,
+        outsideHandlesCanOpenDoorConfiguration,
+        insideHandlesCanOpenDoorConfiguration,
+        lockTimeoutConfiguration,
+        autoRelockTime,
+        holdAndReleaseTime,
+        twistAssist,
+        blockToBlock
+      });
+    }
+    operationType;
+    outsideHandlesCanOpenDoorConfiguration;
+    insideHandlesCanOpenDoorConfiguration;
+    lockTimeoutConfiguration;
+    // These are not always supported and have to be persisted manually
+    // to avoid unsupported values being exposed to the user
+    autoRelockTime;
+    holdAndReleaseTime;
+    twistAssist;
+    blockToBlock;
+    persistValues(ctx) {
+      if (!super.persistValues(ctx))
+        return false;
+      const supportsAutoRelock = !!this.getValue(ctx, DoorLockCCValues.autoRelockSupported);
+      if (supportsAutoRelock) {
+        this.setValue(ctx, DoorLockCCValues.autoRelockTime, this.autoRelockTime);
+      }
+      const supportsHoldAndRelease = !!this.getValue(ctx, DoorLockCCValues.holdAndReleaseSupported);
+      if (supportsHoldAndRelease) {
+        this.setValue(ctx, DoorLockCCValues.holdAndReleaseTime, this.holdAndReleaseTime);
+      }
+      const supportsTwistAssist = !!this.getValue(ctx, DoorLockCCValues.twistAssistSupported);
+      if (supportsTwistAssist) {
+        this.setValue(ctx, DoorLockCCValues.twistAssist, this.twistAssist);
+      }
+      const supportsBlockToBlock = !!this.getValue(ctx, DoorLockCCValues.blockToBlockSupported);
+      if (supportsBlockToBlock) {
+        this.setValue(ctx, DoorLockCCValues.blockToBlock, this.blockToBlock);
+      }
+      return true;
+    }
+    toLogEntry(ctx) {
+      const message = {
+        "operation type": (0, import_safe3.getEnumMemberName)(import_Types.DoorLockOperationType, this.operationType),
+        "outside handle configuration": this.outsideHandlesCanOpenDoorConfiguration.join(", "),
+        "inside handle configuration": this.insideHandlesCanOpenDoorConfiguration.join(", ")
+      };
+      if (this.lockTimeoutConfiguration != void 0) {
+        message["timed mode duration"] = `${this.lockTimeoutConfiguration} seconds`;
+      }
+      if (this.autoRelockTime != void 0) {
+        message["auto-relock time"] = `${this.autoRelockTime} seconds`;
+      }
+      if (this.holdAndReleaseTime != void 0) {
+        message["hold-and-release time"] = `${this.holdAndReleaseTime} seconds`;
+      }
+      if (this.twistAssist != void 0) {
+        message["twist assist enabled"] = this.twistAssist;
+      }
+      if (this.blockToBlock != void 0) {
+        message["block-to-block enabled"] = this.blockToBlock;
+      }
+      return {
+        ...super.toLogEntry(ctx),
+        message
+      };
+    }
+  };
+  return DoorLockCCConfigurationReport2 = _classThis;
+})();
+let DoorLockCCConfigurationGet = (() => {
+  let _classDecorators = [(0, import_CommandClassDecorators.CCCommand)(import_Types.DoorLockCommand.ConfigurationGet), (0, import_CommandClassDecorators.expectedCCResponse)(DoorLockCCConfigurationReport)];
+  let _classDescriptor;
+  let _classExtraInitializers = [];
+  let _classThis;
+  let _classSuper = DoorLockCC;
+  var DoorLockCCConfigurationGet2 = 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);
+      DoorLockCCConfigurationGet2 = _classThis = _classDescriptor.value;
+      if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+      __runInitializers(_classThis, _classExtraInitializers);
+    }
+  };
+  return DoorLockCCConfigurationGet2 = _classThis;
+})();
+let DoorLockCCConfigurationSet = (() => {
+  let _classDecorators = [(0, import_CommandClassDecorators.CCCommand)(import_Types.DoorLockCommand.ConfigurationSet), (0, import_CommandClassDecorators.useSupervision)()];
+  let _classDescriptor;
+  let _classExtraInitializers = [];
+  let _classThis;
+  let _classSuper = DoorLockCC;
+  var DoorLockCCConfigurationSet2 = 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);
+      DoorLockCCConfigurationSet2 = _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.operationType = options.operationType;
+      this.outsideHandlesCanOpenDoorConfiguration = options.outsideHandlesCanOpenDoorConfiguration;
+      this.insideHandlesCanOpenDoorConfiguration = options.insideHandlesCanOpenDoorConfiguration;
+      this.lockTimeoutConfiguration = options.lockTimeoutConfiguration;
+      this.autoRelockTime = options.autoRelockTime;
+      this.holdAndReleaseTime = options.holdAndReleaseTime;
+      this.twistAssist = options.twistAssist;
+      this.blockToBlock = options.blockToBlock;
+    }
+    static from(_raw, _ctx) {
+      throw new import_safe.ZWaveError(`${this.name}: deserialization not implemented`, import_safe.ZWaveErrorCodes.Deserialization_NotImplemented);
+    }
+    operationType;
+    outsideHandlesCanOpenDoorConfiguration;
+    insideHandlesCanOpenDoorConfiguration;
+    lockTimeoutConfiguration;
+    autoRelockTime;
+    holdAndReleaseTime;
+    twistAssist;
+    blockToBlock;
+    serialize(ctx) {
+      const insideHandles = (0, import_typeguards.isArray)(this.insideHandlesCanOpenDoorConfiguration) ? this.insideHandlesCanOpenDoorConfiguration : [];
+      const outsideHandles = (0, import_typeguards.isArray)(this.outsideHandlesCanOpenDoorConfiguration) ? this.outsideHandlesCanOpenDoorConfiguration : [];
+      const handles = [...insideHandles, ...outsideHandles].map((val, i) => val ? 1 << i : 0).reduce((acc, cur) => acc | cur, 0);
+      let lockTimeoutMinutes;
+      let lockTimeoutSeconds;
+      if (this.operationType === import_Types.DoorLockOperationType.Constant) {
+        lockTimeoutMinutes = lockTimeoutSeconds = 254;
+      } else {
+        lockTimeoutMinutes = Math.floor(this.lockTimeoutConfiguration / 60);
+        lockTimeoutSeconds = this.lockTimeoutConfiguration % 60;
+      }
+      const flags = (this.twistAssist ? 1 : 0) | (this.blockToBlock ? 2 : 0);
+      this.payload = import_safe2.Bytes.from([
+        this.operationType,
+        handles,
+        lockTimeoutMinutes,
+        lockTimeoutSeconds,
+        // placeholder for auto relock time
+        0,
+        0,
+        // placeholder for hold and release time
+        0,
+        0,
+        flags
+      ]);
+      this.payload.writeUInt16BE((this.autoRelockTime ?? 0) & 65535, 4);
+      this.payload.writeUInt16BE((this.holdAndReleaseTime ?? 0) & 65535, 6);
+      return super.serialize(ctx);
+    }
+    toLogEntry(ctx) {
+      const insideHandles = (0, import_typeguards.isArray)(this.insideHandlesCanOpenDoorConfiguration) ? this.insideHandlesCanOpenDoorConfiguration : [];
+      const outsideHandles = (0, import_typeguards.isArray)(this.outsideHandlesCanOpenDoorConfiguration) ? this.outsideHandlesCanOpenDoorConfiguration : [];
+      const message = {
+        "operation type": (0, import_safe3.getEnumMemberName)(import_Types.DoorLockOperationType, this.operationType),
+        "outside handle configuration": outsideHandles.join(", "),
+        "inside handle configuration": insideHandles.join(", ")
+      };
+      if (this.lockTimeoutConfiguration != void 0) {
+        message["timed mode duration"] = `${this.lockTimeoutConfiguration} seconds`;
+      }
+      if (this.autoRelockTime != void 0) {
+        message["auto-relock time"] = `${this.autoRelockTime} seconds`;
+      }
+      if (this.holdAndReleaseTime != void 0) {
+        message["hold-and-release time"] = `${this.holdAndReleaseTime} seconds`;
+      }
+      if (this.twistAssist != void 0) {
+        message["enable twist assist"] = this.twistAssist;
+      }
+      if (this.blockToBlock != void 0) {
+        message["enable block-to-block"] = this.blockToBlock;
+      }
+      return {
+        ...super.toLogEntry(ctx),
+        message
+      };
+    }
+  };
+  return DoorLockCCConfigurationSet2 = _classThis;
+})();
+let DoorLockCCCapabilitiesReport = (() => {
+  let _classDecorators = [(0, import_CommandClassDecorators.CCCommand)(import_Types.DoorLockCommand.CapabilitiesReport), (0, import_CommandClassDecorators.ccValueProperty)("supportedOutsideHandles", DoorLockCCValues.supportedOutsideHandles), (0, import_CommandClassDecorators.ccValueProperty)("supportedInsideHandles", DoorLockCCValues.supportedInsideHandles), (0, import_CommandClassDecorators.ccValueProperty)("autoRelockSupported", DoorLockCCValues.autoRelockSupported), (0, import_CommandClassDecorators.ccValueProperty)("holdAndReleaseSupported", DoorLockCCValues.holdAndReleaseSupported), (0, import_CommandClassDecorators.ccValueProperty)("twistAssistSupported", DoorLockCCValues.twistAssistSupported), (0, import_CommandClassDecorators.ccValueProperty)("blockToBlockSupported", DoorLockCCValues.blockToBlockSupported)];
+  let _classDescriptor;
+  let _classExtraInitializers = [];
+  let _classThis;
+  let _classSuper = DoorLockCC;
+  var DoorLockCCCapabilitiesReport2 = 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);
+      DoorLockCCCapabilitiesReport2 = _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.supportedOperationTypes = options.supportedOperationTypes;
+      this.supportedDoorLockModes = options.supportedDoorLockModes;
+      this.supportedOutsideHandles = options.supportedOutsideHandles;
+      this.supportedInsideHandles = options.supportedInsideHandles;
+      this.doorSupported = options.doorSupported;
+      this.boltSupported = options.boltSupported;
+      this.latchSupported = options.latchSupported;
+      this.blockToBlockSupported = options.blockToBlockSupported;
+      this.twistAssistSupported = options.twistAssistSupported;
+      this.holdAndReleaseSupported = options.holdAndReleaseSupported;
+      this.autoRelockSupported = options.autoRelockSupported;
+    }
+    static from(raw, ctx) {
+      (0, import_safe.validatePayload)(raw.payload.length >= 1);
+      const bitMaskLength = raw.payload[0] & 31;
+      let offset = 1;
+      (0, import_safe.validatePayload)(raw.payload.length >= offset + bitMaskLength + 1);
+      const supportedOperationTypes = (0, import_safe.parseBitMask)(
+        raw.payload.subarray(offset, offset + bitMaskLength),
+        // bit 0 is reserved, bitmask starts at 1
+        0
+      );
+      offset += bitMaskLength;
+      const listLength = raw.payload[offset];
+      offset += 1;
+      (0, import_safe.validatePayload)(raw.payload.length >= offset + listLength + 3);
+      const supportedDoorLockModes = [
+        ...raw.payload.subarray(offset, offset + listLength)
+      ];
+      offset += listLength;
+      const supportedOutsideHandles = [
+        !!(raw.payload[offset] & 16),
+        !!(raw.payload[offset] & 32),
+        !!(raw.payload[offset] & 64),
+        !!(raw.payload[offset] & 128)
+      ];
+      const supportedInsideHandles = [
+        !!(raw.payload[offset] & 1),
+        !!(raw.payload[offset] & 2),
+        !!(raw.payload[offset] & 4),
+        !!(raw.payload[offset] & 8)
+      ];
+      const doorSupported = !!(raw.payload[offset + 1] & 1);
+      const boltSupported = !!(raw.payload[offset + 1] & 2);
+      const latchSupported = !!(raw.payload[offset + 1] & 4);
+      const blockToBlockSupported = !!(raw.payload[offset + 2] & 1);
+      const twistAssistSupported = !!(raw.payload[offset + 2] & 2);
+      const holdAndReleaseSupported = !!(raw.payload[offset + 2] & 4);
+      const autoRelockSupported = !!(raw.payload[offset + 2] & 8);
+      return new this({
+        nodeId: ctx.sourceNodeId,
+        supportedOperationTypes,
+        supportedDoorLockModes,
+        supportedOutsideHandles,
+        supportedInsideHandles,
+        doorSupported,
+        boltSupported,
+        latchSupported,
+        blockToBlockSupported,
+        twistAssistSupported,
+        holdAndReleaseSupported,
+        autoRelockSupported
+      });
+    }
+    supportedOperationTypes;
+    supportedDoorLockModes;
+    supportedOutsideHandles;
+    supportedInsideHandles;
+    // These 3 are not automatically persisted because in CC version 3
+    // we have to assume them to be supported. In v4 we can query this.
+    latchSupported;
+    boltSupported;
+    doorSupported;
+    autoRelockSupported;
+    holdAndReleaseSupported;
+    twistAssistSupported;
+    blockToBlockSupported;
+    toLogEntry(ctx) {
+      return {
+        ...super.toLogEntry(ctx),
+        message: {
+          door: this.doorSupported,
+          bolt: this.boltSupported,
+          latch: this.latchSupported,
+          "block-to-block feature": this.blockToBlockSupported,
+          "twist assist feature": this.twistAssistSupported,
+          "hold-and-release feature": this.holdAndReleaseSupported,
+          "auto-relock feature": this.autoRelockSupported,
+          "operation types": this.supportedOperationTypes.map((t) => `
+\xB7 ${(0, import_safe3.getEnumMemberName)(import_Types.DoorLockOperationType, t)}`).join(""),
+          "door lock modes": this.supportedDoorLockModes.map((t) => `
+\xB7 ${(0, import_safe3.getEnumMemberName)(import_Types.DoorLockMode, t)}`).join(""),
+          "outside handles": this.supportedOutsideHandles.join(", "),
+          "inside handles": this.supportedInsideHandles.join(", ")
+        }
+      };
+    }
+  };
+  return DoorLockCCCapabilitiesReport2 = _classThis;
+})();
+let DoorLockCCCapabilitiesGet = (() => {
+  let _classDecorators = [(0, import_CommandClassDecorators.CCCommand)(import_Types.DoorLockCommand.CapabilitiesGet), (0, import_CommandClassDecorators.expectedCCResponse)(DoorLockCCCapabilitiesReport)];
+  let _classDescriptor;
+  let _classExtraInitializers = [];
+  let _classThis;
+  let _classSuper = DoorLockCC;
+  var DoorLockCCCapabilitiesGet2 = 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);
+      DoorLockCCCapabilitiesGet2 = _classThis = _classDescriptor.value;
+      if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+      __runInitializers(_classThis, _classExtraInitializers);
+    }
+  };
+  return DoorLockCCCapabilitiesGet2 = _classThis;
+})();
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DoorLockCC,
+  DoorLockCCAPI,
+  DoorLockCCCapabilitiesGet,
+  DoorLockCCCapabilitiesReport,
+  DoorLockCCConfigurationGet,
+  DoorLockCCConfigurationReport,
+  DoorLockCCConfigurationSet,
+  DoorLockCCOperationGet,
+  DoorLockCCOperationReport,
+  DoorLockCCOperationSet,
+  DoorLockCCValues
+});
+//# sourceMappingURL=DoorLockCC.js.map