matter-clusters 0.3.0

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

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

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

/// Cluster ID.
pub const CLUSTER_ID: u32 = 0x0200;
/// Cluster revision.
pub const CLUSTER_REVISION: u16 = 5;

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

/// Attribute IDs (cluster-specific).
pub mod attribute_id {
    /// `MaxPressure`.
    pub const MAX_PRESSURE: u32 = 0x0000;
    /// `MaxSpeed`.
    pub const MAX_SPEED: u32 = 0x0001;
    /// `MaxFlow`.
    pub const MAX_FLOW: u32 = 0x0002;
    /// `MinConstPressure`.
    pub const MIN_CONST_PRESSURE: u32 = 0x0003;
    /// `MaxConstPressure`.
    pub const MAX_CONST_PRESSURE: u32 = 0x0004;
    /// `MinCompPressure`.
    pub const MIN_COMP_PRESSURE: u32 = 0x0005;
    /// `MaxCompPressure`.
    pub const MAX_COMP_PRESSURE: u32 = 0x0006;
    /// `MinConstSpeed`.
    pub const MIN_CONST_SPEED: u32 = 0x0007;
    /// `MaxConstSpeed`.
    pub const MAX_CONST_SPEED: u32 = 0x0008;
    /// `MinConstFlow`.
    pub const MIN_CONST_FLOW: u32 = 0x0009;
    /// `MaxConstFlow`.
    pub const MAX_CONST_FLOW: u32 = 0x000A;
    /// `MinConstTemp`.
    pub const MIN_CONST_TEMP: u32 = 0x000B;
    /// `MaxConstTemp`.
    pub const MAX_CONST_TEMP: u32 = 0x000C;
    /// `PumpStatus`.
    pub const PUMP_STATUS: u32 = 0x0010;
    /// `EffectiveOperationMode`.
    pub const EFFECTIVE_OPERATION_MODE: u32 = 0x0011;
    /// `EffectiveControlMode`.
    pub const EFFECTIVE_CONTROL_MODE: u32 = 0x0012;
    /// `Capacity`.
    pub const CAPACITY: u32 = 0x0013;
    /// `Speed`.
    pub const SPEED: u32 = 0x0014;
    /// `LifetimeRunningHours`.
    pub const LIFETIME_RUNNING_HOURS: u32 = 0x0015;
    /// `Power`.
    pub const POWER: u32 = 0x0016;
    /// `LifetimeEnergyConsumed`.
    pub const LIFETIME_ENERGY_CONSUMED: u32 = 0x0017;
    /// `OperationMode`.
    pub const OPERATION_MODE: u32 = 0x0020;
    /// `ControlMode`.
    pub const CONTROL_MODE: u32 = 0x0021;
}

bitflags::bitflags! {
    /// `PumpConfigurationAndControl` feature bits (FeatureMap).
    #[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
    pub struct Feature: u32 {
        /// ConstantPressure (PRSCONST).
        const PRSCONST = 1 << 0;
        /// CompensatedPressure (PRSCOMP).
        const PRSCOMP = 1 << 1;
        /// ConstantFlow (FLW).
        const FLW = 1 << 2;
        /// ConstantSpeed (SPD).
        const SPD = 1 << 3;
        /// ConstantTemperature (TEMP).
        const TEMP = 1 << 4;
        /// Automatic (AUTO).
        const AUTO = 1 << 5;
        /// LocalOperation (LOCAL).
        const LOCAL = 1 << 6;
    }
}

/// `ControlModeEnum` (enum8).
#[derive(Copy, Clone, Debug, PartialEq, Eq)]
pub enum ControlModeEnum {
    /// ConstantSpeed = 0.
    ConstantSpeed,
    /// ConstantPressure = 1.
    ConstantPressure,
    /// ProportionalPressure = 2.
    ProportionalPressure,
    /// ConstantFlow = 3.
    ConstantFlow,
    /// ConstantTemperature = 5.
    ConstantTemperature,
    /// Automatic = 7.
    Automatic,
    /// A value not known to this codegen revision.
    Unknown(u8),
}

impl ControlModeEnum {
    /// Decode from its raw discriminant (unknown → `Unknown`).
    #[must_use]
    pub fn from_raw(v: u8) -> Self {
        match v {
            0 => Self::ConstantSpeed,
            1 => Self::ConstantPressure,
            2 => Self::ProportionalPressure,
            3 => Self::ConstantFlow,
            5 => Self::ConstantTemperature,
            7 => Self::Automatic,
            other => Self::Unknown(other),
        }
    }
    /// The raw discriminant.
    #[must_use]
    pub fn to_raw(self) -> u8 {
        match self {
            Self::ConstantSpeed => 0,
            Self::ConstantPressure => 1,
            Self::ProportionalPressure => 2,
            Self::ConstantFlow => 3,
            Self::ConstantTemperature => 5,
            Self::Automatic => 7,
            Self::Unknown(v) => v,
        }
    }
}

/// `OperationModeEnum` (enum8).
#[derive(Copy, Clone, Debug, PartialEq, Eq)]
pub enum OperationModeEnum {
    /// Normal = 0.
    Normal,
    /// Minimum = 1.
    Minimum,
    /// Maximum = 2.
    Maximum,
    /// Local = 3.
    Local,
    /// A value not known to this codegen revision.
    Unknown(u8),
}

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

bitflags::bitflags! {
    /// `PumpStatusBitmap` (map16).
    #[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
    pub struct PumpStatusBitmap: u16 {
        /// DeviceFault.
        const DEVICE_FAULT = 1 << 0;
        /// SupplyFault.
        const SUPPLY_FAULT = 1 << 1;
        /// SpeedLow.
        const SPEED_LOW = 1 << 2;
        /// SpeedHigh.
        const SPEED_HIGH = 1 << 3;
        /// LocalOverride.
        const LOCAL_OVERRIDE = 1 << 4;
        /// Running.
        const RUNNING = 1 << 5;
        /// RemotePressure.
        const REMOTE_PRESSURE = 1 << 6;
        /// RemoteFlow.
        const REMOTE_FLOW = 1 << 7;
        /// RemoteTemperature.
        const REMOTE_TEMPERATURE = 1 << 8;
    }
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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