matter_clusters/gen/

thermostat.rs

//! Thermostat cluster (0x0201).
//! @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 = 0x0201;
/// Cluster revision.
pub const CLUSTER_REVISION: u16 = 10;

/// Command IDs (requests and responses).
pub mod command_id {
    /// `SetpointRaiseLower` (request).
    pub const SETPOINT_RAISE_LOWER: u32 = 0x00;
    /// `SetActiveScheduleRequest` (request).
    pub const SET_ACTIVE_SCHEDULE_REQUEST: u32 = 0x05;
    /// `SetActivePresetRequest` (request).
    pub const SET_ACTIVE_PRESET_REQUEST: u32 = 0x06;
    /// `AtomicResponse` (response).
    pub const ATOMIC_RESPONSE: u32 = 0xFD;
    /// `AtomicRequest` (request).
    pub const ATOMIC_REQUEST: u32 = 0xFE;
}

/// Attribute IDs (cluster-specific).
pub mod attribute_id {
    /// `LocalTemperature`.
    pub const LOCAL_TEMPERATURE: u32 = 0x0000;
    /// `OutdoorTemperature`.
    pub const OUTDOOR_TEMPERATURE: u32 = 0x0001;
    /// `Occupancy`.
    pub const OCCUPANCY: u32 = 0x0002;
    /// `AbsMinHeatSetpointLimit`.
    pub const ABS_MIN_HEAT_SETPOINT_LIMIT: u32 = 0x0003;
    /// `AbsMaxHeatSetpointLimit`.
    pub const ABS_MAX_HEAT_SETPOINT_LIMIT: u32 = 0x0004;
    /// `AbsMinCoolSetpointLimit`.
    pub const ABS_MIN_COOL_SETPOINT_LIMIT: u32 = 0x0005;
    /// `AbsMaxCoolSetpointLimit`.
    pub const ABS_MAX_COOL_SETPOINT_LIMIT: u32 = 0x0006;
    /// `LocalTemperatureCalibration`.
    pub const LOCAL_TEMPERATURE_CALIBRATION: u32 = 0x0010;
    /// `OccupiedCoolingSetpoint`.
    pub const OCCUPIED_COOLING_SETPOINT: u32 = 0x0011;
    /// `OccupiedHeatingSetpoint`.
    pub const OCCUPIED_HEATING_SETPOINT: u32 = 0x0012;
    /// `UnoccupiedCoolingSetpoint`.
    pub const UNOCCUPIED_COOLING_SETPOINT: u32 = 0x0013;
    /// `UnoccupiedHeatingSetpoint`.
    pub const UNOCCUPIED_HEATING_SETPOINT: u32 = 0x0014;
    /// `MinHeatSetpointLimit`.
    pub const MIN_HEAT_SETPOINT_LIMIT: u32 = 0x0015;
    /// `MaxHeatSetpointLimit`.
    pub const MAX_HEAT_SETPOINT_LIMIT: u32 = 0x0016;
    /// `MinCoolSetpointLimit`.
    pub const MIN_COOL_SETPOINT_LIMIT: u32 = 0x0017;
    /// `MaxCoolSetpointLimit`.
    pub const MAX_COOL_SETPOINT_LIMIT: u32 = 0x0018;
    /// `MinSetpointDeadBand`.
    pub const MIN_SETPOINT_DEAD_BAND: u32 = 0x0019;
    /// `RemoteSensing`.
    pub const REMOTE_SENSING: u32 = 0x001A;
    /// `ControlSequenceOfOperation`.
    pub const CONTROL_SEQUENCE_OF_OPERATION: u32 = 0x001B;
    /// `SystemMode`.
    pub const SYSTEM_MODE: u32 = 0x001C;
    /// `ThermostatRunningMode`.
    pub const THERMOSTAT_RUNNING_MODE: u32 = 0x001E;
    /// `TemperatureSetpointHold`.
    pub const TEMPERATURE_SETPOINT_HOLD: u32 = 0x0023;
    /// `TemperatureSetpointHoldDuration`.
    pub const TEMPERATURE_SETPOINT_HOLD_DURATION: u32 = 0x0024;
    /// `ThermostatRunningState`.
    pub const THERMOSTAT_RUNNING_STATE: u32 = 0x0029;
    /// `SetpointChangeSource`.
    pub const SETPOINT_CHANGE_SOURCE: u32 = 0x0030;
    /// `SetpointChangeAmount`.
    pub const SETPOINT_CHANGE_AMOUNT: u32 = 0x0031;
    /// `SetpointChangeSourceTimestamp`.
    pub const SETPOINT_CHANGE_SOURCE_TIMESTAMP: u32 = 0x0032;
    /// `EmergencyHeatDelta`.
    pub const EMERGENCY_HEAT_DELTA: u32 = 0x003A;
    /// `AcType`.
    pub const AC_TYPE: u32 = 0x0040;
    /// `AcCapacity`.
    pub const AC_CAPACITY: u32 = 0x0041;
    /// `AcRefrigerantType`.
    pub const AC_REFRIGERANT_TYPE: u32 = 0x0042;
    /// `AcCompressorType`.
    pub const AC_COMPRESSOR_TYPE: u32 = 0x0043;
    /// `AcErrorCode`.
    pub const AC_ERROR_CODE: u32 = 0x0044;
    /// `AcLouverPosition`.
    pub const AC_LOUVER_POSITION: u32 = 0x0045;
    /// `AcCoilTemperature`.
    pub const AC_COIL_TEMPERATURE: u32 = 0x0046;
    /// `AcCapacityFormat`.
    pub const AC_CAPACITY_FORMAT: u32 = 0x0047;
    /// `PresetTypes`.
    pub const PRESET_TYPES: u32 = 0x0048;
    /// `ScheduleTypes`.
    pub const SCHEDULE_TYPES: u32 = 0x0049;
    /// `NumberOfPresets`.
    pub const NUMBER_OF_PRESETS: u32 = 0x004A;
    /// `NumberOfSchedules`.
    pub const NUMBER_OF_SCHEDULES: u32 = 0x004B;
    /// `NumberOfScheduleTransitions`.
    pub const NUMBER_OF_SCHEDULE_TRANSITIONS: u32 = 0x004C;
    /// `NumberOfScheduleTransitionPerDay`.
    pub const NUMBER_OF_SCHEDULE_TRANSITION_PER_DAY: u32 = 0x004D;
    /// `ActivePresetHandle`.
    pub const ACTIVE_PRESET_HANDLE: u32 = 0x004E;
    /// `ActiveScheduleHandle`.
    pub const ACTIVE_SCHEDULE_HANDLE: u32 = 0x004F;
    /// `Presets`.
    pub const PRESETS: u32 = 0x0050;
    /// `Schedules`.
    pub const SCHEDULES: u32 = 0x0051;
    /// `SetpointHoldExpiryTimestamp`.
    pub const SETPOINT_HOLD_EXPIRY_TIMESTAMP: u32 = 0x0052;
}

bitflags::bitflags! {
    /// `Thermostat` feature bits (FeatureMap).
    #[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
    pub struct Feature: u32 {
        /// Heating (HEAT).
        const HEAT = 1 << 0;
        /// Cooling (COOL).
        const COOL = 1 << 1;
        /// Occupancy (OCC).
        const OCC = 1 << 2;
        /// Setback (SB).
        const SB = 1 << 4;
        /// AutoMode (AUTO).
        const AUTO = 1 << 5;
        /// LocalTemperatureNotExposed (LTNE).
        const LTNE = 1 << 6;
        /// MatterScheduleConfiguration (MSCH).
        const MSCH = 1 << 7;
        /// Presets (PRES).
        const PRES = 1 << 8;
    }
}

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

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

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

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

bitflags::bitflags! {
    /// `ACErrorCodeBitmap` (map32).
    #[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
    pub struct ACErrorCodeBitmap: u32 {
        /// CompressorFail.
        const COMPRESSOR_FAIL = 1 << 0;
        /// RoomSensorFail.
        const ROOM_SENSOR_FAIL = 1 << 1;
        /// OutdoorSensorFail.
        const OUTDOOR_SENSOR_FAIL = 1 << 2;
        /// CoilSensorFail.
        const COIL_SENSOR_FAIL = 1 << 3;
        /// FanFail.
        const FAN_FAIL = 1 << 4;
    }
}

/// `ACLouverPositionEnum` (enum8).
#[derive(Copy, Clone, Debug, PartialEq, Eq)]
pub enum ACLouverPositionEnum {
    /// Closed = 1.
    Closed,
    /// Open = 2.
    Open,
    /// Quarter = 3.
    Quarter,
    /// Half = 4.
    Half,
    /// ThreeQuarters = 5.
    ThreeQuarters,
    /// A value not known to this codegen revision.
    Unknown(u8),
}

impl ACLouverPositionEnum {
    /// Decode from its raw discriminant (unknown → `Unknown`).
    #[must_use]
    pub fn from_raw(v: u8) -> Self {
        match v {
            1 => Self::Closed,
            2 => Self::Open,
            3 => Self::Quarter,
            4 => Self::Half,
            5 => Self::ThreeQuarters,
            other => Self::Unknown(other),
        }
    }
    /// The raw discriminant.
    #[must_use]
    pub fn to_raw(self) -> u8 {
        match self {
            Self::Closed => 1,
            Self::Open => 2,
            Self::Quarter => 3,
            Self::Half => 4,
            Self::ThreeQuarters => 5,
            Self::Unknown(v) => v,
        }
    }
}

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

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

/// `ACTypeEnum` (enum8).
#[derive(Copy, Clone, Debug, PartialEq, Eq)]
pub enum ACTypeEnum {
    /// Unknown = 0.
    Unknown,
    /// CoolingFixed = 1.
    CoolingFixed,
    /// HeatPumpFixed = 2.
    HeatPumpFixed,
    /// CoolingInverter = 3.
    CoolingInverter,
    /// HeatPumpInverter = 4.
    HeatPumpInverter,
    /// A value not known to this codegen revision.
    Unrecognized(u8),
}

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

/// `ControlSequenceOfOperationEnum` (enum8).
#[derive(Copy, Clone, Debug, PartialEq, Eq)]
pub enum ControlSequenceOfOperationEnum {
    /// CoolingOnly = 0.
    CoolingOnly,
    /// CoolingWithReheat = 1.
    CoolingWithReheat,
    /// HeatingOnly = 2.
    HeatingOnly,
    /// HeatingWithReheat = 3.
    HeatingWithReheat,
    /// CoolingAndHeating = 4.
    CoolingAndHeating,
    /// CoolingAndHeatingWithReheat = 5.
    CoolingAndHeatingWithReheat,
    /// A value not known to this codegen revision.
    Unknown(u8),
}

impl ControlSequenceOfOperationEnum {
    /// Decode from its raw discriminant (unknown → `Unknown`).
    #[must_use]
    pub fn from_raw(v: u8) -> Self {
        match v {
            0 => Self::CoolingOnly,
            1 => Self::CoolingWithReheat,
            2 => Self::HeatingOnly,
            3 => Self::HeatingWithReheat,
            4 => Self::CoolingAndHeating,
            5 => Self::CoolingAndHeatingWithReheat,
            other => Self::Unknown(other),
        }
    }
    /// The raw discriminant.
    #[must_use]
    pub fn to_raw(self) -> u8 {
        match self {
            Self::CoolingOnly => 0,
            Self::CoolingWithReheat => 1,
            Self::HeatingOnly => 2,
            Self::HeatingWithReheat => 3,
            Self::CoolingAndHeating => 4,
            Self::CoolingAndHeatingWithReheat => 5,
            Self::Unknown(v) => v,
        }
    }
}

bitflags::bitflags! {
    /// `OccupancyBitmap` (map8).
    #[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
    pub struct OccupancyBitmap: u8 {
        /// Occupied.
        const OCCUPIED = 1 << 0;
    }
}

/// `PresetScenarioEnum` (enum8).
#[derive(Copy, Clone, Debug, PartialEq, Eq)]
pub enum PresetScenarioEnum {
    /// Occupied = 1.
    Occupied,
    /// Unoccupied = 2.
    Unoccupied,
    /// Sleep = 3.
    Sleep,
    /// Wake = 4.
    Wake,
    /// Vacation = 5.
    Vacation,
    /// GoingToSleep = 6.
    GoingToSleep,
    /// UserDefined = 254.
    UserDefined,
    /// A value not known to this codegen revision.
    Unknown(u8),
}

impl PresetScenarioEnum {
    /// Decode from its raw discriminant (unknown → `Unknown`).
    #[must_use]
    pub fn from_raw(v: u8) -> Self {
        match v {
            1 => Self::Occupied,
            2 => Self::Unoccupied,
            3 => Self::Sleep,
            4 => Self::Wake,
            5 => Self::Vacation,
            6 => Self::GoingToSleep,
            254 => Self::UserDefined,
            other => Self::Unknown(other),
        }
    }
    /// The raw discriminant.
    #[must_use]
    pub fn to_raw(self) -> u8 {
        match self {
            Self::Occupied => 1,
            Self::Unoccupied => 2,
            Self::Sleep => 3,
            Self::Wake => 4,
            Self::Vacation => 5,
            Self::GoingToSleep => 6,
            Self::UserDefined => 254,
            Self::Unknown(v) => v,
        }
    }
}

/// `PresetStruct` struct.
#[derive(Clone, Debug, PartialEq)]
#[non_exhaustive]
pub struct PresetStruct {
    /// Field PresetHandle (tag 0).
    pub preset_handle: Nullable<Vec<u8>>,
    /// Field PresetScenario (tag 1).
    pub preset_scenario: PresetScenarioEnum,
    /// Field Name (tag 2).
    pub name: Option<Nullable<String>>,
    /// Field CoolingSetpoint (tag 3).
    pub cooling_setpoint: Option<i16>,
    /// Field HeatingSetpoint (tag 4).
    pub heating_setpoint: Option<i16>,
    /// Field BuiltIn (tag 5).
    pub built_in: Nullable<bool>,
}

bitflags::bitflags! {
    /// `PresetTypeFeaturesBitmap` (map16).
    #[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
    pub struct PresetTypeFeaturesBitmap: u16 {
        /// Automatic.
        const AUTOMATIC = 1 << 0;
        /// SupportsNames.
        const SUPPORTS_NAMES = 1 << 1;
    }
}

/// `PresetTypeStruct` struct.
#[derive(Clone, Debug, PartialEq)]
#[non_exhaustive]
pub struct PresetTypeStruct {
    /// Field PresetScenario (tag 0).
    pub preset_scenario: PresetScenarioEnum,
    /// Field NumberOfPresets (tag 1).
    pub number_of_presets: u8,
    /// Field PresetTypeFeatures (tag 2).
    pub preset_type_features: PresetTypeFeaturesBitmap,
}

bitflags::bitflags! {
    /// `RelayStateBitmap` (map16).
    #[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
    pub struct RelayStateBitmap: u16 {
        /// Heat.
        const HEAT = 1 << 0;
        /// Cool.
        const COOL = 1 << 1;
        /// Fan.
        const FAN = 1 << 2;
        /// HeatStage2.
        const HEAT_STAGE2 = 1 << 3;
        /// CoolStage2.
        const COOL_STAGE2 = 1 << 4;
        /// FanStage2.
        const FAN_STAGE2 = 1 << 5;
        /// FanStage3.
        const FAN_STAGE3 = 1 << 6;
    }
}

bitflags::bitflags! {
    /// `RemoteSensingBitmap` (map8).
    #[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
    pub struct RemoteSensingBitmap: u8 {
        /// LocalTemperature.
        const LOCAL_TEMPERATURE = 1 << 0;
        /// OutdoorTemperature.
        const OUTDOOR_TEMPERATURE = 1 << 1;
        /// Occupancy.
        const OCCUPANCY = 1 << 2;
    }
}

bitflags::bitflags! {
    /// `ScheduleDayOfWeekBitmap` (map8).
    #[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
    pub struct ScheduleDayOfWeekBitmap: u8 {
        /// Sunday.
        const SUNDAY = 1 << 0;
        /// Monday.
        const MONDAY = 1 << 1;
        /// Tuesday.
        const TUESDAY = 1 << 2;
        /// Wednesday.
        const WEDNESDAY = 1 << 3;
        /// Thursday.
        const THURSDAY = 1 << 4;
        /// Friday.
        const FRIDAY = 1 << 5;
        /// Saturday.
        const SATURDAY = 1 << 6;
        /// Away.
        const AWAY = 1 << 7;
    }
}

bitflags::bitflags! {
    /// `ScheduleModeBitmap` (map8).
    #[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
    pub struct ScheduleModeBitmap: u8 {
        /// HeatSetpointPresent.
        const HEAT_SETPOINT_PRESENT = 1 << 0;
        /// CoolSetpointPresent.
        const COOL_SETPOINT_PRESENT = 1 << 1;
    }
}

/// `ScheduleStruct` struct.
#[derive(Clone, Debug, PartialEq)]
#[non_exhaustive]
pub struct ScheduleStruct {
    /// Field ScheduleHandle (tag 0).
    pub schedule_handle: Nullable<Vec<u8>>,
    /// Field SystemMode (tag 1).
    pub system_mode: SystemModeEnum,
    /// Field Name (tag 2).
    pub name: Option<String>,
    /// Field PresetHandle (tag 3).
    pub preset_handle: Option<Vec<u8>>,
    /// Field Transitions (tag 4).
    pub transitions: Vec<ScheduleTransitionStruct>,
    /// Field BuiltIn (tag 5).
    pub built_in: Nullable<bool>,
}

/// `ScheduleTransitionStruct` struct.
#[derive(Clone, Debug, PartialEq)]
#[non_exhaustive]
pub struct ScheduleTransitionStruct {
    /// Field DayOfWeek (tag 0).
    pub day_of_week: ScheduleDayOfWeekBitmap,
    /// Field TransitionTime (tag 1).
    pub transition_time: u16,
    /// Field PresetHandle (tag 2).
    pub preset_handle: Option<Vec<u8>>,
    /// Field SystemMode (tag 3).
    pub system_mode: Option<SystemModeEnum>,
    /// Field CoolingSetpoint (tag 4).
    pub cooling_setpoint: Option<i16>,
    /// Field HeatingSetpoint (tag 5).
    pub heating_setpoint: Option<i16>,
}

bitflags::bitflags! {
    /// `ScheduleTypeFeaturesBitmap` (map16).
    #[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
    pub struct ScheduleTypeFeaturesBitmap: u16 {
        /// SupportsPresets.
        const SUPPORTS_PRESETS = 1 << 0;
        /// SupportsSetpoints.
        const SUPPORTS_SETPOINTS = 1 << 1;
        /// SupportsNames.
        const SUPPORTS_NAMES = 1 << 2;
        /// SupportsOff.
        const SUPPORTS_OFF = 1 << 3;
    }
}

/// `ScheduleTypeStruct` struct.
#[derive(Clone, Debug, PartialEq)]
#[non_exhaustive]
pub struct ScheduleTypeStruct {
    /// Field SystemMode (tag 0).
    pub system_mode: SystemModeEnum,
    /// Field NumberOfSchedules (tag 1).
    pub number_of_schedules: u8,
    /// Field ScheduleTypeFeatures (tag 2).
    pub schedule_type_features: ScheduleTypeFeaturesBitmap,
}

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

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

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

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

/// `StartOfWeekEnum` (enum8).
#[derive(Copy, Clone, Debug, PartialEq, Eq)]
pub enum StartOfWeekEnum {
    /// Sunday = 0.
    Sunday,
    /// Monday = 1.
    Monday,
    /// Tuesday = 2.
    Tuesday,
    /// Wednesday = 3.
    Wednesday,
    /// Thursday = 4.
    Thursday,
    /// Friday = 5.
    Friday,
    /// Saturday = 6.
    Saturday,
    /// A value not known to this codegen revision.
    Unknown(u8),
}

impl StartOfWeekEnum {
    /// Decode from its raw discriminant (unknown → `Unknown`).
    #[must_use]
    pub fn from_raw(v: u8) -> Self {
        match v {
            0 => Self::Sunday,
            1 => Self::Monday,
            2 => Self::Tuesday,
            3 => Self::Wednesday,
            4 => Self::Thursday,
            5 => Self::Friday,
            6 => Self::Saturday,
            other => Self::Unknown(other),
        }
    }
    /// The raw discriminant.
    #[must_use]
    pub fn to_raw(self) -> u8 {
        match self {
            Self::Sunday => 0,
            Self::Monday => 1,
            Self::Tuesday => 2,
            Self::Wednesday => 3,
            Self::Thursday => 4,
            Self::Friday => 5,
            Self::Saturday => 6,
            Self::Unknown(v) => v,
        }
    }
}

/// `SystemModeEnum` (enum8).
#[derive(Copy, Clone, Debug, PartialEq, Eq)]
pub enum SystemModeEnum {
    /// Off = 0.
    Off,
    /// Auto = 1.
    Auto,
    /// Cool = 3.
    Cool,
    /// Heat = 4.
    Heat,
    /// EmergencyHeat = 5.
    EmergencyHeat,
    /// Precooling = 6.
    Precooling,
    /// FanOnly = 7.
    FanOnly,
    /// Dry = 8.
    Dry,
    /// Sleep = 9.
    Sleep,
    /// A value not known to this codegen revision.
    Unknown(u8),
}

impl SystemModeEnum {
    /// Decode from its raw discriminant (unknown → `Unknown`).
    #[must_use]
    pub fn from_raw(v: u8) -> Self {
        match v {
            0 => Self::Off,
            1 => Self::Auto,
            3 => Self::Cool,
            4 => Self::Heat,
            5 => Self::EmergencyHeat,
            6 => Self::Precooling,
            7 => Self::FanOnly,
            8 => Self::Dry,
            9 => Self::Sleep,
            other => Self::Unknown(other),
        }
    }
    /// The raw discriminant.
    #[must_use]
    pub fn to_raw(self) -> u8 {
        match self {
            Self::Off => 0,
            Self::Auto => 1,
            Self::Cool => 3,
            Self::Heat => 4,
            Self::EmergencyHeat => 5,
            Self::Precooling => 6,
            Self::FanOnly => 7,
            Self::Dry => 8,
            Self::Sleep => 9,
            Self::Unknown(v) => v,
        }
    }
}

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

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

/// `ThermostatAttributeStatusEntryStruct` struct.
#[derive(Clone, Debug, PartialEq)]
#[non_exhaustive]
pub struct ThermostatAttributeStatusEntryStruct {
    /// Field AttributeId (tag 0).
    pub attribute_id: u32,
    /// Field StatusCode (tag 1).
    pub status_code: u8,
}

/// `ThermostatRunningModeEnum` (enum8).
#[derive(Copy, Clone, Debug, PartialEq, Eq)]
pub enum ThermostatRunningModeEnum {
    /// Off = 0.
    Off,
    /// Cool = 3.
    Cool,
    /// Heat = 4.
    Heat,
    /// A value not known to this codegen revision.
    Unknown(u8),
}

impl ThermostatRunningModeEnum {
    /// Decode from its raw discriminant (unknown → `Unknown`).
    #[must_use]
    pub fn from_raw(v: u8) -> Self {
        match v {
            0 => Self::Off,
            3 => Self::Cool,
            4 => Self::Heat,
            other => Self::Unknown(other),
        }
    }
    /// The raw discriminant.
    #[must_use]
    pub fn to_raw(self) -> u8 {
        match self {
            Self::Off => 0,
            Self::Cool => 3,
            Self::Heat => 4,
            Self::Unknown(v) => v,
        }
    }
}

/// `WeeklyScheduleTransitionStruct` struct.
#[derive(Clone, Debug, PartialEq)]
#[non_exhaustive]
pub struct WeeklyScheduleTransitionStruct {
    /// Field TransitionTime (tag 0).
    pub transition_time: u16,
    /// Field HeatSetpoint (tag 1).
    pub heat_setpoint: Nullable<i16>,
    /// Field CoolSetpoint (tag 2).
    pub cool_setpoint: Nullable<i16>,
}

impl PresetStruct {
    /// Decode the fields of an already-opened anonymous structure
    /// (reader positioned after the struct start; consumes to its end).
    ///
    /// # Errors
    /// Returns [`ClusterError`] on a malformed structure or missing required field.
    pub fn decode_from(r: &mut TlvReader<'_>) -> Result<Self, ClusterError> {
        let mut f_preset_handle: Option<Nullable<Vec<u8>>> = None;
        let mut f_preset_scenario: Option<PresetScenarioEnum> = None;
        let mut f_name: Option<Nullable<String>> = None;
        let mut f_cooling_setpoint: Option<i16> = None;
        let mut f_heating_setpoint: Option<i16> = None;
        let mut f_built_in: Option<Nullable<bool>> = None;
        loop {
            match r.next()? {
                Some(Element::ContainerEnd) => break,
                Some(Element::Scalar {
                    tag: Tag::Context(0),
                    value: Value::Null,
                }) => f_preset_handle = Some(Nullable::Null),
                Some(Element::Scalar {
                    tag: Tag::Context(0),
                    value: Value::Bytes(v),
                }) => f_preset_handle = Some(Nullable::Value(v)),
                Some(Element::Scalar {
                    tag: Tag::Context(1),
                    value: Value::Uint(v),
                }) => {
                    f_preset_scenario = Some(PresetScenarioEnum::from_raw(
                        u8::try_from(v)
                            .map_err(|_| ClusterError::InvalidLength("PresetScenario"))?,
                    ))
                }
                Some(Element::Scalar {
                    tag: Tag::Context(2),
                    value: Value::Null,
                }) => f_name = Some(Nullable::Null),
                Some(Element::Scalar {
                    tag: Tag::Context(2),
                    value: Value::Utf8(v),
                }) => f_name = Some(Nullable::Value(v)),
                Some(Element::Scalar {
                    tag: Tag::Context(3),
                    value: Value::Int(v),
                }) => {
                    f_cooling_setpoint = Some(
                        i16::try_from(v)
                            .map_err(|_| ClusterError::InvalidLength("CoolingSetpoint"))?,
                    )
                }
                Some(Element::Scalar {
                    tag: Tag::Context(4),
                    value: Value::Int(v),
                }) => {
                    f_heating_setpoint = Some(
                        i16::try_from(v)
                            .map_err(|_| ClusterError::InvalidLength("HeatingSetpoint"))?,
                    )
                }
                Some(Element::Scalar {
                    tag: Tag::Context(5),
                    value: Value::Null,
                }) => f_built_in = Some(Nullable::Null),
                Some(Element::Scalar {
                    tag: Tag::Context(5),
                    value: Value::Bool(v),
                }) => f_built_in = Some(Nullable::Value(v)),
                None => return Err(ClusterError::Tlv(matter_codec::Error::UnclosedContainer)),
                Some(Element::ContainerStart { .. }) => r.skip_container()?,
                Some(_) => {} // unknown/future scalar — skip
            }
        }
        Ok(Self {
            preset_handle: f_preset_handle.ok_or(ClusterError::MissingField("PresetHandle"))?,
            preset_scenario: f_preset_scenario
                .ok_or(ClusterError::MissingField("PresetScenario"))?,
            name: f_name,
            cooling_setpoint: f_cooling_setpoint,
            heating_setpoint: f_heating_setpoint,
            built_in: f_built_in.ok_or(ClusterError::MissingField("BuiltIn"))?,
        })
    }
    /// Decode from a standalone anonymous TLV structure.
    ///
    /// # Errors
    /// Returns [`ClusterError`] if the bytes are not an anonymous structure or a field is malformed.
    pub fn decode(tlv: &[u8]) -> Result<Self, ClusterError> {
        let mut r = TlvReader::new(tlv);
        match r.next()? {
            Some(Element::ContainerStart {
                kind: ContainerKind::Structure,
                ..
            }) => {}
            _ => {
                return Err(ClusterError::UnexpectedType {
                    context: "PresetStruct",
                })
            }
        }
        Self::decode_from(&mut r)
    }
    /// Write this struct's fields into an already-open container.
    #[allow(clippy::expect_used)] // Vec-backed TlvWriter is infallible.
    pub fn write_fields(&self, w: &mut TlvWriter<'_>) {
        match &self.preset_handle {
            Nullable::Null => w.put_null(Tag::Context(0)).expect("infallible: vec writer"),
            Nullable::Value(preset_handle) => {
                w.put_bytes(Tag::Context(0), &*preset_handle)
                    .expect("infallible: vec writer");
            }
        }
        w.put_uint(Tag::Context(1), u64::from(self.preset_scenario.to_raw()))
            .expect("infallible: vec writer");
        if let Some(name) = &self.name {
            match name {
                Nullable::Null => w.put_null(Tag::Context(2)).expect("infallible: vec writer"),
                Nullable::Value(name) => {
                    w.put_utf8(Tag::Context(2), &*name)
                        .expect("infallible: vec writer");
                }
            }
        }
        if let Some(cooling_setpoint) = &self.cooling_setpoint {
            w.put_int(Tag::Context(3), i64::from(*cooling_setpoint))
                .expect("infallible: vec writer");
        }
        if let Some(heating_setpoint) = &self.heating_setpoint {
            w.put_int(Tag::Context(4), i64::from(*heating_setpoint))
                .expect("infallible: vec writer");
        }
        match &self.built_in {
            Nullable::Null => w.put_null(Tag::Context(5)).expect("infallible: vec writer"),
            Nullable::Value(built_in) => {
                w.put_bool(Tag::Context(5), *built_in)
                    .expect("infallible: vec writer");
            }
        }
    }
    /// Encode as a standalone anonymous TLV structure.
    #[must_use]
    #[allow(clippy::expect_used)] // Vec-backed TlvWriter is infallible.
    pub fn encode(&self) -> Vec<u8> {
        let mut buf = Vec::new();
        let mut w = TlvWriter::new(&mut buf);
        w.start_structure(Tag::Anonymous)
            .expect("infallible: vec writer");
        self.write_fields(&mut w);
        w.end_container().expect("infallible: vec writer");
        buf
    }
}

impl PresetTypeStruct {
    /// Decode the fields of an already-opened anonymous structure
    /// (reader positioned after the struct start; consumes to its end).
    ///
    /// # Errors
    /// Returns [`ClusterError`] on a malformed structure or missing required field.
    pub fn decode_from(r: &mut TlvReader<'_>) -> Result<Self, ClusterError> {
        let mut f_preset_scenario: Option<PresetScenarioEnum> = None;
        let mut f_number_of_presets: Option<u8> = None;
        let mut f_preset_type_features: Option<PresetTypeFeaturesBitmap> = None;
        loop {
            match r.next()? {
                Some(Element::ContainerEnd) => break,
                Some(Element::Scalar {
                    tag: Tag::Context(0),
                    value: Value::Uint(v),
                }) => {
                    f_preset_scenario = Some(PresetScenarioEnum::from_raw(
                        u8::try_from(v)
                            .map_err(|_| ClusterError::InvalidLength("PresetScenario"))?,
                    ))
                }
                Some(Element::Scalar {
                    tag: Tag::Context(1),
                    value: Value::Uint(v),
                }) => {
                    f_number_of_presets = Some(
                        u8::try_from(v)
                            .map_err(|_| ClusterError::InvalidLength("NumberOfPresets"))?,
                    )
                }
                Some(Element::Scalar {
                    tag: Tag::Context(2),
                    value: Value::Uint(v),
                }) => {
                    f_preset_type_features = Some(PresetTypeFeaturesBitmap::from_bits_retain(
                        u16::try_from(v)
                            .map_err(|_| ClusterError::InvalidLength("PresetTypeFeatures"))?,
                    ))
                }
                None => return Err(ClusterError::Tlv(matter_codec::Error::UnclosedContainer)),
                Some(Element::ContainerStart { .. }) => r.skip_container()?,
                Some(_) => {} // unknown/future scalar — skip
            }
        }
        Ok(Self {
            preset_scenario: f_preset_scenario
                .ok_or(ClusterError::MissingField("PresetScenario"))?,
            number_of_presets: f_number_of_presets
                .ok_or(ClusterError::MissingField("NumberOfPresets"))?,
            preset_type_features: f_preset_type_features
                .ok_or(ClusterError::MissingField("PresetTypeFeatures"))?,
        })
    }
    /// Decode from a standalone anonymous TLV structure.
    ///
    /// # Errors
    /// Returns [`ClusterError`] if the bytes are not an anonymous structure or a field is malformed.
    pub fn decode(tlv: &[u8]) -> Result<Self, ClusterError> {
        let mut r = TlvReader::new(tlv);
        match r.next()? {
            Some(Element::ContainerStart {
                kind: ContainerKind::Structure,
                ..
            }) => {}
            _ => {
                return Err(ClusterError::UnexpectedType {
                    context: "PresetTypeStruct",
                })
            }
        }
        Self::decode_from(&mut r)
    }
    /// Write this struct's fields into an already-open container.
    #[allow(clippy::expect_used)] // Vec-backed TlvWriter is infallible.
    pub fn write_fields(&self, w: &mut TlvWriter<'_>) {
        w.put_uint(Tag::Context(0), u64::from(self.preset_scenario.to_raw()))
            .expect("infallible: vec writer");
        w.put_uint(Tag::Context(1), u64::from(self.number_of_presets))
            .expect("infallible: vec writer");
        w.put_uint(Tag::Context(2), u64::from(self.preset_type_features.bits()))
            .expect("infallible: vec writer");
    }
    /// Encode as a standalone anonymous TLV structure.
    #[must_use]
    #[allow(clippy::expect_used)] // Vec-backed TlvWriter is infallible.
    pub fn encode(&self) -> Vec<u8> {
        let mut buf = Vec::new();
        let mut w = TlvWriter::new(&mut buf);
        w.start_structure(Tag::Anonymous)
            .expect("infallible: vec writer");
        self.write_fields(&mut w);
        w.end_container().expect("infallible: vec writer");
        buf
    }
}

impl ScheduleStruct {
    /// Decode the fields of an already-opened anonymous structure
    /// (reader positioned after the struct start; consumes to its end).
    ///
    /// # Errors
    /// Returns [`ClusterError`] on a malformed structure or missing required field.
    pub fn decode_from(r: &mut TlvReader<'_>) -> Result<Self, ClusterError> {
        let mut f_schedule_handle: Option<Nullable<Vec<u8>>> = None;
        let mut f_system_mode: Option<SystemModeEnum> = None;
        let mut f_name: Option<String> = None;
        let mut f_preset_handle: Option<Vec<u8>> = None;
        let mut f_transitions: Option<Vec<ScheduleTransitionStruct>> = None;
        let mut f_built_in: Option<Nullable<bool>> = None;
        loop {
            match r.next()? {
                Some(Element::ContainerEnd) => break,
                Some(Element::Scalar {
                    tag: Tag::Context(0),
                    value: Value::Null,
                }) => f_schedule_handle = Some(Nullable::Null),
                Some(Element::Scalar {
                    tag: Tag::Context(0),
                    value: Value::Bytes(v),
                }) => f_schedule_handle = Some(Nullable::Value(v)),
                Some(Element::Scalar {
                    tag: Tag::Context(1),
                    value: Value::Uint(v),
                }) => {
                    f_system_mode = Some(SystemModeEnum::from_raw(
                        u8::try_from(v).map_err(|_| ClusterError::InvalidLength("SystemMode"))?,
                    ))
                }
                Some(Element::Scalar {
                    tag: Tag::Context(2),
                    value: Value::Utf8(v),
                }) => f_name = Some(v),
                Some(Element::Scalar {
                    tag: Tag::Context(3),
                    value: Value::Bytes(v),
                }) => f_preset_handle = Some(v),
                Some(Element::ContainerStart {
                    tag: Tag::Context(4),
                    kind: ContainerKind::Array,
                }) => {
                    let mut out = Vec::new();
                    loop {
                        match r.next()? {
                            Some(Element::ContainerEnd) => break,
                            Some(Element::ContainerStart {
                                kind: ContainerKind::Structure,
                                ..
                            }) => {
                                out.push(ScheduleTransitionStruct::decode_from(r)?);
                            }
                            None => {
                                return Err(ClusterError::Tlv(
                                    matter_codec::Error::UnclosedContainer,
                                ))
                            }
                            Some(Element::ContainerStart { .. }) => r.skip_container()?,
                            Some(_) => {} // skip unknown scalar
                        }
                    }
                    f_transitions = Some(out);
                }
                Some(Element::Scalar {
                    tag: Tag::Context(5),
                    value: Value::Null,
                }) => f_built_in = Some(Nullable::Null),
                Some(Element::Scalar {
                    tag: Tag::Context(5),
                    value: Value::Bool(v),
                }) => f_built_in = Some(Nullable::Value(v)),
                None => return Err(ClusterError::Tlv(matter_codec::Error::UnclosedContainer)),
                Some(Element::ContainerStart { .. }) => r.skip_container()?,
                Some(_) => {} // unknown/future scalar — skip
            }
        }
        Ok(Self {
            schedule_handle: f_schedule_handle
                .ok_or(ClusterError::MissingField("ScheduleHandle"))?,
            system_mode: f_system_mode.ok_or(ClusterError::MissingField("SystemMode"))?,
            name: f_name,
            preset_handle: f_preset_handle,
            transitions: f_transitions.ok_or(ClusterError::MissingField("Transitions"))?,
            built_in: f_built_in.ok_or(ClusterError::MissingField("BuiltIn"))?,
        })
    }
    /// Decode from a standalone anonymous TLV structure.
    ///
    /// # Errors
    /// Returns [`ClusterError`] if the bytes are not an anonymous structure or a field is malformed.
    pub fn decode(tlv: &[u8]) -> Result<Self, ClusterError> {
        let mut r = TlvReader::new(tlv);
        match r.next()? {
            Some(Element::ContainerStart {
                kind: ContainerKind::Structure,
                ..
            }) => {}
            _ => {
                return Err(ClusterError::UnexpectedType {
                    context: "ScheduleStruct",
                })
            }
        }
        Self::decode_from(&mut r)
    }
}

impl ScheduleTransitionStruct {
    /// Decode the fields of an already-opened anonymous structure
    /// (reader positioned after the struct start; consumes to its end).
    ///
    /// # Errors
    /// Returns [`ClusterError`] on a malformed structure or missing required field.
    pub fn decode_from(r: &mut TlvReader<'_>) -> Result<Self, ClusterError> {
        let mut f_day_of_week: Option<ScheduleDayOfWeekBitmap> = None;
        let mut f_transition_time: Option<u16> = None;
        let mut f_preset_handle: Option<Vec<u8>> = None;
        let mut f_system_mode: Option<SystemModeEnum> = None;
        let mut f_cooling_setpoint: Option<i16> = None;
        let mut f_heating_setpoint: Option<i16> = None;
        loop {
            match r.next()? {
                Some(Element::ContainerEnd) => break,
                Some(Element::Scalar {
                    tag: Tag::Context(0),
                    value: Value::Uint(v),
                }) => {
                    f_day_of_week = Some(ScheduleDayOfWeekBitmap::from_bits_retain(
                        u8::try_from(v).map_err(|_| ClusterError::InvalidLength("DayOfWeek"))?,
                    ))
                }
                Some(Element::Scalar {
                    tag: Tag::Context(1),
                    value: Value::Uint(v),
                }) => {
                    f_transition_time = Some(
                        u16::try_from(v)
                            .map_err(|_| ClusterError::InvalidLength("TransitionTime"))?,
                    )
                }
                Some(Element::Scalar {
                    tag: Tag::Context(2),
                    value: Value::Bytes(v),
                }) => f_preset_handle = Some(v),
                Some(Element::Scalar {
                    tag: Tag::Context(3),
                    value: Value::Uint(v),
                }) => {
                    f_system_mode = Some(SystemModeEnum::from_raw(
                        u8::try_from(v).map_err(|_| ClusterError::InvalidLength("SystemMode"))?,
                    ))
                }
                Some(Element::Scalar {
                    tag: Tag::Context(4),
                    value: Value::Int(v),
                }) => {
                    f_cooling_setpoint = Some(
                        i16::try_from(v)
                            .map_err(|_| ClusterError::InvalidLength("CoolingSetpoint"))?,
                    )
                }
                Some(Element::Scalar {
                    tag: Tag::Context(5),
                    value: Value::Int(v),
                }) => {
                    f_heating_setpoint = Some(
                        i16::try_from(v)
                            .map_err(|_| ClusterError::InvalidLength("HeatingSetpoint"))?,
                    )
                }
                None => return Err(ClusterError::Tlv(matter_codec::Error::UnclosedContainer)),
                Some(Element::ContainerStart { .. }) => r.skip_container()?,
                Some(_) => {} // unknown/future scalar — skip
            }
        }
        Ok(Self {
            day_of_week: f_day_of_week.ok_or(ClusterError::MissingField("DayOfWeek"))?,
            transition_time: f_transition_time
                .ok_or(ClusterError::MissingField("TransitionTime"))?,
            preset_handle: f_preset_handle,
            system_mode: f_system_mode,
            cooling_setpoint: f_cooling_setpoint,
            heating_setpoint: f_heating_setpoint,
        })
    }
    /// Decode from a standalone anonymous TLV structure.
    ///
    /// # Errors
    /// Returns [`ClusterError`] if the bytes are not an anonymous structure or a field is malformed.
    pub fn decode(tlv: &[u8]) -> Result<Self, ClusterError> {
        let mut r = TlvReader::new(tlv);
        match r.next()? {
            Some(Element::ContainerStart {
                kind: ContainerKind::Structure,
                ..
            }) => {}
            _ => {
                return Err(ClusterError::UnexpectedType {
                    context: "ScheduleTransitionStruct",
                })
            }
        }
        Self::decode_from(&mut r)
    }
    /// Write this struct's fields into an already-open container.
    #[allow(clippy::expect_used)] // Vec-backed TlvWriter is infallible.
    pub fn write_fields(&self, w: &mut TlvWriter<'_>) {
        w.put_uint(Tag::Context(0), u64::from(self.day_of_week.bits()))
            .expect("infallible: vec writer");
        w.put_uint(Tag::Context(1), u64::from(self.transition_time))
            .expect("infallible: vec writer");
        if let Some(preset_handle) = &self.preset_handle {
            w.put_bytes(Tag::Context(2), &*preset_handle)
                .expect("infallible: vec writer");
        }
        if let Some(system_mode) = &self.system_mode {
            w.put_uint(Tag::Context(3), u64::from((*system_mode).to_raw()))
                .expect("infallible: vec writer");
        }
        if let Some(cooling_setpoint) = &self.cooling_setpoint {
            w.put_int(Tag::Context(4), i64::from(*cooling_setpoint))
                .expect("infallible: vec writer");
        }
        if let Some(heating_setpoint) = &self.heating_setpoint {
            w.put_int(Tag::Context(5), i64::from(*heating_setpoint))
                .expect("infallible: vec writer");
        }
    }
    /// Encode as a standalone anonymous TLV structure.
    #[must_use]
    #[allow(clippy::expect_used)] // Vec-backed TlvWriter is infallible.
    pub fn encode(&self) -> Vec<u8> {
        let mut buf = Vec::new();
        let mut w = TlvWriter::new(&mut buf);
        w.start_structure(Tag::Anonymous)
            .expect("infallible: vec writer");
        self.write_fields(&mut w);
        w.end_container().expect("infallible: vec writer");
        buf
    }
}

impl ScheduleTypeStruct {
    /// Decode the fields of an already-opened anonymous structure
    /// (reader positioned after the struct start; consumes to its end).
    ///
    /// # Errors
    /// Returns [`ClusterError`] on a malformed structure or missing required field.
    pub fn decode_from(r: &mut TlvReader<'_>) -> Result<Self, ClusterError> {
        let mut f_system_mode: Option<SystemModeEnum> = None;
        let mut f_number_of_schedules: Option<u8> = None;
        let mut f_schedule_type_features: Option<ScheduleTypeFeaturesBitmap> = None;
        loop {
            match r.next()? {
                Some(Element::ContainerEnd) => break,
                Some(Element::Scalar {
                    tag: Tag::Context(0),
                    value: Value::Uint(v),
                }) => {
                    f_system_mode = Some(SystemModeEnum::from_raw(
                        u8::try_from(v).map_err(|_| ClusterError::InvalidLength("SystemMode"))?,
                    ))
                }
                Some(Element::Scalar {
                    tag: Tag::Context(1),
                    value: Value::Uint(v),
                }) => {
                    f_number_of_schedules = Some(
                        u8::try_from(v)
                            .map_err(|_| ClusterError::InvalidLength("NumberOfSchedules"))?,
                    )
                }
                Some(Element::Scalar {
                    tag: Tag::Context(2),
                    value: Value::Uint(v),
                }) => {
                    f_schedule_type_features = Some(ScheduleTypeFeaturesBitmap::from_bits_retain(
                        u16::try_from(v)
                            .map_err(|_| ClusterError::InvalidLength("ScheduleTypeFeatures"))?,
                    ))
                }
                None => return Err(ClusterError::Tlv(matter_codec::Error::UnclosedContainer)),
                Some(Element::ContainerStart { .. }) => r.skip_container()?,
                Some(_) => {} // unknown/future scalar — skip
            }
        }
        Ok(Self {
            system_mode: f_system_mode.ok_or(ClusterError::MissingField("SystemMode"))?,
            number_of_schedules: f_number_of_schedules
                .ok_or(ClusterError::MissingField("NumberOfSchedules"))?,
            schedule_type_features: f_schedule_type_features
                .ok_or(ClusterError::MissingField("ScheduleTypeFeatures"))?,
        })
    }
    /// Decode from a standalone anonymous TLV structure.
    ///
    /// # Errors
    /// Returns [`ClusterError`] if the bytes are not an anonymous structure or a field is malformed.
    pub fn decode(tlv: &[u8]) -> Result<Self, ClusterError> {
        let mut r = TlvReader::new(tlv);
        match r.next()? {
            Some(Element::ContainerStart {
                kind: ContainerKind::Structure,
                ..
            }) => {}
            _ => {
                return Err(ClusterError::UnexpectedType {
                    context: "ScheduleTypeStruct",
                })
            }
        }
        Self::decode_from(&mut r)
    }
    /// Write this struct's fields into an already-open container.
    #[allow(clippy::expect_used)] // Vec-backed TlvWriter is infallible.
    pub fn write_fields(&self, w: &mut TlvWriter<'_>) {
        w.put_uint(Tag::Context(0), u64::from(self.system_mode.to_raw()))
            .expect("infallible: vec writer");
        w.put_uint(Tag::Context(1), u64::from(self.number_of_schedules))
            .expect("infallible: vec writer");
        w.put_uint(
            Tag::Context(2),
            u64::from(self.schedule_type_features.bits()),
        )
        .expect("infallible: vec writer");
    }
    /// Encode as a standalone anonymous TLV structure.
    #[must_use]
    #[allow(clippy::expect_used)] // Vec-backed TlvWriter is infallible.
    pub fn encode(&self) -> Vec<u8> {
        let mut buf = Vec::new();
        let mut w = TlvWriter::new(&mut buf);
        w.start_structure(Tag::Anonymous)
            .expect("infallible: vec writer");
        self.write_fields(&mut w);
        w.end_container().expect("infallible: vec writer");
        buf
    }
}

impl ThermostatAttributeStatusEntryStruct {
    /// Decode the fields of an already-opened anonymous structure
    /// (reader positioned after the struct start; consumes to its end).
    ///
    /// # Errors
    /// Returns [`ClusterError`] on a malformed structure or missing required field.
    pub fn decode_from(r: &mut TlvReader<'_>) -> Result<Self, ClusterError> {
        let mut f_attribute_id: Option<u32> = None;
        let mut f_status_code: Option<u8> = None;
        loop {
            match r.next()? {
                Some(Element::ContainerEnd) => break,
                Some(Element::Scalar {
                    tag: Tag::Context(0),
                    value: Value::Uint(v),
                }) => {
                    f_attribute_id = Some(
                        u32::try_from(v).map_err(|_| ClusterError::InvalidLength("AttributeId"))?,
                    )
                }
                Some(Element::Scalar {
                    tag: Tag::Context(1),
                    value: Value::Uint(v),
                }) => {
                    f_status_code = Some(
                        u8::try_from(v).map_err(|_| ClusterError::InvalidLength("StatusCode"))?,
                    )
                }
                None => return Err(ClusterError::Tlv(matter_codec::Error::UnclosedContainer)),
                Some(Element::ContainerStart { .. }) => r.skip_container()?,
                Some(_) => {} // unknown/future scalar — skip
            }
        }
        Ok(Self {
            attribute_id: f_attribute_id.ok_or(ClusterError::MissingField("AttributeId"))?,
            status_code: f_status_code.ok_or(ClusterError::MissingField("StatusCode"))?,
        })
    }
    /// Decode from a standalone anonymous TLV structure.
    ///
    /// # Errors
    /// Returns [`ClusterError`] if the bytes are not an anonymous structure or a field is malformed.
    pub fn decode(tlv: &[u8]) -> Result<Self, ClusterError> {
        let mut r = TlvReader::new(tlv);
        match r.next()? {
            Some(Element::ContainerStart {
                kind: ContainerKind::Structure,
                ..
            }) => {}
            _ => {
                return Err(ClusterError::UnexpectedType {
                    context: "ThermostatAttributeStatusEntryStruct",
                })
            }
        }
        Self::decode_from(&mut r)
    }
    /// Write this struct's fields into an already-open container.
    #[allow(clippy::expect_used)] // Vec-backed TlvWriter is infallible.
    pub fn write_fields(&self, w: &mut TlvWriter<'_>) {
        w.put_uint(Tag::Context(0), u64::from(self.attribute_id))
            .expect("infallible: vec writer");
        w.put_uint(Tag::Context(1), u64::from(self.status_code))
            .expect("infallible: vec writer");
    }
    /// Encode as a standalone anonymous TLV structure.
    #[must_use]
    #[allow(clippy::expect_used)] // Vec-backed TlvWriter is infallible.
    pub fn encode(&self) -> Vec<u8> {
        let mut buf = Vec::new();
        let mut w = TlvWriter::new(&mut buf);
        w.start_structure(Tag::Anonymous)
            .expect("infallible: vec writer");
        self.write_fields(&mut w);
        w.end_container().expect("infallible: vec writer");
        buf
    }
}

impl WeeklyScheduleTransitionStruct {
    /// Decode the fields of an already-opened anonymous structure
    /// (reader positioned after the struct start; consumes to its end).
    ///
    /// # Errors
    /// Returns [`ClusterError`] on a malformed structure or missing required field.
    pub fn decode_from(r: &mut TlvReader<'_>) -> Result<Self, ClusterError> {
        let mut f_transition_time: Option<u16> = None;
        let mut f_heat_setpoint: Option<Nullable<i16>> = None;
        let mut f_cool_setpoint: Option<Nullable<i16>> = None;
        loop {
            match r.next()? {
                Some(Element::ContainerEnd) => break,
                Some(Element::Scalar {
                    tag: Tag::Context(0),
                    value: Value::Uint(v),
                }) => {
                    f_transition_time = Some(
                        u16::try_from(v)
                            .map_err(|_| ClusterError::InvalidLength("TransitionTime"))?,
                    )
                }
                Some(Element::Scalar {
                    tag: Tag::Context(1),
                    value: Value::Null,
                }) => f_heat_setpoint = Some(Nullable::Null),
                Some(Element::Scalar {
                    tag: Tag::Context(1),
                    value: Value::Int(v),
                }) => {
                    f_heat_setpoint = Some(Nullable::Value(
                        i16::try_from(v)
                            .map_err(|_| ClusterError::InvalidLength("HeatSetpoint"))?,
                    ))
                }
                Some(Element::Scalar {
                    tag: Tag::Context(2),
                    value: Value::Null,
                }) => f_cool_setpoint = Some(Nullable::Null),
                Some(Element::Scalar {
                    tag: Tag::Context(2),
                    value: Value::Int(v),
                }) => {
                    f_cool_setpoint = Some(Nullable::Value(
                        i16::try_from(v)
                            .map_err(|_| ClusterError::InvalidLength("CoolSetpoint"))?,
                    ))
                }
                None => return Err(ClusterError::Tlv(matter_codec::Error::UnclosedContainer)),
                Some(Element::ContainerStart { .. }) => r.skip_container()?,
                Some(_) => {} // unknown/future scalar — skip
            }
        }
        Ok(Self {
            transition_time: f_transition_time
                .ok_or(ClusterError::MissingField("TransitionTime"))?,
            heat_setpoint: f_heat_setpoint.ok_or(ClusterError::MissingField("HeatSetpoint"))?,
            cool_setpoint: f_cool_setpoint.ok_or(ClusterError::MissingField("CoolSetpoint"))?,
        })
    }
    /// Decode from a standalone anonymous TLV structure.
    ///
    /// # Errors
    /// Returns [`ClusterError`] if the bytes are not an anonymous structure or a field is malformed.
    pub fn decode(tlv: &[u8]) -> Result<Self, ClusterError> {
        let mut r = TlvReader::new(tlv);
        match r.next()? {
            Some(Element::ContainerStart {
                kind: ContainerKind::Structure,
                ..
            }) => {}
            _ => {
                return Err(ClusterError::UnexpectedType {
                    context: "WeeklyScheduleTransitionStruct",
                })
            }
        }
        Self::decode_from(&mut r)
    }
    /// Write this struct's fields into an already-open container.
    #[allow(clippy::expect_used)] // Vec-backed TlvWriter is infallible.
    pub fn write_fields(&self, w: &mut TlvWriter<'_>) {
        w.put_uint(Tag::Context(0), u64::from(self.transition_time))
            .expect("infallible: vec writer");
        match &self.heat_setpoint {
            Nullable::Null => w.put_null(Tag::Context(1)).expect("infallible: vec writer"),
            Nullable::Value(heat_setpoint) => {
                w.put_int(Tag::Context(1), i64::from(*heat_setpoint))
                    .expect("infallible: vec writer");
            }
        }
        match &self.cool_setpoint {
            Nullable::Null => w.put_null(Tag::Context(2)).expect("infallible: vec writer"),
            Nullable::Value(cool_setpoint) => {
                w.put_int(Tag::Context(2), i64::from(*cool_setpoint))
                    .expect("infallible: vec writer");
            }
        }
    }
    /// Encode as a standalone anonymous TLV structure.
    #[must_use]
    #[allow(clippy::expect_used)] // Vec-backed TlvWriter is infallible.
    pub fn encode(&self) -> Vec<u8> {
        let mut buf = Vec::new();
        let mut w = TlvWriter::new(&mut buf);
        w.start_structure(Tag::Anonymous)
            .expect("infallible: vec writer");
        self.write_fields(&mut w);
        w.end_container().expect("infallible: vec writer");
        buf
    }
}

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

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

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

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

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

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

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

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

/// Encode the `LocalTemperatureCalibration` attribute value as a standalone TLV element.
#[must_use]
#[allow(clippy::expect_used, clippy::missing_panics_doc)] // Vec-backed TlvWriter is infallible.
pub fn encode_local_temperature_calibration(value: i8) -> Vec<u8> {
    let mut buf = Vec::new();
    let mut w = TlvWriter::new(&mut buf);
    w.put_int(Tag::Anonymous, i64::from(value))
        .expect("infallible: vec writer");
    buf
}

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

/// Encode the `OccupiedCoolingSetpoint` attribute value as a standalone TLV element.
#[must_use]
#[allow(clippy::expect_used, clippy::missing_panics_doc)] // Vec-backed TlvWriter is infallible.
pub fn encode_occupied_cooling_setpoint(value: i16) -> Vec<u8> {
    let mut buf = Vec::new();
    let mut w = TlvWriter::new(&mut buf);
    w.put_int(Tag::Anonymous, i64::from(value))
        .expect("infallible: vec writer");
    buf
}

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

/// Encode the `OccupiedHeatingSetpoint` attribute value as a standalone TLV element.
#[must_use]
#[allow(clippy::expect_used, clippy::missing_panics_doc)] // Vec-backed TlvWriter is infallible.
pub fn encode_occupied_heating_setpoint(value: i16) -> Vec<u8> {
    let mut buf = Vec::new();
    let mut w = TlvWriter::new(&mut buf);
    w.put_int(Tag::Anonymous, i64::from(value))
        .expect("infallible: vec writer");
    buf
}

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

/// Encode the `UnoccupiedCoolingSetpoint` attribute value as a standalone TLV element.
#[must_use]
#[allow(clippy::expect_used, clippy::missing_panics_doc)] // Vec-backed TlvWriter is infallible.
pub fn encode_unoccupied_cooling_setpoint(value: i16) -> Vec<u8> {
    let mut buf = Vec::new();
    let mut w = TlvWriter::new(&mut buf);
    w.put_int(Tag::Anonymous, i64::from(value))
        .expect("infallible: vec writer");
    buf
}

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

/// Encode the `UnoccupiedHeatingSetpoint` attribute value as a standalone TLV element.
#[must_use]
#[allow(clippy::expect_used, clippy::missing_panics_doc)] // Vec-backed TlvWriter is infallible.
pub fn encode_unoccupied_heating_setpoint(value: i16) -> Vec<u8> {
    let mut buf = Vec::new();
    let mut w = TlvWriter::new(&mut buf);
    w.put_int(Tag::Anonymous, i64::from(value))
        .expect("infallible: vec writer");
    buf
}

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

/// Encode the `MinHeatSetpointLimit` attribute value as a standalone TLV element.
#[must_use]
#[allow(clippy::expect_used, clippy::missing_panics_doc)] // Vec-backed TlvWriter is infallible.
pub fn encode_min_heat_setpoint_limit(value: i16) -> Vec<u8> {
    let mut buf = Vec::new();
    let mut w = TlvWriter::new(&mut buf);
    w.put_int(Tag::Anonymous, i64::from(value))
        .expect("infallible: vec writer");
    buf
}

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

/// Encode the `MaxHeatSetpointLimit` attribute value as a standalone TLV element.
#[must_use]
#[allow(clippy::expect_used, clippy::missing_panics_doc)] // Vec-backed TlvWriter is infallible.
pub fn encode_max_heat_setpoint_limit(value: i16) -> Vec<u8> {
    let mut buf = Vec::new();
    let mut w = TlvWriter::new(&mut buf);
    w.put_int(Tag::Anonymous, i64::from(value))
        .expect("infallible: vec writer");
    buf
}

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

/// Encode the `MinCoolSetpointLimit` attribute value as a standalone TLV element.
#[must_use]
#[allow(clippy::expect_used, clippy::missing_panics_doc)] // Vec-backed TlvWriter is infallible.
pub fn encode_min_cool_setpoint_limit(value: i16) -> Vec<u8> {
    let mut buf = Vec::new();
    let mut w = TlvWriter::new(&mut buf);
    w.put_int(Tag::Anonymous, i64::from(value))
        .expect("infallible: vec writer");
    buf
}

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

/// Encode the `MaxCoolSetpointLimit` attribute value as a standalone TLV element.
#[must_use]
#[allow(clippy::expect_used, clippy::missing_panics_doc)] // Vec-backed TlvWriter is infallible.
pub fn encode_max_cool_setpoint_limit(value: i16) -> Vec<u8> {
    let mut buf = Vec::new();
    let mut w = TlvWriter::new(&mut buf);
    w.put_int(Tag::Anonymous, i64::from(value))
        .expect("infallible: vec writer");
    buf
}

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

/// Encode the `MinSetpointDeadBand` attribute value as a standalone TLV element.
#[must_use]
#[allow(clippy::expect_used, clippy::missing_panics_doc)] // Vec-backed TlvWriter is infallible.
pub fn encode_min_setpoint_dead_band(value: i8) -> Vec<u8> {
    let mut buf = Vec::new();
    let mut w = TlvWriter::new(&mut buf);
    w.put_int(Tag::Anonymous, i64::from(value))
        .expect("infallible: vec writer");
    buf
}

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

/// Encode the `RemoteSensing` attribute value as a standalone TLV element.
#[must_use]
#[allow(clippy::expect_used, clippy::missing_panics_doc)] // Vec-backed TlvWriter is infallible.
pub fn encode_remote_sensing(value: RemoteSensingBitmap) -> Vec<u8> {
    let mut buf = Vec::new();
    let mut w = TlvWriter::new(&mut buf);
    w.put_uint(Tag::Anonymous, u64::from(value.bits()))
        .expect("infallible: vec writer");
    buf
}

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

/// Encode the `ControlSequenceOfOperation` attribute value as a standalone TLV element.
#[must_use]
#[allow(clippy::expect_used, clippy::missing_panics_doc)] // Vec-backed TlvWriter is infallible.
pub fn encode_control_sequence_of_operation(value: ControlSequenceOfOperationEnum) -> Vec<u8> {
    let mut buf = Vec::new();
    let mut w = TlvWriter::new(&mut buf);
    w.put_uint(Tag::Anonymous, u64::from(value.to_raw()))
        .expect("infallible: vec writer");
    buf
}

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

/// Encode the `SystemMode` attribute value as a standalone TLV element.
#[must_use]
#[allow(clippy::expect_used, clippy::missing_panics_doc)] // Vec-backed TlvWriter is infallible.
pub fn encode_system_mode(value: SystemModeEnum) -> Vec<u8> {
    let mut buf = Vec::new();
    let mut w = TlvWriter::new(&mut buf);
    w.put_uint(Tag::Anonymous, u64::from(value.to_raw()))
        .expect("infallible: vec writer");
    buf
}

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

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

/// Encode the `TemperatureSetpointHold` attribute value as a standalone TLV element.
#[must_use]
#[allow(clippy::expect_used, clippy::missing_panics_doc)] // Vec-backed TlvWriter is infallible.
pub fn encode_temperature_setpoint_hold(value: TemperatureSetpointHoldEnum) -> Vec<u8> {
    let mut buf = Vec::new();
    let mut w = TlvWriter::new(&mut buf);
    w.put_uint(Tag::Anonymous, u64::from(value.to_raw()))
        .expect("infallible: vec writer");
    buf
}

/// Decode the `TemperatureSetpointHoldDuration` attribute value.
///
/// # Errors
/// Returns [`ClusterError`] on a type mismatch or out-of-range value.
pub fn decode_temperature_setpoint_hold_duration(
    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("TemperatureSetpointHoldDuration")
        })?)),
        _ => Err(ClusterError::UnexpectedType {
            context: "TemperatureSetpointHoldDuration",
        }),
    }
}

/// Encode the `TemperatureSetpointHoldDuration` attribute value as a standalone TLV element.
#[must_use]
#[allow(clippy::expect_used, clippy::missing_panics_doc)] // Vec-backed TlvWriter is infallible.
pub fn encode_temperature_setpoint_hold_duration(value: Nullable<u16>) -> Vec<u8> {
    let mut buf = Vec::new();
    let mut w = TlvWriter::new(&mut buf);
    match value {
        Nullable::Null => w.put_null(Tag::Anonymous).expect("infallible: vec writer"),
        Nullable::Value(value) => {
            w.put_uint(Tag::Anonymous, u64::from(value))
                .expect("infallible: vec writer");
        }
    }
    buf
}

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

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

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

/// Decode the `SetpointChangeSourceTimestamp` attribute value.
///
/// # Errors
/// Returns [`ClusterError`] on a type mismatch or out-of-range value.
pub fn decode_setpoint_change_source_timestamp(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("SetpointChangeSourceTimestamp"))?),
        _ => Err(ClusterError::UnexpectedType {
            context: "SetpointChangeSourceTimestamp",
        }),
    }
}

/// Decode the `EmergencyHeatDelta` attribute value.
///
/// # Errors
/// Returns [`ClusterError`] on a type mismatch or out-of-range value.
pub fn decode_emergency_heat_delta(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("EmergencyHeatDelta"))?),
        _ => Err(ClusterError::UnexpectedType {
            context: "EmergencyHeatDelta",
        }),
    }
}

/// Encode the `EmergencyHeatDelta` attribute value as a standalone TLV element.
#[must_use]
#[allow(clippy::expect_used, clippy::missing_panics_doc)] // Vec-backed TlvWriter is infallible.
pub fn encode_emergency_heat_delta(value: u8) -> Vec<u8> {
    let mut buf = Vec::new();
    let mut w = TlvWriter::new(&mut buf);
    w.put_uint(Tag::Anonymous, u64::from(value))
        .expect("infallible: vec writer");
    buf
}

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

/// Encode the `AcType` attribute value as a standalone TLV element.
#[must_use]
#[allow(clippy::expect_used, clippy::missing_panics_doc)] // Vec-backed TlvWriter is infallible.
pub fn encode_ac_type(value: ACTypeEnum) -> Vec<u8> {
    let mut buf = Vec::new();
    let mut w = TlvWriter::new(&mut buf);
    w.put_uint(Tag::Anonymous, u64::from(value.to_raw()))
        .expect("infallible: vec writer");
    buf
}

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

/// Encode the `AcCapacity` attribute value as a standalone TLV element.
#[must_use]
#[allow(clippy::expect_used, clippy::missing_panics_doc)] // Vec-backed TlvWriter is infallible.
pub fn encode_ac_capacity(value: u16) -> Vec<u8> {
    let mut buf = Vec::new();
    let mut w = TlvWriter::new(&mut buf);
    w.put_uint(Tag::Anonymous, u64::from(value))
        .expect("infallible: vec writer");
    buf
}

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

/// Encode the `AcRefrigerantType` attribute value as a standalone TLV element.
#[must_use]
#[allow(clippy::expect_used, clippy::missing_panics_doc)] // Vec-backed TlvWriter is infallible.
pub fn encode_ac_refrigerant_type(value: ACRefrigerantTypeEnum) -> Vec<u8> {
    let mut buf = Vec::new();
    let mut w = TlvWriter::new(&mut buf);
    w.put_uint(Tag::Anonymous, u64::from(value.to_raw()))
        .expect("infallible: vec writer");
    buf
}

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

/// Encode the `AcCompressorType` attribute value as a standalone TLV element.
#[must_use]
#[allow(clippy::expect_used, clippy::missing_panics_doc)] // Vec-backed TlvWriter is infallible.
pub fn encode_ac_compressor_type(value: ACCompressorTypeEnum) -> Vec<u8> {
    let mut buf = Vec::new();
    let mut w = TlvWriter::new(&mut buf);
    w.put_uint(Tag::Anonymous, u64::from(value.to_raw()))
        .expect("infallible: vec writer");
    buf
}

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

/// Encode the `AcErrorCode` attribute value as a standalone TLV element.
#[must_use]
#[allow(clippy::expect_used, clippy::missing_panics_doc)] // Vec-backed TlvWriter is infallible.
pub fn encode_ac_error_code(value: ACErrorCodeBitmap) -> Vec<u8> {
    let mut buf = Vec::new();
    let mut w = TlvWriter::new(&mut buf);
    w.put_uint(Tag::Anonymous, u64::from(value.bits()))
        .expect("infallible: vec writer");
    buf
}

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

/// Encode the `AcLouverPosition` attribute value as a standalone TLV element.
#[must_use]
#[allow(clippy::expect_used, clippy::missing_panics_doc)] // Vec-backed TlvWriter is infallible.
pub fn encode_ac_louver_position(value: ACLouverPositionEnum) -> Vec<u8> {
    let mut buf = Vec::new();
    let mut w = TlvWriter::new(&mut buf);
    w.put_uint(Tag::Anonymous, u64::from(value.to_raw()))
        .expect("infallible: vec writer");
    buf
}

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

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

/// Encode the `AcCapacityFormat` attribute value as a standalone TLV element.
#[must_use]
#[allow(clippy::expect_used, clippy::missing_panics_doc)] // Vec-backed TlvWriter is infallible.
pub fn encode_ac_capacity_format(value: ACCapacityFormatEnum) -> Vec<u8> {
    let mut buf = Vec::new();
    let mut w = TlvWriter::new(&mut buf);
    w.put_uint(Tag::Anonymous, u64::from(value.to_raw()))
        .expect("infallible: vec writer");
    buf
}

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

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

/// Decode the `NumberOfPresets` attribute value.
///
/// # Errors
/// Returns [`ClusterError`] on a type mismatch or out-of-range value.
pub fn decode_number_of_presets(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("NumberOfPresets"))?),
        _ => Err(ClusterError::UnexpectedType {
            context: "NumberOfPresets",
        }),
    }
}

/// Decode the `NumberOfSchedules` attribute value.
///
/// # Errors
/// Returns [`ClusterError`] on a type mismatch or out-of-range value.
pub fn decode_number_of_schedules(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("NumberOfSchedules"))?),
        _ => Err(ClusterError::UnexpectedType {
            context: "NumberOfSchedules",
        }),
    }
}

/// Decode the `NumberOfScheduleTransitions` attribute value.
///
/// # Errors
/// Returns [`ClusterError`] on a type mismatch or out-of-range value.
pub fn decode_number_of_schedule_transitions(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("NumberOfScheduleTransitions"))?),
        _ => Err(ClusterError::UnexpectedType {
            context: "NumberOfScheduleTransitions",
        }),
    }
}

/// Decode the `NumberOfScheduleTransitionPerDay` attribute value.
///
/// # Errors
/// Returns [`ClusterError`] on a type mismatch or out-of-range value.
pub fn decode_number_of_schedule_transition_per_day(
    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("NumberOfScheduleTransitionPerDay")
        })?)),
        _ => Err(ClusterError::UnexpectedType {
            context: "NumberOfScheduleTransitionPerDay",
        }),
    }
}

/// Decode the `ActivePresetHandle` attribute value.
///
/// # Errors
/// Returns [`ClusterError`] on a type mismatch or out-of-range value.
pub fn decode_active_preset_handle(tlv: &[u8]) -> Result<Nullable<Vec<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::Bytes(v),
            ..
        }) => Ok(Nullable::Value(v)),
        _ => Err(ClusterError::UnexpectedType {
            context: "ActivePresetHandle",
        }),
    }
}

/// Decode the `ActiveScheduleHandle` attribute value.
///
/// # Errors
/// Returns [`ClusterError`] on a type mismatch or out-of-range value.
pub fn decode_active_schedule_handle(tlv: &[u8]) -> Result<Nullable<Vec<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::Bytes(v),
            ..
        }) => Ok(Nullable::Value(v)),
        _ => Err(ClusterError::UnexpectedType {
            context: "ActiveScheduleHandle",
        }),
    }
}

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

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

/// Decode the `SetpointHoldExpiryTimestamp` attribute value.
///
/// # Errors
/// Returns [`ClusterError`] on a type mismatch or out-of-range value.
pub fn decode_setpoint_hold_expiry_timestamp(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("SetpointHoldExpiryTimestamp")
        })?)),
        _ => Err(ClusterError::UnexpectedType {
            context: "SetpointHoldExpiryTimestamp",
        }),
    }
}

/// Encode the `SetpointRaiseLower` command request payload.
#[must_use]
#[allow(clippy::expect_used, clippy::missing_panics_doc)] // Vec-backed TlvWriter is infallible.
pub fn encode_setpoint_raise_lower(mode: SetpointRaiseLowerModeEnum, amount: i8) -> Vec<u8> {
    let mut buf = Vec::new();
    let mut w = TlvWriter::new(&mut buf);
    w.start_structure(Tag::Anonymous)
        .expect("infallible: vec writer");
    w.put_uint(Tag::Context(0), u64::from(mode.to_raw()))
        .expect("infallible: vec writer");
    w.put_int(Tag::Context(1), i64::from(amount))
        .expect("infallible: vec writer");
    w.end_container().expect("infallible: vec writer");
    buf
}

/// Encode the `SetActiveScheduleRequest` command request payload.
#[must_use]
#[allow(clippy::expect_used, clippy::missing_panics_doc)] // Vec-backed TlvWriter is infallible.
pub fn encode_set_active_schedule_request(schedule_handle: &Vec<u8>) -> Vec<u8> {
    let mut buf = Vec::new();
    let mut w = TlvWriter::new(&mut buf);
    w.start_structure(Tag::Anonymous)
        .expect("infallible: vec writer");
    w.put_bytes(Tag::Context(0), &schedule_handle)
        .expect("infallible: vec writer");
    w.end_container().expect("infallible: vec writer");
    buf
}

/// Encode the `SetActivePresetRequest` command request payload.
#[must_use]
#[allow(clippy::expect_used, clippy::missing_panics_doc)] // Vec-backed TlvWriter is infallible.
pub fn encode_set_active_preset_request(preset_handle: Nullable<Vec<u8>>) -> Vec<u8> {
    let mut buf = Vec::new();
    let mut w = TlvWriter::new(&mut buf);
    w.start_structure(Tag::Anonymous)
        .expect("infallible: vec writer");
    match preset_handle {
        Nullable::Null => w.put_null(Tag::Context(0)).expect("infallible: vec writer"),
        Nullable::Value(preset_handle) => {
            w.put_bytes(Tag::Context(0), &preset_handle)
                .expect("infallible: vec writer");
        }
    }
    w.end_container().expect("infallible: vec writer");
    buf
}

/// Decoded `AtomicResponse` payload.
#[derive(Clone, Debug, PartialEq)]
#[non_exhaustive]
pub struct AtomicResponse {
    /// Field StatusCode (tag 0).
    pub status_code: u8,
    /// Field AttributeStatus (tag 1).
    pub attribute_status: Vec<ThermostatAttributeStatusEntryStruct>,
    /// Field Timeout (tag 2).
    pub timeout: Option<u16>,
}

impl AtomicResponse {
    /// Decode the fields of an already-opened anonymous structure
    /// (reader positioned after the struct start; consumes to its end).
    ///
    /// # Errors
    /// Returns [`ClusterError`] on a malformed structure or missing required field.
    pub fn decode_from(r: &mut TlvReader<'_>) -> Result<Self, ClusterError> {
        let mut f_status_code: Option<u8> = None;
        let mut f_attribute_status: Option<Vec<ThermostatAttributeStatusEntryStruct>> = None;
        let mut f_timeout: Option<u16> = None;
        loop {
            match r.next()? {
                Some(Element::ContainerEnd) => break,
                Some(Element::Scalar {
                    tag: Tag::Context(0),
                    value: Value::Uint(v),
                }) => {
                    f_status_code = Some(
                        u8::try_from(v).map_err(|_| ClusterError::InvalidLength("StatusCode"))?,
                    )
                }
                Some(Element::ContainerStart {
                    tag: Tag::Context(1),
                    kind: ContainerKind::Array,
                }) => {
                    let mut out = Vec::new();
                    loop {
                        match r.next()? {
                            Some(Element::ContainerEnd) => break,
                            Some(Element::ContainerStart {
                                kind: ContainerKind::Structure,
                                ..
                            }) => {
                                out.push(ThermostatAttributeStatusEntryStruct::decode_from(r)?);
                            }
                            None => {
                                return Err(ClusterError::Tlv(
                                    matter_codec::Error::UnclosedContainer,
                                ))
                            }
                            Some(Element::ContainerStart { .. }) => r.skip_container()?,
                            Some(_) => {} // skip unknown scalar
                        }
                    }
                    f_attribute_status = Some(out);
                }
                Some(Element::Scalar {
                    tag: Tag::Context(2),
                    value: Value::Uint(v),
                }) => {
                    f_timeout =
                        Some(u16::try_from(v).map_err(|_| ClusterError::InvalidLength("Timeout"))?)
                }
                None => return Err(ClusterError::Tlv(matter_codec::Error::UnclosedContainer)),
                Some(Element::ContainerStart { .. }) => r.skip_container()?,
                Some(_) => {} // unknown/future scalar — skip
            }
        }
        Ok(Self {
            status_code: f_status_code.ok_or(ClusterError::MissingField("StatusCode"))?,
            attribute_status: f_attribute_status
                .ok_or(ClusterError::MissingField("AttributeStatus"))?,
            timeout: f_timeout,
        })
    }
    /// Decode from a standalone anonymous TLV structure.
    ///
    /// # Errors
    /// Returns [`ClusterError`] if the bytes are not an anonymous structure or a field is malformed.
    pub fn decode(tlv: &[u8]) -> Result<Self, ClusterError> {
        let mut r = TlvReader::new(tlv);
        match r.next()? {
            Some(Element::ContainerStart {
                kind: ContainerKind::Structure,
                ..
            }) => {}
            _ => {
                return Err(ClusterError::UnexpectedType {
                    context: "AtomicResponse",
                })
            }
        }
        Self::decode_from(&mut r)
    }
}

/// Encode the `AtomicRequest` command request payload.
#[must_use]
#[allow(clippy::expect_used, clippy::missing_panics_doc)] // Vec-backed TlvWriter is infallible.
pub fn encode_atomic_request(
    request_type: u8,
    attribute_requests: &Vec<u32>,
    timeout: Option<u16>,
) -> Vec<u8> {
    let mut buf = Vec::new();
    let mut w = TlvWriter::new(&mut buf);
    w.start_structure(Tag::Anonymous)
        .expect("infallible: vec writer");
    w.put_uint(Tag::Context(0), u64::from(request_type))
        .expect("infallible: vec writer");
    w.start_array(Tag::Context(1))
        .expect("infallible: vec writer");
    for el in attribute_requests.iter().copied() {
        w.put_uint(Tag::Anonymous, u64::from(el))
            .expect("infallible: vec writer");
    }
    w.end_container().expect("infallible: vec writer");
    if let Some(timeout) = timeout {
        w.put_uint(Tag::Context(2), u64::from(timeout))
            .expect("infallible: vec writer");
    }
    w.end_container().expect("infallible: vec writer");
    buf
}