matc/clusters/codec/

camera_av_stream_management.rs

//! Matter TLV encoders and decoders for Camera AV Stream Management Cluster
//! Cluster IDs: 0x0551
//!
//! This file is automatically generated from CameraAVStreamManagement.xml

#![allow(clippy::too_many_arguments)]

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


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

// Enum definitions

#[derive(Debug, Clone, Copy, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
#[repr(u8)]
pub enum AudioCodec {
    /// Open source IETF standard codec.
    Opus = 0,
    /// Advanced Audio Coding codec-Low Complexity
    AacLc = 1,
}

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

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

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

#[derive(Debug, Clone, Copy, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
#[repr(u8)]
pub enum ImageCodec {
    /// JPEG image codec.
    Jpeg = 0,
    /// HEIC image codec.
    Heic = 1,
}

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

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

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

#[derive(Debug, Clone, Copy, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
#[repr(u8)]
pub enum TriStateAuto {
    /// Off
    Off = 0,
    /// On
    On = 1,
    /// Automatic Operation
    Auto = 2,
}

impl TriStateAuto {
    /// Convert from u8 value
    pub fn from_u8(value: u8) -> Option<Self> {
        match value {
            0 => Some(TriStateAuto::Off),
            1 => Some(TriStateAuto::On),
            2 => Some(TriStateAuto::Auto),
            _ => None,
        }
    }

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

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

#[derive(Debug, Clone, Copy, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
#[repr(u8)]
pub enum TwoWayTalkSupportType {
    /// Two-way Talk support is absent.
    Notsupported = 0,
    /// Audio in one direction at a time.
    Halfduplex = 1,
    /// Audio in both directions simultaneously.
    Fullduplex = 2,
}

impl TwoWayTalkSupportType {
    /// Convert from u8 value
    pub fn from_u8(value: u8) -> Option<Self> {
        match value {
            0 => Some(TwoWayTalkSupportType::Notsupported),
            1 => Some(TwoWayTalkSupportType::Halfduplex),
            2 => Some(TwoWayTalkSupportType::Fullduplex),
            _ => None,
        }
    }

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

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

#[derive(Debug, Clone, Copy, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
#[repr(u8)]
pub enum VideoCodec {
    /// Advanced Video Coding (H.264) codec.
    H264 = 0,
    /// High efficiency Video Coding (H.265) codec.
    Hevc = 1,
    /// Versatile Video Coding (H.266) codec.
    Vvc = 2,
    /// AOMedia Video 1 codec.
    Av1 = 3,
}

impl VideoCodec {
    /// Convert from u8 value
    pub fn from_u8(value: u8) -> Option<Self> {
        match value {
            0 => Some(VideoCodec::H264),
            1 => Some(VideoCodec::Hevc),
            2 => Some(VideoCodec::Vvc),
            3 => Some(VideoCodec::Av1),
            _ => None,
        }
    }

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

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

// Struct definitions

#[derive(Debug, serde::Serialize)]
pub struct AVMetadata {
    pub utc_time: Option<u64>,
    pub motion_zones_active: Option<Vec<u16>>,
    pub black_and_white_active: Option<bool>,
    #[serde(serialize_with = "serialize_opt_bytes_as_hex")]
    pub user_defined: Option<Vec<u8>>,
}

#[derive(Debug, serde::Serialize)]
pub struct AudioCapabilities {
    pub max_number_of_channels: Option<u8>,
    pub supported_codecs: Option<Vec<AudioCodec>>,
    pub supported_sample_rates: Option<Vec<u32>>,
    pub supported_bit_depths: Option<Vec<u8>>,
}

#[derive(Debug, serde::Serialize)]
pub struct AudioStream {
    pub audio_stream_id: Option<u16>,
    pub stream_usage: Option<u8>,
    pub audio_codec: Option<AudioCodec>,
    pub channel_count: Option<u8>,
    pub sample_rate: Option<u32>,
    pub bit_rate: Option<u32>,
    pub bit_depth: Option<u8>,
    pub reference_count: Option<u8>,
}

#[derive(Debug, serde::Serialize)]
pub struct RateDistortionTradeOffPoints {
    pub codec: Option<VideoCodec>,
    pub resolution: Option<VideoResolution>,
    pub min_bit_rate: Option<u32>,
}

#[derive(Debug, serde::Serialize)]
pub struct SnapshotCapabilities {
    pub resolution: Option<VideoResolution>,
    pub max_frame_rate: Option<u16>,
    pub image_codec: Option<ImageCodec>,
    pub requires_encoded_pixels: Option<bool>,
    pub requires_hardware_encoder: Option<bool>,
}

#[derive(Debug, serde::Serialize)]
pub struct SnapshotStream {
    pub snapshot_stream_id: Option<u16>,
    pub image_codec: Option<ImageCodec>,
    pub frame_rate: Option<u16>,
    pub min_resolution: Option<VideoResolution>,
    pub max_resolution: Option<VideoResolution>,
    pub quality: Option<u8>,
    pub reference_count: Option<u8>,
    pub encoded_pixels: Option<bool>,
    pub hardware_encoder: Option<bool>,
    pub watermark_enabled: Option<bool>,
    pub osd_enabled: Option<bool>,
}

#[derive(Debug, serde::Serialize)]
pub struct VideoResolution {
    pub width: Option<u16>,
    pub height: Option<u16>,
}

#[derive(Debug, serde::Serialize)]
pub struct VideoSensorParams {
    pub sensor_width: Option<u16>,
    pub sensor_height: Option<u16>,
    pub max_fps: Option<u16>,
    pub max_hdrfps: Option<u16>,
}

#[derive(Debug, serde::Serialize)]
pub struct VideoStream {
    pub video_stream_id: Option<u16>,
    pub stream_usage: Option<u8>,
    pub video_codec: Option<VideoCodec>,
    pub min_frame_rate: Option<u16>,
    pub max_frame_rate: Option<u16>,
    pub min_resolution: Option<VideoResolution>,
    pub max_resolution: Option<VideoResolution>,
    pub min_bit_rate: Option<u32>,
    pub max_bit_rate: Option<u32>,
    pub key_frame_interval: Option<u16>,
    pub watermark_enabled: Option<bool>,
    pub osd_enabled: Option<bool>,
    pub reference_count: Option<u8>,
}

// Command encoders

/// Encode AudioStreamAllocate command (0x00)
pub fn encode_audio_stream_allocate(stream_usage: u8, audio_codec: AudioCodec, channel_count: u8, sample_rate: u32, bit_rate: u32, bit_depth: u8) -> anyhow::Result<Vec<u8>> {
    let tlv = tlv::TlvItemEnc {
        tag: 0,
        value: tlv::TlvItemValueEnc::StructInvisible(vec![
        (0, tlv::TlvItemValueEnc::UInt8(stream_usage)).into(),
        (1, tlv::TlvItemValueEnc::UInt8(audio_codec.to_u8())).into(),
        (2, tlv::TlvItemValueEnc::UInt8(channel_count)).into(),
        (3, tlv::TlvItemValueEnc::UInt32(sample_rate)).into(),
        (4, tlv::TlvItemValueEnc::UInt32(bit_rate)).into(),
        (5, tlv::TlvItemValueEnc::UInt8(bit_depth)).into(),
        ]),
    };
    Ok(tlv.encode()?)
}

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

/// Parameters for VideoStreamAllocate command
pub struct VideoStreamAllocateParams {
    pub stream_usage: u8,
    pub video_codec: VideoCodec,
    pub min_frame_rate: u16,
    pub max_frame_rate: u16,
    pub min_resolution: VideoResolution,
    pub max_resolution: VideoResolution,
    pub min_bit_rate: u32,
    pub max_bit_rate: u32,
    pub key_frame_interval: u16,
    pub watermark_enabled: bool,
    pub osd_enabled: bool,
}

/// Encode VideoStreamAllocate command (0x03)
pub fn encode_video_stream_allocate(params: VideoStreamAllocateParams) -> anyhow::Result<Vec<u8>> {
            // Encode struct VideoResolutionStruct
            let mut min_resolution_fields = Vec::new();
            if let Some(x) = params.min_resolution.width { min_resolution_fields.push((0, tlv::TlvItemValueEnc::UInt16(x)).into()); }
            if let Some(x) = params.min_resolution.height { min_resolution_fields.push((1, tlv::TlvItemValueEnc::UInt16(x)).into()); }
            // Encode struct VideoResolutionStruct
            let mut max_resolution_fields = Vec::new();
            if let Some(x) = params.max_resolution.width { max_resolution_fields.push((0, tlv::TlvItemValueEnc::UInt16(x)).into()); }
            if let Some(x) = params.max_resolution.height { max_resolution_fields.push((1, tlv::TlvItemValueEnc::UInt16(x)).into()); }
    let tlv = tlv::TlvItemEnc {
        tag: 0,
        value: tlv::TlvItemValueEnc::StructInvisible(vec![
        (0, tlv::TlvItemValueEnc::UInt8(params.stream_usage)).into(),
        (1, tlv::TlvItemValueEnc::UInt8(params.video_codec.to_u8())).into(),
        (2, tlv::TlvItemValueEnc::UInt16(params.min_frame_rate)).into(),
        (3, tlv::TlvItemValueEnc::UInt16(params.max_frame_rate)).into(),
        (4, tlv::TlvItemValueEnc::StructInvisible(min_resolution_fields)).into(),
        (5, tlv::TlvItemValueEnc::StructInvisible(max_resolution_fields)).into(),
        (6, tlv::TlvItemValueEnc::UInt32(params.min_bit_rate)).into(),
        (7, tlv::TlvItemValueEnc::UInt32(params.max_bit_rate)).into(),
        (8, tlv::TlvItemValueEnc::UInt16(params.key_frame_interval)).into(),
        (9, tlv::TlvItemValueEnc::Bool(params.watermark_enabled)).into(),
        (10, tlv::TlvItemValueEnc::Bool(params.osd_enabled)).into(),
        ]),
    };
    Ok(tlv.encode()?)
}

/// Encode VideoStreamModify command (0x05)
pub fn encode_video_stream_modify(video_stream_id: u16, watermark_enabled: Option<bool>, osd_enabled: Option<bool>) -> anyhow::Result<Vec<u8>> {
    let mut tlv_fields: Vec<tlv::TlvItemEnc> = Vec::new();
    tlv_fields.push((0, tlv::TlvItemValueEnc::UInt16(video_stream_id)).into());
    if let Some(x) = watermark_enabled { tlv_fields.push((1, tlv::TlvItemValueEnc::Bool(x)).into()); }
    if let Some(x) = osd_enabled { tlv_fields.push((2, tlv::TlvItemValueEnc::Bool(x)).into()); }
    let tlv = tlv::TlvItemEnc {
        tag: 0,
        value: tlv::TlvItemValueEnc::StructInvisible(tlv_fields),
    };
    Ok(tlv.encode()?)
}

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

/// Encode SnapshotStreamAllocate command (0x07)
pub fn encode_snapshot_stream_allocate(image_codec: ImageCodec, max_frame_rate: u16, min_resolution: VideoResolution, max_resolution: VideoResolution, quality: u8, watermark_enabled: bool, osd_enabled: bool) -> anyhow::Result<Vec<u8>> {
            // Encode struct VideoResolutionStruct
            let mut min_resolution_fields = Vec::new();
            if let Some(x) = min_resolution.width { min_resolution_fields.push((0, tlv::TlvItemValueEnc::UInt16(x)).into()); }
            if let Some(x) = min_resolution.height { min_resolution_fields.push((1, tlv::TlvItemValueEnc::UInt16(x)).into()); }
            // Encode struct VideoResolutionStruct
            let mut max_resolution_fields = Vec::new();
            if let Some(x) = max_resolution.width { max_resolution_fields.push((0, tlv::TlvItemValueEnc::UInt16(x)).into()); }
            if let Some(x) = max_resolution.height { max_resolution_fields.push((1, tlv::TlvItemValueEnc::UInt16(x)).into()); }
    let tlv = tlv::TlvItemEnc {
        tag: 0,
        value: tlv::TlvItemValueEnc::StructInvisible(vec![
        (0, tlv::TlvItemValueEnc::UInt8(image_codec.to_u8())).into(),
        (1, tlv::TlvItemValueEnc::UInt16(max_frame_rate)).into(),
        (2, tlv::TlvItemValueEnc::StructInvisible(min_resolution_fields)).into(),
        (3, tlv::TlvItemValueEnc::StructInvisible(max_resolution_fields)).into(),
        (4, tlv::TlvItemValueEnc::UInt8(quality)).into(),
        (5, tlv::TlvItemValueEnc::Bool(watermark_enabled)).into(),
        (6, tlv::TlvItemValueEnc::Bool(osd_enabled)).into(),
        ]),
    };
    Ok(tlv.encode()?)
}

/// Encode SnapshotStreamModify command (0x09)
pub fn encode_snapshot_stream_modify(snapshot_stream_id: u16, watermark_enabled: Option<bool>, osd_enabled: Option<bool>) -> anyhow::Result<Vec<u8>> {
    let mut tlv_fields: Vec<tlv::TlvItemEnc> = Vec::new();
    tlv_fields.push((0, tlv::TlvItemValueEnc::UInt16(snapshot_stream_id)).into());
    if let Some(x) = watermark_enabled { tlv_fields.push((1, tlv::TlvItemValueEnc::Bool(x)).into()); }
    if let Some(x) = osd_enabled { tlv_fields.push((2, tlv::TlvItemValueEnc::Bool(x)).into()); }
    let tlv = tlv::TlvItemEnc {
        tag: 0,
        value: tlv::TlvItemValueEnc::StructInvisible(tlv_fields),
    };
    Ok(tlv.encode()?)
}

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

/// Encode SetStreamPriorities command (0x0B)
pub fn encode_set_stream_priorities(stream_priorities: Vec<u8>) -> anyhow::Result<Vec<u8>> {
    let tlv = tlv::TlvItemEnc {
        tag: 0,
        value: tlv::TlvItemValueEnc::StructInvisible(vec![
        (0, tlv::TlvItemValueEnc::StructAnon(stream_priorities.into_iter().map(|v| (0, tlv::TlvItemValueEnc::UInt8(v)).into()).collect())).into(),
        ]),
    };
    Ok(tlv.encode()?)
}

/// Encode CaptureSnapshot command (0x0C)
pub fn encode_capture_snapshot(snapshot_stream_id: Option<u16>, requested_resolution: VideoResolution) -> anyhow::Result<Vec<u8>> {
            // Encode struct VideoResolutionStruct
            let mut requested_resolution_fields = Vec::new();
            if let Some(x) = requested_resolution.width { requested_resolution_fields.push((0, tlv::TlvItemValueEnc::UInt16(x)).into()); }
            if let Some(x) = requested_resolution.height { requested_resolution_fields.push((1, tlv::TlvItemValueEnc::UInt16(x)).into()); }
    let tlv = tlv::TlvItemEnc {
        tag: 0,
        value: tlv::TlvItemValueEnc::StructInvisible(vec![
        (0, tlv::TlvItemValueEnc::UInt16(snapshot_stream_id.unwrap_or(0))).into(),
        (1, tlv::TlvItemValueEnc::StructInvisible(requested_resolution_fields)).into(),
        ]),
    };
    Ok(tlv.encode()?)
}

// Attribute decoders

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

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

/// Decode VideoSensorParams attribute (0x0002)
pub fn decode_video_sensor_params(inp: &tlv::TlvItemValue) -> anyhow::Result<VideoSensorParams> {
    if let tlv::TlvItemValue::List(_fields) = inp {
        // Struct with fields
        let item = tlv::TlvItem { tag: 0, value: inp.clone() };
        Ok(VideoSensorParams {
                sensor_width: item.get_int(&[0]).map(|v| v as u16),
                sensor_height: item.get_int(&[1]).map(|v| v as u16),
                max_fps: item.get_int(&[2]).map(|v| v as u16),
                max_hdrfps: item.get_int(&[3]).map(|v| v as u16),
        })
    } else {
        Err(anyhow::anyhow!("Expected struct fields"))
    }
}

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

/// Decode MinViewportResolution attribute (0x0004)
pub fn decode_min_viewport_resolution(inp: &tlv::TlvItemValue) -> anyhow::Result<VideoResolution> {
    if let tlv::TlvItemValue::List(_fields) = inp {
        // Struct with fields
        let item = tlv::TlvItem { tag: 0, value: inp.clone() };
        Ok(VideoResolution {
                width: item.get_int(&[0]).map(|v| v as u16),
                height: item.get_int(&[1]).map(|v| v as u16),
        })
    } else {
        Err(anyhow::anyhow!("Expected struct fields"))
    }
}

/// Decode RateDistortionTradeOffPoints attribute (0x0005)
pub fn decode_rate_distortion_trade_off_points(inp: &tlv::TlvItemValue) -> anyhow::Result<Vec<RateDistortionTradeOffPoints>> {
    let mut res = Vec::new();
    if let tlv::TlvItemValue::List(v) = inp {
        for item in v {
            res.push(RateDistortionTradeOffPoints {
                codec: item.get_int(&[0]).and_then(|v| VideoCodec::from_u8(v as u8)),
                resolution: {
                    if let Some(nested_tlv) = item.get(&[1]) {
                        if let tlv::TlvItemValue::List(_) = nested_tlv {
                            let nested_item = tlv::TlvItem { tag: 1, value: nested_tlv.clone() };
                            Some(VideoResolution {
                width: nested_item.get_int(&[0]).map(|v| v as u16),
                height: nested_item.get_int(&[1]).map(|v| v as u16),
                            })
                        } else {
                            None
                        }
                    } else {
                        None
                    }
                },
                min_bit_rate: item.get_int(&[2]).map(|v| v as u32),
            });
        }
    }
    Ok(res)
}

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

/// Decode MicrophoneCapabilities attribute (0x0007)
pub fn decode_microphone_capabilities(inp: &tlv::TlvItemValue) -> anyhow::Result<AudioCapabilities> {
    if let tlv::TlvItemValue::List(_fields) = inp {
        // Struct with fields
        let item = tlv::TlvItem { tag: 0, value: inp.clone() };
        Ok(AudioCapabilities {
                max_number_of_channels: item.get_int(&[0]).map(|v| v as u8),
                supported_codecs: {
                    if let Some(tlv::TlvItemValue::List(l)) = item.get(&[1]) {
                        let items: Vec<AudioCodec> = l.iter().filter_map(|e| { if let tlv::TlvItemValue::Int(v) = &e.value { AudioCodec::from_u8(*v as u8) } else { None } }).collect();
                        Some(items)
                    } else {
                        None
                    }
                },
                supported_sample_rates: {
                    if let Some(tlv::TlvItemValue::List(l)) = item.get(&[2]) {
                        let items: Vec<u32> = l.iter().filter_map(|e| { if let tlv::TlvItemValue::Int(v) = &e.value { Some(*v as u32) } else { None } }).collect();
                        Some(items)
                    } else {
                        None
                    }
                },
                supported_bit_depths: {
                    if let Some(tlv::TlvItemValue::List(l)) = item.get(&[3]) {
                        let items: Vec<u8> = l.iter().filter_map(|e| { if let tlv::TlvItemValue::Int(v) = &e.value { Some(*v as u8) } else { None } }).collect();
                        Some(items)
                    } else {
                        None
                    }
                },
        })
    } else {
        Err(anyhow::anyhow!("Expected struct fields"))
    }
}

/// Decode SpeakerCapabilities attribute (0x0008)
pub fn decode_speaker_capabilities(inp: &tlv::TlvItemValue) -> anyhow::Result<AudioCapabilities> {
    if let tlv::TlvItemValue::List(_fields) = inp {
        // Struct with fields
        let item = tlv::TlvItem { tag: 0, value: inp.clone() };
        Ok(AudioCapabilities {
                max_number_of_channels: item.get_int(&[0]).map(|v| v as u8),
                supported_codecs: {
                    if let Some(tlv::TlvItemValue::List(l)) = item.get(&[1]) {
                        let items: Vec<AudioCodec> = l.iter().filter_map(|e| { if let tlv::TlvItemValue::Int(v) = &e.value { AudioCodec::from_u8(*v as u8) } else { None } }).collect();
                        Some(items)
                    } else {
                        None
                    }
                },
                supported_sample_rates: {
                    if let Some(tlv::TlvItemValue::List(l)) = item.get(&[2]) {
                        let items: Vec<u32> = l.iter().filter_map(|e| { if let tlv::TlvItemValue::Int(v) = &e.value { Some(*v as u32) } else { None } }).collect();
                        Some(items)
                    } else {
                        None
                    }
                },
                supported_bit_depths: {
                    if let Some(tlv::TlvItemValue::List(l)) = item.get(&[3]) {
                        let items: Vec<u8> = l.iter().filter_map(|e| { if let tlv::TlvItemValue::Int(v) = &e.value { Some(*v as u8) } else { None } }).collect();
                        Some(items)
                    } else {
                        None
                    }
                },
        })
    } else {
        Err(anyhow::anyhow!("Expected struct fields"))
    }
}

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

/// Decode SnapshotCapabilities attribute (0x000A)
pub fn decode_snapshot_capabilities(inp: &tlv::TlvItemValue) -> anyhow::Result<Vec<SnapshotCapabilities>> {
    let mut res = Vec::new();
    if let tlv::TlvItemValue::List(v) = inp {
        for item in v {
            res.push(SnapshotCapabilities {
                resolution: {
                    if let Some(nested_tlv) = item.get(&[0]) {
                        if let tlv::TlvItemValue::List(_) = nested_tlv {
                            let nested_item = tlv::TlvItem { tag: 0, value: nested_tlv.clone() };
                            Some(VideoResolution {
                width: nested_item.get_int(&[0]).map(|v| v as u16),
                height: nested_item.get_int(&[1]).map(|v| v as u16),
                            })
                        } else {
                            None
                        }
                    } else {
                        None
                    }
                },
                max_frame_rate: item.get_int(&[1]).map(|v| v as u16),
                image_codec: item.get_int(&[2]).and_then(|v| ImageCodec::from_u8(v as u8)),
                requires_encoded_pixels: item.get_bool(&[3]),
                requires_hardware_encoder: item.get_bool(&[4]),
            });
        }
    }
    Ok(res)
}

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

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

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

/// Decode SupportedStreamUsages attribute (0x000E)
pub fn decode_supported_stream_usages(inp: &tlv::TlvItemValue) -> anyhow::Result<Vec<u8>> {
    let mut res = Vec::new();
    if let tlv::TlvItemValue::List(v) = inp {
        for item in v {
            if let tlv::TlvItemValue::Int(i) = &item.value {
                res.push(*i as u8);
            }
        }
    }
    Ok(res)
}

/// Decode AllocatedVideoStreams attribute (0x000F)
pub fn decode_allocated_video_streams(inp: &tlv::TlvItemValue) -> anyhow::Result<Vec<VideoStream>> {
    let mut res = Vec::new();
    if let tlv::TlvItemValue::List(v) = inp {
        for item in v {
            res.push(VideoStream {
                video_stream_id: item.get_int(&[0]).map(|v| v as u16),
                stream_usage: item.get_int(&[1]).map(|v| v as u8),
                video_codec: item.get_int(&[2]).and_then(|v| VideoCodec::from_u8(v as u8)),
                min_frame_rate: item.get_int(&[3]).map(|v| v as u16),
                max_frame_rate: item.get_int(&[4]).map(|v| v as u16),
                min_resolution: {
                    if let Some(nested_tlv) = item.get(&[5]) {
                        if let tlv::TlvItemValue::List(_) = nested_tlv {
                            let nested_item = tlv::TlvItem { tag: 5, value: nested_tlv.clone() };
                            Some(VideoResolution {
                width: nested_item.get_int(&[0]).map(|v| v as u16),
                height: nested_item.get_int(&[1]).map(|v| v as u16),
                            })
                        } else {
                            None
                        }
                    } else {
                        None
                    }
                },
                max_resolution: {
                    if let Some(nested_tlv) = item.get(&[6]) {
                        if let tlv::TlvItemValue::List(_) = nested_tlv {
                            let nested_item = tlv::TlvItem { tag: 6, value: nested_tlv.clone() };
                            Some(VideoResolution {
                width: nested_item.get_int(&[0]).map(|v| v as u16),
                height: nested_item.get_int(&[1]).map(|v| v as u16),
                            })
                        } else {
                            None
                        }
                    } else {
                        None
                    }
                },
                min_bit_rate: item.get_int(&[7]).map(|v| v as u32),
                max_bit_rate: item.get_int(&[8]).map(|v| v as u32),
                key_frame_interval: item.get_int(&[9]).map(|v| v as u16),
                watermark_enabled: item.get_bool(&[10]),
                osd_enabled: item.get_bool(&[11]),
                reference_count: item.get_int(&[12]).map(|v| v as u8),
            });
        }
    }
    Ok(res)
}

/// Decode AllocatedAudioStreams attribute (0x0010)
pub fn decode_allocated_audio_streams(inp: &tlv::TlvItemValue) -> anyhow::Result<Vec<AudioStream>> {
    let mut res = Vec::new();
    if let tlv::TlvItemValue::List(v) = inp {
        for item in v {
            res.push(AudioStream {
                audio_stream_id: item.get_int(&[0]).map(|v| v as u16),
                stream_usage: item.get_int(&[1]).map(|v| v as u8),
                audio_codec: item.get_int(&[2]).and_then(|v| AudioCodec::from_u8(v as u8)),
                channel_count: item.get_int(&[3]).map(|v| v as u8),
                sample_rate: item.get_int(&[4]).map(|v| v as u32),
                bit_rate: item.get_int(&[5]).map(|v| v as u32),
                bit_depth: item.get_int(&[6]).map(|v| v as u8),
                reference_count: item.get_int(&[7]).map(|v| v as u8),
            });
        }
    }
    Ok(res)
}

/// Decode AllocatedSnapshotStreams attribute (0x0011)
pub fn decode_allocated_snapshot_streams(inp: &tlv::TlvItemValue) -> anyhow::Result<Vec<SnapshotStream>> {
    let mut res = Vec::new();
    if let tlv::TlvItemValue::List(v) = inp {
        for item in v {
            res.push(SnapshotStream {
                snapshot_stream_id: item.get_int(&[0]).map(|v| v as u16),
                image_codec: item.get_int(&[1]).and_then(|v| ImageCodec::from_u8(v as u8)),
                frame_rate: item.get_int(&[2]).map(|v| v as u16),
                min_resolution: {
                    if let Some(nested_tlv) = item.get(&[3]) {
                        if let tlv::TlvItemValue::List(_) = nested_tlv {
                            let nested_item = tlv::TlvItem { tag: 3, value: nested_tlv.clone() };
                            Some(VideoResolution {
                width: nested_item.get_int(&[0]).map(|v| v as u16),
                height: nested_item.get_int(&[1]).map(|v| v as u16),
                            })
                        } else {
                            None
                        }
                    } else {
                        None
                    }
                },
                max_resolution: {
                    if let Some(nested_tlv) = item.get(&[4]) {
                        if let tlv::TlvItemValue::List(_) = nested_tlv {
                            let nested_item = tlv::TlvItem { tag: 4, value: nested_tlv.clone() };
                            Some(VideoResolution {
                width: nested_item.get_int(&[0]).map(|v| v as u16),
                height: nested_item.get_int(&[1]).map(|v| v as u16),
                            })
                        } else {
                            None
                        }
                    } else {
                        None
                    }
                },
                quality: item.get_int(&[5]).map(|v| v as u8),
                reference_count: item.get_int(&[6]).map(|v| v as u8),
                encoded_pixels: item.get_bool(&[7]),
                hardware_encoder: item.get_bool(&[8]),
                watermark_enabled: item.get_bool(&[9]),
                osd_enabled: item.get_bool(&[10]),
            });
        }
    }
    Ok(res)
}

/// Decode StreamUsagePriorities attribute (0x0012)
pub fn decode_stream_usage_priorities(inp: &tlv::TlvItemValue) -> anyhow::Result<Vec<u8>> {
    let mut res = Vec::new();
    if let tlv::TlvItemValue::List(v) = inp {
        for item in v {
            if let tlv::TlvItemValue::Int(i) = &item.value {
                res.push(*i as u8);
            }
        }
    }
    Ok(res)
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


// JSON dispatcher function

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

    match attribute_id {
        0x0000 => {
            match decode_max_concurrent_encoders(tlv_value) {
                Ok(value) => serde_json::to_string(&value).unwrap_or_else(|_| "null".to_string()),
                Err(e) => format!("{{\"error\": \"{}\"}}", e),
            }
        }
        0x0001 => {
            match decode_max_encoded_pixel_rate(tlv_value) {
                Ok(value) => serde_json::to_string(&value).unwrap_or_else(|_| "null".to_string()),
                Err(e) => format!("{{\"error\": \"{}\"}}", e),
            }
        }
        0x0002 => {
            match decode_video_sensor_params(tlv_value) {
                Ok(value) => serde_json::to_string(&value).unwrap_or_else(|_| "null".to_string()),
                Err(e) => format!("{{\"error\": \"{}\"}}", e),
            }
        }
        0x0003 => {
            match decode_night_vision_uses_infrared(tlv_value) {
                Ok(value) => serde_json::to_string(&value).unwrap_or_else(|_| "null".to_string()),
                Err(e) => format!("{{\"error\": \"{}\"}}", e),
            }
        }
        0x0004 => {
            match decode_min_viewport_resolution(tlv_value) {
                Ok(value) => serde_json::to_string(&value).unwrap_or_else(|_| "null".to_string()),
                Err(e) => format!("{{\"error\": \"{}\"}}", e),
            }
        }
        0x0005 => {
            match decode_rate_distortion_trade_off_points(tlv_value) {
                Ok(value) => serde_json::to_string(&value).unwrap_or_else(|_| "null".to_string()),
                Err(e) => format!("{{\"error\": \"{}\"}}", e),
            }
        }
        0x0006 => {
            match decode_max_content_buffer_size(tlv_value) {
                Ok(value) => serde_json::to_string(&value).unwrap_or_else(|_| "null".to_string()),
                Err(e) => format!("{{\"error\": \"{}\"}}", e),
            }
        }
        0x0007 => {
            match decode_microphone_capabilities(tlv_value) {
                Ok(value) => serde_json::to_string(&value).unwrap_or_else(|_| "null".to_string()),
                Err(e) => format!("{{\"error\": \"{}\"}}", e),
            }
        }
        0x0008 => {
            match decode_speaker_capabilities(tlv_value) {
                Ok(value) => serde_json::to_string(&value).unwrap_or_else(|_| "null".to_string()),
                Err(e) => format!("{{\"error\": \"{}\"}}", e),
            }
        }
        0x0009 => {
            match decode_two_way_talk_support(tlv_value) {
                Ok(value) => serde_json::to_string(&value).unwrap_or_else(|_| "null".to_string()),
                Err(e) => format!("{{\"error\": \"{}\"}}", e),
            }
        }
        0x000A => {
            match decode_snapshot_capabilities(tlv_value) {
                Ok(value) => serde_json::to_string(&value).unwrap_or_else(|_| "null".to_string()),
                Err(e) => format!("{{\"error\": \"{}\"}}", e),
            }
        }
        0x000B => {
            match decode_max_network_bandwidth(tlv_value) {
                Ok(value) => serde_json::to_string(&value).unwrap_or_else(|_| "null".to_string()),
                Err(e) => format!("{{\"error\": \"{}\"}}", e),
            }
        }
        0x000C => {
            match decode_current_frame_rate(tlv_value) {
                Ok(value) => serde_json::to_string(&value).unwrap_or_else(|_| "null".to_string()),
                Err(e) => format!("{{\"error\": \"{}\"}}", e),
            }
        }
        0x000D => {
            match decode_hdr_mode_enabled(tlv_value) {
                Ok(value) => serde_json::to_string(&value).unwrap_or_else(|_| "null".to_string()),
                Err(e) => format!("{{\"error\": \"{}\"}}", e),
            }
        }
        0x000E => {
            match decode_supported_stream_usages(tlv_value) {
                Ok(value) => serde_json::to_string(&value).unwrap_or_else(|_| "null".to_string()),
                Err(e) => format!("{{\"error\": \"{}\"}}", e),
            }
        }
        0x000F => {
            match decode_allocated_video_streams(tlv_value) {
                Ok(value) => serde_json::to_string(&value).unwrap_or_else(|_| "null".to_string()),
                Err(e) => format!("{{\"error\": \"{}\"}}", e),
            }
        }
        0x0010 => {
            match decode_allocated_audio_streams(tlv_value) {
                Ok(value) => serde_json::to_string(&value).unwrap_or_else(|_| "null".to_string()),
                Err(e) => format!("{{\"error\": \"{}\"}}", e),
            }
        }
        0x0011 => {
            match decode_allocated_snapshot_streams(tlv_value) {
                Ok(value) => serde_json::to_string(&value).unwrap_or_else(|_| "null".to_string()),
                Err(e) => format!("{{\"error\": \"{}\"}}", e),
            }
        }
        0x0012 => {
            match decode_stream_usage_priorities(tlv_value) {
                Ok(value) => serde_json::to_string(&value).unwrap_or_else(|_| "null".to_string()),
                Err(e) => format!("{{\"error\": \"{}\"}}", e),
            }
        }
        0x0013 => {
            match decode_soft_recording_privacy_mode_enabled(tlv_value) {
                Ok(value) => serde_json::to_string(&value).unwrap_or_else(|_| "null".to_string()),
                Err(e) => format!("{{\"error\": \"{}\"}}", e),
            }
        }
        0x0014 => {
            match decode_soft_livestream_privacy_mode_enabled(tlv_value) {
                Ok(value) => serde_json::to_string(&value).unwrap_or_else(|_| "null".to_string()),
                Err(e) => format!("{{\"error\": \"{}\"}}", e),
            }
        }
        0x0015 => {
            match decode_hard_privacy_mode_on(tlv_value) {
                Ok(value) => serde_json::to_string(&value).unwrap_or_else(|_| "null".to_string()),
                Err(e) => format!("{{\"error\": \"{}\"}}", e),
            }
        }
        0x0016 => {
            match decode_night_vision(tlv_value) {
                Ok(value) => serde_json::to_string(&value).unwrap_or_else(|_| "null".to_string()),
                Err(e) => format!("{{\"error\": \"{}\"}}", e),
            }
        }
        0x0017 => {
            match decode_night_vision_illum(tlv_value) {
                Ok(value) => serde_json::to_string(&value).unwrap_or_else(|_| "null".to_string()),
                Err(e) => format!("{{\"error\": \"{}\"}}", e),
            }
        }
        0x0018 => {
            match decode_viewport(tlv_value) {
                Ok(value) => serde_json::to_string(&value).unwrap_or_else(|_| "null".to_string()),
                Err(e) => format!("{{\"error\": \"{}\"}}", e),
            }
        }
        0x0019 => {
            match decode_speaker_muted(tlv_value) {
                Ok(value) => serde_json::to_string(&value).unwrap_or_else(|_| "null".to_string()),
                Err(e) => format!("{{\"error\": \"{}\"}}", e),
            }
        }
        0x001A => {
            match decode_speaker_volume_level(tlv_value) {
                Ok(value) => serde_json::to_string(&value).unwrap_or_else(|_| "null".to_string()),
                Err(e) => format!("{{\"error\": \"{}\"}}", e),
            }
        }
        0x001B => {
            match decode_speaker_max_level(tlv_value) {
                Ok(value) => serde_json::to_string(&value).unwrap_or_else(|_| "null".to_string()),
                Err(e) => format!("{{\"error\": \"{}\"}}", e),
            }
        }
        0x001C => {
            match decode_speaker_min_level(tlv_value) {
                Ok(value) => serde_json::to_string(&value).unwrap_or_else(|_| "null".to_string()),
                Err(e) => format!("{{\"error\": \"{}\"}}", e),
            }
        }
        0x001D => {
            match decode_microphone_muted(tlv_value) {
                Ok(value) => serde_json::to_string(&value).unwrap_or_else(|_| "null".to_string()),
                Err(e) => format!("{{\"error\": \"{}\"}}", e),
            }
        }
        0x001E => {
            match decode_microphone_volume_level(tlv_value) {
                Ok(value) => serde_json::to_string(&value).unwrap_or_else(|_| "null".to_string()),
                Err(e) => format!("{{\"error\": \"{}\"}}", e),
            }
        }
        0x001F => {
            match decode_microphone_max_level(tlv_value) {
                Ok(value) => serde_json::to_string(&value).unwrap_or_else(|_| "null".to_string()),
                Err(e) => format!("{{\"error\": \"{}\"}}", e),
            }
        }
        0x0020 => {
            match decode_microphone_min_level(tlv_value) {
                Ok(value) => serde_json::to_string(&value).unwrap_or_else(|_| "null".to_string()),
                Err(e) => format!("{{\"error\": \"{}\"}}", e),
            }
        }
        0x0021 => {
            match decode_microphone_agc_enabled(tlv_value) {
                Ok(value) => serde_json::to_string(&value).unwrap_or_else(|_| "null".to_string()),
                Err(e) => format!("{{\"error\": \"{}\"}}", e),
            }
        }
        0x0022 => {
            match decode_image_rotation(tlv_value) {
                Ok(value) => serde_json::to_string(&value).unwrap_or_else(|_| "null".to_string()),
                Err(e) => format!("{{\"error\": \"{}\"}}", e),
            }
        }
        0x0023 => {
            match decode_image_flip_horizontal(tlv_value) {
                Ok(value) => serde_json::to_string(&value).unwrap_or_else(|_| "null".to_string()),
                Err(e) => format!("{{\"error\": \"{}\"}}", e),
            }
        }
        0x0024 => {
            match decode_image_flip_vertical(tlv_value) {
                Ok(value) => serde_json::to_string(&value).unwrap_or_else(|_| "null".to_string()),
                Err(e) => format!("{{\"error\": \"{}\"}}", e),
            }
        }
        0x0025 => {
            match decode_local_video_recording_enabled(tlv_value) {
                Ok(value) => serde_json::to_string(&value).unwrap_or_else(|_| "null".to_string()),
                Err(e) => format!("{{\"error\": \"{}\"}}", e),
            }
        }
        0x0026 => {
            match decode_local_snapshot_recording_enabled(tlv_value) {
                Ok(value) => serde_json::to_string(&value).unwrap_or_else(|_| "null".to_string()),
                Err(e) => format!("{{\"error\": \"{}\"}}", e),
            }
        }
        0x0027 => {
            match decode_status_light_enabled(tlv_value) {
                Ok(value) => serde_json::to_string(&value).unwrap_or_else(|_| "null".to_string()),
                Err(e) => format!("{{\"error\": \"{}\"}}", e),
            }
        }
        0x0028 => {
            match decode_status_light_brightness(tlv_value) {
                Ok(value) => serde_json::to_string(&value).unwrap_or_else(|_| "null".to_string()),
                Err(e) => format!("{{\"error\": \"{}\"}}", e),
            }
        }
        0x0029 => {
            match decode_image_rotation_discrete_angles(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, "MaxConcurrentEncoders"),
        (0x0001, "MaxEncodedPixelRate"),
        (0x0002, "VideoSensorParams"),
        (0x0003, "NightVisionUsesInfrared"),
        (0x0004, "MinViewportResolution"),
        (0x0005, "RateDistortionTradeOffPoints"),
        (0x0006, "MaxContentBufferSize"),
        (0x0007, "MicrophoneCapabilities"),
        (0x0008, "SpeakerCapabilities"),
        (0x0009, "TwoWayTalkSupport"),
        (0x000A, "SnapshotCapabilities"),
        (0x000B, "MaxNetworkBandwidth"),
        (0x000C, "CurrentFrameRate"),
        (0x000D, "HDRModeEnabled"),
        (0x000E, "SupportedStreamUsages"),
        (0x000F, "AllocatedVideoStreams"),
        (0x0010, "AllocatedAudioStreams"),
        (0x0011, "AllocatedSnapshotStreams"),
        (0x0012, "StreamUsagePriorities"),
        (0x0013, "SoftRecordingPrivacyModeEnabled"),
        (0x0014, "SoftLivestreamPrivacyModeEnabled"),
        (0x0015, "HardPrivacyModeOn"),
        (0x0016, "NightVision"),
        (0x0017, "NightVisionIllum"),
        (0x0018, "Viewport"),
        (0x0019, "SpeakerMuted"),
        (0x001A, "SpeakerVolumeLevel"),
        (0x001B, "SpeakerMaxLevel"),
        (0x001C, "SpeakerMinLevel"),
        (0x001D, "MicrophoneMuted"),
        (0x001E, "MicrophoneVolumeLevel"),
        (0x001F, "MicrophoneMaxLevel"),
        (0x0020, "MicrophoneMinLevel"),
        (0x0021, "MicrophoneAGCEnabled"),
        (0x0022, "ImageRotation"),
        (0x0023, "ImageFlipHorizontal"),
        (0x0024, "ImageFlipVertical"),
        (0x0025, "LocalVideoRecordingEnabled"),
        (0x0026, "LocalSnapshotRecordingEnabled"),
        (0x0027, "StatusLightEnabled"),
        (0x0028, "StatusLightBrightness"),
        (0x0029, "ImageRotationDiscreteAngles"),
    ]
}

// Command listing

pub fn get_command_list() -> Vec<(u32, &'static str)> {
    vec![
        (0x00, "AudioStreamAllocate"),
        (0x02, "AudioStreamDeallocate"),
        (0x03, "VideoStreamAllocate"),
        (0x05, "VideoStreamModify"),
        (0x06, "VideoStreamDeallocate"),
        (0x07, "SnapshotStreamAllocate"),
        (0x09, "SnapshotStreamModify"),
        (0x0A, "SnapshotStreamDeallocate"),
        (0x0B, "SetStreamPriorities"),
        (0x0C, "CaptureSnapshot"),
    ]
}

pub fn get_command_name(cmd_id: u32) -> Option<&'static str> {
    match cmd_id {
        0x00 => Some("AudioStreamAllocate"),
        0x02 => Some("AudioStreamDeallocate"),
        0x03 => Some("VideoStreamAllocate"),
        0x05 => Some("VideoStreamModify"),
        0x06 => Some("VideoStreamDeallocate"),
        0x07 => Some("SnapshotStreamAllocate"),
        0x09 => Some("SnapshotStreamModify"),
        0x0A => Some("SnapshotStreamDeallocate"),
        0x0B => Some("SetStreamPriorities"),
        0x0C => Some("CaptureSnapshot"),
        _ => 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: "stream_usage", kind: crate::clusters::codec::FieldKind::U8, optional: false, nullable: false },
            crate::clusters::codec::CommandField { tag: 1, name: "audio_codec", kind: crate::clusters::codec::FieldKind::Enum { name: "AudioCodec", variants: &[(0, "Opus"), (1, "AacLc")] }, optional: false, nullable: false },
            crate::clusters::codec::CommandField { tag: 2, name: "channel_count", kind: crate::clusters::codec::FieldKind::U8, optional: false, nullable: false },
            crate::clusters::codec::CommandField { tag: 3, name: "sample_rate", kind: crate::clusters::codec::FieldKind::U32, optional: false, nullable: false },
            crate::clusters::codec::CommandField { tag: 4, name: "bit_rate", kind: crate::clusters::codec::FieldKind::U32, optional: false, nullable: false },
            crate::clusters::codec::CommandField { tag: 5, name: "bit_depth", kind: crate::clusters::codec::FieldKind::U8, optional: false, nullable: false },
        ]),
        0x02 => Some(vec![
            crate::clusters::codec::CommandField { tag: 0, name: "audio_stream_id", kind: crate::clusters::codec::FieldKind::U16, optional: false, nullable: false },
        ]),
        0x03 => Some(vec![
            crate::clusters::codec::CommandField { tag: 0, name: "stream_usage", kind: crate::clusters::codec::FieldKind::U8, optional: false, nullable: false },
            crate::clusters::codec::CommandField { tag: 1, name: "video_codec", kind: crate::clusters::codec::FieldKind::Enum { name: "VideoCodec", variants: &[(0, "H264"), (1, "Hevc"), (2, "Vvc"), (3, "Av1")] }, optional: false, nullable: false },
            crate::clusters::codec::CommandField { tag: 2, name: "min_frame_rate", kind: crate::clusters::codec::FieldKind::U16, optional: false, nullable: false },
            crate::clusters::codec::CommandField { tag: 3, name: "max_frame_rate", kind: crate::clusters::codec::FieldKind::U16, optional: false, nullable: false },
            crate::clusters::codec::CommandField { tag: 4, name: "min_resolution", kind: crate::clusters::codec::FieldKind::Struct { name: "VideoResolutionStruct" }, optional: false, nullable: false },
            crate::clusters::codec::CommandField { tag: 5, name: "max_resolution", kind: crate::clusters::codec::FieldKind::Struct { name: "VideoResolutionStruct" }, optional: false, nullable: false },
            crate::clusters::codec::CommandField { tag: 6, name: "min_bit_rate", kind: crate::clusters::codec::FieldKind::U32, optional: false, nullable: false },
            crate::clusters::codec::CommandField { tag: 7, name: "max_bit_rate", kind: crate::clusters::codec::FieldKind::U32, optional: false, nullable: false },
            crate::clusters::codec::CommandField { tag: 8, name: "key_frame_interval", kind: crate::clusters::codec::FieldKind::U16, optional: false, nullable: false },
            crate::clusters::codec::CommandField { tag: 9, name: "watermark_enabled", kind: crate::clusters::codec::FieldKind::Bool, optional: false, nullable: false },
            crate::clusters::codec::CommandField { tag: 10, name: "osd_enabled", kind: crate::clusters::codec::FieldKind::Bool, optional: false, nullable: false },
        ]),
        0x05 => Some(vec![
            crate::clusters::codec::CommandField { tag: 0, name: "video_stream_id", kind: crate::clusters::codec::FieldKind::U16, optional: false, nullable: false },
            crate::clusters::codec::CommandField { tag: 1, name: "watermark_enabled", kind: crate::clusters::codec::FieldKind::Bool, optional: true, nullable: false },
            crate::clusters::codec::CommandField { tag: 2, name: "osd_enabled", kind: crate::clusters::codec::FieldKind::Bool, optional: true, nullable: false },
        ]),
        0x06 => Some(vec![
            crate::clusters::codec::CommandField { tag: 0, name: "video_stream_id", kind: crate::clusters::codec::FieldKind::U16, optional: false, nullable: false },
        ]),
        0x07 => Some(vec![
            crate::clusters::codec::CommandField { tag: 0, name: "image_codec", kind: crate::clusters::codec::FieldKind::Enum { name: "ImageCodec", variants: &[(0, "Jpeg"), (1, "Heic")] }, optional: false, nullable: false },
            crate::clusters::codec::CommandField { tag: 1, name: "max_frame_rate", kind: crate::clusters::codec::FieldKind::U16, optional: false, nullable: false },
            crate::clusters::codec::CommandField { tag: 2, name: "min_resolution", kind: crate::clusters::codec::FieldKind::Struct { name: "VideoResolutionStruct" }, optional: false, nullable: false },
            crate::clusters::codec::CommandField { tag: 3, name: "max_resolution", kind: crate::clusters::codec::FieldKind::Struct { name: "VideoResolutionStruct" }, optional: false, nullable: false },
            crate::clusters::codec::CommandField { tag: 4, name: "quality", kind: crate::clusters::codec::FieldKind::U8, optional: false, nullable: false },
            crate::clusters::codec::CommandField { tag: 5, name: "watermark_enabled", kind: crate::clusters::codec::FieldKind::Bool, optional: false, nullable: false },
            crate::clusters::codec::CommandField { tag: 6, name: "osd_enabled", kind: crate::clusters::codec::FieldKind::Bool, optional: false, nullable: false },
        ]),
        0x09 => Some(vec![
            crate::clusters::codec::CommandField { tag: 0, name: "snapshot_stream_id", kind: crate::clusters::codec::FieldKind::U16, optional: false, nullable: false },
            crate::clusters::codec::CommandField { tag: 1, name: "watermark_enabled", kind: crate::clusters::codec::FieldKind::Bool, optional: true, nullable: false },
            crate::clusters::codec::CommandField { tag: 2, name: "osd_enabled", kind: crate::clusters::codec::FieldKind::Bool, optional: true, nullable: false },
        ]),
        0x0A => Some(vec![
            crate::clusters::codec::CommandField { tag: 0, name: "snapshot_stream_id", kind: crate::clusters::codec::FieldKind::U16, optional: false, nullable: false },
        ]),
        0x0B => Some(vec![
            crate::clusters::codec::CommandField { tag: 0, name: "stream_priorities", kind: crate::clusters::codec::FieldKind::List { entry_type: "StreamUsageEnum" }, optional: false, nullable: false },
        ]),
        0x0C => Some(vec![
            crate::clusters::codec::CommandField { tag: 0, name: "snapshot_stream_id", kind: crate::clusters::codec::FieldKind::U16, optional: false, nullable: true },
            crate::clusters::codec::CommandField { tag: 1, name: "requested_resolution", kind: crate::clusters::codec::FieldKind::Struct { name: "VideoResolutionStruct" }, 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 stream_usage = crate::clusters::codec::json_util::get_u8(args, "stream_usage")?;
        let audio_codec = {
            let n = crate::clusters::codec::json_util::get_u64(args, "audio_codec")?;
            AudioCodec::from_u8(n as u8).ok_or_else(|| anyhow::anyhow!("invalid AudioCodec: {}", n))?
        };
        let channel_count = crate::clusters::codec::json_util::get_u8(args, "channel_count")?;
        let sample_rate = crate::clusters::codec::json_util::get_u32(args, "sample_rate")?;
        let bit_rate = crate::clusters::codec::json_util::get_u32(args, "bit_rate")?;
        let bit_depth = crate::clusters::codec::json_util::get_u8(args, "bit_depth")?;
        encode_audio_stream_allocate(stream_usage, audio_codec, channel_count, sample_rate, bit_rate, bit_depth)
        }
        0x02 => {
        let audio_stream_id = crate::clusters::codec::json_util::get_u16(args, "audio_stream_id")?;
        encode_audio_stream_deallocate(audio_stream_id)
        }
        0x03 => Err(anyhow::anyhow!("command \"VideoStreamAllocate\" has complex args: use raw mode")),
        0x05 => {
        let video_stream_id = crate::clusters::codec::json_util::get_u16(args, "video_stream_id")?;
        let watermark_enabled = crate::clusters::codec::json_util::get_opt_bool(args, "watermark_enabled")?;
        let osd_enabled = crate::clusters::codec::json_util::get_opt_bool(args, "osd_enabled")?;
        encode_video_stream_modify(video_stream_id, watermark_enabled, osd_enabled)
        }
        0x06 => {
        let video_stream_id = crate::clusters::codec::json_util::get_u16(args, "video_stream_id")?;
        encode_video_stream_deallocate(video_stream_id)
        }
        0x07 => Err(anyhow::anyhow!("command \"SnapshotStreamAllocate\" has complex args: use raw mode")),
        0x09 => {
        let snapshot_stream_id = crate::clusters::codec::json_util::get_u16(args, "snapshot_stream_id")?;
        let watermark_enabled = crate::clusters::codec::json_util::get_opt_bool(args, "watermark_enabled")?;
        let osd_enabled = crate::clusters::codec::json_util::get_opt_bool(args, "osd_enabled")?;
        encode_snapshot_stream_modify(snapshot_stream_id, watermark_enabled, osd_enabled)
        }
        0x0A => {
        let snapshot_stream_id = crate::clusters::codec::json_util::get_u16(args, "snapshot_stream_id")?;
        encode_snapshot_stream_deallocate(snapshot_stream_id)
        }
        0x0B => Err(anyhow::anyhow!("command \"SetStreamPriorities\" has complex args: use raw mode")),
        0x0C => Err(anyhow::anyhow!("command \"CaptureSnapshot\" has complex args: use raw mode")),
        _ => Err(anyhow::anyhow!("unknown command ID: 0x{:02X}", cmd_id)),
    }
}

#[derive(Debug, serde::Serialize)]
pub struct AudioStreamAllocateResponse {
    pub audio_stream_id: Option<u16>,
}

#[derive(Debug, serde::Serialize)]
pub struct VideoStreamAllocateResponse {
    pub video_stream_id: Option<u16>,
}

#[derive(Debug, serde::Serialize)]
pub struct SnapshotStreamAllocateResponse {
    pub snapshot_stream_id: Option<u16>,
}

#[derive(Debug, serde::Serialize)]
pub struct CaptureSnapshotResponse {
    #[serde(serialize_with = "serialize_opt_bytes_as_hex")]
    pub data: Option<Vec<u8>>,
    pub image_codec: Option<ImageCodec>,
    pub resolution: Option<VideoResolution>,
}

// Command response decoders

/// Decode AudioStreamAllocateResponse command response (01)
pub fn decode_audio_stream_allocate_response(inp: &tlv::TlvItemValue) -> anyhow::Result<AudioStreamAllocateResponse> {
    if let tlv::TlvItemValue::List(_fields) = inp {
        let item = tlv::TlvItem { tag: 0, value: inp.clone() };
        Ok(AudioStreamAllocateResponse {
                audio_stream_id: item.get_int(&[0]).map(|v| v as u16),
        })
    } else {
        Err(anyhow::anyhow!("Expected struct fields"))
    }
}

/// Decode VideoStreamAllocateResponse command response (04)
pub fn decode_video_stream_allocate_response(inp: &tlv::TlvItemValue) -> anyhow::Result<VideoStreamAllocateResponse> {
    if let tlv::TlvItemValue::List(_fields) = inp {
        let item = tlv::TlvItem { tag: 0, value: inp.clone() };
        Ok(VideoStreamAllocateResponse {
                video_stream_id: item.get_int(&[0]).map(|v| v as u16),
        })
    } else {
        Err(anyhow::anyhow!("Expected struct fields"))
    }
}

/// Decode SnapshotStreamAllocateResponse command response (08)
pub fn decode_snapshot_stream_allocate_response(inp: &tlv::TlvItemValue) -> anyhow::Result<SnapshotStreamAllocateResponse> {
    if let tlv::TlvItemValue::List(_fields) = inp {
        let item = tlv::TlvItem { tag: 0, value: inp.clone() };
        Ok(SnapshotStreamAllocateResponse {
                snapshot_stream_id: item.get_int(&[0]).map(|v| v as u16),
        })
    } else {
        Err(anyhow::anyhow!("Expected struct fields"))
    }
}

/// Decode CaptureSnapshotResponse command response (0D)
pub fn decode_capture_snapshot_response(inp: &tlv::TlvItemValue) -> anyhow::Result<CaptureSnapshotResponse> {
    if let tlv::TlvItemValue::List(_fields) = inp {
        let item = tlv::TlvItem { tag: 0, value: inp.clone() };
        Ok(CaptureSnapshotResponse {
                data: item.get_octet_string_owned(&[0]),
                image_codec: item.get_int(&[1]).and_then(|v| ImageCodec::from_u8(v as u8)),
                resolution: {
                    if let Some(nested_tlv) = item.get(&[2]) {
                        if let tlv::TlvItemValue::List(_) = nested_tlv {
                            let nested_item = tlv::TlvItem { tag: 2, value: nested_tlv.clone() };
                            Some(VideoResolution {
                width: nested_item.get_int(&[0]).map(|v| v as u16),
                height: nested_item.get_int(&[1]).map(|v| v as u16),
                            })
                        } else {
                            None
                        }
                    } else {
                        None
                    }
                },
        })
    } else {
        Err(anyhow::anyhow!("Expected struct fields"))
    }
}

// Typed facade (invokes + reads)

/// Invoke `AudioStreamAllocate` command on cluster `Camera AV Stream Management`.
pub async fn audio_stream_allocate(conn: &crate::controller::Connection, endpoint: u16, stream_usage: u8, audio_codec: AudioCodec, channel_count: u8, sample_rate: u32, bit_rate: u32, bit_depth: u8) -> anyhow::Result<AudioStreamAllocateResponse> {
    let tlv = conn.invoke_request2(endpoint, crate::clusters::defs::CLUSTER_ID_CAMERA_AV_STREAM_MANAGEMENT, crate::clusters::defs::CLUSTER_CAMERA_AV_STREAM_MANAGEMENT_CMD_ID_AUDIOSTREAMALLOCATE, &encode_audio_stream_allocate(stream_usage, audio_codec, channel_count, sample_rate, bit_rate, bit_depth)?).await?;
    decode_audio_stream_allocate_response(&tlv)
}

/// Invoke `AudioStreamDeallocate` command on cluster `Camera AV Stream Management`.
pub async fn audio_stream_deallocate(conn: &crate::controller::Connection, endpoint: u16, audio_stream_id: u16) -> anyhow::Result<()> {
    conn.invoke_request(endpoint, crate::clusters::defs::CLUSTER_ID_CAMERA_AV_STREAM_MANAGEMENT, crate::clusters::defs::CLUSTER_CAMERA_AV_STREAM_MANAGEMENT_CMD_ID_AUDIOSTREAMDEALLOCATE, &encode_audio_stream_deallocate(audio_stream_id)?).await?;
    Ok(())
}

/// Invoke `VideoStreamAllocate` command on cluster `Camera AV Stream Management`.
pub async fn video_stream_allocate(conn: &crate::controller::Connection, endpoint: u16, params: VideoStreamAllocateParams) -> anyhow::Result<VideoStreamAllocateResponse> {
    let tlv = conn.invoke_request2(endpoint, crate::clusters::defs::CLUSTER_ID_CAMERA_AV_STREAM_MANAGEMENT, crate::clusters::defs::CLUSTER_CAMERA_AV_STREAM_MANAGEMENT_CMD_ID_VIDEOSTREAMALLOCATE, &encode_video_stream_allocate(params)?).await?;
    decode_video_stream_allocate_response(&tlv)
}

/// Invoke `VideoStreamModify` command on cluster `Camera AV Stream Management`.
pub async fn video_stream_modify(conn: &crate::controller::Connection, endpoint: u16, video_stream_id: u16, watermark_enabled: Option<bool>, osd_enabled: Option<bool>) -> anyhow::Result<()> {
    conn.invoke_request(endpoint, crate::clusters::defs::CLUSTER_ID_CAMERA_AV_STREAM_MANAGEMENT, crate::clusters::defs::CLUSTER_CAMERA_AV_STREAM_MANAGEMENT_CMD_ID_VIDEOSTREAMMODIFY, &encode_video_stream_modify(video_stream_id, watermark_enabled, osd_enabled)?).await?;
    Ok(())
}

/// Invoke `VideoStreamDeallocate` command on cluster `Camera AV Stream Management`.
pub async fn video_stream_deallocate(conn: &crate::controller::Connection, endpoint: u16, video_stream_id: u16) -> anyhow::Result<()> {
    conn.invoke_request(endpoint, crate::clusters::defs::CLUSTER_ID_CAMERA_AV_STREAM_MANAGEMENT, crate::clusters::defs::CLUSTER_CAMERA_AV_STREAM_MANAGEMENT_CMD_ID_VIDEOSTREAMDEALLOCATE, &encode_video_stream_deallocate(video_stream_id)?).await?;
    Ok(())
}

/// Invoke `SnapshotStreamAllocate` command on cluster `Camera AV Stream Management`.
pub async fn snapshot_stream_allocate(conn: &crate::controller::Connection, endpoint: u16, image_codec: ImageCodec, max_frame_rate: u16, min_resolution: VideoResolution, max_resolution: VideoResolution, quality: u8, watermark_enabled: bool, osd_enabled: bool) -> anyhow::Result<SnapshotStreamAllocateResponse> {
    let tlv = conn.invoke_request2(endpoint, crate::clusters::defs::CLUSTER_ID_CAMERA_AV_STREAM_MANAGEMENT, crate::clusters::defs::CLUSTER_CAMERA_AV_STREAM_MANAGEMENT_CMD_ID_SNAPSHOTSTREAMALLOCATE, &encode_snapshot_stream_allocate(image_codec, max_frame_rate, min_resolution, max_resolution, quality, watermark_enabled, osd_enabled)?).await?;
    decode_snapshot_stream_allocate_response(&tlv)
}

/// Invoke `SnapshotStreamModify` command on cluster `Camera AV Stream Management`.
pub async fn snapshot_stream_modify(conn: &crate::controller::Connection, endpoint: u16, snapshot_stream_id: u16, watermark_enabled: Option<bool>, osd_enabled: Option<bool>) -> anyhow::Result<()> {
    conn.invoke_request(endpoint, crate::clusters::defs::CLUSTER_ID_CAMERA_AV_STREAM_MANAGEMENT, crate::clusters::defs::CLUSTER_CAMERA_AV_STREAM_MANAGEMENT_CMD_ID_SNAPSHOTSTREAMMODIFY, &encode_snapshot_stream_modify(snapshot_stream_id, watermark_enabled, osd_enabled)?).await?;
    Ok(())
}

/// Invoke `SnapshotStreamDeallocate` command on cluster `Camera AV Stream Management`.
pub async fn snapshot_stream_deallocate(conn: &crate::controller::Connection, endpoint: u16, snapshot_stream_id: u16) -> anyhow::Result<()> {
    conn.invoke_request(endpoint, crate::clusters::defs::CLUSTER_ID_CAMERA_AV_STREAM_MANAGEMENT, crate::clusters::defs::CLUSTER_CAMERA_AV_STREAM_MANAGEMENT_CMD_ID_SNAPSHOTSTREAMDEALLOCATE, &encode_snapshot_stream_deallocate(snapshot_stream_id)?).await?;
    Ok(())
}

/// Invoke `SetStreamPriorities` command on cluster `Camera AV Stream Management`.
pub async fn set_stream_priorities(conn: &crate::controller::Connection, endpoint: u16, stream_priorities: Vec<u8>) -> anyhow::Result<()> {
    conn.invoke_request(endpoint, crate::clusters::defs::CLUSTER_ID_CAMERA_AV_STREAM_MANAGEMENT, crate::clusters::defs::CLUSTER_CAMERA_AV_STREAM_MANAGEMENT_CMD_ID_SETSTREAMPRIORITIES, &encode_set_stream_priorities(stream_priorities)?).await?;
    Ok(())
}

/// Invoke `CaptureSnapshot` command on cluster `Camera AV Stream Management`.
pub async fn capture_snapshot(conn: &crate::controller::Connection, endpoint: u16, snapshot_stream_id: Option<u16>, requested_resolution: VideoResolution) -> anyhow::Result<CaptureSnapshotResponse> {
    let tlv = conn.invoke_request2(endpoint, crate::clusters::defs::CLUSTER_ID_CAMERA_AV_STREAM_MANAGEMENT, crate::clusters::defs::CLUSTER_CAMERA_AV_STREAM_MANAGEMENT_CMD_ID_CAPTURESNAPSHOT, &encode_capture_snapshot(snapshot_stream_id, requested_resolution)?).await?;
    decode_capture_snapshot_response(&tlv)
}

/// Read `MaxConcurrentEncoders` attribute from cluster `Camera AV Stream Management`.
pub async fn read_max_concurrent_encoders(conn: &crate::controller::Connection, endpoint: u16) -> anyhow::Result<u8> {
    let tlv = conn.read_request2(endpoint, crate::clusters::defs::CLUSTER_ID_CAMERA_AV_STREAM_MANAGEMENT, crate::clusters::defs::CLUSTER_CAMERA_AV_STREAM_MANAGEMENT_ATTR_ID_MAXCONCURRENTENCODERS).await?;
    decode_max_concurrent_encoders(&tlv)
}

/// Read `MaxEncodedPixelRate` attribute from cluster `Camera AV Stream Management`.
pub async fn read_max_encoded_pixel_rate(conn: &crate::controller::Connection, endpoint: u16) -> anyhow::Result<u32> {
    let tlv = conn.read_request2(endpoint, crate::clusters::defs::CLUSTER_ID_CAMERA_AV_STREAM_MANAGEMENT, crate::clusters::defs::CLUSTER_CAMERA_AV_STREAM_MANAGEMENT_ATTR_ID_MAXENCODEDPIXELRATE).await?;
    decode_max_encoded_pixel_rate(&tlv)
}

/// Read `VideoSensorParams` attribute from cluster `Camera AV Stream Management`.
pub async fn read_video_sensor_params(conn: &crate::controller::Connection, endpoint: u16) -> anyhow::Result<VideoSensorParams> {
    let tlv = conn.read_request2(endpoint, crate::clusters::defs::CLUSTER_ID_CAMERA_AV_STREAM_MANAGEMENT, crate::clusters::defs::CLUSTER_CAMERA_AV_STREAM_MANAGEMENT_ATTR_ID_VIDEOSENSORPARAMS).await?;
    decode_video_sensor_params(&tlv)
}

/// Read `NightVisionUsesInfrared` attribute from cluster `Camera AV Stream Management`.
pub async fn read_night_vision_uses_infrared(conn: &crate::controller::Connection, endpoint: u16) -> anyhow::Result<bool> {
    let tlv = conn.read_request2(endpoint, crate::clusters::defs::CLUSTER_ID_CAMERA_AV_STREAM_MANAGEMENT, crate::clusters::defs::CLUSTER_CAMERA_AV_STREAM_MANAGEMENT_ATTR_ID_NIGHTVISIONUSESINFRARED).await?;
    decode_night_vision_uses_infrared(&tlv)
}

/// Read `MinViewportResolution` attribute from cluster `Camera AV Stream Management`.
pub async fn read_min_viewport_resolution(conn: &crate::controller::Connection, endpoint: u16) -> anyhow::Result<VideoResolution> {
    let tlv = conn.read_request2(endpoint, crate::clusters::defs::CLUSTER_ID_CAMERA_AV_STREAM_MANAGEMENT, crate::clusters::defs::CLUSTER_CAMERA_AV_STREAM_MANAGEMENT_ATTR_ID_MINVIEWPORTRESOLUTION).await?;
    decode_min_viewport_resolution(&tlv)
}

/// Read `RateDistortionTradeOffPoints` attribute from cluster `Camera AV Stream Management`.
pub async fn read_rate_distortion_trade_off_points(conn: &crate::controller::Connection, endpoint: u16) -> anyhow::Result<Vec<RateDistortionTradeOffPoints>> {
    let tlv = conn.read_request2(endpoint, crate::clusters::defs::CLUSTER_ID_CAMERA_AV_STREAM_MANAGEMENT, crate::clusters::defs::CLUSTER_CAMERA_AV_STREAM_MANAGEMENT_ATTR_ID_RATEDISTORTIONTRADEOFFPOINTS).await?;
    decode_rate_distortion_trade_off_points(&tlv)
}

/// Read `MaxContentBufferSize` attribute from cluster `Camera AV Stream Management`.
pub async fn read_max_content_buffer_size(conn: &crate::controller::Connection, endpoint: u16) -> anyhow::Result<u32> {
    let tlv = conn.read_request2(endpoint, crate::clusters::defs::CLUSTER_ID_CAMERA_AV_STREAM_MANAGEMENT, crate::clusters::defs::CLUSTER_CAMERA_AV_STREAM_MANAGEMENT_ATTR_ID_MAXCONTENTBUFFERSIZE).await?;
    decode_max_content_buffer_size(&tlv)
}

/// Read `MicrophoneCapabilities` attribute from cluster `Camera AV Stream Management`.
pub async fn read_microphone_capabilities(conn: &crate::controller::Connection, endpoint: u16) -> anyhow::Result<AudioCapabilities> {
    let tlv = conn.read_request2(endpoint, crate::clusters::defs::CLUSTER_ID_CAMERA_AV_STREAM_MANAGEMENT, crate::clusters::defs::CLUSTER_CAMERA_AV_STREAM_MANAGEMENT_ATTR_ID_MICROPHONECAPABILITIES).await?;
    decode_microphone_capabilities(&tlv)
}

/// Read `SpeakerCapabilities` attribute from cluster `Camera AV Stream Management`.
pub async fn read_speaker_capabilities(conn: &crate::controller::Connection, endpoint: u16) -> anyhow::Result<AudioCapabilities> {
    let tlv = conn.read_request2(endpoint, crate::clusters::defs::CLUSTER_ID_CAMERA_AV_STREAM_MANAGEMENT, crate::clusters::defs::CLUSTER_CAMERA_AV_STREAM_MANAGEMENT_ATTR_ID_SPEAKERCAPABILITIES).await?;
    decode_speaker_capabilities(&tlv)
}

/// Read `TwoWayTalkSupport` attribute from cluster `Camera AV Stream Management`.
pub async fn read_two_way_talk_support(conn: &crate::controller::Connection, endpoint: u16) -> anyhow::Result<TwoWayTalkSupportType> {
    let tlv = conn.read_request2(endpoint, crate::clusters::defs::CLUSTER_ID_CAMERA_AV_STREAM_MANAGEMENT, crate::clusters::defs::CLUSTER_CAMERA_AV_STREAM_MANAGEMENT_ATTR_ID_TWOWAYTALKSUPPORT).await?;
    decode_two_way_talk_support(&tlv)
}

/// Read `SnapshotCapabilities` attribute from cluster `Camera AV Stream Management`.
pub async fn read_snapshot_capabilities(conn: &crate::controller::Connection, endpoint: u16) -> anyhow::Result<Vec<SnapshotCapabilities>> {
    let tlv = conn.read_request2(endpoint, crate::clusters::defs::CLUSTER_ID_CAMERA_AV_STREAM_MANAGEMENT, crate::clusters::defs::CLUSTER_CAMERA_AV_STREAM_MANAGEMENT_ATTR_ID_SNAPSHOTCAPABILITIES).await?;
    decode_snapshot_capabilities(&tlv)
}

/// Read `MaxNetworkBandwidth` attribute from cluster `Camera AV Stream Management`.
pub async fn read_max_network_bandwidth(conn: &crate::controller::Connection, endpoint: u16) -> anyhow::Result<u32> {
    let tlv = conn.read_request2(endpoint, crate::clusters::defs::CLUSTER_ID_CAMERA_AV_STREAM_MANAGEMENT, crate::clusters::defs::CLUSTER_CAMERA_AV_STREAM_MANAGEMENT_ATTR_ID_MAXNETWORKBANDWIDTH).await?;
    decode_max_network_bandwidth(&tlv)
}

/// Read `CurrentFrameRate` attribute from cluster `Camera AV Stream Management`.
pub async fn read_current_frame_rate(conn: &crate::controller::Connection, endpoint: u16) -> anyhow::Result<u16> {
    let tlv = conn.read_request2(endpoint, crate::clusters::defs::CLUSTER_ID_CAMERA_AV_STREAM_MANAGEMENT, crate::clusters::defs::CLUSTER_CAMERA_AV_STREAM_MANAGEMENT_ATTR_ID_CURRENTFRAMERATE).await?;
    decode_current_frame_rate(&tlv)
}

/// Read `HDRModeEnabled` attribute from cluster `Camera AV Stream Management`.
pub async fn read_hdr_mode_enabled(conn: &crate::controller::Connection, endpoint: u16) -> anyhow::Result<bool> {
    let tlv = conn.read_request2(endpoint, crate::clusters::defs::CLUSTER_ID_CAMERA_AV_STREAM_MANAGEMENT, crate::clusters::defs::CLUSTER_CAMERA_AV_STREAM_MANAGEMENT_ATTR_ID_HDRMODEENABLED).await?;
    decode_hdr_mode_enabled(&tlv)
}

/// Read `SupportedStreamUsages` attribute from cluster `Camera AV Stream Management`.
pub async fn read_supported_stream_usages(conn: &crate::controller::Connection, endpoint: u16) -> anyhow::Result<Vec<u8>> {
    let tlv = conn.read_request2(endpoint, crate::clusters::defs::CLUSTER_ID_CAMERA_AV_STREAM_MANAGEMENT, crate::clusters::defs::CLUSTER_CAMERA_AV_STREAM_MANAGEMENT_ATTR_ID_SUPPORTEDSTREAMUSAGES).await?;
    decode_supported_stream_usages(&tlv)
}

/// Read `AllocatedVideoStreams` attribute from cluster `Camera AV Stream Management`.
pub async fn read_allocated_video_streams(conn: &crate::controller::Connection, endpoint: u16) -> anyhow::Result<Vec<VideoStream>> {
    let tlv = conn.read_request2(endpoint, crate::clusters::defs::CLUSTER_ID_CAMERA_AV_STREAM_MANAGEMENT, crate::clusters::defs::CLUSTER_CAMERA_AV_STREAM_MANAGEMENT_ATTR_ID_ALLOCATEDVIDEOSTREAMS).await?;
    decode_allocated_video_streams(&tlv)
}

/// Read `AllocatedAudioStreams` attribute from cluster `Camera AV Stream Management`.
pub async fn read_allocated_audio_streams(conn: &crate::controller::Connection, endpoint: u16) -> anyhow::Result<Vec<AudioStream>> {
    let tlv = conn.read_request2(endpoint, crate::clusters::defs::CLUSTER_ID_CAMERA_AV_STREAM_MANAGEMENT, crate::clusters::defs::CLUSTER_CAMERA_AV_STREAM_MANAGEMENT_ATTR_ID_ALLOCATEDAUDIOSTREAMS).await?;
    decode_allocated_audio_streams(&tlv)
}

/// Read `AllocatedSnapshotStreams` attribute from cluster `Camera AV Stream Management`.
pub async fn read_allocated_snapshot_streams(conn: &crate::controller::Connection, endpoint: u16) -> anyhow::Result<Vec<SnapshotStream>> {
    let tlv = conn.read_request2(endpoint, crate::clusters::defs::CLUSTER_ID_CAMERA_AV_STREAM_MANAGEMENT, crate::clusters::defs::CLUSTER_CAMERA_AV_STREAM_MANAGEMENT_ATTR_ID_ALLOCATEDSNAPSHOTSTREAMS).await?;
    decode_allocated_snapshot_streams(&tlv)
}

/// Read `StreamUsagePriorities` attribute from cluster `Camera AV Stream Management`.
pub async fn read_stream_usage_priorities(conn: &crate::controller::Connection, endpoint: u16) -> anyhow::Result<Vec<u8>> {
    let tlv = conn.read_request2(endpoint, crate::clusters::defs::CLUSTER_ID_CAMERA_AV_STREAM_MANAGEMENT, crate::clusters::defs::CLUSTER_CAMERA_AV_STREAM_MANAGEMENT_ATTR_ID_STREAMUSAGEPRIORITIES).await?;
    decode_stream_usage_priorities(&tlv)
}

/// Read `SoftRecordingPrivacyModeEnabled` attribute from cluster `Camera AV Stream Management`.
pub async fn read_soft_recording_privacy_mode_enabled(conn: &crate::controller::Connection, endpoint: u16) -> anyhow::Result<bool> {
    let tlv = conn.read_request2(endpoint, crate::clusters::defs::CLUSTER_ID_CAMERA_AV_STREAM_MANAGEMENT, crate::clusters::defs::CLUSTER_CAMERA_AV_STREAM_MANAGEMENT_ATTR_ID_SOFTRECORDINGPRIVACYMODEENABLED).await?;
    decode_soft_recording_privacy_mode_enabled(&tlv)
}

/// Read `SoftLivestreamPrivacyModeEnabled` attribute from cluster `Camera AV Stream Management`.
pub async fn read_soft_livestream_privacy_mode_enabled(conn: &crate::controller::Connection, endpoint: u16) -> anyhow::Result<bool> {
    let tlv = conn.read_request2(endpoint, crate::clusters::defs::CLUSTER_ID_CAMERA_AV_STREAM_MANAGEMENT, crate::clusters::defs::CLUSTER_CAMERA_AV_STREAM_MANAGEMENT_ATTR_ID_SOFTLIVESTREAMPRIVACYMODEENABLED).await?;
    decode_soft_livestream_privacy_mode_enabled(&tlv)
}

/// Read `HardPrivacyModeOn` attribute from cluster `Camera AV Stream Management`.
pub async fn read_hard_privacy_mode_on(conn: &crate::controller::Connection, endpoint: u16) -> anyhow::Result<bool> {
    let tlv = conn.read_request2(endpoint, crate::clusters::defs::CLUSTER_ID_CAMERA_AV_STREAM_MANAGEMENT, crate::clusters::defs::CLUSTER_CAMERA_AV_STREAM_MANAGEMENT_ATTR_ID_HARDPRIVACYMODEON).await?;
    decode_hard_privacy_mode_on(&tlv)
}

/// Read `NightVision` attribute from cluster `Camera AV Stream Management`.
pub async fn read_night_vision(conn: &crate::controller::Connection, endpoint: u16) -> anyhow::Result<TriStateAuto> {
    let tlv = conn.read_request2(endpoint, crate::clusters::defs::CLUSTER_ID_CAMERA_AV_STREAM_MANAGEMENT, crate::clusters::defs::CLUSTER_CAMERA_AV_STREAM_MANAGEMENT_ATTR_ID_NIGHTVISION).await?;
    decode_night_vision(&tlv)
}

/// Read `NightVisionIllum` attribute from cluster `Camera AV Stream Management`.
pub async fn read_night_vision_illum(conn: &crate::controller::Connection, endpoint: u16) -> anyhow::Result<TriStateAuto> {
    let tlv = conn.read_request2(endpoint, crate::clusters::defs::CLUSTER_ID_CAMERA_AV_STREAM_MANAGEMENT, crate::clusters::defs::CLUSTER_CAMERA_AV_STREAM_MANAGEMENT_ATTR_ID_NIGHTVISIONILLUM).await?;
    decode_night_vision_illum(&tlv)
}

/// Read `Viewport` attribute from cluster `Camera AV Stream Management`.
pub async fn read_viewport(conn: &crate::controller::Connection, endpoint: u16) -> anyhow::Result<u8> {
    let tlv = conn.read_request2(endpoint, crate::clusters::defs::CLUSTER_ID_CAMERA_AV_STREAM_MANAGEMENT, crate::clusters::defs::CLUSTER_CAMERA_AV_STREAM_MANAGEMENT_ATTR_ID_VIEWPORT).await?;
    decode_viewport(&tlv)
}

/// Read `SpeakerMuted` attribute from cluster `Camera AV Stream Management`.
pub async fn read_speaker_muted(conn: &crate::controller::Connection, endpoint: u16) -> anyhow::Result<bool> {
    let tlv = conn.read_request2(endpoint, crate::clusters::defs::CLUSTER_ID_CAMERA_AV_STREAM_MANAGEMENT, crate::clusters::defs::CLUSTER_CAMERA_AV_STREAM_MANAGEMENT_ATTR_ID_SPEAKERMUTED).await?;
    decode_speaker_muted(&tlv)
}

/// Read `SpeakerVolumeLevel` attribute from cluster `Camera AV Stream Management`.
pub async fn read_speaker_volume_level(conn: &crate::controller::Connection, endpoint: u16) -> anyhow::Result<u8> {
    let tlv = conn.read_request2(endpoint, crate::clusters::defs::CLUSTER_ID_CAMERA_AV_STREAM_MANAGEMENT, crate::clusters::defs::CLUSTER_CAMERA_AV_STREAM_MANAGEMENT_ATTR_ID_SPEAKERVOLUMELEVEL).await?;
    decode_speaker_volume_level(&tlv)
}

/// Read `SpeakerMaxLevel` attribute from cluster `Camera AV Stream Management`.
pub async fn read_speaker_max_level(conn: &crate::controller::Connection, endpoint: u16) -> anyhow::Result<u8> {
    let tlv = conn.read_request2(endpoint, crate::clusters::defs::CLUSTER_ID_CAMERA_AV_STREAM_MANAGEMENT, crate::clusters::defs::CLUSTER_CAMERA_AV_STREAM_MANAGEMENT_ATTR_ID_SPEAKERMAXLEVEL).await?;
    decode_speaker_max_level(&tlv)
}

/// Read `SpeakerMinLevel` attribute from cluster `Camera AV Stream Management`.
pub async fn read_speaker_min_level(conn: &crate::controller::Connection, endpoint: u16) -> anyhow::Result<u8> {
    let tlv = conn.read_request2(endpoint, crate::clusters::defs::CLUSTER_ID_CAMERA_AV_STREAM_MANAGEMENT, crate::clusters::defs::CLUSTER_CAMERA_AV_STREAM_MANAGEMENT_ATTR_ID_SPEAKERMINLEVEL).await?;
    decode_speaker_min_level(&tlv)
}

/// Read `MicrophoneMuted` attribute from cluster `Camera AV Stream Management`.
pub async fn read_microphone_muted(conn: &crate::controller::Connection, endpoint: u16) -> anyhow::Result<bool> {
    let tlv = conn.read_request2(endpoint, crate::clusters::defs::CLUSTER_ID_CAMERA_AV_STREAM_MANAGEMENT, crate::clusters::defs::CLUSTER_CAMERA_AV_STREAM_MANAGEMENT_ATTR_ID_MICROPHONEMUTED).await?;
    decode_microphone_muted(&tlv)
}

/// Read `MicrophoneVolumeLevel` attribute from cluster `Camera AV Stream Management`.
pub async fn read_microphone_volume_level(conn: &crate::controller::Connection, endpoint: u16) -> anyhow::Result<u8> {
    let tlv = conn.read_request2(endpoint, crate::clusters::defs::CLUSTER_ID_CAMERA_AV_STREAM_MANAGEMENT, crate::clusters::defs::CLUSTER_CAMERA_AV_STREAM_MANAGEMENT_ATTR_ID_MICROPHONEVOLUMELEVEL).await?;
    decode_microphone_volume_level(&tlv)
}

/// Read `MicrophoneMaxLevel` attribute from cluster `Camera AV Stream Management`.
pub async fn read_microphone_max_level(conn: &crate::controller::Connection, endpoint: u16) -> anyhow::Result<u8> {
    let tlv = conn.read_request2(endpoint, crate::clusters::defs::CLUSTER_ID_CAMERA_AV_STREAM_MANAGEMENT, crate::clusters::defs::CLUSTER_CAMERA_AV_STREAM_MANAGEMENT_ATTR_ID_MICROPHONEMAXLEVEL).await?;
    decode_microphone_max_level(&tlv)
}

/// Read `MicrophoneMinLevel` attribute from cluster `Camera AV Stream Management`.
pub async fn read_microphone_min_level(conn: &crate::controller::Connection, endpoint: u16) -> anyhow::Result<u8> {
    let tlv = conn.read_request2(endpoint, crate::clusters::defs::CLUSTER_ID_CAMERA_AV_STREAM_MANAGEMENT, crate::clusters::defs::CLUSTER_CAMERA_AV_STREAM_MANAGEMENT_ATTR_ID_MICROPHONEMINLEVEL).await?;
    decode_microphone_min_level(&tlv)
}

/// Read `MicrophoneAGCEnabled` attribute from cluster `Camera AV Stream Management`.
pub async fn read_microphone_agc_enabled(conn: &crate::controller::Connection, endpoint: u16) -> anyhow::Result<bool> {
    let tlv = conn.read_request2(endpoint, crate::clusters::defs::CLUSTER_ID_CAMERA_AV_STREAM_MANAGEMENT, crate::clusters::defs::CLUSTER_CAMERA_AV_STREAM_MANAGEMENT_ATTR_ID_MICROPHONEAGCENABLED).await?;
    decode_microphone_agc_enabled(&tlv)
}

/// Read `ImageRotation` attribute from cluster `Camera AV Stream Management`.
pub async fn read_image_rotation(conn: &crate::controller::Connection, endpoint: u16) -> anyhow::Result<u16> {
    let tlv = conn.read_request2(endpoint, crate::clusters::defs::CLUSTER_ID_CAMERA_AV_STREAM_MANAGEMENT, crate::clusters::defs::CLUSTER_CAMERA_AV_STREAM_MANAGEMENT_ATTR_ID_IMAGEROTATION).await?;
    decode_image_rotation(&tlv)
}

/// Read `ImageFlipHorizontal` attribute from cluster `Camera AV Stream Management`.
pub async fn read_image_flip_horizontal(conn: &crate::controller::Connection, endpoint: u16) -> anyhow::Result<bool> {
    let tlv = conn.read_request2(endpoint, crate::clusters::defs::CLUSTER_ID_CAMERA_AV_STREAM_MANAGEMENT, crate::clusters::defs::CLUSTER_CAMERA_AV_STREAM_MANAGEMENT_ATTR_ID_IMAGEFLIPHORIZONTAL).await?;
    decode_image_flip_horizontal(&tlv)
}

/// Read `ImageFlipVertical` attribute from cluster `Camera AV Stream Management`.
pub async fn read_image_flip_vertical(conn: &crate::controller::Connection, endpoint: u16) -> anyhow::Result<bool> {
    let tlv = conn.read_request2(endpoint, crate::clusters::defs::CLUSTER_ID_CAMERA_AV_STREAM_MANAGEMENT, crate::clusters::defs::CLUSTER_CAMERA_AV_STREAM_MANAGEMENT_ATTR_ID_IMAGEFLIPVERTICAL).await?;
    decode_image_flip_vertical(&tlv)
}

/// Read `LocalVideoRecordingEnabled` attribute from cluster `Camera AV Stream Management`.
pub async fn read_local_video_recording_enabled(conn: &crate::controller::Connection, endpoint: u16) -> anyhow::Result<bool> {
    let tlv = conn.read_request2(endpoint, crate::clusters::defs::CLUSTER_ID_CAMERA_AV_STREAM_MANAGEMENT, crate::clusters::defs::CLUSTER_CAMERA_AV_STREAM_MANAGEMENT_ATTR_ID_LOCALVIDEORECORDINGENABLED).await?;
    decode_local_video_recording_enabled(&tlv)
}

/// Read `LocalSnapshotRecordingEnabled` attribute from cluster `Camera AV Stream Management`.
pub async fn read_local_snapshot_recording_enabled(conn: &crate::controller::Connection, endpoint: u16) -> anyhow::Result<bool> {
    let tlv = conn.read_request2(endpoint, crate::clusters::defs::CLUSTER_ID_CAMERA_AV_STREAM_MANAGEMENT, crate::clusters::defs::CLUSTER_CAMERA_AV_STREAM_MANAGEMENT_ATTR_ID_LOCALSNAPSHOTRECORDINGENABLED).await?;
    decode_local_snapshot_recording_enabled(&tlv)
}

/// Read `StatusLightEnabled` attribute from cluster `Camera AV Stream Management`.
pub async fn read_status_light_enabled(conn: &crate::controller::Connection, endpoint: u16) -> anyhow::Result<bool> {
    let tlv = conn.read_request2(endpoint, crate::clusters::defs::CLUSTER_ID_CAMERA_AV_STREAM_MANAGEMENT, crate::clusters::defs::CLUSTER_CAMERA_AV_STREAM_MANAGEMENT_ATTR_ID_STATUSLIGHTENABLED).await?;
    decode_status_light_enabled(&tlv)
}

/// Read `StatusLightBrightness` attribute from cluster `Camera AV Stream Management`.
pub async fn read_status_light_brightness(conn: &crate::controller::Connection, endpoint: u16) -> anyhow::Result<u8> {
    let tlv = conn.read_request2(endpoint, crate::clusters::defs::CLUSTER_ID_CAMERA_AV_STREAM_MANAGEMENT, crate::clusters::defs::CLUSTER_CAMERA_AV_STREAM_MANAGEMENT_ATTR_ID_STATUSLIGHTBRIGHTNESS).await?;
    decode_status_light_brightness(&tlv)
}

/// Read `ImageRotationDiscreteAngles` attribute from cluster `Camera AV Stream Management`.
pub async fn read_image_rotation_discrete_angles(conn: &crate::controller::Connection, endpoint: u16) -> anyhow::Result<u16> {
    let tlv = conn.read_request2(endpoint, crate::clusters::defs::CLUSTER_ID_CAMERA_AV_STREAM_MANAGEMENT, crate::clusters::defs::CLUSTER_CAMERA_AV_STREAM_MANAGEMENT_ATTR_ID_IMAGEROTATIONDISCRETEANGLES).await?;
    decode_image_rotation_discrete_angles(&tlv)
}