use serde::Deserialize;
use serde::de::Unexpected;
use serde::de;
use serde::Deserializer;
use zigbee2mqtt_types_base_types::LastSeen;
/// namron:1402755 [zigbee2mqtt link](https://www.zigbee2mqtt.io/devices/1402755.html)
///
/// 
#[cfg_attr(feature = "debug", derive(Debug))]
#[cfg_attr(feature = "clone", derive(Clone))]
#[derive(Deserialize)]
pub struct Zigbee1402755 {
    ///Brightness of this light
    pub brightness: f64,
    ///Link quality (signal strength)
    pub linkquality: f64,
    ///Controls the behavior when the device is powered on after power loss
    pub power_on_behavior: Zigbee1402755Poweronbehavior,
    ///Zigbee herdsman description: "On/off state of this light"
    ///The string values get converted into boolean with: ON = true and OFF = false
    #[serde(deserialize_with = "zigbee1402755_state_deserializer")]
    pub state: bool,
    /// Optional last_seen type, set as a global zigbee2mqtt setting
    pub last_seen: Option<LastSeen>,
    /// Optional elapsed type
    pub elapsed: Option<u64>,
}
/// Deserialize bool from String with custom value mapping
fn zigbee1402755_state_deserializer<'de, D>(deserializer: D) -> Result<bool, D::Error>
where
    D: Deserializer<'de>,
{
    match String::deserialize(deserializer)?.as_ref() {
        "ON" => Ok(true),
        "OFF" => Ok(false),
        other => Err(de::Error::invalid_value(
            Unexpected::Str(other),
            &"Value expected was either ON or OFF",
        )),
    }
}

/// namron:3308431 [zigbee2mqtt link](https://www.zigbee2mqtt.io/devices/3308431.html)
///
/// 
#[cfg_attr(feature = "debug", derive(Debug))]
#[cfg_attr(feature = "clone", derive(Clone))]
#[derive(Deserialize)]
pub struct Zigbee3308431 {
    ///Brightness of this light
    pub brightness: f64,
    ///Color temperature of this light
    pub color_temp: f64,
    ///Color temperature after cold power on of this light
    pub color_temp_startup: f64,
    ///Link quality (signal strength)
    pub linkquality: f64,
    ///Controls the behavior when the device is powered on after power loss
    pub power_on_behavior: Zigbee3308431Poweronbehavior,
    ///Zigbee herdsman description: "On/off state of this light"
    ///The string values get converted into boolean with: ON = true and OFF = false
    #[serde(deserialize_with = "zigbee3308431_state_deserializer")]
    pub state: bool,
    /// Optional last_seen type, set as a global zigbee2mqtt setting
    pub last_seen: Option<LastSeen>,
    /// Optional elapsed type
    pub elapsed: Option<u64>,
}
/// Deserialize bool from String with custom value mapping
fn zigbee3308431_state_deserializer<'de, D>(deserializer: D) -> Result<bool, D::Error>
where
    D: Deserializer<'de>,
{
    match String::deserialize(deserializer)?.as_ref() {
        "ON" => Ok(true),
        "OFF" => Ok(false),
        other => Err(de::Error::invalid_value(
            Unexpected::Str(other),
            &"Value expected was either ON or OFF",
        )),
    }
}

/// namron:3802960 [zigbee2mqtt link](https://www.zigbee2mqtt.io/devices/3802960.html)
///
/// 
#[cfg_attr(feature = "debug", derive(Debug))]
#[cfg_attr(feature = "clone", derive(Clone))]
#[derive(Deserialize)]
pub struct Zigbee3802960 {
    ///Brightness of this light
    pub brightness: f64,
    ///Link quality (signal strength)
    pub linkquality: f64,
    ///Controls the behavior when the device is powered on after power loss
    pub power_on_behavior: Zigbee3802960Poweronbehavior,
    ///Zigbee herdsman description: "On/off state of this light"
    ///The string values get converted into boolean with: ON = true and OFF = false
    #[serde(deserialize_with = "zigbee3802960_state_deserializer")]
    pub state: bool,
    /// Optional last_seen type, set as a global zigbee2mqtt setting
    pub last_seen: Option<LastSeen>,
    /// Optional elapsed type
    pub elapsed: Option<u64>,
}
/// Deserialize bool from String with custom value mapping
fn zigbee3802960_state_deserializer<'de, D>(deserializer: D) -> Result<bool, D::Error>
where
    D: Deserializer<'de>,
{
    match String::deserialize(deserializer)?.as_ref() {
        "ON" => Ok(true),
        "OFF" => Ok(false),
        other => Err(de::Error::invalid_value(
            Unexpected::Str(other),
            &"Value expected was either ON or OFF",
        )),
    }
}

/// namron:3802961 [zigbee2mqtt link](https://www.zigbee2mqtt.io/devices/3802961.html)
///
/// 
#[cfg_attr(feature = "debug", derive(Debug))]
#[cfg_attr(feature = "clone", derive(Clone))]
#[derive(Deserialize)]
pub struct Zigbee3802961 {
    ///Brightness of this light
    pub brightness: f64,
    ///Color temperature of this light
    pub color_temp: f64,
    ///Color temperature after cold power on of this light
    pub color_temp_startup: f64,
    ///Link quality (signal strength)
    pub linkquality: f64,
    ///Controls the behavior when the device is powered on after power loss
    pub power_on_behavior: Zigbee3802961Poweronbehavior,
    ///Zigbee herdsman description: "On/off state of this light"
    ///The string values get converted into boolean with: ON = true and OFF = false
    #[serde(deserialize_with = "zigbee3802961_state_deserializer")]
    pub state: bool,
    /// Optional last_seen type, set as a global zigbee2mqtt setting
    pub last_seen: Option<LastSeen>,
    /// Optional elapsed type
    pub elapsed: Option<u64>,
}
/// Deserialize bool from String with custom value mapping
fn zigbee3802961_state_deserializer<'de, D>(deserializer: D) -> Result<bool, D::Error>
where
    D: Deserializer<'de>,
{
    match String::deserialize(deserializer)?.as_ref() {
        "ON" => Ok(true),
        "OFF" => Ok(false),
        other => Err(de::Error::invalid_value(
            Unexpected::Str(other),
            &"Value expected was either ON or OFF",
        )),
    }
}

/// namron:3802962 [zigbee2mqtt link](https://www.zigbee2mqtt.io/devices/3802962.html)
///
/// 
#[cfg_attr(feature = "debug", derive(Debug))]
#[cfg_attr(feature = "clone", derive(Clone))]
#[derive(Deserialize)]
pub struct Zigbee3802962 {
    ///Brightness of this light
    pub brightness: f64,
    ///Color temperature of this light
    pub color_temp: f64,
    ///Color temperature after cold power on of this light
    pub color_temp_startup: f64,
    ///Link quality (signal strength)
    pub linkquality: f64,
    ///Controls the behavior when the device is powered on after power loss
    pub power_on_behavior: Zigbee3802962Poweronbehavior,
    ///Zigbee herdsman description: "On/off state of this light"
    ///The string values get converted into boolean with: ON = true and OFF = false
    #[serde(deserialize_with = "zigbee3802962_state_deserializer")]
    pub state: bool,
    /// Optional last_seen type, set as a global zigbee2mqtt setting
    pub last_seen: Option<LastSeen>,
    /// Optional elapsed type
    pub elapsed: Option<u64>,
}
/// Deserialize bool from String with custom value mapping
fn zigbee3802962_state_deserializer<'de, D>(deserializer: D) -> Result<bool, D::Error>
where
    D: Deserializer<'de>,
{
    match String::deserialize(deserializer)?.as_ref() {
        "ON" => Ok(true),
        "OFF" => Ok(false),
        other => Err(de::Error::invalid_value(
            Unexpected::Str(other),
            &"Value expected was either ON or OFF",
        )),
    }
}

/// namron:3802963 [zigbee2mqtt link](https://www.zigbee2mqtt.io/devices/3802963.html)
///
/// 
#[cfg_attr(feature = "debug", derive(Debug))]
#[cfg_attr(feature = "clone", derive(Clone))]
#[derive(Deserialize)]
pub struct Zigbee3802963 {
    ///Brightness of this light
    pub brightness: f64,
    ///Link quality (signal strength)
    pub linkquality: f64,
    ///Controls the behavior when the device is powered on after power loss
    pub power_on_behavior: Zigbee3802963Poweronbehavior,
    ///Zigbee herdsman description: "On/off state of this light"
    ///The string values get converted into boolean with: ON = true and OFF = false
    #[serde(deserialize_with = "zigbee3802963_state_deserializer")]
    pub state: bool,
    /// Optional last_seen type, set as a global zigbee2mqtt setting
    pub last_seen: Option<LastSeen>,
    /// Optional elapsed type
    pub elapsed: Option<u64>,
}
/// Deserialize bool from String with custom value mapping
fn zigbee3802963_state_deserializer<'de, D>(deserializer: D) -> Result<bool, D::Error>
where
    D: Deserializer<'de>,
{
    match String::deserialize(deserializer)?.as_ref() {
        "ON" => Ok(true),
        "OFF" => Ok(false),
        other => Err(de::Error::invalid_value(
            Unexpected::Str(other),
            &"Value expected was either ON or OFF",
        )),
    }
}

/// namron:3802964 [zigbee2mqtt link](https://www.zigbee2mqtt.io/devices/3802964.html)
///
/// 
#[cfg_attr(feature = "debug", derive(Debug))]
#[cfg_attr(feature = "clone", derive(Clone))]
#[derive(Deserialize)]
pub struct Zigbee3802964 {
    ///Brightness of this light
    pub brightness: f64,
    ///Color temperature of this light
    pub color_temp: f64,
    ///Color temperature after cold power on of this light
    pub color_temp_startup: f64,
    ///Link quality (signal strength)
    pub linkquality: f64,
    ///Controls the behavior when the device is powered on after power loss
    pub power_on_behavior: Zigbee3802964Poweronbehavior,
    ///Zigbee herdsman description: "On/off state of this light"
    ///The string values get converted into boolean with: ON = true and OFF = false
    #[serde(deserialize_with = "zigbee3802964_state_deserializer")]
    pub state: bool,
    /// Optional last_seen type, set as a global zigbee2mqtt setting
    pub last_seen: Option<LastSeen>,
    /// Optional elapsed type
    pub elapsed: Option<u64>,
}
/// Deserialize bool from String with custom value mapping
fn zigbee3802964_state_deserializer<'de, D>(deserializer: D) -> Result<bool, D::Error>
where
    D: Deserializer<'de>,
{
    match String::deserialize(deserializer)?.as_ref() {
        "ON" => Ok(true),
        "OFF" => Ok(false),
        other => Err(de::Error::invalid_value(
            Unexpected::Str(other),
            &"Value expected was either ON or OFF",
        )),
    }
}

/// namron:3802965 [zigbee2mqtt link](https://www.zigbee2mqtt.io/devices/3802965.html)
///
/// 
#[cfg_attr(feature = "debug", derive(Debug))]
#[cfg_attr(feature = "clone", derive(Clone))]
#[derive(Deserialize)]
pub struct Zigbee3802965 {
    ///Brightness of this light
    pub brightness: f64,
    ///Link quality (signal strength)
    pub linkquality: f64,
    ///Controls the behavior when the device is powered on after power loss
    pub power_on_behavior: Zigbee3802965Poweronbehavior,
    ///Zigbee herdsman description: "On/off state of this light"
    ///The string values get converted into boolean with: ON = true and OFF = false
    #[serde(deserialize_with = "zigbee3802965_state_deserializer")]
    pub state: bool,
    /// Optional last_seen type, set as a global zigbee2mqtt setting
    pub last_seen: Option<LastSeen>,
    /// Optional elapsed type
    pub elapsed: Option<u64>,
}
/// Deserialize bool from String with custom value mapping
fn zigbee3802965_state_deserializer<'de, D>(deserializer: D) -> Result<bool, D::Error>
where
    D: Deserializer<'de>,
{
    match String::deserialize(deserializer)?.as_ref() {
        "ON" => Ok(true),
        "OFF" => Ok(false),
        other => Err(de::Error::invalid_value(
            Unexpected::Str(other),
            &"Value expected was either ON or OFF",
        )),
    }
}

/// namron:3802966 [zigbee2mqtt link](https://www.zigbee2mqtt.io/devices/3802966.html)
///
/// 
#[cfg_attr(feature = "debug", derive(Debug))]
#[cfg_attr(feature = "clone", derive(Clone))]
#[derive(Deserialize)]
pub struct Zigbee3802966 {
    ///Brightness of this light
    pub brightness: f64,
    ///Color temperature of this light
    pub color_temp: f64,
    ///Color temperature after cold power on of this light
    pub color_temp_startup: f64,
    ///Link quality (signal strength)
    pub linkquality: f64,
    ///Controls the behavior when the device is powered on after power loss
    pub power_on_behavior: Zigbee3802966Poweronbehavior,
    ///Zigbee herdsman description: "On/off state of this light"
    ///The string values get converted into boolean with: ON = true and OFF = false
    #[serde(deserialize_with = "zigbee3802966_state_deserializer")]
    pub state: bool,
    /// Optional last_seen type, set as a global zigbee2mqtt setting
    pub last_seen: Option<LastSeen>,
    /// Optional elapsed type
    pub elapsed: Option<u64>,
}
/// Deserialize bool from String with custom value mapping
fn zigbee3802966_state_deserializer<'de, D>(deserializer: D) -> Result<bool, D::Error>
where
    D: Deserializer<'de>,
{
    match String::deserialize(deserializer)?.as_ref() {
        "ON" => Ok(true),
        "OFF" => Ok(false),
        other => Err(de::Error::invalid_value(
            Unexpected::Str(other),
            &"Value expected was either ON or OFF",
        )),
    }
}

/// namron:3802967 [zigbee2mqtt link](https://www.zigbee2mqtt.io/devices/3802967.html)
///
/// 
#[cfg_attr(feature = "debug", derive(Debug))]
#[cfg_attr(feature = "clone", derive(Clone))]
#[derive(Deserialize)]
pub struct Zigbee3802967 {
    ///Brightness of this light
    pub brightness: f64,
    ///Color temperature of this light
    pub color_temp: f64,
    ///Color temperature after cold power on of this light
    pub color_temp_startup: f64,
    ///Link quality (signal strength)
    pub linkquality: f64,
    ///Controls the behavior when the device is powered on after power loss
    pub power_on_behavior: Zigbee3802967Poweronbehavior,
    ///Zigbee herdsman description: "On/off state of this light"
    ///The string values get converted into boolean with: ON = true and OFF = false
    #[serde(deserialize_with = "zigbee3802967_state_deserializer")]
    pub state: bool,
    /// Optional last_seen type, set as a global zigbee2mqtt setting
    pub last_seen: Option<LastSeen>,
    /// Optional elapsed type
    pub elapsed: Option<u64>,
}
/// Deserialize bool from String with custom value mapping
fn zigbee3802967_state_deserializer<'de, D>(deserializer: D) -> Result<bool, D::Error>
where
    D: Deserializer<'de>,
{
    match String::deserialize(deserializer)?.as_ref() {
        "ON" => Ok(true),
        "OFF" => Ok(false),
        other => Err(de::Error::invalid_value(
            Unexpected::Str(other),
            &"Value expected was either ON or OFF",
        )),
    }
}

/// namron:3802968 [zigbee2mqtt link](https://www.zigbee2mqtt.io/devices/3802968.html)
///
/// 
#[cfg_attr(feature = "debug", derive(Debug))]
#[cfg_attr(feature = "clone", derive(Clone))]
#[derive(Deserialize)]
pub struct Zigbee3802968 {
    ///Brightness of this light
    pub brightness: f64,
    ///Color temperature of this light
    pub color_temp: f64,
    ///Color temperature after cold power on of this light
    pub color_temp_startup: f64,
    ///Link quality (signal strength)
    pub linkquality: f64,
    ///Controls the behavior when the device is powered on after power loss
    pub power_on_behavior: Zigbee3802968Poweronbehavior,
    ///Zigbee herdsman description: "On/off state of this light"
    ///The string values get converted into boolean with: ON = true and OFF = false
    #[serde(deserialize_with = "zigbee3802968_state_deserializer")]
    pub state: bool,
    /// Optional last_seen type, set as a global zigbee2mqtt setting
    pub last_seen: Option<LastSeen>,
    /// Optional elapsed type
    pub elapsed: Option<u64>,
}
/// Deserialize bool from String with custom value mapping
fn zigbee3802968_state_deserializer<'de, D>(deserializer: D) -> Result<bool, D::Error>
where
    D: Deserializer<'de>,
{
    match String::deserialize(deserializer)?.as_ref() {
        "ON" => Ok(true),
        "OFF" => Ok(false),
        other => Err(de::Error::invalid_value(
            Unexpected::Str(other),
            &"Value expected was either ON or OFF",
        )),
    }
}

/// namron:4512700 [zigbee2mqtt link](https://www.zigbee2mqtt.io/devices/4512700.html)
///
/// 
#[cfg_attr(feature = "debug", derive(Debug))]
#[cfg_attr(feature = "clone", derive(Clone))]
#[derive(Deserialize)]
pub struct Zigbee4512700 {
    ///Brightness of this light
    pub brightness: f64,
    ///Link quality (signal strength)
    pub linkquality: f64,
    ///Controls the behavior when the device is powered on after power loss
    pub power_on_behavior: Zigbee4512700Poweronbehavior,
    ///Zigbee herdsman description: "On/off state of this light"
    ///The string values get converted into boolean with: ON = true and OFF = false
    #[serde(deserialize_with = "zigbee4512700_state_deserializer")]
    pub state: bool,
    /// Optional last_seen type, set as a global zigbee2mqtt setting
    pub last_seen: Option<LastSeen>,
    /// Optional elapsed type
    pub elapsed: Option<u64>,
}
/// Deserialize bool from String with custom value mapping
fn zigbee4512700_state_deserializer<'de, D>(deserializer: D) -> Result<bool, D::Error>
where
    D: Deserializer<'de>,
{
    match String::deserialize(deserializer)?.as_ref() {
        "ON" => Ok(true),
        "OFF" => Ok(false),
        other => Err(de::Error::invalid_value(
            Unexpected::Str(other),
            &"Value expected was either ON or OFF",
        )),
    }
}

/// namron:4512701 [zigbee2mqtt link](https://www.zigbee2mqtt.io/devices/4512701.html)
///
/// 
#[cfg_attr(feature = "debug", derive(Debug))]
#[cfg_attr(feature = "clone", derive(Clone))]
#[derive(Deserialize)]
pub struct Zigbee4512701 {
    ///Triggered action (e.g. a button click)
    pub action: Zigbee4512701Action,
    ///Remaining battery in %, can take up to 24 hours before reported.
    pub battery: f64,
    ///Link quality (signal strength)
    pub linkquality: f64,
    /// Optional last_seen type, set as a global zigbee2mqtt setting
    pub last_seen: Option<LastSeen>,
    /// Optional elapsed type
    pub elapsed: Option<u64>,
}/// namron:4512702 [zigbee2mqtt link](https://www.zigbee2mqtt.io/devices/4512702.html)
///
/// 
#[cfg_attr(feature = "debug", derive(Debug))]
#[cfg_attr(feature = "clone", derive(Clone))]
#[derive(Deserialize)]
pub struct Zigbee4512702 {
    ///Triggered action (e.g. a button click)
    pub action: Zigbee4512702Action,
    ///Remaining battery in %, can take up to 24 hours before reported.
    pub battery: f64,
    ///Link quality (signal strength)
    pub linkquality: f64,
    /// Optional last_seen type, set as a global zigbee2mqtt setting
    pub last_seen: Option<LastSeen>,
    /// Optional elapsed type
    pub elapsed: Option<u64>,
}/// namron:4512703 [zigbee2mqtt link](https://www.zigbee2mqtt.io/devices/4512703.html)
///
/// 
#[cfg_attr(feature = "debug", derive(Debug))]
#[cfg_attr(feature = "clone", derive(Clone))]
#[derive(Deserialize)]
pub struct Zigbee4512703 {
    ///Triggered action (e.g. a button click)
    pub action: Zigbee4512703Action,
    ///Remaining battery in %, can take up to 24 hours before reported.
    pub battery: f64,
    ///Link quality (signal strength)
    pub linkquality: f64,
    /// Optional last_seen type, set as a global zigbee2mqtt setting
    pub last_seen: Option<LastSeen>,
    /// Optional elapsed type
    pub elapsed: Option<u64>,
}/// namron:4512704 [zigbee2mqtt link](https://www.zigbee2mqtt.io/devices/4512704.html)
///
/// 
#[cfg_attr(feature = "debug", derive(Debug))]
#[cfg_attr(feature = "clone", derive(Clone))]
#[derive(Deserialize)]
pub struct Zigbee4512704 {
    ///Link quality (signal strength)
    pub linkquality: f64,
    ///Controls the behavior when the device is powered on after power loss
    pub power_on_behavior: Zigbee4512704Poweronbehavior,
    ///Zigbee herdsman description: "On/off state of the switch"
    ///The string values get converted into boolean with: ON = true and OFF = false
    #[serde(deserialize_with = "zigbee4512704_state_deserializer")]
    pub state: bool,
    /// Optional last_seen type, set as a global zigbee2mqtt setting
    pub last_seen: Option<LastSeen>,
    /// Optional elapsed type
    pub elapsed: Option<u64>,
}
/// Deserialize bool from String with custom value mapping
fn zigbee4512704_state_deserializer<'de, D>(deserializer: D) -> Result<bool, D::Error>
where
    D: Deserializer<'de>,
{
    match String::deserialize(deserializer)?.as_ref() {
        "ON" => Ok(true),
        "OFF" => Ok(false),
        other => Err(de::Error::invalid_value(
            Unexpected::Str(other),
            &"Value expected was either ON or OFF",
        )),
    }
}

/// namron:4512705 [zigbee2mqtt link](https://www.zigbee2mqtt.io/devices/4512705.html)
///
/// 
#[cfg_attr(feature = "debug", derive(Debug))]
#[cfg_attr(feature = "clone", derive(Clone))]
#[derive(Deserialize)]
pub struct Zigbee4512705 {
    ///Triggered action (e.g. a button click)
    pub action: Zigbee4512705Action,
    ///Remaining battery in %, can take up to 24 hours before reported.
    pub battery: f64,
    ///Link quality (signal strength)
    pub linkquality: f64,
    /// Optional last_seen type, set as a global zigbee2mqtt setting
    pub last_seen: Option<LastSeen>,
    /// Optional elapsed type
    pub elapsed: Option<u64>,
}/// namron:4512706 [zigbee2mqtt link](https://www.zigbee2mqtt.io/devices/4512706.html)
///
/// 
#[cfg_attr(feature = "debug", derive(Debug))]
#[cfg_attr(feature = "clone", derive(Clone))]
#[derive(Deserialize)]
pub struct Zigbee4512706 {
    ///Triggered action (e.g. a button click)
    pub action: Zigbee4512706Action,
    ///Remaining battery in %, can take up to 24 hours before reported.
    pub battery: f64,
    ///Link quality (signal strength)
    pub linkquality: f64,
    /// Optional last_seen type, set as a global zigbee2mqtt setting
    pub last_seen: Option<LastSeen>,
    /// Optional elapsed type
    pub elapsed: Option<u64>,
}/// namron:4512708 [zigbee2mqtt link](https://www.zigbee2mqtt.io/devices/4512708.html)
///
/// 
#[cfg_attr(feature = "debug", derive(Debug))]
#[cfg_attr(feature = "clone", derive(Clone))]
#[derive(Deserialize)]
pub struct Zigbee4512708 {
    ///Brightness of this light
    pub brightness: f64,
    ///Link quality (signal strength)
    pub linkquality: f64,
    ///Controls the behavior when the device is powered on after power loss
    pub power_on_behavior: Zigbee4512708Poweronbehavior,
    ///Zigbee herdsman description: "On/off state of this light"
    ///The string values get converted into boolean with: ON = true and OFF = false
    #[serde(deserialize_with = "zigbee4512708_state_deserializer")]
    pub state: bool,
    /// Optional last_seen type, set as a global zigbee2mqtt setting
    pub last_seen: Option<LastSeen>,
    /// Optional elapsed type
    pub elapsed: Option<u64>,
}
/// Deserialize bool from String with custom value mapping
fn zigbee4512708_state_deserializer<'de, D>(deserializer: D) -> Result<bool, D::Error>
where
    D: Deserializer<'de>,
{
    match String::deserialize(deserializer)?.as_ref() {
        "ON" => Ok(true),
        "OFF" => Ok(false),
        other => Err(de::Error::invalid_value(
            Unexpected::Str(other),
            &"Value expected was either ON or OFF",
        )),
    }
}

/// namron:4512719 [zigbee2mqtt link](https://www.zigbee2mqtt.io/devices/4512719.html)
///
/// 
#[cfg_attr(feature = "debug", derive(Debug))]
#[cfg_attr(feature = "clone", derive(Clone))]
#[derive(Deserialize)]
pub struct Zigbee4512719 {
    ///Triggered action (e.g. a button click)
    pub action: Zigbee4512719Action,
    ///Remaining battery in %, can take up to 24 hours before reported.
    pub battery: f64,
    ///Link quality (signal strength)
    pub linkquality: f64,
    /// Optional last_seen type, set as a global zigbee2mqtt setting
    pub last_seen: Option<LastSeen>,
    /// Optional elapsed type
    pub elapsed: Option<u64>,
}/// namron:4512721 [zigbee2mqtt link](https://www.zigbee2mqtt.io/devices/4512721.html)
///
/// 
#[cfg_attr(feature = "debug", derive(Debug))]
#[cfg_attr(feature = "clone", derive(Clone))]
#[derive(Deserialize)]
pub struct Zigbee4512721 {
    ///Triggered action (e.g. a button click)
    pub action: Zigbee4512721Action,
    ///Remaining battery in %, can take up to 24 hours before reported.
    pub battery: f64,
    ///Link quality (signal strength)
    pub linkquality: f64,
    /// Optional last_seen type, set as a global zigbee2mqtt setting
    pub last_seen: Option<LastSeen>,
    /// Optional elapsed type
    pub elapsed: Option<u64>,
}/// namron:4512726 [zigbee2mqtt link](https://www.zigbee2mqtt.io/devices/4512726.html)
///
/// 
#[cfg_attr(feature = "debug", derive(Debug))]
#[cfg_attr(feature = "clone", derive(Clone))]
#[derive(Deserialize)]
pub struct Zigbee4512726 {
    ///Triggered action (e.g. a button click)
    pub action: Zigbee4512726Action,
    ///Remaining battery in %, can take up to 24 hours before reported.
    pub battery: f64,
    ///Link quality (signal strength)
    pub linkquality: f64,
    ///Voltage of the battery in millivolts
    pub voltage: f64,
    /// Optional last_seen type, set as a global zigbee2mqtt setting
    pub last_seen: Option<LastSeen>,
    /// Optional elapsed type
    pub elapsed: Option<u64>,
}/// namron:4512728 [zigbee2mqtt link](https://www.zigbee2mqtt.io/devices/4512728.html)
///
/// 
#[cfg_attr(feature = "debug", derive(Debug))]
#[cfg_attr(feature = "clone", derive(Clone))]
#[derive(Deserialize)]
pub struct Zigbee4512728 {
    ///Triggered action (e.g. a button click)
    pub action: Zigbee4512728Action,
    ///Remaining battery in %, can take up to 24 hours before reported.
    pub battery: f64,
    ///Link quality (signal strength)
    pub linkquality: f64,
    /// Optional last_seen type, set as a global zigbee2mqtt setting
    pub last_seen: Option<LastSeen>,
    /// Optional elapsed type
    pub elapsed: Option<u64>,
}/// namron:4512729 [zigbee2mqtt link](https://www.zigbee2mqtt.io/devices/4512729.html)
///
/// 
#[cfg_attr(feature = "debug", derive(Debug))]
#[cfg_attr(feature = "clone", derive(Clone))]
#[derive(Deserialize)]
pub struct Zigbee4512729 {
    ///Triggered action (e.g. a button click)
    pub action: Zigbee4512729Action,
    ///Remaining battery in %, can take up to 24 hours before reported.
    pub battery: f64,
    ///Link quality (signal strength)
    pub linkquality: f64,
    /// Optional last_seen type, set as a global zigbee2mqtt setting
    pub last_seen: Option<LastSeen>,
    /// Optional elapsed type
    pub elapsed: Option<u64>,
}/// namron:4512733 [zigbee2mqtt link](https://www.zigbee2mqtt.io/devices/4512733.html)
///
/// 
#[cfg_attr(feature = "debug", derive(Debug))]
#[cfg_attr(feature = "clone", derive(Clone))]
#[derive(Deserialize)]
pub struct Zigbee4512733 {
    ///Brightness of this light
    pub brightness: f64,
    ///Link quality (signal strength)
    pub linkquality: f64,
    ///Controls the behavior when the device is powered on after power loss
    pub power_on_behavior: Zigbee4512733Poweronbehavior,
    ///Zigbee herdsman description: "On/off state of this light"
    ///The string values get converted into boolean with: ON = true and OFF = false
    #[serde(deserialize_with = "zigbee4512733_state_deserializer")]
    pub state: bool,
    /// Optional last_seen type, set as a global zigbee2mqtt setting
    pub last_seen: Option<LastSeen>,
    /// Optional elapsed type
    pub elapsed: Option<u64>,
}
/// Deserialize bool from String with custom value mapping
fn zigbee4512733_state_deserializer<'de, D>(deserializer: D) -> Result<bool, D::Error>
where
    D: Deserializer<'de>,
{
    match String::deserialize(deserializer)?.as_ref() {
        "ON" => Ok(true),
        "OFF" => Ok(false),
        other => Err(de::Error::invalid_value(
            Unexpected::Str(other),
            &"Value expected was either ON or OFF",
        )),
    }
}

/// namron:4512735 [zigbee2mqtt link](https://www.zigbee2mqtt.io/devices/4512735.html)
///
/// 
#[cfg_attr(feature = "debug", derive(Debug))]
#[cfg_attr(feature = "clone", derive(Clone))]
#[derive(Deserialize)]
pub struct Zigbee4512735 {
    ///Link quality (signal strength)
    pub linkquality: f64,
    ///Zigbee herdsman description: "On/off state of the switch"
    ///The string values get converted into boolean with: ON = true and OFF = false
    #[serde(deserialize_with = "zigbee4512735_state_l1_deserializer")]
    pub state_l1: bool,
    ///Zigbee herdsman description: "On/off state of the switch"
    ///The string values get converted into boolean with: ON = true and OFF = false
    #[serde(deserialize_with = "zigbee4512735_state_l2_deserializer")]
    pub state_l2: bool,
    ///Zigbee herdsman description: "On/off state of the switch"
    ///The string values get converted into boolean with: ON = true and OFF = false
    #[serde(deserialize_with = "zigbee4512735_state_l3_deserializer")]
    pub state_l3: bool,
    ///Zigbee herdsman description: "On/off state of the switch"
    ///The string values get converted into boolean with: ON = true and OFF = false
    #[serde(deserialize_with = "zigbee4512735_state_l4_deserializer")]
    pub state_l4: bool,
    ///Zigbee herdsman description: "On/off state of the switch"
    ///The string values get converted into boolean with: ON = true and OFF = false
    #[serde(deserialize_with = "zigbee4512735_state_l5_deserializer")]
    pub state_l5: bool,
    /// Optional last_seen type, set as a global zigbee2mqtt setting
    pub last_seen: Option<LastSeen>,
    /// Optional elapsed type
    pub elapsed: Option<u64>,
}
/// Deserialize bool from String with custom value mapping
fn zigbee4512735_state_l1_deserializer<'de, D>(deserializer: D) -> Result<bool, D::Error>
where
    D: Deserializer<'de>,
{
    match String::deserialize(deserializer)?.as_ref() {
        "ON" => Ok(true),
        "OFF" => Ok(false),
        other => Err(de::Error::invalid_value(
            Unexpected::Str(other),
            &"Value expected was either ON or OFF",
        )),
    }
}


/// Deserialize bool from String with custom value mapping
fn zigbee4512735_state_l2_deserializer<'de, D>(deserializer: D) -> Result<bool, D::Error>
where
    D: Deserializer<'de>,
{
    match String::deserialize(deserializer)?.as_ref() {
        "ON" => Ok(true),
        "OFF" => Ok(false),
        other => Err(de::Error::invalid_value(
            Unexpected::Str(other),
            &"Value expected was either ON or OFF",
        )),
    }
}


/// Deserialize bool from String with custom value mapping
fn zigbee4512735_state_l3_deserializer<'de, D>(deserializer: D) -> Result<bool, D::Error>
where
    D: Deserializer<'de>,
{
    match String::deserialize(deserializer)?.as_ref() {
        "ON" => Ok(true),
        "OFF" => Ok(false),
        other => Err(de::Error::invalid_value(
            Unexpected::Str(other),
            &"Value expected was either ON or OFF",
        )),
    }
}


/// Deserialize bool from String with custom value mapping
fn zigbee4512735_state_l4_deserializer<'de, D>(deserializer: D) -> Result<bool, D::Error>
where
    D: Deserializer<'de>,
{
    match String::deserialize(deserializer)?.as_ref() {
        "ON" => Ok(true),
        "OFF" => Ok(false),
        other => Err(de::Error::invalid_value(
            Unexpected::Str(other),
            &"Value expected was either ON or OFF",
        )),
    }
}


/// Deserialize bool from String with custom value mapping
fn zigbee4512735_state_l5_deserializer<'de, D>(deserializer: D) -> Result<bool, D::Error>
where
    D: Deserializer<'de>,
{
    match String::deserialize(deserializer)?.as_ref() {
        "ON" => Ok(true),
        "OFF" => Ok(false),
        other => Err(de::Error::invalid_value(
            Unexpected::Str(other),
            &"Value expected was either ON or OFF",
        )),
    }
}

/// namron:4512737/4512738 [zigbee2mqtt link](https://www.zigbee2mqtt.io/devices/4512737/4512738.html)
///
/// 
#[cfg_attr(feature = "debug", derive(Debug))]
#[cfg_attr(feature = "clone", derive(Clone))]
#[derive(Deserialize)]
pub struct Zigbee45127374512738 {
    ///Floor temperature over heating threshold, range is 0-35, unit is 1ºC, 0 means this function is disabled, default value is 27.
    pub alarm_airtemp_overvalue: f64,
    ///Zigbee herdsman description: "Enable/disable away mode"
    ///The string values get converted into boolean with: ON = true and OFF = false
    #[serde(deserialize_with = "zigbee45127374512738_away_mode_deserializer")]
    pub away_mode: bool,
    ///Key beep volume and vibration level.  Default: Low.
    pub button_vibration_level: Zigbee45127374512738Buttonvibrationlevel,
    ///Zigbee herdsman description: "Enables/disables physical input on the device"
    ///The string values get converted into boolean with: LOCK = true and UNLOCK = false
    #[serde(deserialize_with = "zigbee45127374512738_child_lock_deserializer")]
    pub child_lock: bool,
    ///Instantaneous measured electrical current
    pub current: f64,
    pub display_auto_off_enabled: Zigbee45127374512738Displayautooffenabled,
    ///The duration of Dry Mode, between 5 and 100 minutes.  Default: 5.
    pub dry_time: f64,
    ///Sum of consumed energy
    pub energy: f64,
    ///The tempearatue calibration for the exernal floor sensor, between -3 and 3 in 0.1°C.  Default: 0.
    pub floor_sensor_calibration: f64,
    ///Type of the external floor sensor.  Default: NTC 10K/25.
    pub floor_sensor_type: Zigbee45127374512738Floorsensortype,
    ///Hysteresis setting, between 0.5 and 5 in 0.1 °C.  Default: 0.5.
    pub hysterersis: f64,
    ///OLED brightness when operating the buttons.  Default: Medium.
    pub lcd_brightness: Zigbee45127374512738Lcdbrightness,
    ///Link quality (signal strength)
    pub linkquality: f64,
    ///Current temperature measured on the device
    pub local_temperature: f64,
    ///Offset to be used in the local_temperature
    pub local_temperature_calibration: f64,
    ///The mode after Dry Mode.  Default: Auto.
    pub mode_after_dry: Zigbee45127374512738Modeafterdry,
    ///Temperature setpoint
    pub occupied_heating_setpoint: f64,
    ///Current temperature measured from the floor sensor
    pub outdoor_temperature: f64,
    ///Instantaneous measured power
    pub power: f64,
    ///The mode after a power reset.  Default: Previous Mode.
    pub powerup_status: Zigbee45127374512738Powerupstatus,
    ///The current running state
    pub running_state: Zigbee45127374512738Runningstate,
    ///The sensor used for heat control.  Default: Room Sensor.
    pub sensor: Zigbee45127374512738Sensor,
    ///Mode of this device
    pub system_mode: Zigbee45127374512738Systemmode,
    ///The temperature on the display.  Default: Room Temperature.
    pub temperature_display: Zigbee45127374512738Temperaturedisplay,
    ///Measured electrical potential value
    pub voltage: f64,
    ///The threshold to detect window open, between 1.5 and 4 in 0.5 °C.  Default: 0 (disabled).
    pub window_open_check: f64,
    /// Optional last_seen type, set as a global zigbee2mqtt setting
    pub last_seen: Option<LastSeen>,
    /// Optional elapsed type
    pub elapsed: Option<u64>,
}
/// Deserialize bool from String with custom value mapping
fn zigbee45127374512738_away_mode_deserializer<'de, D>(deserializer: D) -> Result<bool, D::Error>
where
    D: Deserializer<'de>,
{
    match String::deserialize(deserializer)?.as_ref() {
        "ON" => Ok(true),
        "OFF" => Ok(false),
        other => Err(de::Error::invalid_value(
            Unexpected::Str(other),
            &"Value expected was either ON or OFF",
        )),
    }
}


/// Deserialize bool from String with custom value mapping
fn zigbee45127374512738_child_lock_deserializer<'de, D>(deserializer: D) -> Result<bool, D::Error>
where
    D: Deserializer<'de>,
{
    match String::deserialize(deserializer)?.as_ref() {
        "LOCK" => Ok(true),
        "UNLOCK" => Ok(false),
        other => Err(de::Error::invalid_value(
            Unexpected::Str(other),
            &"Value expected was either LOCK or UNLOCK",
        )),
    }
}

/// namron:4512747 [zigbee2mqtt link](https://www.zigbee2mqtt.io/devices/4512747.html)
///
/// 
#[cfg_attr(feature = "debug", derive(Debug))]
#[cfg_attr(feature = "clone", derive(Clone))]
#[derive(Deserialize)]
pub struct Zigbee4512747 {
    ///Link quality (signal strength)
    pub linkquality: f64,
    ///Position of this cover
    pub position: f64,
    pub state: Zigbee4512747State,
    /// Optional last_seen type, set as a global zigbee2mqtt setting
    pub last_seen: Option<LastSeen>,
    /// Optional elapsed type
    pub elapsed: Option<u64>,
}/// namron:4512749 [zigbee2mqtt link](https://www.zigbee2mqtt.io/devices/4512749.html)
///
/// 
#[cfg_attr(feature = "debug", derive(Debug))]
#[cfg_attr(feature = "clone", derive(Clone))]
#[derive(Deserialize)]
pub struct Zigbee4512749 {
    ///Instantaneous measured electrical current
    pub current: f64,
    ///Link quality (signal strength)
    pub linkquality: f64,
    ///Instantaneous measured power
    pub power: f64,
    ///Controls the behavior when the device is powered on after power loss
    pub power_on_behavior: Zigbee4512749Poweronbehavior,
    ///Zigbee herdsman description: "On/off state of the switch"
    ///The string values get converted into boolean with: ON = true and OFF = false
    #[serde(deserialize_with = "zigbee4512749_state_deserializer")]
    pub state: bool,
    ///Measured temperature value
    pub temperature: f64,
    ///Measured electrical potential value
    pub voltage: f64,
    /// Optional last_seen type, set as a global zigbee2mqtt setting
    pub last_seen: Option<LastSeen>,
    /// Optional elapsed type
    pub elapsed: Option<u64>,
}
/// Deserialize bool from String with custom value mapping
fn zigbee4512749_state_deserializer<'de, D>(deserializer: D) -> Result<bool, D::Error>
where
    D: Deserializer<'de>,
{
    match String::deserialize(deserializer)?.as_ref() {
        "ON" => Ok(true),
        "OFF" => Ok(false),
        other => Err(de::Error::invalid_value(
            Unexpected::Str(other),
            &"Value expected was either ON or OFF",
        )),
    }
}

/// namron:540139X [zigbee2mqtt link](https://www.zigbee2mqtt.io/devices/540139X.html)
///
/// 
#[cfg_attr(feature = "debug", derive(Debug))]
#[cfg_attr(feature = "clone", derive(Clone))]
#[derive(Deserialize)]
pub struct Zigbee540139x {
    ///Zigbee herdsman description: "Enables/disables physical input on the device"
    ///The string values get converted into boolean with: LOCK = true and UNLOCK = false
    #[serde(deserialize_with = "zigbee540139x_child_lock_deserializer")]
    pub child_lock: bool,
    ///Instantaneous measured electrical current
    pub current: f64,
    ///Enable / Disable display auto off
    pub display_auto_off: Zigbee540139xDisplayautooff,
    ///Adjust brightness of display values 1(Low)-7(High)
    pub display_brightnesss: f64,
    ///Sum of consumed energy
    pub energy: f64,
    ///Hysteresis setting, default: 0.5
    pub hysterersis: f64,
    ///Link quality (signal strength)
    pub linkquality: f64,
    ///Current temperature measured on the device
    pub local_temperature: f64,
    ///Offset to be used in the local_temperature
    pub local_temperature_calibration: f64,
    ///Temperature setpoint
    pub occupied_heating_setpoint: f64,
    ///Instantaneous measured power
    pub power: f64,
    ///The mode after a power reset.  Default: Previous Mode. See instructions for information about manual
    pub power_up_status: Zigbee540139xPowerupstatus,
    ///The current running state
    pub running_state: Zigbee540139xRunningstate,
    ///Mode of this device
    pub system_mode: Zigbee540139xSystemmode,
    ///Measured electrical potential value
    pub voltage: f64,
    ///Turn on/off window check mode
    pub window_open_check: Zigbee540139xWindowopencheck,
    /// Optional last_seen type, set as a global zigbee2mqtt setting
    pub last_seen: Option<LastSeen>,
    /// Optional elapsed type
    pub elapsed: Option<u64>,
}
/// Deserialize bool from String with custom value mapping
fn zigbee540139x_child_lock_deserializer<'de, D>(deserializer: D) -> Result<bool, D::Error>
where
    D: Deserializer<'de>,
{
    match String::deserialize(deserializer)?.as_ref() {
        "LOCK" => Ok(true),
        "UNLOCK" => Ok(false),
        other => Err(de::Error::invalid_value(
            Unexpected::Str(other),
            &"Value expected was either LOCK or UNLOCK",
        )),
    }
}

/// namron:89665 [zigbee2mqtt link](https://www.zigbee2mqtt.io/devices/89665.html)
///
/// 
#[cfg_attr(feature = "debug", derive(Debug))]
#[cfg_attr(feature = "clone", derive(Clone))]
#[derive(Deserialize)]
pub struct Zigbee89665 {
    ///Brightness of this light
    pub brightness: f64,
    ///Color temperature of this light
    pub color_temp: f64,
    ///Color temperature after cold power on of this light
    pub color_temp_startup: f64,
    ///Link quality (signal strength)
    pub linkquality: f64,
    ///Controls the behavior when the device is powered on after power loss
    pub power_on_behavior: Zigbee89665Poweronbehavior,
    ///Zigbee herdsman description: "On/off state of this light"
    ///The string values get converted into boolean with: ON = true and OFF = false
    #[serde(deserialize_with = "zigbee89665_state_deserializer")]
    pub state: bool,
    /// Optional last_seen type, set as a global zigbee2mqtt setting
    pub last_seen: Option<LastSeen>,
    /// Optional elapsed type
    pub elapsed: Option<u64>,
}
/// Deserialize bool from String with custom value mapping
fn zigbee89665_state_deserializer<'de, D>(deserializer: D) -> Result<bool, D::Error>
where
    D: Deserializer<'de>,
{
    match String::deserialize(deserializer)?.as_ref() {
        "ON" => Ok(true),
        "OFF" => Ok(false),
        other => Err(de::Error::invalid_value(
            Unexpected::Str(other),
            &"Value expected was either ON or OFF",
        )),
    }
}


#[cfg_attr(feature = "debug", derive(Debug))]
#[cfg_attr(feature = "clone", derive(Clone))]
#[derive(Deserialize, PartialEq)]
pub enum Zigbee1402755Poweronbehavior {
    #[serde(rename = "off")]
    Off,
    #[serde(rename = "on")]
    On,
    #[serde(rename = "previous")]
    Previous,
    #[serde(rename = "toggle")]
    Toggle,
}
#[cfg_attr(feature = "debug", derive(Debug))]
#[cfg_attr(feature = "clone", derive(Clone))]
#[derive(Deserialize, PartialEq)]
pub enum Zigbee3308431Poweronbehavior {
    #[serde(rename = "off")]
    Off,
    #[serde(rename = "on")]
    On,
    #[serde(rename = "previous")]
    Previous,
    #[serde(rename = "toggle")]
    Toggle,
}
#[cfg_attr(feature = "debug", derive(Debug))]
#[cfg_attr(feature = "clone", derive(Clone))]
#[derive(Deserialize, PartialEq)]
pub enum Zigbee3802960Poweronbehavior {
    #[serde(rename = "off")]
    Off,
    #[serde(rename = "on")]
    On,
    #[serde(rename = "previous")]
    Previous,
    #[serde(rename = "toggle")]
    Toggle,
}
#[cfg_attr(feature = "debug", derive(Debug))]
#[cfg_attr(feature = "clone", derive(Clone))]
#[derive(Deserialize, PartialEq)]
pub enum Zigbee3802961Poweronbehavior {
    #[serde(rename = "off")]
    Off,
    #[serde(rename = "on")]
    On,
    #[serde(rename = "previous")]
    Previous,
    #[serde(rename = "toggle")]
    Toggle,
}
#[cfg_attr(feature = "debug", derive(Debug))]
#[cfg_attr(feature = "clone", derive(Clone))]
#[derive(Deserialize, PartialEq)]
pub enum Zigbee3802962Poweronbehavior {
    #[serde(rename = "off")]
    Off,
    #[serde(rename = "on")]
    On,
    #[serde(rename = "previous")]
    Previous,
    #[serde(rename = "toggle")]
    Toggle,
}
#[cfg_attr(feature = "debug", derive(Debug))]
#[cfg_attr(feature = "clone", derive(Clone))]
#[derive(Deserialize, PartialEq)]
pub enum Zigbee3802963Poweronbehavior {
    #[serde(rename = "off")]
    Off,
    #[serde(rename = "on")]
    On,
    #[serde(rename = "previous")]
    Previous,
    #[serde(rename = "toggle")]
    Toggle,
}
#[cfg_attr(feature = "debug", derive(Debug))]
#[cfg_attr(feature = "clone", derive(Clone))]
#[derive(Deserialize, PartialEq)]
pub enum Zigbee3802964Poweronbehavior {
    #[serde(rename = "off")]
    Off,
    #[serde(rename = "on")]
    On,
    #[serde(rename = "previous")]
    Previous,
    #[serde(rename = "toggle")]
    Toggle,
}
#[cfg_attr(feature = "debug", derive(Debug))]
#[cfg_attr(feature = "clone", derive(Clone))]
#[derive(Deserialize, PartialEq)]
pub enum Zigbee3802965Poweronbehavior {
    #[serde(rename = "off")]
    Off,
    #[serde(rename = "on")]
    On,
    #[serde(rename = "previous")]
    Previous,
    #[serde(rename = "toggle")]
    Toggle,
}
#[cfg_attr(feature = "debug", derive(Debug))]
#[cfg_attr(feature = "clone", derive(Clone))]
#[derive(Deserialize, PartialEq)]
pub enum Zigbee3802966Poweronbehavior {
    #[serde(rename = "off")]
    Off,
    #[serde(rename = "on")]
    On,
    #[serde(rename = "previous")]
    Previous,
    #[serde(rename = "toggle")]
    Toggle,
}
#[cfg_attr(feature = "debug", derive(Debug))]
#[cfg_attr(feature = "clone", derive(Clone))]
#[derive(Deserialize, PartialEq)]
pub enum Zigbee3802967Poweronbehavior {
    #[serde(rename = "off")]
    Off,
    #[serde(rename = "on")]
    On,
    #[serde(rename = "previous")]
    Previous,
    #[serde(rename = "toggle")]
    Toggle,
}
#[cfg_attr(feature = "debug", derive(Debug))]
#[cfg_attr(feature = "clone", derive(Clone))]
#[derive(Deserialize, PartialEq)]
pub enum Zigbee3802968Poweronbehavior {
    #[serde(rename = "off")]
    Off,
    #[serde(rename = "on")]
    On,
    #[serde(rename = "previous")]
    Previous,
    #[serde(rename = "toggle")]
    Toggle,
}
#[cfg_attr(feature = "debug", derive(Debug))]
#[cfg_attr(feature = "clone", derive(Clone))]
#[derive(Deserialize, PartialEq)]
pub enum Zigbee4512700Poweronbehavior {
    #[serde(rename = "off")]
    Off,
    #[serde(rename = "on")]
    On,
    #[serde(rename = "previous")]
    Previous,
    #[serde(rename = "toggle")]
    Toggle,
}
#[cfg_attr(feature = "debug", derive(Debug))]
#[cfg_attr(feature = "clone", derive(Clone))]
#[derive(Deserialize, PartialEq)]
pub enum Zigbee4512701Action {
    #[serde(rename = "brightness_move_down")]
    BrightnessMoveDown,
    #[serde(rename = "brightness_move_up")]
    BrightnessMoveUp,
    #[serde(rename = "brightness_stop")]
    BrightnessStop,
    #[serde(rename = "off")]
    Off,
    #[serde(rename = "on")]
    On,
}
#[cfg_attr(feature = "debug", derive(Debug))]
#[cfg_attr(feature = "clone", derive(Clone))]
#[derive(Deserialize, PartialEq)]
pub enum Zigbee4512702Action {
    #[serde(rename = "brightness_move_down")]
    BrightnessMoveDown,
    #[serde(rename = "brightness_move_up")]
    BrightnessMoveUp,
    #[serde(rename = "brightness_step_down")]
    BrightnessStepDown,
    #[serde(rename = "brightness_step_up")]
    BrightnessStepUp,
    #[serde(rename = "brightness_stop")]
    BrightnessStop,
    #[serde(rename = "off")]
    Off,
    #[serde(rename = "on")]
    On,
}
#[cfg_attr(feature = "debug", derive(Debug))]
#[cfg_attr(feature = "clone", derive(Clone))]
#[derive(Deserialize, PartialEq)]
pub enum Zigbee4512703Action {
    #[serde(rename = "brightness_move_down_l1")]
    BrightnessMoveDownL1,
    #[serde(rename = "brightness_move_down_l2")]
    BrightnessMoveDownL2,
    #[serde(rename = "brightness_move_down_l3")]
    BrightnessMoveDownL3,
    #[serde(rename = "brightness_move_down_l4")]
    BrightnessMoveDownL4,
    #[serde(rename = "brightness_move_up_l1")]
    BrightnessMoveUpL1,
    #[serde(rename = "brightness_move_up_l2")]
    BrightnessMoveUpL2,
    #[serde(rename = "brightness_move_up_l3")]
    BrightnessMoveUpL3,
    #[serde(rename = "brightness_move_up_l4")]
    BrightnessMoveUpL4,
    #[serde(rename = "brightness_stop_l1")]
    BrightnessStopL1,
    #[serde(rename = "brightness_stop_l2")]
    BrightnessStopL2,
    #[serde(rename = "brightness_stop_l3")]
    BrightnessStopL3,
    #[serde(rename = "brightness_stop_l4")]
    BrightnessStopL4,
    #[serde(rename = "off_l1")]
    OffL1,
    #[serde(rename = "off_l2")]
    OffL2,
    #[serde(rename = "off_l3")]
    OffL3,
    #[serde(rename = "off_l4")]
    OffL4,
    #[serde(rename = "on_l1")]
    OnL1,
    #[serde(rename = "on_l2")]
    OnL2,
    #[serde(rename = "on_l3")]
    OnL3,
    #[serde(rename = "on_l4")]
    OnL4,
}
#[cfg_attr(feature = "debug", derive(Debug))]
#[cfg_attr(feature = "clone", derive(Clone))]
#[derive(Deserialize, PartialEq)]
pub enum Zigbee4512704Poweronbehavior {
    #[serde(rename = "off")]
    Off,
    #[serde(rename = "on")]
    On,
    #[serde(rename = "previous")]
    Previous,
    #[serde(rename = "toggle")]
    Toggle,
}
#[cfg_attr(feature = "debug", derive(Debug))]
#[cfg_attr(feature = "clone", derive(Clone))]
#[derive(Deserialize, PartialEq)]
pub enum Zigbee4512705Action {
    #[serde(rename = "brightness_move_down_l1")]
    BrightnessMoveDownL1,
    #[serde(rename = "brightness_move_down_l2")]
    BrightnessMoveDownL2,
    #[serde(rename = "brightness_move_down_l3")]
    BrightnessMoveDownL3,
    #[serde(rename = "brightness_move_down_l4")]
    BrightnessMoveDownL4,
    #[serde(rename = "brightness_move_up_l1")]
    BrightnessMoveUpL1,
    #[serde(rename = "brightness_move_up_l2")]
    BrightnessMoveUpL2,
    #[serde(rename = "brightness_move_up_l3")]
    BrightnessMoveUpL3,
    #[serde(rename = "brightness_move_up_l4")]
    BrightnessMoveUpL4,
    #[serde(rename = "brightness_stop_l1")]
    BrightnessStopL1,
    #[serde(rename = "brightness_stop_l2")]
    BrightnessStopL2,
    #[serde(rename = "brightness_stop_l3")]
    BrightnessStopL3,
    #[serde(rename = "brightness_stop_l4")]
    BrightnessStopL4,
    #[serde(rename = "off_l1")]
    OffL1,
    #[serde(rename = "off_l2")]
    OffL2,
    #[serde(rename = "off_l3")]
    OffL3,
    #[serde(rename = "off_l4")]
    OffL4,
    #[serde(rename = "on_l1")]
    OnL1,
    #[serde(rename = "on_l2")]
    OnL2,
    #[serde(rename = "on_l3")]
    OnL3,
    #[serde(rename = "on_l4")]
    OnL4,
    #[serde(rename = "recall_*")]
    Recall,
}
#[cfg_attr(feature = "debug", derive(Debug))]
#[cfg_attr(feature = "clone", derive(Clone))]
#[derive(Deserialize, PartialEq)]
pub enum Zigbee4512706Action {
    #[serde(rename = "brightness_step_down")]
    BrightnessStepDown,
    #[serde(rename = "brightness_step_up")]
    BrightnessStepUp,
    #[serde(rename = "color_temperature_move")]
    ColorTemperatureMove,
    #[serde(rename = "color_temperature_step_down")]
    ColorTemperatureStepDown,
    #[serde(rename = "color_temperature_step_up")]
    ColorTemperatureStepUp,
    #[serde(rename = "move_to_hue_l1")]
    MoveToHueL1,
    #[serde(rename = "move_to_hue_l2")]
    MoveToHueL2,
    #[serde(rename = "move_to_hue_l3")]
    MoveToHueL3,
    #[serde(rename = "move_to_hue_l4")]
    MoveToHueL4,
    #[serde(rename = "off")]
    Off,
    #[serde(rename = "on")]
    On,
    #[serde(rename = "recall_*")]
    Recall,
}
#[cfg_attr(feature = "debug", derive(Debug))]
#[cfg_attr(feature = "clone", derive(Clone))]
#[derive(Deserialize, PartialEq)]
pub enum Zigbee4512708Poweronbehavior {
    #[serde(rename = "off")]
    Off,
    #[serde(rename = "on")]
    On,
    #[serde(rename = "previous")]
    Previous,
    #[serde(rename = "toggle")]
    Toggle,
}
#[cfg_attr(feature = "debug", derive(Debug))]
#[cfg_attr(feature = "clone", derive(Clone))]
#[derive(Deserialize, PartialEq)]
pub enum Zigbee4512719Action {
    #[serde(rename = "brightness_move_down_l1")]
    BrightnessMoveDownL1,
    #[serde(rename = "brightness_move_down_l2")]
    BrightnessMoveDownL2,
    #[serde(rename = "brightness_move_up_l1")]
    BrightnessMoveUpL1,
    #[serde(rename = "brightness_move_up_l2")]
    BrightnessMoveUpL2,
    #[serde(rename = "brightness_stop_l1")]
    BrightnessStopL1,
    #[serde(rename = "brightness_stop_l2")]
    BrightnessStopL2,
    #[serde(rename = "off_l1")]
    OffL1,
    #[serde(rename = "off_l2")]
    OffL2,
    #[serde(rename = "on_l1")]
    OnL1,
    #[serde(rename = "on_l2")]
    OnL2,
}
#[cfg_attr(feature = "debug", derive(Debug))]
#[cfg_attr(feature = "clone", derive(Clone))]
#[derive(Deserialize, PartialEq)]
pub enum Zigbee4512721Action {
    #[serde(rename = "brightness_move_down_l1")]
    BrightnessMoveDownL1,
    #[serde(rename = "brightness_move_down_l2")]
    BrightnessMoveDownL2,
    #[serde(rename = "brightness_move_down_l3")]
    BrightnessMoveDownL3,
    #[serde(rename = "brightness_move_down_l4")]
    BrightnessMoveDownL4,
    #[serde(rename = "brightness_move_up_l1")]
    BrightnessMoveUpL1,
    #[serde(rename = "brightness_move_up_l2")]
    BrightnessMoveUpL2,
    #[serde(rename = "brightness_move_up_l3")]
    BrightnessMoveUpL3,
    #[serde(rename = "brightness_move_up_l4")]
    BrightnessMoveUpL4,
    #[serde(rename = "brightness_stop_l1")]
    BrightnessStopL1,
    #[serde(rename = "brightness_stop_l2")]
    BrightnessStopL2,
    #[serde(rename = "brightness_stop_l3")]
    BrightnessStopL3,
    #[serde(rename = "brightness_stop_l4")]
    BrightnessStopL4,
    #[serde(rename = "off_l1")]
    OffL1,
    #[serde(rename = "off_l2")]
    OffL2,
    #[serde(rename = "off_l3")]
    OffL3,
    #[serde(rename = "off_l4")]
    OffL4,
    #[serde(rename = "on_l1")]
    OnL1,
    #[serde(rename = "on_l2")]
    OnL2,
    #[serde(rename = "on_l3")]
    OnL3,
    #[serde(rename = "on_l4")]
    OnL4,
}
#[cfg_attr(feature = "debug", derive(Debug))]
#[cfg_attr(feature = "clone", derive(Clone))]
#[derive(Deserialize, PartialEq)]
pub enum Zigbee4512726Action {
    #[serde(rename = "brightness_move_to_level")]
    BrightnessMoveToLevel,
    #[serde(rename = "color_temperature_move")]
    ColorTemperatureMove,
    #[serde(rename = "move_to_hue")]
    MoveToHue,
    #[serde(rename = "off")]
    Off,
    #[serde(rename = "on")]
    On,
}
#[cfg_attr(feature = "debug", derive(Debug))]
#[cfg_attr(feature = "clone", derive(Clone))]
#[derive(Deserialize, PartialEq)]
pub enum Zigbee4512728Action {
    #[serde(rename = "brightness_move_down")]
    BrightnessMoveDown,
    #[serde(rename = "brightness_move_up")]
    BrightnessMoveUp,
    #[serde(rename = "brightness_stop")]
    BrightnessStop,
    #[serde(rename = "off")]
    Off,
    #[serde(rename = "on")]
    On,
}
#[cfg_attr(feature = "debug", derive(Debug))]
#[cfg_attr(feature = "clone", derive(Clone))]
#[derive(Deserialize, PartialEq)]
pub enum Zigbee4512729Action {
    #[serde(rename = "brightness_move_down_l1")]
    BrightnessMoveDownL1,
    #[serde(rename = "brightness_move_down_l2")]
    BrightnessMoveDownL2,
    #[serde(rename = "brightness_move_up_l1")]
    BrightnessMoveUpL1,
    #[serde(rename = "brightness_move_up_l2")]
    BrightnessMoveUpL2,
    #[serde(rename = "brightness_stop_l1")]
    BrightnessStopL1,
    #[serde(rename = "brightness_stop_l2")]
    BrightnessStopL2,
    #[serde(rename = "off_l1")]
    OffL1,
    #[serde(rename = "off_l2")]
    OffL2,
    #[serde(rename = "on_l1")]
    OnL1,
    #[serde(rename = "on_l2")]
    OnL2,
}
#[cfg_attr(feature = "debug", derive(Debug))]
#[cfg_attr(feature = "clone", derive(Clone))]
#[derive(Deserialize, PartialEq)]
pub enum Zigbee4512733Poweronbehavior {
    #[serde(rename = "off")]
    Off,
    #[serde(rename = "on")]
    On,
    #[serde(rename = "previous")]
    Previous,
    #[serde(rename = "toggle")]
    Toggle,
}
#[cfg_attr(feature = "debug", derive(Debug))]
#[cfg_attr(feature = "clone", derive(Clone))]
#[derive(Deserialize, PartialEq)]
pub enum Zigbee45127374512738Buttonvibrationlevel {
    #[serde(rename = "high")]
    High,
    #[serde(rename = "low")]
    Low,
    #[serde(rename = "off")]
    Off,
}
#[cfg_attr(feature = "debug", derive(Debug))]
#[cfg_attr(feature = "clone", derive(Clone))]
#[derive(Deserialize, PartialEq)]
pub enum Zigbee45127374512738Displayautooffenabled {
    #[serde(rename = "disabled")]
    Disabled,
    #[serde(rename = "enabled")]
    Enabled,
}
#[cfg_attr(feature = "debug", derive(Debug))]
#[cfg_attr(feature = "clone", derive(Clone))]
#[derive(Deserialize, PartialEq)]
pub enum Zigbee45127374512738Floorsensortype {
    #[serde(rename = "100k")]
    Number100k,
    #[serde(rename = "10k")]
    Number10k,
    #[serde(rename = "12k")]
    Number12k,
    #[serde(rename = "15k")]
    Number15k,
    #[serde(rename = "50k")]
    Number50k,
}
#[cfg_attr(feature = "debug", derive(Debug))]
#[cfg_attr(feature = "clone", derive(Clone))]
#[derive(Deserialize, PartialEq)]
pub enum Zigbee45127374512738Lcdbrightness {
    #[serde(rename = "high")]
    High,
    #[serde(rename = "low")]
    Low,
    #[serde(rename = "mid")]
    Mid,
}
#[cfg_attr(feature = "debug", derive(Debug))]
#[cfg_attr(feature = "clone", derive(Clone))]
#[derive(Deserialize, PartialEq)]
pub enum Zigbee45127374512738Modeafterdry {
    #[serde(rename = "auto")]
    Auto,
    #[serde(rename = "away")]
    Away,
    #[serde(rename = "manual")]
    Manual,
    #[serde(rename = "off")]
    Off,
}
#[cfg_attr(feature = "debug", derive(Debug))]
#[cfg_attr(feature = "clone", derive(Clone))]
#[derive(Deserialize, PartialEq)]
pub enum Zigbee45127374512738Powerupstatus {
    #[serde(rename = "default")]
    Default,
    #[serde(rename = "last_status")]
    LastStatus,
}
#[cfg_attr(feature = "debug", derive(Debug))]
#[cfg_attr(feature = "clone", derive(Clone))]
#[derive(Deserialize, PartialEq)]
pub enum Zigbee45127374512738Runningstate {
    #[serde(rename = "heat")]
    Heat,
    #[serde(rename = "idle")]
    Idle,
}
#[cfg_attr(feature = "debug", derive(Debug))]
#[cfg_attr(feature = "clone", derive(Clone))]
#[derive(Deserialize, PartialEq)]
pub enum Zigbee45127374512738Sensor {
    #[serde(rename = "air")]
    Air,
    #[serde(rename = "both")]
    Both,
    #[serde(rename = "floor")]
    Floor,
}
#[cfg_attr(feature = "debug", derive(Debug))]
#[cfg_attr(feature = "clone", derive(Clone))]
#[derive(Deserialize, PartialEq)]
pub enum Zigbee45127374512738Systemmode {
    #[serde(rename = "auto")]
    Auto,
    #[serde(rename = "dry")]
    Dry,
    #[serde(rename = "heat")]
    Heat,
    #[serde(rename = "off")]
    Off,
}
#[cfg_attr(feature = "debug", derive(Debug))]
#[cfg_attr(feature = "clone", derive(Clone))]
#[derive(Deserialize, PartialEq)]
pub enum Zigbee45127374512738Temperaturedisplay {
    #[serde(rename = "floor")]
    Floor,
    #[serde(rename = "room")]
    Room,
}
#[cfg_attr(feature = "debug", derive(Debug))]
#[cfg_attr(feature = "clone", derive(Clone))]
#[derive(Deserialize, PartialEq)]
pub enum Zigbee4512747State {
    #[serde(rename = "CLOSE")]
    Close,
    #[serde(rename = "OPEN")]
    Open,
    #[serde(rename = "STOP")]
    Stop,
}
#[cfg_attr(feature = "debug", derive(Debug))]
#[cfg_attr(feature = "clone", derive(Clone))]
#[derive(Deserialize, PartialEq)]
pub enum Zigbee4512749Poweronbehavior {
    #[serde(rename = "off")]
    Off,
    #[serde(rename = "on")]
    On,
    #[serde(rename = "previous")]
    Previous,
}
#[cfg_attr(feature = "debug", derive(Debug))]
#[cfg_attr(feature = "clone", derive(Clone))]
#[derive(Deserialize, PartialEq)]
pub enum Zigbee540139xDisplayautooff {
    #[serde(rename = "activated")]
    Activated,
    #[serde(rename = "deactivated")]
    Deactivated,
}
#[cfg_attr(feature = "debug", derive(Debug))]
#[cfg_attr(feature = "clone", derive(Clone))]
#[derive(Deserialize, PartialEq)]
pub enum Zigbee540139xPowerupstatus {
    #[serde(rename = "last_state")]
    LastState,
    #[serde(rename = "manual")]
    Manual,
}
#[cfg_attr(feature = "debug", derive(Debug))]
#[cfg_attr(feature = "clone", derive(Clone))]
#[derive(Deserialize, PartialEq)]
pub enum Zigbee540139xRunningstate {
    #[serde(rename = "heat")]
    Heat,
    #[serde(rename = "idle")]
    Idle,
}
#[cfg_attr(feature = "debug", derive(Debug))]
#[cfg_attr(feature = "clone", derive(Clone))]
#[derive(Deserialize, PartialEq)]
pub enum Zigbee540139xSystemmode {
    #[serde(rename = "heat")]
    Heat,
    #[serde(rename = "off")]
    Off,
}
#[cfg_attr(feature = "debug", derive(Debug))]
#[cfg_attr(feature = "clone", derive(Clone))]
#[derive(Deserialize, PartialEq)]
pub enum Zigbee540139xWindowopencheck {
    #[serde(rename = "disable")]
    Disable,
    #[serde(rename = "enable")]
    Enable,
}
#[cfg_attr(feature = "debug", derive(Debug))]
#[cfg_attr(feature = "clone", derive(Clone))]
#[derive(Deserialize, PartialEq)]
pub enum Zigbee89665Poweronbehavior {
    #[serde(rename = "off")]
    Off,
    #[serde(rename = "on")]
    On,
    #[serde(rename = "previous")]
    Previous,
    #[serde(rename = "toggle")]
    Toggle,
}
#[cfg(all(feature = "last_seen_epoch", feature = "last_seen_iso_8601"))]
compile_error!{"Feature last_seen epoch and iso_8601 are mutually exclusive and cannot be enabled together.
This was done because it is a global setting in zigbee2mqtt and therefor can't see a reason both would be enabled.
If you have a any reason to have both ways enabled please submit an issue to https://gitlab.com/seam345/zigbee2mqtt-types/-/issues"}