matc/clusters/codec/

color_control.rs

//! Matter TLV encoders and decoders for Color Control Cluster
//! Cluster ID: 0x0300
//!
//! This file is automatically generated from ColorControl.xml

#![allow(clippy::too_many_arguments)]

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


// Enum definitions

#[derive(Debug, Clone, Copy, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
#[repr(u8)]
pub enum ColorLoopAction {
    /// De-activate the color loop.
    Deactivate = 0,
    /// Activate the color loop from the value in the ColorLoopStartEnhancedHue field.
    Activatefromcolorloopstartenhancedhue = 1,
    /// Activate the color loop from the value of the EnhancedCurrentHue attribute.
    Activatefromenhancedcurrenthue = 2,
}

impl ColorLoopAction {
    /// Convert from u8 value
    pub fn from_u8(value: u8) -> Option<Self> {
        match value {
            0 => Some(ColorLoopAction::Deactivate),
            1 => Some(ColorLoopAction::Activatefromcolorloopstartenhancedhue),
            2 => Some(ColorLoopAction::Activatefromenhancedcurrenthue),
            _ => None,
        }
    }

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

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

#[derive(Debug, Clone, Copy, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
#[repr(u8)]
pub enum ColorLoopDirection {
    /// Decrement the hue in the color loop.
    Decrement = 0,
    /// Increment the hue in the color loop.
    Increment = 1,
}

impl ColorLoopDirection {
    /// Convert from u8 value
    pub fn from_u8(value: u8) -> Option<Self> {
        match value {
            0 => Some(ColorLoopDirection::Decrement),
            1 => Some(ColorLoopDirection::Increment),
            _ => None,
        }
    }

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

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

#[derive(Debug, Clone, Copy, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
#[repr(u8)]
pub enum ColorMode {
    /// The current hue and saturation attributes determine the color.
    Currenthueandcurrentsaturation = 0,
    /// The current X and Y attributes determine the color.
    Currentxandcurrenty = 1,
    /// The color temperature attribute determines the color.
    Colortemperaturemireds = 2,
}

impl ColorMode {
    /// Convert from u8 value
    pub fn from_u8(value: u8) -> Option<Self> {
        match value {
            0 => Some(ColorMode::Currenthueandcurrentsaturation),
            1 => Some(ColorMode::Currentxandcurrenty),
            2 => Some(ColorMode::Colortemperaturemireds),
            _ => None,
        }
    }

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

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

#[derive(Debug, Clone, Copy, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
#[repr(u8)]
pub enum Direction {
    /// Shortest distance
    Shortest = 0,
    /// Longest distance
    Longest = 1,
    /// Up
    Up = 2,
    /// Down
    Down = 3,
}

impl Direction {
    /// Convert from u8 value
    pub fn from_u8(value: u8) -> Option<Self> {
        match value {
            0 => Some(Direction::Shortest),
            1 => Some(Direction::Longest),
            2 => Some(Direction::Up),
            3 => Some(Direction::Down),
            _ => None,
        }
    }

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

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

#[derive(Debug, Clone, Copy, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
#[repr(u8)]
pub enum DriftCompensation {
    /// There is no compensation.
    None = 0,
    /// The compensation is based on other or unknown mechanism.
    Otherorunknown = 1,
    /// The compensation is based on temperature monitoring.
    Temperaturemonitoring = 2,
    /// The compensation is based on optical luminance monitoring and feedback.
    Opticalluminancemonitoringandfeedback = 3,
    /// The compensation is based on optical color monitoring and feedback.
    Opticalcolormonitoringandfeedback = 4,
}

impl DriftCompensation {
    /// Convert from u8 value
    pub fn from_u8(value: u8) -> Option<Self> {
        match value {
            0 => Some(DriftCompensation::None),
            1 => Some(DriftCompensation::Otherorunknown),
            2 => Some(DriftCompensation::Temperaturemonitoring),
            3 => Some(DriftCompensation::Opticalluminancemonitoringandfeedback),
            4 => Some(DriftCompensation::Opticalcolormonitoringandfeedback),
            _ => None,
        }
    }

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

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

#[derive(Debug, Clone, Copy, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
#[repr(u8)]
pub enum EnhancedColorMode {
    /// The current hue and saturation attributes determine the color.
    Currenthueandcurrentsaturation = 0,
    /// The current X and Y attributes determine the color.
    Currentxandcurrenty = 1,
    /// The color temperature attribute determines the color.
    Colortemperaturemireds = 2,
    /// The enhanced current hue and saturation attributes determine the color.
    Enhancedcurrenthueandcurrentsaturation = 3,
}

impl EnhancedColorMode {
    /// Convert from u8 value
    pub fn from_u8(value: u8) -> Option<Self> {
        match value {
            0 => Some(EnhancedColorMode::Currenthueandcurrentsaturation),
            1 => Some(EnhancedColorMode::Currentxandcurrenty),
            2 => Some(EnhancedColorMode::Colortemperaturemireds),
            3 => Some(EnhancedColorMode::Enhancedcurrenthueandcurrentsaturation),
            _ => None,
        }
    }

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

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

#[derive(Debug, Clone, Copy, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
#[repr(u8)]
pub enum MoveMode {
    /// Stop the movement
    Stop = 0,
    /// Move in an upwards direction
    Up = 1,
    /// Move in a downwards direction
    Down = 3,
}

impl MoveMode {
    /// Convert from u8 value
    pub fn from_u8(value: u8) -> Option<Self> {
        match value {
            0 => Some(MoveMode::Stop),
            1 => Some(MoveMode::Up),
            3 => Some(MoveMode::Down),
            _ => None,
        }
    }

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

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

#[derive(Debug, Clone, Copy, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
#[repr(u8)]
pub enum StepMode {
    /// Step in an upwards direction
    Up = 1,
    /// Step in a downwards direction
    Down = 3,
}

impl StepMode {
    /// Convert from u8 value
    pub fn from_u8(value: u8) -> Option<Self> {
        match value {
            1 => Some(StepMode::Up),
            3 => Some(StepMode::Down),
            _ => None,
        }
    }

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

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

// Bitmap definitions

/// ColorCapabilities bitmap type
pub type ColorCapabilities = u8;

/// Constants for ColorCapabilities
pub mod colorcapabilities {
    /// Supports color specification via hue/saturation.
    pub const HUE_SATURATION: u8 = 0x01;
    /// Enhanced hue is supported.
    pub const ENHANCED_HUE: u8 = 0x02;
    /// Color loop is supported.
    pub const COLOR_LOOP: u8 = 0x04;
    /// Supports color specification via XY.
    pub const XY: u8 = 0x08;
    /// Supports color specification via color temperature.
    pub const COLOR_TEMPERATURE: u8 = 0x10;
}

/// Options bitmap type
pub type Options = u8;

/// Constants for Options
pub mod options {
    /// Dependency on On/Off cluster
    pub const EXECUTE_IF_OFF: u8 = 0x01;
}

/// UpdateFlags bitmap type
pub type UpdateFlags = u8;

/// Constants for UpdateFlags
pub mod updateflags {
    /// Device adheres to the associated action field.
    pub const UPDATE_ACTION: u8 = 0x01;
    /// Device updates the associated direction attribute.
    pub const UPDATE_DIRECTION: u8 = 0x02;
    /// Device updates the associated time attribute.
    pub const UPDATE_TIME: u8 = 0x04;
    /// Device updates the associated start hue attribute.
    pub const UPDATE_START_HUE: u8 = 0x08;
}

// Command encoders

/// Encode MoveToHue command (0x00)
pub fn encode_move_to_hue(hue: u8, direction: Direction, transition_time: u16, options_mask: Options, options_override: Options) -> anyhow::Result<Vec<u8>> {
    let tlv = tlv::TlvItemEnc {
        tag: 0,
        value: tlv::TlvItemValueEnc::StructInvisible(vec![
        (0, tlv::TlvItemValueEnc::UInt8(hue)).into(),
        (1, tlv::TlvItemValueEnc::UInt8(direction.to_u8())).into(),
        (2, tlv::TlvItemValueEnc::UInt16(transition_time)).into(),
        (3, tlv::TlvItemValueEnc::UInt8(options_mask)).into(),
        (4, tlv::TlvItemValueEnc::UInt8(options_override)).into(),
        ]),
    };
    Ok(tlv.encode()?)
}

/// Encode MoveHue command (0x01)
pub fn encode_move_hue(move_mode: MoveMode, rate: u8, options_mask: Options, options_override: Options) -> anyhow::Result<Vec<u8>> {
    let tlv = tlv::TlvItemEnc {
        tag: 0,
        value: tlv::TlvItemValueEnc::StructInvisible(vec![
        (0, tlv::TlvItemValueEnc::UInt8(move_mode.to_u8())).into(),
        (1, tlv::TlvItemValueEnc::UInt8(rate)).into(),
        (2, tlv::TlvItemValueEnc::UInt8(options_mask)).into(),
        (3, tlv::TlvItemValueEnc::UInt8(options_override)).into(),
        ]),
    };
    Ok(tlv.encode()?)
}

/// Encode StepHue command (0x02)
pub fn encode_step_hue(step_mode: StepMode, step_size: u8, transition_time: u8, options_mask: Options, options_override: Options) -> anyhow::Result<Vec<u8>> {
    let tlv = tlv::TlvItemEnc {
        tag: 0,
        value: tlv::TlvItemValueEnc::StructInvisible(vec![
        (0, tlv::TlvItemValueEnc::UInt8(step_mode.to_u8())).into(),
        (1, tlv::TlvItemValueEnc::UInt8(step_size)).into(),
        (2, tlv::TlvItemValueEnc::UInt8(transition_time)).into(),
        (3, tlv::TlvItemValueEnc::UInt8(options_mask)).into(),
        (4, tlv::TlvItemValueEnc::UInt8(options_override)).into(),
        ]),
    };
    Ok(tlv.encode()?)
}

/// Encode MoveToSaturation command (0x03)
pub fn encode_move_to_saturation(saturation: u8, transition_time: u16, options_mask: Options, options_override: Options) -> anyhow::Result<Vec<u8>> {
    let tlv = tlv::TlvItemEnc {
        tag: 0,
        value: tlv::TlvItemValueEnc::StructInvisible(vec![
        (0, tlv::TlvItemValueEnc::UInt8(saturation)).into(),
        (1, tlv::TlvItemValueEnc::UInt16(transition_time)).into(),
        (2, tlv::TlvItemValueEnc::UInt8(options_mask)).into(),
        (3, tlv::TlvItemValueEnc::UInt8(options_override)).into(),
        ]),
    };
    Ok(tlv.encode()?)
}

/// Encode MoveSaturation command (0x04)
pub fn encode_move_saturation(move_mode: MoveMode, rate: u8, options_mask: Options, options_override: Options) -> anyhow::Result<Vec<u8>> {
    let tlv = tlv::TlvItemEnc {
        tag: 0,
        value: tlv::TlvItemValueEnc::StructInvisible(vec![
        (0, tlv::TlvItemValueEnc::UInt8(move_mode.to_u8())).into(),
        (1, tlv::TlvItemValueEnc::UInt8(rate)).into(),
        (2, tlv::TlvItemValueEnc::UInt8(options_mask)).into(),
        (3, tlv::TlvItemValueEnc::UInt8(options_override)).into(),
        ]),
    };
    Ok(tlv.encode()?)
}

/// Encode StepSaturation command (0x05)
pub fn encode_step_saturation(step_mode: StepMode, step_size: u8, transition_time: u8, options_mask: Options, options_override: Options) -> anyhow::Result<Vec<u8>> {
    let tlv = tlv::TlvItemEnc {
        tag: 0,
        value: tlv::TlvItemValueEnc::StructInvisible(vec![
        (0, tlv::TlvItemValueEnc::UInt8(step_mode.to_u8())).into(),
        (1, tlv::TlvItemValueEnc::UInt8(step_size)).into(),
        (2, tlv::TlvItemValueEnc::UInt8(transition_time)).into(),
        (3, tlv::TlvItemValueEnc::UInt8(options_mask)).into(),
        (4, tlv::TlvItemValueEnc::UInt8(options_override)).into(),
        ]),
    };
    Ok(tlv.encode()?)
}

/// Encode MoveToHueAndSaturation command (0x06)
pub fn encode_move_to_hue_and_saturation(hue: u8, saturation: u8, transition_time: u16, options_mask: Options, options_override: Options) -> anyhow::Result<Vec<u8>> {
    let tlv = tlv::TlvItemEnc {
        tag: 0,
        value: tlv::TlvItemValueEnc::StructInvisible(vec![
        (0, tlv::TlvItemValueEnc::UInt8(hue)).into(),
        (1, tlv::TlvItemValueEnc::UInt8(saturation)).into(),
        (2, tlv::TlvItemValueEnc::UInt16(transition_time)).into(),
        (3, tlv::TlvItemValueEnc::UInt8(options_mask)).into(),
        (4, tlv::TlvItemValueEnc::UInt8(options_override)).into(),
        ]),
    };
    Ok(tlv.encode()?)
}

/// Encode MoveToColor command (0x07)
pub fn encode_move_to_color(color_x: u16, color_y: u16, transition_time: u16, options_mask: Options, options_override: Options) -> anyhow::Result<Vec<u8>> {
    let tlv = tlv::TlvItemEnc {
        tag: 0,
        value: tlv::TlvItemValueEnc::StructInvisible(vec![
        (0, tlv::TlvItemValueEnc::UInt16(color_x)).into(),
        (1, tlv::TlvItemValueEnc::UInt16(color_y)).into(),
        (2, tlv::TlvItemValueEnc::UInt16(transition_time)).into(),
        (3, tlv::TlvItemValueEnc::UInt8(options_mask)).into(),
        (4, tlv::TlvItemValueEnc::UInt8(options_override)).into(),
        ]),
    };
    Ok(tlv.encode()?)
}

/// Encode MoveColor command (0x08)
pub fn encode_move_color(rate_x: i16, rate_y: i16, options_mask: Options, options_override: Options) -> anyhow::Result<Vec<u8>> {
    let tlv = tlv::TlvItemEnc {
        tag: 0,
        value: tlv::TlvItemValueEnc::StructInvisible(vec![
        (0, tlv::TlvItemValueEnc::Int16(rate_x)).into(),
        (1, tlv::TlvItemValueEnc::Int16(rate_y)).into(),
        (2, tlv::TlvItemValueEnc::UInt8(options_mask)).into(),
        (3, tlv::TlvItemValueEnc::UInt8(options_override)).into(),
        ]),
    };
    Ok(tlv.encode()?)
}

/// Encode StepColor command (0x09)
pub fn encode_step_color(step_x: i16, step_y: i16, transition_time: u16, options_mask: Options, options_override: Options) -> anyhow::Result<Vec<u8>> {
    let tlv = tlv::TlvItemEnc {
        tag: 0,
        value: tlv::TlvItemValueEnc::StructInvisible(vec![
        (0, tlv::TlvItemValueEnc::Int16(step_x)).into(),
        (1, tlv::TlvItemValueEnc::Int16(step_y)).into(),
        (2, tlv::TlvItemValueEnc::UInt16(transition_time)).into(),
        (3, tlv::TlvItemValueEnc::UInt8(options_mask)).into(),
        (4, tlv::TlvItemValueEnc::UInt8(options_override)).into(),
        ]),
    };
    Ok(tlv.encode()?)
}

/// Encode MoveToColorTemperature command (0x0A)
pub fn encode_move_to_color_temperature(color_temperature_mireds: u16, transition_time: u16, options_mask: Options, options_override: Options) -> anyhow::Result<Vec<u8>> {
    let tlv = tlv::TlvItemEnc {
        tag: 0,
        value: tlv::TlvItemValueEnc::StructInvisible(vec![
        (0, tlv::TlvItemValueEnc::UInt16(color_temperature_mireds)).into(),
        (1, tlv::TlvItemValueEnc::UInt16(transition_time)).into(),
        (2, tlv::TlvItemValueEnc::UInt8(options_mask)).into(),
        (3, tlv::TlvItemValueEnc::UInt8(options_override)).into(),
        ]),
    };
    Ok(tlv.encode()?)
}

/// Encode EnhancedMoveToHue command (0x40)
pub fn encode_enhanced_move_to_hue(enhanced_hue: u16, direction: Direction, transition_time: u16, options_mask: Options, options_override: Options) -> anyhow::Result<Vec<u8>> {
    let tlv = tlv::TlvItemEnc {
        tag: 0,
        value: tlv::TlvItemValueEnc::StructInvisible(vec![
        (0, tlv::TlvItemValueEnc::UInt16(enhanced_hue)).into(),
        (1, tlv::TlvItemValueEnc::UInt8(direction.to_u8())).into(),
        (2, tlv::TlvItemValueEnc::UInt16(transition_time)).into(),
        (3, tlv::TlvItemValueEnc::UInt8(options_mask)).into(),
        (4, tlv::TlvItemValueEnc::UInt8(options_override)).into(),
        ]),
    };
    Ok(tlv.encode()?)
}

/// Encode EnhancedMoveHue command (0x41)
pub fn encode_enhanced_move_hue(move_mode: MoveMode, rate: u16, options_mask: Options, options_override: Options) -> anyhow::Result<Vec<u8>> {
    let tlv = tlv::TlvItemEnc {
        tag: 0,
        value: tlv::TlvItemValueEnc::StructInvisible(vec![
        (0, tlv::TlvItemValueEnc::UInt8(move_mode.to_u8())).into(),
        (1, tlv::TlvItemValueEnc::UInt16(rate)).into(),
        (2, tlv::TlvItemValueEnc::UInt8(options_mask)).into(),
        (3, tlv::TlvItemValueEnc::UInt8(options_override)).into(),
        ]),
    };
    Ok(tlv.encode()?)
}

/// Encode EnhancedStepHue command (0x42)
pub fn encode_enhanced_step_hue(step_mode: StepMode, step_size: u16, transition_time: u16, options_mask: Options, options_override: Options) -> anyhow::Result<Vec<u8>> {
    let tlv = tlv::TlvItemEnc {
        tag: 0,
        value: tlv::TlvItemValueEnc::StructInvisible(vec![
        (0, tlv::TlvItemValueEnc::UInt8(step_mode.to_u8())).into(),
        (1, tlv::TlvItemValueEnc::UInt16(step_size)).into(),
        (2, tlv::TlvItemValueEnc::UInt16(transition_time)).into(),
        (3, tlv::TlvItemValueEnc::UInt8(options_mask)).into(),
        (4, tlv::TlvItemValueEnc::UInt8(options_override)).into(),
        ]),
    };
    Ok(tlv.encode()?)
}

/// Encode EnhancedMoveToHueAndSaturation command (0x43)
pub fn encode_enhanced_move_to_hue_and_saturation(enhanced_hue: u16, saturation: u8, transition_time: u16, options_mask: Options, options_override: Options) -> anyhow::Result<Vec<u8>> {
    let tlv = tlv::TlvItemEnc {
        tag: 0,
        value: tlv::TlvItemValueEnc::StructInvisible(vec![
        (0, tlv::TlvItemValueEnc::UInt16(enhanced_hue)).into(),
        (1, tlv::TlvItemValueEnc::UInt8(saturation)).into(),
        (2, tlv::TlvItemValueEnc::UInt16(transition_time)).into(),
        (3, tlv::TlvItemValueEnc::UInt8(options_mask)).into(),
        (4, tlv::TlvItemValueEnc::UInt8(options_override)).into(),
        ]),
    };
    Ok(tlv.encode()?)
}

/// Encode ColorLoopSet command (0x44)
pub fn encode_color_loop_set(update_flags: UpdateFlags, action: ColorLoopAction, direction: ColorLoopDirection, time: u16, start_hue: u16, options_mask: Options, options_override: Options) -> anyhow::Result<Vec<u8>> {
    let tlv = tlv::TlvItemEnc {
        tag: 0,
        value: tlv::TlvItemValueEnc::StructInvisible(vec![
        (0, tlv::TlvItemValueEnc::UInt8(update_flags)).into(),
        (1, tlv::TlvItemValueEnc::UInt8(action.to_u8())).into(),
        (2, tlv::TlvItemValueEnc::UInt8(direction.to_u8())).into(),
        (3, tlv::TlvItemValueEnc::UInt16(time)).into(),
        (4, tlv::TlvItemValueEnc::UInt16(start_hue)).into(),
        (5, tlv::TlvItemValueEnc::UInt8(options_mask)).into(),
        (6, tlv::TlvItemValueEnc::UInt8(options_override)).into(),
        ]),
    };
    Ok(tlv.encode()?)
}

/// Encode StopMoveStep command (0x47)
pub fn encode_stop_move_step(options_mask: Options, options_override: Options) -> anyhow::Result<Vec<u8>> {
    let tlv = tlv::TlvItemEnc {
        tag: 0,
        value: tlv::TlvItemValueEnc::StructInvisible(vec![
        (0, tlv::TlvItemValueEnc::UInt8(options_mask)).into(),
        (1, tlv::TlvItemValueEnc::UInt8(options_override)).into(),
        ]),
    };
    Ok(tlv.encode()?)
}

/// Encode MoveColorTemperature command (0x4B)
pub fn encode_move_color_temperature(move_mode: MoveMode, rate: u16, color_temperature_minimum_mireds: u16, color_temperature_maximum_mireds: u16, options_mask: Options, options_override: Options) -> anyhow::Result<Vec<u8>> {
    let tlv = tlv::TlvItemEnc {
        tag: 0,
        value: tlv::TlvItemValueEnc::StructInvisible(vec![
        (0, tlv::TlvItemValueEnc::UInt8(move_mode.to_u8())).into(),
        (1, tlv::TlvItemValueEnc::UInt16(rate)).into(),
        (2, tlv::TlvItemValueEnc::UInt16(color_temperature_minimum_mireds)).into(),
        (3, tlv::TlvItemValueEnc::UInt16(color_temperature_maximum_mireds)).into(),
        (4, tlv::TlvItemValueEnc::UInt8(options_mask)).into(),
        (5, tlv::TlvItemValueEnc::UInt8(options_override)).into(),
        ]),
    };
    Ok(tlv.encode()?)
}

/// Encode StepColorTemperature command (0x4C)
pub fn encode_step_color_temperature(step_mode: StepMode, step_size: u16, transition_time: u16, color_temperature_minimum_mireds: u16, color_temperature_maximum_mireds: u16, options_mask: Options, options_override: Options) -> anyhow::Result<Vec<u8>> {
    let tlv = tlv::TlvItemEnc {
        tag: 0,
        value: tlv::TlvItemValueEnc::StructInvisible(vec![
        (0, tlv::TlvItemValueEnc::UInt8(step_mode.to_u8())).into(),
        (1, tlv::TlvItemValueEnc::UInt16(step_size)).into(),
        (2, tlv::TlvItemValueEnc::UInt16(transition_time)).into(),
        (3, tlv::TlvItemValueEnc::UInt16(color_temperature_minimum_mireds)).into(),
        (4, tlv::TlvItemValueEnc::UInt16(color_temperature_maximum_mireds)).into(),
        (5, tlv::TlvItemValueEnc::UInt8(options_mask)).into(),
        (6, tlv::TlvItemValueEnc::UInt8(options_override)).into(),
        ]),
    };
    Ok(tlv.encode()?)
}

// Attribute decoders

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

/// Decode StartUpColorTemperatureMireds attribute (0x4010)
pub fn decode_start_up_color_temperature_mireds(inp: &tlv::TlvItemValue) -> anyhow::Result<Option<u16>> {
    if let tlv::TlvItemValue::Int(v) = inp {
        Ok(Some(*v as u16))
    } else {
        Ok(None)
    }
}


// JSON dispatcher function

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

    match attribute_id {
        0x0000 => {
            match decode_current_hue(tlv_value) {
                Ok(value) => serde_json::to_string(&value).unwrap_or_else(|_| "null".to_string()),
                Err(e) => format!("{{\"error\": \"{}\"}}", e),
            }
        }
        0x0001 => {
            match decode_current_saturation(tlv_value) {
                Ok(value) => serde_json::to_string(&value).unwrap_or_else(|_| "null".to_string()),
                Err(e) => format!("{{\"error\": \"{}\"}}", e),
            }
        }
        0x0002 => {
            match decode_remaining_time(tlv_value) {
                Ok(value) => serde_json::to_string(&value).unwrap_or_else(|_| "null".to_string()),
                Err(e) => format!("{{\"error\": \"{}\"}}", e),
            }
        }
        0x0003 => {
            match decode_current_x(tlv_value) {
                Ok(value) => serde_json::to_string(&value).unwrap_or_else(|_| "null".to_string()),
                Err(e) => format!("{{\"error\": \"{}\"}}", e),
            }
        }
        0x0004 => {
            match decode_current_y(tlv_value) {
                Ok(value) => serde_json::to_string(&value).unwrap_or_else(|_| "null".to_string()),
                Err(e) => format!("{{\"error\": \"{}\"}}", e),
            }
        }
        0x0005 => {
            match decode_drift_compensation(tlv_value) {
                Ok(value) => serde_json::to_string(&value).unwrap_or_else(|_| "null".to_string()),
                Err(e) => format!("{{\"error\": \"{}\"}}", e),
            }
        }
        0x0006 => {
            match decode_compensation_text(tlv_value) {
                Ok(value) => serde_json::to_string(&value).unwrap_or_else(|_| "null".to_string()),
                Err(e) => format!("{{\"error\": \"{}\"}}", e),
            }
        }
        0x0007 => {
            match decode_color_temperature_mireds(tlv_value) {
                Ok(value) => serde_json::to_string(&value).unwrap_or_else(|_| "null".to_string()),
                Err(e) => format!("{{\"error\": \"{}\"}}", e),
            }
        }
        0x0008 => {
            match decode_color_mode(tlv_value) {
                Ok(value) => serde_json::to_string(&value).unwrap_or_else(|_| "null".to_string()),
                Err(e) => format!("{{\"error\": \"{}\"}}", e),
            }
        }
        0x000F => {
            match decode_options(tlv_value) {
                Ok(value) => serde_json::to_string(&value).unwrap_or_else(|_| "null".to_string()),
                Err(e) => format!("{{\"error\": \"{}\"}}", e),
            }
        }
        0x0010 => {
            match decode_number_of_primaries(tlv_value) {
                Ok(value) => serde_json::to_string(&value).unwrap_or_else(|_| "null".to_string()),
                Err(e) => format!("{{\"error\": \"{}\"}}", e),
            }
        }
        0x0011 => {
            match decode_primary1_x(tlv_value) {
                Ok(value) => serde_json::to_string(&value).unwrap_or_else(|_| "null".to_string()),
                Err(e) => format!("{{\"error\": \"{}\"}}", e),
            }
        }
        0x0012 => {
            match decode_primary1_y(tlv_value) {
                Ok(value) => serde_json::to_string(&value).unwrap_or_else(|_| "null".to_string()),
                Err(e) => format!("{{\"error\": \"{}\"}}", e),
            }
        }
        0x0013 => {
            match decode_primary1_intensity(tlv_value) {
                Ok(value) => serde_json::to_string(&value).unwrap_or_else(|_| "null".to_string()),
                Err(e) => format!("{{\"error\": \"{}\"}}", e),
            }
        }
        0x0015 => {
            match decode_primary2_x(tlv_value) {
                Ok(value) => serde_json::to_string(&value).unwrap_or_else(|_| "null".to_string()),
                Err(e) => format!("{{\"error\": \"{}\"}}", e),
            }
        }
        0x0016 => {
            match decode_primary2_y(tlv_value) {
                Ok(value) => serde_json::to_string(&value).unwrap_or_else(|_| "null".to_string()),
                Err(e) => format!("{{\"error\": \"{}\"}}", e),
            }
        }
        0x0017 => {
            match decode_primary2_intensity(tlv_value) {
                Ok(value) => serde_json::to_string(&value).unwrap_or_else(|_| "null".to_string()),
                Err(e) => format!("{{\"error\": \"{}\"}}", e),
            }
        }
        0x0019 => {
            match decode_primary3_x(tlv_value) {
                Ok(value) => serde_json::to_string(&value).unwrap_or_else(|_| "null".to_string()),
                Err(e) => format!("{{\"error\": \"{}\"}}", e),
            }
        }
        0x001A => {
            match decode_primary3_y(tlv_value) {
                Ok(value) => serde_json::to_string(&value).unwrap_or_else(|_| "null".to_string()),
                Err(e) => format!("{{\"error\": \"{}\"}}", e),
            }
        }
        0x001B => {
            match decode_primary3_intensity(tlv_value) {
                Ok(value) => serde_json::to_string(&value).unwrap_or_else(|_| "null".to_string()),
                Err(e) => format!("{{\"error\": \"{}\"}}", e),
            }
        }
        0x0020 => {
            match decode_primary4_x(tlv_value) {
                Ok(value) => serde_json::to_string(&value).unwrap_or_else(|_| "null".to_string()),
                Err(e) => format!("{{\"error\": \"{}\"}}", e),
            }
        }
        0x0021 => {
            match decode_primary4_y(tlv_value) {
                Ok(value) => serde_json::to_string(&value).unwrap_or_else(|_| "null".to_string()),
                Err(e) => format!("{{\"error\": \"{}\"}}", e),
            }
        }
        0x0022 => {
            match decode_primary4_intensity(tlv_value) {
                Ok(value) => serde_json::to_string(&value).unwrap_or_else(|_| "null".to_string()),
                Err(e) => format!("{{\"error\": \"{}\"}}", e),
            }
        }
        0x0024 => {
            match decode_primary5_x(tlv_value) {
                Ok(value) => serde_json::to_string(&value).unwrap_or_else(|_| "null".to_string()),
                Err(e) => format!("{{\"error\": \"{}\"}}", e),
            }
        }
        0x0025 => {
            match decode_primary5_y(tlv_value) {
                Ok(value) => serde_json::to_string(&value).unwrap_or_else(|_| "null".to_string()),
                Err(e) => format!("{{\"error\": \"{}\"}}", e),
            }
        }
        0x0026 => {
            match decode_primary5_intensity(tlv_value) {
                Ok(value) => serde_json::to_string(&value).unwrap_or_else(|_| "null".to_string()),
                Err(e) => format!("{{\"error\": \"{}\"}}", e),
            }
        }
        0x0028 => {
            match decode_primary6_x(tlv_value) {
                Ok(value) => serde_json::to_string(&value).unwrap_or_else(|_| "null".to_string()),
                Err(e) => format!("{{\"error\": \"{}\"}}", e),
            }
        }
        0x0029 => {
            match decode_primary6_y(tlv_value) {
                Ok(value) => serde_json::to_string(&value).unwrap_or_else(|_| "null".to_string()),
                Err(e) => format!("{{\"error\": \"{}\"}}", e),
            }
        }
        0x002A => {
            match decode_primary6_intensity(tlv_value) {
                Ok(value) => serde_json::to_string(&value).unwrap_or_else(|_| "null".to_string()),
                Err(e) => format!("{{\"error\": \"{}\"}}", e),
            }
        }
        0x0030 => {
            match decode_white_point_x(tlv_value) {
                Ok(value) => serde_json::to_string(&value).unwrap_or_else(|_| "null".to_string()),
                Err(e) => format!("{{\"error\": \"{}\"}}", e),
            }
        }
        0x0031 => {
            match decode_white_point_y(tlv_value) {
                Ok(value) => serde_json::to_string(&value).unwrap_or_else(|_| "null".to_string()),
                Err(e) => format!("{{\"error\": \"{}\"}}", e),
            }
        }
        0x0032 => {
            match decode_color_point_rx(tlv_value) {
                Ok(value) => serde_json::to_string(&value).unwrap_or_else(|_| "null".to_string()),
                Err(e) => format!("{{\"error\": \"{}\"}}", e),
            }
        }
        0x0033 => {
            match decode_color_point_ry(tlv_value) {
                Ok(value) => serde_json::to_string(&value).unwrap_or_else(|_| "null".to_string()),
                Err(e) => format!("{{\"error\": \"{}\"}}", e),
            }
        }
        0x0034 => {
            match decode_color_point_r_intensity(tlv_value) {
                Ok(value) => serde_json::to_string(&value).unwrap_or_else(|_| "null".to_string()),
                Err(e) => format!("{{\"error\": \"{}\"}}", e),
            }
        }
        0x0036 => {
            match decode_color_point_gx(tlv_value) {
                Ok(value) => serde_json::to_string(&value).unwrap_or_else(|_| "null".to_string()),
                Err(e) => format!("{{\"error\": \"{}\"}}", e),
            }
        }
        0x0037 => {
            match decode_color_point_gy(tlv_value) {
                Ok(value) => serde_json::to_string(&value).unwrap_or_else(|_| "null".to_string()),
                Err(e) => format!("{{\"error\": \"{}\"}}", e),
            }
        }
        0x0038 => {
            match decode_color_point_g_intensity(tlv_value) {
                Ok(value) => serde_json::to_string(&value).unwrap_or_else(|_| "null".to_string()),
                Err(e) => format!("{{\"error\": \"{}\"}}", e),
            }
        }
        0x003A => {
            match decode_color_point_bx(tlv_value) {
                Ok(value) => serde_json::to_string(&value).unwrap_or_else(|_| "null".to_string()),
                Err(e) => format!("{{\"error\": \"{}\"}}", e),
            }
        }
        0x003B => {
            match decode_color_point_by(tlv_value) {
                Ok(value) => serde_json::to_string(&value).unwrap_or_else(|_| "null".to_string()),
                Err(e) => format!("{{\"error\": \"{}\"}}", e),
            }
        }
        0x003C => {
            match decode_color_point_b_intensity(tlv_value) {
                Ok(value) => serde_json::to_string(&value).unwrap_or_else(|_| "null".to_string()),
                Err(e) => format!("{{\"error\": \"{}\"}}", e),
            }
        }
        0x4000 => {
            match decode_enhanced_current_hue(tlv_value) {
                Ok(value) => serde_json::to_string(&value).unwrap_or_else(|_| "null".to_string()),
                Err(e) => format!("{{\"error\": \"{}\"}}", e),
            }
        }
        0x4001 => {
            match decode_enhanced_color_mode(tlv_value) {
                Ok(value) => serde_json::to_string(&value).unwrap_or_else(|_| "null".to_string()),
                Err(e) => format!("{{\"error\": \"{}\"}}", e),
            }
        }
        0x4002 => {
            match decode_color_loop_active(tlv_value) {
                Ok(value) => serde_json::to_string(&value).unwrap_or_else(|_| "null".to_string()),
                Err(e) => format!("{{\"error\": \"{}\"}}", e),
            }
        }
        0x4003 => {
            match decode_color_loop_direction(tlv_value) {
                Ok(value) => serde_json::to_string(&value).unwrap_or_else(|_| "null".to_string()),
                Err(e) => format!("{{\"error\": \"{}\"}}", e),
            }
        }
        0x4004 => {
            match decode_color_loop_time(tlv_value) {
                Ok(value) => serde_json::to_string(&value).unwrap_or_else(|_| "null".to_string()),
                Err(e) => format!("{{\"error\": \"{}\"}}", e),
            }
        }
        0x4005 => {
            match decode_color_loop_start_enhanced_hue(tlv_value) {
                Ok(value) => serde_json::to_string(&value).unwrap_or_else(|_| "null".to_string()),
                Err(e) => format!("{{\"error\": \"{}\"}}", e),
            }
        }
        0x4006 => {
            match decode_color_loop_stored_enhanced_hue(tlv_value) {
                Ok(value) => serde_json::to_string(&value).unwrap_or_else(|_| "null".to_string()),
                Err(e) => format!("{{\"error\": \"{}\"}}", e),
            }
        }
        0x400A => {
            match decode_color_capabilities(tlv_value) {
                Ok(value) => serde_json::to_string(&value).unwrap_or_else(|_| "null".to_string()),
                Err(e) => format!("{{\"error\": \"{}\"}}", e),
            }
        }
        0x400B => {
            match decode_color_temp_physical_min_mireds(tlv_value) {
                Ok(value) => serde_json::to_string(&value).unwrap_or_else(|_| "null".to_string()),
                Err(e) => format!("{{\"error\": \"{}\"}}", e),
            }
        }
        0x400C => {
            match decode_color_temp_physical_max_mireds(tlv_value) {
                Ok(value) => serde_json::to_string(&value).unwrap_or_else(|_| "null".to_string()),
                Err(e) => format!("{{\"error\": \"{}\"}}", e),
            }
        }
        0x400D => {
            match decode_couple_color_temp_to_level_min_mireds(tlv_value) {
                Ok(value) => serde_json::to_string(&value).unwrap_or_else(|_| "null".to_string()),
                Err(e) => format!("{{\"error\": \"{}\"}}", e),
            }
        }
        0x4010 => {
            match decode_start_up_color_temperature_mireds(tlv_value) {
                Ok(value) => serde_json::to_string(&value).unwrap_or_else(|_| "null".to_string()),
                Err(e) => format!("{{\"error\": \"{}\"}}", e),
            }
        }
        _ => format!("{{\"error\": \"Unknown attribute ID: {}\"}}", attribute_id),
    }
}

/// Get list of all attributes supported by this cluster
///
/// # Returns
/// Vector of tuples containing (attribute_id, attribute_name)
pub fn get_attribute_list() -> Vec<(u32, &'static str)> {
    vec![
        (0x0000, "CurrentHue"),
        (0x0001, "CurrentSaturation"),
        (0x0002, "RemainingTime"),
        (0x0003, "CurrentX"),
        (0x0004, "CurrentY"),
        (0x0005, "DriftCompensation"),
        (0x0006, "CompensationText"),
        (0x0007, "ColorTemperatureMireds"),
        (0x0008, "ColorMode"),
        (0x000F, "Options"),
        (0x0010, "NumberOfPrimaries"),
        (0x0011, "Primary1X"),
        (0x0012, "Primary1Y"),
        (0x0013, "Primary1Intensity"),
        (0x0015, "Primary2X"),
        (0x0016, "Primary2Y"),
        (0x0017, "Primary2Intensity"),
        (0x0019, "Primary3X"),
        (0x001A, "Primary3Y"),
        (0x001B, "Primary3Intensity"),
        (0x0020, "Primary4X"),
        (0x0021, "Primary4Y"),
        (0x0022, "Primary4Intensity"),
        (0x0024, "Primary5X"),
        (0x0025, "Primary5Y"),
        (0x0026, "Primary5Intensity"),
        (0x0028, "Primary6X"),
        (0x0029, "Primary6Y"),
        (0x002A, "Primary6Intensity"),
        (0x0030, "WhitePointX"),
        (0x0031, "WhitePointY"),
        (0x0032, "ColorPointRX"),
        (0x0033, "ColorPointRY"),
        (0x0034, "ColorPointRIntensity"),
        (0x0036, "ColorPointGX"),
        (0x0037, "ColorPointGY"),
        (0x0038, "ColorPointGIntensity"),
        (0x003A, "ColorPointBX"),
        (0x003B, "ColorPointBY"),
        (0x003C, "ColorPointBIntensity"),
        (0x4000, "EnhancedCurrentHue"),
        (0x4001, "EnhancedColorMode"),
        (0x4002, "ColorLoopActive"),
        (0x4003, "ColorLoopDirection"),
        (0x4004, "ColorLoopTime"),
        (0x4005, "ColorLoopStartEnhancedHue"),
        (0x4006, "ColorLoopStoredEnhancedHue"),
        (0x400A, "ColorCapabilities"),
        (0x400B, "ColorTempPhysicalMinMireds"),
        (0x400C, "ColorTempPhysicalMaxMireds"),
        (0x400D, "CoupleColorTempToLevelMinMireds"),
        (0x4010, "StartUpColorTemperatureMireds"),
    ]
}

// Command listing

pub fn get_command_list() -> Vec<(u32, &'static str)> {
    vec![
        (0x00, "MoveToHue"),
        (0x01, "MoveHue"),
        (0x02, "StepHue"),
        (0x03, "MoveToSaturation"),
        (0x04, "MoveSaturation"),
        (0x05, "StepSaturation"),
        (0x06, "MoveToHueAndSaturation"),
        (0x07, "MoveToColor"),
        (0x08, "MoveColor"),
        (0x09, "StepColor"),
        (0x0A, "MoveToColorTemperature"),
        (0x40, "EnhancedMoveToHue"),
        (0x41, "EnhancedMoveHue"),
        (0x42, "EnhancedStepHue"),
        (0x43, "EnhancedMoveToHueAndSaturation"),
        (0x44, "ColorLoopSet"),
        (0x47, "StopMoveStep"),
        (0x4B, "MoveColorTemperature"),
        (0x4C, "StepColorTemperature"),
    ]
}

pub fn get_command_name(cmd_id: u32) -> Option<&'static str> {
    match cmd_id {
        0x00 => Some("MoveToHue"),
        0x01 => Some("MoveHue"),
        0x02 => Some("StepHue"),
        0x03 => Some("MoveToSaturation"),
        0x04 => Some("MoveSaturation"),
        0x05 => Some("StepSaturation"),
        0x06 => Some("MoveToHueAndSaturation"),
        0x07 => Some("MoveToColor"),
        0x08 => Some("MoveColor"),
        0x09 => Some("StepColor"),
        0x0A => Some("MoveToColorTemperature"),
        0x40 => Some("EnhancedMoveToHue"),
        0x41 => Some("EnhancedMoveHue"),
        0x42 => Some("EnhancedStepHue"),
        0x43 => Some("EnhancedMoveToHueAndSaturation"),
        0x44 => Some("ColorLoopSet"),
        0x47 => Some("StopMoveStep"),
        0x4B => Some("MoveColorTemperature"),
        0x4C => Some("StepColorTemperature"),
        _ => None,
    }
}

pub fn get_command_schema(cmd_id: u32) -> Option<Vec<crate::clusters::codec::CommandField>> {
    match cmd_id {
        0x00 => Some(vec![
            crate::clusters::codec::CommandField { tag: 0, name: "hue", kind: crate::clusters::codec::FieldKind::U8, optional: false, nullable: false },
            crate::clusters::codec::CommandField { tag: 1, name: "direction", kind: crate::clusters::codec::FieldKind::Enum { name: "Direction", variants: &[(0, "Shortest"), (1, "Longest"), (2, "Up"), (3, "Down")] }, optional: false, nullable: false },
            crate::clusters::codec::CommandField { tag: 2, name: "transition_time", kind: crate::clusters::codec::FieldKind::U16, optional: false, nullable: false },
            crate::clusters::codec::CommandField { tag: 3, name: "options_mask", kind: crate::clusters::codec::FieldKind::Bitmap { name: "Options", bits: &[(1, "EXECUTE_IF_OFF")] }, optional: false, nullable: false },
            crate::clusters::codec::CommandField { tag: 4, name: "options_override", kind: crate::clusters::codec::FieldKind::Bitmap { name: "Options", bits: &[(1, "EXECUTE_IF_OFF")] }, optional: false, nullable: false },
        ]),
        0x01 => Some(vec![
            crate::clusters::codec::CommandField { tag: 0, name: "move_mode", kind: crate::clusters::codec::FieldKind::Enum { name: "MoveMode", variants: &[(0, "Stop"), (1, "Up"), (3, "Down")] }, optional: false, nullable: false },
            crate::clusters::codec::CommandField { tag: 1, name: "rate", kind: crate::clusters::codec::FieldKind::U8, optional: false, nullable: false },
            crate::clusters::codec::CommandField { tag: 2, name: "options_mask", kind: crate::clusters::codec::FieldKind::Bitmap { name: "Options", bits: &[(1, "EXECUTE_IF_OFF")] }, optional: false, nullable: false },
            crate::clusters::codec::CommandField { tag: 3, name: "options_override", kind: crate::clusters::codec::FieldKind::Bitmap { name: "Options", bits: &[(1, "EXECUTE_IF_OFF")] }, optional: false, nullable: false },
        ]),
        0x02 => Some(vec![
            crate::clusters::codec::CommandField { tag: 0, name: "step_mode", kind: crate::clusters::codec::FieldKind::Enum { name: "StepMode", variants: &[(1, "Up"), (3, "Down")] }, optional: false, nullable: false },
            crate::clusters::codec::CommandField { tag: 1, name: "step_size", kind: crate::clusters::codec::FieldKind::U8, optional: false, nullable: false },
            crate::clusters::codec::CommandField { tag: 2, name: "transition_time", kind: crate::clusters::codec::FieldKind::U8, optional: false, nullable: false },
            crate::clusters::codec::CommandField { tag: 3, name: "options_mask", kind: crate::clusters::codec::FieldKind::Bitmap { name: "Options", bits: &[(1, "EXECUTE_IF_OFF")] }, optional: false, nullable: false },
            crate::clusters::codec::CommandField { tag: 4, name: "options_override", kind: crate::clusters::codec::FieldKind::Bitmap { name: "Options", bits: &[(1, "EXECUTE_IF_OFF")] }, optional: false, nullable: false },
        ]),
        0x03 => Some(vec![
            crate::clusters::codec::CommandField { tag: 0, name: "saturation", kind: crate::clusters::codec::FieldKind::U8, optional: false, nullable: false },
            crate::clusters::codec::CommandField { tag: 1, name: "transition_time", kind: crate::clusters::codec::FieldKind::U16, optional: false, nullable: false },
            crate::clusters::codec::CommandField { tag: 2, name: "options_mask", kind: crate::clusters::codec::FieldKind::Bitmap { name: "Options", bits: &[(1, "EXECUTE_IF_OFF")] }, optional: false, nullable: false },
            crate::clusters::codec::CommandField { tag: 3, name: "options_override", kind: crate::clusters::codec::FieldKind::Bitmap { name: "Options", bits: &[(1, "EXECUTE_IF_OFF")] }, optional: false, nullable: false },
        ]),
        0x04 => Some(vec![
            crate::clusters::codec::CommandField { tag: 0, name: "move_mode", kind: crate::clusters::codec::FieldKind::Enum { name: "MoveMode", variants: &[(0, "Stop"), (1, "Up"), (3, "Down")] }, optional: false, nullable: false },
            crate::clusters::codec::CommandField { tag: 1, name: "rate", kind: crate::clusters::codec::FieldKind::U8, optional: false, nullable: false },
            crate::clusters::codec::CommandField { tag: 2, name: "options_mask", kind: crate::clusters::codec::FieldKind::Bitmap { name: "Options", bits: &[(1, "EXECUTE_IF_OFF")] }, optional: false, nullable: false },
            crate::clusters::codec::CommandField { tag: 3, name: "options_override", kind: crate::clusters::codec::FieldKind::Bitmap { name: "Options", bits: &[(1, "EXECUTE_IF_OFF")] }, optional: false, nullable: false },
        ]),
        0x05 => Some(vec![
            crate::clusters::codec::CommandField { tag: 0, name: "step_mode", kind: crate::clusters::codec::FieldKind::Enum { name: "StepMode", variants: &[(1, "Up"), (3, "Down")] }, optional: false, nullable: false },
            crate::clusters::codec::CommandField { tag: 1, name: "step_size", kind: crate::clusters::codec::FieldKind::U8, optional: false, nullable: false },
            crate::clusters::codec::CommandField { tag: 2, name: "transition_time", kind: crate::clusters::codec::FieldKind::U8, optional: false, nullable: false },
            crate::clusters::codec::CommandField { tag: 3, name: "options_mask", kind: crate::clusters::codec::FieldKind::Bitmap { name: "Options", bits: &[(1, "EXECUTE_IF_OFF")] }, optional: false, nullable: false },
            crate::clusters::codec::CommandField { tag: 4, name: "options_override", kind: crate::clusters::codec::FieldKind::Bitmap { name: "Options", bits: &[(1, "EXECUTE_IF_OFF")] }, optional: false, nullable: false },
        ]),
        0x06 => Some(vec![
            crate::clusters::codec::CommandField { tag: 0, name: "hue", kind: crate::clusters::codec::FieldKind::U8, optional: false, nullable: false },
            crate::clusters::codec::CommandField { tag: 1, name: "saturation", kind: crate::clusters::codec::FieldKind::U8, optional: false, nullable: false },
            crate::clusters::codec::CommandField { tag: 2, name: "transition_time", kind: crate::clusters::codec::FieldKind::U16, optional: false, nullable: false },
            crate::clusters::codec::CommandField { tag: 3, name: "options_mask", kind: crate::clusters::codec::FieldKind::Bitmap { name: "Options", bits: &[(1, "EXECUTE_IF_OFF")] }, optional: false, nullable: false },
            crate::clusters::codec::CommandField { tag: 4, name: "options_override", kind: crate::clusters::codec::FieldKind::Bitmap { name: "Options", bits: &[(1, "EXECUTE_IF_OFF")] }, optional: false, nullable: false },
        ]),
        0x07 => Some(vec![
            crate::clusters::codec::CommandField { tag: 0, name: "color_x", kind: crate::clusters::codec::FieldKind::U16, optional: false, nullable: false },
            crate::clusters::codec::CommandField { tag: 1, name: "color_y", kind: crate::clusters::codec::FieldKind::U16, optional: false, nullable: false },
            crate::clusters::codec::CommandField { tag: 2, name: "transition_time", kind: crate::clusters::codec::FieldKind::U16, optional: false, nullable: false },
            crate::clusters::codec::CommandField { tag: 3, name: "options_mask", kind: crate::clusters::codec::FieldKind::Bitmap { name: "Options", bits: &[(1, "EXECUTE_IF_OFF")] }, optional: false, nullable: false },
            crate::clusters::codec::CommandField { tag: 4, name: "options_override", kind: crate::clusters::codec::FieldKind::Bitmap { name: "Options", bits: &[(1, "EXECUTE_IF_OFF")] }, optional: false, nullable: false },
        ]),
        0x08 => Some(vec![
            crate::clusters::codec::CommandField { tag: 0, name: "rate_x", kind: crate::clusters::codec::FieldKind::I16, optional: false, nullable: false },
            crate::clusters::codec::CommandField { tag: 1, name: "rate_y", kind: crate::clusters::codec::FieldKind::I16, optional: false, nullable: false },
            crate::clusters::codec::CommandField { tag: 2, name: "options_mask", kind: crate::clusters::codec::FieldKind::Bitmap { name: "Options", bits: &[(1, "EXECUTE_IF_OFF")] }, optional: false, nullable: false },
            crate::clusters::codec::CommandField { tag: 3, name: "options_override", kind: crate::clusters::codec::FieldKind::Bitmap { name: "Options", bits: &[(1, "EXECUTE_IF_OFF")] }, optional: false, nullable: false },
        ]),
        0x09 => Some(vec![
            crate::clusters::codec::CommandField { tag: 0, name: "step_x", kind: crate::clusters::codec::FieldKind::I16, optional: false, nullable: false },
            crate::clusters::codec::CommandField { tag: 1, name: "step_y", kind: crate::clusters::codec::FieldKind::I16, optional: false, nullable: false },
            crate::clusters::codec::CommandField { tag: 2, name: "transition_time", kind: crate::clusters::codec::FieldKind::U16, optional: false, nullable: false },
            crate::clusters::codec::CommandField { tag: 3, name: "options_mask", kind: crate::clusters::codec::FieldKind::Bitmap { name: "Options", bits: &[(1, "EXECUTE_IF_OFF")] }, optional: false, nullable: false },
            crate::clusters::codec::CommandField { tag: 4, name: "options_override", kind: crate::clusters::codec::FieldKind::Bitmap { name: "Options", bits: &[(1, "EXECUTE_IF_OFF")] }, optional: false, nullable: false },
        ]),
        0x0A => Some(vec![
            crate::clusters::codec::CommandField { tag: 0, name: "color_temperature_mireds", kind: crate::clusters::codec::FieldKind::U16, optional: false, nullable: false },
            crate::clusters::codec::CommandField { tag: 1, name: "transition_time", kind: crate::clusters::codec::FieldKind::U16, optional: false, nullable: false },
            crate::clusters::codec::CommandField { tag: 2, name: "options_mask", kind: crate::clusters::codec::FieldKind::Bitmap { name: "Options", bits: &[(1, "EXECUTE_IF_OFF")] }, optional: false, nullable: false },
            crate::clusters::codec::CommandField { tag: 3, name: "options_override", kind: crate::clusters::codec::FieldKind::Bitmap { name: "Options", bits: &[(1, "EXECUTE_IF_OFF")] }, optional: false, nullable: false },
        ]),
        0x40 => Some(vec![
            crate::clusters::codec::CommandField { tag: 0, name: "enhanced_hue", kind: crate::clusters::codec::FieldKind::U16, optional: false, nullable: false },
            crate::clusters::codec::CommandField { tag: 1, name: "direction", kind: crate::clusters::codec::FieldKind::Enum { name: "Direction", variants: &[(0, "Shortest"), (1, "Longest"), (2, "Up"), (3, "Down")] }, optional: false, nullable: false },
            crate::clusters::codec::CommandField { tag: 2, name: "transition_time", kind: crate::clusters::codec::FieldKind::U16, optional: false, nullable: false },
            crate::clusters::codec::CommandField { tag: 3, name: "options_mask", kind: crate::clusters::codec::FieldKind::Bitmap { name: "Options", bits: &[(1, "EXECUTE_IF_OFF")] }, optional: false, nullable: false },
            crate::clusters::codec::CommandField { tag: 4, name: "options_override", kind: crate::clusters::codec::FieldKind::Bitmap { name: "Options", bits: &[(1, "EXECUTE_IF_OFF")] }, optional: false, nullable: false },
        ]),
        0x41 => Some(vec![
            crate::clusters::codec::CommandField { tag: 0, name: "move_mode", kind: crate::clusters::codec::FieldKind::Enum { name: "MoveMode", variants: &[(0, "Stop"), (1, "Up"), (3, "Down")] }, optional: false, nullable: false },
            crate::clusters::codec::CommandField { tag: 1, name: "rate", kind: crate::clusters::codec::FieldKind::U16, optional: false, nullable: false },
            crate::clusters::codec::CommandField { tag: 2, name: "options_mask", kind: crate::clusters::codec::FieldKind::Bitmap { name: "Options", bits: &[(1, "EXECUTE_IF_OFF")] }, optional: false, nullable: false },
            crate::clusters::codec::CommandField { tag: 3, name: "options_override", kind: crate::clusters::codec::FieldKind::Bitmap { name: "Options", bits: &[(1, "EXECUTE_IF_OFF")] }, optional: false, nullable: false },
        ]),
        0x42 => Some(vec![
            crate::clusters::codec::CommandField { tag: 0, name: "step_mode", kind: crate::clusters::codec::FieldKind::Enum { name: "StepMode", variants: &[(1, "Up"), (3, "Down")] }, optional: false, nullable: false },
            crate::clusters::codec::CommandField { tag: 1, name: "step_size", kind: crate::clusters::codec::FieldKind::U16, optional: false, nullable: false },
            crate::clusters::codec::CommandField { tag: 2, name: "transition_time", kind: crate::clusters::codec::FieldKind::U16, optional: false, nullable: false },
            crate::clusters::codec::CommandField { tag: 3, name: "options_mask", kind: crate::clusters::codec::FieldKind::Bitmap { name: "Options", bits: &[(1, "EXECUTE_IF_OFF")] }, optional: false, nullable: false },
            crate::clusters::codec::CommandField { tag: 4, name: "options_override", kind: crate::clusters::codec::FieldKind::Bitmap { name: "Options", bits: &[(1, "EXECUTE_IF_OFF")] }, optional: false, nullable: false },
        ]),
        0x43 => Some(vec![
            crate::clusters::codec::CommandField { tag: 0, name: "enhanced_hue", kind: crate::clusters::codec::FieldKind::U16, optional: false, nullable: false },
            crate::clusters::codec::CommandField { tag: 1, name: "saturation", kind: crate::clusters::codec::FieldKind::U8, optional: false, nullable: false },
            crate::clusters::codec::CommandField { tag: 2, name: "transition_time", kind: crate::clusters::codec::FieldKind::U16, optional: false, nullable: false },
            crate::clusters::codec::CommandField { tag: 3, name: "options_mask", kind: crate::clusters::codec::FieldKind::Bitmap { name: "Options", bits: &[(1, "EXECUTE_IF_OFF")] }, optional: false, nullable: false },
            crate::clusters::codec::CommandField { tag: 4, name: "options_override", kind: crate::clusters::codec::FieldKind::Bitmap { name: "Options", bits: &[(1, "EXECUTE_IF_OFF")] }, optional: false, nullable: false },
        ]),
        0x44 => Some(vec![
            crate::clusters::codec::CommandField { tag: 0, name: "update_flags", kind: crate::clusters::codec::FieldKind::Bitmap { name: "UpdateFlags", bits: &[(1, "UPDATE_ACTION"), (2, "UPDATE_DIRECTION"), (4, "UPDATE_TIME"), (8, "UPDATE_START_HUE")] }, optional: false, nullable: false },
            crate::clusters::codec::CommandField { tag: 1, name: "action", kind: crate::clusters::codec::FieldKind::Enum { name: "ColorLoopAction", variants: &[(0, "Deactivate"), (1, "Activatefromcolorloopstartenhancedhue"), (2, "Activatefromenhancedcurrenthue")] }, optional: false, nullable: false },
            crate::clusters::codec::CommandField { tag: 2, name: "direction", kind: crate::clusters::codec::FieldKind::Enum { name: "ColorLoopDirection", variants: &[(0, "Decrement"), (1, "Increment")] }, optional: false, nullable: false },
            crate::clusters::codec::CommandField { tag: 3, name: "time", kind: crate::clusters::codec::FieldKind::U16, optional: false, nullable: false },
            crate::clusters::codec::CommandField { tag: 4, name: "start_hue", kind: crate::clusters::codec::FieldKind::U16, optional: false, nullable: false },
            crate::clusters::codec::CommandField { tag: 5, name: "options_mask", kind: crate::clusters::codec::FieldKind::Bitmap { name: "Options", bits: &[(1, "EXECUTE_IF_OFF")] }, optional: false, nullable: false },
            crate::clusters::codec::CommandField { tag: 6, name: "options_override", kind: crate::clusters::codec::FieldKind::Bitmap { name: "Options", bits: &[(1, "EXECUTE_IF_OFF")] }, optional: false, nullable: false },
        ]),
        0x47 => Some(vec![
            crate::clusters::codec::CommandField { tag: 0, name: "options_mask", kind: crate::clusters::codec::FieldKind::Bitmap { name: "Options", bits: &[(1, "EXECUTE_IF_OFF")] }, optional: false, nullable: false },
            crate::clusters::codec::CommandField { tag: 1, name: "options_override", kind: crate::clusters::codec::FieldKind::Bitmap { name: "Options", bits: &[(1, "EXECUTE_IF_OFF")] }, optional: false, nullable: false },
        ]),
        0x4B => Some(vec![
            crate::clusters::codec::CommandField { tag: 0, name: "move_mode", kind: crate::clusters::codec::FieldKind::Enum { name: "MoveMode", variants: &[(0, "Stop"), (1, "Up"), (3, "Down")] }, optional: false, nullable: false },
            crate::clusters::codec::CommandField { tag: 1, name: "rate", kind: crate::clusters::codec::FieldKind::U16, optional: false, nullable: false },
            crate::clusters::codec::CommandField { tag: 2, name: "color_temperature_minimum_mireds", kind: crate::clusters::codec::FieldKind::U16, optional: false, nullable: false },
            crate::clusters::codec::CommandField { tag: 3, name: "color_temperature_maximum_mireds", kind: crate::clusters::codec::FieldKind::U16, optional: false, nullable: false },
            crate::clusters::codec::CommandField { tag: 4, name: "options_mask", kind: crate::clusters::codec::FieldKind::Bitmap { name: "Options", bits: &[(1, "EXECUTE_IF_OFF")] }, optional: false, nullable: false },
            crate::clusters::codec::CommandField { tag: 5, name: "options_override", kind: crate::clusters::codec::FieldKind::Bitmap { name: "Options", bits: &[(1, "EXECUTE_IF_OFF")] }, optional: false, nullable: false },
        ]),
        0x4C => Some(vec![
            crate::clusters::codec::CommandField { tag: 0, name: "step_mode", kind: crate::clusters::codec::FieldKind::Enum { name: "StepMode", variants: &[(1, "Up"), (3, "Down")] }, optional: false, nullable: false },
            crate::clusters::codec::CommandField { tag: 1, name: "step_size", kind: crate::clusters::codec::FieldKind::U16, optional: false, nullable: false },
            crate::clusters::codec::CommandField { tag: 2, name: "transition_time", kind: crate::clusters::codec::FieldKind::U16, optional: false, nullable: false },
            crate::clusters::codec::CommandField { tag: 3, name: "color_temperature_minimum_mireds", kind: crate::clusters::codec::FieldKind::U16, optional: false, nullable: false },
            crate::clusters::codec::CommandField { tag: 4, name: "color_temperature_maximum_mireds", kind: crate::clusters::codec::FieldKind::U16, optional: false, nullable: false },
            crate::clusters::codec::CommandField { tag: 5, name: "options_mask", kind: crate::clusters::codec::FieldKind::Bitmap { name: "Options", bits: &[(1, "EXECUTE_IF_OFF")] }, optional: false, nullable: false },
            crate::clusters::codec::CommandField { tag: 6, name: "options_override", kind: crate::clusters::codec::FieldKind::Bitmap { name: "Options", bits: &[(1, "EXECUTE_IF_OFF")] }, optional: false, nullable: false },
        ]),
        _ => None,
    }
}

pub fn encode_command_json(cmd_id: u32, args: &serde_json::Value) -> anyhow::Result<Vec<u8>> {
    match cmd_id {
        0x00 => {
        let hue = crate::clusters::codec::json_util::get_u8(args, "hue")?;
        let direction = {
            let n = crate::clusters::codec::json_util::get_u64(args, "direction")?;
            Direction::from_u8(n as u8).ok_or_else(|| anyhow::anyhow!("invalid Direction: {}", n))?
        };
        let transition_time = crate::clusters::codec::json_util::get_u16(args, "transition_time")?;
        let options_mask = crate::clusters::codec::json_util::get_u8(args, "options_mask")?;
        let options_override = crate::clusters::codec::json_util::get_u8(args, "options_override")?;
        encode_move_to_hue(hue, direction, transition_time, options_mask, options_override)
        }
        0x01 => {
        let move_mode = {
            let n = crate::clusters::codec::json_util::get_u64(args, "move_mode")?;
            MoveMode::from_u8(n as u8).ok_or_else(|| anyhow::anyhow!("invalid MoveMode: {}", n))?
        };
        let rate = crate::clusters::codec::json_util::get_u8(args, "rate")?;
        let options_mask = crate::clusters::codec::json_util::get_u8(args, "options_mask")?;
        let options_override = crate::clusters::codec::json_util::get_u8(args, "options_override")?;
        encode_move_hue(move_mode, rate, options_mask, options_override)
        }
        0x02 => {
        let step_mode = {
            let n = crate::clusters::codec::json_util::get_u64(args, "step_mode")?;
            StepMode::from_u8(n as u8).ok_or_else(|| anyhow::anyhow!("invalid StepMode: {}", n))?
        };
        let step_size = crate::clusters::codec::json_util::get_u8(args, "step_size")?;
        let transition_time = crate::clusters::codec::json_util::get_u8(args, "transition_time")?;
        let options_mask = crate::clusters::codec::json_util::get_u8(args, "options_mask")?;
        let options_override = crate::clusters::codec::json_util::get_u8(args, "options_override")?;
        encode_step_hue(step_mode, step_size, transition_time, options_mask, options_override)
        }
        0x03 => {
        let saturation = crate::clusters::codec::json_util::get_u8(args, "saturation")?;
        let transition_time = crate::clusters::codec::json_util::get_u16(args, "transition_time")?;
        let options_mask = crate::clusters::codec::json_util::get_u8(args, "options_mask")?;
        let options_override = crate::clusters::codec::json_util::get_u8(args, "options_override")?;
        encode_move_to_saturation(saturation, transition_time, options_mask, options_override)
        }
        0x04 => {
        let move_mode = {
            let n = crate::clusters::codec::json_util::get_u64(args, "move_mode")?;
            MoveMode::from_u8(n as u8).ok_or_else(|| anyhow::anyhow!("invalid MoveMode: {}", n))?
        };
        let rate = crate::clusters::codec::json_util::get_u8(args, "rate")?;
        let options_mask = crate::clusters::codec::json_util::get_u8(args, "options_mask")?;
        let options_override = crate::clusters::codec::json_util::get_u8(args, "options_override")?;
        encode_move_saturation(move_mode, rate, options_mask, options_override)
        }
        0x05 => {
        let step_mode = {
            let n = crate::clusters::codec::json_util::get_u64(args, "step_mode")?;
            StepMode::from_u8(n as u8).ok_or_else(|| anyhow::anyhow!("invalid StepMode: {}", n))?
        };
        let step_size = crate::clusters::codec::json_util::get_u8(args, "step_size")?;
        let transition_time = crate::clusters::codec::json_util::get_u8(args, "transition_time")?;
        let options_mask = crate::clusters::codec::json_util::get_u8(args, "options_mask")?;
        let options_override = crate::clusters::codec::json_util::get_u8(args, "options_override")?;
        encode_step_saturation(step_mode, step_size, transition_time, options_mask, options_override)
        }
        0x06 => {
        let hue = crate::clusters::codec::json_util::get_u8(args, "hue")?;
        let saturation = crate::clusters::codec::json_util::get_u8(args, "saturation")?;
        let transition_time = crate::clusters::codec::json_util::get_u16(args, "transition_time")?;
        let options_mask = crate::clusters::codec::json_util::get_u8(args, "options_mask")?;
        let options_override = crate::clusters::codec::json_util::get_u8(args, "options_override")?;
        encode_move_to_hue_and_saturation(hue, saturation, transition_time, options_mask, options_override)
        }
        0x07 => {
        let color_x = crate::clusters::codec::json_util::get_u16(args, "color_x")?;
        let color_y = crate::clusters::codec::json_util::get_u16(args, "color_y")?;
        let transition_time = crate::clusters::codec::json_util::get_u16(args, "transition_time")?;
        let options_mask = crate::clusters::codec::json_util::get_u8(args, "options_mask")?;
        let options_override = crate::clusters::codec::json_util::get_u8(args, "options_override")?;
        encode_move_to_color(color_x, color_y, transition_time, options_mask, options_override)
        }
        0x08 => {
        let rate_x = crate::clusters::codec::json_util::get_i16(args, "rate_x")?;
        let rate_y = crate::clusters::codec::json_util::get_i16(args, "rate_y")?;
        let options_mask = crate::clusters::codec::json_util::get_u8(args, "options_mask")?;
        let options_override = crate::clusters::codec::json_util::get_u8(args, "options_override")?;
        encode_move_color(rate_x, rate_y, options_mask, options_override)
        }
        0x09 => {
        let step_x = crate::clusters::codec::json_util::get_i16(args, "step_x")?;
        let step_y = crate::clusters::codec::json_util::get_i16(args, "step_y")?;
        let transition_time = crate::clusters::codec::json_util::get_u16(args, "transition_time")?;
        let options_mask = crate::clusters::codec::json_util::get_u8(args, "options_mask")?;
        let options_override = crate::clusters::codec::json_util::get_u8(args, "options_override")?;
        encode_step_color(step_x, step_y, transition_time, options_mask, options_override)
        }
        0x0A => {
        let color_temperature_mireds = crate::clusters::codec::json_util::get_u16(args, "color_temperature_mireds")?;
        let transition_time = crate::clusters::codec::json_util::get_u16(args, "transition_time")?;
        let options_mask = crate::clusters::codec::json_util::get_u8(args, "options_mask")?;
        let options_override = crate::clusters::codec::json_util::get_u8(args, "options_override")?;
        encode_move_to_color_temperature(color_temperature_mireds, transition_time, options_mask, options_override)
        }
        0x40 => {
        let enhanced_hue = crate::clusters::codec::json_util::get_u16(args, "enhanced_hue")?;
        let direction = {
            let n = crate::clusters::codec::json_util::get_u64(args, "direction")?;
            Direction::from_u8(n as u8).ok_or_else(|| anyhow::anyhow!("invalid Direction: {}", n))?
        };
        let transition_time = crate::clusters::codec::json_util::get_u16(args, "transition_time")?;
        let options_mask = crate::clusters::codec::json_util::get_u8(args, "options_mask")?;
        let options_override = crate::clusters::codec::json_util::get_u8(args, "options_override")?;
        encode_enhanced_move_to_hue(enhanced_hue, direction, transition_time, options_mask, options_override)
        }
        0x41 => {
        let move_mode = {
            let n = crate::clusters::codec::json_util::get_u64(args, "move_mode")?;
            MoveMode::from_u8(n as u8).ok_or_else(|| anyhow::anyhow!("invalid MoveMode: {}", n))?
        };
        let rate = crate::clusters::codec::json_util::get_u16(args, "rate")?;
        let options_mask = crate::clusters::codec::json_util::get_u8(args, "options_mask")?;
        let options_override = crate::clusters::codec::json_util::get_u8(args, "options_override")?;
        encode_enhanced_move_hue(move_mode, rate, options_mask, options_override)
        }
        0x42 => {
        let step_mode = {
            let n = crate::clusters::codec::json_util::get_u64(args, "step_mode")?;
            StepMode::from_u8(n as u8).ok_or_else(|| anyhow::anyhow!("invalid StepMode: {}", n))?
        };
        let step_size = crate::clusters::codec::json_util::get_u16(args, "step_size")?;
        let transition_time = crate::clusters::codec::json_util::get_u16(args, "transition_time")?;
        let options_mask = crate::clusters::codec::json_util::get_u8(args, "options_mask")?;
        let options_override = crate::clusters::codec::json_util::get_u8(args, "options_override")?;
        encode_enhanced_step_hue(step_mode, step_size, transition_time, options_mask, options_override)
        }
        0x43 => {
        let enhanced_hue = crate::clusters::codec::json_util::get_u16(args, "enhanced_hue")?;
        let saturation = crate::clusters::codec::json_util::get_u8(args, "saturation")?;
        let transition_time = crate::clusters::codec::json_util::get_u16(args, "transition_time")?;
        let options_mask = crate::clusters::codec::json_util::get_u8(args, "options_mask")?;
        let options_override = crate::clusters::codec::json_util::get_u8(args, "options_override")?;
        encode_enhanced_move_to_hue_and_saturation(enhanced_hue, saturation, transition_time, options_mask, options_override)
        }
        0x44 => {
        let update_flags = crate::clusters::codec::json_util::get_u8(args, "update_flags")?;
        let action = {
            let n = crate::clusters::codec::json_util::get_u64(args, "action")?;
            ColorLoopAction::from_u8(n as u8).ok_or_else(|| anyhow::anyhow!("invalid ColorLoopAction: {}", n))?
        };
        let direction = {
            let n = crate::clusters::codec::json_util::get_u64(args, "direction")?;
            ColorLoopDirection::from_u8(n as u8).ok_or_else(|| anyhow::anyhow!("invalid ColorLoopDirection: {}", n))?
        };
        let time = crate::clusters::codec::json_util::get_u16(args, "time")?;
        let start_hue = crate::clusters::codec::json_util::get_u16(args, "start_hue")?;
        let options_mask = crate::clusters::codec::json_util::get_u8(args, "options_mask")?;
        let options_override = crate::clusters::codec::json_util::get_u8(args, "options_override")?;
        encode_color_loop_set(update_flags, action, direction, time, start_hue, options_mask, options_override)
        }
        0x47 => {
        let options_mask = crate::clusters::codec::json_util::get_u8(args, "options_mask")?;
        let options_override = crate::clusters::codec::json_util::get_u8(args, "options_override")?;
        encode_stop_move_step(options_mask, options_override)
        }
        0x4B => {
        let move_mode = {
            let n = crate::clusters::codec::json_util::get_u64(args, "move_mode")?;
            MoveMode::from_u8(n as u8).ok_or_else(|| anyhow::anyhow!("invalid MoveMode: {}", n))?
        };
        let rate = crate::clusters::codec::json_util::get_u16(args, "rate")?;
        let color_temperature_minimum_mireds = crate::clusters::codec::json_util::get_u16(args, "color_temperature_minimum_mireds")?;
        let color_temperature_maximum_mireds = crate::clusters::codec::json_util::get_u16(args, "color_temperature_maximum_mireds")?;
        let options_mask = crate::clusters::codec::json_util::get_u8(args, "options_mask")?;
        let options_override = crate::clusters::codec::json_util::get_u8(args, "options_override")?;
        encode_move_color_temperature(move_mode, rate, color_temperature_minimum_mireds, color_temperature_maximum_mireds, options_mask, options_override)
        }
        0x4C => {
        let step_mode = {
            let n = crate::clusters::codec::json_util::get_u64(args, "step_mode")?;
            StepMode::from_u8(n as u8).ok_or_else(|| anyhow::anyhow!("invalid StepMode: {}", n))?
        };
        let step_size = crate::clusters::codec::json_util::get_u16(args, "step_size")?;
        let transition_time = crate::clusters::codec::json_util::get_u16(args, "transition_time")?;
        let color_temperature_minimum_mireds = crate::clusters::codec::json_util::get_u16(args, "color_temperature_minimum_mireds")?;
        let color_temperature_maximum_mireds = crate::clusters::codec::json_util::get_u16(args, "color_temperature_maximum_mireds")?;
        let options_mask = crate::clusters::codec::json_util::get_u8(args, "options_mask")?;
        let options_override = crate::clusters::codec::json_util::get_u8(args, "options_override")?;
        encode_step_color_temperature(step_mode, step_size, transition_time, color_temperature_minimum_mireds, color_temperature_maximum_mireds, options_mask, options_override)
        }
        _ => Err(anyhow::anyhow!("unknown command ID: 0x{:02X}", cmd_id)),
    }
}

// Typed facade (invokes + reads)

/// Invoke `MoveToHue` command on cluster `Color Control`.
pub async fn move_to_hue(conn: &crate::controller::Connection, endpoint: u16, hue: u8, direction: Direction, transition_time: u16, options_mask: Options, options_override: Options) -> anyhow::Result<()> {
    conn.invoke_request(endpoint, crate::clusters::defs::CLUSTER_ID_COLOR_CONTROL, crate::clusters::defs::CLUSTER_COLOR_CONTROL_CMD_ID_MOVETOHUE, &encode_move_to_hue(hue, direction, transition_time, options_mask, options_override)?).await?;
    Ok(())
}

/// Invoke `MoveHue` command on cluster `Color Control`.
pub async fn move_hue(conn: &crate::controller::Connection, endpoint: u16, move_mode: MoveMode, rate: u8, options_mask: Options, options_override: Options) -> anyhow::Result<()> {
    conn.invoke_request(endpoint, crate::clusters::defs::CLUSTER_ID_COLOR_CONTROL, crate::clusters::defs::CLUSTER_COLOR_CONTROL_CMD_ID_MOVEHUE, &encode_move_hue(move_mode, rate, options_mask, options_override)?).await?;
    Ok(())
}

/// Invoke `StepHue` command on cluster `Color Control`.
pub async fn step_hue(conn: &crate::controller::Connection, endpoint: u16, step_mode: StepMode, step_size: u8, transition_time: u8, options_mask: Options, options_override: Options) -> anyhow::Result<()> {
    conn.invoke_request(endpoint, crate::clusters::defs::CLUSTER_ID_COLOR_CONTROL, crate::clusters::defs::CLUSTER_COLOR_CONTROL_CMD_ID_STEPHUE, &encode_step_hue(step_mode, step_size, transition_time, options_mask, options_override)?).await?;
    Ok(())
}

/// Invoke `MoveToSaturation` command on cluster `Color Control`.
pub async fn move_to_saturation(conn: &crate::controller::Connection, endpoint: u16, saturation: u8, transition_time: u16, options_mask: Options, options_override: Options) -> anyhow::Result<()> {
    conn.invoke_request(endpoint, crate::clusters::defs::CLUSTER_ID_COLOR_CONTROL, crate::clusters::defs::CLUSTER_COLOR_CONTROL_CMD_ID_MOVETOSATURATION, &encode_move_to_saturation(saturation, transition_time, options_mask, options_override)?).await?;
    Ok(())
}

/// Invoke `MoveSaturation` command on cluster `Color Control`.
pub async fn move_saturation(conn: &crate::controller::Connection, endpoint: u16, move_mode: MoveMode, rate: u8, options_mask: Options, options_override: Options) -> anyhow::Result<()> {
    conn.invoke_request(endpoint, crate::clusters::defs::CLUSTER_ID_COLOR_CONTROL, crate::clusters::defs::CLUSTER_COLOR_CONTROL_CMD_ID_MOVESATURATION, &encode_move_saturation(move_mode, rate, options_mask, options_override)?).await?;
    Ok(())
}

/// Invoke `StepSaturation` command on cluster `Color Control`.
pub async fn step_saturation(conn: &crate::controller::Connection, endpoint: u16, step_mode: StepMode, step_size: u8, transition_time: u8, options_mask: Options, options_override: Options) -> anyhow::Result<()> {
    conn.invoke_request(endpoint, crate::clusters::defs::CLUSTER_ID_COLOR_CONTROL, crate::clusters::defs::CLUSTER_COLOR_CONTROL_CMD_ID_STEPSATURATION, &encode_step_saturation(step_mode, step_size, transition_time, options_mask, options_override)?).await?;
    Ok(())
}

/// Invoke `MoveToHueAndSaturation` command on cluster `Color Control`.
pub async fn move_to_hue_and_saturation(conn: &crate::controller::Connection, endpoint: u16, hue: u8, saturation: u8, transition_time: u16, options_mask: Options, options_override: Options) -> anyhow::Result<()> {
    conn.invoke_request(endpoint, crate::clusters::defs::CLUSTER_ID_COLOR_CONTROL, crate::clusters::defs::CLUSTER_COLOR_CONTROL_CMD_ID_MOVETOHUEANDSATURATION, &encode_move_to_hue_and_saturation(hue, saturation, transition_time, options_mask, options_override)?).await?;
    Ok(())
}

/// Invoke `MoveToColor` command on cluster `Color Control`.
pub async fn move_to_color(conn: &crate::controller::Connection, endpoint: u16, color_x: u16, color_y: u16, transition_time: u16, options_mask: Options, options_override: Options) -> anyhow::Result<()> {
    conn.invoke_request(endpoint, crate::clusters::defs::CLUSTER_ID_COLOR_CONTROL, crate::clusters::defs::CLUSTER_COLOR_CONTROL_CMD_ID_MOVETOCOLOR, &encode_move_to_color(color_x, color_y, transition_time, options_mask, options_override)?).await?;
    Ok(())
}

/// Invoke `MoveColor` command on cluster `Color Control`.
pub async fn move_color(conn: &crate::controller::Connection, endpoint: u16, rate_x: i16, rate_y: i16, options_mask: Options, options_override: Options) -> anyhow::Result<()> {
    conn.invoke_request(endpoint, crate::clusters::defs::CLUSTER_ID_COLOR_CONTROL, crate::clusters::defs::CLUSTER_COLOR_CONTROL_CMD_ID_MOVECOLOR, &encode_move_color(rate_x, rate_y, options_mask, options_override)?).await?;
    Ok(())
}

/// Invoke `StepColor` command on cluster `Color Control`.
pub async fn step_color(conn: &crate::controller::Connection, endpoint: u16, step_x: i16, step_y: i16, transition_time: u16, options_mask: Options, options_override: Options) -> anyhow::Result<()> {
    conn.invoke_request(endpoint, crate::clusters::defs::CLUSTER_ID_COLOR_CONTROL, crate::clusters::defs::CLUSTER_COLOR_CONTROL_CMD_ID_STEPCOLOR, &encode_step_color(step_x, step_y, transition_time, options_mask, options_override)?).await?;
    Ok(())
}

/// Invoke `MoveToColorTemperature` command on cluster `Color Control`.
pub async fn move_to_color_temperature(conn: &crate::controller::Connection, endpoint: u16, color_temperature_mireds: u16, transition_time: u16, options_mask: Options, options_override: Options) -> anyhow::Result<()> {
    conn.invoke_request(endpoint, crate::clusters::defs::CLUSTER_ID_COLOR_CONTROL, crate::clusters::defs::CLUSTER_COLOR_CONTROL_CMD_ID_MOVETOCOLORTEMPERATURE, &encode_move_to_color_temperature(color_temperature_mireds, transition_time, options_mask, options_override)?).await?;
    Ok(())
}

/// Invoke `EnhancedMoveToHue` command on cluster `Color Control`.
pub async fn enhanced_move_to_hue(conn: &crate::controller::Connection, endpoint: u16, enhanced_hue: u16, direction: Direction, transition_time: u16, options_mask: Options, options_override: Options) -> anyhow::Result<()> {
    conn.invoke_request(endpoint, crate::clusters::defs::CLUSTER_ID_COLOR_CONTROL, crate::clusters::defs::CLUSTER_COLOR_CONTROL_CMD_ID_ENHANCEDMOVETOHUE, &encode_enhanced_move_to_hue(enhanced_hue, direction, transition_time, options_mask, options_override)?).await?;
    Ok(())
}

/// Invoke `EnhancedMoveHue` command on cluster `Color Control`.
pub async fn enhanced_move_hue(conn: &crate::controller::Connection, endpoint: u16, move_mode: MoveMode, rate: u16, options_mask: Options, options_override: Options) -> anyhow::Result<()> {
    conn.invoke_request(endpoint, crate::clusters::defs::CLUSTER_ID_COLOR_CONTROL, crate::clusters::defs::CLUSTER_COLOR_CONTROL_CMD_ID_ENHANCEDMOVEHUE, &encode_enhanced_move_hue(move_mode, rate, options_mask, options_override)?).await?;
    Ok(())
}

/// Invoke `EnhancedStepHue` command on cluster `Color Control`.
pub async fn enhanced_step_hue(conn: &crate::controller::Connection, endpoint: u16, step_mode: StepMode, step_size: u16, transition_time: u16, options_mask: Options, options_override: Options) -> anyhow::Result<()> {
    conn.invoke_request(endpoint, crate::clusters::defs::CLUSTER_ID_COLOR_CONTROL, crate::clusters::defs::CLUSTER_COLOR_CONTROL_CMD_ID_ENHANCEDSTEPHUE, &encode_enhanced_step_hue(step_mode, step_size, transition_time, options_mask, options_override)?).await?;
    Ok(())
}

/// Invoke `EnhancedMoveToHueAndSaturation` command on cluster `Color Control`.
pub async fn enhanced_move_to_hue_and_saturation(conn: &crate::controller::Connection, endpoint: u16, enhanced_hue: u16, saturation: u8, transition_time: u16, options_mask: Options, options_override: Options) -> anyhow::Result<()> {
    conn.invoke_request(endpoint, crate::clusters::defs::CLUSTER_ID_COLOR_CONTROL, crate::clusters::defs::CLUSTER_COLOR_CONTROL_CMD_ID_ENHANCEDMOVETOHUEANDSATURATION, &encode_enhanced_move_to_hue_and_saturation(enhanced_hue, saturation, transition_time, options_mask, options_override)?).await?;
    Ok(())
}

/// Invoke `ColorLoopSet` command on cluster `Color Control`.
pub async fn color_loop_set(conn: &crate::controller::Connection, endpoint: u16, update_flags: UpdateFlags, action: ColorLoopAction, direction: ColorLoopDirection, time: u16, start_hue: u16, options_mask: Options, options_override: Options) -> anyhow::Result<()> {
    conn.invoke_request(endpoint, crate::clusters::defs::CLUSTER_ID_COLOR_CONTROL, crate::clusters::defs::CLUSTER_COLOR_CONTROL_CMD_ID_COLORLOOPSET, &encode_color_loop_set(update_flags, action, direction, time, start_hue, options_mask, options_override)?).await?;
    Ok(())
}

/// Invoke `StopMoveStep` command on cluster `Color Control`.
pub async fn stop_move_step(conn: &crate::controller::Connection, endpoint: u16, options_mask: Options, options_override: Options) -> anyhow::Result<()> {
    conn.invoke_request(endpoint, crate::clusters::defs::CLUSTER_ID_COLOR_CONTROL, crate::clusters::defs::CLUSTER_COLOR_CONTROL_CMD_ID_STOPMOVESTEP, &encode_stop_move_step(options_mask, options_override)?).await?;
    Ok(())
}

/// Invoke `MoveColorTemperature` command on cluster `Color Control`.
pub async fn move_color_temperature(conn: &crate::controller::Connection, endpoint: u16, move_mode: MoveMode, rate: u16, color_temperature_minimum_mireds: u16, color_temperature_maximum_mireds: u16, options_mask: Options, options_override: Options) -> anyhow::Result<()> {
    conn.invoke_request(endpoint, crate::clusters::defs::CLUSTER_ID_COLOR_CONTROL, crate::clusters::defs::CLUSTER_COLOR_CONTROL_CMD_ID_MOVECOLORTEMPERATURE, &encode_move_color_temperature(move_mode, rate, color_temperature_minimum_mireds, color_temperature_maximum_mireds, options_mask, options_override)?).await?;
    Ok(())
}

/// Invoke `StepColorTemperature` command on cluster `Color Control`.
pub async fn step_color_temperature(conn: &crate::controller::Connection, endpoint: u16, step_mode: StepMode, step_size: u16, transition_time: u16, color_temperature_minimum_mireds: u16, color_temperature_maximum_mireds: u16, options_mask: Options, options_override: Options) -> anyhow::Result<()> {
    conn.invoke_request(endpoint, crate::clusters::defs::CLUSTER_ID_COLOR_CONTROL, crate::clusters::defs::CLUSTER_COLOR_CONTROL_CMD_ID_STEPCOLORTEMPERATURE, &encode_step_color_temperature(step_mode, step_size, transition_time, color_temperature_minimum_mireds, color_temperature_maximum_mireds, options_mask, options_override)?).await?;
    Ok(())
}

/// Read `CurrentHue` attribute from cluster `Color Control`.
pub async fn read_current_hue(conn: &crate::controller::Connection, endpoint: u16) -> anyhow::Result<u8> {
    let tlv = conn.read_request2(endpoint, crate::clusters::defs::CLUSTER_ID_COLOR_CONTROL, crate::clusters::defs::CLUSTER_COLOR_CONTROL_ATTR_ID_CURRENTHUE).await?;
    decode_current_hue(&tlv)
}

/// Read `CurrentSaturation` attribute from cluster `Color Control`.
pub async fn read_current_saturation(conn: &crate::controller::Connection, endpoint: u16) -> anyhow::Result<u8> {
    let tlv = conn.read_request2(endpoint, crate::clusters::defs::CLUSTER_ID_COLOR_CONTROL, crate::clusters::defs::CLUSTER_COLOR_CONTROL_ATTR_ID_CURRENTSATURATION).await?;
    decode_current_saturation(&tlv)
}

/// Read `RemainingTime` attribute from cluster `Color Control`.
pub async fn read_remaining_time(conn: &crate::controller::Connection, endpoint: u16) -> anyhow::Result<u16> {
    let tlv = conn.read_request2(endpoint, crate::clusters::defs::CLUSTER_ID_COLOR_CONTROL, crate::clusters::defs::CLUSTER_COLOR_CONTROL_ATTR_ID_REMAININGTIME).await?;
    decode_remaining_time(&tlv)
}

/// Read `CurrentX` attribute from cluster `Color Control`.
pub async fn read_current_x(conn: &crate::controller::Connection, endpoint: u16) -> anyhow::Result<u16> {
    let tlv = conn.read_request2(endpoint, crate::clusters::defs::CLUSTER_ID_COLOR_CONTROL, crate::clusters::defs::CLUSTER_COLOR_CONTROL_ATTR_ID_CURRENTX).await?;
    decode_current_x(&tlv)
}

/// Read `CurrentY` attribute from cluster `Color Control`.
pub async fn read_current_y(conn: &crate::controller::Connection, endpoint: u16) -> anyhow::Result<u16> {
    let tlv = conn.read_request2(endpoint, crate::clusters::defs::CLUSTER_ID_COLOR_CONTROL, crate::clusters::defs::CLUSTER_COLOR_CONTROL_ATTR_ID_CURRENTY).await?;
    decode_current_y(&tlv)
}

/// Read `DriftCompensation` attribute from cluster `Color Control`.
pub async fn read_drift_compensation(conn: &crate::controller::Connection, endpoint: u16) -> anyhow::Result<DriftCompensation> {
    let tlv = conn.read_request2(endpoint, crate::clusters::defs::CLUSTER_ID_COLOR_CONTROL, crate::clusters::defs::CLUSTER_COLOR_CONTROL_ATTR_ID_DRIFTCOMPENSATION).await?;
    decode_drift_compensation(&tlv)
}

/// Read `CompensationText` attribute from cluster `Color Control`.
pub async fn read_compensation_text(conn: &crate::controller::Connection, endpoint: u16) -> anyhow::Result<String> {
    let tlv = conn.read_request2(endpoint, crate::clusters::defs::CLUSTER_ID_COLOR_CONTROL, crate::clusters::defs::CLUSTER_COLOR_CONTROL_ATTR_ID_COMPENSATIONTEXT).await?;
    decode_compensation_text(&tlv)
}

/// Read `ColorTemperatureMireds` attribute from cluster `Color Control`.
pub async fn read_color_temperature_mireds(conn: &crate::controller::Connection, endpoint: u16) -> anyhow::Result<u16> {
    let tlv = conn.read_request2(endpoint, crate::clusters::defs::CLUSTER_ID_COLOR_CONTROL, crate::clusters::defs::CLUSTER_COLOR_CONTROL_ATTR_ID_COLORTEMPERATUREMIREDS).await?;
    decode_color_temperature_mireds(&tlv)
}

/// Read `ColorMode` attribute from cluster `Color Control`.
pub async fn read_color_mode(conn: &crate::controller::Connection, endpoint: u16) -> anyhow::Result<ColorMode> {
    let tlv = conn.read_request2(endpoint, crate::clusters::defs::CLUSTER_ID_COLOR_CONTROL, crate::clusters::defs::CLUSTER_COLOR_CONTROL_ATTR_ID_COLORMODE).await?;
    decode_color_mode(&tlv)
}

/// Read `Options` attribute from cluster `Color Control`.
pub async fn read_options(conn: &crate::controller::Connection, endpoint: u16) -> anyhow::Result<Options> {
    let tlv = conn.read_request2(endpoint, crate::clusters::defs::CLUSTER_ID_COLOR_CONTROL, crate::clusters::defs::CLUSTER_COLOR_CONTROL_ATTR_ID_OPTIONS).await?;
    decode_options(&tlv)
}

/// Read `NumberOfPrimaries` attribute from cluster `Color Control`.
pub async fn read_number_of_primaries(conn: &crate::controller::Connection, endpoint: u16) -> anyhow::Result<Option<u8>> {
    let tlv = conn.read_request2(endpoint, crate::clusters::defs::CLUSTER_ID_COLOR_CONTROL, crate::clusters::defs::CLUSTER_COLOR_CONTROL_ATTR_ID_NUMBEROFPRIMARIES).await?;
    decode_number_of_primaries(&tlv)
}

/// Read `Primary1X` attribute from cluster `Color Control`.
pub async fn read_primary1_x(conn: &crate::controller::Connection, endpoint: u16) -> anyhow::Result<u16> {
    let tlv = conn.read_request2(endpoint, crate::clusters::defs::CLUSTER_ID_COLOR_CONTROL, crate::clusters::defs::CLUSTER_COLOR_CONTROL_ATTR_ID_PRIMARY1X).await?;
    decode_primary1_x(&tlv)
}

/// Read `Primary1Y` attribute from cluster `Color Control`.
pub async fn read_primary1_y(conn: &crate::controller::Connection, endpoint: u16) -> anyhow::Result<u16> {
    let tlv = conn.read_request2(endpoint, crate::clusters::defs::CLUSTER_ID_COLOR_CONTROL, crate::clusters::defs::CLUSTER_COLOR_CONTROL_ATTR_ID_PRIMARY1Y).await?;
    decode_primary1_y(&tlv)
}

/// Read `Primary1Intensity` attribute from cluster `Color Control`.
pub async fn read_primary1_intensity(conn: &crate::controller::Connection, endpoint: u16) -> anyhow::Result<Option<u8>> {
    let tlv = conn.read_request2(endpoint, crate::clusters::defs::CLUSTER_ID_COLOR_CONTROL, crate::clusters::defs::CLUSTER_COLOR_CONTROL_ATTR_ID_PRIMARY1INTENSITY).await?;
    decode_primary1_intensity(&tlv)
}

/// Read `Primary2X` attribute from cluster `Color Control`.
pub async fn read_primary2_x(conn: &crate::controller::Connection, endpoint: u16) -> anyhow::Result<u16> {
    let tlv = conn.read_request2(endpoint, crate::clusters::defs::CLUSTER_ID_COLOR_CONTROL, crate::clusters::defs::CLUSTER_COLOR_CONTROL_ATTR_ID_PRIMARY2X).await?;
    decode_primary2_x(&tlv)
}

/// Read `Primary2Y` attribute from cluster `Color Control`.
pub async fn read_primary2_y(conn: &crate::controller::Connection, endpoint: u16) -> anyhow::Result<u16> {
    let tlv = conn.read_request2(endpoint, crate::clusters::defs::CLUSTER_ID_COLOR_CONTROL, crate::clusters::defs::CLUSTER_COLOR_CONTROL_ATTR_ID_PRIMARY2Y).await?;
    decode_primary2_y(&tlv)
}

/// Read `Primary2Intensity` attribute from cluster `Color Control`.
pub async fn read_primary2_intensity(conn: &crate::controller::Connection, endpoint: u16) -> anyhow::Result<Option<u8>> {
    let tlv = conn.read_request2(endpoint, crate::clusters::defs::CLUSTER_ID_COLOR_CONTROL, crate::clusters::defs::CLUSTER_COLOR_CONTROL_ATTR_ID_PRIMARY2INTENSITY).await?;
    decode_primary2_intensity(&tlv)
}

/// Read `Primary3X` attribute from cluster `Color Control`.
pub async fn read_primary3_x(conn: &crate::controller::Connection, endpoint: u16) -> anyhow::Result<u16> {
    let tlv = conn.read_request2(endpoint, crate::clusters::defs::CLUSTER_ID_COLOR_CONTROL, crate::clusters::defs::CLUSTER_COLOR_CONTROL_ATTR_ID_PRIMARY3X).await?;
    decode_primary3_x(&tlv)
}

/// Read `Primary3Y` attribute from cluster `Color Control`.
pub async fn read_primary3_y(conn: &crate::controller::Connection, endpoint: u16) -> anyhow::Result<u16> {
    let tlv = conn.read_request2(endpoint, crate::clusters::defs::CLUSTER_ID_COLOR_CONTROL, crate::clusters::defs::CLUSTER_COLOR_CONTROL_ATTR_ID_PRIMARY3Y).await?;
    decode_primary3_y(&tlv)
}

/// Read `Primary3Intensity` attribute from cluster `Color Control`.
pub async fn read_primary3_intensity(conn: &crate::controller::Connection, endpoint: u16) -> anyhow::Result<Option<u8>> {
    let tlv = conn.read_request2(endpoint, crate::clusters::defs::CLUSTER_ID_COLOR_CONTROL, crate::clusters::defs::CLUSTER_COLOR_CONTROL_ATTR_ID_PRIMARY3INTENSITY).await?;
    decode_primary3_intensity(&tlv)
}

/// Read `Primary4X` attribute from cluster `Color Control`.
pub async fn read_primary4_x(conn: &crate::controller::Connection, endpoint: u16) -> anyhow::Result<u16> {
    let tlv = conn.read_request2(endpoint, crate::clusters::defs::CLUSTER_ID_COLOR_CONTROL, crate::clusters::defs::CLUSTER_COLOR_CONTROL_ATTR_ID_PRIMARY4X).await?;
    decode_primary4_x(&tlv)
}

/// Read `Primary4Y` attribute from cluster `Color Control`.
pub async fn read_primary4_y(conn: &crate::controller::Connection, endpoint: u16) -> anyhow::Result<u16> {
    let tlv = conn.read_request2(endpoint, crate::clusters::defs::CLUSTER_ID_COLOR_CONTROL, crate::clusters::defs::CLUSTER_COLOR_CONTROL_ATTR_ID_PRIMARY4Y).await?;
    decode_primary4_y(&tlv)
}

/// Read `Primary4Intensity` attribute from cluster `Color Control`.
pub async fn read_primary4_intensity(conn: &crate::controller::Connection, endpoint: u16) -> anyhow::Result<Option<u8>> {
    let tlv = conn.read_request2(endpoint, crate::clusters::defs::CLUSTER_ID_COLOR_CONTROL, crate::clusters::defs::CLUSTER_COLOR_CONTROL_ATTR_ID_PRIMARY4INTENSITY).await?;
    decode_primary4_intensity(&tlv)
}

/// Read `Primary5X` attribute from cluster `Color Control`.
pub async fn read_primary5_x(conn: &crate::controller::Connection, endpoint: u16) -> anyhow::Result<u16> {
    let tlv = conn.read_request2(endpoint, crate::clusters::defs::CLUSTER_ID_COLOR_CONTROL, crate::clusters::defs::CLUSTER_COLOR_CONTROL_ATTR_ID_PRIMARY5X).await?;
    decode_primary5_x(&tlv)
}

/// Read `Primary5Y` attribute from cluster `Color Control`.
pub async fn read_primary5_y(conn: &crate::controller::Connection, endpoint: u16) -> anyhow::Result<u16> {
    let tlv = conn.read_request2(endpoint, crate::clusters::defs::CLUSTER_ID_COLOR_CONTROL, crate::clusters::defs::CLUSTER_COLOR_CONTROL_ATTR_ID_PRIMARY5Y).await?;
    decode_primary5_y(&tlv)
}

/// Read `Primary5Intensity` attribute from cluster `Color Control`.
pub async fn read_primary5_intensity(conn: &crate::controller::Connection, endpoint: u16) -> anyhow::Result<Option<u8>> {
    let tlv = conn.read_request2(endpoint, crate::clusters::defs::CLUSTER_ID_COLOR_CONTROL, crate::clusters::defs::CLUSTER_COLOR_CONTROL_ATTR_ID_PRIMARY5INTENSITY).await?;
    decode_primary5_intensity(&tlv)
}

/// Read `Primary6X` attribute from cluster `Color Control`.
pub async fn read_primary6_x(conn: &crate::controller::Connection, endpoint: u16) -> anyhow::Result<u16> {
    let tlv = conn.read_request2(endpoint, crate::clusters::defs::CLUSTER_ID_COLOR_CONTROL, crate::clusters::defs::CLUSTER_COLOR_CONTROL_ATTR_ID_PRIMARY6X).await?;
    decode_primary6_x(&tlv)
}

/// Read `Primary6Y` attribute from cluster `Color Control`.
pub async fn read_primary6_y(conn: &crate::controller::Connection, endpoint: u16) -> anyhow::Result<u16> {
    let tlv = conn.read_request2(endpoint, crate::clusters::defs::CLUSTER_ID_COLOR_CONTROL, crate::clusters::defs::CLUSTER_COLOR_CONTROL_ATTR_ID_PRIMARY6Y).await?;
    decode_primary6_y(&tlv)
}

/// Read `Primary6Intensity` attribute from cluster `Color Control`.
pub async fn read_primary6_intensity(conn: &crate::controller::Connection, endpoint: u16) -> anyhow::Result<Option<u8>> {
    let tlv = conn.read_request2(endpoint, crate::clusters::defs::CLUSTER_ID_COLOR_CONTROL, crate::clusters::defs::CLUSTER_COLOR_CONTROL_ATTR_ID_PRIMARY6INTENSITY).await?;
    decode_primary6_intensity(&tlv)
}

/// Read `WhitePointX` attribute from cluster `Color Control`.
pub async fn read_white_point_x(conn: &crate::controller::Connection, endpoint: u16) -> anyhow::Result<u16> {
    let tlv = conn.read_request2(endpoint, crate::clusters::defs::CLUSTER_ID_COLOR_CONTROL, crate::clusters::defs::CLUSTER_COLOR_CONTROL_ATTR_ID_WHITEPOINTX).await?;
    decode_white_point_x(&tlv)
}

/// Read `WhitePointY` attribute from cluster `Color Control`.
pub async fn read_white_point_y(conn: &crate::controller::Connection, endpoint: u16) -> anyhow::Result<u16> {
    let tlv = conn.read_request2(endpoint, crate::clusters::defs::CLUSTER_ID_COLOR_CONTROL, crate::clusters::defs::CLUSTER_COLOR_CONTROL_ATTR_ID_WHITEPOINTY).await?;
    decode_white_point_y(&tlv)
}

/// Read `ColorPointRX` attribute from cluster `Color Control`.
pub async fn read_color_point_rx(conn: &crate::controller::Connection, endpoint: u16) -> anyhow::Result<u16> {
    let tlv = conn.read_request2(endpoint, crate::clusters::defs::CLUSTER_ID_COLOR_CONTROL, crate::clusters::defs::CLUSTER_COLOR_CONTROL_ATTR_ID_COLORPOINTRX).await?;
    decode_color_point_rx(&tlv)
}

/// Read `ColorPointRY` attribute from cluster `Color Control`.
pub async fn read_color_point_ry(conn: &crate::controller::Connection, endpoint: u16) -> anyhow::Result<u16> {
    let tlv = conn.read_request2(endpoint, crate::clusters::defs::CLUSTER_ID_COLOR_CONTROL, crate::clusters::defs::CLUSTER_COLOR_CONTROL_ATTR_ID_COLORPOINTRY).await?;
    decode_color_point_ry(&tlv)
}

/// Read `ColorPointRIntensity` attribute from cluster `Color Control`.
pub async fn read_color_point_r_intensity(conn: &crate::controller::Connection, endpoint: u16) -> anyhow::Result<Option<u8>> {
    let tlv = conn.read_request2(endpoint, crate::clusters::defs::CLUSTER_ID_COLOR_CONTROL, crate::clusters::defs::CLUSTER_COLOR_CONTROL_ATTR_ID_COLORPOINTRINTENSITY).await?;
    decode_color_point_r_intensity(&tlv)
}

/// Read `ColorPointGX` attribute from cluster `Color Control`.
pub async fn read_color_point_gx(conn: &crate::controller::Connection, endpoint: u16) -> anyhow::Result<u16> {
    let tlv = conn.read_request2(endpoint, crate::clusters::defs::CLUSTER_ID_COLOR_CONTROL, crate::clusters::defs::CLUSTER_COLOR_CONTROL_ATTR_ID_COLORPOINTGX).await?;
    decode_color_point_gx(&tlv)
}

/// Read `ColorPointGY` attribute from cluster `Color Control`.
pub async fn read_color_point_gy(conn: &crate::controller::Connection, endpoint: u16) -> anyhow::Result<u16> {
    let tlv = conn.read_request2(endpoint, crate::clusters::defs::CLUSTER_ID_COLOR_CONTROL, crate::clusters::defs::CLUSTER_COLOR_CONTROL_ATTR_ID_COLORPOINTGY).await?;
    decode_color_point_gy(&tlv)
}

/// Read `ColorPointGIntensity` attribute from cluster `Color Control`.
pub async fn read_color_point_g_intensity(conn: &crate::controller::Connection, endpoint: u16) -> anyhow::Result<Option<u8>> {
    let tlv = conn.read_request2(endpoint, crate::clusters::defs::CLUSTER_ID_COLOR_CONTROL, crate::clusters::defs::CLUSTER_COLOR_CONTROL_ATTR_ID_COLORPOINTGINTENSITY).await?;
    decode_color_point_g_intensity(&tlv)
}

/// Read `ColorPointBX` attribute from cluster `Color Control`.
pub async fn read_color_point_bx(conn: &crate::controller::Connection, endpoint: u16) -> anyhow::Result<u16> {
    let tlv = conn.read_request2(endpoint, crate::clusters::defs::CLUSTER_ID_COLOR_CONTROL, crate::clusters::defs::CLUSTER_COLOR_CONTROL_ATTR_ID_COLORPOINTBX).await?;
    decode_color_point_bx(&tlv)
}

/// Read `ColorPointBY` attribute from cluster `Color Control`.
pub async fn read_color_point_by(conn: &crate::controller::Connection, endpoint: u16) -> anyhow::Result<u16> {
    let tlv = conn.read_request2(endpoint, crate::clusters::defs::CLUSTER_ID_COLOR_CONTROL, crate::clusters::defs::CLUSTER_COLOR_CONTROL_ATTR_ID_COLORPOINTBY).await?;
    decode_color_point_by(&tlv)
}

/// Read `ColorPointBIntensity` attribute from cluster `Color Control`.
pub async fn read_color_point_b_intensity(conn: &crate::controller::Connection, endpoint: u16) -> anyhow::Result<Option<u8>> {
    let tlv = conn.read_request2(endpoint, crate::clusters::defs::CLUSTER_ID_COLOR_CONTROL, crate::clusters::defs::CLUSTER_COLOR_CONTROL_ATTR_ID_COLORPOINTBINTENSITY).await?;
    decode_color_point_b_intensity(&tlv)
}

/// Read `EnhancedCurrentHue` attribute from cluster `Color Control`.
pub async fn read_enhanced_current_hue(conn: &crate::controller::Connection, endpoint: u16) -> anyhow::Result<u16> {
    let tlv = conn.read_request2(endpoint, crate::clusters::defs::CLUSTER_ID_COLOR_CONTROL, crate::clusters::defs::CLUSTER_COLOR_CONTROL_ATTR_ID_ENHANCEDCURRENTHUE).await?;
    decode_enhanced_current_hue(&tlv)
}

/// Read `EnhancedColorMode` attribute from cluster `Color Control`.
pub async fn read_enhanced_color_mode(conn: &crate::controller::Connection, endpoint: u16) -> anyhow::Result<EnhancedColorMode> {
    let tlv = conn.read_request2(endpoint, crate::clusters::defs::CLUSTER_ID_COLOR_CONTROL, crate::clusters::defs::CLUSTER_COLOR_CONTROL_ATTR_ID_ENHANCEDCOLORMODE).await?;
    decode_enhanced_color_mode(&tlv)
}

/// Read `ColorLoopActive` attribute from cluster `Color Control`.
pub async fn read_color_loop_active(conn: &crate::controller::Connection, endpoint: u16) -> anyhow::Result<u8> {
    let tlv = conn.read_request2(endpoint, crate::clusters::defs::CLUSTER_ID_COLOR_CONTROL, crate::clusters::defs::CLUSTER_COLOR_CONTROL_ATTR_ID_COLORLOOPACTIVE).await?;
    decode_color_loop_active(&tlv)
}

/// Read `ColorLoopDirection` attribute from cluster `Color Control`.
pub async fn read_color_loop_direction(conn: &crate::controller::Connection, endpoint: u16) -> anyhow::Result<ColorLoopDirection> {
    let tlv = conn.read_request2(endpoint, crate::clusters::defs::CLUSTER_ID_COLOR_CONTROL, crate::clusters::defs::CLUSTER_COLOR_CONTROL_ATTR_ID_COLORLOOPDIRECTION).await?;
    decode_color_loop_direction(&tlv)
}

/// Read `ColorLoopTime` attribute from cluster `Color Control`.
pub async fn read_color_loop_time(conn: &crate::controller::Connection, endpoint: u16) -> anyhow::Result<u16> {
    let tlv = conn.read_request2(endpoint, crate::clusters::defs::CLUSTER_ID_COLOR_CONTROL, crate::clusters::defs::CLUSTER_COLOR_CONTROL_ATTR_ID_COLORLOOPTIME).await?;
    decode_color_loop_time(&tlv)
}

/// Read `ColorLoopStartEnhancedHue` attribute from cluster `Color Control`.
pub async fn read_color_loop_start_enhanced_hue(conn: &crate::controller::Connection, endpoint: u16) -> anyhow::Result<u16> {
    let tlv = conn.read_request2(endpoint, crate::clusters::defs::CLUSTER_ID_COLOR_CONTROL, crate::clusters::defs::CLUSTER_COLOR_CONTROL_ATTR_ID_COLORLOOPSTARTENHANCEDHUE).await?;
    decode_color_loop_start_enhanced_hue(&tlv)
}

/// Read `ColorLoopStoredEnhancedHue` attribute from cluster `Color Control`.
pub async fn read_color_loop_stored_enhanced_hue(conn: &crate::controller::Connection, endpoint: u16) -> anyhow::Result<u16> {
    let tlv = conn.read_request2(endpoint, crate::clusters::defs::CLUSTER_ID_COLOR_CONTROL, crate::clusters::defs::CLUSTER_COLOR_CONTROL_ATTR_ID_COLORLOOPSTOREDENHANCEDHUE).await?;
    decode_color_loop_stored_enhanced_hue(&tlv)
}

/// Read `ColorCapabilities` attribute from cluster `Color Control`.
pub async fn read_color_capabilities(conn: &crate::controller::Connection, endpoint: u16) -> anyhow::Result<ColorCapabilities> {
    let tlv = conn.read_request2(endpoint, crate::clusters::defs::CLUSTER_ID_COLOR_CONTROL, crate::clusters::defs::CLUSTER_COLOR_CONTROL_ATTR_ID_COLORCAPABILITIES).await?;
    decode_color_capabilities(&tlv)
}

/// Read `ColorTempPhysicalMinMireds` attribute from cluster `Color Control`.
pub async fn read_color_temp_physical_min_mireds(conn: &crate::controller::Connection, endpoint: u16) -> anyhow::Result<u16> {
    let tlv = conn.read_request2(endpoint, crate::clusters::defs::CLUSTER_ID_COLOR_CONTROL, crate::clusters::defs::CLUSTER_COLOR_CONTROL_ATTR_ID_COLORTEMPPHYSICALMINMIREDS).await?;
    decode_color_temp_physical_min_mireds(&tlv)
}

/// Read `ColorTempPhysicalMaxMireds` attribute from cluster `Color Control`.
pub async fn read_color_temp_physical_max_mireds(conn: &crate::controller::Connection, endpoint: u16) -> anyhow::Result<u16> {
    let tlv = conn.read_request2(endpoint, crate::clusters::defs::CLUSTER_ID_COLOR_CONTROL, crate::clusters::defs::CLUSTER_COLOR_CONTROL_ATTR_ID_COLORTEMPPHYSICALMAXMIREDS).await?;
    decode_color_temp_physical_max_mireds(&tlv)
}

/// Read `CoupleColorTempToLevelMinMireds` attribute from cluster `Color Control`.
pub async fn read_couple_color_temp_to_level_min_mireds(conn: &crate::controller::Connection, endpoint: u16) -> anyhow::Result<u16> {
    let tlv = conn.read_request2(endpoint, crate::clusters::defs::CLUSTER_ID_COLOR_CONTROL, crate::clusters::defs::CLUSTER_COLOR_CONTROL_ATTR_ID_COUPLECOLORTEMPTOLEVELMINMIREDS).await?;
    decode_couple_color_temp_to_level_min_mireds(&tlv)
}

/// Read `StartUpColorTemperatureMireds` attribute from cluster `Color Control`.
pub async fn read_start_up_color_temperature_mireds(conn: &crate::controller::Connection, endpoint: u16) -> anyhow::Result<Option<u16>> {
    let tlv = conn.read_request2(endpoint, crate::clusters::defs::CLUSTER_ID_COLOR_CONTROL, crate::clusters::defs::CLUSTER_COLOR_CONTROL_ATTR_ID_STARTUPCOLORTEMPERATUREMIREDS).await?;
    decode_start_up_color_temperature_mireds(&tlv)
}