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

package/build/cjs/cc/UserCodeCC.js

@@ -0,0 +1,1620 @@
+"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 UserCodeCC_exports = {};
+__export(UserCodeCC_exports, {
+  UserCodeCC: () => UserCodeCC,
+  UserCodeCCAPI: () => UserCodeCCAPI,
+  UserCodeCCAdminCodeGet: () => UserCodeCCAdminCodeGet,
+  UserCodeCCAdminCodeReport: () => UserCodeCCAdminCodeReport,
+  UserCodeCCAdminCodeSet: () => UserCodeCCAdminCodeSet,
+  UserCodeCCCapabilitiesGet: () => UserCodeCCCapabilitiesGet,
+  UserCodeCCCapabilitiesReport: () => UserCodeCCCapabilitiesReport,
+  UserCodeCCExtendedUserCodeGet: () => UserCodeCCExtendedUserCodeGet,
+  UserCodeCCExtendedUserCodeReport: () => UserCodeCCExtendedUserCodeReport,
+  UserCodeCCExtendedUserCodeSet: () => UserCodeCCExtendedUserCodeSet,
+  UserCodeCCGet: () => UserCodeCCGet,
+  UserCodeCCKeypadModeGet: () => UserCodeCCKeypadModeGet,
+  UserCodeCCKeypadModeReport: () => UserCodeCCKeypadModeReport,
+  UserCodeCCKeypadModeSet: () => UserCodeCCKeypadModeSet,
+  UserCodeCCReport: () => UserCodeCCReport,
+  UserCodeCCSet: () => UserCodeCCSet,
+  UserCodeCCUserCodeChecksumGet: () => UserCodeCCUserCodeChecksumGet,
+  UserCodeCCUserCodeChecksumReport: () => UserCodeCCUserCodeChecksumReport,
+  UserCodeCCUsersNumberGet: () => UserCodeCCUsersNumberGet,
+  UserCodeCCUsersNumberReport: () => UserCodeCCUsersNumberReport,
+  UserCodeCCValues: () => UserCodeCCValues,
+  userCodeToLogString: () => userCodeToLogString
+});
+module.exports = __toCommonJS(UserCodeCC_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_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 UserCodeCC_1, UserCodeCCSet_1, UserCodeCCReport_1, UserCodeCCGet_1, UserCodeCCUsersNumberReport_1, UserCodeCCCapabilitiesReport_1, UserCodeCCKeypadModeSet_1, UserCodeCCKeypadModeReport_1, UserCodeCCAdminCodeSet_1, UserCodeCCAdminCodeReport_1, UserCodeCCUserCodeChecksumReport_1, UserCodeCCExtendedUserCodeReport_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__number = ($o) => {
+  function _number($o2) {
+    return typeof $o2 !== "number" ? {} : null;
+  }
+  return _number($o);
+};
+const __assertType__optional_boolean = ($o) => {
+  function _boolean($o2) {
+    return typeof $o2 !== "boolean" ? {} : null;
+  }
+  function optional__boolean($o2) {
+    if ($o2 !== void 0) {
+      const error = _boolean($o2);
+      if (error)
+        return error;
+    }
+    return null;
+  }
+  return optional__boolean($o);
+};
+const __assertType__su__1__2__3__4_eu = ($o) => {
+  function _1($o2) {
+    return $o2 !== 1 ? {} : null;
+  }
+  function _2($o2) {
+    return $o2 !== 2 ? {} : null;
+  }
+  function _3($o2) {
+    return $o2 !== 3 ? {} : null;
+  }
+  function _4($o2) {
+    return $o2 !== 4 ? {} : null;
+  }
+  function su__1__2__3__4_eu($o2) {
+    const conditions = [_1, _2, _3, _4];
+    for (const condition of conditions) {
+      const error = condition($o2);
+      if (!error)
+        return null;
+    }
+    return {};
+  }
+  return su__1__2__3__4_eu($o);
+};
+const __assertType__su__string__uint8array_eu = ($o) => {
+  function _string($o2) {
+    return typeof $o2 !== "string" ? {} : null;
+  }
+  function _uint8array($o2) {
+    return !require("@zwave-js/shared/safe").isUint8Array($o2) ? {} : null;
+  }
+  function su__string__uint8array_eu($o2) {
+    const conditions = [_string, _uint8array];
+    for (const condition of conditions) {
+      const error = condition($o2);
+      if (!error)
+        return null;
+    }
+    return {};
+  }
+  return su__string__uint8array_eu($o);
+};
+const __assertType__sa_su__3__4__5_eu_ea_2 = ($o) => {
+  function _6($o2) {
+    return $o2 !== 0 ? {} : null;
+  }
+  function _7($o2) {
+    return $o2 !== 0 ? {} : null;
+  }
+  function _undefined($o2) {
+    return $o2 !== void 0 ? {} : null;
+  }
+  function _3($o2) {
+    if (typeof $o2 !== "object" || $o2 === null || Array.isArray($o2))
+      return {};
+    if ("userId" in $o2 && $o2["userId"] !== void 0) {
+      const error = _6($o2["userId"]);
+      if (error)
+        return error;
+    } else
+      return {};
+    if ("userIdStatus" in $o2 && $o2["userIdStatus"] !== void 0) {
+      const error = _7($o2["userIdStatus"]);
+      if (error)
+        return error;
+    } else
+      return {};
+    if ("userCode" in $o2 && $o2["userCode"] !== void 0) {
+      const error = _undefined($o2["userCode"]);
+      if (error)
+        return error;
+    }
+    return null;
+  }
+  function _number($o2) {
+    return typeof $o2 !== "number" ? {} : null;
+  }
+  function _4($o2) {
+    if (typeof $o2 !== "object" || $o2 === null || Array.isArray($o2))
+      return {};
+    if ("userId" in $o2 && $o2["userId"] !== void 0) {
+      const error = _number($o2["userId"]);
+      if (error)
+        return error;
+    } else
+      return {};
+    if ("userIdStatus" in $o2 && $o2["userIdStatus"] !== void 0) {
+      const error = _7($o2["userIdStatus"]);
+      if (error)
+        return error;
+    } else
+      return {};
+    if ("userCode" in $o2 && $o2["userCode"] !== void 0) {
+      const error = _undefined($o2["userCode"]);
+      if (error)
+        return error;
+    }
+    return null;
+  }
+  function _9($o2) {
+    return $o2 !== 1 ? {} : null;
+  }
+  function _10($o2) {
+    return $o2 !== 2 ? {} : null;
+  }
+  function _11($o2) {
+    return $o2 !== 3 ? {} : null;
+  }
+  function _12($o2) {
+    return $o2 !== 4 ? {} : null;
+  }
+  function su__9__10__11__12_eu($o2) {
+    const conditions = [_9, _10, _11, _12];
+    for (const condition of conditions) {
+      const error = condition($o2);
+      if (!error)
+        return null;
+    }
+    return {};
+  }
+  function _string($o2) {
+    return typeof $o2 !== "string" ? {} : null;
+  }
+  function _uint8array($o2) {
+    return !require("@zwave-js/shared/safe").isUint8Array($o2) ? {} : null;
+  }
+  function su__string__uint8array_eu($o2) {
+    const conditions = [_string, _uint8array];
+    for (const condition of conditions) {
+      const error = condition($o2);
+      if (!error)
+        return null;
+    }
+    return {};
+  }
+  function _5($o2) {
+    if (typeof $o2 !== "object" || $o2 === null || Array.isArray($o2))
+      return {};
+    if ("userId" in $o2 && $o2["userId"] !== void 0) {
+      const error = _number($o2["userId"]);
+      if (error)
+        return error;
+    } else
+      return {};
+    if ("userIdStatus" in $o2 && $o2["userIdStatus"] !== void 0) {
+      const error = su__9__10__11__12_eu($o2["userIdStatus"]);
+      if (error)
+        return error;
+    } else
+      return {};
+    if ("userCode" in $o2 && $o2["userCode"] !== void 0) {
+      const error = su__string__uint8array_eu($o2["userCode"]);
+      if (error)
+        return error;
+    } else
+      return {};
+    return null;
+  }
+  function su__3__4__5_eu($o2) {
+    const conditions = [_3, _4, _5];
+    for (const condition of conditions) {
+      const error = condition($o2);
+      if (!error)
+        return null;
+    }
+    return {};
+  }
+  function sa_su__3__4__5_eu_ea_2($o2) {
+    if (!Array.isArray($o2))
+      return {};
+    for (let i = 0; i < $o2.length; i++) {
+      const error = su__3__4__5_eu($o2[i]);
+      if (error)
+        return error;
+    }
+    return null;
+  }
+  return sa_su__3__4__5_eu_ea_2($o);
+};
+const __assertType__optional_number = ($o) => {
+  function _number($o2) {
+    return typeof $o2 !== "number" ? {} : null;
+  }
+  function optional__number($o2) {
+    if ($o2 !== void 0) {
+      const error = _number($o2);
+      if (error)
+        return error;
+    }
+    return null;
+  }
+  return optional__number($o);
+};
+const __assertType__KeypadMode = ($o) => {
+  function su__1__2__3__4_eu($o2) {
+    return ![0, 1, 2, 3].includes($o2) ? {} : null;
+  }
+  return su__1__2__3__4_eu($o);
+};
+const __assertType__string = ($o) => {
+  function _string($o2) {
+    return typeof $o2 !== "string" ? {} : null;
+  }
+  return _string($o);
+};
+const UserCodeCCValues = Object.freeze({
+  ...import_Values.V.defineStaticCCValues(import_safe.CommandClasses["User Code"], {
+    ...import_Values.V.staticProperty("supportedUsers", void 0, { internal: true }),
+    ...import_Values.V.staticProperty("supportsAdminCode", void 0, {
+      internal: true
+    }),
+    ...import_Values.V.staticProperty("supportsAdminCodeDeactivation", void 0, {
+      internal: true
+    }),
+    // The following two properties are only kept for compatibility with devices
+    // that were interviewed before the rename to admin code
+    ...import_Values.V.staticPropertyWithName("_deprecated_supportsMasterCode", "supportsMasterCode", void 0, {
+      internal: true
+    }),
+    ...import_Values.V.staticPropertyWithName("_deprecated_supportsMasterCodeDeactivation", "supportsMasterCodeDeactivation", void 0, {
+      internal: true
+    }),
+    ...import_Values.V.staticProperty("supportsUserCodeChecksum", void 0, {
+      internal: true
+    }),
+    ...import_Values.V.staticProperty("supportsMultipleUserCodeReport", void 0, {
+      internal: true
+    }),
+    ...import_Values.V.staticProperty("supportsMultipleUserCodeSet", void 0, {
+      internal: true
+    }),
+    ...import_Values.V.staticProperty("supportedUserIDStatuses", void 0, {
+      internal: true
+    }),
+    ...import_Values.V.staticProperty("supportedKeypadModes", void 0, {
+      internal: true
+    }),
+    ...import_Values.V.staticProperty("supportedASCIIChars", void 0, {
+      internal: true
+    }),
+    ...import_Values.V.staticProperty("userCodeChecksum", void 0, { internal: true }),
+    ...import_Values.V.staticProperty("keypadMode", {
+      ...import_safe.ValueMetadata.ReadOnlyNumber,
+      label: "Keypad Mode"
+    }, { minVersion: 2 }),
+    ...import_Values.V.staticProperty("adminCode", {
+      ...import_safe.ValueMetadata.String,
+      label: "Admin Code",
+      minLength: 4,
+      maxLength: 10
+    }, {
+      minVersion: 2,
+      secret: true
+    })
+  }),
+  ...import_Values.V.defineDynamicCCValues(import_safe.CommandClasses["User Code"], {
+    ...import_Values.V.dynamicPropertyAndKeyWithName("userIdStatus", "userIdStatus", (userId) => userId, ({ property, propertyKey }) => property === "userIdStatus" && typeof propertyKey === "number", (userId) => ({
+      ...import_safe.ValueMetadata.Number,
+      label: `User ID status (${userId})`
+    })),
+    ...import_Values.V.dynamicPropertyAndKeyWithName(
+      "userCode",
+      "userCode",
+      (userId) => userId,
+      ({ property, propertyKey }) => property === "userCode" && typeof propertyKey === "number",
+      // The user code metadata is dynamically created
+      void 0,
+      { secret: true }
+    )
+  })
+});
+function parseExtendedUserCode(payload) {
+  (0, import_safe.validatePayload)(payload.length >= 4);
+  const userId = payload.readUInt16BE(0);
+  const status = payload[2];
+  const codeLength = payload[3] & 15;
+  (0, import_safe.validatePayload)(payload.length >= 4 + codeLength);
+  const code = payload.subarray(4, 4 + codeLength).toString("ascii");
+  return {
+    code: {
+      userId,
+      userIdStatus: status,
+      userCode: code
+    },
+    bytesRead: 4 + codeLength
+  };
+}
+function validateCode(code, supportedChars) {
+  if (code.length < 4 || code.length > 10)
+    return false;
+  return [...code].every((char) => supportedChars.includes(char));
+}
+function setUserCodeMetadata(ctx, userId, userCode) {
+  const statusValue = UserCodeCCValues.userIdStatus(userId);
+  const codeValue = UserCodeCCValues.userCode(userId);
+  const ccVersion = (0, import_CommandClass.getEffectiveCCVersion)(ctx, this);
+  const supportedUserIDStatuses = this.getValue(ctx, UserCodeCCValues.supportedUserIDStatuses) ?? (ccVersion === 1 ? [
+    import_Types.UserIDStatus.Available,
+    import_Types.UserIDStatus.Enabled,
+    import_Types.UserIDStatus.Disabled
+  ] : [
+    import_Types.UserIDStatus.Available,
+    import_Types.UserIDStatus.Enabled,
+    import_Types.UserIDStatus.Disabled,
+    import_Types.UserIDStatus.Messaging,
+    import_Types.UserIDStatus.PassageMode
+  ]);
+  this.ensureMetadata(ctx, statusValue, {
+    ...statusValue.meta,
+    states: (0, import_safe.enumValuesToMetadataStates)(import_Types.UserIDStatus, supportedUserIDStatuses)
+  });
+  const codeMetadata = {
+    ...(0, import_safe2.isUint8Array)(userCode) ? import_safe.ValueMetadata.Buffer : import_safe.ValueMetadata.String,
+    minLength: 4,
+    maxLength: 10,
+    label: `User Code (${userId})`
+  };
+  if (this.getMetadata(ctx, codeValue)?.type !== codeMetadata.type) {
+    this.setMetadata(ctx, codeValue, codeMetadata);
+  }
+}
+function persistUserCode(ctx, userId, userIdStatus, userCode) {
+  const statusValue = UserCodeCCValues.userIdStatus(userId);
+  const codeValue = UserCodeCCValues.userCode(userId);
+  if (userIdStatus === import_Types.UserIDStatus.StatusNotAvailable) {
+    this.removeValue(ctx, statusValue);
+    this.removeValue(ctx, codeValue);
+    this.removeMetadata(ctx, statusValue);
+    this.removeMetadata(ctx, codeValue);
+  } else {
+    setUserCodeMetadata.call(this, ctx, userId, userCode);
+    this.setValue(ctx, statusValue, userIdStatus);
+    this.setValue(ctx, codeValue, userCode);
+  }
+  return true;
+}
+function userCodeToLogString(userCode) {
+  if (userCode.length === 0)
+    return "(empty)";
+  return "*".repeat(userCode.length);
+}
+let UserCodeCCAPI = class UserCodeCCAPI2 extends import_API.PhysicalCCAPI {
+  supportsCommand(cmd) {
+    switch (cmd) {
+      case import_Types.UserCodeCommand.Get:
+      case import_Types.UserCodeCommand.Set:
+      case import_Types.UserCodeCommand.UsersNumberGet:
+        return true;
+      // This is mandatory
+      case import_Types.UserCodeCommand.CapabilitiesGet:
+      case import_Types.UserCodeCommand.KeypadModeSet:
+      case import_Types.UserCodeCommand.KeypadModeGet:
+      case import_Types.UserCodeCommand.ExtendedUserCodeSet:
+      case import_Types.UserCodeCommand.ExtendedUserCodeGet:
+        return this.version >= 2;
+      case import_Types.UserCodeCommand.AdminCodeSet:
+      case import_Types.UserCodeCommand.AdminCodeGet: {
+        if (this.version < 2)
+          return false;
+        return this.tryGetValueDB()?.getValue(UserCodeCCValues.supportsAdminCode.endpoint(this.endpoint.index));
+      }
+      case import_Types.UserCodeCommand.UserCodeChecksumGet: {
+        if (this.version < 2)
+          return false;
+        return this.tryGetValueDB()?.getValue(UserCodeCCValues.supportsUserCodeChecksum.endpoint(this.endpoint.index));
+      }
+    }
+    return super.supportsCommand(cmd);
+  }
+  get [import_API.SET_VALUE]() {
+    return async function({ property, propertyKey }, value) {
+      let result;
+      if (property === "keypadMode") {
+        if (typeof value !== "number") {
+          (0, import_API.throwWrongValueType)(this.ccId, property, "number", typeof value);
+        }
+        result = await this.setKeypadMode(value);
+      } else if (property === "adminCode" || property === "masterCode") {
+        if (typeof value !== "string") {
+          (0, import_API.throwWrongValueType)(this.ccId, property, "string", typeof value);
+        }
+        result = await this.setAdminCode(value);
+      } else if (property === "userIdStatus") {
+        if (propertyKey == void 0) {
+          (0, import_API.throwMissingPropertyKey)(this.ccId, property);
+        } else if (typeof propertyKey !== "number") {
+          (0, import_API.throwUnsupportedPropertyKey)(this.ccId, property, propertyKey);
+        }
+        if (typeof value !== "number") {
+          (0, import_API.throwWrongValueType)(this.ccId, property, "number", typeof value);
+        }
+        if (value === import_Types.UserIDStatus.Available) {
+          result = await this.clear(propertyKey);
+        } else {
+          const userCode = this.getValueDB().getValue(UserCodeCCValues.userCode(propertyKey).endpoint(this.endpoint.index));
+          result = await this.set(propertyKey, value, userCode);
+        }
+      } else if (property === "userCode") {
+        if (propertyKey == void 0) {
+          (0, import_API.throwMissingPropertyKey)(this.ccId, property);
+        } else if (typeof propertyKey !== "number") {
+          (0, import_API.throwUnsupportedPropertyKey)(this.ccId, property, propertyKey);
+        }
+        if (typeof value !== "string" && !(0, import_safe2.isUint8Array)(value)) {
+          (0, import_API.throwWrongValueType)(this.ccId, property, "string or Buffer", typeof value);
+        }
+        let userIdStatus = this.getValueDB().getValue(UserCodeCCValues.userIdStatus(propertyKey).endpoint(this.endpoint.index));
+        if (userIdStatus === import_Types.UserIDStatus.Available || userIdStatus == void 0) {
+          userIdStatus = import_Types.UserIDStatus.Enabled;
+        }
+        result = await this.set(propertyKey, userIdStatus, value);
+      } else {
+        (0, import_API.throwUnsupportedProperty)(this.ccId, property);
+      }
+      if (this.isSinglecast() && !(0, import_safe.supervisedCommandSucceeded)(result)) {
+        this.schedulePoll({ property, propertyKey }, value, {
+          transition: "fast"
+        });
+      }
+      return result;
+    };
+  }
+  get [import_API.POLL_VALUE]() {
+    return async function({ property, propertyKey }) {
+      switch (property) {
+        case "keypadMode":
+          return this.getKeypadMode();
+        case "adminCode":
+          return this.getAdminCode();
+        case "userIdStatus":
+        case "userCode": {
+          if (propertyKey == void 0) {
+            (0, import_API.throwMissingPropertyKey)(this.ccId, property);
+          } else if (typeof propertyKey !== "number") {
+            (0, import_API.throwUnsupportedPropertyKey)(this.ccId, property, propertyKey);
+          }
+          return (await this.get(propertyKey))?.[property];
+        }
+        default:
+          (0, import_API.throwUnsupportedProperty)(this.ccId, property);
+      }
+    };
+  }
+  async getUsersCount() {
+    this.assertSupportsCommand(import_Types.UserCodeCommand, import_Types.UserCodeCommand.UsersNumberGet);
+    const cc = new UserCodeCCUsersNumberGet({
+      nodeId: this.endpoint.nodeId,
+      endpointIndex: this.endpoint.index
+    });
+    const response = await this.host.sendCommand(cc, this.commandOptions);
+    return response?.supportedUsers;
+  }
+  async get(userId, multiple = false) {
+    __assertType("userId", "number", __assertType__number.bind(void 0, userId));
+    __assertType("multiple", "(optional) boolean", __assertType__optional_boolean.bind(void 0, multiple));
+    if (userId > 255 || multiple) {
+      this.assertSupportsCommand(import_Types.UserCodeCommand, import_Types.UserCodeCommand.ExtendedUserCodeGet);
+      const cc = new UserCodeCCExtendedUserCodeGet({
+        nodeId: this.endpoint.nodeId,
+        endpointIndex: this.endpoint.index,
+        userId,
+        reportMore: multiple
+      });
+      const response = await this.host.sendCommand(cc, this.commandOptions);
+      if (!response) {
+        return;
+      } else if (multiple) {
+        return (0, import_safe3.pick)(response, ["userCodes", "nextUserId"]);
+      } else {
+        return (0, import_safe3.pick)(response.userCodes[0], [
+          "userIdStatus",
+          "userCode"
+        ]);
+      }
+    } else {
+      this.assertSupportsCommand(import_Types.UserCodeCommand, import_Types.UserCodeCommand.Get);
+      const cc = new UserCodeCCGet({
+        nodeId: this.endpoint.nodeId,
+        endpointIndex: this.endpoint.index,
+        userId
+      });
+      const response = await this.host.sendCommand(cc, this.commandOptions);
+      if (response)
+        return (0, import_safe3.pick)(response, ["userIdStatus", "userCode"]);
+    }
+  }
+  /** Configures a single user code */
+  async set(userId, userIdStatus, userCode) {
+    __assertType("userId", "number", __assertType__number.bind(void 0, userId));
+    __assertType("userIdStatus", void 0, __assertType__su__1__2__3__4_eu.bind(void 0, userIdStatus));
+    __assertType("userCode", void 0, __assertType__su__string__uint8array_eu.bind(void 0, userCode));
+    if (userId > 255) {
+      return this.setMany([{ userId, userIdStatus, userCode }]);
+    }
+    this.assertSupportsCommand(import_Types.UserCodeCommand, import_Types.UserCodeCommand.Set);
+    const numUsers = UserCodeCC.getSupportedUsersCached(this.host, this.endpoint);
+    if (numUsers != void 0 && userId > numUsers) {
+      throw new import_safe.ZWaveError(`The user ID must be between 0 and the number of supported users ${numUsers}.`, import_safe.ZWaveErrorCodes.Argument_Invalid);
+    }
+    const cc = new UserCodeCCSet({
+      nodeId: this.endpoint.nodeId,
+      endpointIndex: this.endpoint.index,
+      userId,
+      userIdStatus,
+      userCode
+    });
+    return this.host.sendCommand(cc, this.commandOptions);
+  }
+  /** Configures multiple user codes */
+  async setMany(codes) {
+    __assertType("codes", void 0, __assertType__sa_su__3__4__5_eu_ea_2.bind(void 0, codes));
+    this.assertSupportsCommand(import_Types.UserCodeCommand, import_Types.UserCodeCommand.ExtendedUserCodeSet);
+    const numUsers = UserCodeCC.getSupportedUsersCached(this.host, this.endpoint);
+    const supportedStatuses = UserCodeCC.getSupportedUserIDStatusesCached(this.host, this.endpoint);
+    const supportedASCIIChars = UserCodeCC.getSupportedASCIICharsCached(this.host, this.endpoint);
+    const supportsMultipleUserCodeSet = UserCodeCC.supportsMultipleUserCodeSetCached(this.host, this.endpoint) ?? false;
+    if (numUsers != void 0) {
+      if (codes.some((code) => code.userId < 0 || code.userId > numUsers)) {
+        throw new import_safe.ZWaveError(`All User IDs must be between 0 and the number of supported users ${numUsers}.`, import_safe.ZWaveErrorCodes.Argument_Invalid);
+      }
+    } else {
+      if (codes.some((code) => code.userId < 0)) {
+        throw new import_safe.ZWaveError(`All User IDs must be greater than 0.`, import_safe.ZWaveErrorCodes.Argument_Invalid);
+      }
+    }
+    if (codes.some((code) => code.userId === 0) && codes.length > 1) {
+      throw new import_safe.ZWaveError(`If user ID 0 is used, only one code may be set`, import_safe.ZWaveErrorCodes.Argument_Invalid);
+    } else if (codes.some((code) => code.userId === 0 && code.userIdStatus !== import_Types.UserIDStatus.Available)) {
+      throw new import_safe.ZWaveError(`User ID 0 may only be used to clear all user codes`, import_safe.ZWaveErrorCodes.Argument_Invalid);
+    } else if (codes.length > 1 && !supportsMultipleUserCodeSet) {
+      throw new import_safe.ZWaveError(`The node does not support setting multiple user codes at once`, import_safe.ZWaveErrorCodes.Argument_Invalid);
+    }
+    for (const code of codes) {
+      if (supportedStatuses != void 0 && !supportedStatuses.includes(code.userIdStatus)) {
+        throw new import_safe.ZWaveError(`The user ID status ${(0, import_safe3.getEnumMemberName)(import_Types.UserIDStatus, code.userIdStatus)} is not supported by the node`, import_safe.ZWaveErrorCodes.Argument_Invalid);
+      } else if (code.userIdStatus === import_Types.UserIDStatus.Available) {
+        code.userCode = void 0;
+      } else if (supportedASCIIChars) {
+        const userCodeString = typeof code.userCode === "string" ? code.userCode : (0, import_safe2.uint8ArrayToString)(code.userCode);
+        if (!validateCode(userCodeString, supportedASCIIChars)) {
+          throw new import_safe.ZWaveError(`The user code must consist of 4 to 10 of the following characters: ${supportedASCIIChars}`, import_safe.ZWaveErrorCodes.Argument_Invalid);
+        }
+      }
+    }
+    const cc = new UserCodeCCExtendedUserCodeSet({
+      nodeId: this.endpoint.nodeId,
+      endpointIndex: this.endpoint.index,
+      userCodes: codes
+    });
+    return this.host.sendCommand(cc, this.commandOptions);
+  }
+  /**
+   * Clears one or all user code
+   * @param userId The user code to clear. If none or 0 is given, all codes are cleared
+   */
+  async clear(userId = 0) {
+    __assertType("userId", "(optional) number", __assertType__optional_number.bind(void 0, userId));
+    if (this.version > 1 || userId > 255) {
+      return this.setMany([
+        { userId, userIdStatus: import_Types.UserIDStatus.Available }
+      ]);
+    } else {
+      this.assertSupportsCommand(import_Types.UserCodeCommand, import_Types.UserCodeCommand.Set);
+      const numUsers = UserCodeCC.getSupportedUsersCached(this.host, this.endpoint);
+      if (numUsers != void 0 && userId > numUsers) {
+        throw new import_safe.ZWaveError(`The user ID must be between 0 and the number of supported users ${numUsers}.`, import_safe.ZWaveErrorCodes.Argument_Invalid);
+      }
+      const cc = new UserCodeCCSet({
+        nodeId: this.endpoint.nodeId,
+        endpointIndex: this.endpoint.index,
+        userId,
+        userIdStatus: import_Types.UserIDStatus.Available
+      });
+      return this.host.sendCommand(cc, this.commandOptions);
+    }
+  }
+  // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
+  async getCapabilities() {
+    this.assertSupportsCommand(import_Types.UserCodeCommand, import_Types.UserCodeCommand.CapabilitiesGet);
+    const cc = new UserCodeCCCapabilitiesGet({
+      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, [
+        "supportsAdminCode",
+        "supportsAdminCodeDeactivation",
+        "supportsUserCodeChecksum",
+        "supportsMultipleUserCodeReport",
+        "supportsMultipleUserCodeSet",
+        "supportedUserIDStatuses",
+        "supportedKeypadModes",
+        "supportedASCIIChars"
+      ]);
+    }
+  }
+  async getKeypadMode() {
+    this.assertSupportsCommand(import_Types.UserCodeCommand, import_Types.UserCodeCommand.KeypadModeGet);
+    const cc = new UserCodeCCKeypadModeGet({
+      nodeId: this.endpoint.nodeId,
+      endpointIndex: this.endpoint.index
+    });
+    const response = await this.host.sendCommand(cc, this.commandOptions);
+    return response?.keypadMode;
+  }
+  async setKeypadMode(keypadMode) {
+    __assertType("keypadMode", "KeypadMode", __assertType__KeypadMode.bind(void 0, keypadMode));
+    this.assertSupportsCommand(import_Types.UserCodeCommand, import_Types.UserCodeCommand.KeypadModeSet);
+    const supportedModes = UserCodeCC.getSupportedKeypadModesCached(this.host, this.endpoint);
+    if (!supportedModes) {
+      throw new import_safe.ZWaveError(`The keypad mode can only be set after the interview is complete!`, import_safe.ZWaveErrorCodes.Argument_Invalid);
+    } else if (!supportedModes.includes(keypadMode)) {
+      throw new import_safe.ZWaveError(`The keypad mode ${(0, import_safe3.getEnumMemberName)(import_Types.KeypadMode, keypadMode)} is not supported by the node!`, import_safe.ZWaveErrorCodes.Argument_Invalid);
+    }
+    const cc = new UserCodeCCKeypadModeSet({
+      nodeId: this.endpoint.nodeId,
+      endpointIndex: this.endpoint.index,
+      keypadMode
+    });
+    return this.host.sendCommand(cc, this.commandOptions);
+  }
+  async getAdminCode() {
+    this.assertSupportsCommand(import_Types.UserCodeCommand, import_Types.UserCodeCommand.AdminCodeGet);
+    const cc = new UserCodeCCAdminCodeGet({
+      nodeId: this.endpoint.nodeId,
+      endpointIndex: this.endpoint.index
+    });
+    const response = await this.host.sendCommand(cc, this.commandOptions);
+    return response?.adminCode;
+  }
+  async setAdminCode(adminCode) {
+    __assertType("adminCode", "string", __assertType__string.bind(void 0, adminCode));
+    this.assertSupportsCommand(import_Types.UserCodeCommand, import_Types.UserCodeCommand.AdminCodeSet);
+    const supportedASCIIChars = UserCodeCC.getSupportedASCIICharsCached(this.host, this.endpoint);
+    if (!supportedASCIIChars) {
+      throw new import_safe.ZWaveError(`The admin code can only be set after the interview is complete!`, import_safe.ZWaveErrorCodes.Argument_Invalid);
+    }
+    if (!adminCode) {
+      const supportsDeactivation = UserCodeCC.supportsAdminCodeDeactivationCached(this.host, this.endpoint);
+      if (!supportsDeactivation) {
+        throw new import_safe.ZWaveError(`The node does not support deactivating the admin code!`, import_safe.ZWaveErrorCodes.Argument_Invalid);
+      }
+    } else if (!validateCode(adminCode, supportedASCIIChars)) {
+      throw new import_safe.ZWaveError(`The admin code must consist of 4 to 10 of the following characters: ${supportedASCIIChars}`, import_safe.ZWaveErrorCodes.Argument_Invalid);
+    }
+    const cc = new UserCodeCCAdminCodeSet({
+      nodeId: this.endpoint.nodeId,
+      endpointIndex: this.endpoint.index,
+      adminCode
+    });
+    return this.host.sendCommand(cc, this.commandOptions);
+  }
+  async getUserCodeChecksum() {
+    this.assertSupportsCommand(import_Types.UserCodeCommand, import_Types.UserCodeCommand.UserCodeChecksumGet);
+    const cc = new UserCodeCCUserCodeChecksumGet({
+      nodeId: this.endpoint.nodeId,
+      endpointIndex: this.endpoint.index
+    });
+    const response = await this.host.sendCommand(cc, this.commandOptions);
+    return response?.userCodeChecksum;
+  }
+};
+UserCodeCCAPI = __decorate([
+  (0, import_CommandClassDecorators.API)(import_safe.CommandClasses["User Code"])
+], UserCodeCCAPI);
+let UserCodeCC = UserCodeCC_1 = class UserCodeCC2 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["User Code"], ctx, endpoint).withOptions({
+      priority: import_safe.MessagePriority.NodeQuery
+    });
+    ctx.logNode(node.id, {
+      endpoint: this.endpointIndex,
+      message: `Interviewing ${this.ccName}...`,
+      direction: "none"
+    });
+    if (api.version >= 2) {
+      ctx.logNode(node.id, {
+        message: "querying capabilities...",
+        direction: "outbound"
+      });
+      const caps = await api.getCapabilities();
+      if (!caps) {
+        ctx.logNode(node.id, {
+          endpoint: this.endpointIndex,
+          message: "User Code capabilities query timed out, skipping interview...",
+          level: "warn"
+        });
+        return;
+      }
+    }
+    ctx.logNode(node.id, {
+      message: "querying number of user codes...",
+      direction: "outbound"
+    });
+    const supportedUsers = await api.getUsersCount();
+    if (supportedUsers == void 0) {
+      ctx.logNode(node.id, {
+        endpoint: this.endpointIndex,
+        message: "Querying number of user codes timed out, skipping interview...",
+        level: "warn"
+      });
+      return;
+    }
+    for (let userId = 1; userId <= supportedUsers; userId++) {
+      setUserCodeMetadata.call(this, ctx, userId);
+    }
+    if (ctx.getInterviewOptions()?.queryAllUserCodes) {
+      await this.refreshValues(ctx);
+    }
+    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["User Code"], ctx, endpoint).withOptions({
+      priority: import_safe.MessagePriority.NodeQuery
+    });
+    const supportsAdminCode = UserCodeCC_1.supportsAdminCodeCached(ctx, endpoint);
+    const supportsUserCodeChecksum = this.getValue(ctx, UserCodeCCValues.supportsUserCodeChecksum) ?? false;
+    const supportedKeypadModes = this.getValue(ctx, UserCodeCCValues.supportedKeypadModes) ?? [];
+    const supportedUsers = this.getValue(ctx, UserCodeCCValues.supportedUsers) ?? 0;
+    const supportsMultipleUserCodeReport = !!this.getValue(ctx, UserCodeCCValues.supportsMultipleUserCodeReport);
+    if (api.version >= 2) {
+      if (supportsAdminCode) {
+        ctx.logNode(node.id, {
+          message: "querying admin code...",
+          direction: "outbound"
+        });
+        await api.getAdminCode();
+      }
+      if (supportedKeypadModes.length > 1) {
+        ctx.logNode(node.id, {
+          message: "querying active keypad mode...",
+          direction: "outbound"
+        });
+        await api.getKeypadMode();
+      }
+      const storedUserCodeChecksum = this.getValue(ctx, UserCodeCCValues.userCodeChecksum) ?? 0;
+      let currentUserCodeChecksum = 0;
+      if (supportsUserCodeChecksum) {
+        ctx.logNode(node.id, {
+          message: "retrieving current user code checksum...",
+          direction: "outbound"
+        });
+        currentUserCodeChecksum = await api.getUserCodeChecksum();
+      }
+      if (!supportsUserCodeChecksum || currentUserCodeChecksum !== storedUserCodeChecksum) {
+        ctx.logNode(node.id, {
+          message: "checksum changed or is not supported, querying all user codes...",
+          direction: "outbound"
+        });
+        if (supportsMultipleUserCodeReport) {
+          let nextUserId = 1;
+          while (nextUserId > 0 && nextUserId <= supportedUsers) {
+            const response = await api.get(nextUserId, true);
+            if (response) {
+              nextUserId = response.nextUserId;
+            } else {
+              ctx.logNode(node.id, {
+                endpoint: this.endpointIndex,
+                message: `Querying user code #${nextUserId} timed out, skipping the remaining interview...`,
+                level: "warn"
+              });
+              break;
+            }
+          }
+        } else {
+          for (let userId = 1; userId <= supportedUsers; userId++) {
+            await api.get(userId);
+          }
+        }
+      }
+    } else {
+      ctx.logNode(node.id, {
+        message: "querying all user codes...",
+        direction: "outbound"
+      });
+      for (let userId = 1; userId <= supportedUsers; userId++) {
+        await api.get(userId);
+      }
+    }
+  }
+  /**
+   * Returns the number of supported users.
+   * This only works AFTER the interview process
+   */
+  static getSupportedUsersCached(ctx, endpoint) {
+    return ctx.getValueDB(endpoint.nodeId).getValue(UserCodeCCValues.supportedUsers.endpoint(endpoint.index));
+  }
+  /**
+   * Returns the supported keypad modes.
+   * This only works AFTER the interview process
+   */
+  static getSupportedKeypadModesCached(ctx, endpoint) {
+    return ctx.getValueDB(endpoint.nodeId).getValue(UserCodeCCValues.supportedKeypadModes.endpoint(endpoint.index));
+  }
+  /**
+   * Returns the supported user ID statuses.
+   * This only works AFTER the interview process
+   */
+  static getSupportedUserIDStatusesCached(ctx, endpoint) {
+    return ctx.getValueDB(endpoint.nodeId).getValue(UserCodeCCValues.supportedUserIDStatuses.endpoint(endpoint.index));
+  }
+  /**
+   * Returns the supported ASCII characters.
+   * This only works AFTER the interview process
+   */
+  static getSupportedASCIICharsCached(ctx, endpoint) {
+    return ctx.getValueDB(endpoint.nodeId).getValue(UserCodeCCValues.supportedASCIIChars.endpoint(endpoint.index));
+  }
+  /**
+   * Returns whether the admin code functionality is supported.
+   * This only works AFTER the interview process
+   */
+  static supportsAdminCodeCached(ctx, endpoint) {
+    const valueDB = ctx.getValueDB(endpoint.nodeId);
+    return valueDB.getValue(UserCodeCCValues.supportsAdminCode.endpoint(endpoint.index)) ?? valueDB.getValue(UserCodeCCValues._deprecated_supportsMasterCode.endpoint(endpoint.index)) ?? false;
+  }
+  /**
+   * Returns whether deactivating the admin code is supported.
+   * This only works AFTER the interview process
+   */
+  static supportsAdminCodeDeactivationCached(ctx, endpoint) {
+    const valueDB = ctx.getValueDB(endpoint.nodeId);
+    return valueDB.getValue(UserCodeCCValues.supportsAdminCodeDeactivation.endpoint(endpoint.index)) ?? valueDB.getValue(UserCodeCCValues._deprecated_supportsMasterCodeDeactivation.endpoint(endpoint.index)) ?? false;
+  }
+  /**
+   * Returns whether setting multiple user codes at once is supported.
+   * This only works AFTER the interview process
+   */
+  static supportsMultipleUserCodeSetCached(ctx, endpoint) {
+    return !!ctx.getValueDB(endpoint.nodeId).getValue(UserCodeCCValues.supportsMultipleUserCodeSet.endpoint(endpoint.index));
+  }
+  /**
+   * Returns the current status of a user ID.
+   * This only works AFTER the user IDs have been queried.
+   */
+  static getUserIdStatusCached(ctx, endpoint, userId) {
+    return ctx.getValueDB(endpoint.nodeId).getValue(UserCodeCCValues.userIdStatus(userId).endpoint(endpoint.index));
+  }
+  /**
+   * Returns the current code belonging to a user ID.
+   * This only works AFTER the user IDs have been queried.
+   */
+  static getUserCodeCached(ctx, endpoint, userId) {
+    return ctx.getValueDB(endpoint.nodeId).getValue(UserCodeCCValues.userCode(userId).endpoint(endpoint.index));
+  }
+};
+UserCodeCC = UserCodeCC_1 = __decorate([
+  (0, import_CommandClassDecorators.commandClass)(import_safe.CommandClasses["User Code"]),
+  (0, import_CommandClassDecorators.implementedVersion)(2),
+  (0, import_CommandClassDecorators.ccValues)(UserCodeCCValues)
+], UserCodeCC);
+let UserCodeCCSet = UserCodeCCSet_1 = class UserCodeCCSet2 extends UserCodeCC {
+  constructor(options) {
+    super(options);
+    this.userId = options.userId;
+    this.userIdStatus = options.userIdStatus;
+    if (this.userId < 0) {
+      throw new import_safe.ZWaveError(`${this.constructor.name}: The user ID must be between greater than 0.`, import_safe.ZWaveErrorCodes.Argument_Invalid);
+    } else if (this.userId === 0 && this.userIdStatus !== import_Types.UserIDStatus.Available) {
+      throw new import_safe.ZWaveError(`${this.constructor.name}: User ID 0 may only be used to clear all user codes`, import_safe.ZWaveErrorCodes.Argument_Invalid);
+    } else if (this.userIdStatus === import_Types.UserIDStatus.Available) {
+      this.userCode = "\0".repeat(4);
+    } else {
+      this.userCode = options.userCode;
+      if (this.userCode.length < 4 || this.userCode.length > 10) {
+        throw new import_safe.ZWaveError(`${this.constructor.name}: The user code must have a length of 4 to 10 ${typeof this.userCode === "string" ? "characters" : "bytes"}`, import_safe.ZWaveErrorCodes.Argument_Invalid);
+      }
+    }
+  }
+  static from(raw, ctx) {
+    (0, import_safe.validatePayload)(raw.payload.length >= 2);
+    const userId = raw.payload[0];
+    const userIdStatus = raw.payload[1];
+    if (userIdStatus === import_Types.UserIDStatus.StatusNotAvailable) {
+      import_safe.validatePayload.fail("Invalid user ID status");
+    }
+    if (userIdStatus === import_Types.UserIDStatus.Available) {
+      return new UserCodeCCSet_1({
+        nodeId: ctx.sourceNodeId,
+        userId,
+        userIdStatus
+      });
+    }
+    const userCode = raw.payload.subarray(2);
+    return new UserCodeCCSet_1({
+      nodeId: ctx.sourceNodeId,
+      userId,
+      userIdStatus,
+      userCode
+    });
+  }
+  userId;
+  userIdStatus;
+  userCode;
+  serialize(ctx) {
+    this.payload = import_safe2.Bytes.concat([
+      import_safe2.Bytes.from([this.userId, this.userIdStatus]),
+      typeof this.userCode === "string" ? import_safe2.Bytes.from(this.userCode, "ascii") : this.userCode
+    ]);
+    return super.serialize(ctx);
+  }
+  toLogEntry(ctx) {
+    return {
+      ...super.toLogEntry(ctx),
+      message: {
+        "user id": this.userId,
+        "id status": (0, import_safe3.getEnumMemberName)(import_Types.UserIDStatus, this.userIdStatus),
+        "user code": userCodeToLogString(this.userCode)
+      }
+    };
+  }
+};
+UserCodeCCSet = UserCodeCCSet_1 = __decorate([
+  (0, import_CommandClassDecorators.CCCommand)(import_Types.UserCodeCommand.Set),
+  (0, import_CommandClassDecorators.useSupervision)()
+], UserCodeCCSet);
+let UserCodeCCReport = UserCodeCCReport_1 = class UserCodeCCReport2 extends UserCodeCC {
+  constructor(options) {
+    super(options);
+    this.userId = options.userId;
+    this.userIdStatus = options.userIdStatus;
+    this.userCode = options.userCode ?? "";
+  }
+  static from(raw, ctx) {
+    (0, import_safe.validatePayload)(raw.payload.length >= 2);
+    const userId = raw.payload[0];
+    const userIdStatus = raw.payload[1];
+    let userCode;
+    if (raw.payload.length === 2 && (userIdStatus === import_Types.UserIDStatus.Available || userIdStatus === import_Types.UserIDStatus.StatusNotAvailable)) {
+      userCode = "";
+    } else {
+      (0, import_safe.validatePayload)(raw.payload.length >= 6);
+      let userCodeBuffer = raw.payload.subarray(2);
+      while (userCodeBuffer.at(-1) === 0) {
+        userCodeBuffer = userCodeBuffer.subarray(0, -1);
+      }
+      const userCodeString = userCodeBuffer.toString("utf8");
+      if ((0, import_safe3.isPrintableASCII)(userCodeString)) {
+        userCode = userCodeString;
+      } else if ((0, import_safe3.isPrintableASCIIWithWhitespace)(userCodeString)) {
+        userCode = userCodeString.trim();
+      } else {
+        userCode = userCodeBuffer;
+      }
+    }
+    return new UserCodeCCReport_1({
+      nodeId: ctx.sourceNodeId,
+      userId,
+      userIdStatus,
+      userCode
+    });
+  }
+  userId;
+  userIdStatus;
+  userCode;
+  persistValues(ctx) {
+    if (!super.persistValues(ctx))
+      return false;
+    persistUserCode.call(this, ctx, this.userId, this.userIdStatus, this.userCode);
+    return true;
+  }
+  serialize(ctx) {
+    let userCodeBuffer;
+    if (typeof this.userCode === "string") {
+      userCodeBuffer = import_safe2.Bytes.from(this.userCode, "ascii");
+    } else {
+      userCodeBuffer = this.userCode;
+    }
+    this.payload = import_safe2.Bytes.concat([
+      import_safe2.Bytes.from([this.userId, this.userIdStatus]),
+      userCodeBuffer
+    ]);
+    return super.serialize(ctx);
+  }
+  toLogEntry(ctx) {
+    return {
+      ...super.toLogEntry(ctx),
+      message: {
+        "user id": this.userId,
+        "id status": (0, import_safe3.getEnumMemberName)(import_Types.UserIDStatus, this.userIdStatus),
+        "user code": userCodeToLogString(this.userCode)
+      }
+    };
+  }
+  // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
+  toNotificationEventParameters() {
+    return { userId: this.userId };
+  }
+};
+UserCodeCCReport = UserCodeCCReport_1 = __decorate([
+  (0, import_CommandClassDecorators.CCCommand)(import_Types.UserCodeCommand.Report)
+], UserCodeCCReport);
+let UserCodeCCGet = UserCodeCCGet_1 = class UserCodeCCGet2 extends UserCodeCC {
+  constructor(options) {
+    super(options);
+    this.userId = options.userId;
+  }
+  static from(raw, ctx) {
+    (0, import_safe.validatePayload)(raw.payload.length >= 1);
+    const userId = raw.payload[0];
+    return new UserCodeCCGet_1({
+      nodeId: ctx.sourceNodeId,
+      userId
+    });
+  }
+  userId;
+  serialize(ctx) {
+    this.payload = import_safe2.Bytes.from([this.userId]);
+    return super.serialize(ctx);
+  }
+  toLogEntry(ctx) {
+    return {
+      ...super.toLogEntry(ctx),
+      message: { "user id": this.userId }
+    };
+  }
+};
+UserCodeCCGet = UserCodeCCGet_1 = __decorate([
+  (0, import_CommandClassDecorators.CCCommand)(import_Types.UserCodeCommand.Get),
+  (0, import_CommandClassDecorators.expectedCCResponse)(UserCodeCCReport)
+], UserCodeCCGet);
+let UserCodeCCUsersNumberReport = UserCodeCCUsersNumberReport_1 = class UserCodeCCUsersNumberReport2 extends UserCodeCC {
+  constructor(options) {
+    super(options);
+    this.supportedUsers = options.supportedUsers;
+  }
+  static from(raw, ctx) {
+    (0, import_safe.validatePayload)(raw.payload.length >= 1);
+    let supportedUsers;
+    if (raw.payload.length >= 3) {
+      supportedUsers = raw.payload.readUInt16BE(1);
+    } else {
+      supportedUsers = raw.payload[0];
+    }
+    return new UserCodeCCUsersNumberReport_1({
+      nodeId: ctx.sourceNodeId,
+      supportedUsers
+    });
+  }
+  supportedUsers;
+  serialize(ctx) {
+    this.payload = new import_safe2.Bytes(3);
+    this.payload[0] = Math.min(255, this.supportedUsers);
+    this.payload.writeUInt16BE(this.supportedUsers, 1);
+    return super.serialize(ctx);
+  }
+  toLogEntry(ctx) {
+    return {
+      ...super.toLogEntry(ctx),
+      message: { "supported users": this.supportedUsers }
+    };
+  }
+};
+__decorate([
+  (0, import_CommandClassDecorators.ccValue)(UserCodeCCValues.supportedUsers)
+], UserCodeCCUsersNumberReport.prototype, "supportedUsers", void 0);
+UserCodeCCUsersNumberReport = UserCodeCCUsersNumberReport_1 = __decorate([
+  (0, import_CommandClassDecorators.CCCommand)(import_Types.UserCodeCommand.UsersNumberReport)
+], UserCodeCCUsersNumberReport);
+let UserCodeCCUsersNumberGet = class UserCodeCCUsersNumberGet2 extends UserCodeCC {
+};
+UserCodeCCUsersNumberGet = __decorate([
+  (0, import_CommandClassDecorators.CCCommand)(import_Types.UserCodeCommand.UsersNumberGet),
+  (0, import_CommandClassDecorators.expectedCCResponse)(UserCodeCCUsersNumberReport)
+], UserCodeCCUsersNumberGet);
+let UserCodeCCCapabilitiesReport = UserCodeCCCapabilitiesReport_1 = class UserCodeCCCapabilitiesReport2 extends UserCodeCC {
+  constructor(options) {
+    super(options);
+    this.supportsAdminCode = options.supportsAdminCode;
+    this.supportsAdminCodeDeactivation = options.supportsAdminCodeDeactivation;
+    this.supportsUserCodeChecksum = options.supportsUserCodeChecksum;
+    this.supportsMultipleUserCodeReport = options.supportsMultipleUserCodeReport;
+    this.supportsMultipleUserCodeSet = options.supportsMultipleUserCodeSet;
+    this.supportedUserIDStatuses = options.supportedUserIDStatuses;
+    this.supportedKeypadModes = options.supportedKeypadModes;
+    this.supportedASCIIChars = options.supportedASCIIChars;
+  }
+  static from(raw, ctx) {
+    let offset = 0;
+    (0, import_safe.validatePayload)(raw.payload.length >= offset + 1);
+    const supportsAdminCode = !!(raw.payload[offset] & 128);
+    const supportsAdminCodeDeactivation = !!(raw.payload[offset] & 64);
+    const statusBitMaskLength = raw.payload[offset] & 31;
+    offset += 1;
+    (0, import_safe.validatePayload)(raw.payload.length >= offset + statusBitMaskLength + 1);
+    const supportedUserIDStatuses = (0, import_safe.parseBitMask)(raw.payload.subarray(offset, offset + statusBitMaskLength), import_Types.UserIDStatus.Available);
+    offset += statusBitMaskLength;
+    const supportsUserCodeChecksum = !!(raw.payload[offset] & 128);
+    const supportsMultipleUserCodeReport = !!(raw.payload[offset] & 64);
+    const supportsMultipleUserCodeSet = !!(raw.payload[offset] & 32);
+    const keypadModesBitMaskLength = raw.payload[offset] & 31;
+    offset += 1;
+    (0, import_safe.validatePayload)(raw.payload.length >= offset + keypadModesBitMaskLength + 1);
+    const supportedKeypadModes = (0, import_safe.parseBitMask)(raw.payload.subarray(offset, offset + keypadModesBitMaskLength), import_Types.KeypadMode.Normal);
+    offset += keypadModesBitMaskLength;
+    const keysBitMaskLength = raw.payload[offset] & 31;
+    offset += 1;
+    (0, import_safe.validatePayload)(raw.payload.length >= offset + keysBitMaskLength);
+    const supportedASCIIChars = import_safe2.Bytes.from((0, import_safe.parseBitMask)(raw.payload.subarray(offset, offset + keysBitMaskLength), 0)).toString("ascii");
+    return new UserCodeCCCapabilitiesReport_1({
+      nodeId: ctx.sourceNodeId,
+      supportsAdminCode,
+      supportsAdminCodeDeactivation,
+      supportedUserIDStatuses,
+      supportsUserCodeChecksum,
+      supportsMultipleUserCodeReport,
+      supportsMultipleUserCodeSet,
+      supportedKeypadModes,
+      supportedASCIIChars
+    });
+  }
+  supportsAdminCode;
+  supportsAdminCodeDeactivation;
+  supportsUserCodeChecksum;
+  supportsMultipleUserCodeReport;
+  supportsMultipleUserCodeSet;
+  supportedUserIDStatuses;
+  supportedKeypadModes;
+  supportedASCIIChars;
+  serialize(ctx) {
+    const supportedStatusesBitmask = (0, import_safe.encodeBitMask)(this.supportedUserIDStatuses, void 0, import_Types.UserIDStatus.Available);
+    const controlByte1 = (this.supportsAdminCode ? 128 : 0) | (this.supportsAdminCodeDeactivation ? 64 : 0) | supportedStatusesBitmask.length & 31;
+    const supportedKeypadModesBitmask = (0, import_safe.encodeBitMask)(this.supportedKeypadModes, void 0, import_Types.KeypadMode.Normal);
+    const controlByte2 = (this.supportsUserCodeChecksum ? 128 : 0) | (this.supportsMultipleUserCodeReport ? 64 : 0) | (this.supportsMultipleUserCodeSet ? 32 : 0) | supportedKeypadModesBitmask.length & 31;
+    const keysAsNumbers = [...this.supportedASCIIChars].map((char) => char.charCodeAt(0));
+    const supportedKeysBitmask = (0, import_safe.encodeBitMask)(keysAsNumbers, void 0, 0);
+    const controlByte3 = supportedKeysBitmask.length & 31;
+    this.payload = import_safe2.Bytes.concat([
+      import_safe2.Bytes.from([controlByte1]),
+      supportedStatusesBitmask,
+      import_safe2.Bytes.from([controlByte2]),
+      supportedKeypadModesBitmask,
+      import_safe2.Bytes.from([controlByte3]),
+      supportedKeysBitmask
+    ]);
+    return super.serialize(ctx);
+  }
+  toLogEntry(ctx) {
+    return {
+      ...super.toLogEntry(ctx),
+      message: {
+        "supports admin code": this.supportsAdminCode,
+        "supports admin code deactivation": this.supportsAdminCodeDeactivation,
+        "supports user code checksum": this.supportsUserCodeChecksum,
+        "supports multiple codes in report": this.supportsMultipleUserCodeReport,
+        "supports multiple codes in set": this.supportsMultipleUserCodeSet,
+        "supported user id statuses": this.supportedUserIDStatuses.map((status) => `
+\xB7 ${(0, import_safe3.getEnumMemberName)(import_Types.UserIDStatus, status)}`).join(""),
+        "supported keypad modes": this.supportedKeypadModes.map((mode) => `
+\xB7 ${(0, import_safe3.getEnumMemberName)(import_Types.KeypadMode, mode)}`).join(""),
+        "supported ASCII chars": this.supportedASCIIChars
+      }
+    };
+  }
+};
+__decorate([
+  (0, import_CommandClassDecorators.ccValue)(UserCodeCCValues.supportsAdminCode)
+], UserCodeCCCapabilitiesReport.prototype, "supportsAdminCode", void 0);
+__decorate([
+  (0, import_CommandClassDecorators.ccValue)(UserCodeCCValues.supportsAdminCodeDeactivation)
+], UserCodeCCCapabilitiesReport.prototype, "supportsAdminCodeDeactivation", void 0);
+__decorate([
+  (0, import_CommandClassDecorators.ccValue)(UserCodeCCValues.supportsUserCodeChecksum)
+], UserCodeCCCapabilitiesReport.prototype, "supportsUserCodeChecksum", void 0);
+__decorate([
+  (0, import_CommandClassDecorators.ccValue)(UserCodeCCValues.supportsMultipleUserCodeReport)
+], UserCodeCCCapabilitiesReport.prototype, "supportsMultipleUserCodeReport", void 0);
+__decorate([
+  (0, import_CommandClassDecorators.ccValue)(UserCodeCCValues.supportsMultipleUserCodeSet)
+], UserCodeCCCapabilitiesReport.prototype, "supportsMultipleUserCodeSet", void 0);
+__decorate([
+  (0, import_CommandClassDecorators.ccValue)(UserCodeCCValues.supportedUserIDStatuses)
+], UserCodeCCCapabilitiesReport.prototype, "supportedUserIDStatuses", void 0);
+__decorate([
+  (0, import_CommandClassDecorators.ccValue)(UserCodeCCValues.supportedKeypadModes)
+], UserCodeCCCapabilitiesReport.prototype, "supportedKeypadModes", void 0);
+__decorate([
+  (0, import_CommandClassDecorators.ccValue)(UserCodeCCValues.supportedASCIIChars)
+], UserCodeCCCapabilitiesReport.prototype, "supportedASCIIChars", void 0);
+UserCodeCCCapabilitiesReport = UserCodeCCCapabilitiesReport_1 = __decorate([
+  (0, import_CommandClassDecorators.CCCommand)(import_Types.UserCodeCommand.CapabilitiesReport)
+], UserCodeCCCapabilitiesReport);
+let UserCodeCCCapabilitiesGet = class UserCodeCCCapabilitiesGet2 extends UserCodeCC {
+};
+UserCodeCCCapabilitiesGet = __decorate([
+  (0, import_CommandClassDecorators.CCCommand)(import_Types.UserCodeCommand.CapabilitiesGet),
+  (0, import_CommandClassDecorators.expectedCCResponse)(UserCodeCCCapabilitiesReport)
+], UserCodeCCCapabilitiesGet);
+let UserCodeCCKeypadModeSet = UserCodeCCKeypadModeSet_1 = class UserCodeCCKeypadModeSet2 extends UserCodeCC {
+  constructor(options) {
+    super(options);
+    this.keypadMode = options.keypadMode;
+  }
+  static from(raw, ctx) {
+    (0, import_safe.validatePayload)(raw.payload.length >= 1);
+    const keypadMode = raw.payload[0];
+    return new UserCodeCCKeypadModeSet_1({
+      nodeId: ctx.sourceNodeId,
+      keypadMode
+    });
+  }
+  keypadMode;
+  serialize(ctx) {
+    this.payload = import_safe2.Bytes.from([this.keypadMode]);
+    return super.serialize(ctx);
+  }
+  toLogEntry(ctx) {
+    return {
+      ...super.toLogEntry(ctx),
+      message: { mode: (0, import_safe3.getEnumMemberName)(import_Types.KeypadMode, this.keypadMode) }
+    };
+  }
+};
+UserCodeCCKeypadModeSet = UserCodeCCKeypadModeSet_1 = __decorate([
+  (0, import_CommandClassDecorators.CCCommand)(import_Types.UserCodeCommand.KeypadModeSet),
+  (0, import_CommandClassDecorators.useSupervision)()
+], UserCodeCCKeypadModeSet);
+let UserCodeCCKeypadModeReport = UserCodeCCKeypadModeReport_1 = class UserCodeCCKeypadModeReport2 extends UserCodeCC {
+  constructor(options) {
+    super(options);
+    this.keypadMode = options.keypadMode;
+  }
+  static from(raw, ctx) {
+    (0, import_safe.validatePayload)(raw.payload.length >= 1);
+    const keypadMode = raw.payload[0];
+    return new UserCodeCCKeypadModeReport_1({
+      nodeId: ctx.sourceNodeId,
+      keypadMode
+    });
+  }
+  persistValues(ctx) {
+    if (!super.persistValues(ctx))
+      return false;
+    const supportedKeypadModes = this.getValue(ctx, UserCodeCCValues.supportedKeypadModes) ?? [this.keypadMode];
+    const keypadModeValue = UserCodeCCValues.keypadMode;
+    this.setMetadata(ctx, keypadModeValue, {
+      ...keypadModeValue.meta,
+      states: (0, import_safe.enumValuesToMetadataStates)(import_Types.KeypadMode, supportedKeypadModes)
+    });
+    return true;
+  }
+  keypadMode;
+  serialize(ctx) {
+    this.payload = import_safe2.Bytes.from([this.keypadMode]);
+    return super.serialize(ctx);
+  }
+  toLogEntry(ctx) {
+    return {
+      ...super.toLogEntry(ctx),
+      message: {
+        keypadMode: (0, import_safe3.getEnumMemberName)(import_Types.KeypadMode, this.keypadMode)
+      }
+    };
+  }
+};
+__decorate([
+  (0, import_CommandClassDecorators.ccValue)(UserCodeCCValues.keypadMode)
+], UserCodeCCKeypadModeReport.prototype, "keypadMode", void 0);
+UserCodeCCKeypadModeReport = UserCodeCCKeypadModeReport_1 = __decorate([
+  (0, import_CommandClassDecorators.CCCommand)(import_Types.UserCodeCommand.KeypadModeReport)
+], UserCodeCCKeypadModeReport);
+let UserCodeCCKeypadModeGet = class UserCodeCCKeypadModeGet2 extends UserCodeCC {
+};
+UserCodeCCKeypadModeGet = __decorate([
+  (0, import_CommandClassDecorators.CCCommand)(import_Types.UserCodeCommand.KeypadModeGet),
+  (0, import_CommandClassDecorators.expectedCCResponse)(UserCodeCCKeypadModeReport)
+], UserCodeCCKeypadModeGet);
+let UserCodeCCAdminCodeSet = UserCodeCCAdminCodeSet_1 = class UserCodeCCAdminCodeSet2 extends UserCodeCC {
+  constructor(options) {
+    super(options);
+    this.adminCode = options.adminCode;
+  }
+  static from(raw, ctx) {
+    (0, import_safe.validatePayload)(raw.payload.length >= 1);
+    const codeLength = raw.payload[0] & 15;
+    (0, import_safe.validatePayload)(raw.payload.length >= 1 + codeLength);
+    const adminCode = raw.payload.subarray(1, 1 + codeLength).toString("ascii");
+    return new UserCodeCCAdminCodeSet_1({
+      nodeId: ctx.sourceNodeId,
+      adminCode
+    });
+  }
+  adminCode;
+  serialize(ctx) {
+    this.payload = import_safe2.Bytes.concat([
+      import_safe2.Bytes.from([this.adminCode.length & 15]),
+      import_safe2.Bytes.from(this.adminCode, "ascii")
+    ]);
+    return super.serialize(ctx);
+  }
+  toLogEntry(ctx) {
+    return {
+      ...super.toLogEntry(ctx),
+      message: { "admin code": userCodeToLogString(this.adminCode) }
+    };
+  }
+};
+UserCodeCCAdminCodeSet = UserCodeCCAdminCodeSet_1 = __decorate([
+  (0, import_CommandClassDecorators.CCCommand)(import_Types.UserCodeCommand.AdminCodeSet),
+  (0, import_CommandClassDecorators.useSupervision)()
+], UserCodeCCAdminCodeSet);
+let UserCodeCCAdminCodeReport = UserCodeCCAdminCodeReport_1 = class UserCodeCCAdminCodeReport2 extends UserCodeCC {
+  constructor(options) {
+    super(options);
+    this.adminCode = options.adminCode;
+  }
+  static from(raw, ctx) {
+    (0, import_safe.validatePayload)(raw.payload.length >= 1);
+    const codeLength = raw.payload[0] & 15;
+    (0, import_safe.validatePayload)(raw.payload.length >= 1 + codeLength);
+    const adminCode = raw.payload.subarray(1, 1 + codeLength).toString("ascii");
+    return new UserCodeCCAdminCodeReport_1({
+      nodeId: ctx.sourceNodeId,
+      adminCode
+    });
+  }
+  adminCode;
+  serialize(ctx) {
+    this.payload = import_safe2.Bytes.concat([
+      import_safe2.Bytes.from([this.adminCode.length & 15]),
+      import_safe2.Bytes.from(this.adminCode, "ascii")
+    ]);
+    return super.serialize(ctx);
+  }
+  toLogEntry(ctx) {
+    return {
+      ...super.toLogEntry(ctx),
+      message: { "admin code": userCodeToLogString(this.adminCode) }
+    };
+  }
+};
+__decorate([
+  (0, import_CommandClassDecorators.ccValue)(UserCodeCCValues.adminCode)
+], UserCodeCCAdminCodeReport.prototype, "adminCode", void 0);
+UserCodeCCAdminCodeReport = UserCodeCCAdminCodeReport_1 = __decorate([
+  (0, import_CommandClassDecorators.CCCommand)(import_Types.UserCodeCommand.AdminCodeReport)
+], UserCodeCCAdminCodeReport);
+let UserCodeCCAdminCodeGet = class UserCodeCCAdminCodeGet2 extends UserCodeCC {
+};
+UserCodeCCAdminCodeGet = __decorate([
+  (0, import_CommandClassDecorators.CCCommand)(import_Types.UserCodeCommand.AdminCodeGet),
+  (0, import_CommandClassDecorators.expectedCCResponse)(UserCodeCCAdminCodeReport)
+], UserCodeCCAdminCodeGet);
+let UserCodeCCUserCodeChecksumReport = UserCodeCCUserCodeChecksumReport_1 = class UserCodeCCUserCodeChecksumReport2 extends UserCodeCC {
+  constructor(options) {
+    super(options);
+    this.userCodeChecksum = options.userCodeChecksum;
+  }
+  static from(raw, ctx) {
+    (0, import_safe.validatePayload)(raw.payload.length >= 2);
+    const userCodeChecksum = raw.payload.readUInt16BE(0);
+    return new UserCodeCCUserCodeChecksumReport_1({
+      nodeId: ctx.sourceNodeId,
+      userCodeChecksum
+    });
+  }
+  userCodeChecksum;
+  serialize(ctx) {
+    this.payload = new import_safe2.Bytes(2);
+    this.payload.writeUInt16BE(this.userCodeChecksum, 0);
+    return super.serialize(ctx);
+  }
+  toLogEntry(ctx) {
+    return {
+      ...super.toLogEntry(ctx),
+      message: { "user code checksum": (0, import_safe3.num2hex)(this.userCodeChecksum) }
+    };
+  }
+};
+__decorate([
+  (0, import_CommandClassDecorators.ccValue)(UserCodeCCValues.userCodeChecksum)
+], UserCodeCCUserCodeChecksumReport.prototype, "userCodeChecksum", void 0);
+UserCodeCCUserCodeChecksumReport = UserCodeCCUserCodeChecksumReport_1 = __decorate([
+  (0, import_CommandClassDecorators.CCCommand)(import_Types.UserCodeCommand.UserCodeChecksumReport)
+], UserCodeCCUserCodeChecksumReport);
+let UserCodeCCUserCodeChecksumGet = class UserCodeCCUserCodeChecksumGet2 extends UserCodeCC {
+};
+UserCodeCCUserCodeChecksumGet = __decorate([
+  (0, import_CommandClassDecorators.CCCommand)(import_Types.UserCodeCommand.UserCodeChecksumGet),
+  (0, import_CommandClassDecorators.expectedCCResponse)(UserCodeCCUserCodeChecksumReport)
+], UserCodeCCUserCodeChecksumGet);
+let UserCodeCCExtendedUserCodeSet = class UserCodeCCExtendedUserCodeSet2 extends UserCodeCC {
+  constructor(options) {
+    super(options);
+    this.userCodes = options.userCodes;
+  }
+  static from(_raw, _ctx) {
+    throw new import_safe.ZWaveError(`${this.name}: deserialization not implemented`, import_safe.ZWaveErrorCodes.Deserialization_NotImplemented);
+  }
+  userCodes;
+  serialize(ctx) {
+    const userCodeBuffers = this.userCodes.map((code) => {
+      const ret = import_safe2.Bytes.concat([
+        import_safe2.Bytes.from([
+          0,
+          0,
+          code.userIdStatus,
+          code.userCode?.length ?? 0
+        ]),
+        (0, import_safe2.isUint8Array)(code.userCode) ? code.userCode : import_safe2.Bytes.from(code.userCode ?? "", "ascii")
+      ]);
+      ret.writeUInt16BE(code.userId, 0);
+      return ret;
+    });
+    this.payload = import_safe2.Bytes.concat([
+      import_safe2.Bytes.from([this.userCodes.length]),
+      ...userCodeBuffers
+    ]);
+    return super.serialize(ctx);
+  }
+  toLogEntry(ctx) {
+    const message = {};
+    for (const { userId, userIdStatus, userCode } of this.userCodes) {
+      message[`code #${userId}`] = `${userCodeToLogString(userCode ?? "")} (status: ${(0, import_safe3.getEnumMemberName)(import_Types.UserIDStatus, userIdStatus)})`;
+    }
+    return {
+      ...super.toLogEntry(ctx),
+      message
+    };
+  }
+};
+UserCodeCCExtendedUserCodeSet = __decorate([
+  (0, import_CommandClassDecorators.CCCommand)(import_Types.UserCodeCommand.ExtendedUserCodeSet),
+  (0, import_CommandClassDecorators.useSupervision)()
+], UserCodeCCExtendedUserCodeSet);
+let UserCodeCCExtendedUserCodeReport = UserCodeCCExtendedUserCodeReport_1 = class UserCodeCCExtendedUserCodeReport2 extends UserCodeCC {
+  constructor(options) {
+    super(options);
+    this.userCodes = options.userCodes;
+    this.nextUserId = options.nextUserId;
+  }
+  static from(raw, ctx) {
+    (0, import_safe.validatePayload)(raw.payload.length >= 1);
+    const numCodes = raw.payload[0];
+    let offset = 1;
+    const userCodes = [];
+    for (let i = 0; i < numCodes; i++) {
+      const { code, bytesRead } = parseExtendedUserCode(raw.payload.subarray(offset));
+      userCodes.push(code);
+      offset += bytesRead;
+    }
+    (0, import_safe.validatePayload)(raw.payload.length >= offset + 2);
+    const nextUserId = raw.payload.readUInt16BE(offset);
+    return new UserCodeCCExtendedUserCodeReport_1({
+      nodeId: ctx.sourceNodeId,
+      userCodes,
+      nextUserId
+    });
+  }
+  persistValues(ctx) {
+    if (!super.persistValues(ctx))
+      return false;
+    for (const { userId, userIdStatus, userCode } of this.userCodes) {
+      persistUserCode.call(this, ctx, userId, userIdStatus, userCode);
+    }
+    return true;
+  }
+  userCodes;
+  nextUserId;
+  toLogEntry(ctx) {
+    const message = {};
+    for (const { userId, userIdStatus, userCode } of this.userCodes) {
+      message[`code #${userId}`] = `${userCodeToLogString(userCode)} (status: ${(0, import_safe3.getEnumMemberName)(import_Types.UserIDStatus, userIdStatus)})`;
+    }
+    message["next user id"] = this.nextUserId;
+    return {
+      ...super.toLogEntry(ctx),
+      message
+    };
+  }
+};
+UserCodeCCExtendedUserCodeReport = UserCodeCCExtendedUserCodeReport_1 = __decorate([
+  (0, import_CommandClassDecorators.CCCommand)(import_Types.UserCodeCommand.ExtendedUserCodeReport)
+], UserCodeCCExtendedUserCodeReport);
+let UserCodeCCExtendedUserCodeGet = class UserCodeCCExtendedUserCodeGet2 extends UserCodeCC {
+  constructor(options) {
+    super(options);
+    this.userId = options.userId;
+    this.reportMore = !!options.reportMore;
+  }
+  static from(_raw, _ctx) {
+    throw new import_safe.ZWaveError(`${this.name}: deserialization not implemented`, import_safe.ZWaveErrorCodes.Deserialization_NotImplemented);
+  }
+  userId;
+  reportMore;
+  serialize(ctx) {
+    this.payload = import_safe2.Bytes.from([0, 0, this.reportMore ? 1 : 0]);
+    this.payload.writeUInt16BE(this.userId, 0);
+    return super.serialize(ctx);
+  }
+  toLogEntry(ctx) {
+    return {
+      ...super.toLogEntry(ctx),
+      message: {
+        "user id": this.userId,
+        "report more": this.reportMore
+      }
+    };
+  }
+};
+UserCodeCCExtendedUserCodeGet = __decorate([
+  (0, import_CommandClassDecorators.CCCommand)(import_Types.UserCodeCommand.ExtendedUserCodeGet),
+  (0, import_CommandClassDecorators.expectedCCResponse)(UserCodeCCExtendedUserCodeReport)
+], UserCodeCCExtendedUserCodeGet);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  UserCodeCC,
+  UserCodeCCAPI,
+  UserCodeCCAdminCodeGet,
+  UserCodeCCAdminCodeReport,
+  UserCodeCCAdminCodeSet,
+  UserCodeCCCapabilitiesGet,
+  UserCodeCCCapabilitiesReport,
+  UserCodeCCExtendedUserCodeGet,
+  UserCodeCCExtendedUserCodeReport,
+  UserCodeCCExtendedUserCodeSet,
+  UserCodeCCGet,
+  UserCodeCCKeypadModeGet,
+  UserCodeCCKeypadModeReport,
+  UserCodeCCKeypadModeSet,
+  UserCodeCCReport,
+  UserCodeCCSet,
+  UserCodeCCUserCodeChecksumGet,
+  UserCodeCCUserCodeChecksumReport,
+  UserCodeCCUsersNumberGet,
+  UserCodeCCUsersNumberReport,
+  UserCodeCCValues,
+  userCodeToLogString
+});
+//# sourceMappingURL=UserCodeCC.js.map