use serde::Deserialize;
use serde::de::Unexpected;
use serde::de;
use serde::Deserializer;
use zigbee2mqtt_types_base_types::LastSeen;
/// bosch:8750001213 [zigbee2mqtt link](https://www.zigbee2mqtt.io/devices/8750001213.html)
///
/// 
#[cfg_attr(feature = "debug", derive(Debug))]
#[cfg_attr(feature = "clone", derive(Clone))]
#[derive(Deserialize)]
pub struct Zigbee8750001213 {
    ///Mode of the alarm (sound effect)
    pub alarm: Zigbee8750001213Alarm,
    ///Remaining battery in %, can take up to 24 hours before reported.
    pub battery: f64,
    ///The measured CO2 (carbon dioxide) value
    pub co2: f64,
    ///Enable/disable heartbeat
    pub heartbeat: Zigbee8750001213Heartbeat,
    ///Measured relative humidity
    pub humidity: f64,
    ///Measured illuminance in lux
    pub illuminance_lux: f64,
    ///Link quality (signal strength)
    pub linkquality: f64,
    ///Enable/disable pre-alarm
    pub pre_alarm: Zigbee8750001213Prealarm,
    ///Zigbee herdsman description: "Initiate self-test"
    ///Boolean values can be an unintuitive way round: value_on = true and value_off = false, consider double checking Zigbee2MQTT to understand what they mean
    pub self_test: bool,
    ///Sensitivity of the smoke alarm
    pub sensitivity: Zigbee8750001213Sensitivity,
    ///Siren state
    pub siren_state: f64,
    ///Zigbee herdsman description: "Indicates whether the device detected smoke"
    ///Boolean values can be an unintuitive way round: value_on = true and value_off = false, consider double checking Zigbee2MQTT to understand what they mean
    pub smoke: bool,
    ///Measured temperature value
    pub temperature: f64,
    /// Optional last_seen type, set as a global zigbee2mqtt setting
    pub last_seen: Option<LastSeen>,
    /// Optional elapsed type
    pub elapsed: Option<u64>,
}/// bosch:BMCT-SLZ [zigbee2mqtt link](https://www.zigbee2mqtt.io/devices/BMCT-SLZ.html)
///
/// 
#[cfg_attr(feature = "debug", derive(Debug))]
#[cfg_attr(feature = "clone", derive(Clone))]
#[derive(Deserialize)]
pub struct ZigbeeBmctDslz {
    ///Calibration opening time
    pub calibration_closing_time: f64,
    ///Calibration closing time
    pub calibration_opening_time: f64,
    ///Zigbee herdsman description: "Enable/Disable child lock"
    ///The string values get converted into boolean with: ON = true and OFF = false
    #[serde(deserialize_with = "zigbeebmctdslz_child_lock_deserializer")]
    pub child_lock: bool,
    ///Zigbee herdsman description: "Enable/Disable child lock"
    ///The string values get converted into boolean with: ON = true and OFF = false
    #[serde(deserialize_with = "zigbeebmctdslz_child_lock_left_deserializer")]
    pub child_lock_left: bool,
    ///Zigbee herdsman description: "Enable/Disable child lock"
    ///The string values get converted into boolean with: ON = true and OFF = false
    #[serde(deserialize_with = "zigbeebmctdslz_child_lock_right_deserializer")]
    pub child_lock_right: bool,
    ///Device type: 
    pub device_type: ZigbeeBmctDslzDevicetype,
    ///Link quality (signal strength)
    pub linkquality: f64,
    ///Shutter motor actual state 
    pub motor_state: ZigbeeBmctDslzMotorstate,
    ///Position of this cover
    pub position: f64,
    ///Controls the behavior when the device is powered on after power loss
    pub power_on_behavior_left: ZigbeeBmctDslzPoweronbehaviorleft,
    ///Controls the behavior when the device is powered on after power loss
    pub power_on_behavior_right: ZigbeeBmctDslzPoweronbehaviorright,
    pub state: ZigbeeBmctDslzState,
    ///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 = "zigbeebmctdslz_state_left_deserializer")]
    pub state_left: 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 = "zigbeebmctdslz_state_right_deserializer")]
    pub state_right: bool,
    ///Module controlled by a rocker switch or a button
    pub switch_type: ZigbeeBmctDslzSwitchtype,
    /// 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 zigbeebmctdslz_child_lock_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 zigbeebmctdslz_child_lock_left_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 zigbeebmctdslz_child_lock_right_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 zigbeebmctdslz_state_left_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 zigbeebmctdslz_state_right_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",
        )),
    }
}

/// bosch:BSD-2 [zigbee2mqtt link](https://www.zigbee2mqtt.io/devices/BSD-2.html)
///
/// 
#[cfg_attr(feature = "debug", derive(Debug))]
#[cfg_attr(feature = "clone", derive(Clone))]
#[derive(Deserialize)]
pub struct ZigbeeBsdD2 {
    ///Remaining battery in %, can take up to 24 hours before reported.
    pub battery: f64,
    ///Zigbee herdsman description: "Indicates if the battery of this device is almost empty"
    ///Boolean values can be an unintuitive way round: value_on = true and value_off = false, consider double checking Zigbee2MQTT to understand what they mean
    pub battery_low: bool,
    ///Link quality (signal strength)
    pub linkquality: f64,
    ///Zigbee herdsman description: "Indicates whether the device detected smoke"
    ///Boolean values can be an unintuitive way round: value_on = true and value_off = false, consider double checking Zigbee2MQTT to understand what they mean
    pub smoke: bool,
    ///Zigbee herdsman description: "Indicates whether the device is being tested"
    ///Boolean values can be an unintuitive way round: value_on = true and value_off = false, consider double checking Zigbee2MQTT to understand what they mean
    pub test: bool,
    /// Optional last_seen type, set as a global zigbee2mqtt setting
    pub last_seen: Option<LastSeen>,
    /// Optional elapsed type
    pub elapsed: Option<u64>,
}/// bosch:BSEN-C2 [zigbee2mqtt link](https://www.zigbee2mqtt.io/devices/BSEN-C2.html)
///
/// 
#[cfg_attr(feature = "debug", derive(Debug))]
#[cfg_attr(feature = "clone", derive(Clone))]
#[derive(Deserialize)]
pub struct ZigbeeBsenDc2 {
    ///Triggered action (e.g. a button click)
    pub action: ZigbeeBsenDc2Action,
    ///Zigbee herdsman description: "Indicates if the battery of this device is almost empty"
    ///Boolean values can be an unintuitive way round: value_on = true and value_off = false, consider double checking Zigbee2MQTT to understand what they mean
    pub battery_low: bool,
    ///Zigbee herdsman description: "Indicates if the contact is closed (= true) or open (= false)"
    ///Boolean values can be an unintuitive way round: value_on = false and value_off = true, consider double checking Zigbee2MQTT to understand what they mean
    pub contact: bool,
    ///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>,
}/// bosch:BSP-EZ2 [zigbee2mqtt link](https://www.zigbee2mqtt.io/devices/BSP-EZ2.html)
///
/// 
#[cfg_attr(feature = "debug", derive(Debug))]
#[cfg_attr(feature = "clone", derive(Clone))]
#[derive(Deserialize)]
pub struct ZigbeeBspDez2 {
    ///Sum of consumed energy
    pub energy: 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: ZigbeeBspDez2Poweronbehavior,
    ///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 = "zigbeebspdez2_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 zigbeebspdez2_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",
        )),
    }
}

/// bosch:BSP-FZ2 [zigbee2mqtt link](https://www.zigbee2mqtt.io/devices/BSP-FZ2.html)
///
/// 
#[cfg_attr(feature = "debug", derive(Debug))]
#[cfg_attr(feature = "clone", derive(Clone))]
#[derive(Deserialize)]
pub struct ZigbeeBspDfz2 {
    ///Sum of consumed energy
    pub energy: 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: ZigbeeBspDfz2Poweronbehavior,
    ///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 = "zigbeebspdfz2_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 zigbeebspdfz2_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",
        )),
    }
}

/// bosch:BTH-RA [zigbee2mqtt link](https://www.zigbee2mqtt.io/devices/BTH-RA.html)
///
/// 
#[cfg_attr(feature = "debug", derive(Debug))]
#[cfg_attr(feature = "clone", derive(Clone))]
#[derive(Deserialize)]
pub struct ZigbeeBthDra {
    ///Remaining battery in %, can take up to 24 hours before reported.
    pub battery: f64,
    ///Zigbee herdsman description: "Activate Boost heating"
    ///The string values get converted into boolean with: ON = true and OFF = false
    #[serde(deserialize_with = "zigbeebthdra_boost_deserializer")]
    pub boost: bool,
    ///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 = "zigbeebthdra_child_lock_deserializer")]
    pub child_lock: bool,
    ///Specifies the brightness value of the display
    pub display_brightness: f64,
    ///Specifies the diplay On-time
    pub display_ontime: f64,
    ///Display orientation
    pub display_orientation: ZigbeeBthDraDisplayorientation,
    ///Temperature displayed on the thermostat
    pub displayed_temperature: ZigbeeBthDraDisplayedtemperature,
    ///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,
    ///Position of the valve (= demanded heat) where 0% is fully closed and 100% is fully open
    pub pi_heating_demand: f64,
    ///Input for remote temperature sensor. Setting this will disable the internal temperature sensor until batteries are removed!
    pub remote_temperature: f64,
    ///The current running state
    pub running_state: ZigbeeBthDraRunningstate,
    ///Mode of this device
    pub system_mode: ZigbeeBthDraSystemmode,
    ///Zigbee herdsman description: "Window open"
    ///The string values get converted into boolean with: ON = true and OFF = false
    #[serde(deserialize_with = "zigbeebthdra_window_open_deserializer")]
    pub window_open: 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 zigbeebthdra_boost_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 zigbeebthdra_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",
        )),
    }
}


/// Deserialize bool from String with custom value mapping
fn zigbeebthdra_window_open_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",
        )),
    }
}

/// bosch:BWA-1 [zigbee2mqtt link](https://www.zigbee2mqtt.io/devices/BWA-1.html)
///
/// 
#[cfg_attr(feature = "debug", derive(Debug))]
#[cfg_attr(feature = "clone", derive(Clone))]
#[derive(Deserialize)]
pub struct ZigbeeBwaD1 {
    ///Zigbee herdsman description: "Enable/Disable sound alarm on motion"
    ///The string values get converted into boolean with: ON = true and OFF = false
    #[serde(deserialize_with = "zigbeebwad1_alarm_on_motion_deserializer")]
    pub alarm_on_motion: bool,
    ///Remaining battery in %, can take up to 24 hours before reported.
    pub battery: f64,
    ///Link quality (signal strength)
    pub linkquality: f64,
    ///Zigbee herdsman description: "Indicates whether the device is tampered"
    ///Boolean values can be an unintuitive way round: value_on = true and value_off = false, consider double checking Zigbee2MQTT to understand what they mean
    pub tamper: bool,
    ///Zigbee herdsman description: "Indicates whether the device detected a water leak"
    ///Boolean values can be an unintuitive way round: value_on = true and value_off = false, consider double checking Zigbee2MQTT to understand what they mean
    pub water_leak: 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 zigbeebwad1_alarm_on_motion_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",
        )),
    }
}

/// bosch:ISW-ZPR1-WP13 [zigbee2mqtt link](https://www.zigbee2mqtt.io/devices/ISW-ZPR1-WP13.html)
///
/// 
#[cfg_attr(feature = "debug", derive(Debug))]
#[cfg_attr(feature = "clone", derive(Clone))]
#[derive(Deserialize)]
pub struct ZigbeeIswDzpr1Dwp13 {
    ///Remaining battery in %, can take up to 24 hours before reported.
    pub battery: f64,
    ///Zigbee herdsman description: "Indicates if the battery of this device is almost empty"
    ///Boolean values can be an unintuitive way round: value_on = true and value_off = false, consider double checking Zigbee2MQTT to understand what they mean
    pub battery_low: bool,
    ///Link quality (signal strength)
    pub linkquality: f64,
    ///Zigbee herdsman description: "Indicates whether the device detected occupancy"
    ///Boolean values can be an unintuitive way round: value_on = true and value_off = false, consider double checking Zigbee2MQTT to understand what they mean
    pub occupancy: bool,
    ///Zigbee herdsman description: "Indicates whether the device is tampered"
    ///Boolean values can be an unintuitive way round: value_on = true and value_off = false, consider double checking Zigbee2MQTT to understand what they mean
    pub tamper: bool,
    ///Measured temperature value
    pub temperature: f64,
    /// Optional last_seen type, set as a global zigbee2mqtt setting
    pub last_seen: Option<LastSeen>,
    /// Optional elapsed type
    pub elapsed: Option<u64>,
}/// bosch:RADON TriTech ZB [zigbee2mqtt link](https://www.zigbee2mqtt.io/devices/RADON_TriTech_ZB.html)
///
/// 
#[cfg_attr(feature = "debug", derive(Debug))]
#[cfg_attr(feature = "clone", derive(Clone))]
#[derive(Deserialize)]
pub struct ZigbeeRadontritechzb {
    ///Remaining battery in %, can take up to 24 hours before reported.
    pub battery: f64,
    ///Zigbee herdsman description: "Indicates if the battery of this device is almost empty"
    ///Boolean values can be an unintuitive way round: value_on = true and value_off = false, consider double checking Zigbee2MQTT to understand what they mean
    pub battery_low: bool,
    ///Raw measured illuminance
    pub illuminance: f64,
    ///Measured illuminance in lux
    pub illuminance_lux: f64,
    ///Link quality (signal strength)
    pub linkquality: f64,
    ///Zigbee herdsman description: "Indicates whether the device detected occupancy"
    ///Boolean values can be an unintuitive way round: value_on = true and value_off = false, consider double checking Zigbee2MQTT to understand what they mean
    pub occupancy: bool,
    ///Zigbee herdsman description: "Indicates whether the device is tampered"
    ///Boolean values can be an unintuitive way round: value_on = true and value_off = false, consider double checking Zigbee2MQTT to understand what they mean
    pub tamper: bool,
    ///Measured temperature value
    pub temperature: f64,
    /// Optional last_seen type, set as a global zigbee2mqtt setting
    pub last_seen: Option<LastSeen>,
    /// Optional elapsed type
    pub elapsed: Option<u64>,
}/// bosch:RFPR-ZB-SH-EU [zigbee2mqtt link](https://www.zigbee2mqtt.io/devices/RFPR-ZB-SH-EU.html)
///
/// 
#[cfg_attr(feature = "debug", derive(Debug))]
#[cfg_attr(feature = "clone", derive(Clone))]
#[derive(Deserialize)]
pub struct ZigbeeRfprDzbDshDeu {
    ///Remaining battery in %, can take up to 24 hours before reported.
    pub battery: f64,
    ///Zigbee herdsman description: "Indicates if the battery of this device is almost empty"
    ///Boolean values can be an unintuitive way round: value_on = true and value_off = false, consider double checking Zigbee2MQTT to understand what they mean
    pub battery_low: bool,
    ///Link quality (signal strength)
    pub linkquality: f64,
    ///Zigbee herdsman description: "Indicates whether the device detected occupancy"
    ///Boolean values can be an unintuitive way round: value_on = true and value_off = false, consider double checking Zigbee2MQTT to understand what they mean
    pub occupancy: bool,
    ///Zigbee herdsman description: "Indicates whether the device is tampered"
    ///Boolean values can be an unintuitive way round: value_on = true and value_off = false, consider double checking Zigbee2MQTT to understand what they mean
    pub tamper: bool,
    ///Measured temperature value
    pub temperature: f64,
    /// Optional last_seen type, set as a global zigbee2mqtt setting
    pub last_seen: Option<LastSeen>,
    /// Optional elapsed type
    pub elapsed: Option<u64>,
}
#[cfg_attr(feature = "debug", derive(Debug))]
#[cfg_attr(feature = "clone", derive(Clone))]
#[derive(Deserialize, PartialEq)]
pub enum Zigbee8750001213Alarm {
    #[serde(rename = "burglar")]
    Burglar,
    #[serde(rename = "fire")]
    Fire,
    #[serde(rename = "pre_alarm")]
    PreAlarm,
    #[serde(rename = "stop")]
    Stop,
}
#[cfg_attr(feature = "debug", derive(Debug))]
#[cfg_attr(feature = "clone", derive(Clone))]
#[derive(Deserialize, PartialEq)]
pub enum Zigbee8750001213Heartbeat {
    #[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 Zigbee8750001213Prealarm {
    #[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 Zigbee8750001213Sensitivity {
    #[serde(rename = "high")]
    High,
    #[serde(rename = "low")]
    Low,
    #[serde(rename = "medium")]
    Medium,
}
#[cfg_attr(feature = "debug", derive(Debug))]
#[cfg_attr(feature = "clone", derive(Clone))]
#[derive(Deserialize, PartialEq)]
pub enum ZigbeeBmctDslzDevicetype {
    #[serde(rename = "light")]
    Light,
    #[serde(rename = "shutter")]
    Shutter,
}
#[cfg_attr(feature = "debug", derive(Debug))]
#[cfg_attr(feature = "clone", derive(Clone))]
#[derive(Deserialize, PartialEq)]
pub enum ZigbeeBmctDslzMotorstate {
    #[serde(rename = "closing")]
    Closing,
    #[serde(rename = "idle")]
    Idle,
    #[serde(rename = "opening")]
    Opening,
}
#[cfg_attr(feature = "debug", derive(Debug))]
#[cfg_attr(feature = "clone", derive(Clone))]
#[derive(Deserialize, PartialEq)]
pub enum ZigbeeBmctDslzPoweronbehaviorleft {
    #[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 ZigbeeBmctDslzPoweronbehaviorright {
    #[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 ZigbeeBmctDslzState {
    #[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 ZigbeeBmctDslzSwitchtype {
    #[serde(rename = "button")]
    Button,
    #[serde(rename = "button_key_change")]
    ButtonKeyChange,
    #[serde(rename = "rocker_rwitch_key_change")]
    RockerRwitchKeyChange,
    #[serde(rename = "rocker_switch")]
    RockerSwitch,
}
#[cfg_attr(feature = "debug", derive(Debug))]
#[cfg_attr(feature = "clone", derive(Clone))]
#[derive(Deserialize, PartialEq)]
pub enum ZigbeeBsenDc2Action {
    #[serde(rename = "long")]
    Long,
    #[serde(rename = "single")]
    Single,
}
#[cfg_attr(feature = "debug", derive(Debug))]
#[cfg_attr(feature = "clone", derive(Clone))]
#[derive(Deserialize, PartialEq)]
pub enum ZigbeeBspDez2Poweronbehavior {
    #[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 ZigbeeBspDfz2Poweronbehavior {
    #[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 ZigbeeBthDraDisplayedtemperature {
    #[serde(rename = "measured")]
    Measured,
    #[serde(rename = "target")]
    Target,
}
#[cfg_attr(feature = "debug", derive(Debug))]
#[cfg_attr(feature = "clone", derive(Clone))]
#[derive(Deserialize, PartialEq)]
pub enum ZigbeeBthDraDisplayorientation {
    #[serde(rename = "flipped")]
    Flipped,
    #[serde(rename = "normal")]
    Normal,
}
#[cfg_attr(feature = "debug", derive(Debug))]
#[cfg_attr(feature = "clone", derive(Clone))]
#[derive(Deserialize, PartialEq)]
pub enum ZigbeeBthDraRunningstate {
    #[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 ZigbeeBthDraSystemmode {
    #[serde(rename = "auto")]
    Auto,
    #[serde(rename = "heat")]
    Heat,
    #[serde(rename = "off")]
    Off,
}
#[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"}