@matter/model 0.11.0-alpha.0-20241005-e3e4e4a7a

package/dist/cjs/standard/elements/DoorLock.js

@@ -0,0 +1,3347 @@
+"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 DoorLock_exports = {};
+__export(DoorLock_exports, {
+  DoorLock: () => DoorLock
+});
+module.exports = __toCommonJS(DoorLock_exports);
+var import_MatterDefinition = require("../MatterDefinition.js");
+var import_elements = require("../../elements/index.js");
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+const DoorLock = (0, import_elements.ClusterElement)({
+  name: "DoorLock",
+  id: 257,
+  classification: "application",
+  pics: "DRLK",
+  details: "The door lock cluster provides an interface to a generic way to secure a door. The physical object that provides the locking functionality is abstracted from the cluster. The cluster has a small list of mandatory attributes and functions and a list of optional features.",
+  xref: { document: "cluster", section: "5.2" },
+  children: [
+    (0, import_elements.AttributeElement)({ name: "ClusterRevision", id: 65533, type: "ClusterRevision", default: 7 }),
+    (0, import_elements.AttributeElement)({
+      name: "FeatureMap",
+      id: 65532,
+      type: "FeatureMap",
+      xref: { document: "cluster", section: "5.2.4" },
+      children: [
+        (0, import_elements.FieldElement)({
+          name: "PIN",
+          conformance: "O",
+          constraint: "0",
+          description: "PinCredential",
+          details: "If the User Feature is also supported then any PIN Code stored in the lock shall be associated with a User.\nA lock may support multiple credential types so if the User feature is supported the UserType, UserStatus and Schedules are all associated with a User index and not directly with a PIN index. A User index may have several credentials associated with it.",
+          xref: { document: "cluster", section: "5.2.4.1" }
+        }),
+        (0, import_elements.FieldElement)({
+          name: "RID",
+          conformance: "O",
+          constraint: "1",
+          description: "RfidCredential",
+          details: "If the User Feature is also supported then any RFID credential stored in the lock shall be associated with a User.\nA lock may support multiple credential types so if the User feature is supported the UserType, UserStatus and Schedules are all associated with a User index and not directly with a RFID index. A User\nIndex may have several credentials associated with it.",
+          xref: { document: "cluster", section: "5.2.4.2" }
+        }),
+        (0, import_elements.FieldElement)({
+          name: "FGP",
+          conformance: "P, O",
+          constraint: "2",
+          description: "FingerCredentials",
+          details: "Currently the cluster only defines the metadata format for notifications when a fingerprint/ finger vein credential is used to access the lock and doesn\u2019t describe how to create fingerprint/finger vein credentials. If the Users feature is also supported then the User that a fingerprint/finger vein is associated with can also have its UserType, UserStatus and Schedule modified.\nA lock may support multiple credential types so if the User feature is supported the UserType, UserStatus and Schedules are all associated with a User index and not directly with a Finger index. A User Index may have several credentials associated with it.",
+          xref: { document: "cluster", section: "5.2.4.3" }
+        }),
+        (0, import_elements.FieldElement)({
+          name: "LOG",
+          conformance: "O",
+          constraint: "3",
+          description: "Logging",
+          details: "If Events are not supported the logging feature shall replace the Event reporting structure. If Events are supported the logging feature shall NOT be supported.",
+          xref: { document: "cluster", section: "5.2.4.4" }
+        }),
+        (0, import_elements.FieldElement)({
+          name: "WDSCH",
+          conformance: "O",
+          constraint: "4",
+          description: "WeekDayAccessSchedules",
+          details: "If the User feature is supported then Week Day Schedules are applied to a User and not a credential.\nWeek Day Schedules are used to restrict access to a specified time window on certain days of the week. The schedule is repeated each week. When a schedule is cleared this clears the access restrictions and grants unrestricted access to the user. The lock may automatically adjust the UserType when a schedule is created or cleared.",
+          xref: { document: "cluster", section: "5.2.4.5" }
+        }),
+        (0, import_elements.FieldElement)({
+          name: "DPS",
+          conformance: "O",
+          constraint: "5",
+          description: "DoorPositionSensor",
+          details: "If this feature is supported this indicates that the lock has the ability to determine the position of the door which is separate from the state of the lock.",
+          xref: { document: "cluster", section: "5.2.4.6" }
+        }),
+        (0, import_elements.FieldElement)({
+          name: "FACE",
+          conformance: "P, O",
+          constraint: "6",
+          description: "FaceCredentials",
+          details: "Currently the cluster only defines the metadata format for notifications when a face recognition, iris, or retina credential is used to access the lock and doesn\u2019t describe how to create face recognition, iris, or retina credentials. If the Users feature is also supported then the User that a face recognition, iris, or retina credential is associated with can also have its UserType, UserStatus and Schedule modified.\nA lock may support multiple credential types so if the User feature is supported the UserType, UserStatus and Schedules are all associated with a User and not directly with a credential.",
+          xref: { document: "cluster", section: "5.2.4.7" }
+        }),
+        (0, import_elements.FieldElement)({
+          name: "COTA",
+          conformance: "O",
+          constraint: "7",
+          description: "CredentialOverTheAirAccess",
+          details: "If this feature is supported then the lock supports the ability to verify a credential provided in a lock/unlock command. Currently the cluster only supports providing the PIN credential to the lock/unlock commands. If this feature is supported then the PIN Credential feature shall also be supported.",
+          xref: { document: "cluster", section: "5.2.4.8" }
+        }),
+        (0, import_elements.FieldElement)({
+          name: "USR",
+          conformance: "[PIN | RID | FGP | FACE]",
+          constraint: "8",
+          description: "User",
+          details: "If the User Feature is supported then a lock employs a User database. A User within the User database is used to associate credentials and schedules to single user record within the lock. This also means the UserType and UserStatus fields are associated with a User and not a credential.",
+          xref: { document: "cluster", section: "5.2.4.9" }
+        }),
+        (0, import_elements.FieldElement)({
+          name: "NOT",
+          conformance: "O",
+          constraint: "9",
+          description: "Notification",
+          details: "This is a feature used before support of events. This feature supports notification commands and masks used to filter these notifications.",
+          xref: { document: "cluster", section: "5.2.4.10" }
+        }),
+        (0, import_elements.FieldElement)({
+          name: "YDSCH",
+          conformance: "O",
+          constraint: "10",
+          description: "YearDayAccessSchedules",
+          details: "If the User feature is supported then Year Day Schedules are applied to a User and not a credential.\nYear Day Schedules are used to restrict access to a specified date and time window. When a schedule is cleared this clears the access restrictions and grants unrestricted access to the user. The lock may automatically adjust the UserType when a schedule is created or cleared.",
+          xref: { document: "cluster", section: "5.2.4.11" }
+        }),
+        (0, import_elements.FieldElement)({
+          name: "HDSCH",
+          conformance: "O",
+          constraint: "11",
+          description: "HolidaySchedules",
+          details: "This feature is used to setup Holiday Schedule in the lock device. A Holiday Schedule sets a start and stop end date/time for the lock to use the specified operating mode set by the Holiday Schedule.",
+          xref: { document: "cluster", section: "5.2.4.12" }
+        }),
+        (0, import_elements.FieldElement)({
+          name: "UBOLT",
+          conformance: "O",
+          constraint: "12",
+          description: "Unbolting",
+          details: "Locks that support this feature differentiate between unbolting and unlocking. The Unbolt Door command retracts the bolt without pulling the latch. The Unlock Door command fully unlocks the door by retracting the bolt and briefly pulling the latch. While the latch is pulled, the lock state changes to Unlatched. Locks without unbolting support don\u2019t differentiate between unbolting and unlocking and perform the same operation for both commands.",
+          xref: { document: "cluster", section: "5.2.4.13" }
+        })
+      ]
+    }),
+    (0, import_elements.AttributeElement)({
+      name: "LockState",
+      id: 0,
+      type: "LockStateEnum",
+      access: "R V",
+      conformance: "M",
+      constraint: "desc",
+      quality: "X S P",
+      details: "This attribute may be NULL if the lock hardware does not currently know the status of the locking mechanism. For example, a lock may not know the LockState status after a power cycle until the first lock actuation is completed.\nThe Not Fully Locked value is used by a lock to indicate that the state of the lock is somewhere between Locked and Unlocked so it is only partially secured. For example, a deadbolt could be partially extended and not in a dead latched state.",
+      xref: { document: "cluster", section: "5.2.9.2" }
+    }),
+    (0, import_elements.AttributeElement)({
+      name: "LockType",
+      id: 1,
+      type: "LockTypeEnum",
+      access: "R V",
+      conformance: "M",
+      constraint: "desc",
+      details: "Indicates the type of door lock as defined in LockTypeEnum.",
+      xref: { document: "cluster", section: "5.2.9.3" }
+    }),
+    (0, import_elements.AttributeElement)({
+      name: "ActuatorEnabled",
+      id: 2,
+      type: "bool",
+      access: "R V",
+      conformance: "M",
+      details: "Indicates if the lock is currently able to (Enabled) or not able to (Disabled) process remote Lock, Unlock, or Unlock with Timeout commands.",
+      xref: { document: "cluster", section: "5.2.9.4" }
+    }),
+    (0, import_elements.AttributeElement)({
+      name: "DoorState",
+      id: 3,
+      type: "DoorStateEnum",
+      access: "R V",
+      conformance: "DPS",
+      constraint: "desc",
+      quality: "X P",
+      details: "Indicates the current door state as defined in DoorStateEnum.\nNull only if an internal error prevents the retrieval of the current door state.",
+      xref: { document: "cluster", section: "5.2.9.5" }
+    }),
+    (0, import_elements.AttributeElement)({
+      name: "DoorOpenEvents",
+      id: 4,
+      type: "uint32",
+      access: "RW VM",
+      conformance: "[DPS]",
+      details: "This attribute shall hold the number of door open events that have occurred since it was last zeroed.",
+      xref: { document: "cluster", section: "5.2.9.6" }
+    }),
+    (0, import_elements.AttributeElement)({
+      name: "DoorClosedEvents",
+      id: 5,
+      type: "uint32",
+      access: "RW VM",
+      conformance: "[DPS]",
+      details: "This attribute shall hold the number of door closed events that have occurred since it was last zeroed.",
+      xref: { document: "cluster", section: "5.2.9.7" }
+    }),
+    (0, import_elements.AttributeElement)({
+      name: "OpenPeriod",
+      id: 6,
+      type: "uint16",
+      access: "RW VM",
+      conformance: "[DPS]",
+      details: "This attribute shall hold the number of minutes the door has been open since the last time it transitioned from closed to open.",
+      xref: { document: "cluster", section: "5.2.9.8" }
+    }),
+    (0, import_elements.AttributeElement)({
+      name: "NumberOfLogRecordsSupported",
+      id: 16,
+      type: "uint16",
+      access: "R V",
+      conformance: "LOG",
+      default: 0,
+      quality: "F",
+      details: "Indicates the number of available log records.",
+      xref: { document: "cluster", section: "5.2.9.9" }
+    }),
+    (0, import_elements.AttributeElement)({
+      name: "NumberOfTotalUsersSupported",
+      id: 17,
+      type: "uint16",
+      access: "R V",
+      conformance: "USR",
+      default: 0,
+      quality: "F",
+      details: "Indicates the number of total users supported by the lock.",
+      xref: { document: "cluster", section: "5.2.9.10" }
+    }),
+    (0, import_elements.AttributeElement)({
+      name: "NumberOfPinUsersSupported",
+      id: 18,
+      type: "uint16",
+      access: "R V",
+      conformance: "PIN",
+      default: 0,
+      quality: "F",
+      details: "Indicates the number of PIN users supported.",
+      xref: { document: "cluster", section: "5.2.9.11" }
+    }),
+    (0, import_elements.AttributeElement)({
+      name: "NumberOfRfidUsersSupported",
+      id: 19,
+      type: "uint16",
+      access: "R V",
+      conformance: "RID",
+      default: 0,
+      quality: "F",
+      details: "Indicates the number of RFID users supported.",
+      xref: { document: "cluster", section: "5.2.9.12" }
+    }),
+    (0, import_elements.AttributeElement)({
+      name: "NumberOfWeekDaySchedulesSupportedPerUser",
+      id: 20,
+      type: "uint8",
+      access: "R V",
+      conformance: "WDSCH",
+      default: 0,
+      quality: "F",
+      details: "Indicates the number of configurable week day schedule supported per user.",
+      xref: { document: "cluster", section: "5.2.9.13" }
+    }),
+    (0, import_elements.AttributeElement)({
+      name: "NumberOfYearDaySchedulesSupportedPerUser",
+      id: 21,
+      type: "uint8",
+      access: "R V",
+      conformance: "YDSCH",
+      default: 0,
+      quality: "F",
+      details: "Indicates the number of configurable year day schedule supported per user.",
+      xref: { document: "cluster", section: "5.2.9.14" }
+    }),
+    (0, import_elements.AttributeElement)({
+      name: "NumberOfHolidaySchedulesSupported",
+      id: 22,
+      type: "uint8",
+      access: "R V",
+      conformance: "HDSCH",
+      default: 0,
+      quality: "F",
+      details: "Indicates the number of holiday schedules supported for the entire door lock device.",
+      xref: { document: "cluster", section: "5.2.9.15" }
+    }),
+    (0, import_elements.AttributeElement)({
+      name: "MaxPinCodeLength",
+      id: 23,
+      type: "uint8",
+      access: "R V",
+      conformance: "PIN",
+      quality: "F",
+      details: "Indicates the maximum length in bytes of a PIN Code on this device.",
+      xref: { document: "cluster", section: "5.2.9.16" }
+    }),
+    (0, import_elements.AttributeElement)({
+      name: "MinPinCodeLength",
+      id: 24,
+      type: "uint8",
+      access: "R V",
+      conformance: "PIN",
+      quality: "F",
+      details: "Indicates the minimum length in bytes of a PIN Code on this device.",
+      xref: { document: "cluster", section: "5.2.9.17" }
+    }),
+    (0, import_elements.AttributeElement)({
+      name: "MaxRfidCodeLength",
+      id: 25,
+      type: "uint8",
+      access: "R V",
+      conformance: "RID",
+      quality: "F",
+      details: "Indicates the maximum length in bytes of a RFID Code on this device. The value depends on the RFID code range specified by the manufacturer, if media anti-collision identifiers (UID) are used as RFID code, a value of 20 (equals 10 Byte ISO 14443A UID) is recommended.",
+      xref: { document: "cluster", section: "5.2.9.18" }
+    }),
+    (0, import_elements.AttributeElement)({
+      name: "MinRfidCodeLength",
+      id: 26,
+      type: "uint8",
+      access: "R V",
+      conformance: "RID",
+      quality: "F",
+      details: "Indicates the minimum length in bytes of a RFID Code on this device. The value depends on the RFID code range specified by the manufacturer, if media anti-collision identifiers (UID) are used as RFID code, a value of 8 (equals 4 Byte ISO 14443A UID) is recommended.",
+      xref: { document: "cluster", section: "5.2.9.19" }
+    }),
+    (0, import_elements.AttributeElement)({
+      name: "CredentialRulesSupport",
+      id: 27,
+      type: "CredentialRulesBitmap",
+      access: "R V",
+      conformance: "USR",
+      default: 1,
+      quality: "F",
+      details: "This attribute shall contain a bitmap with the bits set for the values of CredentialRuleEnum supported on this device.",
+      xref: { document: "cluster", section: "5.2.9.20" }
+    }),
+    (0, import_elements.AttributeElement)({
+      name: "NumberOfCredentialsSupportedPerUser",
+      id: 28,
+      type: "uint8",
+      access: "R V",
+      conformance: "USR",
+      default: 0,
+      quality: "F",
+      details: "Indicates the number of credentials that could be assigned for each user.\nDepending on the value of NumberOfRFIDUsersSupported and NumberOfPINUsersSupported it may not be possible to assign that number of credentials for a user.\nFor example, if the device supports only PIN and RFID credential types, NumberOfCredentialsSupportedPerUser is set to 10, NumberOfPINUsersSupported is set to 5 and NumberOfRFIDUsersSupported is set to 3, it will not be possible to actually assign 10 credentials for a user because maximum number of credentials in the database is 8.",
+      xref: { document: "cluster", section: "5.2.9.21" }
+    }),
+    (0, import_elements.AttributeElement)({
+      name: "EnableLogging",
+      id: 32,
+      type: "bool",
+      access: "R[W] VA",
+      conformance: "LOG",
+      default: true,
+      quality: "P",
+      details: "This attribute shall enable/disable event logging.\nWhen event logging is enabled, all event messages are stored on the lock for retrieval. Logging events can be, but are not limited to, Tamper Alarm, Lock, Unlock, AutoRelock, User Code Added, User Code Cleared, Schedule Added, and Schedule Cleared. For a full detail of all the possible alarms and events, please refer to the full list in the Alarm and Event Masks Attribute Set.",
+      xref: { document: "cluster", section: "5.2.9.22" }
+    }),
+    (0, import_elements.AttributeElement)({
+      name: "Language",
+      id: 33,
+      type: "string",
+      access: "R[W] VM",
+      conformance: "O",
+      constraint: "max 3",
+      quality: "P",
+      details: "Indicates the language for the on-screen or audible user interface using a 2- byte language code from ISO-639-1.",
+      xref: { document: "cluster", section: "5.2.9.23" }
+    }),
+    (0, import_elements.AttributeElement)({
+      name: "LedSettings",
+      id: 34,
+      type: "LEDSettingEnum",
+      access: "R[W] VM",
+      conformance: "O",
+      default: 0,
+      quality: "P",
+      details: "Indicates the settings for the LED support, as defined by LEDSettingEnum.",
+      xref: { document: "cluster", section: "5.2.9.24" }
+    }),
+    (0, import_elements.AttributeElement)({
+      name: "AutoRelockTime",
+      id: 35,
+      type: "uint32",
+      access: "R[W] VM",
+      conformance: "O",
+      quality: "P",
+      details: "Indicates the number of seconds to wait after unlocking a lock before it automatically locks again. 0=disabled. If set, unlock operations from any source will be timed. For one time unlock with timeout use the specific command.",
+      xref: { document: "cluster", section: "5.2.9.25" }
+    }),
+    (0, import_elements.AttributeElement)({
+      name: "SoundVolume",
+      id: 36,
+      type: "SoundVolumeEnum",
+      access: "R[W] VM",
+      conformance: "O",
+      default: 0,
+      quality: "P",
+      details: "Indicates the sound volume on a door lock as defined by SoundVolumeEnum.",
+      xref: { document: "cluster", section: "5.2.9.26" }
+    }),
+    (0, import_elements.AttributeElement)({
+      name: "OperatingMode",
+      id: 37,
+      type: "OperatingModeEnum",
+      access: "R[W] VM",
+      conformance: "M",
+      constraint: "desc",
+      default: 0,
+      quality: "P",
+      details: "Indicates the current operating mode of the lock as defined in OperatingModeEnum.",
+      xref: { document: "cluster", section: "5.2.9.27" }
+    }),
+    (0, import_elements.AttributeElement)({
+      name: "SupportedOperatingModes",
+      id: 38,
+      type: "OperatingModesBitmap",
+      access: "R V",
+      conformance: "M",
+      default: 65526,
+      quality: "F",
+      details: "This attribute shall contain a bitmap with all operating bits of the OperatingMode attribute supported by the lock. All operating modes NOT supported by a lock shall be set to one. The value of the OperatingMode enumeration defines the related bit to be set.",
+      xref: { document: "cluster", section: "5.2.9.28" }
+    }),
+    (0, import_elements.AttributeElement)({
+      name: "DefaultConfigurationRegister",
+      id: 39,
+      type: "ConfigurationRegisterBitmap",
+      access: "R V",
+      conformance: "O",
+      default: 0,
+      quality: "P",
+      details: "Indicates the default configurations as they are physically set on the device (example: hardware dip switch setting, etc\u2026) and represents the default setting for some of the attributes within this cluster (for example: LED, Auto Lock, Sound Volume, and Operating Mode attributes).\nThis is a read-only attribute and is intended to allow clients to determine what changes may need to be made without having to query all the included attributes. It may be beneficial for the clients to know what the device\u2019s original settings were in the event that the device needs to be restored to factory default settings.\nIf the Client device would like to query and modify the door lock server\u2019s operating settings, it SHOULD send read and write attribute requests to the specific attributes.\nFor example, the Sound Volume attribute default value is Silent Mode. However, it is possible that the current Sound Volume is High Volume. Therefore, if the client wants to query/modify the current Sound Volume setting on the server, the client SHOULD read/write to the Sound Volume attribute.",
+      xref: { document: "cluster", section: "5.2.9.29" }
+    }),
+    (0, import_elements.AttributeElement)({
+      name: "EnableLocalProgramming",
+      id: 40,
+      type: "bool",
+      access: "R[W] VA",
+      conformance: "O",
+      default: true,
+      quality: "P",
+      details: "This attribute shall enable/disable local programming on the door lock of certain features (see LocalProgrammingFeatures attribute). If this value is set to TRUE then local programming is enabled on the door lock for all features. If it is set to FALSE then local programming is disabled on the door lock for those features whose bit is set to 0 in the LocalProgrammingFeatures attribute. Local programming shall be enabled by default.",
+      xref: { document: "cluster", section: "5.2.9.30" }
+    }),
+    (0, import_elements.AttributeElement)({
+      name: "EnableOneTouchLocking",
+      id: 41,
+      type: "bool",
+      access: "RW VM",
+      conformance: "O",
+      default: true,
+      quality: "P",
+      details: "This attribute shall enable/disable the ability to lock the door lock with a single touch on the door lock.",
+      xref: { document: "cluster", section: "5.2.9.31" }
+    }),
+    (0, import_elements.AttributeElement)({
+      name: "EnableInsideStatusLed",
+      id: 42,
+      type: "bool",
+      access: "RW VM",
+      conformance: "O",
+      default: true,
+      quality: "P",
+      details: "This attribute shall enable/disable an inside LED that allows the user to see at a glance if the door is locked.",
+      xref: { document: "cluster", section: "5.2.9.32" }
+    }),
+    (0, import_elements.AttributeElement)({
+      name: "EnablePrivacyModeButton",
+      id: 43,
+      type: "bool",
+      access: "RW VM",
+      conformance: "O",
+      default: true,
+      quality: "P",
+      details: "This attribute shall enable/disable a button inside the door that is used to put the lock into privacy mode. When the lock is in privacy mode it cannot be manipulated from the outside.",
+      xref: { document: "cluster", section: "5.2.9.33" }
+    }),
+    (0, import_elements.AttributeElement)({
+      name: "LocalProgrammingFeatures",
+      id: 44,
+      type: "LocalProgrammingFeaturesBitmap",
+      access: "R[W] VA",
+      conformance: "O",
+      default: 0,
+      quality: "P",
+      details: "Indicates the local programming features that will be disabled when EnableLocalProgramming attribute is set to False. If a door lock doesn\u2019t support disabling one aspect of local programming it shall return CONSTRAINT_ERROR during a write operation of this attribute. If the EnableLocalProgramming attribute is set to True then all local programming features shall be enabled regardless of the bits set to 0 in this attribute.\nThe features that can be disabled from local programming are defined in LocalProgrammingFeaturesBitmap.",
+      xref: { document: "cluster", section: "5.2.9.34" }
+    }),
+    (0, import_elements.AttributeElement)({
+      name: "WrongCodeEntryLimit",
+      id: 48,
+      type: "uint8",
+      access: "R[W] VA",
+      conformance: "PIN | RID",
+      constraint: "1 to 255",
+      quality: "P",
+      details: "Indicates the number of incorrect Pin codes or RFID presentment attempts a user is allowed to enter before the lock will enter a lockout state. The value of this attribute is compared to all failing forms of credential presentation, including Pin codes used in an Unlock Command when RequirePINforRemoteOperation is set to true. Valid range is 1-255 incorrect attempts. The lockout state will be for the duration of UserCodeTemporaryDisableTime. If the attribute accepts writes and an attempt to write the value 0 is made, the device shall respond with CONSTRAINT_ERROR.\nThe lock may reset the counter used to track incorrect credential presentations as required by internal logic, environmental events, or other reasons. The lock shall reset the counter if a valid credential is presented.",
+      xref: { document: "cluster", section: "5.2.9.35" }
+    }),
+    (0, import_elements.AttributeElement)({
+      name: "UserCodeTemporaryDisableTime",
+      id: 49,
+      type: "uint8",
+      access: "R[W] VA",
+      conformance: "PIN | RID",
+      constraint: "1 to 255",
+      quality: "P",
+      details: "Indicates the number of seconds that the lock shuts down following wrong code entry. Valid range is 1-255 seconds. Device can shut down to lock user out for specified amount of time. (Makes it difficult to try and guess a PIN for the device.) If the attribute accepts writes and an attempt to write the attribute to 0 is made, the device shall respond with CONSTRAINT_ERROR.",
+      xref: { document: "cluster", section: "5.2.9.36" }
+    }),
+    (0, import_elements.AttributeElement)({
+      name: "SendPinOverTheAir",
+      id: 50,
+      type: "bool",
+      access: "R[W] VA",
+      conformance: "[!USR & PIN]",
+      default: true,
+      quality: "P",
+      details: 'Indicates the door locks ability to send PINs over the air. If the attribute is True it is ok for the door lock server to send PINs over the air. This attribute determines the behavior of the server\u2019s TX operation. If it is false, then it is not ok for the device to send PIN in any messages over the air.\nThe PIN field within any door lock cluster message shall keep the first octet unchanged and masks the actual code by replacing with 0xFF. For example (PIN "1234" ): If the attribute value is True, 0x04 0x31 0x32 0x33 0x34 shall be used in the PIN field in any door lock cluster message payload. If the attribute value is False, 0x04 0xFF 0xFF 0xFF 0xFF shall be used.',
+      xref: { document: "cluster", section: "5.2.9.37" }
+    }),
+    (0, import_elements.AttributeElement)({
+      name: "RequirePinForRemoteOperation",
+      id: 51,
+      type: "bool",
+      access: "R[W] VA",
+      conformance: "COTA & PIN",
+      default: true,
+      quality: "P",
+      details: "Indicates if the door lock requires an optional PIN. If this attribute is set to True, the door lock server requires that an optional PINs be included in the payload of remote lock operation events like Lock, Unlock, Unlock with Timeout and Toggle in order to function.",
+      xref: { document: "cluster", section: "5.2.9.38" }
+    }),
+    (0, import_elements.AttributeElement)({
+      name: "SecurityLevel",
+      id: 52,
+      conformance: "D",
+      default: "0",
+      xref: { document: "cluster", section: "5.2.9" }
+    }),
+    (0, import_elements.AttributeElement)({
+      name: "ExpiringUserTimeout",
+      id: 53,
+      type: "uint16",
+      access: "R[W] VA",
+      conformance: "[USR]",
+      constraint: "1 to 2880",
+      quality: "P",
+      details: "Indicates the number of minutes a PIN, RFID, Fingerprint, or other credential associated with a user of type ExpiringUser shall remain valid after its first use before expiring. When the credential expires the UserStatus for the corresponding user record shall be set to OccupiedDisabled.",
+      xref: { document: "cluster", section: "5.2.9.39" }
+    }),
+    (0, import_elements.AttributeElement)({
+      name: "AlarmMask",
+      id: 64,
+      type: "AlarmMaskBitmap",
+      access: "RW VA",
+      conformance: "O",
+      default: 65535,
+      quality: "P",
+      details: "This attribute is only supported if the Alarms cluster is on the same endpoint. The alarm mask is used to turn on/off alarms for particular functions. Alarms for an alarm group are enabled if the associated alarm mask bit is set. Each bit represents a group of alarms. Entire alarm groups can be turned on or off by setting or clearing the associated bit in the alarm mask.\nThis mask DOES NOT apply to the Events mechanism of this cluster.",
+      xref: { document: "cluster", section: "5.2.9.40" }
+    }),
+    (0, import_elements.AttributeElement)({
+      name: "KeypadOperationEventMask",
+      id: 65,
+      type: "EventMaskBitmap",
+      access: "RW VA",
+      conformance: "[NOT & PIN]",
+      default: 65535,
+      quality: "P",
+      details: "Event mask used to turn on and off the transmission of keypad operation events. This mask DOES NOT apply to the storing of events in the event log. This mask only applies to the Operation Event Notification Command.\nThis mask DOES NOT apply to the Events mechanism of this cluster.",
+      xref: { document: "cluster", section: "5.2.9.41" }
+    }),
+    (0, import_elements.AttributeElement)({
+      name: "RemoteOperationEventMask",
+      id: 66,
+      type: "EventMaskBitmap",
+      access: "RW VA",
+      conformance: "[NOT]",
+      default: 65535,
+      quality: "P",
+      details: "Event mask used to turn on and off the transmission of remote operation events. This mask DOES NOT apply to the storing of events in the event log. This mask only applies to the Operation Event Notification Command.\nThis mask DOES NOT apply to the Events mechanism of this cluster.",
+      xref: { document: "cluster", section: "5.2.9.42" }
+    }),
+    (0, import_elements.AttributeElement)({
+      name: "ManualOperationEventMask",
+      id: 67,
+      type: "EventMaskBitmap",
+      access: "RW VA",
+      conformance: "[NOT]",
+      default: 65535,
+      quality: "P",
+      details: "Event mask used to turn on and off manual operation events. This mask DOES NOT apply to the storing of events in the event log. This mask only applies to the Operation Event Notification Command.\nThis mask DOES NOT apply to the Events mechanism of this cluster.",
+      xref: { document: "cluster", section: "5.2.9.43" }
+    }),
+    (0, import_elements.AttributeElement)({
+      name: "RfidOperationEventMask",
+      id: 68,
+      type: "EventMaskBitmap",
+      access: "RW VA",
+      conformance: "[NOT & RID]",
+      default: 65535,
+      quality: "P",
+      details: "Event mask used to turn on and off RFID operation events. This mask DOES NOT apply to the storing of events in the event log. This mask only applies to the Operation Event Notification Command.\nThis mask DOES NOT apply to the Events mechanism of this cluster.",
+      xref: { document: "cluster", section: "5.2.9.44" }
+    }),
+    (0, import_elements.AttributeElement)({
+      name: "KeypadProgrammingEventMask",
+      id: 69,
+      type: "EventMaskBitmap",
+      access: "RW VA",
+      conformance: "[NOT & PIN]",
+      default: 65535,
+      quality: "P",
+      details: "Event mask used to turn on and off keypad programming events. This mask DOES NOT apply to the storing of events in the event log. This mask only applies to the Programming Event Notification Command.\nThis mask DOES NOT apply to the Events mechanism of this cluster.",
+      xref: { document: "cluster", section: "5.2.9.45" },
+      children: [
+        (0, import_elements.FieldElement)({ name: "Unknown", constraint: "0" }),
+        (0, import_elements.FieldElement)({ name: "PinCodeChanged", constraint: "1" }),
+        (0, import_elements.FieldElement)({ name: "PinAdded", constraint: "2" }),
+        (0, import_elements.FieldElement)({ name: "PinCleared", constraint: "3" }),
+        (0, import_elements.FieldElement)({ name: "PinChanged", constraint: "4" })
+      ]
+    }),
+    (0, import_elements.AttributeElement)({
+      name: "RemoteProgrammingEventMask",
+      id: 70,
+      type: "EventMaskBitmap",
+      access: "RW VA",
+      conformance: "[NOT]",
+      default: 65535,
+      quality: "P",
+      details: "Event mask used to turn on and off remote programming events. This mask DOES NOT apply to the storing of events in the event log. This mask only applies to the Programming Event Notification Command.\nThis mask DOES NOT apply to the Events mechanism of this cluster.",
+      xref: { document: "cluster", section: "5.2.9.46" },
+      children: [
+        (0, import_elements.FieldElement)({ name: "Unknown", constraint: "0" }),
+        (0, import_elements.FieldElement)({ name: "PinAdded", constraint: "2" }),
+        (0, import_elements.FieldElement)({ name: "PinCleared", constraint: "3" }),
+        (0, import_elements.FieldElement)({ name: "PinChanged", constraint: "4" }),
+        (0, import_elements.FieldElement)({ name: "RfidCodeAdded", constraint: "5" }),
+        (0, import_elements.FieldElement)({ name: "RfidCodeCleared", constraint: "6" })
+      ]
+    }),
+    (0, import_elements.AttributeElement)({
+      name: "RfidProgrammingEventMask",
+      id: 71,
+      type: "EventMaskBitmap",
+      access: "RW VA",
+      conformance: "[NOT & RID]",
+      default: 65535,
+      quality: "P",
+      details: "Event mask used to turn on and off RFID programming events. This mask DOES NOT apply to the storing of events in the event log. This mask only applies to the Programming Event Notification Command.\nThis mask DOES NOT apply to the Events mechanism of this cluster.\nThis mask DOES NOT apply to the Events mechanism of this cluster.",
+      xref: { document: "cluster", section: "5.2.9.47" },
+      children: [
+        (0, import_elements.FieldElement)({ name: "Unknown", constraint: "0" }),
+        (0, import_elements.FieldElement)({ name: "IdAdded", constraint: "5" }),
+        (0, import_elements.FieldElement)({ name: "IdCleared", constraint: "6" })
+      ]
+    }),
+    (0, import_elements.EventElement)({
+      name: "DoorLockAlarm",
+      id: 0,
+      access: "V",
+      conformance: "M",
+      priority: "critical",
+      details: "The door lock server provides several alarms which can be sent when there is a critical state on the door lock. The alarms available for the door lock server are listed in AlarmCodeEnum.",
+      xref: { document: "cluster", section: "5.2.11.1" },
+      children: [(0, import_elements.FieldElement)({
+        name: "AlarmCode",
+        id: 0,
+        type: "AlarmCodeEnum",
+        conformance: "M",
+        details: "This field shall indicate the alarm code of the event that has happened.",
+        xref: { document: "cluster", section: "5.2.11.1.1" }
+      })]
+    }),
+    (0, import_elements.EventElement)({
+      name: "DoorStateChange",
+      id: 1,
+      access: "V",
+      conformance: "DPS",
+      priority: "critical",
+      details: "The door lock server sends out a DoorStateChange event when the door lock door state changes.",
+      xref: { document: "cluster", section: "5.2.11.2" },
+      children: [(0, import_elements.FieldElement)({
+        name: "DoorState",
+        id: 0,
+        type: "DoorStateEnum",
+        conformance: "M",
+        details: "This field shall indicate the new door state for this door event.",
+        xref: { document: "cluster", section: "5.2.11.2.1" }
+      })]
+    }),
+    (0, import_elements.EventElement)({
+      name: "LockOperation",
+      id: 2,
+      access: "V",
+      conformance: "M",
+      priority: "critical",
+      details: "The door lock server sends out a LockOperation event when the event is triggered by the various lock operation sources.\n  \u2022 If the door lock server supports the Unbolt Door command, it shall generate a LockOperation     event with LockOperationType set to Unlock after an Unbolt Door command succeeds.\n  \u2022 If the door lock server supports the Unbolting feature and an Unlock Door command is performed,     it shall generate a LockOperation event with LockOperationType set to Unlatch when the     unlatched state is reached and a LockOperation event with LockOperationType set to Unlock when     the lock successfully completes the unlock \u2192 hold latch \u2192 release latch and return to unlock     state operation.\n  \u2022 If the command fails during holding or releasing the latch but after passing the unlocked     state, the door lock server shall generate a LockOperationError event with LockOperationType     set to Unlatch and a LockOperation event with LockOperationType set to Unlock.\n    \u25E6 If it fails before reaching the unlocked state, the door lock server shall generate only a       LockOperationError event with LockOperationType set to Unlock.\n  \u2022 Upon manual actuation, a door lock server that supports the Unbolting feature:\n    \u25E6 shall generate a LockOperation event of LockOperationType Unlatch when it is actuated from       the outside.\n    \u25E6 may generate a LockOperation event of LockOperationType Unlatch when it is actuated from the       inside.",
+      xref: { document: "cluster", section: "5.2.11.3" },
+      children: [
+        (0, import_elements.FieldElement)({
+          name: "LockOperationType",
+          id: 0,
+          type: "LockOperationTypeEnum",
+          conformance: "M",
+          details: "This field shall indicate the type of the lock operation that was performed.",
+          xref: { document: "cluster", section: "5.2.11.3.1" }
+        }),
+        (0, import_elements.FieldElement)({
+          name: "OperationSource",
+          id: 1,
+          type: "OperationSourceEnum",
+          conformance: "M",
+          details: "This field shall indicate the source of the lock operation that was performed.",
+          xref: { document: "cluster", section: "5.2.11.3.2" }
+        }),
+        (0, import_elements.FieldElement)({
+          name: "UserIndex",
+          id: 2,
+          type: "uint16",
+          conformance: "M",
+          quality: "X",
+          details: "This field shall indicate the UserIndex who performed the lock operation. This shall be null if there is no user index that can be determined for the given operation source. This shall NOT be null if a user index can be determined. In particular, this shall NOT be null if the operation was associated with a valid credential.",
+          xref: { document: "cluster", section: "5.2.11.3.3" }
+        }),
+        (0, import_elements.FieldElement)({
+          name: "FabricIndex",
+          id: 3,
+          type: "fabric-idx",
+          conformance: "M",
+          quality: "X",
+          details: 'This field shall indicate the fabric index of the fabric that performed the lock operation. This shall be null if there is no fabric that can be determined for the given operation source. This shall NOT be null if the operation source is "Remote".',
+          xref: { document: "cluster", section: "5.2.11.3.4" }
+        }),
+        (0, import_elements.FieldElement)({
+          name: "SourceNode",
+          id: 4,
+          type: "node-id",
+          conformance: "M",
+          quality: "X",
+          details: 'This field shall indicate the Node ID of the node that performed the lock operation. This shall be null if there is no Node associated with the given operation source. This shall NOT be null if the operation source is "Remote".',
+          xref: { document: "cluster", section: "5.2.11.3.5" }
+        }),
+        (0, import_elements.FieldElement)({
+          name: "Credentials",
+          id: 5,
+          type: "list",
+          conformance: "[USR]",
+          constraint: "1 to numberOfCredentialsSupportedPerUser",
+          quality: "X",
+          details: "This field shall indicate the list of credentials used in performing the lock operation. This shall be null if no credentials were involved.",
+          xref: { document: "cluster", section: "5.2.11.3.6" },
+          children: [(0, import_elements.FieldElement)({ name: "entry", type: "CredentialStruct" })]
+        })
+      ]
+    }),
+    (0, import_elements.EventElement)({
+      name: "LockOperationError",
+      id: 3,
+      access: "V",
+      conformance: "M",
+      priority: "critical",
+      details: "The door lock server sends out a LockOperationError event when a lock operation fails for various reasons.",
+      xref: { document: "cluster", section: "5.2.11.4" },
+      children: [
+        (0, import_elements.FieldElement)({
+          name: "LockOperationType",
+          id: 0,
+          type: "LockOperationTypeEnum",
+          conformance: "M",
+          details: "This field shall indicate the type of the lock operation that was performed.",
+          xref: { document: "cluster", section: "5.2.11.4.1" }
+        }),
+        (0, import_elements.FieldElement)({
+          name: "OperationSource",
+          id: 1,
+          type: "OperationSourceEnum",
+          conformance: "M",
+          details: "This field shall indicate the source of the lock operation that was performed.",
+          xref: { document: "cluster", section: "5.2.11.4.2" }
+        }),
+        (0, import_elements.FieldElement)({
+          name: "OperationError",
+          id: 2,
+          type: "OperationErrorEnum",
+          conformance: "M",
+          details: "This field shall indicate the lock operation error triggered when the operation was performed.",
+          xref: { document: "cluster", section: "5.2.11.4.3" }
+        }),
+        (0, import_elements.FieldElement)({
+          name: "UserIndex",
+          id: 3,
+          type: "uint16",
+          conformance: "M",
+          quality: "X",
+          details: "This field shall indicate the lock UserIndex who performed the lock operation. This shall be null if there is no user id that can be determined for the given operation source.",
+          xref: { document: "cluster", section: "5.2.11.4.4" }
+        }),
+        (0, import_elements.FieldElement)({
+          name: "FabricIndex",
+          id: 4,
+          type: "fabric-idx",
+          conformance: "M",
+          quality: "X",
+          details: 'This field shall indicate the fabric index of the fabric that performed the lock operation. This shall be null if there is no fabric that can be determined for the given operation source. This shall NOT be null if the operation source is "Remote".',
+          xref: { document: "cluster", section: "5.2.11.4.5" }
+        }),
+        (0, import_elements.FieldElement)({
+          name: "SourceNode",
+          id: 5,
+          type: "node-id",
+          conformance: "M",
+          quality: "X",
+          details: 'This field shall indicate the Node ID of the node that performed the lock operation. This shall be null if there is no Node associated with the given operation source. This shall NOT be null if the operation source is "Remote".',
+          xref: { document: "cluster", section: "5.2.11.4.6" }
+        }),
+        (0, import_elements.FieldElement)({
+          name: "Credentials",
+          id: 6,
+          type: "list",
+          conformance: "[USR]",
+          constraint: "1 to numberOfCredentialsSupportedPerUser",
+          quality: "X",
+          details: "This field shall indicate the list of credentials used in performing the lock operation. This shall be null if no credentials were involved.",
+          xref: { document: "cluster", section: "5.2.11.4.7" },
+          children: [(0, import_elements.FieldElement)({ name: "entry", type: "CredentialStruct" })]
+        })
+      ]
+    }),
+    (0, import_elements.EventElement)({
+      name: "LockUserChange",
+      id: 4,
+      access: "V",
+      conformance: "USR",
+      priority: "info",
+      details: "The door lock server sends out a LockUserChange event when a lock user, schedule, or credential change has occurred.",
+      xref: { document: "cluster", section: "5.2.11.5" },
+      children: [
+        (0, import_elements.FieldElement)({
+          name: "LockDataType",
+          id: 0,
+          type: "LockDataTypeEnum",
+          conformance: "M",
+          details: "This field shall indicate the lock data type that was changed.",
+          xref: { document: "cluster", section: "5.2.11.5.1" }
+        }),
+        (0, import_elements.FieldElement)({
+          name: "DataOperationType",
+          id: 1,
+          type: "DataOperationTypeEnum",
+          conformance: "M",
+          details: "This field shall indicate the data operation performed on the lock data type changed.",
+          xref: { document: "cluster", section: "5.2.11.5.2" }
+        }),
+        (0, import_elements.FieldElement)({
+          name: "OperationSource",
+          id: 2,
+          type: "OperationSourceEnum",
+          conformance: "M",
+          constraint: "unspecified, keypad, remote",
+          details: "This field shall indicate the source of the user data change.",
+          xref: { document: "cluster", section: "5.2.11.5.3" }
+        }),
+        (0, import_elements.FieldElement)({
+          name: "UserIndex",
+          id: 3,
+          type: "uint16",
+          conformance: "M",
+          quality: "X",
+          details: "This field shall indicate the lock UserIndex associated with the change (if any). This shall be null if there is no specific user associated with the data operation. This shall be 0xFFFE if all users are affected (e.g. Clear Users).",
+          xref: { document: "cluster", section: "5.2.11.5.4" }
+        }),
+        (0, import_elements.FieldElement)({
+          name: "FabricIndex",
+          id: 4,
+          type: "fabric-idx",
+          conformance: "M",
+          quality: "X",
+          details: 'This field shall indicate the fabric index of the fabric that performed the change (if any). This shall be null if there is no fabric that can be determined to have caused the change. This shall NOT be null if the operation source is "Remote".',
+          xref: { document: "cluster", section: "5.2.11.5.5" }
+        }),
+        (0, import_elements.FieldElement)({
+          name: "SourceNode",
+          id: 5,
+          type: "node-id",
+          conformance: "M",
+          quality: "X",
+          details: 'This field shall indicate the Node ID that performed the change (if any). The Node ID of the node that performed the change. This shall be null if there was no Node involved in the change. This shall NOT be null if the operation source is "Remote".',
+          xref: { document: "cluster", section: "5.2.11.5.6" }
+        }),
+        (0, import_elements.FieldElement)({
+          name: "DataIndex",
+          id: 6,
+          type: "uint16",
+          conformance: "M",
+          quality: "X",
+          details: "This field shall indicate the index of the specific item that was changed (e.g. schedule, PIN, RFID, etc.) in the list of items identified by LockDataType. This shall be null if the LockDataType does not correspond to a list that can be indexed into (e.g. ProgrammingUser). This shall be 0xFFFE if all indices are affected (e.g. ClearPINCode, ClearRFIDCode, ClearWeekDaySchedule, ClearYearDaySchedule, etc.).",
+          xref: { document: "cluster", section: "5.2.11.5.7" }
+        })
+      ]
+    }),
+    (0, import_elements.CommandElement)({
+      name: "LockDoor",
+      id: 0,
+      access: "O T",
+      conformance: "M",
+      direction: "request",
+      response: "status",
+      details: "This command causes the lock device to lock the door. This command includes an optional code for the lock. The door lock may require a PIN depending on the value of the RequirePINForRemoteOperation attribute.\n\u2020 The PIN/RFID Code is an obsolete field name, use PINCode instead.",
+      xref: { document: "cluster", section: "5.2.10.1" },
+      children: [(0, import_elements.FieldElement)({
+        name: "PinCode",
+        id: 0,
+        type: "octstr",
+        conformance: "[COTA & PIN]",
+        details: "If the RequirePINforRemoteOperation attribute is True then PINCode field shall be provided and the door lock shall NOT grant access if it is not provided.\nIf the PINCode field is provided, the door lock shall verify PINCode before granting access regardless of the value of RequirePINForRemoteOperation attribute.\nWhen the PINCode field is provided an invalid PIN will count towards the WrongCodeEntryLimit and the UserCodeTemporaryDisableTime will be triggered if the WrongCodeEntryLimit is exceeded. The lock shall ignore any attempts to lock/unlock the door until the UserCodeTemporaryDisableTime expires.",
+        xref: { document: "cluster", section: "5.2.10.1.1" }
+      })]
+    }),
+    (0, import_elements.CommandElement)({
+      name: "UnlockDoor",
+      id: 1,
+      access: "O T",
+      conformance: "M",
+      direction: "request",
+      response: "status",
+      details: "This command causes the lock device to unlock the door. This command includes an optional code for the lock. The door lock may require a code depending on the value of the RequirePINForRemoteOperation attribute.\nNOTE\nIf the attribute AutoRelockTime is supported the lock will transition to the locked state when the auto relock time has expired.\n\u2020 The PIN/RFID Code is an obsolete field name, use PINCode instead.",
+      xref: { document: "cluster", section: "5.2.10.2" },
+      children: [(0, import_elements.FieldElement)({
+        name: "PinCode",
+        id: 0,
+        type: "octstr",
+        conformance: "[COTA & PIN]",
+        details: "See PINCode field.",
+        xref: { document: "cluster", section: "5.2.10.2.1" }
+      })]
+    }),
+    (0, import_elements.CommandElement)({
+      name: "Toggle",
+      id: 2,
+      access: "O T",
+      conformance: "X",
+      direction: "request",
+      response: "status",
+      xref: { document: "cluster", section: "5.2.10" }
+    }),
+    (0, import_elements.CommandElement)({
+      name: "UnlockWithTimeout",
+      id: 3,
+      access: "O T",
+      conformance: "O",
+      direction: "request",
+      response: "status",
+      details: "This command causes the lock device to unlock the door with a timeout parameter. After the time in seconds specified in the timeout field, the lock device will relock itself automatically. This timeout parameter is only temporary for this message transition and overrides the default relock time\nas specified in the AutoRelockTime attribute. If the door lock device is not capable of or does not want to support temporary Relock Timeout, it SHOULD NOT support this optional command.\n\u2020 The PIN/RFID Code is an obsolete field name, use PINCode instead.",
+      xref: { document: "cluster", section: "5.2.10.3" },
+      children: [
+        (0, import_elements.FieldElement)({
+          name: "Timeout",
+          id: 0,
+          type: "uint16",
+          conformance: "M",
+          details: "This field shall indicate the timeout in seconds to wait before relocking the door lock. This value is independent of the AutoRelockTime attribute value.",
+          xref: { document: "cluster", section: "5.2.10.3.1" }
+        }),
+        (0, import_elements.FieldElement)({
+          name: "PinCode",
+          id: 1,
+          type: "octstr",
+          conformance: "[COTA & PIN]",
+          details: "See PINCode field.",
+          xref: { document: "cluster", section: "5.2.10.3.2" }
+        })
+      ]
+    }),
+    (0, import_elements.CommandElement)({
+      name: "GetLogRecord",
+      id: 4,
+      access: "M",
+      conformance: "LOG",
+      direction: "request",
+      response: "GetLogRecordResponse",
+      details: "Request a log record. Log number is between 1 \u2013 [Number of Log Records Supported attribute]. If log number 0 is requested then the most recent log entry is returned.\nLog record format: The log record format is defined in the description of the GetLogRecordResponse command.",
+      xref: { document: "cluster", section: "5.2.10.4" },
+      children: [(0, import_elements.FieldElement)({ name: "LogIndex", id: 0, type: "uint16", conformance: "M", constraint: "desc" })]
+    }),
+    (0, import_elements.CommandElement)({
+      name: "GetLogRecordResponse",
+      id: 4,
+      conformance: "LOG",
+      direction: "response",
+      details: "Returns the specified log record. If an invalid log entry ID was requested, it is set to 0 and the most recent log entry will be returned.",
+      xref: { document: "cluster", section: "5.2.10.5" },
+      children: [
+        (0, import_elements.FieldElement)({
+          name: "LogEntryId",
+          id: 0,
+          type: "uint16",
+          conformance: "M",
+          constraint: "desc",
+          details: "This field shall indicate the index into the log table where this log entry is stored. If the log entry requested is 0, the most recent log is returned with the appropriate log entry ID.",
+          xref: { document: "cluster", section: "5.2.10.5.1" }
+        }),
+        (0, import_elements.FieldElement)({
+          name: "Timestamp",
+          id: 1,
+          type: "epoch-s",
+          conformance: "M",
+          details: "This field shall indicate the timestamp for all events and alarms on the door lock in Epoch Time in Seconds with local time offset based on the local timezone and DST offset on the day of the event.",
+          xref: { document: "cluster", section: "5.2.10.5.2" }
+        }),
+        (0, import_elements.FieldElement)({
+          name: "EventType",
+          id: 2,
+          type: "EventTypeEnum",
+          conformance: "M",
+          details: "This field shall indicate the type of event that took place on the door lock, as defined in EventTypeEnum.",
+          xref: { document: "cluster", section: "5.2.10.5.3" }
+        }),
+        (0, import_elements.FieldElement)({
+          name: "Source",
+          id: 3,
+          type: "EventSourceEnum",
+          conformance: "M",
+          details: "This field shall indicate the source value as defined in EventSourceEnum.\nIf the EventType is 2 (Alarm) then the source SHOULD be, but does not have to be 255 (Indeterminate).",
+          xref: { document: "cluster", section: "5.2.10.5.4" }
+        }),
+        (0, import_elements.FieldElement)({
+          name: "EventId",
+          id: 4,
+          type: "uint8",
+          conformance: "M",
+          constraint: "desc",
+          details: "This field shall indicate the type of event that took place on the door lock depending on the event code table provided for a given event type and source. See Operation Event Codes.",
+          xref: { document: "cluster", section: "5.2.10.5.5" }
+        }),
+        (0, import_elements.FieldElement)({
+          name: "UserId",
+          id: 5,
+          type: "uint16",
+          conformance: "M",
+          constraint: "desc",
+          details: "This field shall indicate the ID of the user who generated the event on the door lock if one is available. Otherwise, the value is 0xFFFF.",
+          xref: { document: "cluster", section: "5.2.10.5.6" }
+        }),
+        (0, import_elements.FieldElement)({
+          name: "Pin",
+          id: 6,
+          type: "octstr",
+          conformance: "M",
+          details: "This field shall indicate the PIN code or RFID code that was used to create the event on the door lock if one is available.",
+          xref: { document: "cluster", section: "5.2.10.5.7" }
+        })
+      ]
+    }),
+    (0, import_elements.CommandElement)({
+      name: "SetPinCode",
+      id: 5,
+      access: "A T",
+      conformance: "!USR & PIN",
+      direction: "request",
+      response: "status",
+      details: "Set a PIN Code into the lock.\nReturn status is a global status code or a cluster-specific status code from the Status Codes table and shall be one of the following values:",
+      xref: { document: "cluster", section: "5.2.10.6" },
+      children: [
+        (0, import_elements.FieldElement)({
+          name: "UserId",
+          id: 0,
+          type: "uint16",
+          conformance: "M",
+          constraint: "desc",
+          details: "This field shall indicate the user ID. The value of the UserID field shall be between 0 and the value of the NumberOfPINUsersSupported attribute.",
+          xref: { document: "cluster", section: "5.2.10.6.1" }
+        }),
+        (0, import_elements.FieldElement)({
+          name: "UserStatus",
+          id: 1,
+          type: "UserStatusEnum",
+          conformance: "M",
+          constraint: "desc",
+          default: 1,
+          quality: "X",
+          details: "This field shall indicate the user status. Only the values 1 (Occupied/Enabled) and 3 (Occupied/Disabled) are allowed for UserStatus.",
+          xref: { document: "cluster", section: "5.2.10.6.2" }
+        }),
+        (0, import_elements.FieldElement)({ name: "UserType", id: 2, type: "UserTypeEnum", conformance: "M", default: 0, quality: "X" }),
+        (0, import_elements.FieldElement)({ name: "Pin", id: 3, type: "octstr", conformance: "M" })
+      ]
+    }),
+    (0, import_elements.CommandElement)({
+      name: "GetPinCode",
+      id: 6,
+      access: "A",
+      conformance: "!USR & PIN",
+      direction: "request",
+      response: "GetPinCodeResponse",
+      details: "Retrieve a PIN Code.",
+      xref: { document: "cluster", section: "5.2.10.7" },
+      children: [(0, import_elements.FieldElement)({
+        name: "UserId",
+        id: 0,
+        type: "uint16",
+        conformance: "M",
+        constraint: "desc",
+        details: "This field shall indicate the user ID. The value of the UserID field shall be between 0 and the value of the NumberOfPINUsersSupported attribute.",
+        xref: { document: "cluster", section: "5.2.10.7.1" }
+      })]
+    }),
+    (0, import_elements.CommandElement)({
+      name: "GetPinCodeResponse",
+      id: 6,
+      conformance: "!USR & PIN",
+      direction: "response",
+      details: "Returns the PIN for the specified user ID.\nIf the requested UserID is valid and the Code doesn\u2019t exist, Get RFID Code Response shall have the following format:\nUserID = requested User ID UserStatus = 0 (Available) UserType = Null (Not supported) PINCode = 0 (zero length)\nIf the requested UserID is invalid, send Default Response with an error status. The error status shall be equal to CONSTRAINT_ERROR when User_ID is less than the max number of users supported, and NOT_FOUND if greater than or equal to the max number of users supported.",
+      xref: { document: "cluster", section: "5.2.10.8" },
+      children: [
+        (0, import_elements.FieldElement)({ name: "UserId", id: 0, type: "uint16", conformance: "M", constraint: "desc" }),
+        (0, import_elements.FieldElement)({
+          name: "UserStatus",
+          id: 1,
+          type: "UserStatusEnum",
+          conformance: "M",
+          constraint: "desc",
+          default: 0,
+          quality: "X"
+        }),
+        (0, import_elements.FieldElement)({
+          name: "UserType",
+          id: 2,
+          type: "UserTypeEnum",
+          conformance: "M",
+          constraint: "desc",
+          quality: "X"
+        }),
+        (0, import_elements.FieldElement)({ name: "PinCode", id: 3, type: "octstr", conformance: "M", quality: "X" })
+      ]
+    }),
+    (0, import_elements.CommandElement)({
+      name: "ClearPinCode",
+      id: 7,
+      access: "A T",
+      conformance: "!USR & PIN",
+      direction: "request",
+      response: "status",
+      details: "Clear a PIN code or all PIN codes.\n\u2020 The User ID is an obsolete field name, use PINSlotIndex instead.\nFor each PIN Code cleared whose user doesn\u2019t have a RFID Code or other credential type, then corresponding user record\u2019s UserStatus value shall be set to Available, and UserType value shall be set to UnrestrictedUser and all schedules shall be cleared.",
+      xref: { document: "cluster", section: "5.2.10.9" },
+      children: [(0, import_elements.FieldElement)({
+        name: "PinSlotIndex",
+        id: 0,
+        type: "uint16",
+        conformance: "M",
+        constraint: "1 to numberOfPinUsersSupported, 65534",
+        details: "This field shall specify a valid PIN code slot index or 0xFFFE to indicate all PIN code slots shall be cleared.",
+        xref: { document: "cluster", section: "5.2.10.9.1" }
+      })]
+    }),
+    (0, import_elements.CommandElement)({
+      name: "ClearAllPinCodes",
+      id: 8,
+      access: "A T",
+      conformance: "!USR & PIN",
+      direction: "request",
+      response: "status",
+      details: "Clear out all PINs on the lock.\nNOTE\nOn the server, the clear all PIN codes command SHOULD have the same effect as the ClearPINCode command with respect to the setting of user status, user type and schedules.",
+      xref: { document: "cluster", section: "5.2.10.10" }
+    }),
+    (0, import_elements.CommandElement)({
+      name: "SetUserStatus",
+      id: 9,
+      access: "A",
+      conformance: "!USR & (PIN | RID | FGP)",
+      direction: "request",
+      response: "status",
+      details: "Set the status of a user ID.",
+      xref: { document: "cluster", section: "5.2.10.11" },
+      children: [
+        (0, import_elements.FieldElement)({
+          name: "UserId",
+          id: 0,
+          type: "uint16",
+          conformance: "M",
+          constraint: "desc",
+          details: "This field shall indicate the user ID. The value of the UserID field shall be between 0 and the value of the NumberOfPINUsersSupported attribute.",
+          xref: { document: "cluster", section: "5.2.10.11.1" }
+        }),
+        (0, import_elements.FieldElement)({
+          name: "UserStatus",
+          id: 1,
+          type: "UserStatusEnum",
+          conformance: "M",
+          constraint: "desc",
+          details: "UserStatus value of Available is not allowed. In order to clear a user id, the ClearUser Command shall be used. For user status value please refer to UserStatusEnum.",
+          xref: { document: "cluster", section: "5.2.10.11.2" }
+        })
+      ]
+    }),
+    (0, import_elements.CommandElement)({
+      name: "GetUserStatus",
+      id: 10,
+      access: "A",
+      conformance: "!USR & (PIN | RID | FGP)",
+      direction: "request",
+      response: "GetUserStatusResponse",
+      details: "Get the status of a user.",
+      xref: { document: "cluster", section: "5.2.10.12" },
+      children: [(0, import_elements.FieldElement)({
+        name: "UserId",
+        id: 0,
+        type: "uint16",
+        conformance: "M",
+        constraint: "desc",
+        details: "This field shall indicate the user ID. The value of the UserID field shall be between 0 and the value of the NumberOfPINUsersSupported attribute.",
+        xref: { document: "cluster", section: "5.2.10.12.1" }
+      })]
+    }),
+    (0, import_elements.CommandElement)({
+      name: "GetUserStatusResponse",
+      id: 10,
+      conformance: "!USR",
+      direction: "response",
+      details: "Returns the user status for the specified user ID.",
+      xref: { document: "cluster", section: "5.2.10.13" },
+      children: [
+        (0, import_elements.FieldElement)({
+          name: "UserId",
+          id: 0,
+          type: "uint16",
+          conformance: "M",
+          constraint: "desc",
+          details: "This field shall indicate the user ID provided in the request.",
+          xref: { document: "cluster", section: "5.2.10.13.1" }
+        }),
+        (0, import_elements.FieldElement)({
+          name: "UserStatus",
+          id: 1,
+          type: "UserStatusEnum",
+          conformance: "M",
+          details: "This field shall indicate the current status of the requested user ID.",
+          xref: { document: "cluster", section: "5.2.10.13.2" }
+        })
+      ]
+    }),
+    (0, import_elements.CommandElement)({
+      name: "SetWeekDaySchedule",
+      id: 11,
+      access: "A",
+      conformance: "WDSCH",
+      direction: "request",
+      response: "status",
+      details: "Set a weekly repeating schedule for a specified user.\n\u2020 The Schedule ID and User ID are obsolete field names, use WeekDayIndex and UserIndex instead, respectively.\nThe associated UserType may be changed to ScheduleRestrictedUser by the lock when a Week Day schedule is set.\nReturn status shall be one of the following values:",
+      xref: { document: "cluster", section: "5.2.10.14" },
+      children: [
+        (0, import_elements.FieldElement)({
+          name: "WeekDayIndex",
+          id: 0,
+          type: "uint8",
+          conformance: "M",
+          constraint: "1 to numberOfWeekDaySchedulesSupportedPerUser",
+          details: "This field shall indicate the index of the Week Day schedule.",
+          xref: { document: "cluster", section: "5.2.10.14.1" }
+        }),
+        (0, import_elements.FieldElement)({
+          name: "UserIndexUserId",
+          id: 1,
+          type: "uint16",
+          conformance: "M",
+          constraint: "1 to numberOfTotalUsersSupported"
+        }),
+        (0, import_elements.FieldElement)({
+          name: "DaysMask",
+          id: 2,
+          type: "DaysMaskBitmap",
+          conformance: "M",
+          details: "This field shall indicate which week days the schedule is active.",
+          xref: { document: "cluster", section: "5.2.10.14.3" }
+        }),
+        (0, import_elements.FieldElement)({
+          name: "StartHour",
+          id: 3,
+          type: "uint8",
+          conformance: "M",
+          constraint: "0 to 23",
+          details: "This field shall indicate the starting hour for the Week Day schedule.",
+          xref: { document: "cluster", section: "5.2.10.14.4" }
+        }),
+        (0, import_elements.FieldElement)({
+          name: "StartMinute",
+          id: 4,
+          type: "uint8",
+          conformance: "M",
+          constraint: "0 to 59",
+          details: "This field shall indicate the starting minute for the Week Day schedule.",
+          xref: { document: "cluster", section: "5.2.10.14.5" }
+        }),
+        (0, import_elements.FieldElement)({
+          name: "EndHour",
+          id: 5,
+          type: "uint8",
+          conformance: "M",
+          constraint: "0 to 23",
+          details: "This field shall indicate the ending hour for the Week Day schedule. EndHour shall be equal to or greater than StartHour.",
+          xref: { document: "cluster", section: "5.2.10.14.6" }
+        }),
+        (0, import_elements.FieldElement)({
+          name: "EndMinute",
+          id: 6,
+          type: "uint8",
+          conformance: "M",
+          constraint: "0 to 59",
+          details: "This field shall indicate the ending minute for the Week Day schedule. If EndHour is equal to StartHour then EndMinute shall be greater than StartMinute.\nIf the EndHour is equal to 23 and the EndMinute is equal to 59 the Lock shall grant access to the user up until 23:59:59.",
+          xref: { document: "cluster", section: "5.2.10.14.7" }
+        })
+      ]
+    }),
+    (0, import_elements.CommandElement)({
+      name: "GetWeekDaySchedule",
+      id: 12,
+      access: "A",
+      conformance: "WDSCH",
+      direction: "request",
+      response: "GetWeekDayScheduleResponse",
+      details: "Retrieve the specific weekly schedule for the specific user.\n\u2020 The Schedule ID and User ID are obsolete field names, use WeekDayIndex and UserIndex instead, respectively.",
+      xref: { document: "cluster", section: "5.2.10.15" },
+      children: [
+        (0, import_elements.FieldElement)({
+          name: "WeekDayIndex",
+          id: 0,
+          type: "uint8",
+          conformance: "M",
+          constraint: "1 to numberOfWeekDaySchedulesSupportedPerUser"
+        }),
+        (0, import_elements.FieldElement)({
+          name: "UserIndexUserId",
+          id: 1,
+          type: "uint16",
+          conformance: "M",
+          constraint: "1 to numberOfTotalUsersSupported"
+        })
+      ]
+    }),
+    (0, import_elements.CommandElement)({
+      name: "GetWeekDayScheduleResponse",
+      id: 12,
+      conformance: "WDSCH",
+      direction: "response",
+      details: "Returns the weekly repeating schedule data for the specified schedule index.\n\u2020 The Schedule ID and User ID are obsolete field names, use WeekDayIndex and UserIndex instead, respectively.",
+      xref: { document: "cluster", section: "5.2.10.16" },
+      children: [
+        (0, import_elements.FieldElement)({
+          name: "WeekDayIndex",
+          id: 0,
+          type: "uint8",
+          conformance: "M",
+          constraint: "1 to numberOfWeekDaySchedulesSupportedPerUser",
+          details: "This field shall indicate the index of the Week Day schedule.",
+          xref: { document: "cluster", section: "5.2.10.16.1" }
+        }),
+        (0, import_elements.FieldElement)({
+          name: "UserIndexUserId",
+          id: 1,
+          type: "uint16",
+          conformance: "M",
+          constraint: "1 to numberOfTotalUsersSupported"
+        }),
+        (0, import_elements.FieldElement)({
+          name: "Status",
+          id: 2,
+          type: "status",
+          conformance: "M",
+          constraint: "desc",
+          default: 0,
+          details: "Status shall be one of the following values:\n  \u2022 SUCCESS if both WeekDayIndex and UserIndex are valid and there is a corresponding schedule     entry.\n  \u2022 INVALID_COMMAND if either WeekDayIndex and/or UserIndex values are not within valid range\n  \u2022 NOT_FOUND if no corresponding schedule entry found for WeekDayIndex.\n  \u2022 NOT_FOUND if no corresponding user entry found for UserIndex.\nIf this field is SUCCESS, the optional fields for this command shall be present. For other (error) status values, only the fields up to the status field shall be present.",
+          xref: { document: "cluster", section: "5.2.10.16.3" }
+        }),
+        (0, import_elements.FieldElement)({ name: "DaysMask", id: 3, type: "DaysMaskBitmap", conformance: "O" }),
+        (0, import_elements.FieldElement)({
+          name: "StartHour",
+          id: 4,
+          type: "uint8",
+          conformance: "O",
+          constraint: "0 to 23",
+          details: "This field shall indicate the starting hour for the Week Day schedule.",
+          xref: { document: "cluster", section: "5.2.10.16.4" }
+        }),
+        (0, import_elements.FieldElement)({
+          name: "StartMinute",
+          id: 5,
+          type: "uint8",
+          conformance: "O",
+          constraint: "0 to 59",
+          details: "This field shall indicate the starting minute for the Week Day schedule.",
+          xref: { document: "cluster", section: "5.2.10.16.5" }
+        }),
+        (0, import_elements.FieldElement)({
+          name: "EndHour",
+          id: 6,
+          type: "uint8",
+          conformance: "O",
+          constraint: "0 to 23",
+          details: "This field shall indicate the ending hour for the Week Day schedule. EndHour shall be equal to or greater than StartHour.",
+          xref: { document: "cluster", section: "5.2.10.16.6" }
+        }),
+        (0, import_elements.FieldElement)({
+          name: "EndMinute",
+          id: 7,
+          type: "uint8",
+          conformance: "O",
+          constraint: "0 to 59",
+          details: "This field shall indicate the ending minute for the Week Day schedule. If EndHour is equal to StartHour then EndMinute shall be greater than StartMinute.",
+          xref: { document: "cluster", section: "5.2.10.16.7" }
+        })
+      ]
+    }),
+    (0, import_elements.CommandElement)({
+      name: "ClearWeekDaySchedule",
+      id: 13,
+      access: "A",
+      conformance: "WDSCH",
+      direction: "request",
+      response: "status",
+      details: "Clear the specific weekly schedule or all weekly schedules for the specific user.\n\u2020 The Schedule ID and User ID are obsolete field names, use WeekDayIndex and UserIndex instead, respectively.\nReturn status shall be one of the following values:",
+      xref: { document: "cluster", section: "5.2.10.17" },
+      children: [
+        (0, import_elements.FieldElement)({
+          name: "WeekDayIndex",
+          id: 0,
+          type: "uint8",
+          conformance: "M",
+          constraint: "1 to numberOfWeekDaySchedulesSupportedPerUser, 254",
+          details: "This field shall indicate the Week Day schedule index to clear or 0xFE to clear all Week Day schedules for the specified user.",
+          xref: { document: "cluster", section: "5.2.10.17.1" }
+        }),
+        (0, import_elements.FieldElement)({
+          name: "UserIndexUserId",
+          id: 1,
+          type: "uint16",
+          conformance: "M",
+          constraint: "1 to numberOfTotalUsersSupported"
+        })
+      ]
+    }),
+    (0, import_elements.CommandElement)({
+      name: "SetYearDaySchedule",
+      id: 14,
+      access: "A",
+      conformance: "YDSCH",
+      direction: "request",
+      response: "status",
+      details: "Set a time-specific schedule ID for a specified user.\n\u2020 The Schedule ID and User ID are obsolete field names, use YearDayIndex and UserIndex instead, respectively.\nThe associated UserType may be changed to ScheduleRestrictedUser by the lock when a Year Day schedule is set.\nReturn status shall be one of the following values:",
+      xref: { document: "cluster", section: "5.2.10.18" },
+      children: [
+        (0, import_elements.FieldElement)({
+          name: "YearDayIndex",
+          id: 0,
+          type: "uint8",
+          conformance: "M",
+          constraint: "1 to numberOfYearDaySchedulesSupportedPerUser",
+          details: "This field shall indicate the index of the Year Day schedule.",
+          xref: { document: "cluster", section: "5.2.10.18.1" }
+        }),
+        (0, import_elements.FieldElement)({
+          name: "UserIndexUserId",
+          id: 1,
+          type: "uint16",
+          conformance: "M",
+          constraint: "1 to numberOfTotalUsersSupported"
+        }),
+        (0, import_elements.FieldElement)({
+          name: "LocalStartTime",
+          id: 2,
+          type: "epoch-s",
+          conformance: "M",
+          details: "This field shall indicate the starting time for the Year Day schedule in Epoch Time in Seconds with local time offset based on the local timezone and DST offset on the day represented by the value.",
+          xref: { document: "cluster", section: "5.2.10.18.3" }
+        }),
+        (0, import_elements.FieldElement)({
+          name: "LocalEndTime",
+          id: 3,
+          type: "epoch-s",
+          conformance: "M",
+          details: "This field shall indicate the ending time for the Year Day schedule in Epoch Time in Seconds with local time offset based on the local timezone and DST offset on the day represented by the value. LocalEndTime shall be greater than LocalStartTime.",
+          xref: { document: "cluster", section: "5.2.10.18.4" }
+        })
+      ]
+    }),
+    (0, import_elements.CommandElement)({
+      name: "GetYearDaySchedule",
+      id: 15,
+      access: "A",
+      conformance: "YDSCH",
+      direction: "request",
+      response: "GetYearDayScheduleResponse",
+      details: "Retrieve the specific year day schedule for the specific schedule and user indexes.\n\u2020 The Schedule ID and User ID are obsolete field names, use YearDayIndex and UserIndex instead, respectively.",
+      xref: { document: "cluster", section: "5.2.10.19" },
+      children: [
+        (0, import_elements.FieldElement)({
+          name: "YearDayIndex",
+          id: 0,
+          type: "uint8",
+          conformance: "M",
+          constraint: "1 to numberOfYearDaySchedulesSupportedPerUser"
+        }),
+        (0, import_elements.FieldElement)({
+          name: "UserIndexUserId",
+          id: 1,
+          type: "uint16",
+          conformance: "M",
+          constraint: "1 to numberOfTotalUsersSupported"
+        })
+      ]
+    }),
+    (0, import_elements.CommandElement)({
+      name: "GetYearDayScheduleResponse",
+      id: 15,
+      conformance: "YDSCH",
+      direction: "response",
+      details: "Returns the year day schedule data for the specified schedule and user indexes.\n\u2020 The Schedule ID and User ID are obsolete field names, use YearDayIndex and UserIndex instead, respectively.",
+      xref: { document: "cluster", section: "5.2.10.20" },
+      children: [
+        (0, import_elements.FieldElement)({
+          name: "YearDayIndex",
+          id: 0,
+          type: "uint8",
+          conformance: "M",
+          constraint: "1 to numberOfYearDaySchedulesSupportedPerUser",
+          details: "This field shall indicate the index of the Year Day schedule.",
+          xref: { document: "cluster", section: "5.2.10.20.1" }
+        }),
+        (0, import_elements.FieldElement)({
+          name: "UserIndexUserId",
+          id: 1,
+          type: "uint16",
+          conformance: "M",
+          constraint: "1 to numberOfTotalUsersSupported"
+        }),
+        (0, import_elements.FieldElement)({
+          name: "Status",
+          id: 2,
+          type: "status",
+          conformance: "M",
+          constraint: "desc",
+          default: 0,
+          details: "Status shall be one of the following values:\n  \u2022 SUCCESS if both YearDayIndex and UserIndex are valid and there is a corresponding schedule     entry.\n  \u2022 INVALID_COMMAND if either YearDayIndex and/or UserIndex values are not within valid range\n  \u2022 NOT_FOUND if no corresponding schedule entry found for YearDayIndex.\n  \u2022 NOT_FOUND if no corresponding user entry found for UserIndex.\nIf this field is SUCCESS, the optional fields for this command shall be present. For other (error) status values, only the fields up to the status field shall be present.",
+          xref: { document: "cluster", section: "5.2.10.20.3" }
+        }),
+        (0, import_elements.FieldElement)({
+          name: "LocalStartTime",
+          id: 2,
+          type: "epoch-s",
+          conformance: "O",
+          details: "This field shall indicate the starting time for the Year Day schedule in Epoch Time in Seconds with local time offset based on the local timezone and DST offset on the day represented by the value. This shall be null if the schedule is not set for the YearDayIndex and UserIndex provided.",
+          xref: { document: "cluster", section: "5.2.10.20.4" }
+        }),
+        (0, import_elements.FieldElement)({
+          name: "LocalEndTime",
+          id: 3,
+          type: "epoch-s",
+          conformance: "O",
+          details: "This field shall indicate the ending time for the Year Day schedule in Epoch Time in Seconds with local time offset based on the local timezone and DST offset on the day represented by the value. LocalEndTime shall be greater than LocalStartTime. This shall be null if the schedule is not set for the YearDayIndex and UserIndex provided.",
+          xref: { document: "cluster", section: "5.2.10.20.5" }
+        })
+      ]
+    }),
+    (0, import_elements.CommandElement)({
+      name: "ClearYearDaySchedule",
+      id: 16,
+      access: "A",
+      conformance: "YDSCH",
+      direction: "request",
+      response: "status",
+      details: "Clears the specific year day schedule or all year day schedules for the specific user.\n\u2020 The Schedule ID and User ID are obsolete field names, use YearDayIndex and UserIndex instead, respectively.\nReturn status shall be one of the following values:",
+      xref: { document: "cluster", section: "5.2.10.21" },
+      children: [
+        (0, import_elements.FieldElement)({
+          name: "YearDayIndex",
+          id: 0,
+          type: "uint8",
+          conformance: "M",
+          constraint: "1 to numberOfYearDaySchedulesSupportedPerUser, 254",
+          details: "This field shall indicate the Year Day schedule index to clear or 0xFE to clear all Year Day schedules for the specified user.",
+          xref: { document: "cluster", section: "5.2.10.21.1" }
+        }),
+        (0, import_elements.FieldElement)({
+          name: "UserIndexUserId",
+          id: 1,
+          type: "uint16",
+          conformance: "M",
+          constraint: "1 to numberOfTotalUsersSupported"
+        })
+      ]
+    }),
+    (0, import_elements.CommandElement)({
+      name: "SetHolidaySchedule",
+      id: 17,
+      access: "A",
+      conformance: "HDSCH",
+      direction: "request",
+      response: "status",
+      details: "Set the holiday Schedule by specifying local start time and local end time with respect to any Lock Operating Mode.\n\u2020 The Holiday Schedule ID is an obsolete field name, use HolidayIndex instead. Return status shall be one of the following values:",
+      xref: { document: "cluster", section: "5.2.10.22" },
+      children: [
+        (0, import_elements.FieldElement)({
+          name: "HolidayIndex",
+          id: 0,
+          type: "uint8",
+          conformance: "M",
+          constraint: "1 to numberOfHolidaySchedulesSupported",
+          details: "This field shall indicate the index of the Holiday schedule.",
+          xref: { document: "cluster", section: "5.2.10.22.1" }
+        }),
+        (0, import_elements.FieldElement)({
+          name: "LocalStartTime",
+          id: 1,
+          type: "epoch-s",
+          conformance: "M",
+          details: "This field shall indicate the starting time for the Holiday Day schedule in Epoch Time in Seconds with local time offset based on the local timezone and DST offset on the day represented by the value.",
+          xref: { document: "cluster", section: "5.2.10.22.2" }
+        }),
+        (0, import_elements.FieldElement)({
+          name: "LocalEndTime",
+          id: 2,
+          type: "epoch-s",
+          conformance: "M",
+          details: "This field shall indicate the ending time for the Holiday Day schedule in Epoch Time in Seconds with local time offset based on the local timezone and DST offset on the day represented by the value. LocalEndTime shall be greater than LocalStartTime.",
+          xref: { document: "cluster", section: "5.2.10.22.3" }
+        }),
+        (0, import_elements.FieldElement)({
+          name: "OperatingMode",
+          id: 3,
+          type: "OperatingModeEnum",
+          conformance: "M",
+          details: "This field shall indicate the operating mode to use during this Holiday schedule start/end time.",
+          xref: { document: "cluster", section: "5.2.10.22.4" }
+        })
+      ]
+    }),
+    (0, import_elements.CommandElement)({
+      name: "GetHolidaySchedule",
+      id: 18,
+      access: "A",
+      conformance: "HDSCH",
+      direction: "request",
+      response: "GetHolidayScheduleResponse",
+      details: "Get the holiday schedule for the specified index.\n\u2020 The Holiday Schedule ID is an obsolete field name, use HolidayIndex instead.",
+      xref: { document: "cluster", section: "5.2.10.23" },
+      children: [(0, import_elements.FieldElement)({
+        name: "HolidayIndex",
+        id: 0,
+        type: "uint8",
+        conformance: "M",
+        constraint: "1 to numberOfHolidaySchedulesSupported"
+      })]
+    }),
+    (0, import_elements.CommandElement)({
+      name: "GetHolidayScheduleResponse",
+      id: 18,
+      conformance: "HDSCH",
+      direction: "response",
+      details: "Returns the Holiday Schedule Entry for the specified Holiday ID.\n\u2020 The Holiday Schedule ID is an obsolete field name, use HolidayIndex instead.",
+      xref: { document: "cluster", section: "5.2.10.24" },
+      children: [
+        (0, import_elements.FieldElement)({
+          name: "HolidayIndex",
+          id: 0,
+          type: "uint8",
+          conformance: "M",
+          constraint: "1 to numberOfHolidaySchedulesSupported",
+          details: "This field shall indicate the index of the Holiday schedule.",
+          xref: { document: "cluster", section: "5.2.10.24.1" }
+        }),
+        (0, import_elements.FieldElement)({
+          name: "Status",
+          id: 1,
+          type: "status",
+          conformance: "M",
+          constraint: "desc",
+          default: 0,
+          details: "Status shall be one of the following values:\n  \u2022 FAILURE if the attribute NumberOfHolidaySchedulesSupported is zero.\n  \u2022 SUCCESS if the HolidayIndex is valid and there is a corresponding schedule entry.\n  \u2022 INVALID_COMMAND if the HolidayIndex is not within valid range\n  \u2022 NOT_FOUND if the HolidayIndex is within the valid range, however, there is not corresponding     schedule entry found.\nIf this field is SUCCESS, the optional fields for this command shall be present. For other (error) status values, only the fields up to the status field shall be present.",
+          xref: { document: "cluster", section: "5.2.10.24.2" }
+        }),
+        (0, import_elements.FieldElement)({
+          name: "LocalStartTime",
+          id: 2,
+          type: "epoch-s",
+          conformance: "O",
+          quality: "X",
+          details: "This field shall indicate the starting time for the Holiday schedule in Epoch Time in Seconds with local time offset based on the local timezone and DST offset on the day represented by the value. This shall be null if the schedule is not set for the HolidayIndex provided.",
+          xref: { document: "cluster", section: "5.2.10.24.3" }
+        }),
+        (0, import_elements.FieldElement)({
+          name: "LocalEndTime",
+          id: 3,
+          type: "epoch-s",
+          conformance: "O",
+          quality: "X",
+          details: "This field shall indicate the ending time for the Holiday schedule in Epoch Time in Seconds with local time offset based on the local timezone and DST offset on the day represented by the value. LocalEndTime shall be greater than LocalStartTime. This shall be null if the schedule is not set for the HolidayIndex provided.",
+          xref: { document: "cluster", section: "5.2.10.24.4" }
+        }),
+        (0, import_elements.FieldElement)({
+          name: "OperatingMode",
+          id: 4,
+          type: "OperatingModeEnum",
+          conformance: "O",
+          quality: "X",
+          details: "This field shall indicate the operating mode to use during this Holiday schedule start/end time. This shall be null if the schedule is not set for the HolidayIndex provided.",
+          xref: { document: "cluster", section: "5.2.10.24.5" }
+        })
+      ]
+    }),
+    (0, import_elements.CommandElement)({
+      name: "ClearHolidaySchedule",
+      id: 19,
+      access: "A",
+      conformance: "HDSCH",
+      direction: "request",
+      response: "status",
+      details: "Clears the holiday schedule or all holiday schedules.\n\u2020 The Holiday Schedule ID is an obsolete field name, use HolidayIndex instead.",
+      xref: { document: "cluster", section: "5.2.10.25" },
+      children: [(0, import_elements.FieldElement)({
+        name: "HolidayIndex",
+        id: 0,
+        type: "uint8",
+        conformance: "M",
+        constraint: "1 to numberOfHolidaySchedulesSupported, 254",
+        details: "This field shall indicate the Holiday schedule index to clear or 0xFE to clear all Holiday schedules.",
+        xref: { document: "cluster", section: "5.2.10.25.1" }
+      })]
+    }),
+    (0, import_elements.CommandElement)({
+      name: "SetUserType",
+      id: 20,
+      access: "A",
+      conformance: "!USR & (PIN | RID | FGP)",
+      direction: "request",
+      response: "status",
+      details: "Set the user type for a specified user.\nFor user type value please refer to User Type Value.\nReturn status shall be one of the following values:",
+      xref: { document: "cluster", section: "5.2.10.26" },
+      children: [
+        (0, import_elements.FieldElement)({
+          name: "UserId",
+          id: 0,
+          type: "uint16",
+          conformance: "M",
+          constraint: "desc",
+          details: "This field shall indicate the user ID.",
+          xref: { document: "cluster", section: "5.2.10.26.1" }
+        }),
+        (0, import_elements.FieldElement)({
+          name: "UserType",
+          id: 1,
+          type: "UserTypeEnum",
+          conformance: "M",
+          details: "This field shall indicate the user type.\nIf UserType is currently YearDayScheduleUser, WeekDayScheduleUser, or ScheduleRestrictedUser and the new UserType is UnrestrictedUser then all existing Year Day and/or Week Day schedules shall be ignored or disabled (if this transition is supported by the door lock). If UserType is ScheduleRestrictedUser and the new UserType is ScheduleRestrictedUser then all existing Year Day and/or Week Day schedules shall be applied or enabled.",
+          xref: { document: "cluster", section: "5.2.10.26.2" }
+        })
+      ]
+    }),
+    (0, import_elements.CommandElement)({
+      name: "GetUserType",
+      id: 21,
+      access: "A",
+      conformance: "!USR & (PIN | RID | FGP)",
+      direction: "request",
+      response: "GetUserTypeResponse",
+      details: "Retrieve the user type for a specific user.",
+      xref: { document: "cluster", section: "5.2.10.27" },
+      children: [(0, import_elements.FieldElement)({ name: "UserId", id: 0, type: "uint16", conformance: "M", constraint: "desc" })]
+    }),
+    (0, import_elements.CommandElement)({
+      name: "GetUserTypeResponse",
+      id: 21,
+      conformance: "!USR",
+      direction: "response",
+      details: "Returns the user type for the specified user ID. If the requested User ID is invalid, send Default Response with an error status equal to FAILURE.",
+      xref: { document: "cluster", section: "5.2.10.28" },
+      children: [
+        (0, import_elements.FieldElement)({ name: "UserId", id: 0, type: "uint16", conformance: "M", constraint: "desc" }),
+        (0, import_elements.FieldElement)({ name: "UserType", id: 1, type: "UserTypeEnum", conformance: "M" })
+      ]
+    }),
+    (0, import_elements.CommandElement)({
+      name: "SetRfidCode",
+      id: 22,
+      access: "A T",
+      conformance: "!USR & RID",
+      direction: "request",
+      response: "status",
+      details: "Set an ID for RFID access into the lock.\nReturn status is a global status code or a cluster-specific status code from the Status Codes table and shall be one of the following values:",
+      xref: { document: "cluster", section: "5.2.10.29" },
+      children: [
+        (0, import_elements.FieldElement)({
+          name: "UserId",
+          id: 0,
+          type: "uint16",
+          conformance: "M",
+          constraint: "desc",
+          details: "This field shall indicate the user ID.\nThe value of the UserID field shall be between 0 and the value of the NumberOfRFIDUsersSupported attribute.",
+          xref: { document: "cluster", section: "5.2.10.29.1" }
+        }),
+        (0, import_elements.FieldElement)({
+          name: "UserStatus",
+          id: 1,
+          type: "UserStatusEnum",
+          conformance: "M",
+          constraint: "desc",
+          default: 1,
+          quality: "X",
+          details: "This field shall indicate what the status is for a specific user ID. The values are according to \u201CSet PIN\u201D while not all are supported.\nOnly the values 1 (Occupied/Enabled) and 3 (Occupied/Disabled) are allowed for UserStatus.",
+          xref: { document: "cluster", section: "5.2.10.29.2" }
+        }),
+        (0, import_elements.FieldElement)({
+          name: "UserType",
+          id: 2,
+          type: "UserTypeEnum",
+          conformance: "M",
+          constraint: "desc",
+          default: 0,
+          quality: "X",
+          details: "The values are the same as used for SetPINCode command.",
+          xref: { document: "cluster", section: "5.2.10.29.3" }
+        }),
+        (0, import_elements.FieldElement)({ name: "RfidCode", id: 3, type: "octstr", conformance: "M" })
+      ]
+    }),
+    (0, import_elements.CommandElement)({
+      name: "GetRfidCode",
+      id: 23,
+      access: "A",
+      conformance: "!USR & RID",
+      direction: "request",
+      response: "GetRfidCodeResponse",
+      details: "Retrieve an RFID code.",
+      xref: { document: "cluster", section: "5.2.10.30" },
+      children: [(0, import_elements.FieldElement)({
+        name: "UserId",
+        id: 0,
+        type: "uint16",
+        conformance: "M",
+        constraint: "desc",
+        details: "This field shall indicate the user ID.\nThe value of the UserID field shall be between 0 and the value of the NumberOfRFIDUsersSupported attribute.",
+        xref: { document: "cluster", section: "5.2.10.30.1" }
+      })]
+    }),
+    (0, import_elements.CommandElement)({
+      name: "GetRfidCodeResponse",
+      id: 23,
+      conformance: "!USR & RID",
+      direction: "response",
+      details: "Returns the RFID code for the specified user ID.\nIf the requested User ID is valid and the Code doesn\u2019t exist, Get RFID Code Response shall have the following format:\nUser ID = requested User ID UserStatus = 0 (available) UserType = 0xFF (not supported) RFID Code = 0 (zero length)\nIf requested User ID is invalid, send Default Response with an error status. The error status shall be equal to CONSTRAINT_ERROR when User_ID is less than the max number of users supported, and NOT_FOUND if greater than or equal to the max number of users supported.",
+      xref: { document: "cluster", section: "5.2.10.31" },
+      children: [
+        (0, import_elements.FieldElement)({ name: "UserId", id: 0, type: "uint16", conformance: "M", constraint: "desc" }),
+        (0, import_elements.FieldElement)({
+          name: "UserStatus",
+          id: 1,
+          type: "UserStatusEnum",
+          conformance: "M",
+          constraint: "desc",
+          default: 0,
+          quality: "X"
+        }),
+        (0, import_elements.FieldElement)({
+          name: "UserType",
+          id: 2,
+          type: "UserTypeEnum",
+          conformance: "M",
+          constraint: "desc",
+          quality: "X"
+        }),
+        (0, import_elements.FieldElement)({ name: "RfidCode", id: 3, type: "octstr", conformance: "M", quality: "X" })
+      ]
+    }),
+    (0, import_elements.CommandElement)({
+      name: "ClearRfidCode",
+      id: 24,
+      access: "A T",
+      conformance: "!USR & RID",
+      direction: "request",
+      response: "status",
+      details: "Clear an RFID code or all RFID codes.\n\u2020 The User ID is an obsolete field name, use RFIDSlotIndex instead.\nFor each RFID Code cleared whose user doesn\u2019t have a PIN Code or other credential type, then the corresponding user record\u2019s UserStatus value shall be set to Available, and UserType value shall be set to UnrestrictedUser and all schedules shall be cleared.",
+      xref: { document: "cluster", section: "5.2.10.32" },
+      children: [(0, import_elements.FieldElement)({
+        name: "RfidSlotIndex",
+        id: 0,
+        type: "uint16",
+        conformance: "M",
+        constraint: "1 to numberOfRfidUsersSupported, 65534",
+        details: "This field shall indicate a valid RFID code slot index or 0xFFFE to indicate all RFID code slots shall be cleared.",
+        xref: { document: "cluster", section: "5.2.10.32.1" }
+      })]
+    }),
+    (0, import_elements.CommandElement)({
+      name: "ClearAllRfidCodes",
+      id: 25,
+      access: "A T",
+      conformance: "!USR & RID",
+      direction: "request",
+      response: "status",
+      details: 'Clear out all RFIDs on the lock. If you clear all RFID codes and this user didn\u2019t have a PIN code, the user status has to be set to "0 Available", the user type has to be set to the default value, and all schedules which are supported have to be set to the default values.',
+      xref: { document: "cluster", section: "5.2.10.33" }
+    }),
+    (0, import_elements.CommandElement)({
+      name: "SetUser",
+      id: 26,
+      access: "A T",
+      conformance: "USR",
+      direction: "request",
+      response: "status",
+      details: "Set user into the lock.\nFields used for different use cases:\nReturn status is a global status code or a cluster-specific status code from the Status Codes table and\nshall be one of the following values:\n  \u2022 SUCCESS, if setting User was successful.\n  \u2022 FAILURE, if some unexpected internal error occurred setting User.\n  \u2022 OCCUPIED, if OperationType is Add and UserIndex points to an occupied slot.\n  \u2022 INVALID_COMMAND, if one or more fields violate constraints or are invalid or if OperationType     is Modify and UserIndex points to an available slot.",
+      xref: { document: "cluster", section: "5.2.10.34" },
+      children: [
+        (0, import_elements.FieldElement)({
+          name: "OperationType",
+          id: 0,
+          type: "DataOperationTypeEnum",
+          conformance: "M",
+          constraint: "add, modify",
+          details: "This field shall indicate the type of operation.",
+          xref: { document: "cluster", section: "5.2.10.34.1" }
+        }),
+        (0, import_elements.FieldElement)({
+          name: "UserIndex",
+          id: 1,
+          type: "uint16",
+          conformance: "M",
+          constraint: "1 to numberOfTotalUsersSupported",
+          details: "This field shall indicate the user ID.",
+          xref: { document: "cluster", section: "5.2.10.34.2" }
+        }),
+        (0, import_elements.FieldElement)({
+          name: "UserName",
+          id: 2,
+          type: "string",
+          conformance: "M",
+          constraint: "max 10",
+          quality: "X",
+          details: "This field shall contain a string to use as a human readable identifier for the user. If UserName is null then:\n  \u2022 If the OperationType is Add, the UserName in the resulting user record shall be set to an empty     string.\n  \u2022 If the OperationType is Modify, the UserName in the user record shall NOT be changed from the     current value.\nIf UserName is not null, the UserName in the user record shall be set to the provided value.",
+          xref: { document: "cluster", section: "5.2.10.34.3" }
+        }),
+        (0, import_elements.FieldElement)({
+          name: "UserUniqueId",
+          id: 3,
+          type: "uint32",
+          conformance: "M",
+          default: 4294967295,
+          quality: "X",
+          details: "This field shall indicate the fabric assigned number to use for connecting this user to other users on other devices from the fabric\u2019s perspective.\nIf UserUniqueID is null then:\n  \u2022 If the OperationType is Add, the UserUniqueID in the resulting user record shall be set to     default value specified above.\n  \u2022 If the OperationType is Modify, the UserUniqueID in the user record shall NOT be changed from     the current value.\nIf UserUniqueID is not null, the UserUniqueID in the user record shall be set to the provided value.",
+          xref: { document: "cluster", section: "5.2.10.34.4" }
+        }),
+        (0, import_elements.FieldElement)({
+          name: "UserStatus",
+          id: 4,
+          type: "UserStatusEnum",
+          conformance: "M",
+          constraint: "occupiedEnabled, occupiedDisabled",
+          default: 1,
+          quality: "X",
+          details: "This field shall indicate the UserStatus to assign to this user when created or modified. If UserStatus is null then:\n  \u2022 If the OperationType is Add, the UserStatus in the resulting user record shall be set to     default value specified above.\n  \u2022 If the OperationType is Modify, the UserStatus in the user record shall NOT be changed from the     current value.\nIf UserStatus is not null, the UserStatus in the user record shall be set to the provided value.",
+          xref: { document: "cluster", section: "5.2.10.34.5" }
+        }),
+        (0, import_elements.FieldElement)({
+          name: "UserType",
+          id: 5,
+          type: "UserTypeEnum",
+          conformance: "M",
+          constraint: "unrestrictedUser, nonAccessUser, forcedUser, disposableUser, expiringUser, scheduleRestrictedUser, remoteOnlyUser",
+          default: 0,
+          quality: "X",
+          details: "This field shall indicate the UserType to assign to this user when created or modified. If UserType is null then:\n  \u2022 If the OperationType is Add, the UserType in the resulting user record shall be set to default     value specified above.\n  \u2022 If the OperationType is Modify, the UserType in the user record shall NOT be changed from the     current value.\nIf UserType is not null, the UserType in the user record shall be set to the provided value.",
+          xref: { document: "cluster", section: "5.2.10.34.6" }
+        }),
+        (0, import_elements.FieldElement)({
+          name: "CredentialRule",
+          id: 6,
+          type: "CredentialRuleEnum",
+          conformance: "M",
+          default: 0,
+          quality: "X",
+          details: "This field shall indicate the CredentialRule to use for this user.\nThe valid CredentialRule enumeration values depends on the bits in the CredentialRulesBitmap map. Each bit in the map identifies a valid CredentialRule that can be used.\nIf CredentialRule is null then:\n  \u2022 If the OperationType is Add, the CredentialRule in the resulting user record shall be set to     default value specified above.\n  \u2022 If the OperationType is Modify, the CredentialRule in the user record shall NOT be changed from     the current value.\nIf CredentialRule is not null, the CredentialRule in the user record shall be set to the provided value.",
+          xref: { document: "cluster", section: "5.2.10.34.7" }
+        })
+      ]
+    }),
+    (0, import_elements.CommandElement)({
+      name: "GetUser",
+      id: 27,
+      access: "A",
+      conformance: "USR",
+      direction: "request",
+      response: "GetUserResponse",
+      details: "Retrieve user.\nAn InvokeResponse command shall be sent with an appropriate error\nCOMMAND, etc.) as needed otherwise the GetUserResponse Command shall be sent implying a status of SUCCESS.",
+      xref: { document: "cluster", section: "5.2.10.35" },
+      children: [(0, import_elements.FieldElement)({
+        name: "UserIndex",
+        id: 0,
+        type: "uint16",
+        conformance: "M",
+        constraint: "1 to numberOfTotalUsersSupported"
+      })]
+    }),
+    (0, import_elements.CommandElement)({
+      name: "GetUserResponse",
+      id: 28,
+      conformance: "USR",
+      direction: "response",
+      details: "Returns the user for the specified UserIndex.\nIf the requested UserIndex is valid and the UserStatus is Available for the requested UserIndex then UserName, UserUniqueID, UserStatus, UserType, CredentialRule, Credentials, CreatorFabricIndex, and LastModifiedFabricIndex shall all be null in the response.",
+      xref: { document: "cluster", section: "5.2.10.36" },
+      children: [
+        (0, import_elements.FieldElement)({
+          name: "UserIndex",
+          id: 0,
+          type: "uint16",
+          conformance: "M",
+          constraint: "1 to numberOfTotalUsersSupported",
+          details: "This field shall indicate the user ID.",
+          xref: { document: "cluster", section: "5.2.10.36.1" }
+        }),
+        (0, import_elements.FieldElement)({
+          name: "UserName",
+          id: 1,
+          type: "string",
+          conformance: "M",
+          constraint: "max 10",
+          quality: "X",
+          details: "This field shall contain a string to use as a human readable identifier for the user.",
+          xref: { document: "cluster", section: "5.2.10.36.2" }
+        }),
+        (0, import_elements.FieldElement)({
+          name: "UserUniqueId",
+          id: 2,
+          type: "uint32",
+          conformance: "M",
+          default: 0,
+          quality: "X",
+          details: "See UserUniqueID field.",
+          xref: { document: "cluster", section: "5.2.10.36.3" }
+        }),
+        (0, import_elements.FieldElement)({
+          name: "UserStatus",
+          id: 3,
+          type: "UserStatusEnum",
+          conformance: "M",
+          default: 0,
+          quality: "X",
+          details: "This field shall indicate the UserStatus assigned to the user when created or modified.",
+          xref: { document: "cluster", section: "5.2.10.36.4" }
+        }),
+        (0, import_elements.FieldElement)({
+          name: "UserType",
+          id: 4,
+          type: "UserTypeEnum",
+          conformance: "M",
+          default: 0,
+          quality: "X",
+          details: "This field shall indicate the UserType assigned to this user when created or modified.",
+          xref: { document: "cluster", section: "5.2.10.36.5" }
+        }),
+        (0, import_elements.FieldElement)({
+          name: "CredentialRule",
+          id: 5,
+          type: "CredentialRuleEnum",
+          conformance: "M",
+          constraint: "desc",
+          default: 0,
+          quality: "X",
+          details: "This field shall indicate the CredentialRule set for this user.",
+          xref: { document: "cluster", section: "5.2.10.36.6" }
+        }),
+        (0, import_elements.FieldElement)({
+          name: "Credentials",
+          id: 6,
+          type: "list",
+          conformance: "M",
+          constraint: "0 to numberOfCredentialsSupportedPerUser",
+          quality: "X",
+          details: "This field shall contain a list of credentials for this user.",
+          xref: { document: "cluster", section: "5.2.10.36.7" },
+          children: [(0, import_elements.FieldElement)({ name: "entry", type: "CredentialStruct" })]
+        }),
+        (0, import_elements.FieldElement)({
+          name: "CreatorFabricIndex",
+          id: 7,
+          type: "fabric-idx",
+          conformance: "M",
+          quality: "X",
+          details: "This field shall indicate the user\u2019s creator fabric index. CreatorFabricIndex shall be null if UserStatus is set to Available or when the creator fabric cannot be determined (for example, when user was created outside the Interaction Model) and shall NOT be null otherwise. This value shall be set to 0 if the original creator fabric was deleted.",
+          xref: { document: "cluster", section: "5.2.10.36.8" }
+        }),
+        (0, import_elements.FieldElement)({
+          name: "LastModifiedFabricIndex",
+          id: 8,
+          type: "fabric-idx",
+          conformance: "M",
+          quality: "X",
+          details: "This field shall indicate the user\u2019s last modifier fabric index. LastModifiedFabricIndex shall be null if UserStatus is set to Available or when the modifier fabric cannot be determined (for example, when user was modified outside the Interaction Model) and shall NOT be null otherwise. This value shall be set to 0 if the last modifier fabric was deleted.",
+          xref: { document: "cluster", section: "5.2.10.36.9" }
+        }),
+        (0, import_elements.FieldElement)({
+          name: "NextUserIndex",
+          id: 9,
+          type: "uint16",
+          conformance: "M",
+          constraint: "1 to numberOfTotalUsersSupported",
+          quality: "X",
+          details: "This field shall indicate the next occupied UserIndex in the database which is useful for quickly identifying occupied user slots in the database. This shall NOT be null if there is at least one occupied entry after the requested UserIndex in the User database and shall be null if there are no more occupied entries.",
+          xref: { document: "cluster", section: "5.2.10.36.10" }
+        })
+      ]
+    }),
+    (0, import_elements.CommandElement)({
+      name: "ClearUser",
+      id: 29,
+      access: "A T",
+      conformance: "USR",
+      direction: "request",
+      response: "status",
+      details: "Clears a user or all Users.\nFor each user to clear, all associated credentials (e.g. PIN, RFID, fingerprint, etc.) shall be cleared and the user entry values shall be reset to their default values (e.g. UserStatus shall be Available, UserType shall be UnrestrictedUser) and all associated schedules shall be cleared.\nA LockUserChange event with the provided UserIndex shall be generated after successfully clearing users.",
+      xref: { document: "cluster", section: "5.2.10.37" },
+      children: [(0, import_elements.FieldElement)({
+        name: "UserIndex",
+        id: 0,
+        type: "uint16",
+        conformance: "M",
+        constraint: "1 to numberOfTotalUsersSupported, 65534",
+        details: "This field shall specify a valid User index or 0xFFFE to indicate all user slots shall be cleared.",
+        xref: { document: "cluster", section: "5.2.10.37.1" }
+      })]
+    }),
+    (0, import_elements.CommandElement)({
+      name: "OperatingEventNotification",
+      id: 32,
+      conformance: "[NOT]",
+      direction: "response",
+      xref: { document: "cluster", section: "5.2.10" }
+    }),
+    (0, import_elements.CommandElement)({
+      name: "ProgrammingEventNotification",
+      id: 33,
+      conformance: "[NOT]",
+      direction: "response",
+      details: "The door lock server sends out a programming event notification whenever a programming event takes place on the door lock.\nAs with operational events, all programming events can be turned on and off by flipping bits in the associated event mask.\nThe programming event notification command includes an optional string of data that can be used by the manufacturer to pass some manufacturer-specific information if that is required.",
+      xref: { document: "cluster", section: "5.2.10.39" },
+      children: [
+        (0, import_elements.FieldElement)({
+          name: "ProgramEventSource",
+          id: 0,
+          type: "EventSourceEnum",
+          conformance: "M",
+          constraint: "desc",
+          details: "This field shall indicate where the event was triggered from.",
+          xref: { document: "cluster", section: "5.2.10.39.1" }
+        }),
+        (0, import_elements.FieldElement)({
+          name: "ProgramEventCode",
+          id: 1,
+          type: "ProgrammingEventCodeEnum",
+          conformance: "M",
+          constraint: "desc"
+        }),
+        (0, import_elements.FieldElement)({
+          name: "UserId",
+          id: 2,
+          type: "uint16",
+          conformance: "M",
+          constraint: "desc",
+          details: "This field shall indicate the UserID who performed the event",
+          xref: { document: "cluster", section: "5.2.10.39.6" }
+        }),
+        (0, import_elements.FieldElement)({
+          name: "Pin",
+          id: 3,
+          type: "octstr",
+          conformance: "M",
+          details: "This field shall indicate the PIN that is associated with the UserID who performed the event",
+          xref: { document: "cluster", section: "5.2.10.39.7" }
+        }),
+        (0, import_elements.FieldElement)({
+          name: "UserType",
+          id: 4,
+          type: "UserTypeEnum",
+          conformance: "M",
+          constraint: "desc",
+          details: "This field shall indicate the UserType that is associated with the UserID who performed the event",
+          xref: { document: "cluster", section: "5.2.10.39.8" }
+        }),
+        (0, import_elements.FieldElement)({
+          name: "UserStatus",
+          id: 5,
+          type: "UserStatusEnum",
+          conformance: "M",
+          constraint: "desc",
+          details: "This field shall indicate the UserStatus that is associated with the UserID who performed the event",
+          xref: { document: "cluster", section: "5.2.10.39.9" }
+        }),
+        (0, import_elements.FieldElement)({
+          name: "LocalTime",
+          id: 6,
+          type: "epoch-s",
+          conformance: "M",
+          details: "This field shall indicate the time when the event was triggered in Epoch Time in Seconds with local time offset based on the local timezone and DST offset on the day represented by the value. If time is not supported, the field shall be populated with default not used value 0xFFFFFFFF.",
+          xref: { document: "cluster", section: "5.2.10.39.10" }
+        }),
+        (0, import_elements.FieldElement)({
+          name: "Data",
+          id: 7,
+          type: "string",
+          conformance: "O",
+          details: "This field may contain a variable string, which can be used to pass data associated with a particular event. Generally this field will be left empty. However, manufacturer can choose to use this field to store/display manufacturer-specific information.",
+          xref: { document: "cluster", section: "5.2.10.39.11" }
+        })
+      ]
+    }),
+    (0, import_elements.CommandElement)({
+      name: "SetCredential",
+      id: 34,
+      access: "A T",
+      conformance: "USR",
+      direction: "request",
+      response: "SetCredentialResponse",
+      details: "Set a credential (e.g. PIN, RFID, Fingerprint, etc.) into the lock for a new user, existing user, or ProgrammingUser.\nFields used for different use cases:",
+      xref: { document: "cluster", section: "5.2.10.40" },
+      children: [
+        (0, import_elements.FieldElement)({
+          name: "OperationType",
+          id: 0,
+          type: "DataOperationTypeEnum",
+          conformance: "M",
+          constraint: "add, modify",
+          details: "This field shall indicate the set credential operation type requested.",
+          xref: { document: "cluster", section: "5.2.10.40.1" }
+        }),
+        (0, import_elements.FieldElement)({
+          name: "Credential",
+          id: 1,
+          type: "CredentialStruct",
+          conformance: "M",
+          details: "This field shall contain a credential structure that contains the CredentialTypeEnum and the credential index (if applicable or 0 if not) to set.",
+          xref: { document: "cluster", section: "5.2.10.40.2" }
+        }),
+        (0, import_elements.FieldElement)({
+          name: "CredentialData",
+          id: 2,
+          type: "octstr",
+          conformance: "M",
+          constraint: "desc",
+          details: "This field shall indicate the credential data to set for the credential being added or modified. The length of the credential data shall conform to the limits of the CredentialType specified in the Credential structure otherwise an INVALID_COMMAND status shall be returned in the SetCredentialResponse command.",
+          xref: { document: "cluster", section: "5.2.10.40.3" }
+        }),
+        (0, import_elements.FieldElement)({
+          name: "UserIndex",
+          id: 3,
+          type: "uint16",
+          conformance: "M",
+          constraint: "1 to numberOfTotalUsersSupported",
+          quality: "X",
+          details: "This field shall indicate the user index to the user record that corresponds to the credential being added or modified. This shall be null if OperationType is add and a new credential and user is being added at the same time.",
+          xref: { document: "cluster", section: "5.2.10.40.4" }
+        }),
+        (0, import_elements.FieldElement)({
+          name: "UserStatus",
+          id: 4,
+          type: "UserStatusEnum",
+          conformance: "M",
+          constraint: "occupiedEnabled, occupiedDisabled",
+          default: 1,
+          quality: "X",
+          details: "This field shall indicate the user status to use in the new user record if a new user is being created. This shall be null if OperationType is Modify. This may be null when adding a new credential and user.",
+          xref: { document: "cluster", section: "5.2.10.40.5" }
+        }),
+        (0, import_elements.FieldElement)({
+          name: "UserType",
+          id: 5,
+          type: "UserTypeEnum",
+          conformance: "M",
+          constraint: "unrestrictedUser, programmingUser, nonAccessUser, forcedUser, disposableUser, expiringUser, remoteOnlyUser",
+          default: 0,
+          quality: "X",
+          details: "This field shall indicate the user type to use in the new user record if a new user is being created. This shall be null if OperationType is Modify. This may be null when adding a new credential and user.",
+          xref: { document: "cluster", section: "5.2.10.40.6" }
+        })
+      ]
+    }),
+    (0, import_elements.CommandElement)({
+      name: "SetCredentialResponse",
+      id: 35,
+      conformance: "USR",
+      direction: "response",
+      details: "Returns the status for setting the specified credential.",
+      xref: { document: "cluster", section: "5.2.10.41" },
+      children: [
+        (0, import_elements.FieldElement)({
+          name: "Status",
+          id: 0,
+          type: "status",
+          conformance: "M",
+          constraint: "desc",
+          details: "Status comes from the Status Codes table and shall be one of the following values:\n  \u2022 SUCCESS, if setting user credential was successful.\n  \u2022 FAILURE, if some unexpected internal error occurred setting user credential.\n  \u2022 OCCUPIED, if OperationType is Add and CredentialIndex in Credential structure points to an     occupied slot.\n  \u2022 OCCUPIED, if OperationType is Modify and CredentialIndex in Credential structure does not match     the CredentialIndex that is already associated with the provided UserIndex.\n  \u2022 DUPLICATE, if CredentialData provided is a duplicate of another credential with the same     CredentialType (e.g. duplicate PIN code).\n  \u2022 RESOURCE_EXHAUSTED, if OperationType is Add and the user referred to by UserIndex already has     NumberOfCredentialsSupportedPerUser credentials associated.\n  \u2022 INVALID_COMMAND, if one or more fields violate constraints or are invalid.\n  \u2022 INVALID_COMMAND, if the CredentialIndex in the Credential provided exceeds the number of     credentials of the provided CredentialType supported by the lock.\n  \u2022 INVALID_COMMAND, if OperationType is Modify and UserIndex points to an available slot.",
+          xref: { document: "cluster", section: "5.2.10.41.1" }
+        }),
+        (0, import_elements.FieldElement)({
+          name: "UserIndex",
+          id: 1,
+          type: "uint16",
+          conformance: "M",
+          constraint: "1 to numberOfTotalUsersSupported",
+          default: 0,
+          quality: "X",
+          details: "This field shall indicate the user index that was created with the new credential. If the status being returned is not success then this shall be null. This shall be null if OperationType was Modify; if the OperationType was Add and a new User was created this shall NOT be null and shall provide the UserIndex created. If the OperationType was Add and an existing User was associated with the new credential then this shall be null.",
+          xref: { document: "cluster", section: "5.2.10.41.2" }
+        }),
+        (0, import_elements.FieldElement)({
+          name: "NextCredentialIndex",
+          id: 2,
+          type: "uint16",
+          conformance: "O",
+          constraint: "desc",
+          quality: "X",
+          details: "This field shall indicate the next available index in the database for the credential type set, which is useful for quickly identifying available credential slots in the database. This shall NOT be null if there is at least one available entry after the requested credential index in the corresponding database and shall be null if there are no more available entries. The NextCredentialIndex reported shall NOT exceed the maximum number of credentials for a particular credential type.",
+          xref: { document: "cluster", section: "5.2.10.41.3" }
+        })
+      ]
+    }),
+    (0, import_elements.CommandElement)({
+      name: "GetCredentialStatus",
+      id: 36,
+      access: "A",
+      conformance: "USR",
+      direction: "request",
+      response: "GetCredentialStatusResponse",
+      details: "Retrieve the status of a particular credential (e.g. PIN, RFID, Fingerprint, etc.) by index.\nAn InvokeResponse command shall be sent with an appropriate error (e.g. FAILURE, INVALID_COMMAND, etc.) as needed otherwise the GetCredentialStatusResponse command shall be sent implying a status of SUCCESS.",
+      xref: { document: "cluster", section: "5.2.10.42" },
+      children: [(0, import_elements.FieldElement)({
+        name: "Credential",
+        id: 0,
+        type: "CredentialStruct",
+        conformance: "M",
+        details: "This field shall contain a credential structure that contains the CredentialTypeEnum and the credential index (if applicable or 0 if not) to retrieve the status for.",
+        xref: { document: "cluster", section: "5.2.10.42.1" }
+      })]
+    }),
+    (0, import_elements.CommandElement)({
+      name: "GetCredentialStatusResponse",
+      id: 37,
+      conformance: "USR",
+      direction: "response",
+      details: "Returns the status for the specified credential.",
+      xref: { document: "cluster", section: "5.2.10.43" },
+      children: [
+        (0, import_elements.FieldElement)({
+          name: "CredentialExists",
+          id: 0,
+          type: "bool",
+          conformance: "M",
+          details: "This field shall indicate if the requested credential type and index exists and is populated for the requested user index.",
+          xref: { document: "cluster", section: "5.2.10.43.1" }
+        }),
+        (0, import_elements.FieldElement)({
+          name: "UserIndex",
+          id: 1,
+          type: "uint16",
+          conformance: "M",
+          constraint: "1 to numberOfTotalUsersSupported",
+          quality: "X",
+          details: "This field shall indicate the credential\u2019s corresponding user index value if the credential exists. If CredentialType requested was ProgrammingPIN then UserIndex shall be null; otherwise, UserIndex shall be null if CredentialExists is set to False and shall NOT be null if CredentialExists is set to True.",
+          xref: { document: "cluster", section: "5.2.10.43.2" }
+        }),
+        (0, import_elements.FieldElement)({
+          name: "CreatorFabricIndex",
+          id: 2,
+          type: "fabric-idx",
+          conformance: "M",
+          quality: "X",
+          details: "This field shall indicate the credential\u2019s creator fabric index. CreatorFabricIndex shall be null if CredentialExists is set to False or when the creator fabric cannot be determined (for example, when credential was created outside the Interaction Model) and shall NOT be null otherwise. This value shall be set to 0 if the original creator fabric was deleted.",
+          xref: { document: "cluster", section: "5.2.10.43.3" }
+        }),
+        (0, import_elements.FieldElement)({
+          name: "LastModifiedFabricIndex",
+          id: 3,
+          type: "fabric-idx",
+          conformance: "M",
+          quality: "X",
+          details: "This field shall indicate the credential\u2019s last modifier fabric index. LastModifiedFabricIndex shall be null if CredentialExists is set to False or when the modifier fabric cannot be determined (for example, when credential was modified outside the Interaction Model) and shall NOT be null otherwise. This value shall be set to 0 if the last modifier fabric was deleted.",
+          xref: { document: "cluster", section: "5.2.10.43.4" }
+        }),
+        (0, import_elements.FieldElement)({
+          name: "NextCredentialIndex",
+          id: 4,
+          type: "uint16",
+          conformance: "O",
+          constraint: "desc",
+          quality: "X",
+          details: "This field shall indicate the next occupied index in the database for the credential type requested, which is useful for quickly identifying occupied credential slots in the database. This shall NOT be null if there is at least one occupied entry after the requested credential index in the corresponding database and shall be null if there are no more occupied entries. The NextCredentialIndex reported shall NOT exceed the maximum number of credentials for a particular credential type.",
+          xref: { document: "cluster", section: "5.2.10.43.5" }
+        })
+      ]
+    }),
+    (0, import_elements.CommandElement)({
+      name: "ClearCredential",
+      id: 38,
+      access: "A T",
+      conformance: "USR",
+      direction: "request",
+      response: "status",
+      details: "Clear one, one type, or all credentials except ProgrammingPIN credential.\nFields used for different use cases:\nFor each credential cleared whose user doesn\u2019t have another valid credential, the corresponding user record shall be reset back to default values and its UserStatus value shall be set to Available and UserType value shall be set to UnrestrictedUser and all schedules shall be cleared. In\nthis case a LockUserChange event shall be generated for the user being cleared. Return status shall be one of the following values:",
+      xref: { document: "cluster", section: "5.2.10.44" },
+      children: [(0, import_elements.FieldElement)({
+        name: "Credential",
+        id: 0,
+        type: "CredentialStruct",
+        conformance: "M",
+        constraint: "desc",
+        quality: "X",
+        details: "This field shall contain a credential structure that contains the CredentialTypeEnum and the credential index (0xFFFE for all credentials or 0 if not applicable) to clear. This shall be null if clearing all credential types otherwise it shall NOT be null.",
+        xref: { document: "cluster", section: "5.2.10.44.1" }
+      })]
+    }),
+    (0, import_elements.CommandElement)({
+      name: "UnboltDoor",
+      id: 39,
+      access: "O T",
+      conformance: "UBOLT",
+      direction: "request",
+      response: "status",
+      details: "This command causes the lock device to unlock the door without pulling the latch. This command includes an optional code for the lock. The door lock may require a code depending on the value of the RequirePINForRemoteOperation attribute.\nNOTE\nIf the attribute AutoRelockTime is supported, the lock will transition to the locked state when the auto relock time has expired.",
+      xref: { document: "cluster", section: "5.2.10.45" },
+      children: [(0, import_elements.FieldElement)({
+        name: "PinCode",
+        id: 0,
+        type: "octstr",
+        conformance: "[COTA & PIN]",
+        details: "See PINCode field.",
+        xref: { document: "cluster", section: "5.2.10.45.1" }
+      })]
+    }),
+    (0, import_elements.DatatypeElement)({
+      name: "DaysMaskBitmap",
+      type: "map8",
+      details: "This bitmap shall indicate the days of the week the Week Day schedule applies for.",
+      xref: { document: "cluster", section: "5.2.6.1" },
+      children: [
+        (0, import_elements.FieldElement)({ name: "Sunday", constraint: "0", description: "Schedule is applied on Sunday" }),
+        (0, import_elements.FieldElement)({ name: "Monday", constraint: "1", description: "Schedule is applied on Monday" }),
+        (0, import_elements.FieldElement)({ name: "Tuesday", constraint: "2", description: "Schedule is applied on Tuesday" }),
+        (0, import_elements.FieldElement)({ name: "Wednesday", constraint: "3", description: "Schedule is applied on Wednesday" }),
+        (0, import_elements.FieldElement)({ name: "Thursday", constraint: "4", description: "Schedule is applied on Thursday" }),
+        (0, import_elements.FieldElement)({ name: "Friday", constraint: "5", description: "Schedule is applied on Friday" }),
+        (0, import_elements.FieldElement)({ name: "Saturday", constraint: "6", description: "Schedule is applied on Saturday" })
+      ]
+    }),
+    (0, import_elements.DatatypeElement)({
+      name: "CredentialRulesBitmap",
+      type: "map8",
+      xref: { document: "cluster", section: "5.2.6.2" },
+      children: [
+        (0, import_elements.FieldElement)({
+          name: "Single",
+          constraint: "0",
+          description: "Only one credential is required for lock operation"
+        }),
+        (0, import_elements.FieldElement)({
+          name: "Dual",
+          constraint: "1",
+          description: "Any two credentials are required for lock operation"
+        }),
+        (0, import_elements.FieldElement)({
+          name: "Tri",
+          constraint: "2",
+          description: "Any three credentials are required for lock operation"
+        })
+      ]
+    }),
+    (0, import_elements.DatatypeElement)({
+      name: "OperatingModesBitmap",
+      type: "map16",
+      xref: { document: "cluster", section: "5.2.6.3" },
+      children: [
+        (0, import_elements.FieldElement)({ name: "Normal", constraint: "0", description: "Normal operation mode" }),
+        (0, import_elements.FieldElement)({ name: "Vacation", constraint: "1", description: "Vacation operation mode" }),
+        (0, import_elements.FieldElement)({ name: "Privacy", constraint: "2", description: "Privacy operation mode" }),
+        (0, import_elements.FieldElement)({
+          name: "NoRemoteLockUnlock",
+          constraint: "3",
+          description: "No remote lock and unlock operation mode"
+        }),
+        (0, import_elements.FieldElement)({ name: "Passage", constraint: "4", description: "Passage operation mode" })
+      ]
+    }),
+    (0, import_elements.DatatypeElement)({
+      name: "ConfigurationRegisterBitmap",
+      type: "map16",
+      xref: { document: "cluster", section: "5.2.6.4" },
+      children: [
+        (0, import_elements.FieldElement)({
+          name: "LocalProgramming",
+          constraint: "0",
+          description: "The state of local programming functionality",
+          details: "This bit shall indicate the state related to local programming:\n  \u2022 0 = Local programming is disabled\n  \u2022 1 = Local programming is enabled",
+          xref: { document: "cluster", section: "5.2.6.4.1" }
+        }),
+        (0, import_elements.FieldElement)({
+          name: "KeypadInterface",
+          constraint: "1",
+          description: "The state of the keypad interface",
+          details: "This bit shall indicate the state related to keypad interface:\n  \u2022 0 = Keypad interface is disabled\n  \u2022 1 = Keypad interface is enabled",
+          xref: { document: "cluster", section: "5.2.6.4.2" }
+        }),
+        (0, import_elements.FieldElement)({
+          name: "RemoteInterface",
+          constraint: "2",
+          description: "The state of the remote interface",
+          details: "This bit shall indicate the state related to remote interface:\n  \u2022 0 = Remote interface is disabled\n  \u2022 1 = Remote interface is enabled",
+          xref: { document: "cluster", section: "5.2.6.4.3" }
+        }),
+        (0, import_elements.FieldElement)({
+          name: "SoundVolume",
+          constraint: "5",
+          description: "Sound volume is set to Silent value",
+          details: "This bit shall indicate the state related to sound volume:\n  \u2022 0 = Sound volume value is 0 (Silent)\n  \u2022 1 = Sound volume value is equal to something other than 0",
+          xref: { document: "cluster", section: "5.2.6.4.4" }
+        }),
+        (0, import_elements.FieldElement)({
+          name: "AutoRelockTime",
+          constraint: "6",
+          description: "Auto relock time it set to 0",
+          details: "This bit shall indicate the state related to auto relock time:\n  \u2022 0 = Auto relock time value is 0\n  \u2022 1 = Auto relock time value is equal to something other than 0",
+          xref: { document: "cluster", section: "5.2.6.4.5" }
+        }),
+        (0, import_elements.FieldElement)({
+          name: "LedSettings",
+          constraint: "7",
+          description: "LEDs is disabled",
+          details: "This bit shall indicate the state related to LED settings:\n  \u2022 0 = LED settings value is 0 (NoLEDSignal)\n  \u2022 1 = LED settings value is equal to something other than 0",
+          xref: { document: "cluster", section: "5.2.6.4.6" }
+        })
+      ]
+    }),
+    (0, import_elements.DatatypeElement)({
+      name: "LocalProgrammingFeaturesBitmap",
+      type: "map8",
+      xref: { document: "cluster", section: "5.2.6.5" },
+      children: [
+        (0, import_elements.FieldElement)({
+          name: "AddUsersCredentialsSchedules",
+          constraint: "0",
+          description: "The state of the ability to add users, credentials or schedules on the device",
+          details: "This bit shall indicate whether the door lock is able to add Users/Credentials/Schedules locally:\n  \u2022 0 = This ability is disabled\n  \u2022 1 = This ability is enabled",
+          xref: { document: "cluster", section: "5.2.6.5.1" }
+        }),
+        (0, import_elements.FieldElement)({
+          name: "ModifyUsersCredentialsSchedules",
+          constraint: "1",
+          description: "The state of the ability to modify users, credentials or schedules on the device",
+          details: "This bit shall indicate whether the door lock is able to modify Users/Credentials/Schedules locally:\n  \u2022 0 = This ability is disabled\n  \u2022 1 = This ability is enabled",
+          xref: { document: "cluster", section: "5.2.6.5.2" }
+        }),
+        (0, import_elements.FieldElement)({
+          name: "ClearUsersCredentialsSchedules",
+          constraint: "2",
+          description: "The state of the ability to clear users, credentials or schedules on the device",
+          details: "This bit shall indicate whether the door lock is able to clear Users/Credentials/Schedules locally:\n  \u2022 0 = This ability is disabled\n  \u2022 1 = This ability is enabled",
+          xref: { document: "cluster", section: "5.2.6.5.3" }
+        }),
+        (0, import_elements.FieldElement)({
+          name: "AdjustSettings",
+          constraint: "3",
+          description: "The state of the ability to adjust settings on the device",
+          details: "This bit shall indicate whether the door lock is able to adjust lock settings locally:\n  \u2022 0 = This ability is disabled\n  \u2022 1 = This ability is enabled",
+          xref: { document: "cluster", section: "5.2.6.5.4" }
+        })
+      ]
+    }),
+    (0, import_elements.DatatypeElement)({
+      name: "AlarmMaskBitmap",
+      type: "map16",
+      xref: { document: "cluster", section: "5.2.6.6" },
+      children: [
+        (0, import_elements.FieldElement)({ name: "LockJammed", constraint: "0", description: "Locking Mechanism Jammed" }),
+        (0, import_elements.FieldElement)({ name: "LockFactoryReset", constraint: "1", description: "Lock Reset to Factory Defaults" }),
+        (0, import_elements.FieldElement)({ name: "NA", constraint: "2", description: "Reserved" }),
+        (0, import_elements.FieldElement)({ name: "LockRadioPowerCycled", constraint: "3", description: "RF Module Power Cycled" }),
+        (0, import_elements.FieldElement)({
+          name: "WrongCodeEntryLimit",
+          constraint: "4",
+          description: "Tamper Alarm - wrong code entry limit"
+        }),
+        (0, import_elements.FieldElement)({
+          name: "FrontEscutcheonRemoved",
+          constraint: "5",
+          description: "Tamper Alarm - front escutcheon removed from main"
+        }),
+        (0, import_elements.FieldElement)({
+          name: "DoorForcedOpen",
+          constraint: "6",
+          description: "Forced Door Open under Door Locked Condition"
+        })
+      ]
+    }),
+    (0, import_elements.DatatypeElement)({
+      name: "EventMaskBitmap",
+      type: "map16",
+      xref: { document: "cluster", section: "5.2.6.7" },
+      children: [
+        (0, import_elements.FieldElement)({ name: "Bit0", constraint: "0", description: "State of bit 0" }),
+        (0, import_elements.FieldElement)({ name: "Bit1", constraint: "1", description: "State of bit 1" }),
+        (0, import_elements.FieldElement)({ name: "Bit2", constraint: "2", description: "State of bit 2" }),
+        (0, import_elements.FieldElement)({ name: "Bit3", constraint: "3", description: "State of bit 3" }),
+        (0, import_elements.FieldElement)({ name: "Bit4", constraint: "4", description: "State of bit 4" }),
+        (0, import_elements.FieldElement)({ name: "Bit5", constraint: "5", description: "State of bit 5" }),
+        (0, import_elements.FieldElement)({ name: "Bit6", constraint: "6", description: "State of bit 6" }),
+        (0, import_elements.FieldElement)({ name: "Bit7", constraint: "7", description: "State of bit 7" }),
+        (0, import_elements.FieldElement)({ name: "Bit8", constraint: "8", description: "State of bit 8" }),
+        (0, import_elements.FieldElement)({ name: "Bit9", constraint: "9", description: "State of bit 9" }),
+        (0, import_elements.FieldElement)({ name: "Bit10", constraint: "10", description: "State of bit 10" }),
+        (0, import_elements.FieldElement)({ name: "Bit11", constraint: "11", description: "State of bit 11" }),
+        (0, import_elements.FieldElement)({ name: "Bit12", constraint: "12", description: "State of bit 12" }),
+        (0, import_elements.FieldElement)({ name: "Bit13", constraint: "13", description: "State of bit 13" }),
+        (0, import_elements.FieldElement)({ name: "Bit14", constraint: "14", description: "State of bit 14" }),
+        (0, import_elements.FieldElement)({ name: "Bit15", constraint: "15", description: "State of bit 15" })
+      ]
+    }),
+    (0, import_elements.DatatypeElement)({
+      name: "AlarmCodeEnum",
+      type: "enum8",
+      details: "This enumeration shall indicate the alarm type.",
+      xref: { document: "cluster", section: "5.2.6.8" },
+      children: [
+        (0, import_elements.FieldElement)({ name: "LockJammed", id: 0, conformance: "M", description: "Locking Mechanism Jammed" }),
+        (0, import_elements.FieldElement)({
+          name: "LockFactoryReset",
+          id: 1,
+          conformance: "O",
+          description: "Lock Reset to Factory Defaults"
+        }),
+        (0, import_elements.FieldElement)({ name: "LockRadioPowerCycled", id: 3, conformance: "O", description: "Lock Radio Power Cycled" }),
+        (0, import_elements.FieldElement)({
+          name: "WrongCodeEntryLimit",
+          id: 4,
+          conformance: "[USR]",
+          description: "Tamper Alarm - wrong code entry limit"
+        }),
+        (0, import_elements.FieldElement)({
+          name: "FrontEsceutcheonRemoved",
+          id: 5,
+          conformance: "O",
+          description: "Tamper Alarm - front escutcheon removed from main"
+        }),
+        (0, import_elements.FieldElement)({
+          name: "DoorForcedOpen",
+          id: 6,
+          conformance: "[DPS]",
+          description: "Forced Door Open under Door Locked Condition"
+        }),
+        (0, import_elements.FieldElement)({ name: "DoorAjar", id: 7, conformance: "[DPS]", description: "Door ajar" }),
+        (0, import_elements.FieldElement)({ name: "ForcedUser", id: 8, conformance: "[USR]", description: "Force User SOS alarm" })
+      ]
+    }),
+    (0, import_elements.DatatypeElement)({
+      name: "CredentialRuleEnum",
+      type: "enum8",
+      details: "This enumeration shall indicate the credential rule that can be applied to a particular user.",
+      xref: { document: "cluster", section: "5.2.6.9" },
+      children: [
+        (0, import_elements.FieldElement)({
+          name: "Single",
+          id: 0,
+          conformance: "USR",
+          description: "Only one credential is required for lock operation"
+        }),
+        (0, import_elements.FieldElement)({
+          name: "Dual",
+          id: 1,
+          conformance: "[USR]",
+          description: "Any two credentials are required for lock operation"
+        }),
+        (0, import_elements.FieldElement)({
+          name: "Tri",
+          id: 2,
+          conformance: "[USR]",
+          description: "Any three credentials are required for lock operation"
+        })
+      ]
+    }),
+    (0, import_elements.DatatypeElement)({
+      name: "CredentialTypeEnum",
+      type: "enum8",
+      details: "This enumeration shall indicate the credential type.",
+      xref: { document: "cluster", section: "5.2.6.10" },
+      children: [
+        (0, import_elements.FieldElement)({
+          name: "ProgrammingPin",
+          id: 0,
+          conformance: "O",
+          description: "Programming PIN code credential type"
+        }),
+        (0, import_elements.FieldElement)({ name: "Pin", id: 1, conformance: "PIN", description: "PIN code credential type" }),
+        (0, import_elements.FieldElement)({ name: "Rfid", id: 2, conformance: "RID", description: "RFID identifier credential type" }),
+        (0, import_elements.FieldElement)({
+          name: "Fingerprint",
+          id: 3,
+          conformance: "FGP",
+          description: "Fingerprint identifier credential type"
+        }),
+        (0, import_elements.FieldElement)({
+          name: "FingerVein",
+          id: 4,
+          conformance: "FGP",
+          description: "Finger vein identifier credential type"
+        }),
+        (0, import_elements.FieldElement)({ name: "Face", id: 5, conformance: "FACE", description: "Face identifier credential type" })
+      ]
+    }),
+    (0, import_elements.DatatypeElement)({
+      name: "DataOperationTypeEnum",
+      type: "enum8",
+      details: "This enumeration shall indicate the data operation performed.",
+      xref: { document: "cluster", section: "5.2.6.11" },
+      children: [
+        (0, import_elements.FieldElement)({ name: "Add", id: 0, conformance: "M", description: "Data is being added or was added" }),
+        (0, import_elements.FieldElement)({ name: "Clear", id: 1, conformance: "M", description: "Data is being cleared or was cleared" }),
+        (0, import_elements.FieldElement)({ name: "Modify", id: 2, conformance: "M", description: "Data is being modified or was modified" })
+      ]
+    }),
+    (0, import_elements.DatatypeElement)({
+      name: "DoorStateEnum",
+      type: "enum8",
+      details: "This enumeration shall indicate the current door state.",
+      xref: { document: "cluster", section: "5.2.6.12" },
+      children: [
+        (0, import_elements.FieldElement)({ name: "DoorOpen", id: 0, conformance: "DPS", description: "Door state is open" }),
+        (0, import_elements.FieldElement)({ name: "DoorClosed", id: 1, conformance: "DPS", description: "Door state is closed" }),
+        (0, import_elements.FieldElement)({ name: "DoorJammed", id: 2, conformance: "[DPS]", description: "Door state is jammed" }),
+        (0, import_elements.FieldElement)({
+          name: "DoorForcedOpen",
+          id: 3,
+          conformance: "[DPS]",
+          description: "Door state is currently forced open"
+        }),
+        (0, import_elements.FieldElement)({
+          name: "DoorUnspecifiedError",
+          id: 4,
+          conformance: "[DPS]",
+          description: "Door state is invalid for unspecified reason"
+        }),
+        (0, import_elements.FieldElement)({ name: "DoorAjar", id: 5, conformance: "[DPS]", description: "Door state is ajar" })
+      ]
+    }),
+    (0, import_elements.DatatypeElement)({
+      name: "LockDataTypeEnum",
+      type: "enum8",
+      details: "This enumeration shall indicate the data type that is being or has changed.",
+      xref: { document: "cluster", section: "5.2.6.13" },
+      children: [
+        (0, import_elements.FieldElement)({
+          name: "Unspecified",
+          id: 0,
+          conformance: "O",
+          description: "Unspecified or manufacturer specific lock user data added, cleared, or modified."
+        }),
+        (0, import_elements.FieldElement)({
+          name: "ProgrammingCode",
+          id: 1,
+          conformance: "O",
+          description: "Lock programming PIN code was added, cleared, or modified."
+        }),
+        (0, import_elements.FieldElement)({
+          name: "UserIndex",
+          id: 2,
+          conformance: "M",
+          description: "Lock user index was added, cleared, or modified."
+        }),
+        (0, import_elements.FieldElement)({
+          name: "WeekDaySchedule",
+          id: 3,
+          conformance: "WDSCH",
+          description: "Lock user week day schedule was added, cleared, or modified."
+        }),
+        (0, import_elements.FieldElement)({
+          name: "YearDaySchedule",
+          id: 4,
+          conformance: "YDSCH",
+          description: "Lock user year day schedule was added, cleared, or modified."
+        }),
+        (0, import_elements.FieldElement)({
+          name: "HolidaySchedule",
+          id: 5,
+          conformance: "HDSCH",
+          description: "Lock holiday schedule was added, cleared, or modified."
+        }),
+        (0, import_elements.FieldElement)({
+          name: "Pin",
+          id: 6,
+          conformance: "PIN",
+          description: "Lock user PIN code was added, cleared, or modified."
+        }),
+        (0, import_elements.FieldElement)({
+          name: "Rfid",
+          id: 7,
+          conformance: "RID",
+          description: "Lock user RFID code was added, cleared, or modified."
+        }),
+        (0, import_elements.FieldElement)({
+          name: "Fingerprint",
+          id: 8,
+          conformance: "FGP",
+          description: "Lock user fingerprint was added, cleared, or modified."
+        }),
+        (0, import_elements.FieldElement)({
+          name: "FingerVein",
+          id: 9,
+          conformance: "FGP",
+          description: "Lock user finger-vein information was added, cleared, or modified."
+        }),
+        (0, import_elements.FieldElement)({
+          name: "Face",
+          id: 10,
+          conformance: "FACE",
+          description: "Lock user face information was added, cleared, or modified."
+        })
+      ]
+    }),
+    (0, import_elements.DatatypeElement)({
+      name: "LockOperationTypeEnum",
+      type: "enum8",
+      details: "This enumeration shall indicate the type of Lock operation performed.",
+      xref: { document: "cluster", section: "5.2.6.14" },
+      children: [
+        (0, import_elements.FieldElement)({ name: "Lock", id: 0, conformance: "M", description: "Lock operation" }),
+        (0, import_elements.FieldElement)({ name: "Unlock", id: 1, conformance: "M", description: "Unlock operation" }),
+        (0, import_elements.FieldElement)({
+          name: "NonAccessUserEvent",
+          id: 2,
+          conformance: "O",
+          description: "Triggered by keypad entry for user with User Type set to Non Access User"
+        }),
+        (0, import_elements.FieldElement)({
+          name: "ForcedUserEvent",
+          id: 3,
+          conformance: "O",
+          description: "Triggered by using a user with UserType set to Forced User"
+        }),
+        (0, import_elements.FieldElement)({ name: "Unlatch", id: 4, conformance: "M", description: "Unlatch operation" })
+      ]
+    }),
+    (0, import_elements.DatatypeElement)({
+      name: "OperationErrorEnum",
+      type: "enum8",
+      details: "This enumeration shall indicate the error cause of the Lock/Unlock operation performed.",
+      xref: { document: "cluster", section: "5.2.6.15" },
+      children: [
+        (0, import_elements.FieldElement)({
+          name: "Unspecified",
+          id: 0,
+          conformance: "O",
+          description: "Lock/unlock error caused by unknown or unspecified source"
+        }),
+        (0, import_elements.FieldElement)({
+          name: "InvalidCredential",
+          id: 1,
+          conformance: "USR",
+          description: "Lock/unlock error caused by invalid PIN, RFID, fingerprint or other credential"
+        }),
+        (0, import_elements.FieldElement)({
+          name: "DisabledUserDenied",
+          id: 2,
+          conformance: "M",
+          description: "Lock/unlock error caused by disabled USER or credential"
+        }),
+        (0, import_elements.FieldElement)({
+          name: "Restricted",
+          id: 3,
+          conformance: "WDSCH | YDSCH",
+          description: "Lock/unlock error caused by schedule restriction"
+        }),
+        (0, import_elements.FieldElement)({
+          name: "InsufficientBattery",
+          id: 4,
+          conformance: "O",
+          description: "Lock/unlock error caused by insufficient battery power left to safely actuate the lock"
+        })
+      ]
+    }),
+    (0, import_elements.DatatypeElement)({
+      name: "OperatingModeEnum",
+      type: "enum8",
+      details: "This enumeration shall indicate the lock operating mode.\nThe table below shows the operating mode and which interfaces are enabled, if supported, for each mode.\n* Interface Operational: Yes, No or N/A\nNOTE\nFor modes that disable the remote interface, the door lock shall respond to Lock, Unlock, Toggle, and Unlock with Timeout commands with a response status Failure and not take the action requested by those commands. The door lock shall NOT disable the radio or otherwise unbind or leave the network. It shall still respond to all other commands and requests.",
+      xref: { document: "cluster", section: "5.2.6.16" },
+      children: [
+        (0, import_elements.FieldElement)({
+          name: "Normal",
+          id: 0,
+          conformance: "M",
+          details: "The lock operates normally. All interfaces are enabled.",
+          xref: { document: "cluster", section: "5.2.6.16.1" }
+        }),
+        (0, import_elements.FieldElement)({
+          name: "Vacation",
+          id: 1,
+          conformance: "O",
+          details: "Only remote interaction is enabled. The keypad shall only be operable by the master user.",
+          xref: { document: "cluster", section: "5.2.6.16.2" }
+        }),
+        (0, import_elements.FieldElement)({
+          name: "Privacy",
+          id: 2,
+          conformance: "O",
+          details: "This mode is only possible if the door is locked. Manual unlocking changes the mode to Normal operating mode. All external interaction with the door lock is disabled. This mode is intended to be used so that users, presumably inside the property, will have control over the entrance.",
+          xref: { document: "cluster", section: "5.2.6.16.3" }
+        }),
+        (0, import_elements.FieldElement)({
+          name: "NoRemoteLockUnlock",
+          id: 3,
+          conformance: "M",
+          details: "This mode only disables remote interaction with the lock. This does not apply to any remote proprietary means of communication. It specifically applies to the Lock, Unlock, Toggle, and Unlock with Timeout Commands.",
+          xref: { document: "cluster", section: "5.2.6.16.4" }
+        }),
+        (0, import_elements.FieldElement)({
+          name: "Passage",
+          id: 4,
+          conformance: "O",
+          details: "The lock is open or can be opened or closed at will without the use of a Keypad or other means of user validation (e.g. a lock for a business during work hours).",
+          xref: { document: "cluster", section: "5.2.6.16.5" }
+        })
+      ]
+    }),
+    (0, import_elements.DatatypeElement)({
+      name: "OperationSourceEnum",
+      type: "enum8",
+      details: "This enumeration shall indicate the source of the Lock/Unlock or user change operation performed.",
+      xref: { document: "cluster", section: "5.2.6.17" },
+      children: [
+        (0, import_elements.FieldElement)({
+          name: "Unspecified",
+          id: 0,
+          conformance: "O",
+          description: "Lock/unlock operation came from unspecified source"
+        }),
+        (0, import_elements.FieldElement)({
+          name: "Manual",
+          id: 1,
+          conformance: "O",
+          description: "Lock/unlock operation came from manual operation (key, thumbturn, handle, etc)."
+        }),
+        (0, import_elements.FieldElement)({
+          name: "ProprietaryRemote",
+          id: 2,
+          conformance: "O",
+          description: "Lock/unlock operation came from proprietary remote source (e.g. vendor app/cloud)"
+        }),
+        (0, import_elements.FieldElement)({ name: "Keypad", id: 3, conformance: "O", description: "Lock/unlock operation came from keypad" }),
+        (0, import_elements.FieldElement)({
+          name: "Auto",
+          id: 4,
+          conformance: "O",
+          description: "Lock/unlock operation came from lock automatically (e.g. relock timer)"
+        }),
+        (0, import_elements.FieldElement)({
+          name: "Button",
+          id: 5,
+          conformance: "O",
+          description: "Lock/unlock operation came from lock button (e.g. one touch or button)"
+        }),
+        (0, import_elements.FieldElement)({
+          name: "Schedule",
+          id: 6,
+          conformance: "HDSCH",
+          description: "Lock/unlock operation came from lock due to a schedule"
+        }),
+        (0, import_elements.FieldElement)({
+          name: "Remote",
+          id: 7,
+          conformance: "M",
+          description: "Lock/unlock operation came from remote node"
+        }),
+        (0, import_elements.FieldElement)({
+          name: "Rfid",
+          id: 8,
+          conformance: "RID",
+          description: "Lock/unlock operation came from RFID card"
+        }),
+        (0, import_elements.FieldElement)({
+          name: "Biometric",
+          id: 9,
+          conformance: "[USR]",
+          description: "Lock/unlock operation came from biometric source (e.g. face, fingerprint/fingervein)"
+        })
+      ]
+    }),
+    (0, import_elements.DatatypeElement)({
+      name: "UserStatusEnum",
+      type: "enum8",
+      details: "This enumeration shall indicate what the status is for a specific user ID.",
+      xref: { document: "cluster", section: "5.2.6.18" },
+      children: [
+        (0, import_elements.FieldElement)({ name: "Available", id: 0, conformance: "M", description: "The user ID is available" }),
+        (0, import_elements.FieldElement)({
+          name: "OccupiedEnabled",
+          id: 1,
+          conformance: "M",
+          description: "The user ID is occupied and enabled"
+        }),
+        (0, import_elements.FieldElement)({
+          name: "OccupiedDisabled",
+          id: 3,
+          conformance: "O",
+          description: "The user ID is occupied and disabled"
+        })
+      ]
+    }),
+    (0, import_elements.DatatypeElement)({
+      name: "UserTypeEnum",
+      type: "enum8",
+      details: "This enumeration shall indicate what the type is for a specific user ID.",
+      xref: { document: "cluster", section: "5.2.6.19" },
+      children: [
+        (0, import_elements.FieldElement)({
+          name: "UnrestrictedUser",
+          id: 0,
+          conformance: "M",
+          description: "The user ID type is unrestricted",
+          details: "This value shall indicate the user has access 24/7 provided proper PIN or RFID is supplied (e.g., owner).",
+          xref: { document: "cluster", section: "5.2.6.19.1" }
+        }),
+        (0, import_elements.FieldElement)({
+          name: "YearDayScheduleUser",
+          id: 1,
+          conformance: "O",
+          description: "The user ID type is schedule",
+          details: "This value shall indicate the user has the ability to open lock within a specific time period (e.g., guest).",
+          xref: { document: "cluster", section: "5.2.6.19.2" }
+        }),
+        (0, import_elements.FieldElement)({
+          name: "WeekDayScheduleUser",
+          id: 2,
+          conformance: "O",
+          description: "The user ID type is schedule",
+          details: "This value shall indicate the user has the ability to open lock based on specific time period within a reoccurring weekly schedule (e.g., cleaning worker).",
+          xref: { document: "cluster", section: "5.2.6.19.3" }
+        }),
+        (0, import_elements.FieldElement)({
+          name: "ProgrammingUser",
+          id: 3,
+          conformance: "O",
+          description: "The user ID type is programming",
+          details: "This value shall indicate the user has the ability to both program and operate the door lock. This user can manage the users and user schedules. In all other respects this user matches the unrestricted (default) user. ProgrammingUser is the only user that can disable the user interface (keypad, remote, etc\u2026).",
+          xref: { document: "cluster", section: "5.2.6.19.4" }
+        }),
+        (0, import_elements.FieldElement)({
+          name: "NonAccessUser",
+          id: 4,
+          conformance: "O",
+          description: "The user ID type is non access",
+          details: "This value shall indicate the user is recognized by the lock but does not have the ability to open the lock. This user will only cause the lock to generate the appropriate event notification to any bound devices.",
+          xref: { document: "cluster", section: "5.2.6.19.5" }
+        }),
+        (0, import_elements.FieldElement)({
+          name: "ForcedUser",
+          id: 5,
+          conformance: "[USR]",
+          description: "The user ID type is forced",
+          details: "This value shall indicate the user has the ability to open lock but a ForcedUser LockOperationType and ForcedUser silent alarm will be emitted to allow a notified Node to alert emergency services or contacts on the user account when used.",
+          xref: { document: "cluster", section: "5.2.6.19.6" }
+        }),
+        (0, import_elements.FieldElement)({
+          name: "DisposableUser",
+          id: 6,
+          conformance: "[USR]",
+          description: "The user ID type is disposable",
+          details: "This value shall indicate the user has the ability to open lock once after which the lock shall change the corresponding user record UserStatus value to OccupiedDisabled automatically.",
+          xref: { document: "cluster", section: "5.2.6.19.7" }
+        }),
+        (0, import_elements.FieldElement)({
+          name: "ExpiringUser",
+          id: 7,
+          conformance: "[USR]",
+          description: "The user ID type is expiring",
+          details: "This value shall indicate the user has the ability to open lock for ExpiringUserTimeout attribute minutes after the first use of the PIN code, RFID code, Fingerprint, or other credential. After ExpiringUserTimeout minutes the corresponding user record UserStatus value shall be set to OccupiedDisabled automatically by the lock. The lock shall persist the timeout across reboots such that the ExpiringUserTimeout is honored.",
+          xref: { document: "cluster", section: "5.2.6.19.8" }
+        }),
+        (0, import_elements.FieldElement)({
+          name: "ScheduleRestrictedUser",
+          id: 8,
+          conformance: "WDSCH | YDSCH",
+          description: "The user ID type is schedule restricted",
+          details: "This value shall indicate the user access is restricted by Week Day and/or Year Day schedule.",
+          xref: { document: "cluster", section: "5.2.6.19.9" }
+        }),
+        (0, import_elements.FieldElement)({
+          name: "RemoteOnlyUser",
+          id: 9,
+          conformance: "USR & COTA & PIN",
+          description: "The user ID type is remote only",
+          details: "This value shall indicate the user access and PIN code is restricted to remote lock/unlock commands only. This type of user might be useful for regular delivery services or voice assistant unlocking operations to prevent a PIN code credential created for them from being used at the keypad. The PIN code credential would only be provided over-the-air for the lock/unlock commands.",
+          xref: { document: "cluster", section: "5.2.6.19.10" }
+        })
+      ]
+    }),
+    (0, import_elements.DatatypeElement)({
+      name: "LockStateEnum",
+      type: "enum8",
+      xref: { document: "cluster", section: "5.2.6.20" },
+      children: [
+        (0, import_elements.FieldElement)({ name: "NotFullyLocked", id: 0, conformance: "M", description: "Lock state is not fully locked" }),
+        (0, import_elements.FieldElement)({ name: "Locked", id: 1, conformance: "M", description: "Lock state is fully locked" }),
+        (0, import_elements.FieldElement)({ name: "Unlocked", id: 2, conformance: "M", description: "Lock state is fully unlocked" }),
+        (0, import_elements.FieldElement)({
+          name: "Unlatched",
+          id: 3,
+          conformance: "O",
+          description: "Lock state is fully unlocked and the latch is pulled"
+        })
+      ]
+    }),
+    (0, import_elements.DatatypeElement)({
+      name: "LockTypeEnum",
+      type: "enum8",
+      xref: { document: "cluster", section: "5.2.6.21" },
+      children: [
+        (0, import_elements.FieldElement)({ name: "DeadBolt", id: 0, conformance: "M", description: "Physical lock type is dead bolt" }),
+        (0, import_elements.FieldElement)({ name: "Magnetic", id: 1, conformance: "M", description: "Physical lock type is magnetic" }),
+        (0, import_elements.FieldElement)({ name: "Other", id: 2, conformance: "M", description: "Physical lock type is other" }),
+        (0, import_elements.FieldElement)({ name: "Mortise", id: 3, conformance: "M", description: "Physical lock type is mortise" }),
+        (0, import_elements.FieldElement)({ name: "Rim", id: 4, conformance: "M", description: "Physical lock type is rim" }),
+        (0, import_elements.FieldElement)({ name: "LatchBolt", id: 5, conformance: "M", description: "Physical lock type is latch bolt" }),
+        (0, import_elements.FieldElement)({
+          name: "CylindricalLock",
+          id: 6,
+          conformance: "M",
+          description: "Physical lock type is cylindrical lock"
+        }),
+        (0, import_elements.FieldElement)({
+          name: "TubularLock",
+          id: 7,
+          conformance: "M",
+          description: "Physical lock type is tubular lock"
+        }),
+        (0, import_elements.FieldElement)({
+          name: "InterconnectedLock",
+          id: 8,
+          conformance: "M",
+          description: "Physical lock type is interconnected lock"
+        }),
+        (0, import_elements.FieldElement)({ name: "DeadLatch", id: 9, conformance: "M", description: "Physical lock type is dead latch" }),
+        (0, import_elements.FieldElement)({
+          name: "DoorFurniture",
+          id: 10,
+          conformance: "M",
+          description: "Physical lock type is door furniture"
+        }),
+        (0, import_elements.FieldElement)({
+          name: "Eurocylinder",
+          id: 11,
+          conformance: "M",
+          description: "Physical lock type is euro cylinder"
+        })
+      ]
+    }),
+    (0, import_elements.DatatypeElement)({
+      name: "LEDSettingEnum",
+      type: "enum8",
+      xref: { document: "cluster", section: "5.2.6.22" },
+      children: [
+        (0, import_elements.FieldElement)({ name: "NoLedSignal", id: 0, conformance: "M", description: "Never use LED for signalization" }),
+        (0, import_elements.FieldElement)({
+          name: "NoLedSignalAccessAllowed",
+          id: 1,
+          conformance: "M",
+          description: "Use LED signalization except for access allowed events"
+        }),
+        (0, import_elements.FieldElement)({
+          name: "LedSignalAll",
+          id: 2,
+          conformance: "M",
+          description: "Use LED signalization for all events"
+        })
+      ]
+    }),
+    (0, import_elements.DatatypeElement)({
+      name: "SoundVolumeEnum",
+      type: "enum8",
+      xref: { document: "cluster", section: "5.2.6.23" },
+      children: [
+        (0, import_elements.FieldElement)({ name: "Silent", id: 0, conformance: "M", description: "Silent Mode" }),
+        (0, import_elements.FieldElement)({ name: "Low", id: 1, conformance: "M", description: "Low Volume" }),
+        (0, import_elements.FieldElement)({ name: "High", id: 2, conformance: "M", description: "High Volume" }),
+        (0, import_elements.FieldElement)({ name: "Medium", id: 3, conformance: "M", description: "Medium Volume" })
+      ]
+    }),
+    (0, import_elements.DatatypeElement)({
+      name: "EventTypeEnum",
+      type: "enum8",
+      xref: { document: "cluster", section: "5.2.6.24" },
+      children: [
+        (0, import_elements.FieldElement)({ name: "Operation", id: 0, conformance: "M", description: "Event type is operation" }),
+        (0, import_elements.FieldElement)({ name: "Programming", id: 1, conformance: "M", description: "Event type is programming" }),
+        (0, import_elements.FieldElement)({ name: "Alarm", id: 2, conformance: "M", description: "Event type is alarm" })
+      ]
+    }),
+    (0, import_elements.DatatypeElement)({
+      name: "EventSourceEnum",
+      type: "enum8",
+      xref: { document: "cluster", section: "5.2.6.25" },
+      children: [
+        (0, import_elements.FieldElement)({ name: "Keypad", id: 0, conformance: "M", description: "Event source is keypad" }),
+        (0, import_elements.FieldElement)({ name: "Remote", id: 1, conformance: "M", description: "Event source is remote" }),
+        (0, import_elements.FieldElement)({ name: "Manual", id: 2, conformance: "M", description: "Event source is manual" }),
+        (0, import_elements.FieldElement)({ name: "Rfid", id: 3, conformance: "M", description: "Event source is RFID" }),
+        (0, import_elements.FieldElement)({ name: "Indeterminate", id: 255, conformance: "M", description: "Event source is unknown" })
+      ]
+    }),
+    (0, import_elements.DatatypeElement)({
+      name: "OperationEventCodeEnum",
+      type: "enum8",
+      xref: { document: "cluster", section: "5.2.6.25.1" },
+      children: [
+        (0, import_elements.FieldElement)({ name: "UnknownOrMfgSpecific", id: 0, conformance: "O", description: "Event code is unknown" }),
+        (0, import_elements.FieldElement)({ name: "Lock", id: 1, conformance: "O", description: "Event code is lock" }),
+        (0, import_elements.FieldElement)({ name: "Unlock", id: 2, conformance: "O", description: "Event code is unlock" }),
+        (0, import_elements.FieldElement)({
+          name: "LockFailureInvalidPiNorRfid",
+          id: 3,
+          conformance: "O",
+          description: "Event code is lock failure due to invalid PIN or RFID"
+        }),
+        (0, import_elements.FieldElement)({
+          name: "LockFailureInvalidSchedule",
+          id: 4,
+          conformance: "O",
+          description: "Event code is lock failure due to invalid schedule"
+        }),
+        (0, import_elements.FieldElement)({
+          name: "UnlockFailureInvalidPiNorRfid",
+          id: 5,
+          conformance: "O",
+          description: "Event code is unlock failure due to invalid PIN or RFID"
+        }),
+        (0, import_elements.FieldElement)({
+          name: "UnlockFailureInvalidSchedule",
+          id: 6,
+          conformance: "O",
+          description: "Event code is unlock failure due to invalid schedule"
+        }),
+        (0, import_elements.FieldElement)({ name: "OneTouchLock", id: 7, conformance: "O", description: "Event code is one touch lock" }),
+        (0, import_elements.FieldElement)({ name: "KeyLock", id: 8, conformance: "O", description: "Event code is key lock" }),
+        (0, import_elements.FieldElement)({ name: "KeyUnlock", id: 9, conformance: "O", description: "Event code is key unlock" }),
+        (0, import_elements.FieldElement)({ name: "AutoLock", id: 10, conformance: "O", description: "Event code is auto lock" }),
+        (0, import_elements.FieldElement)({
+          name: "ScheduleLock",
+          id: 11,
+          conformance: "WDSCH | YDSCH",
+          description: "Event code is schedule lock"
+        }),
+        (0, import_elements.FieldElement)({
+          name: "ScheduleUnlock",
+          id: 12,
+          conformance: "WDSCH | YDSCH",
+          description: "Event code is schedule unlock"
+        }),
+        (0, import_elements.FieldElement)({
+          name: "ManualLock",
+          id: 13,
+          conformance: "O",
+          description: "Event code is manual lock (Key or Thumbturn)"
+        }),
+        (0, import_elements.FieldElement)({
+          name: "ManualUnlock",
+          id: 14,
+          conformance: "O",
+          description: "Event code is manual unlock (Key or Thumbturn)"
+        }),
+        (0, import_elements.FieldElement)({
+          name: "NonAccessUserOperationEvent",
+          id: 15,
+          conformance: "O",
+          description: "Event code is non access user operation"
+        })
+      ]
+    }),
+    (0, import_elements.DatatypeElement)({
+      name: "ProgrammingEventCodeEnum",
+      type: "enum8",
+      xref: { document: "cluster", section: "5.2.6.25.2" },
+      children: [
+        (0, import_elements.FieldElement)({ name: "UnknownOrMfgSpecific", id: 0, conformance: "O", description: "Event code is unknown" }),
+        (0, import_elements.FieldElement)({
+          name: "ProgrammingCodeChanged",
+          id: 1,
+          conformance: "O",
+          description: "Event code is code changed"
+        }),
+        (0, import_elements.FieldElement)({ name: "PinCodeAdded", id: 2, conformance: "O", description: "Event code is PIN added" }),
+        (0, import_elements.FieldElement)({ name: "PinCodeCleared", id: 3, conformance: "O", description: "Event code is PIN cleared" }),
+        (0, import_elements.FieldElement)({ name: "PinCodeChanged", id: 4, conformance: "O", description: "Event code is PIN changed" }),
+        (0, import_elements.FieldElement)({ name: "RfidCodeAdded", id: 5, conformance: "O", description: "Event code is RFID added" }),
+        (0, import_elements.FieldElement)({ name: "RfidCodeCleared", id: 6, conformance: "O", description: "Event code is RFID cleared" })
+      ]
+    }),
+    (0, import_elements.DatatypeElement)({
+      name: "CredentialStruct",
+      type: "struct",
+      details: "This struct shall indicate the credential types and their corresponding indices (if any) for the event or user record.",
+      xref: { document: "cluster", section: "5.2.6.26" },
+      children: [
+        (0, import_elements.FieldElement)({
+          name: "CredentialType",
+          id: 0,
+          type: "CredentialTypeEnum",
+          conformance: "M",
+          details: "This field shall indicate the credential field used to authorize the lock operation.",
+          xref: { document: "cluster", section: "5.2.6.26.1" }
+        }),
+        (0, import_elements.FieldElement)({
+          name: "CredentialIndex",
+          id: 1,
+          type: "uint16",
+          conformance: "M",
+          default: 0,
+          details: "This field shall indicate the index of the specific credential used to authorize the lock operation in the list of credentials identified by CredentialType (e.g. PIN, RFID, etc.). This field shall be set to 0 if CredentialType is ProgrammingPIN or does not correspond to a list that can be indexed into.",
+          xref: { document: "cluster", section: "5.2.6.26.2" }
+        })
+      ]
+    }),
+    (0, import_elements.DatatypeElement)({
+      name: "StatusCodeEnum",
+      type: "enum8",
+      xref: { document: "cluster", section: "5.2.7.1" },
+      children: [
+        (0, import_elements.FieldElement)({ name: "Duplicate", id: 2, description: "Entry would cause a duplicate credential/ID." }),
+        (0, import_elements.FieldElement)({ name: "Occupied", id: 3, description: "Entry would replace an occupied slot." })
+      ]
+    })
+  ]
+});
+import_MatterDefinition.MatterDefinition.children.push(DoorLock);
+//# sourceMappingURL=DoorLock.js.map