use serde::Deserialize;
use serde::de::Unexpected;
use serde::de;
use serde::Deserializer;
use zigbee2mqtt_types_base_types::LastSeen;
/// centralite:3156105 [zigbee2mqtt link](https://www.zigbee2mqtt.io/devices/3156105.html)
///
/// 
#[cfg_attr(feature = "debug", derive(Debug))]
#[cfg_attr(feature = "clone", derive(Clone))]
#[derive(Deserialize)]
pub struct Zigbee3156105 {
    ///Remaining battery in %, can take up to 24 hours before reported.
    pub battery: f64,
    ///Mode of the fan
    pub fan_mode: Zigbee3156105Fanmode,
    ///Link quality (signal strength)
    pub linkquality: f64,
    ///Current temperature measured on the device
    pub local_temperature: f64,
    ///Temperature setpoint
    pub occupied_cooling_setpoint: f64,
    ///Temperature setpoint
    pub occupied_heating_setpoint: f64,
    ///The current running state
    pub running_state: Zigbee3156105Runningstate,
    ///Mode of this device
    pub system_mode: Zigbee3156105Systemmode,
    ///Zigbee herdsman description: "Prevent changes. `false` = run normally. `true` = prevent from making changes."
    ///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 temperature_setpoint_hold: bool,
    /// Optional last_seen type, set as a global zigbee2mqtt setting
    pub last_seen: Option<LastSeen>,
    /// Optional elapsed type
    pub elapsed: Option<u64>,
}/// centralite:3157100 [zigbee2mqtt link](https://www.zigbee2mqtt.io/devices/3157100.html)
///
/// 
#[cfg_attr(feature = "debug", derive(Debug))]
#[cfg_attr(feature = "clone", derive(Clone))]
#[derive(Deserialize)]
pub struct Zigbee3157100 {
    ///Remaining battery in %, can take up to 24 hours before reported.
    pub battery: f64,
    ///Mode of the fan
    pub fan_mode: Zigbee3157100Fanmode,
    ///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_cooling_setpoint: f64,
    ///Temperature setpoint
    pub occupied_heating_setpoint: f64,
    ///The current running state
    pub running_state: Zigbee3157100Runningstate,
    ///Mode of this device
    pub system_mode: Zigbee3157100Systemmode,
    ///Zigbee herdsman description: "Prevent changes. `false` = run normally. `true` = prevent from making changes."
    ///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 temperature_setpoint_hold: bool,
    /// Optional last_seen type, set as a global zigbee2mqtt setting
    pub last_seen: Option<LastSeen>,
    /// Optional elapsed type
    pub elapsed: Option<u64>,
}/// centralite:3200-de [zigbee2mqtt link](https://www.zigbee2mqtt.io/devices/3200-de.html)
///
/// 
#[cfg_attr(feature = "debug", derive(Debug))]
#[cfg_attr(feature = "clone", derive(Clone))]
#[derive(Deserialize)]
pub struct Zigbee3200Dde {
    ///Instantaneous measured electrical current
    pub current: f64,
    ///Link quality (signal strength)
    pub linkquality: f64,
    ///Instantaneous measured power
    pub power: 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 = "zigbee3200dde_state_deserializer")]
    pub state: bool,
    ///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 zigbee3200dde_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",
        )),
    }
}

/// centralite:3200-fr [zigbee2mqtt link](https://www.zigbee2mqtt.io/devices/3200-fr.html)
///
/// 
#[cfg_attr(feature = "debug", derive(Debug))]
#[cfg_attr(feature = "clone", derive(Clone))]
#[derive(Deserialize)]
pub struct Zigbee3200Dfr {
    ///Instantaneous measured electrical current
    pub current: f64,
    ///Link quality (signal strength)
    pub linkquality: f64,
    ///Instantaneous measured power
    pub power: 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 = "zigbee3200dfr_state_deserializer")]
    pub state: bool,
    ///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 zigbee3200dfr_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",
        )),
    }
}

/// centralite:3310-G [zigbee2mqtt link](https://www.zigbee2mqtt.io/devices/3310-G.html)
///
/// 
#[cfg_attr(feature = "debug", derive(Debug))]
#[cfg_attr(feature = "clone", derive(Clone))]
#[derive(Deserialize)]
pub struct Zigbee3310Dg {
    ///Remaining battery in %, can take up to 24 hours before reported.
    pub battery: f64,
    ///Measured relative humidity
    pub humidity: f64,
    ///Link quality (signal strength)
    pub linkquality: f64,
    ///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>,
}/// centralite:3315-Geu [zigbee2mqtt link](https://www.zigbee2mqtt.io/devices/3315-Geu.html)
///
/// 
#[cfg_attr(feature = "debug", derive(Debug))]
#[cfg_attr(feature = "clone", derive(Clone))]
#[derive(Deserialize)]
pub struct Zigbee3315Dgeu {
    ///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 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,
    ///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>,
}/// centralite:3323-G [zigbee2mqtt link](https://www.zigbee2mqtt.io/devices/3323-G.html)
///
/// 
#[cfg_attr(feature = "debug", derive(Debug))]
#[cfg_attr(feature = "clone", derive(Clone))]
#[derive(Deserialize)]
pub struct Zigbee3323Dg {
    ///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,
    ///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>,
}/// centralite:3328-G [zigbee2mqtt link](https://www.zigbee2mqtt.io/devices/3328-G.html)
///
/// 
#[cfg_attr(feature = "debug", derive(Debug))]
#[cfg_attr(feature = "clone", derive(Clone))]
#[derive(Deserialize)]
pub struct Zigbee3328Dg {
    ///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>,
}/// centralite:3400-D [zigbee2mqtt link](https://www.zigbee2mqtt.io/devices/3400-D.html)
///
/// 
#[cfg_attr(feature = "debug", derive(Debug))]
#[cfg_attr(feature = "clone", derive(Clone))]
#[derive(Deserialize)]
pub struct Zigbee3400Dd {
    ///Triggered action (e.g. a button click)
    pub action: Zigbee3400DdAction,
    ///Pin code introduced.
    pub action_code: f64,
    ///Last action transaction number.
    pub action_transaction: f64,
    ///Alarm zone. Default value 0
    pub action_zone: f64,
    ///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 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,
    ///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>,
}/// centralite:3420-G [zigbee2mqtt link](https://www.zigbee2mqtt.io/devices/3420-G.html)
///
/// 
#[cfg_attr(feature = "debug", derive(Debug))]
#[cfg_attr(feature = "clone", derive(Clone))]
#[derive(Deserialize)]
pub struct Zigbee3420Dg {
    ///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: Zigbee3420DgPoweronbehavior,
    ///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 = "zigbee3420dg_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 zigbee3420dg_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",
        )),
    }
}

/// centralite:4200-C [zigbee2mqtt link](https://www.zigbee2mqtt.io/devices/4200-C.html)
///
/// 
#[cfg_attr(feature = "debug", derive(Debug))]
#[cfg_attr(feature = "clone", derive(Clone))]
#[derive(Deserialize)]
pub struct Zigbee4200Dc {
    ///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 = "zigbee4200dc_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 zigbee4200dc_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",
        )),
    }
}

/// centralite:4256050-RZHAC [zigbee2mqtt link](https://www.zigbee2mqtt.io/devices/4256050-RZHAC.html)
///
/// 
#[cfg_attr(feature = "debug", derive(Debug))]
#[cfg_attr(feature = "clone", derive(Clone))]
#[derive(Deserialize)]
pub struct Zigbee4256050Drzhac {
    ///Instantaneous measured electrical current
    pub current: f64,
    ///Link quality (signal strength)
    pub linkquality: f64,
    ///Instantaneous measured power
    pub power: 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 = "zigbee4256050drzhac_state_deserializer")]
    pub state: bool,
    ///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 zigbee4256050drzhac_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",
        )),
    }
}

/// centralite:4256050-ZHAC [zigbee2mqtt link](https://www.zigbee2mqtt.io/devices/4256050-ZHAC.html)
///
/// 
#[cfg_attr(feature = "debug", derive(Debug))]
#[cfg_attr(feature = "clone", derive(Clone))]
#[derive(Deserialize)]
pub struct Zigbee4256050Dzhac {
    ///Brightness of this light
    pub brightness: f64,
    ///Instantaneous measured electrical current
    pub current: f64,
    ///Link quality (signal strength)
    pub linkquality: f64,
    ///Instantaneous measured power
    pub power: f64,
    ///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 = "zigbee4256050dzhac_state_deserializer")]
    pub state: bool,
    ///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 zigbee4256050dzhac_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",
        )),
    }
}

/// centralite:4256251-RZHAC [zigbee2mqtt link](https://www.zigbee2mqtt.io/devices/4256251-RZHAC.html)
///
/// 
#[cfg_attr(feature = "debug", derive(Debug))]
#[cfg_attr(feature = "clone", derive(Clone))]
#[derive(Deserialize)]
pub struct Zigbee4256251Drzhac {
    ///Instantaneous measured electrical current
    pub current: f64,
    ///Link quality (signal strength)
    pub linkquality: f64,
    ///Instantaneous measured power
    pub power: 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 = "zigbee4256251drzhac_state_deserializer")]
    pub state: bool,
    ///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 zigbee4256251drzhac_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",
        )),
    }
}

/// centralite:4257050-RZHAC [zigbee2mqtt link](https://www.zigbee2mqtt.io/devices/4257050-RZHAC.html)
///
/// 
#[cfg_attr(feature = "debug", derive(Debug))]
#[cfg_attr(feature = "clone", derive(Clone))]
#[derive(Deserialize)]
pub struct Zigbee4257050Drzhac {
    ///Instantaneous measured electrical current
    pub current: f64,
    ///Link quality (signal strength)
    pub linkquality: f64,
    ///Instantaneous measured power
    pub power: 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 = "zigbee4257050drzhac_state_deserializer")]
    pub state: bool,
    ///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 zigbee4257050drzhac_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",
        )),
    }
}

/// centralite:4257050-ZHAC [zigbee2mqtt link](https://www.zigbee2mqtt.io/devices/4257050-ZHAC.html)
///
/// 
#[cfg_attr(feature = "debug", derive(Debug))]
#[cfg_attr(feature = "clone", derive(Clone))]
#[derive(Deserialize)]
pub struct Zigbee4257050Dzhac {
    ///Brightness of this light
    pub brightness: f64,
    ///Instantaneous measured electrical current
    pub current: f64,
    ///Link quality (signal strength)
    pub linkquality: f64,
    ///Instantaneous measured power
    pub power: f64,
    ///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 = "zigbee4257050dzhac_state_deserializer")]
    pub state: bool,
    ///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 zigbee4257050dzhac_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 Zigbee3156105Fanmode {
    #[serde(rename = "auto")]
    Auto,
    #[serde(rename = "on")]
    On,
}
#[cfg_attr(feature = "debug", derive(Debug))]
#[cfg_attr(feature = "clone", derive(Clone))]
#[derive(Deserialize, PartialEq)]
pub enum Zigbee3156105Runningstate {
    #[serde(rename = "cool")]
    Cool,
    #[serde(rename = "fan_only")]
    FanOnly,
    #[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 Zigbee3156105Systemmode {
    #[serde(rename = "cool")]
    Cool,
    #[serde(rename = "emergency_heating")]
    EmergencyHeating,
    #[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 Zigbee3157100Fanmode {
    #[serde(rename = "auto")]
    Auto,
    #[serde(rename = "on")]
    On,
}
#[cfg_attr(feature = "debug", derive(Debug))]
#[cfg_attr(feature = "clone", derive(Clone))]
#[derive(Deserialize, PartialEq)]
pub enum Zigbee3157100Runningstate {
    #[serde(rename = "cool")]
    Cool,
    #[serde(rename = "fan_only")]
    FanOnly,
    #[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 Zigbee3157100Systemmode {
    #[serde(rename = "cool")]
    Cool,
    #[serde(rename = "emergency_heating")]
    EmergencyHeating,
    #[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 Zigbee3400DdAction {
    #[serde(rename = "arm_all_zones")]
    ArmAllZones,
    #[serde(rename = "arm_day_zones")]
    ArmDayZones,
    #[serde(rename = "arm_night_zones")]
    ArmNightZones,
    #[serde(rename = "disarm")]
    Disarm,
    #[serde(rename = "emergency")]
    Emergency,
    #[serde(rename = "exit_delay")]
    ExitDelay,
}
#[cfg_attr(feature = "debug", derive(Debug))]
#[cfg_attr(feature = "clone", derive(Clone))]
#[derive(Deserialize, PartialEq)]
pub enum Zigbee3420DgPoweronbehavior {
    #[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"}