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

package/build/cjs/cc/DoorLockCC.js

@@ -0,0 +1,1239 @@
+"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 __decorate = function(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var DoorLockCCOperationReport_1, DoorLockCCConfigurationReport_1, DoorLockCCCapabilitiesReport_1;
+function __assertType(argName, typeName, boundHasError) {
+  const { ZWaveError: ZWaveError2, ZWaveErrorCodes: ZWaveErrorCodes2 } = require("@zwave-js/core");
+  if (boundHasError()) {
+    throw new ZWaveError2(typeName ? `${argName} is not a ${typeName}` : `${argName} has the wrong type`, ZWaveErrorCodes2.Argument_Invalid);
+  }
+}
+const __assertType__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 = class DoorLockCCAPI2 extends import_API.PhysicalCCAPI {
+  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"
+      ]);
+    }
+  }
+};
+DoorLockCCAPI = __decorate([
+  (0, import_CommandClassDecorators.API)(import_safe.CommandClasses["Door Lock"])
+], DoorLockCCAPI);
+let DoorLockCC = class DoorLockCC2 extends import_CommandClass.CommandClass {
+  async interview(ctx) {
+    const node = this.getNode(ctx);
+    const endpoint = this.getEndpoint(ctx);
+    const api = import_API.CCAPI.create(import_safe.CommandClasses["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"
+      });
+    }
+  }
+};
+DoorLockCC = __decorate([
+  (0, import_CommandClassDecorators.commandClass)(import_safe.CommandClasses["Door Lock"]),
+  (0, import_CommandClassDecorators.implementedVersion)(4),
+  (0, import_CommandClassDecorators.ccValues)(DoorLockCCValues)
+], DoorLockCC);
+let DoorLockCCOperationSet = class DoorLockCCOperationSet2 extends DoorLockCC {
+  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)
+      }
+    };
+  }
+};
+DoorLockCCOperationSet = __decorate([
+  (0, import_CommandClassDecorators.CCCommand)(import_Types.DoorLockCommand.OperationSet),
+  (0, import_CommandClassDecorators.useSupervision)()
+], DoorLockCCOperationSet);
+let DoorLockCCOperationReport = DoorLockCCOperationReport_1 = class DoorLockCCOperationReport2 extends DoorLockCC {
+  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 DoorLockCCOperationReport_1({
+      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
+    };
+  }
+};
+__decorate([
+  (0, import_CommandClassDecorators.ccValue)(DoorLockCCValues.currentMode)
+], DoorLockCCOperationReport.prototype, "currentMode", void 0);
+__decorate([
+  (0, import_CommandClassDecorators.ccValue)(DoorLockCCValues.targetMode)
+], DoorLockCCOperationReport.prototype, "targetMode", void 0);
+__decorate([
+  (0, import_CommandClassDecorators.ccValue)(DoorLockCCValues.duration)
+], DoorLockCCOperationReport.prototype, "duration", void 0);
+__decorate([
+  (0, import_CommandClassDecorators.ccValue)(DoorLockCCValues.outsideHandlesCanOpenDoor)
+], DoorLockCCOperationReport.prototype, "outsideHandlesCanOpenDoor", void 0);
+__decorate([
+  (0, import_CommandClassDecorators.ccValue)(DoorLockCCValues.insideHandlesCanOpenDoor)
+], DoorLockCCOperationReport.prototype, "insideHandlesCanOpenDoor", void 0);
+__decorate([
+  (0, import_CommandClassDecorators.ccValue)(DoorLockCCValues.lockTimeout)
+], DoorLockCCOperationReport.prototype, "lockTimeout", void 0);
+DoorLockCCOperationReport = DoorLockCCOperationReport_1 = __decorate([
+  (0, import_CommandClassDecorators.CCCommand)(import_Types.DoorLockCommand.OperationReport)
+], DoorLockCCOperationReport);
+let DoorLockCCOperationGet = class DoorLockCCOperationGet2 extends DoorLockCC {
+};
+DoorLockCCOperationGet = __decorate([
+  (0, import_CommandClassDecorators.CCCommand)(import_Types.DoorLockCommand.OperationGet),
+  (0, import_CommandClassDecorators.expectedCCResponse)(DoorLockCCOperationReport)
+], DoorLockCCOperationGet);
+let DoorLockCCConfigurationReport = DoorLockCCConfigurationReport_1 = class DoorLockCCConfigurationReport2 extends DoorLockCC {
+  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 DoorLockCCConfigurationReport_1({
+      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
+    };
+  }
+};
+__decorate([
+  (0, import_CommandClassDecorators.ccValue)(DoorLockCCValues.operationType)
+], DoorLockCCConfigurationReport.prototype, "operationType", void 0);
+__decorate([
+  (0, import_CommandClassDecorators.ccValue)(DoorLockCCValues.outsideHandlesCanOpenDoorConfiguration)
+], DoorLockCCConfigurationReport.prototype, "outsideHandlesCanOpenDoorConfiguration", void 0);
+__decorate([
+  (0, import_CommandClassDecorators.ccValue)(DoorLockCCValues.insideHandlesCanOpenDoorConfiguration)
+], DoorLockCCConfigurationReport.prototype, "insideHandlesCanOpenDoorConfiguration", void 0);
+__decorate([
+  (0, import_CommandClassDecorators.ccValue)(DoorLockCCValues.lockTimeoutConfiguration)
+], DoorLockCCConfigurationReport.prototype, "lockTimeoutConfiguration", void 0);
+DoorLockCCConfigurationReport = DoorLockCCConfigurationReport_1 = __decorate([
+  (0, import_CommandClassDecorators.CCCommand)(import_Types.DoorLockCommand.ConfigurationReport)
+], DoorLockCCConfigurationReport);
+let DoorLockCCConfigurationGet = class DoorLockCCConfigurationGet2 extends DoorLockCC {
+};
+DoorLockCCConfigurationGet = __decorate([
+  (0, import_CommandClassDecorators.CCCommand)(import_Types.DoorLockCommand.ConfigurationGet),
+  (0, import_CommandClassDecorators.expectedCCResponse)(DoorLockCCConfigurationReport)
+], DoorLockCCConfigurationGet);
+let DoorLockCCConfigurationSet = class DoorLockCCConfigurationSet2 extends DoorLockCC {
+  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
+    };
+  }
+};
+DoorLockCCConfigurationSet = __decorate([
+  (0, import_CommandClassDecorators.CCCommand)(import_Types.DoorLockCommand.ConfigurationSet),
+  (0, import_CommandClassDecorators.useSupervision)()
+], DoorLockCCConfigurationSet);
+let DoorLockCCCapabilitiesReport = DoorLockCCCapabilitiesReport_1 = class DoorLockCCCapabilitiesReport2 extends DoorLockCC {
+  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 DoorLockCCCapabilitiesReport_1({
+      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(", ")
+      }
+    };
+  }
+};
+__decorate([
+  (0, import_CommandClassDecorators.ccValue)(DoorLockCCValues.supportedOutsideHandles)
+], DoorLockCCCapabilitiesReport.prototype, "supportedOutsideHandles", void 0);
+__decorate([
+  (0, import_CommandClassDecorators.ccValue)(DoorLockCCValues.supportedInsideHandles)
+], DoorLockCCCapabilitiesReport.prototype, "supportedInsideHandles", void 0);
+__decorate([
+  (0, import_CommandClassDecorators.ccValue)(DoorLockCCValues.autoRelockSupported)
+], DoorLockCCCapabilitiesReport.prototype, "autoRelockSupported", void 0);
+__decorate([
+  (0, import_CommandClassDecorators.ccValue)(DoorLockCCValues.holdAndReleaseSupported)
+], DoorLockCCCapabilitiesReport.prototype, "holdAndReleaseSupported", void 0);
+__decorate([
+  (0, import_CommandClassDecorators.ccValue)(DoorLockCCValues.twistAssistSupported)
+], DoorLockCCCapabilitiesReport.prototype, "twistAssistSupported", void 0);
+__decorate([
+  (0, import_CommandClassDecorators.ccValue)(DoorLockCCValues.blockToBlockSupported)
+], DoorLockCCCapabilitiesReport.prototype, "blockToBlockSupported", void 0);
+DoorLockCCCapabilitiesReport = DoorLockCCCapabilitiesReport_1 = __decorate([
+  (0, import_CommandClassDecorators.CCCommand)(import_Types.DoorLockCommand.CapabilitiesReport)
+], DoorLockCCCapabilitiesReport);
+let DoorLockCCCapabilitiesGet = class DoorLockCCCapabilitiesGet2 extends DoorLockCC {
+};
+DoorLockCCCapabilitiesGet = __decorate([
+  (0, import_CommandClassDecorators.CCCommand)(import_Types.DoorLockCommand.CapabilitiesGet),
+  (0, import_CommandClassDecorators.expectedCCResponse)(DoorLockCCCapabilitiesReport)
+], DoorLockCCCapabilitiesGet);
+// 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