matc 0.1.3

//! Matter TLV encoders and decoders for Camera AV Settings User Level Management Cluster
//! Cluster ID: 0x0552
//!
//! This file is automatically generated from CameraAVSettingsUserLevelManagement.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 PhysicalMovement {
    /// The camera is idle.
    Idle = 0,
    /// The camera is moving to a new value of Pan, Tilt, and/or Zoom.
    Moving = 1,
}

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

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

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

// Struct definitions

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

#[derive(Debug, serde::Serialize)]
pub struct MPTZPreset {
    pub preset_id: Option<u8>,
    pub name: Option<String>,
    pub settings: Option<MPTZ>,
}

#[derive(Debug, serde::Serialize)]
pub struct MPTZ {
    pub pan: Option<i16>,
    pub tilt: Option<i16>,
    pub zoom: Option<u8>,
}

// Command encoders

/// Encode MPTZSetPosition command (0x00)
pub fn encode_mptz_set_position(pan: Option<i16>, tilt: Option<i16>, zoom: Option<u8>) -> anyhow::Result<Vec<u8>> {
    let mut tlv_fields: Vec<tlv::TlvItemEnc> = Vec::new();
    if let Some(x) = pan { tlv_fields.push((0, tlv::TlvItemValueEnc::Int16(x)).into()); }
    if let Some(x) = tilt { tlv_fields.push((1, tlv::TlvItemValueEnc::Int16(x)).into()); }
    if let Some(x) = zoom { tlv_fields.push((2, tlv::TlvItemValueEnc::UInt8(x)).into()); }
    let tlv = tlv::TlvItemEnc {
        tag: 0,
        value: tlv::TlvItemValueEnc::StructInvisible(tlv_fields),
    };
    Ok(tlv.encode()?)
}

/// Encode MPTZRelativeMove command (0x01)
pub fn encode_mptz_relative_move(pan_delta: Option<i16>, tilt_delta: Option<i16>, zoom_delta: Option<i8>) -> anyhow::Result<Vec<u8>> {
    let mut tlv_fields: Vec<tlv::TlvItemEnc> = Vec::new();
    if let Some(x) = pan_delta { tlv_fields.push((0, tlv::TlvItemValueEnc::Int16(x)).into()); }
    if let Some(x) = tilt_delta { tlv_fields.push((1, tlv::TlvItemValueEnc::Int16(x)).into()); }
    if let Some(x) = zoom_delta { tlv_fields.push((2, tlv::TlvItemValueEnc::Int8(x)).into()); }
    let tlv = tlv::TlvItemEnc {
        tag: 0,
        value: tlv::TlvItemValueEnc::StructInvisible(tlv_fields),
    };
    Ok(tlv.encode()?)
}

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

/// Encode MPTZSavePreset command (0x03)
pub fn encode_mptz_save_preset(preset_id: Option<u8>, name: String) -> anyhow::Result<Vec<u8>> {
    let mut tlv_fields: Vec<tlv::TlvItemEnc> = Vec::new();
    if let Some(x) = preset_id { tlv_fields.push((0, tlv::TlvItemValueEnc::UInt8(x)).into()); }
    tlv_fields.push((1, tlv::TlvItemValueEnc::String(name)).into());
    let tlv = tlv::TlvItemEnc {
        tag: 0,
        value: tlv::TlvItemValueEnc::StructInvisible(tlv_fields),
    };
    Ok(tlv.encode()?)
}

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

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

/// Encode DPTZRelativeMove command (0x06)
pub fn encode_dptz_relative_move(video_stream_id: u8, delta_x: Option<i16>, delta_y: Option<i16>, zoom_delta: Option<i8>) -> anyhow::Result<Vec<u8>> {
    let mut tlv_fields: Vec<tlv::TlvItemEnc> = Vec::new();
    tlv_fields.push((0, tlv::TlvItemValueEnc::UInt8(video_stream_id)).into());
    if let Some(x) = delta_x { tlv_fields.push((1, tlv::TlvItemValueEnc::Int16(x)).into()); }
    if let Some(x) = delta_y { tlv_fields.push((2, tlv::TlvItemValueEnc::Int16(x)).into()); }
    if let Some(x) = zoom_delta { tlv_fields.push((3, tlv::TlvItemValueEnc::Int8(x)).into()); }
    let tlv = tlv::TlvItemEnc {
        tag: 0,
        value: tlv::TlvItemValueEnc::StructInvisible(tlv_fields),
    };
    Ok(tlv.encode()?)
}

// Attribute decoders

/// Decode MPTZPosition attribute (0x0000)
pub fn decode_mptz_position(inp: &tlv::TlvItemValue) -> anyhow::Result<MPTZ> {
    if let tlv::TlvItemValue::List(_fields) = inp {
        // Struct with fields
        let item = tlv::TlvItem { tag: 0, value: inp.clone() };
        Ok(MPTZ {
                pan: item.get_int(&[0]).map(|v| v as i16),
                tilt: item.get_int(&[1]).map(|v| v as i16),
                zoom: item.get_int(&[2]).map(|v| v as u8),
        })
    } else {
        Err(anyhow::anyhow!("Expected struct fields"))
    }
}

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

/// Decode MPTZPresets attribute (0x0002)
pub fn decode_mptz_presets(inp: &tlv::TlvItemValue) -> anyhow::Result<Vec<MPTZPreset>> {
    let mut res = Vec::new();
    if let tlv::TlvItemValue::List(v) = inp {
        for item in v {
            res.push(MPTZPreset {
                preset_id: item.get_int(&[0]).map(|v| v as u8),
                name: item.get_string_owned(&[1]),
                settings: {
                    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(MPTZ {
                pan: nested_item.get_int(&[0]).map(|v| v as i16),
                tilt: nested_item.get_int(&[1]).map(|v| v as i16),
                zoom: nested_item.get_int(&[2]).map(|v| v as u8),
                            })
                        } else {
                            None
                        }
                    } else {
                        None
                    }
                },
            });
        }
    }
    Ok(res)
}

/// Decode DPTZStreams attribute (0x0003)
pub fn decode_dptz_streams(inp: &tlv::TlvItemValue) -> anyhow::Result<Vec<DPTZ>> {
    let mut res = Vec::new();
    if let tlv::TlvItemValue::List(v) = inp {
        for item in v {
            res.push(DPTZ {
                video_stream_id: item.get_int(&[0]).map(|v| v as u8),
            });
        }
    }
    Ok(res)
}

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

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

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

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

/// Decode PanMax attribute (0x0008)
pub fn decode_pan_max(inp: &tlv::TlvItemValue) -> anyhow::Result<i16> {
    if let tlv::TlvItemValue::Int(v) = inp {
        Ok(*v as i16)
    } else {
        Err(anyhow::anyhow!("Expected Int16"))
    }
}

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


// 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 != 0x0552 {
        return format!("{{\"error\": \"Invalid cluster ID. Expected 0x0552, got {}\"}}", cluster_id);
    }

    match attribute_id {
        0x0000 => {
            match decode_mptz_position(tlv_value) {
                Ok(value) => serde_json::to_string(&value).unwrap_or_else(|_| "null".to_string()),
                Err(e) => format!("{{\"error\": \"{}\"}}", e),
            }
        }
        0x0001 => {
            match decode_max_presets(tlv_value) {
                Ok(value) => serde_json::to_string(&value).unwrap_or_else(|_| "null".to_string()),
                Err(e) => format!("{{\"error\": \"{}\"}}", e),
            }
        }
        0x0002 => {
            match decode_mptz_presets(tlv_value) {
                Ok(value) => serde_json::to_string(&value).unwrap_or_else(|_| "null".to_string()),
                Err(e) => format!("{{\"error\": \"{}\"}}", e),
            }
        }
        0x0003 => {
            match decode_dptz_streams(tlv_value) {
                Ok(value) => serde_json::to_string(&value).unwrap_or_else(|_| "null".to_string()),
                Err(e) => format!("{{\"error\": \"{}\"}}", e),
            }
        }
        0x0004 => {
            match decode_zoom_max(tlv_value) {
                Ok(value) => serde_json::to_string(&value).unwrap_or_else(|_| "null".to_string()),
                Err(e) => format!("{{\"error\": \"{}\"}}", e),
            }
        }
        0x0005 => {
            match decode_tilt_min(tlv_value) {
                Ok(value) => serde_json::to_string(&value).unwrap_or_else(|_| "null".to_string()),
                Err(e) => format!("{{\"error\": \"{}\"}}", e),
            }
        }
        0x0006 => {
            match decode_tilt_max(tlv_value) {
                Ok(value) => serde_json::to_string(&value).unwrap_or_else(|_| "null".to_string()),
                Err(e) => format!("{{\"error\": \"{}\"}}", e),
            }
        }
        0x0007 => {
            match decode_pan_min(tlv_value) {
                Ok(value) => serde_json::to_string(&value).unwrap_or_else(|_| "null".to_string()),
                Err(e) => format!("{{\"error\": \"{}\"}}", e),
            }
        }
        0x0008 => {
            match decode_pan_max(tlv_value) {
                Ok(value) => serde_json::to_string(&value).unwrap_or_else(|_| "null".to_string()),
                Err(e) => format!("{{\"error\": \"{}\"}}", e),
            }
        }
        0x0009 => {
            match decode_movement_state(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, "MPTZPosition"),
        (0x0001, "MaxPresets"),
        (0x0002, "MPTZPresets"),
        (0x0003, "DPTZStreams"),
        (0x0004, "ZoomMax"),
        (0x0005, "TiltMin"),
        (0x0006, "TiltMax"),
        (0x0007, "PanMin"),
        (0x0008, "PanMax"),
        (0x0009, "MovementState"),
    ]
}

// Command listing

pub fn get_command_list() -> Vec<(u32, &'static str)> {
    vec![
        (0x00, "MPTZSetPosition"),
        (0x01, "MPTZRelativeMove"),
        (0x02, "MPTZMoveToPreset"),
        (0x03, "MPTZSavePreset"),
        (0x04, "MPTZRemovePreset"),
        (0x05, "DPTZSetViewport"),
        (0x06, "DPTZRelativeMove"),
    ]
}

pub fn get_command_name(cmd_id: u32) -> Option<&'static str> {
    match cmd_id {
        0x00 => Some("MPTZSetPosition"),
        0x01 => Some("MPTZRelativeMove"),
        0x02 => Some("MPTZMoveToPreset"),
        0x03 => Some("MPTZSavePreset"),
        0x04 => Some("MPTZRemovePreset"),
        0x05 => Some("DPTZSetViewport"),
        0x06 => Some("DPTZRelativeMove"),
        _ => 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: "pan", kind: crate::clusters::codec::FieldKind::I16, optional: true, nullable: false },
            crate::clusters::codec::CommandField { tag: 1, name: "tilt", kind: crate::clusters::codec::FieldKind::I16, optional: true, nullable: false },
            crate::clusters::codec::CommandField { tag: 2, name: "zoom", kind: crate::clusters::codec::FieldKind::U8, optional: true, nullable: false },
        ]),
        0x01 => Some(vec![
            crate::clusters::codec::CommandField { tag: 0, name: "pan_delta", kind: crate::clusters::codec::FieldKind::I16, optional: true, nullable: false },
            crate::clusters::codec::CommandField { tag: 1, name: "tilt_delta", kind: crate::clusters::codec::FieldKind::I16, optional: true, nullable: false },
            crate::clusters::codec::CommandField { tag: 2, name: "zoom_delta", kind: crate::clusters::codec::FieldKind::I8, optional: true, nullable: false },
        ]),
        0x02 => Some(vec![
            crate::clusters::codec::CommandField { tag: 0, name: "preset_id", kind: crate::clusters::codec::FieldKind::U8, optional: false, nullable: false },
        ]),
        0x03 => Some(vec![
            crate::clusters::codec::CommandField { tag: 0, name: "preset_id", kind: crate::clusters::codec::FieldKind::U8, optional: true, nullable: false },
            crate::clusters::codec::CommandField { tag: 1, name: "name", kind: crate::clusters::codec::FieldKind::String, optional: false, nullable: false },
        ]),
        0x04 => Some(vec![
            crate::clusters::codec::CommandField { tag: 0, name: "preset_id", kind: crate::clusters::codec::FieldKind::U8, optional: false, nullable: false },
        ]),
        0x05 => Some(vec![
            crate::clusters::codec::CommandField { tag: 0, name: "video_stream_id", kind: crate::clusters::codec::FieldKind::U32, optional: false, nullable: false },
        ]),
        0x06 => Some(vec![
            crate::clusters::codec::CommandField { tag: 0, name: "video_stream_id", kind: crate::clusters::codec::FieldKind::U32, optional: false, nullable: false },
            crate::clusters::codec::CommandField { tag: 1, name: "delta_x", kind: crate::clusters::codec::FieldKind::I16, optional: true, nullable: false },
            crate::clusters::codec::CommandField { tag: 2, name: "delta_y", kind: crate::clusters::codec::FieldKind::I16, optional: true, nullable: false },
            crate::clusters::codec::CommandField { tag: 3, name: "zoom_delta", kind: crate::clusters::codec::FieldKind::I8, optional: true, nullable: false },
        ]),
        _ => None,
    }
}

pub fn encode_command_json(cmd_id: u32, args: &serde_json::Value) -> anyhow::Result<Vec<u8>> {
    match cmd_id {
        0x00 => {
        let pan = crate::clusters::codec::json_util::get_opt_i16(args, "pan")?;
        let tilt = crate::clusters::codec::json_util::get_opt_i16(args, "tilt")?;
        let zoom = crate::clusters::codec::json_util::get_opt_u8(args, "zoom")?;
        encode_mptz_set_position(pan, tilt, zoom)
        }
        0x01 => {
        let pan_delta = crate::clusters::codec::json_util::get_opt_i16(args, "pan_delta")?;
        let tilt_delta = crate::clusters::codec::json_util::get_opt_i16(args, "tilt_delta")?;
        let zoom_delta = crate::clusters::codec::json_util::get_opt_i8(args, "zoom_delta")?;
        encode_mptz_relative_move(pan_delta, tilt_delta, zoom_delta)
        }
        0x02 => {
        let preset_id = crate::clusters::codec::json_util::get_u8(args, "preset_id")?;
        encode_mptz_move_to_preset(preset_id)
        }
        0x03 => {
        let preset_id = crate::clusters::codec::json_util::get_opt_u8(args, "preset_id")?;
        let name = crate::clusters::codec::json_util::get_string(args, "name")?;
        encode_mptz_save_preset(preset_id, name)
        }
        0x04 => {
        let preset_id = crate::clusters::codec::json_util::get_u8(args, "preset_id")?;
        encode_mptz_remove_preset(preset_id)
        }
        0x05 => {
        let video_stream_id = crate::clusters::codec::json_util::get_u8(args, "video_stream_id")?;
        encode_dptz_set_viewport(video_stream_id)
        }
        0x06 => {
        let video_stream_id = crate::clusters::codec::json_util::get_u8(args, "video_stream_id")?;
        let delta_x = crate::clusters::codec::json_util::get_opt_i16(args, "delta_x")?;
        let delta_y = crate::clusters::codec::json_util::get_opt_i16(args, "delta_y")?;
        let zoom_delta = crate::clusters::codec::json_util::get_opt_i8(args, "zoom_delta")?;
        encode_dptz_relative_move(video_stream_id, delta_x, delta_y, zoom_delta)
        }
        _ => Err(anyhow::anyhow!("unknown command ID: 0x{:02X}", cmd_id)),
    }
}

// Typed facade (invokes + reads)

/// Invoke `MPTZSetPosition` command on cluster `Camera AV Settings User Level Management`.
pub async fn mptz_set_position(conn: &crate::controller::Connection, endpoint: u16, pan: Option<i16>, tilt: Option<i16>, zoom: Option<u8>) -> anyhow::Result<()> {
    conn.invoke_request(endpoint, crate::clusters::defs::CLUSTER_ID_CAMERA_AV_SETTINGS_USER_LEVEL_MANAGEMENT, crate::clusters::defs::CLUSTER_CAMERA_AV_SETTINGS_USER_LEVEL_MANAGEMENT_CMD_ID_MPTZSETPOSITION, &encode_mptz_set_position(pan, tilt, zoom)?).await?;
    Ok(())
}

/// Invoke `MPTZRelativeMove` command on cluster `Camera AV Settings User Level Management`.
pub async fn mptz_relative_move(conn: &crate::controller::Connection, endpoint: u16, pan_delta: Option<i16>, tilt_delta: Option<i16>, zoom_delta: Option<i8>) -> anyhow::Result<()> {
    conn.invoke_request(endpoint, crate::clusters::defs::CLUSTER_ID_CAMERA_AV_SETTINGS_USER_LEVEL_MANAGEMENT, crate::clusters::defs::CLUSTER_CAMERA_AV_SETTINGS_USER_LEVEL_MANAGEMENT_CMD_ID_MPTZRELATIVEMOVE, &encode_mptz_relative_move(pan_delta, tilt_delta, zoom_delta)?).await?;
    Ok(())
}

/// Invoke `MPTZMoveToPreset` command on cluster `Camera AV Settings User Level Management`.
pub async fn mptz_move_to_preset(conn: &crate::controller::Connection, endpoint: u16, preset_id: u8) -> anyhow::Result<()> {
    conn.invoke_request(endpoint, crate::clusters::defs::CLUSTER_ID_CAMERA_AV_SETTINGS_USER_LEVEL_MANAGEMENT, crate::clusters::defs::CLUSTER_CAMERA_AV_SETTINGS_USER_LEVEL_MANAGEMENT_CMD_ID_MPTZMOVETOPRESET, &encode_mptz_move_to_preset(preset_id)?).await?;
    Ok(())
}

/// Invoke `MPTZSavePreset` command on cluster `Camera AV Settings User Level Management`.
pub async fn mptz_save_preset(conn: &crate::controller::Connection, endpoint: u16, preset_id: Option<u8>, name: String) -> anyhow::Result<()> {
    conn.invoke_request(endpoint, crate::clusters::defs::CLUSTER_ID_CAMERA_AV_SETTINGS_USER_LEVEL_MANAGEMENT, crate::clusters::defs::CLUSTER_CAMERA_AV_SETTINGS_USER_LEVEL_MANAGEMENT_CMD_ID_MPTZSAVEPRESET, &encode_mptz_save_preset(preset_id, name)?).await?;
    Ok(())
}

/// Invoke `MPTZRemovePreset` command on cluster `Camera AV Settings User Level Management`.
pub async fn mptz_remove_preset(conn: &crate::controller::Connection, endpoint: u16, preset_id: u8) -> anyhow::Result<()> {
    conn.invoke_request(endpoint, crate::clusters::defs::CLUSTER_ID_CAMERA_AV_SETTINGS_USER_LEVEL_MANAGEMENT, crate::clusters::defs::CLUSTER_CAMERA_AV_SETTINGS_USER_LEVEL_MANAGEMENT_CMD_ID_MPTZREMOVEPRESET, &encode_mptz_remove_preset(preset_id)?).await?;
    Ok(())
}

/// Invoke `DPTZSetViewport` command on cluster `Camera AV Settings User Level Management`.
pub async fn dptz_set_viewport(conn: &crate::controller::Connection, endpoint: u16, video_stream_id: u8) -> anyhow::Result<()> {
    conn.invoke_request(endpoint, crate::clusters::defs::CLUSTER_ID_CAMERA_AV_SETTINGS_USER_LEVEL_MANAGEMENT, crate::clusters::defs::CLUSTER_CAMERA_AV_SETTINGS_USER_LEVEL_MANAGEMENT_CMD_ID_DPTZSETVIEWPORT, &encode_dptz_set_viewport(video_stream_id)?).await?;
    Ok(())
}

/// Invoke `DPTZRelativeMove` command on cluster `Camera AV Settings User Level Management`.
pub async fn dptz_relative_move(conn: &crate::controller::Connection, endpoint: u16, video_stream_id: u8, delta_x: Option<i16>, delta_y: Option<i16>, zoom_delta: Option<i8>) -> anyhow::Result<()> {
    conn.invoke_request(endpoint, crate::clusters::defs::CLUSTER_ID_CAMERA_AV_SETTINGS_USER_LEVEL_MANAGEMENT, crate::clusters::defs::CLUSTER_CAMERA_AV_SETTINGS_USER_LEVEL_MANAGEMENT_CMD_ID_DPTZRELATIVEMOVE, &encode_dptz_relative_move(video_stream_id, delta_x, delta_y, zoom_delta)?).await?;
    Ok(())
}

/// Read `MPTZPosition` attribute from cluster `Camera AV Settings User Level Management`.
pub async fn read_mptz_position(conn: &crate::controller::Connection, endpoint: u16) -> anyhow::Result<MPTZ> {
    let tlv = conn.read_request2(endpoint, crate::clusters::defs::CLUSTER_ID_CAMERA_AV_SETTINGS_USER_LEVEL_MANAGEMENT, crate::clusters::defs::CLUSTER_CAMERA_AV_SETTINGS_USER_LEVEL_MANAGEMENT_ATTR_ID_MPTZPOSITION).await?;
    decode_mptz_position(&tlv)
}

/// Read `MaxPresets` attribute from cluster `Camera AV Settings User Level Management`.
pub async fn read_max_presets(conn: &crate::controller::Connection, endpoint: u16) -> anyhow::Result<u8> {
    let tlv = conn.read_request2(endpoint, crate::clusters::defs::CLUSTER_ID_CAMERA_AV_SETTINGS_USER_LEVEL_MANAGEMENT, crate::clusters::defs::CLUSTER_CAMERA_AV_SETTINGS_USER_LEVEL_MANAGEMENT_ATTR_ID_MAXPRESETS).await?;
    decode_max_presets(&tlv)
}

/// Read `MPTZPresets` attribute from cluster `Camera AV Settings User Level Management`.
pub async fn read_mptz_presets(conn: &crate::controller::Connection, endpoint: u16) -> anyhow::Result<Vec<MPTZPreset>> {
    let tlv = conn.read_request2(endpoint, crate::clusters::defs::CLUSTER_ID_CAMERA_AV_SETTINGS_USER_LEVEL_MANAGEMENT, crate::clusters::defs::CLUSTER_CAMERA_AV_SETTINGS_USER_LEVEL_MANAGEMENT_ATTR_ID_MPTZPRESETS).await?;
    decode_mptz_presets(&tlv)
}

/// Read `DPTZStreams` attribute from cluster `Camera AV Settings User Level Management`.
pub async fn read_dptz_streams(conn: &crate::controller::Connection, endpoint: u16) -> anyhow::Result<Vec<DPTZ>> {
    let tlv = conn.read_request2(endpoint, crate::clusters::defs::CLUSTER_ID_CAMERA_AV_SETTINGS_USER_LEVEL_MANAGEMENT, crate::clusters::defs::CLUSTER_CAMERA_AV_SETTINGS_USER_LEVEL_MANAGEMENT_ATTR_ID_DPTZSTREAMS).await?;
    decode_dptz_streams(&tlv)
}

/// Read `ZoomMax` attribute from cluster `Camera AV Settings User Level Management`.
pub async fn read_zoom_max(conn: &crate::controller::Connection, endpoint: u16) -> anyhow::Result<u8> {
    let tlv = conn.read_request2(endpoint, crate::clusters::defs::CLUSTER_ID_CAMERA_AV_SETTINGS_USER_LEVEL_MANAGEMENT, crate::clusters::defs::CLUSTER_CAMERA_AV_SETTINGS_USER_LEVEL_MANAGEMENT_ATTR_ID_ZOOMMAX).await?;
    decode_zoom_max(&tlv)
}

/// Read `TiltMin` attribute from cluster `Camera AV Settings User Level Management`.
pub async fn read_tilt_min(conn: &crate::controller::Connection, endpoint: u16) -> anyhow::Result<i16> {
    let tlv = conn.read_request2(endpoint, crate::clusters::defs::CLUSTER_ID_CAMERA_AV_SETTINGS_USER_LEVEL_MANAGEMENT, crate::clusters::defs::CLUSTER_CAMERA_AV_SETTINGS_USER_LEVEL_MANAGEMENT_ATTR_ID_TILTMIN).await?;
    decode_tilt_min(&tlv)
}

/// Read `TiltMax` attribute from cluster `Camera AV Settings User Level Management`.
pub async fn read_tilt_max(conn: &crate::controller::Connection, endpoint: u16) -> anyhow::Result<i16> {
    let tlv = conn.read_request2(endpoint, crate::clusters::defs::CLUSTER_ID_CAMERA_AV_SETTINGS_USER_LEVEL_MANAGEMENT, crate::clusters::defs::CLUSTER_CAMERA_AV_SETTINGS_USER_LEVEL_MANAGEMENT_ATTR_ID_TILTMAX).await?;
    decode_tilt_max(&tlv)
}

/// Read `PanMin` attribute from cluster `Camera AV Settings User Level Management`.
pub async fn read_pan_min(conn: &crate::controller::Connection, endpoint: u16) -> anyhow::Result<i16> {
    let tlv = conn.read_request2(endpoint, crate::clusters::defs::CLUSTER_ID_CAMERA_AV_SETTINGS_USER_LEVEL_MANAGEMENT, crate::clusters::defs::CLUSTER_CAMERA_AV_SETTINGS_USER_LEVEL_MANAGEMENT_ATTR_ID_PANMIN).await?;
    decode_pan_min(&tlv)
}

/// Read `PanMax` attribute from cluster `Camera AV Settings User Level Management`.
pub async fn read_pan_max(conn: &crate::controller::Connection, endpoint: u16) -> anyhow::Result<i16> {
    let tlv = conn.read_request2(endpoint, crate::clusters::defs::CLUSTER_ID_CAMERA_AV_SETTINGS_USER_LEVEL_MANAGEMENT, crate::clusters::defs::CLUSTER_CAMERA_AV_SETTINGS_USER_LEVEL_MANAGEMENT_ATTR_ID_PANMAX).await?;
    decode_pan_max(&tlv)
}

/// Read `MovementState` attribute from cluster `Camera AV Settings User Level Management`.
pub async fn read_movement_state(conn: &crate::controller::Connection, endpoint: u16) -> anyhow::Result<PhysicalMovement> {
    let tlv = conn.read_request2(endpoint, crate::clusters::defs::CLUSTER_ID_CAMERA_AV_SETTINGS_USER_LEVEL_MANAGEMENT, crate::clusters::defs::CLUSTER_CAMERA_AV_SETTINGS_USER_LEVEL_MANAGEMENT_ATTR_ID_MOVEMENTSTATE).await?;
    decode_movement_state(&tlv)
}