matter-clusters 0.3.0

//! PowerSource cluster (0x002F).
//! @generated by `cargo xtask codegen` — do not edit.

#![allow(
    clippy::all,
    clippy::pedantic,
    dead_code,
    unreachable_pub,
    unused_imports
)]

use crate::datatypes::SemanticTagStruct;
use crate::error::ClusterError;
use crate::types::Nullable;
use matter_codec::{ContainerKind, Element, Tag, TlvReader, TlvWriter, Value};

/// Cluster ID.
pub const CLUSTER_ID: u32 = 0x002F;
/// Cluster revision.
pub const CLUSTER_REVISION: u16 = 3;

/// Command IDs (requests and responses).
pub mod command_id {}

/// Attribute IDs (cluster-specific).
pub mod attribute_id {
    /// `Status`.
    pub const STATUS: u32 = 0x0000;
    /// `Order`.
    pub const ORDER: u32 = 0x0001;
    /// `Description`.
    pub const DESCRIPTION: u32 = 0x0002;
    /// `WiredAssessedInputVoltage`.
    pub const WIRED_ASSESSED_INPUT_VOLTAGE: u32 = 0x0003;
    /// `WiredAssessedInputFrequency`.
    pub const WIRED_ASSESSED_INPUT_FREQUENCY: u32 = 0x0004;
    /// `WiredCurrentType`.
    pub const WIRED_CURRENT_TYPE: u32 = 0x0005;
    /// `WiredAssessedCurrent`.
    pub const WIRED_ASSESSED_CURRENT: u32 = 0x0006;
    /// `WiredNominalVoltage`.
    pub const WIRED_NOMINAL_VOLTAGE: u32 = 0x0007;
    /// `WiredMaximumCurrent`.
    pub const WIRED_MAXIMUM_CURRENT: u32 = 0x0008;
    /// `WiredPresent`.
    pub const WIRED_PRESENT: u32 = 0x0009;
    /// `ActiveWiredFaults`.
    pub const ACTIVE_WIRED_FAULTS: u32 = 0x000A;
    /// `BatVoltage`.
    pub const BAT_VOLTAGE: u32 = 0x000B;
    /// `BatPercentRemaining`.
    pub const BAT_PERCENT_REMAINING: u32 = 0x000C;
    /// `BatTimeRemaining`.
    pub const BAT_TIME_REMAINING: u32 = 0x000D;
    /// `BatChargeLevel`.
    pub const BAT_CHARGE_LEVEL: u32 = 0x000E;
    /// `BatReplacementNeeded`.
    pub const BAT_REPLACEMENT_NEEDED: u32 = 0x000F;
    /// `BatReplaceability`.
    pub const BAT_REPLACEABILITY: u32 = 0x0010;
    /// `BatPresent`.
    pub const BAT_PRESENT: u32 = 0x0011;
    /// `ActiveBatFaults`.
    pub const ACTIVE_BAT_FAULTS: u32 = 0x0012;
    /// `BatReplacementDescription`.
    pub const BAT_REPLACEMENT_DESCRIPTION: u32 = 0x0013;
    /// `BatCommonDesignation`.
    pub const BAT_COMMON_DESIGNATION: u32 = 0x0014;
    /// `BatAnsiDesignation`.
    pub const BAT_ANSI_DESIGNATION: u32 = 0x0015;
    /// `BatIecDesignation`.
    pub const BAT_IEC_DESIGNATION: u32 = 0x0016;
    /// `BatApprovedChemistry`.
    pub const BAT_APPROVED_CHEMISTRY: u32 = 0x0017;
    /// `BatCapacity`.
    pub const BAT_CAPACITY: u32 = 0x0018;
    /// `BatQuantity`.
    pub const BAT_QUANTITY: u32 = 0x0019;
    /// `BatChargeState`.
    pub const BAT_CHARGE_STATE: u32 = 0x001A;
    /// `BatTimeToFullCharge`.
    pub const BAT_TIME_TO_FULL_CHARGE: u32 = 0x001B;
    /// `BatFunctionalWhileCharging`.
    pub const BAT_FUNCTIONAL_WHILE_CHARGING: u32 = 0x001C;
    /// `BatChargingCurrent`.
    pub const BAT_CHARGING_CURRENT: u32 = 0x001D;
    /// `ActiveBatChargeFaults`.
    pub const ACTIVE_BAT_CHARGE_FAULTS: u32 = 0x001E;
    /// `EndpointList`.
    pub const ENDPOINT_LIST: u32 = 0x001F;
}

bitflags::bitflags! {
    /// `PowerSource` feature bits (FeatureMap).
    #[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
    pub struct Feature: u32 {
        /// Wired (WIRED).
        const WIRED = 1 << 0;
        /// Battery (BAT).
        const BAT = 1 << 1;
        /// Rechargeable (RECHG).
        const RECHG = 1 << 2;
        /// Replaceable (REPLC).
        const REPLC = 1 << 3;
    }
}

/// `BatApprovedChemistryEnum` (enum16).
#[derive(Copy, Clone, Debug, PartialEq, Eq)]
pub enum BatApprovedChemistryEnum {
    /// Unspecified = 0.
    Unspecified,
    /// Alkaline = 1.
    Alkaline,
    /// LithiumCarbonFluoride = 2.
    LithiumCarbonFluoride,
    /// LithiumChromiumOxide = 3.
    LithiumChromiumOxide,
    /// LithiumCopperOxide = 4.
    LithiumCopperOxide,
    /// LithiumIronDisulfide = 5.
    LithiumIronDisulfide,
    /// LithiumManganeseDioxide = 6.
    LithiumManganeseDioxide,
    /// LithiumThionylChloride = 7.
    LithiumThionylChloride,
    /// Magnesium = 8.
    Magnesium,
    /// MercuryOxide = 9.
    MercuryOxide,
    /// NickelOxyhydride = 10.
    NickelOxyhydride,
    /// SilverOxide = 11.
    SilverOxide,
    /// ZincAir = 12.
    ZincAir,
    /// ZincCarbon = 13.
    ZincCarbon,
    /// ZincChloride = 14.
    ZincChloride,
    /// ZincManganeseDioxide = 15.
    ZincManganeseDioxide,
    /// LeadAcid = 16.
    LeadAcid,
    /// LithiumCobaltOxide = 17.
    LithiumCobaltOxide,
    /// LithiumIon = 18.
    LithiumIon,
    /// LithiumIonPolymer = 19.
    LithiumIonPolymer,
    /// LithiumIronPhosphate = 20.
    LithiumIronPhosphate,
    /// LithiumSulfur = 21.
    LithiumSulfur,
    /// LithiumTitanate = 22.
    LithiumTitanate,
    /// NickelCadmium = 23.
    NickelCadmium,
    /// NickelHydrogen = 24.
    NickelHydrogen,
    /// NickelIron = 25.
    NickelIron,
    /// NickelMetalHydride = 26.
    NickelMetalHydride,
    /// NickelZinc = 27.
    NickelZinc,
    /// SilverZinc = 28.
    SilverZinc,
    /// SodiumIon = 29.
    SodiumIon,
    /// SodiumSulfur = 30.
    SodiumSulfur,
    /// ZincBromide = 31.
    ZincBromide,
    /// ZincCerium = 32.
    ZincCerium,
    /// A value not known to this codegen revision.
    Unknown(u16),
}

impl BatApprovedChemistryEnum {
    /// Decode from its raw discriminant (unknown → `Unknown`).
    #[must_use]
    pub fn from_raw(v: u16) -> Self {
        match v {
            0 => Self::Unspecified,
            1 => Self::Alkaline,
            2 => Self::LithiumCarbonFluoride,
            3 => Self::LithiumChromiumOxide,
            4 => Self::LithiumCopperOxide,
            5 => Self::LithiumIronDisulfide,
            6 => Self::LithiumManganeseDioxide,
            7 => Self::LithiumThionylChloride,
            8 => Self::Magnesium,
            9 => Self::MercuryOxide,
            10 => Self::NickelOxyhydride,
            11 => Self::SilverOxide,
            12 => Self::ZincAir,
            13 => Self::ZincCarbon,
            14 => Self::ZincChloride,
            15 => Self::ZincManganeseDioxide,
            16 => Self::LeadAcid,
            17 => Self::LithiumCobaltOxide,
            18 => Self::LithiumIon,
            19 => Self::LithiumIonPolymer,
            20 => Self::LithiumIronPhosphate,
            21 => Self::LithiumSulfur,
            22 => Self::LithiumTitanate,
            23 => Self::NickelCadmium,
            24 => Self::NickelHydrogen,
            25 => Self::NickelIron,
            26 => Self::NickelMetalHydride,
            27 => Self::NickelZinc,
            28 => Self::SilverZinc,
            29 => Self::SodiumIon,
            30 => Self::SodiumSulfur,
            31 => Self::ZincBromide,
            32 => Self::ZincCerium,
            other => Self::Unknown(other),
        }
    }
    /// The raw discriminant.
    #[must_use]
    pub fn to_raw(self) -> u16 {
        match self {
            Self::Unspecified => 0,
            Self::Alkaline => 1,
            Self::LithiumCarbonFluoride => 2,
            Self::LithiumChromiumOxide => 3,
            Self::LithiumCopperOxide => 4,
            Self::LithiumIronDisulfide => 5,
            Self::LithiumManganeseDioxide => 6,
            Self::LithiumThionylChloride => 7,
            Self::Magnesium => 8,
            Self::MercuryOxide => 9,
            Self::NickelOxyhydride => 10,
            Self::SilverOxide => 11,
            Self::ZincAir => 12,
            Self::ZincCarbon => 13,
            Self::ZincChloride => 14,
            Self::ZincManganeseDioxide => 15,
            Self::LeadAcid => 16,
            Self::LithiumCobaltOxide => 17,
            Self::LithiumIon => 18,
            Self::LithiumIonPolymer => 19,
            Self::LithiumIronPhosphate => 20,
            Self::LithiumSulfur => 21,
            Self::LithiumTitanate => 22,
            Self::NickelCadmium => 23,
            Self::NickelHydrogen => 24,
            Self::NickelIron => 25,
            Self::NickelMetalHydride => 26,
            Self::NickelZinc => 27,
            Self::SilverZinc => 28,
            Self::SodiumIon => 29,
            Self::SodiumSulfur => 30,
            Self::ZincBromide => 31,
            Self::ZincCerium => 32,
            Self::Unknown(v) => v,
        }
    }
}

/// `BatChargeFaultEnum` (enum8).
#[derive(Copy, Clone, Debug, PartialEq, Eq)]
pub enum BatChargeFaultEnum {
    /// Unspecified = 0.
    Unspecified,
    /// AmbientTooHot = 1.
    AmbientTooHot,
    /// AmbientTooCold = 2.
    AmbientTooCold,
    /// BatteryTooHot = 3.
    BatteryTooHot,
    /// BatteryTooCold = 4.
    BatteryTooCold,
    /// BatteryAbsent = 5.
    BatteryAbsent,
    /// BatteryOverVoltage = 6.
    BatteryOverVoltage,
    /// BatteryUnderVoltage = 7.
    BatteryUnderVoltage,
    /// ChargerOverVoltage = 8.
    ChargerOverVoltage,
    /// ChargerUnderVoltage = 9.
    ChargerUnderVoltage,
    /// SafetyTimeout = 10.
    SafetyTimeout,
    /// A value not known to this codegen revision.
    Unknown(u8),
}

impl BatChargeFaultEnum {
    /// Decode from its raw discriminant (unknown → `Unknown`).
    #[must_use]
    pub fn from_raw(v: u8) -> Self {
        match v {
            0 => Self::Unspecified,
            1 => Self::AmbientTooHot,
            2 => Self::AmbientTooCold,
            3 => Self::BatteryTooHot,
            4 => Self::BatteryTooCold,
            5 => Self::BatteryAbsent,
            6 => Self::BatteryOverVoltage,
            7 => Self::BatteryUnderVoltage,
            8 => Self::ChargerOverVoltage,
            9 => Self::ChargerUnderVoltage,
            10 => Self::SafetyTimeout,
            other => Self::Unknown(other),
        }
    }
    /// The raw discriminant.
    #[must_use]
    pub fn to_raw(self) -> u8 {
        match self {
            Self::Unspecified => 0,
            Self::AmbientTooHot => 1,
            Self::AmbientTooCold => 2,
            Self::BatteryTooHot => 3,
            Self::BatteryTooCold => 4,
            Self::BatteryAbsent => 5,
            Self::BatteryOverVoltage => 6,
            Self::BatteryUnderVoltage => 7,
            Self::ChargerOverVoltage => 8,
            Self::ChargerUnderVoltage => 9,
            Self::SafetyTimeout => 10,
            Self::Unknown(v) => v,
        }
    }
}

/// `BatChargeLevelEnum` (enum8).
#[derive(Copy, Clone, Debug, PartialEq, Eq)]
pub enum BatChargeLevelEnum {
    /// Ok = 0.
    Ok,
    /// Warning = 1.
    Warning,
    /// Critical = 2.
    Critical,
    /// A value not known to this codegen revision.
    Unknown(u8),
}

impl BatChargeLevelEnum {
    /// Decode from its raw discriminant (unknown → `Unknown`).
    #[must_use]
    pub fn from_raw(v: u8) -> Self {
        match v {
            0 => Self::Ok,
            1 => Self::Warning,
            2 => Self::Critical,
            other => Self::Unknown(other),
        }
    }
    /// The raw discriminant.
    #[must_use]
    pub fn to_raw(self) -> u8 {
        match self {
            Self::Ok => 0,
            Self::Warning => 1,
            Self::Critical => 2,
            Self::Unknown(v) => v,
        }
    }
}

/// `BatChargeStateEnum` (enum8).
#[derive(Copy, Clone, Debug, PartialEq, Eq)]
pub enum BatChargeStateEnum {
    /// Unknown = 0.
    Unknown,
    /// IsCharging = 1.
    IsCharging,
    /// IsAtFullCharge = 2.
    IsAtFullCharge,
    /// IsNotCharging = 3.
    IsNotCharging,
    /// A value not known to this codegen revision.
    Unrecognized(u8),
}

impl BatChargeStateEnum {
    /// Decode from its raw discriminant (unknown → `Unrecognized`).
    #[must_use]
    pub fn from_raw(v: u8) -> Self {
        match v {
            0 => Self::Unknown,
            1 => Self::IsCharging,
            2 => Self::IsAtFullCharge,
            3 => Self::IsNotCharging,
            other => Self::Unrecognized(other),
        }
    }
    /// The raw discriminant.
    #[must_use]
    pub fn to_raw(self) -> u8 {
        match self {
            Self::Unknown => 0,
            Self::IsCharging => 1,
            Self::IsAtFullCharge => 2,
            Self::IsNotCharging => 3,
            Self::Unrecognized(v) => v,
        }
    }
}

/// `BatCommonDesignationEnum` (enum16).
#[derive(Copy, Clone, Debug, PartialEq, Eq)]
#[allow(non_camel_case_types)]
pub enum BatCommonDesignationEnum {
    /// Unspecified = 0.
    Unspecified,
    /// Aaa = 1.
    Aaa,
    /// Aa = 2.
    Aa,
    /// C = 3.
    C,
    /// D = 4.
    D,
    /// 4V5 = 5.
    _4V5,
    /// 6V0 = 6.
    _6V0,
    /// 9V0 = 7.
    _9V0,
    /// 12Aa = 8.
    _12Aa,
    /// Aaaa = 9.
    Aaaa,
    /// A = 10.
    A,
    /// B = 11.
    B,
    /// F = 12.
    F,
    /// N = 13.
    N,
    /// No6 = 14.
    No6,
    /// SubC = 15.
    SubC,
    /// A23 = 16.
    A23,
    /// A27 = 17.
    A27,
    /// Ba5800 = 18.
    Ba5800,
    /// Duplex = 19.
    Duplex,
    /// 4Sr44 = 20.
    _4Sr44,
    /// 523 = 21.
    _523,
    /// 531 = 22.
    _531,
    /// 15V0 = 23.
    _15V0,
    /// 22V5 = 24.
    _22V5,
    /// 30V0 = 25.
    _30V0,
    /// 45V0 = 26.
    _45V0,
    /// 67V5 = 27.
    _67V5,
    /// J = 28.
    J,
    /// Cr123A = 29.
    Cr123A,
    /// Cr2 = 30.
    Cr2,
    /// 2Cr5 = 31.
    _2Cr5,
    /// CrP2 = 32.
    CrP2,
    /// CrV3 = 33.
    CrV3,
    /// Sr41 = 34.
    Sr41,
    /// Sr43 = 35.
    Sr43,
    /// Sr44 = 36.
    Sr44,
    /// Sr45 = 37.
    Sr45,
    /// Sr48 = 38.
    Sr48,
    /// Sr54 = 39.
    Sr54,
    /// Sr55 = 40.
    Sr55,
    /// Sr57 = 41.
    Sr57,
    /// Sr58 = 42.
    Sr58,
    /// Sr59 = 43.
    Sr59,
    /// Sr60 = 44.
    Sr60,
    /// Sr63 = 45.
    Sr63,
    /// Sr64 = 46.
    Sr64,
    /// Sr65 = 47.
    Sr65,
    /// Sr66 = 48.
    Sr66,
    /// Sr67 = 49.
    Sr67,
    /// Sr68 = 50.
    Sr68,
    /// Sr69 = 51.
    Sr69,
    /// Sr516 = 52.
    Sr516,
    /// Sr731 = 53.
    Sr731,
    /// Sr712 = 54.
    Sr712,
    /// Lr932 = 55.
    Lr932,
    /// A5 = 56.
    A5,
    /// A10 = 57.
    A10,
    /// A13 = 58.
    A13,
    /// A312 = 59.
    A312,
    /// A675 = 60.
    A675,
    /// Ac41E = 61.
    Ac41E,
    /// 10180 = 62.
    _10180,
    /// 10280 = 63.
    _10280,
    /// 10440 = 64.
    _10440,
    /// 14250 = 65.
    _14250,
    /// 14430 = 66.
    _14430,
    /// 14500 = 67.
    _14500,
    /// 14650 = 68.
    _14650,
    /// 15270 = 69.
    _15270,
    /// 16340 = 70.
    _16340,
    /// Rcr123A = 71.
    Rcr123A,
    /// 17500 = 72.
    _17500,
    /// 17670 = 73.
    _17670,
    /// 18350 = 74.
    _18350,
    /// 18500 = 75.
    _18500,
    /// 18650 = 76.
    _18650,
    /// 19670 = 77.
    _19670,
    /// 25500 = 78.
    _25500,
    /// 26650 = 79.
    _26650,
    /// 32600 = 80.
    _32600,
    /// A value not known to this codegen revision.
    Unknown(u16),
}

impl BatCommonDesignationEnum {
    /// Decode from its raw discriminant (unknown → `Unknown`).
    #[must_use]
    pub fn from_raw(v: u16) -> Self {
        match v {
            0 => Self::Unspecified,
            1 => Self::Aaa,
            2 => Self::Aa,
            3 => Self::C,
            4 => Self::D,
            5 => Self::_4V5,
            6 => Self::_6V0,
            7 => Self::_9V0,
            8 => Self::_12Aa,
            9 => Self::Aaaa,
            10 => Self::A,
            11 => Self::B,
            12 => Self::F,
            13 => Self::N,
            14 => Self::No6,
            15 => Self::SubC,
            16 => Self::A23,
            17 => Self::A27,
            18 => Self::Ba5800,
            19 => Self::Duplex,
            20 => Self::_4Sr44,
            21 => Self::_523,
            22 => Self::_531,
            23 => Self::_15V0,
            24 => Self::_22V5,
            25 => Self::_30V0,
            26 => Self::_45V0,
            27 => Self::_67V5,
            28 => Self::J,
            29 => Self::Cr123A,
            30 => Self::Cr2,
            31 => Self::_2Cr5,
            32 => Self::CrP2,
            33 => Self::CrV3,
            34 => Self::Sr41,
            35 => Self::Sr43,
            36 => Self::Sr44,
            37 => Self::Sr45,
            38 => Self::Sr48,
            39 => Self::Sr54,
            40 => Self::Sr55,
            41 => Self::Sr57,
            42 => Self::Sr58,
            43 => Self::Sr59,
            44 => Self::Sr60,
            45 => Self::Sr63,
            46 => Self::Sr64,
            47 => Self::Sr65,
            48 => Self::Sr66,
            49 => Self::Sr67,
            50 => Self::Sr68,
            51 => Self::Sr69,
            52 => Self::Sr516,
            53 => Self::Sr731,
            54 => Self::Sr712,
            55 => Self::Lr932,
            56 => Self::A5,
            57 => Self::A10,
            58 => Self::A13,
            59 => Self::A312,
            60 => Self::A675,
            61 => Self::Ac41E,
            62 => Self::_10180,
            63 => Self::_10280,
            64 => Self::_10440,
            65 => Self::_14250,
            66 => Self::_14430,
            67 => Self::_14500,
            68 => Self::_14650,
            69 => Self::_15270,
            70 => Self::_16340,
            71 => Self::Rcr123A,
            72 => Self::_17500,
            73 => Self::_17670,
            74 => Self::_18350,
            75 => Self::_18500,
            76 => Self::_18650,
            77 => Self::_19670,
            78 => Self::_25500,
            79 => Self::_26650,
            80 => Self::_32600,
            other => Self::Unknown(other),
        }
    }
    /// The raw discriminant.
    #[must_use]
    pub fn to_raw(self) -> u16 {
        match self {
            Self::Unspecified => 0,
            Self::Aaa => 1,
            Self::Aa => 2,
            Self::C => 3,
            Self::D => 4,
            Self::_4V5 => 5,
            Self::_6V0 => 6,
            Self::_9V0 => 7,
            Self::_12Aa => 8,
            Self::Aaaa => 9,
            Self::A => 10,
            Self::B => 11,
            Self::F => 12,
            Self::N => 13,
            Self::No6 => 14,
            Self::SubC => 15,
            Self::A23 => 16,
            Self::A27 => 17,
            Self::Ba5800 => 18,
            Self::Duplex => 19,
            Self::_4Sr44 => 20,
            Self::_523 => 21,
            Self::_531 => 22,
            Self::_15V0 => 23,
            Self::_22V5 => 24,
            Self::_30V0 => 25,
            Self::_45V0 => 26,
            Self::_67V5 => 27,
            Self::J => 28,
            Self::Cr123A => 29,
            Self::Cr2 => 30,
            Self::_2Cr5 => 31,
            Self::CrP2 => 32,
            Self::CrV3 => 33,
            Self::Sr41 => 34,
            Self::Sr43 => 35,
            Self::Sr44 => 36,
            Self::Sr45 => 37,
            Self::Sr48 => 38,
            Self::Sr54 => 39,
            Self::Sr55 => 40,
            Self::Sr57 => 41,
            Self::Sr58 => 42,
            Self::Sr59 => 43,
            Self::Sr60 => 44,
            Self::Sr63 => 45,
            Self::Sr64 => 46,
            Self::Sr65 => 47,
            Self::Sr66 => 48,
            Self::Sr67 => 49,
            Self::Sr68 => 50,
            Self::Sr69 => 51,
            Self::Sr516 => 52,
            Self::Sr731 => 53,
            Self::Sr712 => 54,
            Self::Lr932 => 55,
            Self::A5 => 56,
            Self::A10 => 57,
            Self::A13 => 58,
            Self::A312 => 59,
            Self::A675 => 60,
            Self::Ac41E => 61,
            Self::_10180 => 62,
            Self::_10280 => 63,
            Self::_10440 => 64,
            Self::_14250 => 65,
            Self::_14430 => 66,
            Self::_14500 => 67,
            Self::_14650 => 68,
            Self::_15270 => 69,
            Self::_16340 => 70,
            Self::Rcr123A => 71,
            Self::_17500 => 72,
            Self::_17670 => 73,
            Self::_18350 => 74,
            Self::_18500 => 75,
            Self::_18650 => 76,
            Self::_19670 => 77,
            Self::_25500 => 78,
            Self::_26650 => 79,
            Self::_32600 => 80,
            Self::Unknown(v) => v,
        }
    }
}

/// `BatFaultEnum` (enum8).
#[derive(Copy, Clone, Debug, PartialEq, Eq)]
pub enum BatFaultEnum {
    /// Unspecified = 0.
    Unspecified,
    /// OverTemp = 1.
    OverTemp,
    /// UnderTemp = 2.
    UnderTemp,
    /// A value not known to this codegen revision.
    Unknown(u8),
}

impl BatFaultEnum {
    /// Decode from its raw discriminant (unknown → `Unknown`).
    #[must_use]
    pub fn from_raw(v: u8) -> Self {
        match v {
            0 => Self::Unspecified,
            1 => Self::OverTemp,
            2 => Self::UnderTemp,
            other => Self::Unknown(other),
        }
    }
    /// The raw discriminant.
    #[must_use]
    pub fn to_raw(self) -> u8 {
        match self {
            Self::Unspecified => 0,
            Self::OverTemp => 1,
            Self::UnderTemp => 2,
            Self::Unknown(v) => v,
        }
    }
}

/// `BatReplaceabilityEnum` (enum8).
#[derive(Copy, Clone, Debug, PartialEq, Eq)]
pub enum BatReplaceabilityEnum {
    /// Unspecified = 0.
    Unspecified,
    /// NotReplaceable = 1.
    NotReplaceable,
    /// UserReplaceable = 2.
    UserReplaceable,
    /// FactoryReplaceable = 3.
    FactoryReplaceable,
    /// A value not known to this codegen revision.
    Unknown(u8),
}

impl BatReplaceabilityEnum {
    /// Decode from its raw discriminant (unknown → `Unknown`).
    #[must_use]
    pub fn from_raw(v: u8) -> Self {
        match v {
            0 => Self::Unspecified,
            1 => Self::NotReplaceable,
            2 => Self::UserReplaceable,
            3 => Self::FactoryReplaceable,
            other => Self::Unknown(other),
        }
    }
    /// The raw discriminant.
    #[must_use]
    pub fn to_raw(self) -> u8 {
        match self {
            Self::Unspecified => 0,
            Self::NotReplaceable => 1,
            Self::UserReplaceable => 2,
            Self::FactoryReplaceable => 3,
            Self::Unknown(v) => v,
        }
    }
}

/// `PowerSourceStatusEnum` (enum8).
#[derive(Copy, Clone, Debug, PartialEq, Eq)]
pub enum PowerSourceStatusEnum {
    /// Unspecified = 0.
    Unspecified,
    /// Active = 1.
    Active,
    /// Standby = 2.
    Standby,
    /// Unavailable = 3.
    Unavailable,
    /// A value not known to this codegen revision.
    Unknown(u8),
}

impl PowerSourceStatusEnum {
    /// Decode from its raw discriminant (unknown → `Unknown`).
    #[must_use]
    pub fn from_raw(v: u8) -> Self {
        match v {
            0 => Self::Unspecified,
            1 => Self::Active,
            2 => Self::Standby,
            3 => Self::Unavailable,
            other => Self::Unknown(other),
        }
    }
    /// The raw discriminant.
    #[must_use]
    pub fn to_raw(self) -> u8 {
        match self {
            Self::Unspecified => 0,
            Self::Active => 1,
            Self::Standby => 2,
            Self::Unavailable => 3,
            Self::Unknown(v) => v,
        }
    }
}

/// `WiredCurrentTypeEnum` (enum8).
#[derive(Copy, Clone, Debug, PartialEq, Eq)]
pub enum WiredCurrentTypeEnum {
    /// Ac = 0.
    Ac,
    /// Dc = 1.
    Dc,
    /// A value not known to this codegen revision.
    Unknown(u8),
}

impl WiredCurrentTypeEnum {
    /// Decode from its raw discriminant (unknown → `Unknown`).
    #[must_use]
    pub fn from_raw(v: u8) -> Self {
        match v {
            0 => Self::Ac,
            1 => Self::Dc,
            other => Self::Unknown(other),
        }
    }
    /// The raw discriminant.
    #[must_use]
    pub fn to_raw(self) -> u8 {
        match self {
            Self::Ac => 0,
            Self::Dc => 1,
            Self::Unknown(v) => v,
        }
    }
}

/// `WiredFaultEnum` (enum8).
#[derive(Copy, Clone, Debug, PartialEq, Eq)]
pub enum WiredFaultEnum {
    /// Unspecified = 0.
    Unspecified,
    /// OverVoltage = 1.
    OverVoltage,
    /// UnderVoltage = 2.
    UnderVoltage,
    /// A value not known to this codegen revision.
    Unknown(u8),
}

impl WiredFaultEnum {
    /// Decode from its raw discriminant (unknown → `Unknown`).
    #[must_use]
    pub fn from_raw(v: u8) -> Self {
        match v {
            0 => Self::Unspecified,
            1 => Self::OverVoltage,
            2 => Self::UnderVoltage,
            other => Self::Unknown(other),
        }
    }
    /// The raw discriminant.
    #[must_use]
    pub fn to_raw(self) -> u8 {
        match self {
            Self::Unspecified => 0,
            Self::OverVoltage => 1,
            Self::UnderVoltage => 2,
            Self::Unknown(v) => v,
        }
    }
}

/// Decode the `Status` attribute value.
///
/// # Errors
/// Returns [`ClusterError`] on a type mismatch or out-of-range value.
pub fn decode_status(tlv: &[u8]) -> Result<PowerSourceStatusEnum, ClusterError> {
    let mut r = TlvReader::new(tlv);
    match r.next()? {
        Some(Element::Scalar {
            value: Value::Uint(v),
            ..
        }) => Ok(PowerSourceStatusEnum::from_raw(
            u8::try_from(v).map_err(|_| ClusterError::InvalidLength("Status"))?,
        )),
        _ => Err(ClusterError::UnexpectedType { context: "Status" }),
    }
}

/// Decode the `Order` attribute value.
///
/// # Errors
/// Returns [`ClusterError`] on a type mismatch or out-of-range value.
pub fn decode_order(tlv: &[u8]) -> Result<u8, ClusterError> {
    let mut r = TlvReader::new(tlv);
    match r.next()? {
        Some(Element::Scalar {
            value: Value::Uint(v),
            ..
        }) => Ok(u8::try_from(v).map_err(|_| ClusterError::InvalidLength("Order"))?),
        _ => Err(ClusterError::UnexpectedType { context: "Order" }),
    }
}

/// Decode the `Description` attribute value.
///
/// # Errors
/// Returns [`ClusterError`] on a type mismatch or out-of-range value.
pub fn decode_description(tlv: &[u8]) -> Result<String, ClusterError> {
    let mut r = TlvReader::new(tlv);
    match r.next()? {
        Some(Element::Scalar {
            value: Value::Utf8(v),
            ..
        }) => Ok(v),
        _ => Err(ClusterError::UnexpectedType {
            context: "Description",
        }),
    }
}

/// Decode the `WiredAssessedInputVoltage` attribute value.
///
/// # Errors
/// Returns [`ClusterError`] on a type mismatch or out-of-range value.
pub fn decode_wired_assessed_input_voltage(tlv: &[u8]) -> Result<Nullable<u32>, ClusterError> {
    let mut r = TlvReader::new(tlv);
    match r.next()? {
        Some(Element::Scalar {
            value: Value::Null, ..
        }) => Ok(Nullable::Null),
        Some(Element::Scalar {
            value: Value::Uint(v),
            ..
        }) => Ok(Nullable::Value(u32::try_from(v).map_err(|_| {
            ClusterError::InvalidLength("WiredAssessedInputVoltage")
        })?)),
        _ => Err(ClusterError::UnexpectedType {
            context: "WiredAssessedInputVoltage",
        }),
    }
}

/// Decode the `WiredAssessedInputFrequency` attribute value.
///
/// # Errors
/// Returns [`ClusterError`] on a type mismatch or out-of-range value.
pub fn decode_wired_assessed_input_frequency(tlv: &[u8]) -> Result<Nullable<u16>, ClusterError> {
    let mut r = TlvReader::new(tlv);
    match r.next()? {
        Some(Element::Scalar {
            value: Value::Null, ..
        }) => Ok(Nullable::Null),
        Some(Element::Scalar {
            value: Value::Uint(v),
            ..
        }) => Ok(Nullable::Value(u16::try_from(v).map_err(|_| {
            ClusterError::InvalidLength("WiredAssessedInputFrequency")
        })?)),
        _ => Err(ClusterError::UnexpectedType {
            context: "WiredAssessedInputFrequency",
        }),
    }
}

/// Decode the `WiredCurrentType` attribute value.
///
/// # Errors
/// Returns [`ClusterError`] on a type mismatch or out-of-range value.
pub fn decode_wired_current_type(tlv: &[u8]) -> Result<WiredCurrentTypeEnum, ClusterError> {
    let mut r = TlvReader::new(tlv);
    match r.next()? {
        Some(Element::Scalar {
            value: Value::Uint(v),
            ..
        }) => Ok(WiredCurrentTypeEnum::from_raw(
            u8::try_from(v).map_err(|_| ClusterError::InvalidLength("WiredCurrentType"))?,
        )),
        _ => Err(ClusterError::UnexpectedType {
            context: "WiredCurrentType",
        }),
    }
}

/// Decode the `WiredAssessedCurrent` attribute value.
///
/// # Errors
/// Returns [`ClusterError`] on a type mismatch or out-of-range value.
pub fn decode_wired_assessed_current(tlv: &[u8]) -> Result<Nullable<u32>, ClusterError> {
    let mut r = TlvReader::new(tlv);
    match r.next()? {
        Some(Element::Scalar {
            value: Value::Null, ..
        }) => Ok(Nullable::Null),
        Some(Element::Scalar {
            value: Value::Uint(v),
            ..
        }) => Ok(Nullable::Value(u32::try_from(v).map_err(|_| {
            ClusterError::InvalidLength("WiredAssessedCurrent")
        })?)),
        _ => Err(ClusterError::UnexpectedType {
            context: "WiredAssessedCurrent",
        }),
    }
}

/// Decode the `WiredNominalVoltage` attribute value.
///
/// # Errors
/// Returns [`ClusterError`] on a type mismatch or out-of-range value.
pub fn decode_wired_nominal_voltage(tlv: &[u8]) -> Result<u32, ClusterError> {
    let mut r = TlvReader::new(tlv);
    match r.next()? {
        Some(Element::Scalar {
            value: Value::Uint(v),
            ..
        }) => Ok(u32::try_from(v).map_err(|_| ClusterError::InvalidLength("WiredNominalVoltage"))?),
        _ => Err(ClusterError::UnexpectedType {
            context: "WiredNominalVoltage",
        }),
    }
}

/// Decode the `WiredMaximumCurrent` attribute value.
///
/// # Errors
/// Returns [`ClusterError`] on a type mismatch or out-of-range value.
pub fn decode_wired_maximum_current(tlv: &[u8]) -> Result<u32, ClusterError> {
    let mut r = TlvReader::new(tlv);
    match r.next()? {
        Some(Element::Scalar {
            value: Value::Uint(v),
            ..
        }) => Ok(u32::try_from(v).map_err(|_| ClusterError::InvalidLength("WiredMaximumCurrent"))?),
        _ => Err(ClusterError::UnexpectedType {
            context: "WiredMaximumCurrent",
        }),
    }
}

/// Decode the `WiredPresent` attribute value.
///
/// # Errors
/// Returns [`ClusterError`] on a type mismatch or out-of-range value.
pub fn decode_wired_present(tlv: &[u8]) -> Result<bool, ClusterError> {
    let mut r = TlvReader::new(tlv);
    match r.next()? {
        Some(Element::Scalar {
            value: Value::Bool(v),
            ..
        }) => Ok(v),
        _ => Err(ClusterError::UnexpectedType {
            context: "WiredPresent",
        }),
    }
}

/// Decode the `ActiveWiredFaults` attribute value.
///
/// # Errors
/// Returns [`ClusterError`] on a type mismatch or out-of-range value.
pub fn decode_active_wired_faults(tlv: &[u8]) -> Result<Vec<WiredFaultEnum>, ClusterError> {
    let mut r = TlvReader::new(tlv);
    match r.next()? {
        Some(Element::ContainerStart {
            kind: ContainerKind::Array,
            ..
        }) => {}
        _ => {
            return Err(ClusterError::UnexpectedType {
                context: "ActiveWiredFaults",
            })
        }
    }
    let r = &mut r;
    let mut out = Vec::new();
    loop {
        match r.next()? {
            Some(Element::ContainerEnd) => break,
            Some(Element::Scalar {
                value: Value::Uint(v),
                ..
            }) => out.push(WiredFaultEnum::from_raw(
                u8::try_from(v).map_err(|_| ClusterError::InvalidLength("ActiveWiredFaults"))?,
            )),
            None => return Err(ClusterError::Tlv(matter_codec::Error::UnclosedContainer)),
            Some(Element::ContainerStart { .. }) => r.skip_container()?,
            Some(_) => {} // skip unknown scalar
        }
    }
    Ok(out)
}

/// Decode the `BatVoltage` attribute value.
///
/// # Errors
/// Returns [`ClusterError`] on a type mismatch or out-of-range value.
pub fn decode_bat_voltage(tlv: &[u8]) -> Result<Nullable<u32>, ClusterError> {
    let mut r = TlvReader::new(tlv);
    match r.next()? {
        Some(Element::Scalar {
            value: Value::Null, ..
        }) => Ok(Nullable::Null),
        Some(Element::Scalar {
            value: Value::Uint(v),
            ..
        }) => Ok(Nullable::Value(
            u32::try_from(v).map_err(|_| ClusterError::InvalidLength("BatVoltage"))?,
        )),
        _ => Err(ClusterError::UnexpectedType {
            context: "BatVoltage",
        }),
    }
}

/// Decode the `BatPercentRemaining` attribute value.
///
/// # Errors
/// Returns [`ClusterError`] on a type mismatch or out-of-range value.
pub fn decode_bat_percent_remaining(tlv: &[u8]) -> Result<Nullable<u8>, ClusterError> {
    let mut r = TlvReader::new(tlv);
    match r.next()? {
        Some(Element::Scalar {
            value: Value::Null, ..
        }) => Ok(Nullable::Null),
        Some(Element::Scalar {
            value: Value::Uint(v),
            ..
        }) => Ok(Nullable::Value(u8::try_from(v).map_err(|_| {
            ClusterError::InvalidLength("BatPercentRemaining")
        })?)),
        _ => Err(ClusterError::UnexpectedType {
            context: "BatPercentRemaining",
        }),
    }
}

/// Decode the `BatTimeRemaining` attribute value.
///
/// # Errors
/// Returns [`ClusterError`] on a type mismatch or out-of-range value.
pub fn decode_bat_time_remaining(tlv: &[u8]) -> Result<Nullable<u32>, ClusterError> {
    let mut r = TlvReader::new(tlv);
    match r.next()? {
        Some(Element::Scalar {
            value: Value::Null, ..
        }) => Ok(Nullable::Null),
        Some(Element::Scalar {
            value: Value::Uint(v),
            ..
        }) => {
            Ok(Nullable::Value(u32::try_from(v).map_err(|_| {
                ClusterError::InvalidLength("BatTimeRemaining")
            })?))
        }
        _ => Err(ClusterError::UnexpectedType {
            context: "BatTimeRemaining",
        }),
    }
}

/// Decode the `BatChargeLevel` attribute value.
///
/// # Errors
/// Returns [`ClusterError`] on a type mismatch or out-of-range value.
pub fn decode_bat_charge_level(tlv: &[u8]) -> Result<BatChargeLevelEnum, ClusterError> {
    let mut r = TlvReader::new(tlv);
    match r.next()? {
        Some(Element::Scalar {
            value: Value::Uint(v),
            ..
        }) => Ok(BatChargeLevelEnum::from_raw(
            u8::try_from(v).map_err(|_| ClusterError::InvalidLength("BatChargeLevel"))?,
        )),
        _ => Err(ClusterError::UnexpectedType {
            context: "BatChargeLevel",
        }),
    }
}

/// Decode the `BatReplacementNeeded` attribute value.
///
/// # Errors
/// Returns [`ClusterError`] on a type mismatch or out-of-range value.
pub fn decode_bat_replacement_needed(tlv: &[u8]) -> Result<bool, ClusterError> {
    let mut r = TlvReader::new(tlv);
    match r.next()? {
        Some(Element::Scalar {
            value: Value::Bool(v),
            ..
        }) => Ok(v),
        _ => Err(ClusterError::UnexpectedType {
            context: "BatReplacementNeeded",
        }),
    }
}

/// Decode the `BatReplaceability` attribute value.
///
/// # Errors
/// Returns [`ClusterError`] on a type mismatch or out-of-range value.
pub fn decode_bat_replaceability(tlv: &[u8]) -> Result<BatReplaceabilityEnum, ClusterError> {
    let mut r = TlvReader::new(tlv);
    match r.next()? {
        Some(Element::Scalar {
            value: Value::Uint(v),
            ..
        }) => Ok(BatReplaceabilityEnum::from_raw(
            u8::try_from(v).map_err(|_| ClusterError::InvalidLength("BatReplaceability"))?,
        )),
        _ => Err(ClusterError::UnexpectedType {
            context: "BatReplaceability",
        }),
    }
}

/// Decode the `BatPresent` attribute value.
///
/// # Errors
/// Returns [`ClusterError`] on a type mismatch or out-of-range value.
pub fn decode_bat_present(tlv: &[u8]) -> Result<bool, ClusterError> {
    let mut r = TlvReader::new(tlv);
    match r.next()? {
        Some(Element::Scalar {
            value: Value::Bool(v),
            ..
        }) => Ok(v),
        _ => Err(ClusterError::UnexpectedType {
            context: "BatPresent",
        }),
    }
}

/// Decode the `ActiveBatFaults` attribute value.
///
/// # Errors
/// Returns [`ClusterError`] on a type mismatch or out-of-range value.
pub fn decode_active_bat_faults(tlv: &[u8]) -> Result<Vec<BatFaultEnum>, ClusterError> {
    let mut r = TlvReader::new(tlv);
    match r.next()? {
        Some(Element::ContainerStart {
            kind: ContainerKind::Array,
            ..
        }) => {}
        _ => {
            return Err(ClusterError::UnexpectedType {
                context: "ActiveBatFaults",
            })
        }
    }
    let r = &mut r;
    let mut out = Vec::new();
    loop {
        match r.next()? {
            Some(Element::ContainerEnd) => break,
            Some(Element::Scalar {
                value: Value::Uint(v),
                ..
            }) => out.push(BatFaultEnum::from_raw(
                u8::try_from(v).map_err(|_| ClusterError::InvalidLength("ActiveBatFaults"))?,
            )),
            None => return Err(ClusterError::Tlv(matter_codec::Error::UnclosedContainer)),
            Some(Element::ContainerStart { .. }) => r.skip_container()?,
            Some(_) => {} // skip unknown scalar
        }
    }
    Ok(out)
}

/// Decode the `BatReplacementDescription` attribute value.
///
/// # Errors
/// Returns [`ClusterError`] on a type mismatch or out-of-range value.
pub fn decode_bat_replacement_description(tlv: &[u8]) -> Result<String, ClusterError> {
    let mut r = TlvReader::new(tlv);
    match r.next()? {
        Some(Element::Scalar {
            value: Value::Utf8(v),
            ..
        }) => Ok(v),
        _ => Err(ClusterError::UnexpectedType {
            context: "BatReplacementDescription",
        }),
    }
}

/// Decode the `BatCommonDesignation` attribute value.
///
/// # Errors
/// Returns [`ClusterError`] on a type mismatch or out-of-range value.
pub fn decode_bat_common_designation(tlv: &[u8]) -> Result<BatCommonDesignationEnum, ClusterError> {
    let mut r = TlvReader::new(tlv);
    match r.next()? {
        Some(Element::Scalar {
            value: Value::Uint(v),
            ..
        }) => Ok(BatCommonDesignationEnum::from_raw(
            u16::try_from(v).map_err(|_| ClusterError::InvalidLength("BatCommonDesignation"))?,
        )),
        _ => Err(ClusterError::UnexpectedType {
            context: "BatCommonDesignation",
        }),
    }
}

/// Decode the `BatAnsiDesignation` attribute value.
///
/// # Errors
/// Returns [`ClusterError`] on a type mismatch or out-of-range value.
pub fn decode_bat_ansi_designation(tlv: &[u8]) -> Result<String, ClusterError> {
    let mut r = TlvReader::new(tlv);
    match r.next()? {
        Some(Element::Scalar {
            value: Value::Utf8(v),
            ..
        }) => Ok(v),
        _ => Err(ClusterError::UnexpectedType {
            context: "BatAnsiDesignation",
        }),
    }
}

/// Decode the `BatIecDesignation` attribute value.
///
/// # Errors
/// Returns [`ClusterError`] on a type mismatch or out-of-range value.
pub fn decode_bat_iec_designation(tlv: &[u8]) -> Result<String, ClusterError> {
    let mut r = TlvReader::new(tlv);
    match r.next()? {
        Some(Element::Scalar {
            value: Value::Utf8(v),
            ..
        }) => Ok(v),
        _ => Err(ClusterError::UnexpectedType {
            context: "BatIecDesignation",
        }),
    }
}

/// Decode the `BatApprovedChemistry` attribute value.
///
/// # Errors
/// Returns [`ClusterError`] on a type mismatch or out-of-range value.
pub fn decode_bat_approved_chemistry(tlv: &[u8]) -> Result<BatApprovedChemistryEnum, ClusterError> {
    let mut r = TlvReader::new(tlv);
    match r.next()? {
        Some(Element::Scalar {
            value: Value::Uint(v),
            ..
        }) => Ok(BatApprovedChemistryEnum::from_raw(
            u16::try_from(v).map_err(|_| ClusterError::InvalidLength("BatApprovedChemistry"))?,
        )),
        _ => Err(ClusterError::UnexpectedType {
            context: "BatApprovedChemistry",
        }),
    }
}

/// Decode the `BatCapacity` attribute value.
///
/// # Errors
/// Returns [`ClusterError`] on a type mismatch or out-of-range value.
pub fn decode_bat_capacity(tlv: &[u8]) -> Result<u32, ClusterError> {
    let mut r = TlvReader::new(tlv);
    match r.next()? {
        Some(Element::Scalar {
            value: Value::Uint(v),
            ..
        }) => Ok(u32::try_from(v).map_err(|_| ClusterError::InvalidLength("BatCapacity"))?),
        _ => Err(ClusterError::UnexpectedType {
            context: "BatCapacity",
        }),
    }
}

/// Decode the `BatQuantity` attribute value.
///
/// # Errors
/// Returns [`ClusterError`] on a type mismatch or out-of-range value.
pub fn decode_bat_quantity(tlv: &[u8]) -> Result<u8, ClusterError> {
    let mut r = TlvReader::new(tlv);
    match r.next()? {
        Some(Element::Scalar {
            value: Value::Uint(v),
            ..
        }) => Ok(u8::try_from(v).map_err(|_| ClusterError::InvalidLength("BatQuantity"))?),
        _ => Err(ClusterError::UnexpectedType {
            context: "BatQuantity",
        }),
    }
}

/// Decode the `BatChargeState` attribute value.
///
/// # Errors
/// Returns [`ClusterError`] on a type mismatch or out-of-range value.
pub fn decode_bat_charge_state(tlv: &[u8]) -> Result<BatChargeStateEnum, ClusterError> {
    let mut r = TlvReader::new(tlv);
    match r.next()? {
        Some(Element::Scalar {
            value: Value::Uint(v),
            ..
        }) => Ok(BatChargeStateEnum::from_raw(
            u8::try_from(v).map_err(|_| ClusterError::InvalidLength("BatChargeState"))?,
        )),
        _ => Err(ClusterError::UnexpectedType {
            context: "BatChargeState",
        }),
    }
}

/// Decode the `BatTimeToFullCharge` attribute value.
///
/// # Errors
/// Returns [`ClusterError`] on a type mismatch or out-of-range value.
pub fn decode_bat_time_to_full_charge(tlv: &[u8]) -> Result<Nullable<u32>, ClusterError> {
    let mut r = TlvReader::new(tlv);
    match r.next()? {
        Some(Element::Scalar {
            value: Value::Null, ..
        }) => Ok(Nullable::Null),
        Some(Element::Scalar {
            value: Value::Uint(v),
            ..
        }) => Ok(Nullable::Value(u32::try_from(v).map_err(|_| {
            ClusterError::InvalidLength("BatTimeToFullCharge")
        })?)),
        _ => Err(ClusterError::UnexpectedType {
            context: "BatTimeToFullCharge",
        }),
    }
}

/// Decode the `BatFunctionalWhileCharging` attribute value.
///
/// # Errors
/// Returns [`ClusterError`] on a type mismatch or out-of-range value.
pub fn decode_bat_functional_while_charging(tlv: &[u8]) -> Result<bool, ClusterError> {
    let mut r = TlvReader::new(tlv);
    match r.next()? {
        Some(Element::Scalar {
            value: Value::Bool(v),
            ..
        }) => Ok(v),
        _ => Err(ClusterError::UnexpectedType {
            context: "BatFunctionalWhileCharging",
        }),
    }
}

/// Decode the `BatChargingCurrent` attribute value.
///
/// # Errors
/// Returns [`ClusterError`] on a type mismatch or out-of-range value.
pub fn decode_bat_charging_current(tlv: &[u8]) -> Result<Nullable<u32>, ClusterError> {
    let mut r = TlvReader::new(tlv);
    match r.next()? {
        Some(Element::Scalar {
            value: Value::Null, ..
        }) => Ok(Nullable::Null),
        Some(Element::Scalar {
            value: Value::Uint(v),
            ..
        }) => Ok(Nullable::Value(u32::try_from(v).map_err(|_| {
            ClusterError::InvalidLength("BatChargingCurrent")
        })?)),
        _ => Err(ClusterError::UnexpectedType {
            context: "BatChargingCurrent",
        }),
    }
}

/// Decode the `ActiveBatChargeFaults` attribute value.
///
/// # Errors
/// Returns [`ClusterError`] on a type mismatch or out-of-range value.
pub fn decode_active_bat_charge_faults(
    tlv: &[u8],
) -> Result<Vec<BatChargeFaultEnum>, ClusterError> {
    let mut r = TlvReader::new(tlv);
    match r.next()? {
        Some(Element::ContainerStart {
            kind: ContainerKind::Array,
            ..
        }) => {}
        _ => {
            return Err(ClusterError::UnexpectedType {
                context: "ActiveBatChargeFaults",
            })
        }
    }
    let r = &mut r;
    let mut out = Vec::new();
    loop {
        match r.next()? {
            Some(Element::ContainerEnd) => break,
            Some(Element::Scalar {
                value: Value::Uint(v),
                ..
            }) => out
                .push(BatChargeFaultEnum::from_raw(u8::try_from(v).map_err(
                    |_| ClusterError::InvalidLength("ActiveBatChargeFaults"),
                )?)),
            None => return Err(ClusterError::Tlv(matter_codec::Error::UnclosedContainer)),
            Some(Element::ContainerStart { .. }) => r.skip_container()?,
            Some(_) => {} // skip unknown scalar
        }
    }
    Ok(out)
}

/// Decode the `EndpointList` attribute value.
///
/// # Errors
/// Returns [`ClusterError`] on a type mismatch or out-of-range value.
pub fn decode_endpoint_list(tlv: &[u8]) -> Result<Vec<u16>, ClusterError> {
    let mut r = TlvReader::new(tlv);
    match r.next()? {
        Some(Element::ContainerStart {
            kind: ContainerKind::Array,
            ..
        }) => {}
        _ => {
            return Err(ClusterError::UnexpectedType {
                context: "EndpointList",
            })
        }
    }
    let r = &mut r;
    let mut out = Vec::new();
    loop {
        match r.next()? {
            Some(Element::ContainerEnd) => break,
            Some(Element::Scalar {
                value: Value::Uint(v),
                ..
            }) => {
                out.push(u16::try_from(v).map_err(|_| ClusterError::InvalidLength("EndpointList"))?)
            }
            None => return Err(ClusterError::Tlv(matter_codec::Error::UnclosedContainer)),
            Some(Element::ContainerStart { .. }) => r.skip_container()?,
            Some(_) => {} // skip unknown scalar
        }
    }
    Ok(out)
}