matc 0.1.3

//! Matter TLV encoders and decoders for Door Lock Cluster
//! Cluster ID: 0x0101
//!
//! This file is automatically generated from DoorLock.xml

#![allow(clippy::too_many_arguments)]

use crate::tlv;
use anyhow;
use serde_json;


// Import serialization helpers for octet strings
use crate::clusters::helpers::{serialize_opt_bytes_as_hex};

// Enum definitions

#[derive(Debug, Clone, Copy, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
#[repr(u8)]
pub enum AlarmCode {
    /// Locking Mechanism Jammed
    Lockjammed = 0,
    /// Lock Reset to Factory Defaults
    Lockfactoryreset = 1,
    /// Lock Radio Power Cycled
    Lockradiopowercycled = 3,
    /// Tamper Alarm - wrong code entry limit
    Wrongcodeentrylimit = 4,
    /// Tamper Alarm - front escutcheon removed from main
    Frontesceutcheonremoved = 5,
    /// Forced Door Open under Door Locked Condition
    Doorforcedopen = 6,
    /// Door ajar
    Doorajar = 7,
    /// Force User SOS alarm
    Forceduser = 8,
}

impl AlarmCode {
    /// Convert from u8 value
    pub fn from_u8(value: u8) -> Option<Self> {
        match value {
            0 => Some(AlarmCode::Lockjammed),
            1 => Some(AlarmCode::Lockfactoryreset),
            3 => Some(AlarmCode::Lockradiopowercycled),
            4 => Some(AlarmCode::Wrongcodeentrylimit),
            5 => Some(AlarmCode::Frontesceutcheonremoved),
            6 => Some(AlarmCode::Doorforcedopen),
            7 => Some(AlarmCode::Doorajar),
            8 => Some(AlarmCode::Forceduser),
            _ => None,
        }
    }

    /// Convert to u8 value
    pub fn to_u8(self) -> u8 {
        self as u8
    }
}

impl From<AlarmCode> for u8 {
    fn from(val: AlarmCode) -> Self {
        val as u8
    }
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
#[repr(u8)]
pub enum CredentialRule {
    /// Only one credential is required for lock operation
    Single = 0,
    /// Any two credentials are required for lock operation
    Dual = 1,
    /// Any three credentials are required for lock operation
    Tri = 2,
}

impl CredentialRule {
    /// Convert from u8 value
    pub fn from_u8(value: u8) -> Option<Self> {
        match value {
            0 => Some(CredentialRule::Single),
            1 => Some(CredentialRule::Dual),
            2 => Some(CredentialRule::Tri),
            _ => None,
        }
    }

    /// Convert to u8 value
    pub fn to_u8(self) -> u8 {
        self as u8
    }
}

impl From<CredentialRule> for u8 {
    fn from(val: CredentialRule) -> Self {
        val as u8
    }
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
#[repr(u8)]
pub enum CredentialType {
    /// Programming PIN code credential type
    Programmingpin = 0,
    /// PIN code credential type
    Pin = 1,
    /// RFID identifier credential type
    Rfid = 2,
    /// Fingerprint identifier credential type
    Fingerprint = 3,
    /// Finger vein identifier credential type
    Fingervein = 4,
    /// Face identifier credential type
    Face = 5,
    /// A Credential Issuer public key as defined in Aliro
    Alirocredentialissuerkey = 6,
    /// An Endpoint public key as defined in Aliro which can be evicted if space is needed for another endpoint key
    Aliroevictableendpointkey = 7,
    /// An Endpoint public key as defined in Aliro which cannot be evicted if space is needed for another endpoint key
    Alirononevictableendpointkey = 8,
}

impl CredentialType {
    /// Convert from u8 value
    pub fn from_u8(value: u8) -> Option<Self> {
        match value {
            0 => Some(CredentialType::Programmingpin),
            1 => Some(CredentialType::Pin),
            2 => Some(CredentialType::Rfid),
            3 => Some(CredentialType::Fingerprint),
            4 => Some(CredentialType::Fingervein),
            5 => Some(CredentialType::Face),
            6 => Some(CredentialType::Alirocredentialissuerkey),
            7 => Some(CredentialType::Aliroevictableendpointkey),
            8 => Some(CredentialType::Alirononevictableendpointkey),
            _ => None,
        }
    }

    /// Convert to u8 value
    pub fn to_u8(self) -> u8 {
        self as u8
    }
}

impl From<CredentialType> for u8 {
    fn from(val: CredentialType) -> Self {
        val as u8
    }
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
#[repr(u8)]
pub enum DataOperationType {
    /// Data is being added or was added
    Add = 0,
    /// Data is being cleared or was cleared
    Clear = 1,
    /// Data is being modified or was modified
    Modify = 2,
}

impl DataOperationType {
    /// Convert from u8 value
    pub fn from_u8(value: u8) -> Option<Self> {
        match value {
            0 => Some(DataOperationType::Add),
            1 => Some(DataOperationType::Clear),
            2 => Some(DataOperationType::Modify),
            _ => None,
        }
    }

    /// Convert to u8 value
    pub fn to_u8(self) -> u8 {
        self as u8
    }
}

impl From<DataOperationType> for u8 {
    fn from(val: DataOperationType) -> Self {
        val as u8
    }
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
#[repr(u8)]
pub enum DoorState {
    /// Door state is open
    Dooropen = 0,
    /// Door state is closed
    Doorclosed = 1,
    /// Door state is jammed
    Doorjammed = 2,
    /// Door state is currently forced open
    Doorforcedopen = 3,
    /// Door state is invalid for unspecified reason
    Doorunspecifiederror = 4,
    /// Door state is ajar
    Doorajar = 5,
}

impl DoorState {
    /// Convert from u8 value
    pub fn from_u8(value: u8) -> Option<Self> {
        match value {
            0 => Some(DoorState::Dooropen),
            1 => Some(DoorState::Doorclosed),
            2 => Some(DoorState::Doorjammed),
            3 => Some(DoorState::Doorforcedopen),
            4 => Some(DoorState::Doorunspecifiederror),
            5 => Some(DoorState::Doorajar),
            _ => None,
        }
    }

    /// Convert to u8 value
    pub fn to_u8(self) -> u8 {
        self as u8
    }
}

impl From<DoorState> for u8 {
    fn from(val: DoorState) -> Self {
        val as u8
    }
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
#[repr(u8)]
pub enum EventType {
    /// Event type is operation
    Operation = 0,
    /// Event type is programming
    Programming = 1,
    /// Event type is alarm
    Alarm = 2,
}

impl EventType {
    /// Convert from u8 value
    pub fn from_u8(value: u8) -> Option<Self> {
        match value {
            0 => Some(EventType::Operation),
            1 => Some(EventType::Programming),
            2 => Some(EventType::Alarm),
            _ => None,
        }
    }

    /// Convert to u8 value
    pub fn to_u8(self) -> u8 {
        self as u8
    }
}

impl From<EventType> for u8 {
    fn from(val: EventType) -> Self {
        val as u8
    }
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
#[repr(u8)]
pub enum LEDSetting {
    /// Never use LED for signalization
    Noledsignal = 0,
    /// Use LED signalization except for access allowed events
    Noledsignalaccessallowed = 1,
    /// Use LED signalization for all events
    Ledsignalall = 2,
}

impl LEDSetting {
    /// Convert from u8 value
    pub fn from_u8(value: u8) -> Option<Self> {
        match value {
            0 => Some(LEDSetting::Noledsignal),
            1 => Some(LEDSetting::Noledsignalaccessallowed),
            2 => Some(LEDSetting::Ledsignalall),
            _ => None,
        }
    }

    /// Convert to u8 value
    pub fn to_u8(self) -> u8 {
        self as u8
    }
}

impl From<LEDSetting> for u8 {
    fn from(val: LEDSetting) -> Self {
        val as u8
    }
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
#[repr(u8)]
pub enum LockDataType {
    /// Unspecified or manufacturer specific lock user data added, cleared, or modified.
    Unspecified = 0,
    /// Lock programming PIN code was added, cleared, or modified.
    Programmingcode = 1,
    /// Lock user index was added, cleared, or modified.
    Userindex = 2,
    /// Lock user week day schedule was added, cleared, or modified.
    Weekdayschedule = 3,
    /// Lock user year day schedule was added, cleared, or modified.
    Yeardayschedule = 4,
    /// Lock holiday schedule was added, cleared, or modified.
    Holidayschedule = 5,
    /// Lock user PIN code was added, cleared, or modified.
    Pin = 6,
    /// Lock user RFID code was added, cleared, or modified.
    Rfid = 7,
    /// Lock user fingerprint was added, cleared, or modified.
    Fingerprint = 8,
    /// Lock user finger-vein information was added, cleared, or modified.
    Fingervein = 9,
    /// Lock user face information was added, cleared, or modified.
    Face = 10,
    /// An Aliro credential issuer key credential was added, cleared, or modified.
    Alirocredentialissuerkey = 11,
    /// An Aliro endpoint key credential which can be evicted credential was added, cleared, or modified.
    Aliroevictableendpointkey = 12,
    /// An Aliro endpoint key credential which cannot be evicted was added, cleared, or modified.
    Alirononevictableendpointkey = 13,
}

impl LockDataType {
    /// Convert from u8 value
    pub fn from_u8(value: u8) -> Option<Self> {
        match value {
            0 => Some(LockDataType::Unspecified),
            1 => Some(LockDataType::Programmingcode),
            2 => Some(LockDataType::Userindex),
            3 => Some(LockDataType::Weekdayschedule),
            4 => Some(LockDataType::Yeardayschedule),
            5 => Some(LockDataType::Holidayschedule),
            6 => Some(LockDataType::Pin),
            7 => Some(LockDataType::Rfid),
            8 => Some(LockDataType::Fingerprint),
            9 => Some(LockDataType::Fingervein),
            10 => Some(LockDataType::Face),
            11 => Some(LockDataType::Alirocredentialissuerkey),
            12 => Some(LockDataType::Aliroevictableendpointkey),
            13 => Some(LockDataType::Alirononevictableendpointkey),
            _ => None,
        }
    }

    /// Convert to u8 value
    pub fn to_u8(self) -> u8 {
        self as u8
    }
}

impl From<LockDataType> for u8 {
    fn from(val: LockDataType) -> Self {
        val as u8
    }
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
#[repr(u8)]
pub enum LockOperationType {
    /// Lock operation
    Lock = 0,
    /// Unlock operation
    Unlock = 1,
    /// Triggered by keypad entry for user with User Type set to Non Access User
    Nonaccessuserevent = 2,
    /// Triggered by using a user with UserType set to Forced User
    Forceduserevent = 3,
    /// Unlatch operation
    Unlatch = 4,
}

impl LockOperationType {
    /// Convert from u8 value
    pub fn from_u8(value: u8) -> Option<Self> {
        match value {
            0 => Some(LockOperationType::Lock),
            1 => Some(LockOperationType::Unlock),
            2 => Some(LockOperationType::Nonaccessuserevent),
            3 => Some(LockOperationType::Forceduserevent),
            4 => Some(LockOperationType::Unlatch),
            _ => None,
        }
    }

    /// Convert to u8 value
    pub fn to_u8(self) -> u8 {
        self as u8
    }
}

impl From<LockOperationType> for u8 {
    fn from(val: LockOperationType) -> Self {
        val as u8
    }
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
#[repr(u8)]
pub enum LockState {
    /// Lock state is not fully locked
    Notfullylocked = 0,
    /// Lock state is fully locked
    Locked = 1,
    /// Lock state is fully unlocked
    Unlocked = 2,
    /// Lock state is fully unlocked and the latch is pulled
    Unlatched = 3,
}

impl LockState {
    /// Convert from u8 value
    pub fn from_u8(value: u8) -> Option<Self> {
        match value {
            0 => Some(LockState::Notfullylocked),
            1 => Some(LockState::Locked),
            2 => Some(LockState::Unlocked),
            3 => Some(LockState::Unlatched),
            _ => None,
        }
    }

    /// Convert to u8 value
    pub fn to_u8(self) -> u8 {
        self as u8
    }
}

impl From<LockState> for u8 {
    fn from(val: LockState) -> Self {
        val as u8
    }
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
#[repr(u8)]
pub enum LockType {
    /// Physical lock type is dead bolt
    Deadbolt = 0,
    /// Physical lock type is magnetic
    Magnetic = 1,
    /// Physical lock type is other
    Other = 2,
    /// Physical lock type is mortise
    Mortise = 3,
    /// Physical lock type is rim
    Rim = 4,
    /// Physical lock type is latch bolt
    Latchbolt = 5,
    /// Physical lock type is cylindrical lock
    Cylindricallock = 6,
    /// Physical lock type is tubular lock
    Tubularlock = 7,
    /// Physical lock type is interconnected lock
    Interconnectedlock = 8,
    /// Physical lock type is dead latch
    Deadlatch = 9,
    /// Physical lock type is door furniture
    Doorfurniture = 10,
    /// Physical lock type is euro cylinder
    Eurocylinder = 11,
}

impl LockType {
    /// Convert from u8 value
    pub fn from_u8(value: u8) -> Option<Self> {
        match value {
            0 => Some(LockType::Deadbolt),
            1 => Some(LockType::Magnetic),
            2 => Some(LockType::Other),
            3 => Some(LockType::Mortise),
            4 => Some(LockType::Rim),
            5 => Some(LockType::Latchbolt),
            6 => Some(LockType::Cylindricallock),
            7 => Some(LockType::Tubularlock),
            8 => Some(LockType::Interconnectedlock),
            9 => Some(LockType::Deadlatch),
            10 => Some(LockType::Doorfurniture),
            11 => Some(LockType::Eurocylinder),
            _ => None,
        }
    }

    /// Convert to u8 value
    pub fn to_u8(self) -> u8 {
        self as u8
    }
}

impl From<LockType> for u8 {
    fn from(val: LockType) -> Self {
        val as u8
    }
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
#[repr(u8)]
pub enum OperatingMode {
    Normal = 0,
    Vacation = 1,
    Privacy = 2,
    Noremotelockunlock = 3,
    Passage = 4,
}

impl OperatingMode {
    /// Convert from u8 value
    pub fn from_u8(value: u8) -> Option<Self> {
        match value {
            0 => Some(OperatingMode::Normal),
            1 => Some(OperatingMode::Vacation),
            2 => Some(OperatingMode::Privacy),
            3 => Some(OperatingMode::Noremotelockunlock),
            4 => Some(OperatingMode::Passage),
            _ => None,
        }
    }

    /// Convert to u8 value
    pub fn to_u8(self) -> u8 {
        self as u8
    }
}

impl From<OperatingMode> for u8 {
    fn from(val: OperatingMode) -> Self {
        val as u8
    }
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
#[repr(u8)]
pub enum OperationError {
    /// Lock/unlock error caused by unknown or unspecified source
    Unspecified = 0,
    /// Lock/unlock error caused by invalid PIN, RFID, fingerprint or other credential
    Invalidcredential = 1,
    /// Lock/unlock error caused by disabled USER or credential
    Disableduserdenied = 2,
    /// Lock/unlock error caused by schedule restriction
    Restricted = 3,
    /// Lock/unlock error caused by insufficient battery power left to safely actuate the lock
    Insufficientbattery = 4,
}

impl OperationError {
    /// Convert from u8 value
    pub fn from_u8(value: u8) -> Option<Self> {
        match value {
            0 => Some(OperationError::Unspecified),
            1 => Some(OperationError::Invalidcredential),
            2 => Some(OperationError::Disableduserdenied),
            3 => Some(OperationError::Restricted),
            4 => Some(OperationError::Insufficientbattery),
            _ => None,
        }
    }

    /// Convert to u8 value
    pub fn to_u8(self) -> u8 {
        self as u8
    }
}

impl From<OperationError> for u8 {
    fn from(val: OperationError) -> Self {
        val as u8
    }
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
#[repr(u8)]
pub enum OperationSource {
    /// Lock/unlock operation came from unspecified source
    Unspecified = 0,
    /// Lock/unlock operation came from manual operation (key, thumbturn, handle, etc).
    Manual = 1,
    /// Lock/unlock operation came from proprietary remote source (e.g. vendor app/cloud)
    Proprietaryremote = 2,
    /// Lock/unlock operation came from keypad
    Keypad = 3,
    /// Lock/unlock operation came from lock automatically (e.g. relock timer)
    Auto = 4,
    /// Lock/unlock operation came from lock button (e.g. one touch or button)
    Button = 5,
    /// Lock/unlock operation came from lock due to a schedule
    Schedule = 6,
    /// Lock/unlock operation came from remote node
    Remote = 7,
    /// Lock/unlock operation came from RFID card
    Rfid = 8,
    /// Lock/unlock operation came from biometric source (e.g. face, fingerprint/fingervein)
    Biometric = 9,
    /// Lock/unlock operation came from an interaction defined in Aliro, or user change operation was a step-up credential provisioning as defined in Aliro
    Aliro = 10,
}

impl OperationSource {
    /// Convert from u8 value
    pub fn from_u8(value: u8) -> Option<Self> {
        match value {
            0 => Some(OperationSource::Unspecified),
            1 => Some(OperationSource::Manual),
            2 => Some(OperationSource::Proprietaryremote),
            3 => Some(OperationSource::Keypad),
            4 => Some(OperationSource::Auto),
            5 => Some(OperationSource::Button),
            6 => Some(OperationSource::Schedule),
            7 => Some(OperationSource::Remote),
            8 => Some(OperationSource::Rfid),
            9 => Some(OperationSource::Biometric),
            10 => Some(OperationSource::Aliro),
            _ => None,
        }
    }

    /// Convert to u8 value
    pub fn to_u8(self) -> u8 {
        self as u8
    }
}

impl From<OperationSource> for u8 {
    fn from(val: OperationSource) -> Self {
        val as u8
    }
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
#[repr(u8)]
pub enum SoundVolume {
    /// Silent Mode
    Silent = 0,
    /// Low Volume
    Low = 1,
    /// High Volume
    High = 2,
    /// Medium Volume
    Medium = 3,
}

impl SoundVolume {
    /// Convert from u8 value
    pub fn from_u8(value: u8) -> Option<Self> {
        match value {
            0 => Some(SoundVolume::Silent),
            1 => Some(SoundVolume::Low),
            2 => Some(SoundVolume::High),
            3 => Some(SoundVolume::Medium),
            _ => None,
        }
    }

    /// Convert to u8 value
    pub fn to_u8(self) -> u8 {
        self as u8
    }
}

impl From<SoundVolume> for u8 {
    fn from(val: SoundVolume) -> Self {
        val as u8
    }
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
#[repr(u8)]
pub enum StatusCode {
    /// Entry would cause a duplicate credential/ID.
    Duplicate = 2,
    /// Entry would replace an occupied slot.
    Occupied = 3,
}

impl StatusCode {
    /// Convert from u8 value
    pub fn from_u8(value: u8) -> Option<Self> {
        match value {
            2 => Some(StatusCode::Duplicate),
            3 => Some(StatusCode::Occupied),
            _ => None,
        }
    }

    /// Convert to u8 value
    pub fn to_u8(self) -> u8 {
        self as u8
    }
}

impl From<StatusCode> for u8 {
    fn from(val: StatusCode) -> Self {
        val as u8
    }
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
#[repr(u8)]
pub enum UserStatus {
    /// The user ID is available
    Available = 0,
    /// The user ID is occupied and enabled
    Occupiedenabled = 1,
    /// The user ID is occupied and disabled
    Occupieddisabled = 3,
}

impl UserStatus {
    /// Convert from u8 value
    pub fn from_u8(value: u8) -> Option<Self> {
        match value {
            0 => Some(UserStatus::Available),
            1 => Some(UserStatus::Occupiedenabled),
            3 => Some(UserStatus::Occupieddisabled),
            _ => None,
        }
    }

    /// Convert to u8 value
    pub fn to_u8(self) -> u8 {
        self as u8
    }
}

impl From<UserStatus> for u8 {
    fn from(val: UserStatus) -> Self {
        val as u8
    }
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
#[repr(u8)]
pub enum UserType {
    /// The user ID type is unrestricted
    Unrestricteduser = 0,
    /// The user ID type is schedule
    Yeardayscheduleuser = 1,
    /// The user ID type is schedule
    Weekdayscheduleuser = 2,
    /// The user ID type is programming
    Programminguser = 3,
    /// The user ID type is non access
    Nonaccessuser = 4,
    /// The user ID type is forced
    Forceduser = 5,
    /// The user ID type is disposable
    Disposableuser = 6,
    /// The user ID type is expiring
    Expiringuser = 7,
    /// The user ID type is schedule restricted
    Schedulerestricteduser = 8,
    /// The user ID type is remote only
    Remoteonlyuser = 9,
}

impl UserType {
    /// Convert from u8 value
    pub fn from_u8(value: u8) -> Option<Self> {
        match value {
            0 => Some(UserType::Unrestricteduser),
            1 => Some(UserType::Yeardayscheduleuser),
            2 => Some(UserType::Weekdayscheduleuser),
            3 => Some(UserType::Programminguser),
            4 => Some(UserType::Nonaccessuser),
            5 => Some(UserType::Forceduser),
            6 => Some(UserType::Disposableuser),
            7 => Some(UserType::Expiringuser),
            8 => Some(UserType::Schedulerestricteduser),
            9 => Some(UserType::Remoteonlyuser),
            _ => None,
        }
    }

    /// Convert to u8 value
    pub fn to_u8(self) -> u8 {
        self as u8
    }
}

impl From<UserType> for u8 {
    fn from(val: UserType) -> Self {
        val as u8
    }
}

// Bitmap definitions

/// AlarmMask bitmap type
pub type AlarmMask = u8;

/// Constants for AlarmMask
pub mod alarmmask {
    /// Locking Mechanism Jammed
    pub const LOCK_JAMMED: u8 = 0x01;
    /// Lock Reset to Factory Defaults
    pub const LOCK_FACTORY_RESET: u8 = 0x02;
    /// RF Module Power Cycled
    pub const LOCK_RADIO_POWER_CYCLED: u8 = 0x08;
    /// Tamper Alarm - wrong code entry limit
    pub const WRONG_CODE_ENTRY_LIMIT: u8 = 0x10;
    /// Tamper Alarm - front escutcheon removed from main
    pub const FRONT_ESCUTCHEON_REMOVED: u8 = 0x20;
    /// Forced Door Open under Door Locked Condition
    pub const DOOR_FORCED_OPEN: u8 = 0x40;
}

/// ConfigurationRegister bitmap type
pub type ConfigurationRegister = u8;

/// Constants for ConfigurationRegister
pub mod configurationregister {
    /// The state of local programming functionality
    pub const LOCAL_PROGRAMMING: u8 = 0x01;
    /// The state of the keypad interface
    pub const KEYPAD_INTERFACE: u8 = 0x02;
    /// The state of the remote interface
    pub const REMOTE_INTERFACE: u8 = 0x04;
    /// Sound volume is set to Silent value
    pub const SOUND_VOLUME: u8 = 0x20;
    /// Auto relock time it set to 0
    pub const AUTO_RELOCK_TIME: u8 = 0x40;
    /// LEDs is disabled
    pub const LEDSETTINGS: u8 = 0x80;
}

/// CredentialRules bitmap type
pub type CredentialRules = u8;

/// Constants for CredentialRules
pub mod credentialrules {
    /// Only one credential is required for lock operation
    pub const SINGLE: u8 = 0x01;
    /// Any two credentials are required for lock operation
    pub const DUAL: u8 = 0x02;
    /// Any three credentials are required for lock operation
    pub const TRI: u8 = 0x04;
}

/// DaysMask bitmap type
pub type DaysMask = u8;

/// Constants for DaysMask
pub mod daysmask {
    /// Schedule is applied on Sunday
    pub const SUNDAY: u8 = 0x01;
    /// Schedule is applied on Monday
    pub const MONDAY: u8 = 0x02;
    /// Schedule is applied on Tuesday
    pub const TUESDAY: u8 = 0x04;
    /// Schedule is applied on Wednesday
    pub const WEDNESDAY: u8 = 0x08;
    /// Schedule is applied on Thursday
    pub const THURSDAY: u8 = 0x10;
    /// Schedule is applied on Friday
    pub const FRIDAY: u8 = 0x20;
    /// Schedule is applied on Saturday
    pub const SATURDAY: u8 = 0x40;
}

/// LocalProgrammingFeatures bitmap type
pub type LocalProgrammingFeatures = u8;

/// Constants for LocalProgrammingFeatures
pub mod localprogrammingfeatures {
    /// The state of the ability to add users, credentials or schedules on the device
    pub const ADD_USERS_CREDENTIALS_SCHEDULES: u8 = 0x01;
    /// The state of the ability to modify users, credentials or schedules on the device
    pub const MODIFY_USERS_CREDENTIALS_SCHEDULES: u8 = 0x02;
    /// The state of the ability to clear users, credentials or schedules on the device
    pub const CLEAR_USERS_CREDENTIALS_SCHEDULES: u8 = 0x04;
    /// The state of the ability to adjust settings on the device
    pub const ADJUST_SETTINGS: u8 = 0x08;
}

/// OperatingModes bitmap type
pub type OperatingModes = u8;

/// Constants for OperatingModes
pub mod operatingmodes {
    /// Normal operation mode
    pub const NORMAL: u8 = 0x01;
    /// Vacation operation mode
    pub const VACATION: u8 = 0x02;
    /// Privacy operation mode
    pub const PRIVACY: u8 = 0x04;
    /// No remote lock and unlock operation mode
    pub const NO_REMOTE_LOCK_UNLOCK: u8 = 0x08;
    /// Passage operation mode
    pub const PASSAGE: u8 = 0x10;
}

// Struct definitions

#[derive(Debug, serde::Serialize)]
pub struct Credential {
    pub credential_type: Option<CredentialType>,
    pub credential_index: Option<u16>,
}

// Command encoders

/// Encode LockDoor command (0x00)
pub fn encode_lock_door(pin_code: Option<Vec<u8>>) -> anyhow::Result<Vec<u8>> {
    let mut tlv_fields: Vec<tlv::TlvItemEnc> = Vec::new();
    if let Some(x) = pin_code { tlv_fields.push((0, tlv::TlvItemValueEnc::OctetString(x)).into()); }
    let tlv = tlv::TlvItemEnc {
        tag: 0,
        value: tlv::TlvItemValueEnc::StructInvisible(tlv_fields),
    };
    Ok(tlv.encode()?)
}

/// Encode UnlockDoor command (0x01)
pub fn encode_unlock_door(pin_code: Option<Vec<u8>>) -> anyhow::Result<Vec<u8>> {
    let mut tlv_fields: Vec<tlv::TlvItemEnc> = Vec::new();
    if let Some(x) = pin_code { tlv_fields.push((0, tlv::TlvItemValueEnc::OctetString(x)).into()); }
    let tlv = tlv::TlvItemEnc {
        tag: 0,
        value: tlv::TlvItemValueEnc::StructInvisible(tlv_fields),
    };
    Ok(tlv.encode()?)
}

/// Encode UnlockWithTimeout command (0x03)
pub fn encode_unlock_with_timeout(timeout: u16, pin_code: Option<Vec<u8>>) -> anyhow::Result<Vec<u8>> {
    let mut tlv_fields: Vec<tlv::TlvItemEnc> = Vec::new();
    tlv_fields.push((0, tlv::TlvItemValueEnc::UInt16(timeout)).into());
    if let Some(x) = pin_code { tlv_fields.push((1, tlv::TlvItemValueEnc::OctetString(x)).into()); }
    let tlv = tlv::TlvItemEnc {
        tag: 0,
        value: tlv::TlvItemValueEnc::StructInvisible(tlv_fields),
    };
    Ok(tlv.encode()?)
}

/// Encode SetWeekDaySchedule command (0x0B)
pub fn encode_set_week_day_schedule(week_day_index: u8, user_index: u16, days_mask: DaysMask, start_hour: u8, start_minute: u8, end_hour: u8, end_minute: u8) -> anyhow::Result<Vec<u8>> {
    let tlv = tlv::TlvItemEnc {
        tag: 0,
        value: tlv::TlvItemValueEnc::StructInvisible(vec![
        (0, tlv::TlvItemValueEnc::UInt8(week_day_index)).into(),
        (1, tlv::TlvItemValueEnc::UInt16(user_index)).into(),
        (2, tlv::TlvItemValueEnc::UInt8(days_mask)).into(),
        (3, tlv::TlvItemValueEnc::UInt8(start_hour)).into(),
        (4, tlv::TlvItemValueEnc::UInt8(start_minute)).into(),
        (5, tlv::TlvItemValueEnc::UInt8(end_hour)).into(),
        (6, tlv::TlvItemValueEnc::UInt8(end_minute)).into(),
        ]),
    };
    Ok(tlv.encode()?)
}

/// Encode GetWeekDaySchedule command (0x0C)
pub fn encode_get_week_day_schedule(week_day_index: u8, user_index: u16) -> anyhow::Result<Vec<u8>> {
    let tlv = tlv::TlvItemEnc {
        tag: 0,
        value: tlv::TlvItemValueEnc::StructInvisible(vec![
        (0, tlv::TlvItemValueEnc::UInt8(week_day_index)).into(),
        (1, tlv::TlvItemValueEnc::UInt16(user_index)).into(),
        ]),
    };
    Ok(tlv.encode()?)
}

/// Encode ClearWeekDaySchedule command (0x0D)
pub fn encode_clear_week_day_schedule(week_day_index: u8, user_index: u16) -> anyhow::Result<Vec<u8>> {
    let tlv = tlv::TlvItemEnc {
        tag: 0,
        value: tlv::TlvItemValueEnc::StructInvisible(vec![
        (0, tlv::TlvItemValueEnc::UInt8(week_day_index)).into(),
        (1, tlv::TlvItemValueEnc::UInt16(user_index)).into(),
        ]),
    };
    Ok(tlv.encode()?)
}

/// Encode SetYearDaySchedule command (0x0E)
pub fn encode_set_year_day_schedule(year_day_index: u8, user_index: u16, local_start_time: u64, local_end_time: u64) -> anyhow::Result<Vec<u8>> {
    let tlv = tlv::TlvItemEnc {
        tag: 0,
        value: tlv::TlvItemValueEnc::StructInvisible(vec![
        (0, tlv::TlvItemValueEnc::UInt8(year_day_index)).into(),
        (1, tlv::TlvItemValueEnc::UInt16(user_index)).into(),
        (2, tlv::TlvItemValueEnc::UInt64(local_start_time)).into(),
        (3, tlv::TlvItemValueEnc::UInt64(local_end_time)).into(),
        ]),
    };
    Ok(tlv.encode()?)
}

/// Encode GetYearDaySchedule command (0x0F)
pub fn encode_get_year_day_schedule(year_day_index: u8, user_index: u16) -> anyhow::Result<Vec<u8>> {
    let tlv = tlv::TlvItemEnc {
        tag: 0,
        value: tlv::TlvItemValueEnc::StructInvisible(vec![
        (0, tlv::TlvItemValueEnc::UInt8(year_day_index)).into(),
        (1, tlv::TlvItemValueEnc::UInt16(user_index)).into(),
        ]),
    };
    Ok(tlv.encode()?)
}

/// Encode ClearYearDaySchedule command (0x10)
pub fn encode_clear_year_day_schedule(year_day_index: u8, user_index: u16) -> anyhow::Result<Vec<u8>> {
    let tlv = tlv::TlvItemEnc {
        tag: 0,
        value: tlv::TlvItemValueEnc::StructInvisible(vec![
        (0, tlv::TlvItemValueEnc::UInt8(year_day_index)).into(),
        (1, tlv::TlvItemValueEnc::UInt16(user_index)).into(),
        ]),
    };
    Ok(tlv.encode()?)
}

/// Encode SetHolidaySchedule command (0x11)
pub fn encode_set_holiday_schedule(holiday_index: u8, local_start_time: u64, local_end_time: u64, operating_mode: OperatingMode) -> anyhow::Result<Vec<u8>> {
    let tlv = tlv::TlvItemEnc {
        tag: 0,
        value: tlv::TlvItemValueEnc::StructInvisible(vec![
        (0, tlv::TlvItemValueEnc::UInt8(holiday_index)).into(),
        (1, tlv::TlvItemValueEnc::UInt64(local_start_time)).into(),
        (2, tlv::TlvItemValueEnc::UInt64(local_end_time)).into(),
        (3, tlv::TlvItemValueEnc::UInt8(operating_mode.to_u8())).into(),
        ]),
    };
    Ok(tlv.encode()?)
}

/// Encode GetHolidaySchedule command (0x12)
pub fn encode_get_holiday_schedule(holiday_index: u8) -> anyhow::Result<Vec<u8>> {
    let tlv = tlv::TlvItemEnc {
        tag: 0,
        value: tlv::TlvItemValueEnc::StructInvisible(vec![
        (0, tlv::TlvItemValueEnc::UInt8(holiday_index)).into(),
        ]),
    };
    Ok(tlv.encode()?)
}

/// Encode ClearHolidaySchedule command (0x13)
pub fn encode_clear_holiday_schedule(holiday_index: u8) -> anyhow::Result<Vec<u8>> {
    let tlv = tlv::TlvItemEnc {
        tag: 0,
        value: tlv::TlvItemValueEnc::StructInvisible(vec![
        (0, tlv::TlvItemValueEnc::UInt8(holiday_index)).into(),
        ]),
    };
    Ok(tlv.encode()?)
}

/// Encode SetUser command (0x1A)
pub fn encode_set_user(operation_type: DataOperationType, user_index: u16, user_name: Option<String>, user_unique_id: Option<u32>, user_status: Option<UserStatus>, user_type: Option<UserType>, credential_rule: Option<CredentialRule>) -> anyhow::Result<Vec<u8>> {
    let tlv = tlv::TlvItemEnc {
        tag: 0,
        value: tlv::TlvItemValueEnc::StructInvisible(vec![
        (0, tlv::TlvItemValueEnc::UInt8(operation_type.to_u8())).into(),
        (1, tlv::TlvItemValueEnc::UInt16(user_index)).into(),
        (2, tlv::TlvItemValueEnc::String(user_name.unwrap_or("".to_string()))).into(),
        (3, tlv::TlvItemValueEnc::UInt32(user_unique_id.unwrap_or(0))).into(),
        (4, tlv::TlvItemValueEnc::UInt8(user_status.map(|e| e.to_u8()).unwrap_or(0))).into(),
        (5, tlv::TlvItemValueEnc::UInt8(user_type.map(|e| e.to_u8()).unwrap_or(0))).into(),
        (6, tlv::TlvItemValueEnc::UInt8(credential_rule.map(|e| e.to_u8()).unwrap_or(0))).into(),
        ]),
    };
    Ok(tlv.encode()?)
}

/// Encode GetUser command (0x1B)
pub fn encode_get_user(user_index: u16) -> anyhow::Result<Vec<u8>> {
    let tlv = tlv::TlvItemEnc {
        tag: 0,
        value: tlv::TlvItemValueEnc::StructInvisible(vec![
        (0, tlv::TlvItemValueEnc::UInt16(user_index)).into(),
        ]),
    };
    Ok(tlv.encode()?)
}

/// Encode ClearUser command (0x1D)
pub fn encode_clear_user(user_index: u16) -> anyhow::Result<Vec<u8>> {
    let tlv = tlv::TlvItemEnc {
        tag: 0,
        value: tlv::TlvItemValueEnc::StructInvisible(vec![
        (0, tlv::TlvItemValueEnc::UInt16(user_index)).into(),
        ]),
    };
    Ok(tlv.encode()?)
}

/// Encode SetCredential command (0x22)
pub fn encode_set_credential(operation_type: DataOperationType, credential: Credential, credential_data: Vec<u8>, user_index: Option<u16>, user_status: Option<UserStatus>, user_type: Option<UserType>) -> anyhow::Result<Vec<u8>> {
            // Encode struct CredentialStruct
            let mut credential_fields = Vec::new();
            if let Some(x) = credential.credential_type { credential_fields.push((0, tlv::TlvItemValueEnc::UInt8(x.to_u8())).into()); }
            if let Some(x) = credential.credential_index { credential_fields.push((1, tlv::TlvItemValueEnc::UInt16(x)).into()); }
    let tlv = tlv::TlvItemEnc {
        tag: 0,
        value: tlv::TlvItemValueEnc::StructInvisible(vec![
        (0, tlv::TlvItemValueEnc::UInt8(operation_type.to_u8())).into(),
        (1, tlv::TlvItemValueEnc::StructInvisible(credential_fields)).into(),
        (2, tlv::TlvItemValueEnc::OctetString(credential_data)).into(),
        (3, tlv::TlvItemValueEnc::UInt16(user_index.unwrap_or(0))).into(),
        (4, tlv::TlvItemValueEnc::UInt8(user_status.map(|e| e.to_u8()).unwrap_or(0))).into(),
        (5, tlv::TlvItemValueEnc::UInt8(user_type.map(|e| e.to_u8()).unwrap_or(0))).into(),
        ]),
    };
    Ok(tlv.encode()?)
}

/// Encode GetCredentialStatus command (0x24)
pub fn encode_get_credential_status(credential: Credential) -> anyhow::Result<Vec<u8>> {
            // Encode struct CredentialStruct
            let mut credential_fields = Vec::new();
            if let Some(x) = credential.credential_type { credential_fields.push((0, tlv::TlvItemValueEnc::UInt8(x.to_u8())).into()); }
            if let Some(x) = credential.credential_index { credential_fields.push((1, tlv::TlvItemValueEnc::UInt16(x)).into()); }
    let tlv = tlv::TlvItemEnc {
        tag: 0,
        value: tlv::TlvItemValueEnc::StructInvisible(vec![
        (0, tlv::TlvItemValueEnc::StructInvisible(credential_fields)).into(),
        ]),
    };
    Ok(tlv.encode()?)
}

/// Encode ClearCredential command (0x26)
pub fn encode_clear_credential(credential: Option<Credential>) -> anyhow::Result<Vec<u8>> {
            // Encode optional struct CredentialStruct
            let credential_enc = if let Some(s) = credential {
                let mut fields = Vec::new();
                if let Some(x) = s.credential_type { fields.push((0, tlv::TlvItemValueEnc::UInt8(x.to_u8())).into()); }
                if let Some(x) = s.credential_index { fields.push((1, tlv::TlvItemValueEnc::UInt16(x)).into()); }
                tlv::TlvItemValueEnc::StructInvisible(fields)
            } else {
                tlv::TlvItemValueEnc::StructInvisible(Vec::new())
            };
    let tlv = tlv::TlvItemEnc {
        tag: 0,
        value: tlv::TlvItemValueEnc::StructInvisible(vec![
        (0, credential_enc).into(),
        ]),
    };
    Ok(tlv.encode()?)
}

/// Encode UnboltDoor command (0x27)
pub fn encode_unbolt_door(pin_code: Option<Vec<u8>>) -> anyhow::Result<Vec<u8>> {
    let mut tlv_fields: Vec<tlv::TlvItemEnc> = Vec::new();
    if let Some(x) = pin_code { tlv_fields.push((0, tlv::TlvItemValueEnc::OctetString(x)).into()); }
    let tlv = tlv::TlvItemEnc {
        tag: 0,
        value: tlv::TlvItemValueEnc::StructInvisible(tlv_fields),
    };
    Ok(tlv.encode()?)
}

/// Encode SetAliroReaderConfig command (0x28)
pub fn encode_set_aliro_reader_config(signing_key: Vec<u8>, verification_key: Vec<u8>, group_identifier: Vec<u8>, group_resolving_key: Vec<u8>) -> anyhow::Result<Vec<u8>> {
    let tlv = tlv::TlvItemEnc {
        tag: 0,
        value: tlv::TlvItemValueEnc::StructInvisible(vec![
        (0, tlv::TlvItemValueEnc::OctetString(signing_key)).into(),
        (1, tlv::TlvItemValueEnc::OctetString(verification_key)).into(),
        (2, tlv::TlvItemValueEnc::OctetString(group_identifier)).into(),
        (3, tlv::TlvItemValueEnc::OctetString(group_resolving_key)).into(),
        ]),
    };
    Ok(tlv.encode()?)
}

// Attribute decoders

/// Decode LockState attribute (0x0000)
pub fn decode_lock_state(inp: &tlv::TlvItemValue) -> anyhow::Result<Option<LockState>> {
    if let tlv::TlvItemValue::Int(v) = inp {
        Ok(LockState::from_u8(*v as u8))
    } else {
        Ok(None)
    }
}

/// Decode LockType attribute (0x0001)
pub fn decode_lock_type(inp: &tlv::TlvItemValue) -> anyhow::Result<LockType> {
    if let tlv::TlvItemValue::Int(v) = inp {
        LockType::from_u8(*v as u8).ok_or_else(|| anyhow::anyhow!("Invalid enum value"))
    } else {
        Err(anyhow::anyhow!("Expected Integer"))
    }
}

/// Decode ActuatorEnabled attribute (0x0002)
pub fn decode_actuator_enabled(inp: &tlv::TlvItemValue) -> anyhow::Result<bool> {
    if let tlv::TlvItemValue::Bool(v) = inp {
        Ok(*v)
    } else {
        Err(anyhow::anyhow!("Expected Bool"))
    }
}

/// Decode DoorState attribute (0x0003)
pub fn decode_door_state(inp: &tlv::TlvItemValue) -> anyhow::Result<Option<DoorState>> {
    if let tlv::TlvItemValue::Int(v) = inp {
        Ok(DoorState::from_u8(*v as u8))
    } else {
        Ok(None)
    }
}

/// Decode DoorOpenEvents attribute (0x0004)
pub fn decode_door_open_events(inp: &tlv::TlvItemValue) -> anyhow::Result<u32> {
    if let tlv::TlvItemValue::Int(v) = inp {
        Ok(*v as u32)
    } else {
        Err(anyhow::anyhow!("Expected UInt32"))
    }
}

/// Decode DoorClosedEvents attribute (0x0005)
pub fn decode_door_closed_events(inp: &tlv::TlvItemValue) -> anyhow::Result<u32> {
    if let tlv::TlvItemValue::Int(v) = inp {
        Ok(*v as u32)
    } else {
        Err(anyhow::anyhow!("Expected UInt32"))
    }
}

/// Decode OpenPeriod attribute (0x0006)
pub fn decode_open_period(inp: &tlv::TlvItemValue) -> anyhow::Result<u16> {
    if let tlv::TlvItemValue::Int(v) = inp {
        Ok(*v as u16)
    } else {
        Err(anyhow::anyhow!("Expected UInt16"))
    }
}

/// Decode NumberOfTotalUsersSupported attribute (0x0011)
pub fn decode_number_of_total_users_supported(inp: &tlv::TlvItemValue) -> anyhow::Result<u16> {
    if let tlv::TlvItemValue::Int(v) = inp {
        Ok(*v as u16)
    } else {
        Err(anyhow::anyhow!("Expected UInt16"))
    }
}

/// Decode NumberOfPINUsersSupported attribute (0x0012)
pub fn decode_number_of_pin_users_supported(inp: &tlv::TlvItemValue) -> anyhow::Result<u16> {
    if let tlv::TlvItemValue::Int(v) = inp {
        Ok(*v as u16)
    } else {
        Err(anyhow::anyhow!("Expected UInt16"))
    }
}

/// Decode NumberOfRFIDUsersSupported attribute (0x0013)
pub fn decode_number_of_rfid_users_supported(inp: &tlv::TlvItemValue) -> anyhow::Result<u16> {
    if let tlv::TlvItemValue::Int(v) = inp {
        Ok(*v as u16)
    } else {
        Err(anyhow::anyhow!("Expected UInt16"))
    }
}

/// Decode NumberOfWeekDaySchedulesSupportedPerUser attribute (0x0014)
pub fn decode_number_of_week_day_schedules_supported_per_user(inp: &tlv::TlvItemValue) -> anyhow::Result<u8> {
    if let tlv::TlvItemValue::Int(v) = inp {
        Ok(*v as u8)
    } else {
        Err(anyhow::anyhow!("Expected UInt8"))
    }
}

/// Decode NumberOfYearDaySchedulesSupportedPerUser attribute (0x0015)
pub fn decode_number_of_year_day_schedules_supported_per_user(inp: &tlv::TlvItemValue) -> anyhow::Result<u8> {
    if let tlv::TlvItemValue::Int(v) = inp {
        Ok(*v as u8)
    } else {
        Err(anyhow::anyhow!("Expected UInt8"))
    }
}

/// Decode NumberOfHolidaySchedulesSupported attribute (0x0016)
pub fn decode_number_of_holiday_schedules_supported(inp: &tlv::TlvItemValue) -> anyhow::Result<u8> {
    if let tlv::TlvItemValue::Int(v) = inp {
        Ok(*v as u8)
    } else {
        Err(anyhow::anyhow!("Expected UInt8"))
    }
}

/// Decode MaxPINCodeLength attribute (0x0017)
pub fn decode_max_pin_code_length(inp: &tlv::TlvItemValue) -> anyhow::Result<u8> {
    if let tlv::TlvItemValue::Int(v) = inp {
        Ok(*v as u8)
    } else {
        Err(anyhow::anyhow!("Expected UInt8"))
    }
}

/// Decode MinPINCodeLength attribute (0x0018)
pub fn decode_min_pin_code_length(inp: &tlv::TlvItemValue) -> anyhow::Result<u8> {
    if let tlv::TlvItemValue::Int(v) = inp {
        Ok(*v as u8)
    } else {
        Err(anyhow::anyhow!("Expected UInt8"))
    }
}

/// Decode MaxRFIDCodeLength attribute (0x0019)
pub fn decode_max_rfid_code_length(inp: &tlv::TlvItemValue) -> anyhow::Result<u8> {
    if let tlv::TlvItemValue::Int(v) = inp {
        Ok(*v as u8)
    } else {
        Err(anyhow::anyhow!("Expected UInt8"))
    }
}

/// Decode MinRFIDCodeLength attribute (0x001A)
pub fn decode_min_rfid_code_length(inp: &tlv::TlvItemValue) -> anyhow::Result<u8> {
    if let tlv::TlvItemValue::Int(v) = inp {
        Ok(*v as u8)
    } else {
        Err(anyhow::anyhow!("Expected UInt8"))
    }
}

/// Decode CredentialRulesSupport attribute (0x001B)
pub fn decode_credential_rules_support(inp: &tlv::TlvItemValue) -> anyhow::Result<CredentialRules> {
    if let tlv::TlvItemValue::Int(v) = inp {
        Ok(*v as u8)
    } else {
        Err(anyhow::anyhow!("Expected Integer"))
    }
}

/// Decode NumberOfCredentialsSupportedPerUser attribute (0x001C)
pub fn decode_number_of_credentials_supported_per_user(inp: &tlv::TlvItemValue) -> anyhow::Result<u8> {
    if let tlv::TlvItemValue::Int(v) = inp {
        Ok(*v as u8)
    } else {
        Err(anyhow::anyhow!("Expected UInt8"))
    }
}

/// Decode Language attribute (0x0021)
pub fn decode_language(inp: &tlv::TlvItemValue) -> anyhow::Result<String> {
    if let tlv::TlvItemValue::String(v) = inp {
        Ok(v.clone())
    } else {
        Err(anyhow::anyhow!("Expected String"))
    }
}

/// Decode LEDSettings attribute (0x0022)
pub fn decode_led_settings(inp: &tlv::TlvItemValue) -> anyhow::Result<LEDSetting> {
    if let tlv::TlvItemValue::Int(v) = inp {
        LEDSetting::from_u8(*v as u8).ok_or_else(|| anyhow::anyhow!("Invalid enum value"))
    } else {
        Err(anyhow::anyhow!("Expected Integer"))
    }
}

/// Decode AutoRelockTime attribute (0x0023)
pub fn decode_auto_relock_time(inp: &tlv::TlvItemValue) -> anyhow::Result<u32> {
    if let tlv::TlvItemValue::Int(v) = inp {
        Ok(*v as u32)
    } else {
        Err(anyhow::anyhow!("Expected UInt32"))
    }
}

/// Decode SoundVolume attribute (0x0024)
pub fn decode_sound_volume(inp: &tlv::TlvItemValue) -> anyhow::Result<SoundVolume> {
    if let tlv::TlvItemValue::Int(v) = inp {
        SoundVolume::from_u8(*v as u8).ok_or_else(|| anyhow::anyhow!("Invalid enum value"))
    } else {
        Err(anyhow::anyhow!("Expected Integer"))
    }
}

/// Decode OperatingMode attribute (0x0025)
pub fn decode_operating_mode(inp: &tlv::TlvItemValue) -> anyhow::Result<OperatingMode> {
    if let tlv::TlvItemValue::Int(v) = inp {
        OperatingMode::from_u8(*v as u8).ok_or_else(|| anyhow::anyhow!("Invalid enum value"))
    } else {
        Err(anyhow::anyhow!("Expected Integer"))
    }
}

/// Decode SupportedOperatingModes attribute (0x0026)
pub fn decode_supported_operating_modes(inp: &tlv::TlvItemValue) -> anyhow::Result<OperatingModes> {
    if let tlv::TlvItemValue::Int(v) = inp {
        Ok(*v as u8)
    } else {
        Err(anyhow::anyhow!("Expected Integer"))
    }
}

/// Decode DefaultConfigurationRegister attribute (0x0027)
pub fn decode_default_configuration_register(inp: &tlv::TlvItemValue) -> anyhow::Result<ConfigurationRegister> {
    if let tlv::TlvItemValue::Int(v) = inp {
        Ok(*v as u8)
    } else {
        Err(anyhow::anyhow!("Expected Integer"))
    }
}

/// Decode EnableLocalProgramming attribute (0x0028)
pub fn decode_enable_local_programming(inp: &tlv::TlvItemValue) -> anyhow::Result<bool> {
    if let tlv::TlvItemValue::Bool(v) = inp {
        Ok(*v)
    } else {
        Err(anyhow::anyhow!("Expected Bool"))
    }
}

/// Decode EnableOneTouchLocking attribute (0x0029)
pub fn decode_enable_one_touch_locking(inp: &tlv::TlvItemValue) -> anyhow::Result<bool> {
    if let tlv::TlvItemValue::Bool(v) = inp {
        Ok(*v)
    } else {
        Err(anyhow::anyhow!("Expected Bool"))
    }
}

/// Decode EnableInsideStatusLED attribute (0x002A)
pub fn decode_enable_inside_status_led(inp: &tlv::TlvItemValue) -> anyhow::Result<bool> {
    if let tlv::TlvItemValue::Bool(v) = inp {
        Ok(*v)
    } else {
        Err(anyhow::anyhow!("Expected Bool"))
    }
}

/// Decode EnablePrivacyModeButton attribute (0x002B)
pub fn decode_enable_privacy_mode_button(inp: &tlv::TlvItemValue) -> anyhow::Result<bool> {
    if let tlv::TlvItemValue::Bool(v) = inp {
        Ok(*v)
    } else {
        Err(anyhow::anyhow!("Expected Bool"))
    }
}

/// Decode LocalProgrammingFeatures attribute (0x002C)
pub fn decode_local_programming_features(inp: &tlv::TlvItemValue) -> anyhow::Result<LocalProgrammingFeatures> {
    if let tlv::TlvItemValue::Int(v) = inp {
        Ok(*v as u8)
    } else {
        Err(anyhow::anyhow!("Expected Integer"))
    }
}

/// Decode WrongCodeEntryLimit attribute (0x0030)
pub fn decode_wrong_code_entry_limit(inp: &tlv::TlvItemValue) -> anyhow::Result<u8> {
    if let tlv::TlvItemValue::Int(v) = inp {
        Ok(*v as u8)
    } else {
        Err(anyhow::anyhow!("Expected UInt8"))
    }
}

/// Decode UserCodeTemporaryDisableTime attribute (0x0031)
pub fn decode_user_code_temporary_disable_time(inp: &tlv::TlvItemValue) -> anyhow::Result<u8> {
    if let tlv::TlvItemValue::Int(v) = inp {
        Ok(*v as u8)
    } else {
        Err(anyhow::anyhow!("Expected UInt8"))
    }
}

/// Decode SendPINOverTheAir attribute (0x0032)
pub fn decode_send_pin_over_the_air(inp: &tlv::TlvItemValue) -> anyhow::Result<bool> {
    if let tlv::TlvItemValue::Bool(v) = inp {
        Ok(*v)
    } else {
        Err(anyhow::anyhow!("Expected Bool"))
    }
}

/// Decode RequirePINforRemoteOperation attribute (0x0033)
pub fn decode_require_pinfor_remote_operation(inp: &tlv::TlvItemValue) -> anyhow::Result<bool> {
    if let tlv::TlvItemValue::Bool(v) = inp {
        Ok(*v)
    } else {
        Err(anyhow::anyhow!("Expected Bool"))
    }
}

/// Decode SecurityLevel attribute (0x0034)
pub fn decode_security_level(inp: &tlv::TlvItemValue) -> anyhow::Result<u8> {
    if let tlv::TlvItemValue::Int(v) = inp {
        Ok(*v as u8)
    } else {
        Err(anyhow::anyhow!("Expected UInt8"))
    }
}

/// Decode ExpiringUserTimeout attribute (0x0035)
pub fn decode_expiring_user_timeout(inp: &tlv::TlvItemValue) -> anyhow::Result<u16> {
    if let tlv::TlvItemValue::Int(v) = inp {
        Ok(*v as u16)
    } else {
        Err(anyhow::anyhow!("Expected UInt16"))
    }
}

/// Decode AliroReaderVerificationKey attribute (0x0080)
pub fn decode_aliro_reader_verification_key(inp: &tlv::TlvItemValue) -> anyhow::Result<Option<Vec<u8>>> {
    if let tlv::TlvItemValue::OctetString(v) = inp {
        Ok(Some(v.clone()))
    } else {
        Ok(None)
    }
}

/// Decode AliroReaderGroupIdentifier attribute (0x0081)
pub fn decode_aliro_reader_group_identifier(inp: &tlv::TlvItemValue) -> anyhow::Result<Option<Vec<u8>>> {
    if let tlv::TlvItemValue::OctetString(v) = inp {
        Ok(Some(v.clone()))
    } else {
        Ok(None)
    }
}

/// Decode AliroReaderGroupSubIdentifier attribute (0x0082)
pub fn decode_aliro_reader_group_sub_identifier(inp: &tlv::TlvItemValue) -> anyhow::Result<Vec<u8>> {
    if let tlv::TlvItemValue::OctetString(v) = inp {
        Ok(v.clone())
    } else {
        Err(anyhow::anyhow!("Expected OctetString"))
    }
}

/// Decode AliroExpeditedTransactionSupportedProtocolVersions attribute (0x0083)
pub fn decode_aliro_expedited_transaction_supported_protocol_versions(inp: &tlv::TlvItemValue) -> anyhow::Result<Vec<Vec<u8>>> {
    let mut res = Vec::new();
    if let tlv::TlvItemValue::List(v) = inp {
        for item in v {
            if let tlv::TlvItemValue::OctetString(o) = &item.value {
                res.push(o.clone());
            }
        }
    }
    Ok(res)
}

/// Decode AliroGroupResolvingKey attribute (0x0084)
pub fn decode_aliro_group_resolving_key(inp: &tlv::TlvItemValue) -> anyhow::Result<Option<Vec<u8>>> {
    if let tlv::TlvItemValue::OctetString(v) = inp {
        Ok(Some(v.clone()))
    } else {
        Ok(None)
    }
}

/// Decode AliroSupportedBLEUWBProtocolVersions attribute (0x0085)
pub fn decode_aliro_supported_bleuwb_protocol_versions(inp: &tlv::TlvItemValue) -> anyhow::Result<Vec<Vec<u8>>> {
    let mut res = Vec::new();
    if let tlv::TlvItemValue::List(v) = inp {
        for item in v {
            if let tlv::TlvItemValue::OctetString(o) = &item.value {
                res.push(o.clone());
            }
        }
    }
    Ok(res)
}

/// Decode AliroBLEAdvertisingVersion attribute (0x0086)
pub fn decode_aliro_ble_advertising_version(inp: &tlv::TlvItemValue) -> anyhow::Result<u8> {
    if let tlv::TlvItemValue::Int(v) = inp {
        Ok(*v as u8)
    } else {
        Err(anyhow::anyhow!("Expected UInt8"))
    }
}

/// Decode NumberOfAliroCredentialIssuerKeysSupported attribute (0x0087)
pub fn decode_number_of_aliro_credential_issuer_keys_supported(inp: &tlv::TlvItemValue) -> anyhow::Result<u16> {
    if let tlv::TlvItemValue::Int(v) = inp {
        Ok(*v as u16)
    } else {
        Err(anyhow::anyhow!("Expected UInt16"))
    }
}

/// Decode NumberOfAliroEndpointKeysSupported attribute (0x0088)
pub fn decode_number_of_aliro_endpoint_keys_supported(inp: &tlv::TlvItemValue) -> anyhow::Result<u16> {
    if let tlv::TlvItemValue::Int(v) = inp {
        Ok(*v as u16)
    } else {
        Err(anyhow::anyhow!("Expected UInt16"))
    }
}


// JSON dispatcher function

/// Decode attribute value and return as JSON string
///
/// # Parameters
/// * `cluster_id` - The cluster identifier
/// * `attribute_id` - The attribute identifier
/// * `tlv_value` - The TLV value to decode
///
/// # Returns
/// JSON string representation of the decoded value or error
pub fn decode_attribute_json(cluster_id: u32, attribute_id: u32, tlv_value: &crate::tlv::TlvItemValue) -> String {
    // Verify this is the correct cluster
    if cluster_id != 0x0101 {
        return format!("{{\"error\": \"Invalid cluster ID. Expected 0x0101, got {}\"}}", cluster_id);
    }

    match attribute_id {
        0x0000 => {
            match decode_lock_state(tlv_value) {
                Ok(value) => serde_json::to_string(&value).unwrap_or_else(|_| "null".to_string()),
                Err(e) => format!("{{\"error\": \"{}\"}}", e),
            }
        }
        0x0001 => {
            match decode_lock_type(tlv_value) {
                Ok(value) => serde_json::to_string(&value).unwrap_or_else(|_| "null".to_string()),
                Err(e) => format!("{{\"error\": \"{}\"}}", e),
            }
        }
        0x0002 => {
            match decode_actuator_enabled(tlv_value) {
                Ok(value) => serde_json::to_string(&value).unwrap_or_else(|_| "null".to_string()),
                Err(e) => format!("{{\"error\": \"{}\"}}", e),
            }
        }
        0x0003 => {
            match decode_door_state(tlv_value) {
                Ok(value) => serde_json::to_string(&value).unwrap_or_else(|_| "null".to_string()),
                Err(e) => format!("{{\"error\": \"{}\"}}", e),
            }
        }
        0x0004 => {
            match decode_door_open_events(tlv_value) {
                Ok(value) => serde_json::to_string(&value).unwrap_or_else(|_| "null".to_string()),
                Err(e) => format!("{{\"error\": \"{}\"}}", e),
            }
        }
        0x0005 => {
            match decode_door_closed_events(tlv_value) {
                Ok(value) => serde_json::to_string(&value).unwrap_or_else(|_| "null".to_string()),
                Err(e) => format!("{{\"error\": \"{}\"}}", e),
            }
        }
        0x0006 => {
            match decode_open_period(tlv_value) {
                Ok(value) => serde_json::to_string(&value).unwrap_or_else(|_| "null".to_string()),
                Err(e) => format!("{{\"error\": \"{}\"}}", e),
            }
        }
        0x0011 => {
            match decode_number_of_total_users_supported(tlv_value) {
                Ok(value) => serde_json::to_string(&value).unwrap_or_else(|_| "null".to_string()),
                Err(e) => format!("{{\"error\": \"{}\"}}", e),
            }
        }
        0x0012 => {
            match decode_number_of_pin_users_supported(tlv_value) {
                Ok(value) => serde_json::to_string(&value).unwrap_or_else(|_| "null".to_string()),
                Err(e) => format!("{{\"error\": \"{}\"}}", e),
            }
        }
        0x0013 => {
            match decode_number_of_rfid_users_supported(tlv_value) {
                Ok(value) => serde_json::to_string(&value).unwrap_or_else(|_| "null".to_string()),
                Err(e) => format!("{{\"error\": \"{}\"}}", e),
            }
        }
        0x0014 => {
            match decode_number_of_week_day_schedules_supported_per_user(tlv_value) {
                Ok(value) => serde_json::to_string(&value).unwrap_or_else(|_| "null".to_string()),
                Err(e) => format!("{{\"error\": \"{}\"}}", e),
            }
        }
        0x0015 => {
            match decode_number_of_year_day_schedules_supported_per_user(tlv_value) {
                Ok(value) => serde_json::to_string(&value).unwrap_or_else(|_| "null".to_string()),
                Err(e) => format!("{{\"error\": \"{}\"}}", e),
            }
        }
        0x0016 => {
            match decode_number_of_holiday_schedules_supported(tlv_value) {
                Ok(value) => serde_json::to_string(&value).unwrap_or_else(|_| "null".to_string()),
                Err(e) => format!("{{\"error\": \"{}\"}}", e),
            }
        }
        0x0017 => {
            match decode_max_pin_code_length(tlv_value) {
                Ok(value) => serde_json::to_string(&value).unwrap_or_else(|_| "null".to_string()),
                Err(e) => format!("{{\"error\": \"{}\"}}", e),
            }
        }
        0x0018 => {
            match decode_min_pin_code_length(tlv_value) {
                Ok(value) => serde_json::to_string(&value).unwrap_or_else(|_| "null".to_string()),
                Err(e) => format!("{{\"error\": \"{}\"}}", e),
            }
        }
        0x0019 => {
            match decode_max_rfid_code_length(tlv_value) {
                Ok(value) => serde_json::to_string(&value).unwrap_or_else(|_| "null".to_string()),
                Err(e) => format!("{{\"error\": \"{}\"}}", e),
            }
        }
        0x001A => {
            match decode_min_rfid_code_length(tlv_value) {
                Ok(value) => serde_json::to_string(&value).unwrap_or_else(|_| "null".to_string()),
                Err(e) => format!("{{\"error\": \"{}\"}}", e),
            }
        }
        0x001B => {
            match decode_credential_rules_support(tlv_value) {
                Ok(value) => serde_json::to_string(&value).unwrap_or_else(|_| "null".to_string()),
                Err(e) => format!("{{\"error\": \"{}\"}}", e),
            }
        }
        0x001C => {
            match decode_number_of_credentials_supported_per_user(tlv_value) {
                Ok(value) => serde_json::to_string(&value).unwrap_or_else(|_| "null".to_string()),
                Err(e) => format!("{{\"error\": \"{}\"}}", e),
            }
        }
        0x0021 => {
            match decode_language(tlv_value) {
                Ok(value) => serde_json::to_string(&value).unwrap_or_else(|_| "null".to_string()),
                Err(e) => format!("{{\"error\": \"{}\"}}", e),
            }
        }
        0x0022 => {
            match decode_led_settings(tlv_value) {
                Ok(value) => serde_json::to_string(&value).unwrap_or_else(|_| "null".to_string()),
                Err(e) => format!("{{\"error\": \"{}\"}}", e),
            }
        }
        0x0023 => {
            match decode_auto_relock_time(tlv_value) {
                Ok(value) => serde_json::to_string(&value).unwrap_or_else(|_| "null".to_string()),
                Err(e) => format!("{{\"error\": \"{}\"}}", e),
            }
        }
        0x0024 => {
            match decode_sound_volume(tlv_value) {
                Ok(value) => serde_json::to_string(&value).unwrap_or_else(|_| "null".to_string()),
                Err(e) => format!("{{\"error\": \"{}\"}}", e),
            }
        }
        0x0025 => {
            match decode_operating_mode(tlv_value) {
                Ok(value) => serde_json::to_string(&value).unwrap_or_else(|_| "null".to_string()),
                Err(e) => format!("{{\"error\": \"{}\"}}", e),
            }
        }
        0x0026 => {
            match decode_supported_operating_modes(tlv_value) {
                Ok(value) => serde_json::to_string(&value).unwrap_or_else(|_| "null".to_string()),
                Err(e) => format!("{{\"error\": \"{}\"}}", e),
            }
        }
        0x0027 => {
            match decode_default_configuration_register(tlv_value) {
                Ok(value) => serde_json::to_string(&value).unwrap_or_else(|_| "null".to_string()),
                Err(e) => format!("{{\"error\": \"{}\"}}", e),
            }
        }
        0x0028 => {
            match decode_enable_local_programming(tlv_value) {
                Ok(value) => serde_json::to_string(&value).unwrap_or_else(|_| "null".to_string()),
                Err(e) => format!("{{\"error\": \"{}\"}}", e),
            }
        }
        0x0029 => {
            match decode_enable_one_touch_locking(tlv_value) {
                Ok(value) => serde_json::to_string(&value).unwrap_or_else(|_| "null".to_string()),
                Err(e) => format!("{{\"error\": \"{}\"}}", e),
            }
        }
        0x002A => {
            match decode_enable_inside_status_led(tlv_value) {
                Ok(value) => serde_json::to_string(&value).unwrap_or_else(|_| "null".to_string()),
                Err(e) => format!("{{\"error\": \"{}\"}}", e),
            }
        }
        0x002B => {
            match decode_enable_privacy_mode_button(tlv_value) {
                Ok(value) => serde_json::to_string(&value).unwrap_or_else(|_| "null".to_string()),
                Err(e) => format!("{{\"error\": \"{}\"}}", e),
            }
        }
        0x002C => {
            match decode_local_programming_features(tlv_value) {
                Ok(value) => serde_json::to_string(&value).unwrap_or_else(|_| "null".to_string()),
                Err(e) => format!("{{\"error\": \"{}\"}}", e),
            }
        }
        0x0030 => {
            match decode_wrong_code_entry_limit(tlv_value) {
                Ok(value) => serde_json::to_string(&value).unwrap_or_else(|_| "null".to_string()),
                Err(e) => format!("{{\"error\": \"{}\"}}", e),
            }
        }
        0x0031 => {
            match decode_user_code_temporary_disable_time(tlv_value) {
                Ok(value) => serde_json::to_string(&value).unwrap_or_else(|_| "null".to_string()),
                Err(e) => format!("{{\"error\": \"{}\"}}", e),
            }
        }
        0x0032 => {
            match decode_send_pin_over_the_air(tlv_value) {
                Ok(value) => serde_json::to_string(&value).unwrap_or_else(|_| "null".to_string()),
                Err(e) => format!("{{\"error\": \"{}\"}}", e),
            }
        }
        0x0033 => {
            match decode_require_pinfor_remote_operation(tlv_value) {
                Ok(value) => serde_json::to_string(&value).unwrap_or_else(|_| "null".to_string()),
                Err(e) => format!("{{\"error\": \"{}\"}}", e),
            }
        }
        0x0034 => {
            match decode_security_level(tlv_value) {
                Ok(value) => serde_json::to_string(&value).unwrap_or_else(|_| "null".to_string()),
                Err(e) => format!("{{\"error\": \"{}\"}}", e),
            }
        }
        0x0035 => {
            match decode_expiring_user_timeout(tlv_value) {
                Ok(value) => serde_json::to_string(&value).unwrap_or_else(|_| "null".to_string()),
                Err(e) => format!("{{\"error\": \"{}\"}}", e),
            }
        }
        0x0080 => {
            match decode_aliro_reader_verification_key(tlv_value) {
                Ok(value) => serde_json::to_string(&value).unwrap_or_else(|_| "null".to_string()),
                Err(e) => format!("{{\"error\": \"{}\"}}", e),
            }
        }
        0x0081 => {
            match decode_aliro_reader_group_identifier(tlv_value) {
                Ok(value) => serde_json::to_string(&value).unwrap_or_else(|_| "null".to_string()),
                Err(e) => format!("{{\"error\": \"{}\"}}", e),
            }
        }
        0x0082 => {
            match decode_aliro_reader_group_sub_identifier(tlv_value) {
                Ok(value) => serde_json::to_string(&value).unwrap_or_else(|_| "null".to_string()),
                Err(e) => format!("{{\"error\": \"{}\"}}", e),
            }
        }
        0x0083 => {
            match decode_aliro_expedited_transaction_supported_protocol_versions(tlv_value) {
                Ok(value) => {
                    // Serialize Vec<Vec<u8>> as array of hex strings
                    let hex_array: Vec<String> = value.iter()
                        .map(|bytes| bytes.iter()
                            .map(|byte| format!("{:02x}", byte))
                            .collect::<String>())
                        .collect();
                    serde_json::to_string(&hex_array).unwrap_or_else(|_| "null".to_string())
                },
                Err(e) => format!("{{\"error\": \"{}\"}}", e),
            }
        }
        0x0084 => {
            match decode_aliro_group_resolving_key(tlv_value) {
                Ok(value) => serde_json::to_string(&value).unwrap_or_else(|_| "null".to_string()),
                Err(e) => format!("{{\"error\": \"{}\"}}", e),
            }
        }
        0x0085 => {
            match decode_aliro_supported_bleuwb_protocol_versions(tlv_value) {
                Ok(value) => {
                    // Serialize Vec<Vec<u8>> as array of hex strings
                    let hex_array: Vec<String> = value.iter()
                        .map(|bytes| bytes.iter()
                            .map(|byte| format!("{:02x}", byte))
                            .collect::<String>())
                        .collect();
                    serde_json::to_string(&hex_array).unwrap_or_else(|_| "null".to_string())
                },
                Err(e) => format!("{{\"error\": \"{}\"}}", e),
            }
        }
        0x0086 => {
            match decode_aliro_ble_advertising_version(tlv_value) {
                Ok(value) => serde_json::to_string(&value).unwrap_or_else(|_| "null".to_string()),
                Err(e) => format!("{{\"error\": \"{}\"}}", e),
            }
        }
        0x0087 => {
            match decode_number_of_aliro_credential_issuer_keys_supported(tlv_value) {
                Ok(value) => serde_json::to_string(&value).unwrap_or_else(|_| "null".to_string()),
                Err(e) => format!("{{\"error\": \"{}\"}}", e),
            }
        }
        0x0088 => {
            match decode_number_of_aliro_endpoint_keys_supported(tlv_value) {
                Ok(value) => serde_json::to_string(&value).unwrap_or_else(|_| "null".to_string()),
                Err(e) => format!("{{\"error\": \"{}\"}}", e),
            }
        }
        _ => format!("{{\"error\": \"Unknown attribute ID: {}\"}}", attribute_id),
    }
}

/// Get list of all attributes supported by this cluster
///
/// # Returns
/// Vector of tuples containing (attribute_id, attribute_name)
pub fn get_attribute_list() -> Vec<(u32, &'static str)> {
    vec![
        (0x0000, "LockState"),
        (0x0001, "LockType"),
        (0x0002, "ActuatorEnabled"),
        (0x0003, "DoorState"),
        (0x0004, "DoorOpenEvents"),
        (0x0005, "DoorClosedEvents"),
        (0x0006, "OpenPeriod"),
        (0x0011, "NumberOfTotalUsersSupported"),
        (0x0012, "NumberOfPINUsersSupported"),
        (0x0013, "NumberOfRFIDUsersSupported"),
        (0x0014, "NumberOfWeekDaySchedulesSupportedPerUser"),
        (0x0015, "NumberOfYearDaySchedulesSupportedPerUser"),
        (0x0016, "NumberOfHolidaySchedulesSupported"),
        (0x0017, "MaxPINCodeLength"),
        (0x0018, "MinPINCodeLength"),
        (0x0019, "MaxRFIDCodeLength"),
        (0x001A, "MinRFIDCodeLength"),
        (0x001B, "CredentialRulesSupport"),
        (0x001C, "NumberOfCredentialsSupportedPerUser"),
        (0x0021, "Language"),
        (0x0022, "LEDSettings"),
        (0x0023, "AutoRelockTime"),
        (0x0024, "SoundVolume"),
        (0x0025, "OperatingMode"),
        (0x0026, "SupportedOperatingModes"),
        (0x0027, "DefaultConfigurationRegister"),
        (0x0028, "EnableLocalProgramming"),
        (0x0029, "EnableOneTouchLocking"),
        (0x002A, "EnableInsideStatusLED"),
        (0x002B, "EnablePrivacyModeButton"),
        (0x002C, "LocalProgrammingFeatures"),
        (0x0030, "WrongCodeEntryLimit"),
        (0x0031, "UserCodeTemporaryDisableTime"),
        (0x0032, "SendPINOverTheAir"),
        (0x0033, "RequirePINforRemoteOperation"),
        (0x0034, "SecurityLevel"),
        (0x0035, "ExpiringUserTimeout"),
        (0x0080, "AliroReaderVerificationKey"),
        (0x0081, "AliroReaderGroupIdentifier"),
        (0x0082, "AliroReaderGroupSubIdentifier"),
        (0x0083, "AliroExpeditedTransactionSupportedProtocolVersions"),
        (0x0084, "AliroGroupResolvingKey"),
        (0x0085, "AliroSupportedBLEUWBProtocolVersions"),
        (0x0086, "AliroBLEAdvertisingVersion"),
        (0x0087, "NumberOfAliroCredentialIssuerKeysSupported"),
        (0x0088, "NumberOfAliroEndpointKeysSupported"),
    ]
}

// Command listing

pub fn get_command_list() -> Vec<(u32, &'static str)> {
    vec![
        (0x00, "LockDoor"),
        (0x01, "UnlockDoor"),
        (0x02, "Toggle"),
        (0x03, "UnlockWithTimeout"),
        (0x0B, "SetWeekDaySchedule"),
        (0x0C, "GetWeekDaySchedule"),
        (0x0D, "ClearWeekDaySchedule"),
        (0x0E, "SetYearDaySchedule"),
        (0x0F, "GetYearDaySchedule"),
        (0x10, "ClearYearDaySchedule"),
        (0x11, "SetHolidaySchedule"),
        (0x12, "GetHolidaySchedule"),
        (0x13, "ClearHolidaySchedule"),
        (0x1A, "SetUser"),
        (0x1B, "GetUser"),
        (0x1D, "ClearUser"),
        (0x22, "SetCredential"),
        (0x24, "GetCredentialStatus"),
        (0x26, "ClearCredential"),
        (0x27, "UnboltDoor"),
        (0x28, "SetAliroReaderConfig"),
        (0x29, "ClearAliroReaderConfig"),
    ]
}

pub fn get_command_name(cmd_id: u32) -> Option<&'static str> {
    match cmd_id {
        0x00 => Some("LockDoor"),
        0x01 => Some("UnlockDoor"),
        0x02 => Some("Toggle"),
        0x03 => Some("UnlockWithTimeout"),
        0x0B => Some("SetWeekDaySchedule"),
        0x0C => Some("GetWeekDaySchedule"),
        0x0D => Some("ClearWeekDaySchedule"),
        0x0E => Some("SetYearDaySchedule"),
        0x0F => Some("GetYearDaySchedule"),
        0x10 => Some("ClearYearDaySchedule"),
        0x11 => Some("SetHolidaySchedule"),
        0x12 => Some("GetHolidaySchedule"),
        0x13 => Some("ClearHolidaySchedule"),
        0x1A => Some("SetUser"),
        0x1B => Some("GetUser"),
        0x1D => Some("ClearUser"),
        0x22 => Some("SetCredential"),
        0x24 => Some("GetCredentialStatus"),
        0x26 => Some("ClearCredential"),
        0x27 => Some("UnboltDoor"),
        0x28 => Some("SetAliroReaderConfig"),
        0x29 => Some("ClearAliroReaderConfig"),
        _ => None,
    }
}

pub fn get_command_schema(cmd_id: u32) -> Option<Vec<crate::clusters::codec::CommandField>> {
    match cmd_id {
        0x00 => Some(vec![
            crate::clusters::codec::CommandField { tag: 0, name: "pin_code", kind: crate::clusters::codec::FieldKind::OctetString, optional: true, nullable: false },
        ]),
        0x01 => Some(vec![
            crate::clusters::codec::CommandField { tag: 0, name: "pin_code", kind: crate::clusters::codec::FieldKind::OctetString, optional: true, nullable: false },
        ]),
        0x02 => Some(vec![]),
        0x03 => Some(vec![
            crate::clusters::codec::CommandField { tag: 0, name: "timeout", kind: crate::clusters::codec::FieldKind::U16, optional: false, nullable: false },
            crate::clusters::codec::CommandField { tag: 1, name: "pin_code", kind: crate::clusters::codec::FieldKind::OctetString, optional: true, nullable: false },
        ]),
        0x0B => Some(vec![
            crate::clusters::codec::CommandField { tag: 0, name: "week_day_index", kind: crate::clusters::codec::FieldKind::U8, optional: false, nullable: false },
            crate::clusters::codec::CommandField { tag: 1, name: "user_index", kind: crate::clusters::codec::FieldKind::U16, optional: false, nullable: false },
            crate::clusters::codec::CommandField { tag: 2, name: "days_mask", kind: crate::clusters::codec::FieldKind::Bitmap { name: "DaysMask", bits: &[(1, "SUNDAY"), (2, "MONDAY"), (4, "TUESDAY"), (8, "WEDNESDAY"), (16, "THURSDAY"), (32, "FRIDAY"), (64, "SATURDAY")] }, optional: false, nullable: false },
            crate::clusters::codec::CommandField { tag: 3, name: "start_hour", kind: crate::clusters::codec::FieldKind::U8, optional: false, nullable: false },
            crate::clusters::codec::CommandField { tag: 4, name: "start_minute", kind: crate::clusters::codec::FieldKind::U8, optional: false, nullable: false },
            crate::clusters::codec::CommandField { tag: 5, name: "end_hour", kind: crate::clusters::codec::FieldKind::U8, optional: false, nullable: false },
            crate::clusters::codec::CommandField { tag: 6, name: "end_minute", kind: crate::clusters::codec::FieldKind::U8, optional: false, nullable: false },
        ]),
        0x0C => Some(vec![
            crate::clusters::codec::CommandField { tag: 0, name: "week_day_index", kind: crate::clusters::codec::FieldKind::U8, optional: false, nullable: false },
            crate::clusters::codec::CommandField { tag: 1, name: "user_index", kind: crate::clusters::codec::FieldKind::U16, optional: false, nullable: false },
        ]),
        0x0D => Some(vec![
            crate::clusters::codec::CommandField { tag: 0, name: "week_day_index", kind: crate::clusters::codec::FieldKind::U8, optional: false, nullable: false },
            crate::clusters::codec::CommandField { tag: 1, name: "user_index", kind: crate::clusters::codec::FieldKind::U16, optional: false, nullable: false },
        ]),
        0x0E => Some(vec![
            crate::clusters::codec::CommandField { tag: 0, name: "year_day_index", kind: crate::clusters::codec::FieldKind::U8, optional: false, nullable: false },
            crate::clusters::codec::CommandField { tag: 1, name: "user_index", kind: crate::clusters::codec::FieldKind::U16, optional: false, nullable: false },
            crate::clusters::codec::CommandField { tag: 2, name: "local_start_time", kind: crate::clusters::codec::FieldKind::U64, optional: false, nullable: false },
            crate::clusters::codec::CommandField { tag: 3, name: "local_end_time", kind: crate::clusters::codec::FieldKind::U64, optional: false, nullable: false },
        ]),
        0x0F => Some(vec![
            crate::clusters::codec::CommandField { tag: 0, name: "year_day_index", kind: crate::clusters::codec::FieldKind::U8, optional: false, nullable: false },
            crate::clusters::codec::CommandField { tag: 1, name: "user_index", kind: crate::clusters::codec::FieldKind::U16, optional: false, nullable: false },
        ]),
        0x10 => Some(vec![
            crate::clusters::codec::CommandField { tag: 0, name: "year_day_index", kind: crate::clusters::codec::FieldKind::U8, optional: false, nullable: false },
            crate::clusters::codec::CommandField { tag: 1, name: "user_index", kind: crate::clusters::codec::FieldKind::U16, optional: false, nullable: false },
        ]),
        0x11 => Some(vec![
            crate::clusters::codec::CommandField { tag: 0, name: "holiday_index", kind: crate::clusters::codec::FieldKind::U8, optional: false, nullable: false },
            crate::clusters::codec::CommandField { tag: 1, name: "local_start_time", kind: crate::clusters::codec::FieldKind::U64, optional: false, nullable: false },
            crate::clusters::codec::CommandField { tag: 2, name: "local_end_time", kind: crate::clusters::codec::FieldKind::U64, optional: false, nullable: false },
            crate::clusters::codec::CommandField { tag: 3, name: "operating_mode", kind: crate::clusters::codec::FieldKind::Enum { name: "OperatingMode", variants: &[(0, "Normal"), (1, "Vacation"), (2, "Privacy"), (3, "Noremotelockunlock"), (4, "Passage")] }, optional: false, nullable: false },
        ]),
        0x12 => Some(vec![
            crate::clusters::codec::CommandField { tag: 0, name: "holiday_index", kind: crate::clusters::codec::FieldKind::U8, optional: false, nullable: false },
        ]),
        0x13 => Some(vec![
            crate::clusters::codec::CommandField { tag: 0, name: "holiday_index", kind: crate::clusters::codec::FieldKind::U8, optional: false, nullable: false },
        ]),
        0x1A => Some(vec![
            crate::clusters::codec::CommandField { tag: 0, name: "operation_type", kind: crate::clusters::codec::FieldKind::Enum { name: "DataOperationType", variants: &[(0, "Add"), (1, "Clear"), (2, "Modify")] }, optional: false, nullable: false },
            crate::clusters::codec::CommandField { tag: 1, name: "user_index", kind: crate::clusters::codec::FieldKind::U16, optional: false, nullable: false },
            crate::clusters::codec::CommandField { tag: 2, name: "user_name", kind: crate::clusters::codec::FieldKind::String, optional: false, nullable: true },
            crate::clusters::codec::CommandField { tag: 3, name: "user_unique_id", kind: crate::clusters::codec::FieldKind::U32, optional: false, nullable: true },
            crate::clusters::codec::CommandField { tag: 4, name: "user_status", kind: crate::clusters::codec::FieldKind::Enum { name: "UserStatus", variants: &[(0, "Available"), (1, "Occupiedenabled"), (3, "Occupieddisabled")] }, optional: false, nullable: true },
            crate::clusters::codec::CommandField { tag: 5, name: "user_type", kind: crate::clusters::codec::FieldKind::Enum { name: "UserType", variants: &[(0, "Unrestricteduser"), (1, "Yeardayscheduleuser"), (2, "Weekdayscheduleuser"), (3, "Programminguser"), (4, "Nonaccessuser"), (5, "Forceduser"), (6, "Disposableuser"), (7, "Expiringuser"), (8, "Schedulerestricteduser"), (9, "Remoteonlyuser")] }, optional: false, nullable: true },
            crate::clusters::codec::CommandField { tag: 6, name: "credential_rule", kind: crate::clusters::codec::FieldKind::Enum { name: "CredentialRule", variants: &[(0, "Single"), (1, "Dual"), (2, "Tri")] }, optional: false, nullable: true },
        ]),
        0x1B => Some(vec![
            crate::clusters::codec::CommandField { tag: 0, name: "user_index", kind: crate::clusters::codec::FieldKind::U16, optional: false, nullable: false },
        ]),
        0x1D => Some(vec![
            crate::clusters::codec::CommandField { tag: 0, name: "user_index", kind: crate::clusters::codec::FieldKind::U16, optional: false, nullable: false },
        ]),
        0x22 => Some(vec![
            crate::clusters::codec::CommandField { tag: 0, name: "operation_type", kind: crate::clusters::codec::FieldKind::Enum { name: "DataOperationType", variants: &[(0, "Add"), (1, "Clear"), (2, "Modify")] }, optional: false, nullable: false },
            crate::clusters::codec::CommandField { tag: 1, name: "credential", kind: crate::clusters::codec::FieldKind::Struct { name: "CredentialStruct" }, optional: false, nullable: false },
            crate::clusters::codec::CommandField { tag: 2, name: "credential_data", kind: crate::clusters::codec::FieldKind::OctetString, optional: false, nullable: false },
            crate::clusters::codec::CommandField { tag: 3, name: "user_index", kind: crate::clusters::codec::FieldKind::U16, optional: false, nullable: true },
            crate::clusters::codec::CommandField { tag: 4, name: "user_status", kind: crate::clusters::codec::FieldKind::Enum { name: "UserStatus", variants: &[(0, "Available"), (1, "Occupiedenabled"), (3, "Occupieddisabled")] }, optional: false, nullable: true },
            crate::clusters::codec::CommandField { tag: 5, name: "user_type", kind: crate::clusters::codec::FieldKind::Enum { name: "UserType", variants: &[(0, "Unrestricteduser"), (1, "Yeardayscheduleuser"), (2, "Weekdayscheduleuser"), (3, "Programminguser"), (4, "Nonaccessuser"), (5, "Forceduser"), (6, "Disposableuser"), (7, "Expiringuser"), (8, "Schedulerestricteduser"), (9, "Remoteonlyuser")] }, optional: false, nullable: true },
        ]),
        0x24 => Some(vec![
            crate::clusters::codec::CommandField { tag: 0, name: "credential", kind: crate::clusters::codec::FieldKind::Struct { name: "CredentialStruct" }, optional: false, nullable: false },
        ]),
        0x26 => Some(vec![
            crate::clusters::codec::CommandField { tag: 0, name: "credential", kind: crate::clusters::codec::FieldKind::Struct { name: "CredentialStruct" }, optional: false, nullable: true },
        ]),
        0x27 => Some(vec![
            crate::clusters::codec::CommandField { tag: 0, name: "pin_code", kind: crate::clusters::codec::FieldKind::OctetString, optional: true, nullable: false },
        ]),
        0x28 => Some(vec![
            crate::clusters::codec::CommandField { tag: 0, name: "signing_key", kind: crate::clusters::codec::FieldKind::OctetString, optional: false, nullable: false },
            crate::clusters::codec::CommandField { tag: 1, name: "verification_key", kind: crate::clusters::codec::FieldKind::OctetString, optional: false, nullable: false },
            crate::clusters::codec::CommandField { tag: 2, name: "group_identifier", kind: crate::clusters::codec::FieldKind::OctetString, optional: false, nullable: false },
            crate::clusters::codec::CommandField { tag: 3, name: "group_resolving_key", kind: crate::clusters::codec::FieldKind::OctetString, optional: false, nullable: false },
        ]),
        0x29 => Some(vec![]),
        _ => None,
    }
}

pub fn encode_command_json(cmd_id: u32, args: &serde_json::Value) -> anyhow::Result<Vec<u8>> {
    match cmd_id {
        0x00 => {
        let pin_code = crate::clusters::codec::json_util::get_opt_octstr(args, "pin_code")?;
        encode_lock_door(pin_code)
        }
        0x01 => {
        let pin_code = crate::clusters::codec::json_util::get_opt_octstr(args, "pin_code")?;
        encode_unlock_door(pin_code)
        }
        0x02 => Ok(vec![]),
        0x03 => {
        let timeout = crate::clusters::codec::json_util::get_u16(args, "timeout")?;
        let pin_code = crate::clusters::codec::json_util::get_opt_octstr(args, "pin_code")?;
        encode_unlock_with_timeout(timeout, pin_code)
        }
        0x0B => {
        let week_day_index = crate::clusters::codec::json_util::get_u8(args, "week_day_index")?;
        let user_index = crate::clusters::codec::json_util::get_u16(args, "user_index")?;
        let days_mask = crate::clusters::codec::json_util::get_u8(args, "days_mask")?;
        let start_hour = crate::clusters::codec::json_util::get_u8(args, "start_hour")?;
        let start_minute = crate::clusters::codec::json_util::get_u8(args, "start_minute")?;
        let end_hour = crate::clusters::codec::json_util::get_u8(args, "end_hour")?;
        let end_minute = crate::clusters::codec::json_util::get_u8(args, "end_minute")?;
        encode_set_week_day_schedule(week_day_index, user_index, days_mask, start_hour, start_minute, end_hour, end_minute)
        }
        0x0C => {
        let week_day_index = crate::clusters::codec::json_util::get_u8(args, "week_day_index")?;
        let user_index = crate::clusters::codec::json_util::get_u16(args, "user_index")?;
        encode_get_week_day_schedule(week_day_index, user_index)
        }
        0x0D => {
        let week_day_index = crate::clusters::codec::json_util::get_u8(args, "week_day_index")?;
        let user_index = crate::clusters::codec::json_util::get_u16(args, "user_index")?;
        encode_clear_week_day_schedule(week_day_index, user_index)
        }
        0x0E => {
        let year_day_index = crate::clusters::codec::json_util::get_u8(args, "year_day_index")?;
        let user_index = crate::clusters::codec::json_util::get_u16(args, "user_index")?;
        let local_start_time = crate::clusters::codec::json_util::get_u64(args, "local_start_time")?;
        let local_end_time = crate::clusters::codec::json_util::get_u64(args, "local_end_time")?;
        encode_set_year_day_schedule(year_day_index, user_index, local_start_time, local_end_time)
        }
        0x0F => {
        let year_day_index = crate::clusters::codec::json_util::get_u8(args, "year_day_index")?;
        let user_index = crate::clusters::codec::json_util::get_u16(args, "user_index")?;
        encode_get_year_day_schedule(year_day_index, user_index)
        }
        0x10 => {
        let year_day_index = crate::clusters::codec::json_util::get_u8(args, "year_day_index")?;
        let user_index = crate::clusters::codec::json_util::get_u16(args, "user_index")?;
        encode_clear_year_day_schedule(year_day_index, user_index)
        }
        0x11 => {
        let holiday_index = crate::clusters::codec::json_util::get_u8(args, "holiday_index")?;
        let local_start_time = crate::clusters::codec::json_util::get_u64(args, "local_start_time")?;
        let local_end_time = crate::clusters::codec::json_util::get_u64(args, "local_end_time")?;
        let operating_mode = {
            let n = crate::clusters::codec::json_util::get_u64(args, "operating_mode")?;
            OperatingMode::from_u8(n as u8).ok_or_else(|| anyhow::anyhow!("invalid OperatingMode: {}", n))?
        };
        encode_set_holiday_schedule(holiday_index, local_start_time, local_end_time, operating_mode)
        }
        0x12 => {
        let holiday_index = crate::clusters::codec::json_util::get_u8(args, "holiday_index")?;
        encode_get_holiday_schedule(holiday_index)
        }
        0x13 => {
        let holiday_index = crate::clusters::codec::json_util::get_u8(args, "holiday_index")?;
        encode_clear_holiday_schedule(holiday_index)
        }
        0x1A => {
        let operation_type = {
            let n = crate::clusters::codec::json_util::get_u64(args, "operation_type")?;
            DataOperationType::from_u8(n as u8).ok_or_else(|| anyhow::anyhow!("invalid DataOperationType: {}", n))?
        };
        let user_index = crate::clusters::codec::json_util::get_u16(args, "user_index")?;
        let user_name = crate::clusters::codec::json_util::get_opt_string(args, "user_name")?;
        let user_unique_id = crate::clusters::codec::json_util::get_opt_u32(args, "user_unique_id")?;
        let user_status = crate::clusters::codec::json_util::get_opt_u64(args, "user_status")?
            .and_then(|n| UserStatus::from_u8(n as u8));
        let user_type = crate::clusters::codec::json_util::get_opt_u64(args, "user_type")?
            .and_then(|n| UserType::from_u8(n as u8));
        let credential_rule = crate::clusters::codec::json_util::get_opt_u64(args, "credential_rule")?
            .and_then(|n| CredentialRule::from_u8(n as u8));
        encode_set_user(operation_type, user_index, user_name, user_unique_id, user_status, user_type, credential_rule)
        }
        0x1B => {
        let user_index = crate::clusters::codec::json_util::get_u16(args, "user_index")?;
        encode_get_user(user_index)
        }
        0x1D => {
        let user_index = crate::clusters::codec::json_util::get_u16(args, "user_index")?;
        encode_clear_user(user_index)
        }
        0x22 => Err(anyhow::anyhow!("command \"SetCredential\" has complex args: use raw mode")),
        0x24 => Err(anyhow::anyhow!("command \"GetCredentialStatus\" has complex args: use raw mode")),
        0x26 => Err(anyhow::anyhow!("command \"ClearCredential\" has complex args: use raw mode")),
        0x27 => {
        let pin_code = crate::clusters::codec::json_util::get_opt_octstr(args, "pin_code")?;
        encode_unbolt_door(pin_code)
        }
        0x28 => {
        let signing_key = crate::clusters::codec::json_util::get_octstr(args, "signing_key")?;
        let verification_key = crate::clusters::codec::json_util::get_octstr(args, "verification_key")?;
        let group_identifier = crate::clusters::codec::json_util::get_octstr(args, "group_identifier")?;
        let group_resolving_key = crate::clusters::codec::json_util::get_octstr(args, "group_resolving_key")?;
        encode_set_aliro_reader_config(signing_key, verification_key, group_identifier, group_resolving_key)
        }
        0x29 => Ok(vec![]),
        _ => Err(anyhow::anyhow!("unknown command ID: 0x{:02X}", cmd_id)),
    }
}

#[derive(Debug, serde::Serialize)]
pub struct GetWeekDayScheduleResponse {
    pub week_day_index: Option<u8>,
    pub user_index: Option<u16>,
    pub status: Option<u8>,
    pub days_mask: Option<DaysMask>,
    pub start_hour: Option<u8>,
    pub start_minute: Option<u8>,
    pub end_hour: Option<u8>,
    pub end_minute: Option<u8>,
}

#[derive(Debug, serde::Serialize)]
pub struct GetYearDayScheduleResponse {
    pub year_day_index: Option<u8>,
    pub user_index: Option<u16>,
    pub status: Option<u8>,
    pub local_start_time: Option<u64>,
    pub local_end_time: Option<u64>,
}

#[derive(Debug, serde::Serialize)]
pub struct GetHolidayScheduleResponse {
    pub holiday_index: Option<u8>,
    pub status: Option<u8>,
    pub local_start_time: Option<u64>,
    pub local_end_time: Option<u64>,
    pub operating_mode: Option<OperatingMode>,
}

#[derive(Debug, serde::Serialize)]
pub struct GetUserResponse {
    pub user_index: Option<u16>,
    pub user_name: Option<String>,
    pub user_unique_id: Option<u32>,
    pub user_status: Option<UserStatus>,
    pub user_type: Option<UserType>,
    pub credential_rule: Option<CredentialRule>,
    pub credentials: Option<Vec<Credential>>,
    pub creator_fabric_index: Option<u8>,
    pub last_modified_fabric_index: Option<u8>,
    pub next_user_index: Option<u16>,
}

#[derive(Debug, serde::Serialize)]
pub struct SetCredentialResponse {
    pub status: Option<u8>,
    pub user_index: Option<u16>,
    pub next_credential_index: Option<u16>,
}

#[derive(Debug, serde::Serialize)]
pub struct GetCredentialStatusResponse {
    pub credential_exists: Option<bool>,
    pub user_index: Option<u16>,
    pub creator_fabric_index: Option<u8>,
    pub last_modified_fabric_index: Option<u8>,
    pub next_credential_index: Option<u16>,
    #[serde(serialize_with = "serialize_opt_bytes_as_hex")]
    pub credential_data: Option<Vec<u8>>,
}

// Command response decoders

/// Decode GetWeekDayScheduleResponse command response (0C)
pub fn decode_get_week_day_schedule_response(inp: &tlv::TlvItemValue) -> anyhow::Result<GetWeekDayScheduleResponse> {
    if let tlv::TlvItemValue::List(_fields) = inp {
        let item = tlv::TlvItem { tag: 0, value: inp.clone() };
        Ok(GetWeekDayScheduleResponse {
                week_day_index: item.get_int(&[0]).map(|v| v as u8),
                user_index: item.get_int(&[1]).map(|v| v as u16),
                status: item.get_int(&[2]).map(|v| v as u8),
                days_mask: item.get_int(&[3]).map(|v| v as u8),
                start_hour: item.get_int(&[4]).map(|v| v as u8),
                start_minute: item.get_int(&[5]).map(|v| v as u8),
                end_hour: item.get_int(&[6]).map(|v| v as u8),
                end_minute: item.get_int(&[7]).map(|v| v as u8),
        })
    } else {
        Err(anyhow::anyhow!("Expected struct fields"))
    }
}

/// Decode GetYearDayScheduleResponse command response (0F)
pub fn decode_get_year_day_schedule_response(inp: &tlv::TlvItemValue) -> anyhow::Result<GetYearDayScheduleResponse> {
    if let tlv::TlvItemValue::List(_fields) = inp {
        let item = tlv::TlvItem { tag: 0, value: inp.clone() };
        Ok(GetYearDayScheduleResponse {
                year_day_index: item.get_int(&[0]).map(|v| v as u8),
                user_index: item.get_int(&[1]).map(|v| v as u16),
                status: item.get_int(&[2]).map(|v| v as u8),
                local_start_time: item.get_int(&[3]),
                local_end_time: item.get_int(&[4]),
        })
    } else {
        Err(anyhow::anyhow!("Expected struct fields"))
    }
}

/// Decode GetHolidayScheduleResponse command response (12)
pub fn decode_get_holiday_schedule_response(inp: &tlv::TlvItemValue) -> anyhow::Result<GetHolidayScheduleResponse> {
    if let tlv::TlvItemValue::List(_fields) = inp {
        let item = tlv::TlvItem { tag: 0, value: inp.clone() };
        Ok(GetHolidayScheduleResponse {
                holiday_index: item.get_int(&[0]).map(|v| v as u8),
                status: item.get_int(&[1]).map(|v| v as u8),
                local_start_time: item.get_int(&[2]),
                local_end_time: item.get_int(&[3]),
                operating_mode: item.get_int(&[4]).and_then(|v| OperatingMode::from_u8(v as u8)),
        })
    } else {
        Err(anyhow::anyhow!("Expected struct fields"))
    }
}

/// Decode GetUserResponse command response (1C)
pub fn decode_get_user_response(inp: &tlv::TlvItemValue) -> anyhow::Result<GetUserResponse> {
    if let tlv::TlvItemValue::List(_fields) = inp {
        let item = tlv::TlvItem { tag: 0, value: inp.clone() };
        Ok(GetUserResponse {
                user_index: item.get_int(&[0]).map(|v| v as u16),
                user_name: item.get_string_owned(&[1]),
                user_unique_id: item.get_int(&[2]).map(|v| v as u32),
                user_status: item.get_int(&[3]).and_then(|v| UserStatus::from_u8(v as u8)),
                user_type: item.get_int(&[4]).and_then(|v| UserType::from_u8(v as u8)),
                credential_rule: item.get_int(&[5]).and_then(|v| CredentialRule::from_u8(v as u8)),
                credentials: {
                    if let Some(tlv::TlvItemValue::List(l)) = item.get(&[6]) {
                        let mut items = Vec::new();
                        for list_item in l {
                            items.push(Credential {
                credential_type: list_item.get_int(&[0]).and_then(|v| CredentialType::from_u8(v as u8)),
                credential_index: list_item.get_int(&[1]).map(|v| v as u16),
                            });
                        }
                        Some(items)
                    } else {
                        None
                    }
                },
                creator_fabric_index: item.get_int(&[7]).map(|v| v as u8),
                last_modified_fabric_index: item.get_int(&[8]).map(|v| v as u8),
                next_user_index: item.get_int(&[9]).map(|v| v as u16),
        })
    } else {
        Err(anyhow::anyhow!("Expected struct fields"))
    }
}

/// Decode SetCredentialResponse command response (23)
pub fn decode_set_credential_response(inp: &tlv::TlvItemValue) -> anyhow::Result<SetCredentialResponse> {
    if let tlv::TlvItemValue::List(_fields) = inp {
        let item = tlv::TlvItem { tag: 0, value: inp.clone() };
        Ok(SetCredentialResponse {
                status: item.get_int(&[0]).map(|v| v as u8),
                user_index: item.get_int(&[1]).map(|v| v as u16),
                next_credential_index: item.get_int(&[2]).map(|v| v as u16),
        })
    } else {
        Err(anyhow::anyhow!("Expected struct fields"))
    }
}

/// Decode GetCredentialStatusResponse command response (25)
pub fn decode_get_credential_status_response(inp: &tlv::TlvItemValue) -> anyhow::Result<GetCredentialStatusResponse> {
    if let tlv::TlvItemValue::List(_fields) = inp {
        let item = tlv::TlvItem { tag: 0, value: inp.clone() };
        Ok(GetCredentialStatusResponse {
                credential_exists: item.get_bool(&[0]),
                user_index: item.get_int(&[1]).map(|v| v as u16),
                creator_fabric_index: item.get_int(&[2]).map(|v| v as u8),
                last_modified_fabric_index: item.get_int(&[3]).map(|v| v as u8),
                next_credential_index: item.get_int(&[4]).map(|v| v as u16),
                credential_data: item.get_octet_string_owned(&[5]),
        })
    } else {
        Err(anyhow::anyhow!("Expected struct fields"))
    }
}

// Typed facade (invokes + reads)

/// Invoke `LockDoor` command on cluster `Door Lock`.
pub async fn lock_door(conn: &crate::controller::Connection, endpoint: u16, pin_code: Option<Vec<u8>>) -> anyhow::Result<()> {
    conn.invoke_request(endpoint, crate::clusters::defs::CLUSTER_ID_DOOR_LOCK, crate::clusters::defs::CLUSTER_DOOR_LOCK_CMD_ID_LOCKDOOR, &encode_lock_door(pin_code)?).await?;
    Ok(())
}

/// Invoke `UnlockDoor` command on cluster `Door Lock`.
pub async fn unlock_door(conn: &crate::controller::Connection, endpoint: u16, pin_code: Option<Vec<u8>>) -> anyhow::Result<()> {
    conn.invoke_request(endpoint, crate::clusters::defs::CLUSTER_ID_DOOR_LOCK, crate::clusters::defs::CLUSTER_DOOR_LOCK_CMD_ID_UNLOCKDOOR, &encode_unlock_door(pin_code)?).await?;
    Ok(())
}

/// Invoke `Toggle` command on cluster `Door Lock`.
pub async fn toggle(conn: &crate::controller::Connection, endpoint: u16) -> anyhow::Result<()> {
    conn.invoke_request(endpoint, crate::clusters::defs::CLUSTER_ID_DOOR_LOCK, crate::clusters::defs::CLUSTER_DOOR_LOCK_CMD_ID_TOGGLE, &[]).await?;
    Ok(())
}

/// Invoke `UnlockWithTimeout` command on cluster `Door Lock`.
pub async fn unlock_with_timeout(conn: &crate::controller::Connection, endpoint: u16, timeout: u16, pin_code: Option<Vec<u8>>) -> anyhow::Result<()> {
    conn.invoke_request(endpoint, crate::clusters::defs::CLUSTER_ID_DOOR_LOCK, crate::clusters::defs::CLUSTER_DOOR_LOCK_CMD_ID_UNLOCKWITHTIMEOUT, &encode_unlock_with_timeout(timeout, pin_code)?).await?;
    Ok(())
}

/// Invoke `SetWeekDaySchedule` command on cluster `Door Lock`.
pub async fn set_week_day_schedule(conn: &crate::controller::Connection, endpoint: u16, week_day_index: u8, user_index: u16, days_mask: DaysMask, start_hour: u8, start_minute: u8, end_hour: u8, end_minute: u8) -> anyhow::Result<()> {
    conn.invoke_request(endpoint, crate::clusters::defs::CLUSTER_ID_DOOR_LOCK, crate::clusters::defs::CLUSTER_DOOR_LOCK_CMD_ID_SETWEEKDAYSCHEDULE, &encode_set_week_day_schedule(week_day_index, user_index, days_mask, start_hour, start_minute, end_hour, end_minute)?).await?;
    Ok(())
}

/// Invoke `GetWeekDaySchedule` command on cluster `Door Lock`.
pub async fn get_week_day_schedule(conn: &crate::controller::Connection, endpoint: u16, week_day_index: u8, user_index: u16) -> anyhow::Result<GetWeekDayScheduleResponse> {
    let tlv = conn.invoke_request2(endpoint, crate::clusters::defs::CLUSTER_ID_DOOR_LOCK, crate::clusters::defs::CLUSTER_DOOR_LOCK_CMD_ID_GETWEEKDAYSCHEDULE, &encode_get_week_day_schedule(week_day_index, user_index)?).await?;
    decode_get_week_day_schedule_response(&tlv)
}

/// Invoke `ClearWeekDaySchedule` command on cluster `Door Lock`.
pub async fn clear_week_day_schedule(conn: &crate::controller::Connection, endpoint: u16, week_day_index: u8, user_index: u16) -> anyhow::Result<()> {
    conn.invoke_request(endpoint, crate::clusters::defs::CLUSTER_ID_DOOR_LOCK, crate::clusters::defs::CLUSTER_DOOR_LOCK_CMD_ID_CLEARWEEKDAYSCHEDULE, &encode_clear_week_day_schedule(week_day_index, user_index)?).await?;
    Ok(())
}

/// Invoke `SetYearDaySchedule` command on cluster `Door Lock`.
pub async fn set_year_day_schedule(conn: &crate::controller::Connection, endpoint: u16, year_day_index: u8, user_index: u16, local_start_time: u64, local_end_time: u64) -> anyhow::Result<()> {
    conn.invoke_request(endpoint, crate::clusters::defs::CLUSTER_ID_DOOR_LOCK, crate::clusters::defs::CLUSTER_DOOR_LOCK_CMD_ID_SETYEARDAYSCHEDULE, &encode_set_year_day_schedule(year_day_index, user_index, local_start_time, local_end_time)?).await?;
    Ok(())
}

/// Invoke `GetYearDaySchedule` command on cluster `Door Lock`.
pub async fn get_year_day_schedule(conn: &crate::controller::Connection, endpoint: u16, year_day_index: u8, user_index: u16) -> anyhow::Result<GetYearDayScheduleResponse> {
    let tlv = conn.invoke_request2(endpoint, crate::clusters::defs::CLUSTER_ID_DOOR_LOCK, crate::clusters::defs::CLUSTER_DOOR_LOCK_CMD_ID_GETYEARDAYSCHEDULE, &encode_get_year_day_schedule(year_day_index, user_index)?).await?;
    decode_get_year_day_schedule_response(&tlv)
}

/// Invoke `ClearYearDaySchedule` command on cluster `Door Lock`.
pub async fn clear_year_day_schedule(conn: &crate::controller::Connection, endpoint: u16, year_day_index: u8, user_index: u16) -> anyhow::Result<()> {
    conn.invoke_request(endpoint, crate::clusters::defs::CLUSTER_ID_DOOR_LOCK, crate::clusters::defs::CLUSTER_DOOR_LOCK_CMD_ID_CLEARYEARDAYSCHEDULE, &encode_clear_year_day_schedule(year_day_index, user_index)?).await?;
    Ok(())
}

/// Invoke `SetHolidaySchedule` command on cluster `Door Lock`.
pub async fn set_holiday_schedule(conn: &crate::controller::Connection, endpoint: u16, holiday_index: u8, local_start_time: u64, local_end_time: u64, operating_mode: OperatingMode) -> anyhow::Result<()> {
    conn.invoke_request(endpoint, crate::clusters::defs::CLUSTER_ID_DOOR_LOCK, crate::clusters::defs::CLUSTER_DOOR_LOCK_CMD_ID_SETHOLIDAYSCHEDULE, &encode_set_holiday_schedule(holiday_index, local_start_time, local_end_time, operating_mode)?).await?;
    Ok(())
}

/// Invoke `GetHolidaySchedule` command on cluster `Door Lock`.
pub async fn get_holiday_schedule(conn: &crate::controller::Connection, endpoint: u16, holiday_index: u8) -> anyhow::Result<GetHolidayScheduleResponse> {
    let tlv = conn.invoke_request2(endpoint, crate::clusters::defs::CLUSTER_ID_DOOR_LOCK, crate::clusters::defs::CLUSTER_DOOR_LOCK_CMD_ID_GETHOLIDAYSCHEDULE, &encode_get_holiday_schedule(holiday_index)?).await?;
    decode_get_holiday_schedule_response(&tlv)
}

/// Invoke `ClearHolidaySchedule` command on cluster `Door Lock`.
pub async fn clear_holiday_schedule(conn: &crate::controller::Connection, endpoint: u16, holiday_index: u8) -> anyhow::Result<()> {
    conn.invoke_request(endpoint, crate::clusters::defs::CLUSTER_ID_DOOR_LOCK, crate::clusters::defs::CLUSTER_DOOR_LOCK_CMD_ID_CLEARHOLIDAYSCHEDULE, &encode_clear_holiday_schedule(holiday_index)?).await?;
    Ok(())
}

/// Invoke `SetUser` command on cluster `Door Lock`.
pub async fn set_user(conn: &crate::controller::Connection, endpoint: u16, operation_type: DataOperationType, user_index: u16, user_name: Option<String>, user_unique_id: Option<u32>, user_status: Option<UserStatus>, user_type: Option<UserType>, credential_rule: Option<CredentialRule>) -> anyhow::Result<()> {
    conn.invoke_request(endpoint, crate::clusters::defs::CLUSTER_ID_DOOR_LOCK, crate::clusters::defs::CLUSTER_DOOR_LOCK_CMD_ID_SETUSER, &encode_set_user(operation_type, user_index, user_name, user_unique_id, user_status, user_type, credential_rule)?).await?;
    Ok(())
}

/// Invoke `GetUser` command on cluster `Door Lock`.
pub async fn get_user(conn: &crate::controller::Connection, endpoint: u16, user_index: u16) -> anyhow::Result<GetUserResponse> {
    let tlv = conn.invoke_request2(endpoint, crate::clusters::defs::CLUSTER_ID_DOOR_LOCK, crate::clusters::defs::CLUSTER_DOOR_LOCK_CMD_ID_GETUSER, &encode_get_user(user_index)?).await?;
    decode_get_user_response(&tlv)
}

/// Invoke `ClearUser` command on cluster `Door Lock`.
pub async fn clear_user(conn: &crate::controller::Connection, endpoint: u16, user_index: u16) -> anyhow::Result<()> {
    conn.invoke_request(endpoint, crate::clusters::defs::CLUSTER_ID_DOOR_LOCK, crate::clusters::defs::CLUSTER_DOOR_LOCK_CMD_ID_CLEARUSER, &encode_clear_user(user_index)?).await?;
    Ok(())
}

/// Invoke `SetCredential` command on cluster `Door Lock`.
pub async fn set_credential(conn: &crate::controller::Connection, endpoint: u16, operation_type: DataOperationType, credential: Credential, credential_data: Vec<u8>, user_index: Option<u16>, user_status: Option<UserStatus>, user_type: Option<UserType>) -> anyhow::Result<SetCredentialResponse> {
    let tlv = conn.invoke_request2(endpoint, crate::clusters::defs::CLUSTER_ID_DOOR_LOCK, crate::clusters::defs::CLUSTER_DOOR_LOCK_CMD_ID_SETCREDENTIAL, &encode_set_credential(operation_type, credential, credential_data, user_index, user_status, user_type)?).await?;
    decode_set_credential_response(&tlv)
}

/// Invoke `GetCredentialStatus` command on cluster `Door Lock`.
pub async fn get_credential_status(conn: &crate::controller::Connection, endpoint: u16, credential: Credential) -> anyhow::Result<GetCredentialStatusResponse> {
    let tlv = conn.invoke_request2(endpoint, crate::clusters::defs::CLUSTER_ID_DOOR_LOCK, crate::clusters::defs::CLUSTER_DOOR_LOCK_CMD_ID_GETCREDENTIALSTATUS, &encode_get_credential_status(credential)?).await?;
    decode_get_credential_status_response(&tlv)
}

/// Invoke `ClearCredential` command on cluster `Door Lock`.
pub async fn clear_credential(conn: &crate::controller::Connection, endpoint: u16, credential: Option<Credential>) -> anyhow::Result<()> {
    conn.invoke_request(endpoint, crate::clusters::defs::CLUSTER_ID_DOOR_LOCK, crate::clusters::defs::CLUSTER_DOOR_LOCK_CMD_ID_CLEARCREDENTIAL, &encode_clear_credential(credential)?).await?;
    Ok(())
}

/// Invoke `UnboltDoor` command on cluster `Door Lock`.
pub async fn unbolt_door(conn: &crate::controller::Connection, endpoint: u16, pin_code: Option<Vec<u8>>) -> anyhow::Result<()> {
    conn.invoke_request(endpoint, crate::clusters::defs::CLUSTER_ID_DOOR_LOCK, crate::clusters::defs::CLUSTER_DOOR_LOCK_CMD_ID_UNBOLTDOOR, &encode_unbolt_door(pin_code)?).await?;
    Ok(())
}

/// Invoke `SetAliroReaderConfig` command on cluster `Door Lock`.
pub async fn set_aliro_reader_config(conn: &crate::controller::Connection, endpoint: u16, signing_key: Vec<u8>, verification_key: Vec<u8>, group_identifier: Vec<u8>, group_resolving_key: Vec<u8>) -> anyhow::Result<()> {
    conn.invoke_request(endpoint, crate::clusters::defs::CLUSTER_ID_DOOR_LOCK, crate::clusters::defs::CLUSTER_DOOR_LOCK_CMD_ID_SETALIROREADERCONFIG, &encode_set_aliro_reader_config(signing_key, verification_key, group_identifier, group_resolving_key)?).await?;
    Ok(())
}

/// Invoke `ClearAliroReaderConfig` command on cluster `Door Lock`.
pub async fn clear_aliro_reader_config(conn: &crate::controller::Connection, endpoint: u16) -> anyhow::Result<()> {
    conn.invoke_request(endpoint, crate::clusters::defs::CLUSTER_ID_DOOR_LOCK, crate::clusters::defs::CLUSTER_DOOR_LOCK_CMD_ID_CLEARALIROREADERCONFIG, &[]).await?;
    Ok(())
}

/// Read `LockState` attribute from cluster `Door Lock`.
pub async fn read_lock_state(conn: &crate::controller::Connection, endpoint: u16) -> anyhow::Result<Option<LockState>> {
    let tlv = conn.read_request2(endpoint, crate::clusters::defs::CLUSTER_ID_DOOR_LOCK, crate::clusters::defs::CLUSTER_DOOR_LOCK_ATTR_ID_LOCKSTATE).await?;
    decode_lock_state(&tlv)
}

/// Read `LockType` attribute from cluster `Door Lock`.
pub async fn read_lock_type(conn: &crate::controller::Connection, endpoint: u16) -> anyhow::Result<LockType> {
    let tlv = conn.read_request2(endpoint, crate::clusters::defs::CLUSTER_ID_DOOR_LOCK, crate::clusters::defs::CLUSTER_DOOR_LOCK_ATTR_ID_LOCKTYPE).await?;
    decode_lock_type(&tlv)
}

/// Read `ActuatorEnabled` attribute from cluster `Door Lock`.
pub async fn read_actuator_enabled(conn: &crate::controller::Connection, endpoint: u16) -> anyhow::Result<bool> {
    let tlv = conn.read_request2(endpoint, crate::clusters::defs::CLUSTER_ID_DOOR_LOCK, crate::clusters::defs::CLUSTER_DOOR_LOCK_ATTR_ID_ACTUATORENABLED).await?;
    decode_actuator_enabled(&tlv)
}

/// Read `DoorState` attribute from cluster `Door Lock`.
pub async fn read_door_state(conn: &crate::controller::Connection, endpoint: u16) -> anyhow::Result<Option<DoorState>> {
    let tlv = conn.read_request2(endpoint, crate::clusters::defs::CLUSTER_ID_DOOR_LOCK, crate::clusters::defs::CLUSTER_DOOR_LOCK_ATTR_ID_DOORSTATE).await?;
    decode_door_state(&tlv)
}

/// Read `DoorOpenEvents` attribute from cluster `Door Lock`.
pub async fn read_door_open_events(conn: &crate::controller::Connection, endpoint: u16) -> anyhow::Result<u32> {
    let tlv = conn.read_request2(endpoint, crate::clusters::defs::CLUSTER_ID_DOOR_LOCK, crate::clusters::defs::CLUSTER_DOOR_LOCK_ATTR_ID_DOOROPENEVENTS).await?;
    decode_door_open_events(&tlv)
}

/// Read `DoorClosedEvents` attribute from cluster `Door Lock`.
pub async fn read_door_closed_events(conn: &crate::controller::Connection, endpoint: u16) -> anyhow::Result<u32> {
    let tlv = conn.read_request2(endpoint, crate::clusters::defs::CLUSTER_ID_DOOR_LOCK, crate::clusters::defs::CLUSTER_DOOR_LOCK_ATTR_ID_DOORCLOSEDEVENTS).await?;
    decode_door_closed_events(&tlv)
}

/// Read `OpenPeriod` attribute from cluster `Door Lock`.
pub async fn read_open_period(conn: &crate::controller::Connection, endpoint: u16) -> anyhow::Result<u16> {
    let tlv = conn.read_request2(endpoint, crate::clusters::defs::CLUSTER_ID_DOOR_LOCK, crate::clusters::defs::CLUSTER_DOOR_LOCK_ATTR_ID_OPENPERIOD).await?;
    decode_open_period(&tlv)
}

/// Read `NumberOfTotalUsersSupported` attribute from cluster `Door Lock`.
pub async fn read_number_of_total_users_supported(conn: &crate::controller::Connection, endpoint: u16) -> anyhow::Result<u16> {
    let tlv = conn.read_request2(endpoint, crate::clusters::defs::CLUSTER_ID_DOOR_LOCK, crate::clusters::defs::CLUSTER_DOOR_LOCK_ATTR_ID_NUMBEROFTOTALUSERSSUPPORTED).await?;
    decode_number_of_total_users_supported(&tlv)
}

/// Read `NumberOfPINUsersSupported` attribute from cluster `Door Lock`.
pub async fn read_number_of_pin_users_supported(conn: &crate::controller::Connection, endpoint: u16) -> anyhow::Result<u16> {
    let tlv = conn.read_request2(endpoint, crate::clusters::defs::CLUSTER_ID_DOOR_LOCK, crate::clusters::defs::CLUSTER_DOOR_LOCK_ATTR_ID_NUMBEROFPINUSERSSUPPORTED).await?;
    decode_number_of_pin_users_supported(&tlv)
}

/// Read `NumberOfRFIDUsersSupported` attribute from cluster `Door Lock`.
pub async fn read_number_of_rfid_users_supported(conn: &crate::controller::Connection, endpoint: u16) -> anyhow::Result<u16> {
    let tlv = conn.read_request2(endpoint, crate::clusters::defs::CLUSTER_ID_DOOR_LOCK, crate::clusters::defs::CLUSTER_DOOR_LOCK_ATTR_ID_NUMBEROFRFIDUSERSSUPPORTED).await?;
    decode_number_of_rfid_users_supported(&tlv)
}

/// Read `NumberOfWeekDaySchedulesSupportedPerUser` attribute from cluster `Door Lock`.
pub async fn read_number_of_week_day_schedules_supported_per_user(conn: &crate::controller::Connection, endpoint: u16) -> anyhow::Result<u8> {
    let tlv = conn.read_request2(endpoint, crate::clusters::defs::CLUSTER_ID_DOOR_LOCK, crate::clusters::defs::CLUSTER_DOOR_LOCK_ATTR_ID_NUMBEROFWEEKDAYSCHEDULESSUPPORTEDPERUSER).await?;
    decode_number_of_week_day_schedules_supported_per_user(&tlv)
}

/// Read `NumberOfYearDaySchedulesSupportedPerUser` attribute from cluster `Door Lock`.
pub async fn read_number_of_year_day_schedules_supported_per_user(conn: &crate::controller::Connection, endpoint: u16) -> anyhow::Result<u8> {
    let tlv = conn.read_request2(endpoint, crate::clusters::defs::CLUSTER_ID_DOOR_LOCK, crate::clusters::defs::CLUSTER_DOOR_LOCK_ATTR_ID_NUMBEROFYEARDAYSCHEDULESSUPPORTEDPERUSER).await?;
    decode_number_of_year_day_schedules_supported_per_user(&tlv)
}

/// Read `NumberOfHolidaySchedulesSupported` attribute from cluster `Door Lock`.
pub async fn read_number_of_holiday_schedules_supported(conn: &crate::controller::Connection, endpoint: u16) -> anyhow::Result<u8> {
    let tlv = conn.read_request2(endpoint, crate::clusters::defs::CLUSTER_ID_DOOR_LOCK, crate::clusters::defs::CLUSTER_DOOR_LOCK_ATTR_ID_NUMBEROFHOLIDAYSCHEDULESSUPPORTED).await?;
    decode_number_of_holiday_schedules_supported(&tlv)
}

/// Read `MaxPINCodeLength` attribute from cluster `Door Lock`.
pub async fn read_max_pin_code_length(conn: &crate::controller::Connection, endpoint: u16) -> anyhow::Result<u8> {
    let tlv = conn.read_request2(endpoint, crate::clusters::defs::CLUSTER_ID_DOOR_LOCK, crate::clusters::defs::CLUSTER_DOOR_LOCK_ATTR_ID_MAXPINCODELENGTH).await?;
    decode_max_pin_code_length(&tlv)
}

/// Read `MinPINCodeLength` attribute from cluster `Door Lock`.
pub async fn read_min_pin_code_length(conn: &crate::controller::Connection, endpoint: u16) -> anyhow::Result<u8> {
    let tlv = conn.read_request2(endpoint, crate::clusters::defs::CLUSTER_ID_DOOR_LOCK, crate::clusters::defs::CLUSTER_DOOR_LOCK_ATTR_ID_MINPINCODELENGTH).await?;
    decode_min_pin_code_length(&tlv)
}

/// Read `MaxRFIDCodeLength` attribute from cluster `Door Lock`.
pub async fn read_max_rfid_code_length(conn: &crate::controller::Connection, endpoint: u16) -> anyhow::Result<u8> {
    let tlv = conn.read_request2(endpoint, crate::clusters::defs::CLUSTER_ID_DOOR_LOCK, crate::clusters::defs::CLUSTER_DOOR_LOCK_ATTR_ID_MAXRFIDCODELENGTH).await?;
    decode_max_rfid_code_length(&tlv)
}

/// Read `MinRFIDCodeLength` attribute from cluster `Door Lock`.
pub async fn read_min_rfid_code_length(conn: &crate::controller::Connection, endpoint: u16) -> anyhow::Result<u8> {
    let tlv = conn.read_request2(endpoint, crate::clusters::defs::CLUSTER_ID_DOOR_LOCK, crate::clusters::defs::CLUSTER_DOOR_LOCK_ATTR_ID_MINRFIDCODELENGTH).await?;
    decode_min_rfid_code_length(&tlv)
}

/// Read `CredentialRulesSupport` attribute from cluster `Door Lock`.
pub async fn read_credential_rules_support(conn: &crate::controller::Connection, endpoint: u16) -> anyhow::Result<CredentialRules> {
    let tlv = conn.read_request2(endpoint, crate::clusters::defs::CLUSTER_ID_DOOR_LOCK, crate::clusters::defs::CLUSTER_DOOR_LOCK_ATTR_ID_CREDENTIALRULESSUPPORT).await?;
    decode_credential_rules_support(&tlv)
}

/// Read `NumberOfCredentialsSupportedPerUser` attribute from cluster `Door Lock`.
pub async fn read_number_of_credentials_supported_per_user(conn: &crate::controller::Connection, endpoint: u16) -> anyhow::Result<u8> {
    let tlv = conn.read_request2(endpoint, crate::clusters::defs::CLUSTER_ID_DOOR_LOCK, crate::clusters::defs::CLUSTER_DOOR_LOCK_ATTR_ID_NUMBEROFCREDENTIALSSUPPORTEDPERUSER).await?;
    decode_number_of_credentials_supported_per_user(&tlv)
}

/// Read `Language` attribute from cluster `Door Lock`.
pub async fn read_language(conn: &crate::controller::Connection, endpoint: u16) -> anyhow::Result<String> {
    let tlv = conn.read_request2(endpoint, crate::clusters::defs::CLUSTER_ID_DOOR_LOCK, crate::clusters::defs::CLUSTER_DOOR_LOCK_ATTR_ID_LANGUAGE).await?;
    decode_language(&tlv)
}

/// Read `LEDSettings` attribute from cluster `Door Lock`.
pub async fn read_led_settings(conn: &crate::controller::Connection, endpoint: u16) -> anyhow::Result<LEDSetting> {
    let tlv = conn.read_request2(endpoint, crate::clusters::defs::CLUSTER_ID_DOOR_LOCK, crate::clusters::defs::CLUSTER_DOOR_LOCK_ATTR_ID_LEDSETTINGS).await?;
    decode_led_settings(&tlv)
}

/// Read `AutoRelockTime` attribute from cluster `Door Lock`.
pub async fn read_auto_relock_time(conn: &crate::controller::Connection, endpoint: u16) -> anyhow::Result<u32> {
    let tlv = conn.read_request2(endpoint, crate::clusters::defs::CLUSTER_ID_DOOR_LOCK, crate::clusters::defs::CLUSTER_DOOR_LOCK_ATTR_ID_AUTORELOCKTIME).await?;
    decode_auto_relock_time(&tlv)
}

/// Read `SoundVolume` attribute from cluster `Door Lock`.
pub async fn read_sound_volume(conn: &crate::controller::Connection, endpoint: u16) -> anyhow::Result<SoundVolume> {
    let tlv = conn.read_request2(endpoint, crate::clusters::defs::CLUSTER_ID_DOOR_LOCK, crate::clusters::defs::CLUSTER_DOOR_LOCK_ATTR_ID_SOUNDVOLUME).await?;
    decode_sound_volume(&tlv)
}

/// Read `OperatingMode` attribute from cluster `Door Lock`.
pub async fn read_operating_mode(conn: &crate::controller::Connection, endpoint: u16) -> anyhow::Result<OperatingMode> {
    let tlv = conn.read_request2(endpoint, crate::clusters::defs::CLUSTER_ID_DOOR_LOCK, crate::clusters::defs::CLUSTER_DOOR_LOCK_ATTR_ID_OPERATINGMODE).await?;
    decode_operating_mode(&tlv)
}

/// Read `SupportedOperatingModes` attribute from cluster `Door Lock`.
pub async fn read_supported_operating_modes(conn: &crate::controller::Connection, endpoint: u16) -> anyhow::Result<OperatingModes> {
    let tlv = conn.read_request2(endpoint, crate::clusters::defs::CLUSTER_ID_DOOR_LOCK, crate::clusters::defs::CLUSTER_DOOR_LOCK_ATTR_ID_SUPPORTEDOPERATINGMODES).await?;
    decode_supported_operating_modes(&tlv)
}

/// Read `DefaultConfigurationRegister` attribute from cluster `Door Lock`.
pub async fn read_default_configuration_register(conn: &crate::controller::Connection, endpoint: u16) -> anyhow::Result<ConfigurationRegister> {
    let tlv = conn.read_request2(endpoint, crate::clusters::defs::CLUSTER_ID_DOOR_LOCK, crate::clusters::defs::CLUSTER_DOOR_LOCK_ATTR_ID_DEFAULTCONFIGURATIONREGISTER).await?;
    decode_default_configuration_register(&tlv)
}

/// Read `EnableLocalProgramming` attribute from cluster `Door Lock`.
pub async fn read_enable_local_programming(conn: &crate::controller::Connection, endpoint: u16) -> anyhow::Result<bool> {
    let tlv = conn.read_request2(endpoint, crate::clusters::defs::CLUSTER_ID_DOOR_LOCK, crate::clusters::defs::CLUSTER_DOOR_LOCK_ATTR_ID_ENABLELOCALPROGRAMMING).await?;
    decode_enable_local_programming(&tlv)
}

/// Read `EnableOneTouchLocking` attribute from cluster `Door Lock`.
pub async fn read_enable_one_touch_locking(conn: &crate::controller::Connection, endpoint: u16) -> anyhow::Result<bool> {
    let tlv = conn.read_request2(endpoint, crate::clusters::defs::CLUSTER_ID_DOOR_LOCK, crate::clusters::defs::CLUSTER_DOOR_LOCK_ATTR_ID_ENABLEONETOUCHLOCKING).await?;
    decode_enable_one_touch_locking(&tlv)
}

/// Read `EnableInsideStatusLED` attribute from cluster `Door Lock`.
pub async fn read_enable_inside_status_led(conn: &crate::controller::Connection, endpoint: u16) -> anyhow::Result<bool> {
    let tlv = conn.read_request2(endpoint, crate::clusters::defs::CLUSTER_ID_DOOR_LOCK, crate::clusters::defs::CLUSTER_DOOR_LOCK_ATTR_ID_ENABLEINSIDESTATUSLED).await?;
    decode_enable_inside_status_led(&tlv)
}

/// Read `EnablePrivacyModeButton` attribute from cluster `Door Lock`.
pub async fn read_enable_privacy_mode_button(conn: &crate::controller::Connection, endpoint: u16) -> anyhow::Result<bool> {
    let tlv = conn.read_request2(endpoint, crate::clusters::defs::CLUSTER_ID_DOOR_LOCK, crate::clusters::defs::CLUSTER_DOOR_LOCK_ATTR_ID_ENABLEPRIVACYMODEBUTTON).await?;
    decode_enable_privacy_mode_button(&tlv)
}

/// Read `LocalProgrammingFeatures` attribute from cluster `Door Lock`.
pub async fn read_local_programming_features(conn: &crate::controller::Connection, endpoint: u16) -> anyhow::Result<LocalProgrammingFeatures> {
    let tlv = conn.read_request2(endpoint, crate::clusters::defs::CLUSTER_ID_DOOR_LOCK, crate::clusters::defs::CLUSTER_DOOR_LOCK_ATTR_ID_LOCALPROGRAMMINGFEATURES).await?;
    decode_local_programming_features(&tlv)
}

/// Read `WrongCodeEntryLimit` attribute from cluster `Door Lock`.
pub async fn read_wrong_code_entry_limit(conn: &crate::controller::Connection, endpoint: u16) -> anyhow::Result<u8> {
    let tlv = conn.read_request2(endpoint, crate::clusters::defs::CLUSTER_ID_DOOR_LOCK, crate::clusters::defs::CLUSTER_DOOR_LOCK_ATTR_ID_WRONGCODEENTRYLIMIT).await?;
    decode_wrong_code_entry_limit(&tlv)
}

/// Read `UserCodeTemporaryDisableTime` attribute from cluster `Door Lock`.
pub async fn read_user_code_temporary_disable_time(conn: &crate::controller::Connection, endpoint: u16) -> anyhow::Result<u8> {
    let tlv = conn.read_request2(endpoint, crate::clusters::defs::CLUSTER_ID_DOOR_LOCK, crate::clusters::defs::CLUSTER_DOOR_LOCK_ATTR_ID_USERCODETEMPORARYDISABLETIME).await?;
    decode_user_code_temporary_disable_time(&tlv)
}

/// Read `SendPINOverTheAir` attribute from cluster `Door Lock`.
pub async fn read_send_pin_over_the_air(conn: &crate::controller::Connection, endpoint: u16) -> anyhow::Result<bool> {
    let tlv = conn.read_request2(endpoint, crate::clusters::defs::CLUSTER_ID_DOOR_LOCK, crate::clusters::defs::CLUSTER_DOOR_LOCK_ATTR_ID_SENDPINOVERTHEAIR).await?;
    decode_send_pin_over_the_air(&tlv)
}

/// Read `RequirePINforRemoteOperation` attribute from cluster `Door Lock`.
pub async fn read_require_pinfor_remote_operation(conn: &crate::controller::Connection, endpoint: u16) -> anyhow::Result<bool> {
    let tlv = conn.read_request2(endpoint, crate::clusters::defs::CLUSTER_ID_DOOR_LOCK, crate::clusters::defs::CLUSTER_DOOR_LOCK_ATTR_ID_REQUIREPINFORREMOTEOPERATION).await?;
    decode_require_pinfor_remote_operation(&tlv)
}

/// Read `SecurityLevel` attribute from cluster `Door Lock`.
pub async fn read_security_level(conn: &crate::controller::Connection, endpoint: u16) -> anyhow::Result<u8> {
    let tlv = conn.read_request2(endpoint, crate::clusters::defs::CLUSTER_ID_DOOR_LOCK, crate::clusters::defs::CLUSTER_DOOR_LOCK_ATTR_ID_SECURITYLEVEL).await?;
    decode_security_level(&tlv)
}

/// Read `ExpiringUserTimeout` attribute from cluster `Door Lock`.
pub async fn read_expiring_user_timeout(conn: &crate::controller::Connection, endpoint: u16) -> anyhow::Result<u16> {
    let tlv = conn.read_request2(endpoint, crate::clusters::defs::CLUSTER_ID_DOOR_LOCK, crate::clusters::defs::CLUSTER_DOOR_LOCK_ATTR_ID_EXPIRINGUSERTIMEOUT).await?;
    decode_expiring_user_timeout(&tlv)
}

/// Read `AliroReaderVerificationKey` attribute from cluster `Door Lock`.
pub async fn read_aliro_reader_verification_key(conn: &crate::controller::Connection, endpoint: u16) -> anyhow::Result<Option<Vec<u8>>> {
    let tlv = conn.read_request2(endpoint, crate::clusters::defs::CLUSTER_ID_DOOR_LOCK, crate::clusters::defs::CLUSTER_DOOR_LOCK_ATTR_ID_ALIROREADERVERIFICATIONKEY).await?;
    decode_aliro_reader_verification_key(&tlv)
}

/// Read `AliroReaderGroupIdentifier` attribute from cluster `Door Lock`.
pub async fn read_aliro_reader_group_identifier(conn: &crate::controller::Connection, endpoint: u16) -> anyhow::Result<Option<Vec<u8>>> {
    let tlv = conn.read_request2(endpoint, crate::clusters::defs::CLUSTER_ID_DOOR_LOCK, crate::clusters::defs::CLUSTER_DOOR_LOCK_ATTR_ID_ALIROREADERGROUPIDENTIFIER).await?;
    decode_aliro_reader_group_identifier(&tlv)
}

/// Read `AliroReaderGroupSubIdentifier` attribute from cluster `Door Lock`.
pub async fn read_aliro_reader_group_sub_identifier(conn: &crate::controller::Connection, endpoint: u16) -> anyhow::Result<Vec<u8>> {
    let tlv = conn.read_request2(endpoint, crate::clusters::defs::CLUSTER_ID_DOOR_LOCK, crate::clusters::defs::CLUSTER_DOOR_LOCK_ATTR_ID_ALIROREADERGROUPSUBIDENTIFIER).await?;
    decode_aliro_reader_group_sub_identifier(&tlv)
}

/// Read `AliroExpeditedTransactionSupportedProtocolVersions` attribute from cluster `Door Lock`.
pub async fn read_aliro_expedited_transaction_supported_protocol_versions(conn: &crate::controller::Connection, endpoint: u16) -> anyhow::Result<Vec<Vec<u8>>> {
    let tlv = conn.read_request2(endpoint, crate::clusters::defs::CLUSTER_ID_DOOR_LOCK, crate::clusters::defs::CLUSTER_DOOR_LOCK_ATTR_ID_ALIROEXPEDITEDTRANSACTIONSUPPORTEDPROTOCOLVERSIONS).await?;
    decode_aliro_expedited_transaction_supported_protocol_versions(&tlv)
}

/// Read `AliroGroupResolvingKey` attribute from cluster `Door Lock`.
pub async fn read_aliro_group_resolving_key(conn: &crate::controller::Connection, endpoint: u16) -> anyhow::Result<Option<Vec<u8>>> {
    let tlv = conn.read_request2(endpoint, crate::clusters::defs::CLUSTER_ID_DOOR_LOCK, crate::clusters::defs::CLUSTER_DOOR_LOCK_ATTR_ID_ALIROGROUPRESOLVINGKEY).await?;
    decode_aliro_group_resolving_key(&tlv)
}

/// Read `AliroSupportedBLEUWBProtocolVersions` attribute from cluster `Door Lock`.
pub async fn read_aliro_supported_bleuwb_protocol_versions(conn: &crate::controller::Connection, endpoint: u16) -> anyhow::Result<Vec<Vec<u8>>> {
    let tlv = conn.read_request2(endpoint, crate::clusters::defs::CLUSTER_ID_DOOR_LOCK, crate::clusters::defs::CLUSTER_DOOR_LOCK_ATTR_ID_ALIROSUPPORTEDBLEUWBPROTOCOLVERSIONS).await?;
    decode_aliro_supported_bleuwb_protocol_versions(&tlv)
}

/// Read `AliroBLEAdvertisingVersion` attribute from cluster `Door Lock`.
pub async fn read_aliro_ble_advertising_version(conn: &crate::controller::Connection, endpoint: u16) -> anyhow::Result<u8> {
    let tlv = conn.read_request2(endpoint, crate::clusters::defs::CLUSTER_ID_DOOR_LOCK, crate::clusters::defs::CLUSTER_DOOR_LOCK_ATTR_ID_ALIROBLEADVERTISINGVERSION).await?;
    decode_aliro_ble_advertising_version(&tlv)
}

/// Read `NumberOfAliroCredentialIssuerKeysSupported` attribute from cluster `Door Lock`.
pub async fn read_number_of_aliro_credential_issuer_keys_supported(conn: &crate::controller::Connection, endpoint: u16) -> anyhow::Result<u16> {
    let tlv = conn.read_request2(endpoint, crate::clusters::defs::CLUSTER_ID_DOOR_LOCK, crate::clusters::defs::CLUSTER_DOOR_LOCK_ATTR_ID_NUMBEROFALIROCREDENTIALISSUERKEYSSUPPORTED).await?;
    decode_number_of_aliro_credential_issuer_keys_supported(&tlv)
}

/// Read `NumberOfAliroEndpointKeysSupported` attribute from cluster `Door Lock`.
pub async fn read_number_of_aliro_endpoint_keys_supported(conn: &crate::controller::Connection, endpoint: u16) -> anyhow::Result<u16> {
    let tlv = conn.read_request2(endpoint, crate::clusters::defs::CLUSTER_ID_DOOR_LOCK, crate::clusters::defs::CLUSTER_DOOR_LOCK_ATTR_ID_NUMBEROFALIROENDPOINTKEYSSUPPORTED).await?;
    decode_number_of_aliro_endpoint_keys_supported(&tlv)
}

#[derive(Debug, serde::Serialize)]
pub struct DoorLockAlarmEvent {
    pub alarm_code: Option<AlarmCode>,
}

#[derive(Debug, serde::Serialize)]
pub struct DoorStateChangeEvent {
    pub door_state: Option<DoorState>,
}

#[derive(Debug, serde::Serialize)]
pub struct LockOperationEvent {
    pub lock_operation_type: Option<LockOperationType>,
    pub operation_source: Option<OperationSource>,
    pub user_index: Option<u16>,
    pub fabric_index: Option<u8>,
    pub source_node: Option<u64>,
    pub credentials: Option<Vec<Credential>>,
}

#[derive(Debug, serde::Serialize)]
pub struct LockOperationErrorEvent {
    pub lock_operation_type: Option<LockOperationType>,
    pub operation_source: Option<OperationSource>,
    pub operation_error: Option<OperationError>,
    pub user_index: Option<u16>,
    pub fabric_index: Option<u8>,
    pub source_node: Option<u64>,
    pub credentials: Option<Vec<Credential>>,
}

#[derive(Debug, serde::Serialize)]
pub struct LockUserChangeEvent {
    pub lock_data_type: Option<LockDataType>,
    pub data_operation_type: Option<DataOperationType>,
    pub operation_source: Option<OperationSource>,
    pub user_index: Option<u16>,
    pub fabric_index: Option<u8>,
    pub source_node: Option<u64>,
    pub data_index: Option<u16>,
}

// Event decoders

/// Decode DoorLockAlarm event (0x00, priority: critical)
pub fn decode_door_lock_alarm_event(inp: &tlv::TlvItemValue) -> anyhow::Result<DoorLockAlarmEvent> {
    if let tlv::TlvItemValue::List(_fields) = inp {
        let item = tlv::TlvItem { tag: 0, value: inp.clone() };
        Ok(DoorLockAlarmEvent {
                                alarm_code: item.get_int(&[0]).and_then(|v| AlarmCode::from_u8(v as u8)),
        })
    } else {
        Err(anyhow::anyhow!("Expected struct fields"))
    }
}

/// Decode DoorStateChange event (0x01, priority: desc)
pub fn decode_door_state_change_event(inp: &tlv::TlvItemValue) -> anyhow::Result<DoorStateChangeEvent> {
    if let tlv::TlvItemValue::List(_fields) = inp {
        let item = tlv::TlvItem { tag: 0, value: inp.clone() };
        Ok(DoorStateChangeEvent {
                                door_state: item.get_int(&[0]).and_then(|v| DoorState::from_u8(v as u8)),
        })
    } else {
        Err(anyhow::anyhow!("Expected struct fields"))
    }
}

/// Decode LockOperation event (0x02, priority: desc)
pub fn decode_lock_operation_event(inp: &tlv::TlvItemValue) -> anyhow::Result<LockOperationEvent> {
    if let tlv::TlvItemValue::List(_fields) = inp {
        let item = tlv::TlvItem { tag: 0, value: inp.clone() };
        Ok(LockOperationEvent {
                                lock_operation_type: item.get_int(&[0]).and_then(|v| LockOperationType::from_u8(v as u8)),
                                operation_source: item.get_int(&[1]).and_then(|v| OperationSource::from_u8(v as u8)),
                                user_index: item.get_int(&[2]).map(|v| v as u16),
                                fabric_index: item.get_int(&[3]).map(|v| v as u8),
                                source_node: item.get_int(&[4]),
                                credentials: {
                    if let Some(tlv::TlvItemValue::List(l)) = item.get(&[5]) {
                        let mut items = Vec::new();
                        for list_item in l {
                            items.push(Credential {
                credential_type: list_item.get_int(&[0]).and_then(|v| CredentialType::from_u8(v as u8)),
                credential_index: list_item.get_int(&[1]).map(|v| v as u16),
                            });
                        }
                        Some(items)
                    } else {
                        None
                    }
                },
        })
    } else {
        Err(anyhow::anyhow!("Expected struct fields"))
    }
}

/// Decode LockOperationError event (0x03, priority: desc)
pub fn decode_lock_operation_error_event(inp: &tlv::TlvItemValue) -> anyhow::Result<LockOperationErrorEvent> {
    if let tlv::TlvItemValue::List(_fields) = inp {
        let item = tlv::TlvItem { tag: 0, value: inp.clone() };
        Ok(LockOperationErrorEvent {
                                lock_operation_type: item.get_int(&[0]).and_then(|v| LockOperationType::from_u8(v as u8)),
                                operation_source: item.get_int(&[1]).and_then(|v| OperationSource::from_u8(v as u8)),
                                operation_error: item.get_int(&[2]).and_then(|v| OperationError::from_u8(v as u8)),
                                user_index: item.get_int(&[3]).map(|v| v as u16),
                                fabric_index: item.get_int(&[4]).map(|v| v as u8),
                                source_node: item.get_int(&[5]),
                                credentials: {
                    if let Some(tlv::TlvItemValue::List(l)) = item.get(&[6]) {
                        let mut items = Vec::new();
                        for list_item in l {
                            items.push(Credential {
                credential_type: list_item.get_int(&[0]).and_then(|v| CredentialType::from_u8(v as u8)),
                credential_index: list_item.get_int(&[1]).map(|v| v as u16),
                            });
                        }
                        Some(items)
                    } else {
                        None
                    }
                },
        })
    } else {
        Err(anyhow::anyhow!("Expected struct fields"))
    }
}

/// Decode LockUserChange event (0x04, priority: info)
pub fn decode_lock_user_change_event(inp: &tlv::TlvItemValue) -> anyhow::Result<LockUserChangeEvent> {
    if let tlv::TlvItemValue::List(_fields) = inp {
        let item = tlv::TlvItem { tag: 0, value: inp.clone() };
        Ok(LockUserChangeEvent {
                                lock_data_type: item.get_int(&[0]).and_then(|v| LockDataType::from_u8(v as u8)),
                                data_operation_type: item.get_int(&[1]).and_then(|v| DataOperationType::from_u8(v as u8)),
                                operation_source: item.get_int(&[2]).and_then(|v| OperationSource::from_u8(v as u8)),
                                user_index: item.get_int(&[3]).map(|v| v as u16),
                                fabric_index: item.get_int(&[4]).map(|v| v as u8),
                                source_node: item.get_int(&[5]),
                                data_index: item.get_int(&[6]).map(|v| v as u16),
        })
    } else {
        Err(anyhow::anyhow!("Expected struct fields"))
    }
}