diff --git a/homeassistant-mqtt-discovery/src/integrations.rs b/homeassistant-mqtt-discovery/src/integrations.rs
index 569e04f..57795f0 100644
--- a/homeassistant-mqtt-discovery/src/integrations.rs
+++ b/homeassistant-mqtt-discovery/src/integrations.rs
@@ -1,11 +1,16 @@
-mod alarm_control_panel {
-    #[derive(Debug, PartialEq, Eq, Clone)]
-    #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
-    struct Discovery {
-        /// The MQTT topic subscribed to receive availability (online/offline) updates. Must not be used together with `availability`.
-        #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
-        pub availability_topic: Option<String>,
+use crate::{Device, Template};
+#[cfg(feature = "serde")]
+use serde::{Deserialize, Serialize};
 
+// TODO:
+pub type Icon = ();
+
+pub mod alarm_control_panel {
+    use super::*;
+
+    #[derive(Debug, PartialEq, Clone)]
+    #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+    pub struct Discovery {
         /// If defined, specifies a code to enable or disable the alarm in the frontend. Note that the code is validated locally and blocks sending MQTT messages to the remote device. For remote code validation, the code can be configured to either of the special values `REMOTE_CODE` (numeric code) or `REMOTE_CODE_TEXT` (text code). In this case, local code validation is bypassed but the frontend will still show a numeric or text code dialog. Use `command_template` to send the code to the remote device. Example configurations for remote code validation [can be found here](#configurations-with-remote-code-validation).
         #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
         pub code: Option<String>,
@@ -112,41 +117,17 @@ mod alarm_control_panel {
         #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
         pub supported_features: Option<Vec<_>>,
 
-        #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
-        pub unique_id: Option<UNKNOWN>,
-
         /// Defines a [template](/docs/configuration/templating/#using-templates-with-the-mqtt-integration) to extract the value.
         #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
         pub value_template: Option<Template>,
     }
-
-    #[derive(Debug, PartialEq, Eq, Clone)]
-    #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
-    struct Availability {
-        /// The payload that represents the available state.
-        #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
-        pub payload_available: Option<String>,
-
-        /// The payload that represents the unavailable state.
-        #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
-        pub payload_not_available: Option<String>,
-
-        /// An MQTT topic subscribed to receive availability (online/offline) updates.
-        pub topic: String,
-
-        /// Defines a [template](/docs/configuration/templating/#using-templates-with-the-mqtt-integration) to extract device's availability from the `topic`. To determine the devices's availability result of this template will be compared to `payload_available` and `payload_not_available`.
-        #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
-        pub value_template: Option<Template>,
-    }
 }
-mod binary_sensor {
-    #[derive(Debug, PartialEq, Eq, Clone)]
-    #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
-    struct Discovery {
-        /// The MQTT topic subscribed to receive birth and LWT messages from the MQTT device. If `availability` is not defined, the binary sensor will always be considered `available` and its state will be `on`, `off` or `unknown`. If `availability` is defined, the binary sensor will be considered as `unavailable` by default and the sensor's initial state will be `unavailable`. Must not be used together with `availability`.
-        #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
-        pub availability_topic: Option<String>,
+pub mod binary_sensor {
+    use super::*;
 
+    #[derive(Debug, PartialEq, Clone)]
+    #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+    pub struct Discovery {
         /// Sets the [class of the device](/integrations/binary_sensor/#device-class), changing the device state and icon that is displayed on the frontend. The `device_class` can be `null`.
         #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
         pub device_class: Option<String>,
@@ -218,42 +199,17 @@ mod binary_sensor {
         /// The MQTT topic subscribed to receive sensor's state.
         pub state_topic: String,
 
-        /// An ID that uniquely identifies this sensor. If two sensors have the same unique ID, Home Assistant will raise an exception.
-        #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
-        pub unique_id: Option<String>,
-
         /// Defines a [template](/docs/configuration/templating/#using-templates-with-the-mqtt-integration) that returns a string to be compared to `payload_on`/`payload_off` or an empty string, in which case the MQTT message will be removed. Remove this option when `payload_on` and `payload_off` are sufficient to match your payloads (i.e no preprocessing of original message is required).
         #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
         pub value_template: Option<Template>,
     }
-
-    #[derive(Debug, PartialEq, Eq, Clone)]
-    #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
-    struct Availability {
-        /// The payload that represents the available state.
-        #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
-        pub payload_available: Option<String>,
-
-        /// The payload that represents the unavailable state.
-        #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
-        pub payload_not_available: Option<String>,
-
-        /// An MQTT topic subscribed to receive availability (online/offline) updates.
-        pub topic: String,
-
-        /// Defines a [template](/docs/configuration/templating/#using-templates-with-the-mqtt-integration) to extract device's availability from the `topic`. To determine the devices's availability result of this template will be compared to `payload_available` and `payload_not_available`.
-        #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
-        pub value_template: Option<Template>,
-    }
 }
-mod button {
-    #[derive(Debug, PartialEq, Eq, Clone)]
-    #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
-    struct Discovery {
-        /// The MQTT topic subscribed to receive availability (online/offline) updates. Must not be used together with `availability`.
-        #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
-        pub availability_topic: Option<String>,
+pub mod button {
+    use super::*;
 
+    #[derive(Debug, PartialEq, Clone)]
+    #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+    pub struct Discovery {
         /// Defines a [template](/docs/configuration/templating/#using-templates-with-the-mqtt-integration) to generate the payload to send to `command_topic`.
         #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
         pub command_template: Option<Template>,
@@ -317,39 +273,14 @@ mod button {
         /// If the published message should have the retain flag on or not.
         #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
         pub retain: Option<bool>,
-
-        /// An ID that uniquely identifies this button entity. If two buttons have the same unique ID, Home Assistant will raise an exception.
-        #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
-        pub unique_id: Option<String>,
-    }
-
-    #[derive(Debug, PartialEq, Eq, Clone)]
-    #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
-    struct Availability {
-        /// The payload that represents the available state.
-        #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
-        pub payload_available: Option<String>,
-
-        /// The payload that represents the unavailable state.
-        #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
-        pub payload_not_available: Option<String>,
-
-        /// An MQTT topic subscribed to receive availability (online/offline) updates.
-        pub topic: String,
-
-        /// Defines a [template](/docs/configuration/templating/#using-templates-with-the-mqtt-integration) to extract device's availability from the `topic`. To determine the devices's availability result of this template will be compared to `payload_available` and `payload_not_available`.
-        #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
-        pub value_template: Option<Template>,
     }
 }
-mod camera {
-    #[derive(Debug, PartialEq, Eq, Clone)]
-    #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
-    struct Discovery {
-        /// The MQTT topic subscribed to receive availability (online/offline) updates. Must not be used together with `availability`.
-        #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
-        pub availability_topic: Option<String>,
+pub mod camera {
+    use super::*;
 
+    #[derive(Debug, PartialEq, Clone)]
+    #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+    pub struct Discovery {
         /// Flag which defines if the entity should be enabled when first added.
         #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
         pub enabled_by_default: Option<bool>,
@@ -388,35 +319,14 @@ mod camera {
 
         /// The MQTT topic to subscribe to.
         pub topic: String,
-
-        /// An ID that uniquely identifies this camera. If two cameras have the same unique ID Home Assistant will raise an exception.
-        #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
-        pub unique_id: Option<String>,
-    }
-
-    #[derive(Debug, PartialEq, Eq, Clone)]
-    #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
-    struct Availability {
-        /// The payload that represents the available state.
-        #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
-        pub payload_available: Option<String>,
-
-        /// The payload that represents the unavailable state.
-        #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
-        pub payload_not_available: Option<String>,
-
-        /// An MQTT topic subscribed to receive availability (online/offline) updates.
-        pub topic: String,
-
-        /// Defines a [template](/docs/configuration/templating/#using-templates-with-the-mqtt-integration) to extract device's availability from the `topic`. To determine the devices's availability result of this template will be compared to `payload_available` and `payload_not_available`.
-        #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
-        pub value_template: Option<Template>,
     }
 }
-mod climate {
-    #[derive(Debug, PartialEq, Eq, Clone)]
+pub mod climate {
+    use super::*;
+
+    #[derive(Debug, PartialEq, Clone)]
     #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
-    struct Discovery {
+    pub struct Discovery {
         /// A template to render the value received on the `action_topic` with.
         #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
         pub action_template: Option<Template>,
@@ -427,10 +337,6 @@ mod climate {
         #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
         pub action_topic: Option<String>,
 
-        /// The MQTT topic subscribed to receive availability (online/offline) updates. Must not be used together with `availability`.
-        #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
-        pub availability_topic: Option<String>,
-
         /// A template with which the value received on `current_humidity_topic` will be rendered.
         #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
         pub current_humidity_template: Option<Template>,
@@ -691,41 +597,17 @@ mod climate {
         #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
         pub temp_step: Option<f32>,
 
-        #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
-        pub unique_id: Option<UNKNOWN>,
-
         /// Default template to render the payloads on *all* `*_state_topic`s with.
         #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
         pub value_template: Option<Template>,
     }
-
-    #[derive(Debug, PartialEq, Eq, Clone)]
-    #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
-    struct Availability {
-        /// The payload that represents the available state.
-        #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
-        pub payload_available: Option<String>,
-
-        /// The payload that represents the unavailable state.
-        #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
-        pub payload_not_available: Option<String>,
-
-        /// An MQTT topic subscribed to receive availability (online/offline) updates.
-        pub topic: String,
-
-        /// Defines a [template](/docs/configuration/templating/#using-templates-with-the-mqtt-integration) to extract device's availability from the `topic`. To determine the devices's availability result of this template will be compared to `payload_available` and `payload_not_available`.
-        #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
-        pub value_template: Option<Template>,
-    }
 }
-mod cover {
-    #[derive(Debug, PartialEq, Eq, Clone)]
-    #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
-    struct Discovery {
-        /// The subscribed-to MQTT topic to receive birth and LWT messages from the MQTT cover device. If an `availability` topic is not defined, the cover availability state will always be `available`. If an `availability` topic is defined, the cover availability state will be `unavailable` by default. Must not be used together with `availability`.
-        #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
-        pub availability_topic: Option<String>,
+pub mod cover {
+    use super::*;
 
+    #[derive(Debug, PartialEq, Clone)]
+    #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+    pub struct Discovery {
         /// The MQTT topic to publish commands to control the cover.
         #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
         pub command_topic: Option<String>,
@@ -882,42 +764,17 @@ mod cover {
         #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
         pub tilt_status_topic: Option<String>,
 
-        /// An ID that uniquely identifies this cover. If two covers have the same unique ID, Home Assistant will raise an exception.
-        #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
-        pub unique_id: Option<String>,
-
         /// Defines a [template](/docs/configuration/templating/#using-templates-with-the-mqtt-integration) that can be used to extract the payload for the `state_topic` topic.
         #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
         pub value_template: Option<Template>,
     }
-
-    #[derive(Debug, PartialEq, Eq, Clone)]
-    #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
-    struct Availability {
-        /// The payload that represents the available state.
-        #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
-        pub payload_available: Option<String>,
-
-        /// The payload that represents the unavailable state.
-        #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
-        pub payload_not_available: Option<String>,
-
-        /// An MQTT topic subscribed to receive availability (online/offline) updates.
-        pub topic: String,
-
-        /// Defines a [template](/docs/configuration/templating/#using-templates-with-the-mqtt-integration) to extract device's availability from the `topic`. To determine the devices's availability result of this template will be compared to `payload_available` and `payload_not_available`.
-        #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
-        pub value_template: Option<Template>,
-    }
 }
-mod device_tracker {
-    #[derive(Debug, PartialEq, Eq, Clone)]
-    #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
-    struct Discovery {
-        /// The MQTT topic subscribed to receive availability (online/offline) updates. Must not be used together with `availability`.
-        #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
-        pub availability_topic: Option<String>,
+pub mod device_tracker {
+    use super::*;
 
+    #[derive(Debug, PartialEq, Clone)]
+    #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+    pub struct Discovery {
         /// [Icon](/docs/configuration/customizing-devices/#icon) for the entity.
         #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
         pub icon: Option<Icon>,
@@ -975,38 +832,17 @@ mod device_tracker {
         #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
         pub state_topic: Option<String>,
 
-        /// An ID that uniquely identifies this device_tracker. If two device_trackers have the same unique ID, Home Assistant will raise an exception.
-        #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
-        pub unique_id: Option<String>,
-
         /// Defines a [template](/docs/configuration/templating/#using-templates-with-the-mqtt-integration) that returns a device tracker state.
         #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
         pub value_template: Option<Template>,
     }
-
-    #[derive(Debug, PartialEq, Eq, Clone)]
-    #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
-    struct Availability {
-        /// The payload that represents the available state.
-        #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
-        pub payload_available: Option<String>,
-
-        /// The payload that represents the unavailable state.
-        #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
-        pub payload_not_available: Option<String>,
-
-        /// An MQTT topic subscribed to receive availability (online/offline) updates.
-        pub topic: String,
-
-        /// Defines a [template](/docs/configuration/templating/#using-templates-with-the-mqtt-integration) to extract device's availability from the `topic`. To determine the devices's availability result of this template will be compared to `payload_available` and `payload_not_available`.
-        #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
-        pub value_template: Option<Template>,
-    }
 }
-mod device_trigger {
-    #[derive(Debug, PartialEq, Eq, Clone)]
+pub mod device_trigger {
+    use super::*;
+
+    #[derive(Debug, PartialEq, Clone)]
     #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
-    struct Discovery {
+    pub struct Discovery {
         /// The type of automation, must be 'trigger'.
         pub automation_type: String,
 
@@ -1035,14 +871,12 @@ mod device_trigger {
         pub value_template: Option<Template>,
     }
 }
-mod event {
-    #[derive(Debug, PartialEq, Eq, Clone)]
-    #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
-    struct Discovery {
-        /// The MQTT topic subscribed to receive availability (online/offline) updates. Must not be used together with `availability`.
-        #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
-        pub availability_topic: Option<String>,
+pub mod event {
+    use super::*;
 
+    #[derive(Debug, PartialEq, Clone)]
+    #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+    pub struct Discovery {
         /// The [type/class](/integrations/event/#device-class) of the event to set the icon in the frontend. The `device_class` can be `null`.
         #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
         pub device_class: Option<_>,
@@ -1097,42 +931,17 @@ mod event {
         /// The MQTT topic subscribed to receive JSON event payloads. The JSON payload should contain the `event_type` element. The event type should be one of the configured `event_types`. Note that replayed retained messages will be discarded.
         pub state_topic: String,
 
-        /// An ID that uniquely identifies this event entity. If two events have the same unique ID, Home Assistant will raise an exception.
-        #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
-        pub unique_id: Option<String>,
-
         /// Defines a [template](/docs/configuration/templating/#using-templates-with-the-mqtt-integration) to extract the value and render it to a valid JSON event payload. If the template throws an error, the current state will be used instead.
         #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
         pub value_template: Option<Template>,
     }
-
-    #[derive(Debug, PartialEq, Eq, Clone)]
-    #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
-    struct Availability {
-        /// The payload that represents the available state.
-        #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
-        pub payload_available: Option<String>,
-
-        /// The payload that represents the unavailable state.
-        #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
-        pub payload_not_available: Option<String>,
-
-        /// An MQTT topic subscribed to receive availability (online/offline) updates.
-        pub topic: String,
-
-        /// Defines a [template](/docs/configuration/templating/#using-templates-with-the-mqtt-integration) to extract device's availability from the `topic`. To determine the devices's availability result of this template will be compared to `payload_available` and `payload_not_available`.
-        #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
-        pub value_template: Option<Template>,
-    }
 }
-mod fan {
-    #[derive(Debug, PartialEq, Eq, Clone)]
-    #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
-    struct Discovery {
-        /// The MQTT topic subscribed to receive availability (online/offline) updates. Must not be used together with `availability`.
-        #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
-        pub availability_topic: Option<String>,
+pub mod fan {
+    use super::*;
 
+    #[derive(Debug, PartialEq, Clone)]
+    #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+    pub struct Discovery {
         /// Defines a [template](/docs/configuration/templating/#using-templates-with-the-mqtt-integration) to generate the payload to send to `command_topic`.
         #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
         pub command_template: Option<Template>,
@@ -1299,35 +1108,14 @@ mod fan {
         /// Defines a [template](/docs/configuration/templating/#using-templates-with-the-mqtt-integration) to extract a value from the state.
         #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
         pub state_value_template: Option<Template>,
-
-        /// An ID that uniquely identifies this fan. If two fans have the same unique ID, Home Assistant will raise an exception.
-        #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
-        pub unique_id: Option<String>,
-    }
-
-    #[derive(Debug, PartialEq, Eq, Clone)]
-    #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
-    struct Availability {
-        /// The payload that represents the available state.
-        #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
-        pub payload_available: Option<String>,
-
-        /// The payload that represents the unavailable state.
-        #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
-        pub payload_not_available: Option<String>,
-
-        /// An MQTT topic subscribed to receive availability (online/offline) updates.
-        pub topic: String,
-
-        /// Defines a [template](/docs/configuration/templating/#using-templates-with-the-mqtt-integration) to extract device's availability from the `topic`. To determine the devices's availability result of this template will be compared to `payload_available` and `payload_not_available`.
-        #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
-        pub value_template: Option<Template>,
     }
 }
-mod humidifier {
-    #[derive(Debug, PartialEq, Eq, Clone)]
+pub mod humidifier {
+    use super::*;
+
+    #[derive(Debug, PartialEq, Clone)]
     #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
-    struct Discovery {
+    pub struct Discovery {
         /// A template to render the value received on the `action_topic` with.
         #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
         pub action_template: Option<Template>,
@@ -1338,10 +1126,6 @@ mod humidifier {
         #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
         pub action_topic: Option<String>,
 
-        /// The MQTT topic subscribed to receive availability (online/offline) updates. Must not be used together with `availability`.
-        #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
-        pub availability_topic: Option<String>,
-
         /// A template with which the value received on `current_humidity_topic` will be rendered.
         #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
         pub current_humidity_template: Option<Template>,
@@ -1479,39 +1263,14 @@ mod humidifier {
         /// Defines a [template](/docs/configuration/templating/#using-templates-with-the-mqtt-integration) to extract a value from the state.
         #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
         pub state_value_template: Option<Template>,
-
-        /// An ID that uniquely identifies this humidifier. If two humidifiers have the same unique ID, Home Assistant will raise an exception.
-        #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
-        pub unique_id: Option<String>,
-    }
-
-    #[derive(Debug, PartialEq, Eq, Clone)]
-    #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
-    struct Availability {
-        /// The payload that represents the available state.
-        #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
-        pub payload_available: Option<String>,
-
-        /// The payload that represents the unavailable state.
-        #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
-        pub payload_not_available: Option<String>,
-
-        /// An MQTT topic subscribed to receive availability (online/offline) updates.
-        pub topic: String,
-
-        /// Defines a [template](/docs/configuration/templating/#using-templates-with-the-mqtt-integration) to extract device's availability from the `topic`. To determine the devices's availability result of this template will be compared to `payload_available` and `payload_not_available`.
-        #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
-        pub value_template: Option<Template>,
     }
 }
-mod image {
-    #[derive(Debug, PartialEq, Eq, Clone)]
-    #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
-    struct Discovery {
-        /// The MQTT topic subscribed to receive availability (online/offline) updates. Must not be used together with `availability`.
-        #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
-        pub availability_topic: Option<String>,
+pub mod image {
+    use super::*;
 
+    #[derive(Debug, PartialEq, Clone)]
+    #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+    pub struct Discovery {
         /// The content type of and image data message received on `image_topic`. This option cannot be used with the `url_topic` because the content type is derived when downloading the image.
         #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
         pub content_type: Option<String>,
@@ -1556,10 +1315,6 @@ mod image {
         #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
         pub object_id: Option<String>,
 
-        /// An ID that uniquely identifies this image. If two images have the same unique ID Home Assistant will raise an exception.
-        #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
-        pub unique_id: Option<String>,
-
         /// Defines a [template](/docs/configuration/templating/#using-templates-with-the-mqtt-integration) to extract the image URL from a message received at `url_topic`.
         #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
         pub url_template: Option<Template>,
@@ -1568,30 +1323,13 @@ mod image {
         #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
         pub url_topic: Option<String>,
     }
-
-    #[derive(Debug, PartialEq, Eq, Clone)]
-    #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
-    struct Availability {
-        /// The payload that represents the available state.
-        #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
-        pub payload_available: Option<String>,
-
-        /// The payload that represents the unavailable state.
-        #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
-        pub payload_not_available: Option<String>,
-
-        /// An MQTT topic subscribed to receive availability (online/offline) updates.
-        pub topic: String,
-
-        /// Defines a [template](/docs/configuration/templating/#using-templates-with-the-mqtt-integration) to extract device's availability from the `topic`. To determine the devices's availability result of this template will be compared to `payload_available` and `payload_not_available`.
-        #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
-        pub value_template: Option<Template>,
-    }
 }
-mod lawn_mower {
-    #[derive(Debug, PartialEq, Eq, Clone)]
+pub mod lawn_mower {
+    use super::*;
+
+    #[derive(Debug, PartialEq, Clone)]
     #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
-    struct Discovery {
+    pub struct Discovery {
         /// The MQTT topic subscribed to receive an update of the activity. Valid activities are `mowing`, `paused`, `docked`, and `error`. Use `value_template` to extract the activity state from a custom payload. When payload `none` is received, the activity state will be reset to `unknown`.  
         #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
         pub activity_state_topic: Option<String>,
@@ -1600,13 +1338,6 @@ mod lawn_mower {
         #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
         pub activity_value_template: Option<Template>,
 
-        /// The MQTT topic subscribed to receive availability (online/offline) updates. Must not be used together with `availability`.
-        #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
-        pub availability_topic: Option<String>,
-
-        #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
-        pub availability_mode: Option<UNKNOWN>,
-
         /// Defines a [template](/docs/configuration/templating/#using-templates-with-the-mqtt-integration) to extract device's availability from the `availability_topic`. To determine the devices's availability, the result of this template will be compared to `payload_available` and `payload_not_available`.
         #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
         pub availability_template: Option<Template>,
@@ -1678,39 +1409,14 @@ mod lawn_mower {
         /// If the published message should have the retain flag on or not.
         #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
         pub retain: Option<bool>,
-
-        /// An ID that uniquely identifies this lawn mower. If two lawn mowers have the same unique ID, Home Assistant will raise an exception.
-        #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
-        pub unique_id: Option<String>,
-    }
-
-    #[derive(Debug, PartialEq, Eq, Clone)]
-    #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
-    struct Availability {
-        /// The payload that represents the available state.
-        #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
-        pub payload_available: Option<String>,
-
-        /// The payload that represents the unavailable state.
-        #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
-        pub payload_not_available: Option<String>,
-
-        /// An MQTT topic subscribed to receive availability (online/offline) updates.
-        pub topic: String,
-
-        /// Defines a [template](/docs/configuration/templating/#using-templates-with-the-mqtt-integration) to extract the device's availability from the `topic`. To determine the device's availability, the result of this template will be compared to `payload_available` and `payload_not_available`.
-        #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
-        pub value_template: Option<Template>,
     }
 }
-mod light {
-    #[derive(Debug, PartialEq, Eq, Clone)]
-    #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
-    struct Discovery {
-        /// The MQTT topic subscribed to receive availability (online/offline) updates. Must not be used together with `availability`.
-        #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
-        pub availability_topic: Option<String>,
+pub mod light {
+    use super::*;
 
+    #[derive(Debug, PartialEq, Clone)]
+    #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+    pub struct Discovery {
         /// The MQTT topic to publish commands to change the light’s brightness.
         #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
         pub brightness_command_topic: Option<String>,
@@ -1929,10 +1635,6 @@ mod light {
         #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
         pub state_value_template: Option<Template>,
 
-        /// An ID that uniquely identifies this light. If two lights have the same unique ID, Home Assistant will raise an exception.
-        #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
-        pub unique_id: Option<String>,
-
         /// The MQTT topic to publish commands to change the light to white mode with a given brightness.
         #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
         pub white_command_topic: Option<String>,
@@ -1957,34 +1659,13 @@ mod light {
         #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
         pub xy_value_template: Option<Template>,
     }
-
-    #[derive(Debug, PartialEq, Eq, Clone)]
-    #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
-    struct Availability {
-        /// The payload that represents the available state.
-        #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
-        pub payload_available: Option<String>,
-
-        /// The payload that represents the unavailable state.
-        #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
-        pub payload_not_available: Option<String>,
-
-        /// An MQTT topic subscribed to receive availability (online/offline) updates.
-        pub topic: String,
-
-        /// Defines a [template](/docs/configuration/templating/#using-templates-with-the-mqtt-integration) to extract device's availability from the `topic`. To determine the devices's availability result of this template will be compared to `payload_available` and `payload_not_available`.
-        #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
-        pub value_template: Option<Template>,
-    }
 }
-mod lock {
-    #[derive(Debug, PartialEq, Eq, Clone)]
-    #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
-    struct Discovery {
-        /// The MQTT topic subscribed to receive availability (online/offline) updates. Must not be used together with `availability`.
-        #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
-        pub availability_topic: Option<String>,
+pub mod lock {
+    use super::*;
 
+    #[derive(Debug, PartialEq, Clone)]
+    #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+    pub struct Discovery {
         /// A regular expression to validate a supplied code when it is set during the service call to `open`, `lock` or `unlock` the MQTT lock.
         #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
         pub code_format: Option<String>,
@@ -2088,44 +1769,17 @@ mod lock {
         #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
         pub state_unlocking: Option<String>,
 
-        #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
-        pub unique_id: Option<UNKNOWN>,
-
         /// Defines a [template](/docs/configuration/templating/#using-templates-with-the-mqtt-integration) to extract a state value from the payload.
         #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
         pub value_template: Option<Template>,
     }
-
-    #[derive(Debug, PartialEq, Eq, Clone)]
-    #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
-    struct Availability {
-        /// The payload that represents the available state.
-        #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
-        pub payload_available: Option<String>,
-
-        /// The payload that represents the unavailable state.
-        #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
-        pub payload_not_available: Option<String>,
-
-        /// An MQTT topic subscribed to receive availability (online/offline) updates.
-        pub topic: String,
-
-        /// Defines a [template](/docs/configuration/templating/#using-templates-with-the-mqtt-integration) to extract device's availability from the `topic`. To determine the devices's availability result of this template will be compared to `payload_available` and `payload_not_available`.
-        #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
-        pub value_template: Option<Template>,
-    }
 }
-mod number {
-    #[derive(Debug, PartialEq, Eq, Clone)]
+pub mod number {
+    use super::*;
+
+    #[derive(Debug, PartialEq, Clone)]
     #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
-    struct Discovery {
-        /// The MQTT topic subscribed to receive availability (online/offline) updates. Must not be used together with `availability`.
-        #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
-        pub availability_topic: Option<String>,
-
-        #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
-        pub availability_mode: Option<UNKNOWN>,
-
+    pub struct Discovery {
         /// Defines a [template](/docs/configuration/templating/#using-templates-with-the-mqtt-integration) to generate the payload to send to `command_topic`.
         #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
         pub command_template: Option<Template>,
@@ -2205,10 +1859,6 @@ mod number {
         #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
         pub step: Option<f32>,
 
-        /// An ID that uniquely identifies this Number. If two Numbers have the same unique ID Home Assistant will raise an exception.
-        #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
-        pub unique_id: Option<String>,
-
         /// Defines the unit of measurement of the sensor, if any. The `unit_of_measurement` can be `null`.
         #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
         pub unit_of_measurement: Option<String>,
@@ -2217,30 +1867,13 @@ mod number {
         #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
         pub value_template: Option<Template>,
     }
-
-    #[derive(Debug, PartialEq, Eq, Clone)]
-    #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
-    struct Availability {
-        /// The payload that represents the available state.
-        #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
-        pub payload_available: Option<String>,
-
-        /// The payload that represents the unavailable state.
-        #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
-        pub payload_not_available: Option<String>,
-
-        /// An MQTT topic subscribed to receive availability (online/offline) updates.
-        pub topic: String,
-    }
 }
-mod scene {
-    #[derive(Debug, PartialEq, Eq, Clone)]
-    #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
-    struct Discovery {
-        /// The MQTT topic subscribed to receive availability (online/offline) updates. Must not be used together with `availability`.
-        #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
-        pub availability_topic: Option<String>,
+pub mod scene {
+    use super::*;
 
+    #[derive(Debug, PartialEq, Clone)]
+    #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+    pub struct Discovery {
         /// The MQTT topic to publish `payload_on` to activate the scene.
         #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
         pub command_topic: Option<String>,
@@ -2296,42 +1929,14 @@ mod scene {
         /// If the published message should have the retain flag on or not.
         #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
         pub retain: Option<bool>,
-
-        /// An ID that uniquely identifies this scene entity. If two scenes have the same unique ID, Home Assistant will raise an exception.
-        #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
-        pub unique_id: Option<String>,
-    }
-
-    #[derive(Debug, PartialEq, Eq, Clone)]
-    #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
-    struct Availability {
-        /// The payload that represents the available state.
-        #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
-        pub payload_available: Option<String>,
-
-        /// The payload that represents the unavailable state.
-        #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
-        pub payload_not_available: Option<String>,
-
-        /// An MQTT topic subscribed to receive availability (online/offline) updates.
-        pub topic: String,
-
-        /// Defines a [template](/docs/configuration/templating/#using-templates-with-the-mqtt-integration) to extract device's availability from the `topic`. To determine the devices's availability result of this template will be compared to `payload_available` and `payload_not_available`.
-        #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
-        pub value_template: Option<Template>,
     }
 }
-mod select {
-    #[derive(Debug, PartialEq, Eq, Clone)]
+pub mod select {
+    use super::*;
+
+    #[derive(Debug, PartialEq, Clone)]
     #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
-    struct Discovery {
-        /// The MQTT topic subscribed to receive availability (online/offline) updates. Must not be used together with `availability`.
-        #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
-        pub availability_topic: Option<String>,
-
-        #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
-        pub availability_mode: Option<UNKNOWN>,
-
+    pub struct Discovery {
         /// Defines a [template](/docs/configuration/templating/#using-templates-with-the-mqtt-integration) to generate the payload to send to `command_topic`.
         #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
         pub command_template: Option<Template>,
@@ -2390,42 +1995,17 @@ mod select {
         #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
         pub state_topic: Option<String>,
 
-        /// An ID that uniquely identifies this Select. If two Selects have the same unique ID Home Assistant will raise an exception.
-        #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
-        pub unique_id: Option<String>,
-
         /// Defines a [template](/docs/configuration/templating/#using-templates-with-the-mqtt-integration) to extract the value.
         #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
         pub value_template: Option<Template>,
     }
-
-    #[derive(Debug, PartialEq, Eq, Clone)]
-    #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
-    struct Availability {
-        /// The payload that represents the available state.
-        #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
-        pub payload_available: Option<String>,
-
-        /// The payload that represents the unavailable state.
-        #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
-        pub payload_not_available: Option<String>,
-
-        /// An MQTT topic subscribed to receive availability (online/offline) updates.
-        pub topic: String,
-
-        /// Defines a [template](/docs/configuration/templating/#using-templates-with-the-mqtt-integration) to extract device's availability from the `topic`. To determine the devices's availability result of this template will be compared to `payload_available` and `payload_not_available`.
-        #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
-        pub value_template: Option<Template>,
-    }
 }
-mod sensor {
-    #[derive(Debug, PartialEq, Eq, Clone)]
-    #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
-    struct Discovery {
-        /// The MQTT topic subscribed to receive availability (online/offline) updates.
-        #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
-        pub availability_topic: Option<String>,
+pub mod sensor {
+    use super::*;
 
+    #[derive(Debug, PartialEq, Clone)]
+    #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+    pub struct Discovery {
         /// The [type/class](/integrations/sensor/#device-class) of the sensor to set the icon in the frontend. The `device_class` can be `null`.
         #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
         pub device_class: Option<_>,
@@ -2497,10 +2077,6 @@ mod sensor {
         /// The MQTT topic subscribed to receive sensor values. If `device_class`, `state_class`, `unit_of_measurement` or `suggested_display_precision` is set, and a numeric value is expected, an empty value `''` will be ignored and will not update the state, a `'null'` value will set the sensor to an `unknown` state. The `device_class` can be `null`.
         pub state_topic: String,
 
-        /// An ID that uniquely identifies this sensor. If two sensors have the same unique ID, Home Assistant will raise an exception.
-        #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
-        pub unique_id: Option<String>,
-
         /// Defines the units of measurement of the sensor, if any. The `unit_of_measurement` can be `null`.
         #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
         pub unit_of_measurement: Option<String>,
@@ -2509,34 +2085,13 @@ mod sensor {
         #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
         pub value_template: Option<Template>,
     }
-
-    #[derive(Debug, PartialEq, Eq, Clone)]
-    #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
-    struct Availability {
-        /// The payload that represents the available state.
-        #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
-        pub payload_available: Option<String>,
-
-        /// The payload that represents the unavailable state.
-        #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
-        pub payload_not_available: Option<String>,
-
-        /// An MQTT topic subscribed to receive availability (online/offline) updates.
-        pub topic: String,
-
-        /// Defines a [template](/docs/configuration/templating/#using-templates-with-the-mqtt-integration) to extract device's availability from the `topic`. To determine the devices's availability result of this template will be compared to `payload_available` and `payload_not_available`.
-        #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
-        pub value_template: Option<Template>,
-    }
 }
-mod siren {
-    #[derive(Debug, PartialEq, Eq, Clone)]
-    #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
-    struct Discovery {
-        /// The MQTT topic subscribed to receive availability (online/offline) updates. Must not be used together with `availability`.
-        #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
-        pub availability_topic: Option<String>,
+pub mod siren {
+    use super::*;
 
+    #[derive(Debug, PartialEq, Clone)]
+    #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+    pub struct Discovery {
         /// A list of available tones the siren supports. When configured, this enables the support for setting a `tone` and enables the `tone` state attribute.
         #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
         pub available_tones: Option<Vec<_>>,
@@ -2637,39 +2192,14 @@ mod siren {
         /// Set to `true` if the MQTT siren supports the `volume_set` service turn on parameter and enables the `volume_level` state attribute.
         #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
         pub support_volume_set: Option<bool>,
-
-        /// An ID that uniquely identifies this siren device. If two sirens have the same unique ID, Home Assistant will raise an exception.
-        #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
-        pub unique_id: Option<String>,
-    }
-
-    #[derive(Debug, PartialEq, Eq, Clone)]
-    #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
-    struct Availability {
-        /// The payload that represents the available state.
-        #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
-        pub payload_available: Option<String>,
-
-        /// The payload that represents the unavailable state.
-        #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
-        pub payload_not_available: Option<String>,
-
-        /// An MQTT topic subscribed to receive availability (online/offline) updates.
-        pub topic: String,
-
-        /// Defines a [template](/docs/configuration/templating/#using-templates-with-the-mqtt-integration) to extract device's availability from the `topic`. To determine the devices's availability result of this template will be compared to `payload_available` and `payload_not_available`.
-        #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
-        pub value_template: Option<Template>,
     }
 }
-mod switch {
-    #[derive(Debug, PartialEq, Eq, Clone)]
-    #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
-    struct Discovery {
-        /// The MQTT topic subscribed to receive availability (online/offline) updates. Must not be used together with `availability`.
-        #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
-        pub availability_topic: Option<String>,
+pub mod switch {
+    use super::*;
 
+    #[derive(Debug, PartialEq, Clone)]
+    #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+    pub struct Discovery {
         /// The MQTT topic to publish commands to change the switch state.
         pub command_topic: String,
 
@@ -2749,38 +2279,17 @@ mod switch {
         #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
         pub state_topic: Option<String>,
 
-        /// An ID that uniquely identifies this switch device. If two switches have the same unique ID, Home Assistant will raise an exception.
-        #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
-        pub unique_id: Option<String>,
-
         /// Defines a [template](/docs/configuration/templating/#using-templates-with-the-mqtt-integration) to extract device's state from the `state_topic`. To determine the switches's state result of this template will be compared to `state_on` and `state_off`.
         #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
         pub value_template: Option<Template>,
     }
-
-    #[derive(Debug, PartialEq, Eq, Clone)]
-    #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
-    struct Availability {
-        /// The payload that represents the available state.
-        #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
-        pub payload_available: Option<String>,
-
-        /// The payload that represents the unavailable state.
-        #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
-        pub payload_not_available: Option<String>,
-
-        /// An MQTT topic subscribed to receive availability (online/offline) updates.
-        pub topic: String,
-
-        /// Defines a [template](/docs/configuration/templating/#using-templates-with-the-mqtt-integration) to extract device's availability from the `topic`. To determine the devices's availability result of this template will be compared to `payload_available` and `payload_not_available`.
-        #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
-        pub value_template: Option<Template>,
-    }
 }
-mod tag {
-    #[derive(Debug, PartialEq, Eq, Clone)]
+pub mod tag {
+    use super::*;
+
+    #[derive(Debug, PartialEq, Clone)]
     #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
-    struct Discovery {
+    pub struct Discovery {
         /// The MQTT topic subscribed to receive tag scanned events.
         pub topic: String,
 
@@ -2792,17 +2301,12 @@ mod tag {
         pub device: Device,
     }
 }
-mod text {
-    #[derive(Debug, PartialEq, Eq, Clone)]
+pub mod text {
+    use super::*;
+
+    #[derive(Debug, PartialEq, Clone)]
     #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
-    struct Discovery {
-        /// The MQTT topic subscribed to receive availability (online/offline) updates. Must not be used together with `availability`.
-        #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
-        pub availability_topic: Option<String>,
-
-        #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
-        pub availability_mode: Option<UNKNOWN>,
-
+    pub struct Discovery {
         /// Defines a [template](/docs/configuration/templating/#using-templates-with-the-mqtt-integration) to generate the payload to send to `command_topic`.
         #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
         pub command_template: Option<Template>,
@@ -2866,45 +2370,17 @@ mod text {
         #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
         pub state_topic: Option<String>,
 
-        /// An ID that uniquely identifies this Select. If two Selects have the same unique ID Home Assistant will raise an exception.
-        #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
-        pub unique_id: Option<String>,
-
         /// Defines a [template](/docs/configuration/templating/#using-templates-with-the-mqtt-integration) to extract the text state value from the payload received on `state_topic`.
         #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
         pub value_template: Option<Template>,
     }
-
-    #[derive(Debug, PartialEq, Eq, Clone)]
-    #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
-    struct Availability {
-        /// The payload that represents the available state.
-        #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
-        pub payload_available: Option<String>,
-
-        /// The payload that represents the unavailable state.
-        #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
-        pub payload_not_available: Option<String>,
-
-        /// An MQTT topic subscribed to receive availability (online/offline) updates.
-        pub topic: String,
-
-        /// Defines a [template](/docs/configuration/templating/#using-templates-with-the-mqtt-integration) to extract device's availability from the `topic`. To determine the devices's availability result of this template will be compared to `payload_available` and `payload_not_available`.
-        #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
-        pub value_template: Option<Template>,
-    }
 }
-mod update {
-    #[derive(Debug, PartialEq, Eq, Clone)]
+pub mod update {
+    use super::*;
+
+    #[derive(Debug, PartialEq, Clone)]
     #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
-    struct Discovery {
-        /// The MQTT topic subscribed to receive availability (online/offline) updates. Must not be used together with `availability`.
-        #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
-        pub availability_topic: Option<String>,
-
-        #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
-        pub availability_mode: Option<UNKNOWN>,
-
+    pub struct Discovery {
         /// The MQTT topic to publish `payload_install` to start installing process.
         #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
         pub command_topic: Option<String>,
@@ -2985,42 +2461,17 @@ mod update {
         #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
         pub title: Option<String>,
 
-        /// An ID that uniquely identifies this Update. If two Updates have the same unique ID Home Assistant will raise an exception.
-        #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
-        pub unique_id: Option<String>,
-
         /// Defines a [template](/docs/configuration/templating/#using-templates-with-the-mqtt-integration) to extract the `installed_version` state value or to render to a valid JSON payload on from the payload received on `state_topic`.
         #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
         pub value_template: Option<Template>,
     }
-
-    #[derive(Debug, PartialEq, Eq, Clone)]
-    #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
-    struct Availability {
-        /// The payload that represents the available state.
-        #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
-        pub payload_available: Option<String>,
-
-        /// The payload that represents the unavailable state.
-        #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
-        pub payload_not_available: Option<String>,
-
-        /// An MQTT topic subscribed to receive availability (online/offline) updates.
-        pub topic: String,
-
-        /// Defines a [template](/docs/configuration/templating/#using-templates-with-the-mqtt-integration) to extract device's availability from the `topic`. To determine the devices's availability result of this template will be compared to `payload_available` and `payload_not_available`.
-        #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
-        pub value_template: Option<Template>,
-    }
 }
-mod vacuum {
-    #[derive(Debug, PartialEq, Eq, Clone)]
-    #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
-    struct Discovery {
-        /// The MQTT topic subscribed to receive availability (online/offline) updates. Must not be used together with `availability`.
-        #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
-        pub availability_topic: Option<String>,
+pub mod vacuum {
+    use super::*;
 
+    #[derive(Debug, PartialEq, Clone)]
+    #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+    pub struct Discovery {
         /// The MQTT topic to publish commands to control the vacuum.
         #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
         pub command_topic: Option<String>,
@@ -3104,42 +2555,18 @@ mod vacuum {
         /// List of features that the vacuum supports (possible values are `start`, `stop`, `pause`, `return_home`, `battery`, `status`, `locate`, `clean_spot`, `fan_speed`, `send_command`).
         #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
         pub supported_features: Option<Vec<String>>,
-
-        #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
-        pub unique_id: Option<UNKNOWN>,
-    }
-
-    #[derive(Debug, PartialEq, Eq, Clone)]
-    #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
-    struct Availability {
-        /// The payload that represents the available state.
-        #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
-        pub payload_available: Option<String>,
-
-        /// The payload that represents the unavailable state.
-        #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
-        pub payload_not_available: Option<String>,
-
-        /// An MQTT topic subscribed to receive availability (online/offline) updates.
-        pub topic: String,
-
-        /// Defines a [template](/docs/configuration/templating/#using-templates-with-the-mqtt-integration) to extract device's availability from the `topic`. To determine the devices's availability result of this template will be compared to `payload_available` and `payload_not_available`.
-        #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
-        pub value_template: Option<Template>,
     }
 }
-mod valve {
-    #[derive(Debug, PartialEq, Eq, Clone)]
+pub mod valve {
+    use super::*;
+
+    #[derive(Debug, PartialEq, Clone)]
     #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
-    struct Discovery {
+    pub struct Discovery {
         /// Defines a [template](/docs/configuration/templating/#using-templates-with-the-mqtt-integration) to extract the device's availability from the `availability_topic`. To determine the devices's availability, the result of this template will be compared to `payload_available` and `payload_not_available`.
         #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
         pub availability_template: Option<Template>,
 
-        /// The MQTT topic subscribed to receive birth and LWT messages from the MQTT valve device. If an `availability` topic is not defined, the valve availability state will always be `available`. If an `availability` topic is defined, the valve availability state will be `unavailable` by default. Must not be used together with `availability`.
-        #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
-        pub availability_topic: Option<String>,
-
         /// Defines a [template](/docs/configuration/templating/#using-templates-with-the-mqtt-integration) to generate the payload to send to `command_topic`.
         #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
         pub command_template: Option<Template>,
@@ -3248,42 +2675,17 @@ mod valve {
         #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
         pub state_topic: Option<String>,
 
-        /// An ID that uniquely identifies this valve. If two valves have the same unique ID, Home Assistant will raise an exception.
-        #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
-        pub unique_id: Option<String>,
-
         /// Defines a [template](/docs/configuration/templating/#using-templates-with-the-mqtt-integration) that can be used to extract the payload for the `state_topic` topic. The rendered value should be a defined state payload or, if reporting a `position` is supported and `reports_position` is set to `true`, a numeric value is expected representing the position. See also `state_topic`.
         #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
         pub value_template: Option<Template>,
     }
-
-    #[derive(Debug, PartialEq, Eq, Clone)]
-    #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
-    struct Availability {
-        /// The payload that represents the available state.
-        #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
-        pub payload_available: Option<String>,
-
-        /// The payload that represents the unavailable state.
-        #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
-        pub payload_not_available: Option<String>,
-
-        /// An MQTT topic subscribed to receive availability (online/offline) updates.
-        pub topic: String,
-
-        /// Defines a [template](/docs/configuration/templating/#using-templates-with-the-mqtt-integration) to extract the device's availability from the `topic`. To determine the devices's availability, the result of this template will be compared to `payload_available` and `payload_not_available`.
-        #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
-        pub value_template: Option<Template>,
-    }
 }
-mod water_heater {
-    #[derive(Debug, PartialEq, Eq, Clone)]
-    #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
-    struct Discovery {
-        /// The MQTT topic subscribed to receive availability (online/offline) updates. Must not be used together with `availability`.
-        #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
-        pub availability_topic: Option<String>,
+pub mod water_heater {
+    use super::*;
 
+    #[derive(Debug, PartialEq, Clone)]
+    #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+    pub struct Discovery {
         /// A template with which the value received on `current_temperature_topic` will be rendered.
         #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
         pub current_temperature_template: Option<Template>,
@@ -3416,30 +2818,8 @@ mod water_heater {
         #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
         pub temperature_unit: Option<String>,
 
-        #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
-        pub unique_id: Option<UNKNOWN>,
-
         /// Default template to render the payloads on *all* `*_state_topic`s with.
         #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
         pub value_template: Option<Template>,
     }
-
-    #[derive(Debug, PartialEq, Eq, Clone)]
-    #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
-    struct Availability {
-        /// The payload that represents the available state.
-        #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
-        pub payload_available: Option<String>,
-
-        /// The payload that represents the unavailable state.
-        #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
-        pub payload_not_available: Option<String>,
-
-        /// An MQTT topic subscribed to receive availability (online/offline) updates.
-        pub topic: String,
-
-        /// Defines a [template](/docs/configuration/templating/#using-templates-with-the-mqtt-integration) to extract device's availability from the `topic`. To determine the devices's availability result of this template will be compared to `payload_available` and `payload_not_available`.
-        #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
-        pub value_template: Option<Template>,
-    }
 }
diff --git a/homeassistant-mqtt-discovery/src/lib.rs b/homeassistant-mqtt-discovery/src/lib.rs
index 7e94c82..3834997 100644
--- a/homeassistant-mqtt-discovery/src/lib.rs
+++ b/homeassistant-mqtt-discovery/src/lib.rs
@@ -2,6 +2,7 @@ use either::Either;
 #[cfg(feature = "serde")]
 use serde::{Deserialize, Serialize};
 
+pub mod integrations;
 pub mod light;
 
 // TODO: Templates
@@ -11,9 +12,22 @@ pub type Template = ();
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 // #[cfg_attr(feature = "serde", serde(flatten))]
 pub struct Common {
+    #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
+    pub unique_id: Option<String>,
+
+    /// Defines a [template](/docs/configuration/templating/#using-templates-with-the-mqtt-integration) to extract device's availability from the `availability_topic`. To determine the devices's availability result of this template will be compared to `payload_available` and `payload_not_available`.
+
+    #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
     availability_template: Option<Template>,
+    #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
+
+    /// When `availability` is configured, this controls the conditions needed to set the entity to `available`. Valid entries are `all`, `any`, and `latest`. If set to `all`, `payload_available` must be received on all configured availability topics before the entity is marked as online. If set to `any`, `payload_available` must be received on at least one configured availability topic before the entity is marked as online. If set to `latest`, the last `payload_available` or `payload_not_available` received on any configured availability topic controls the availability.
     availability_mode: Option<AvailabilityMode>,
+
+    /// A list of MQTT topics subscribed to receive availability (online/offline) updates. Must not be used together with `availability_topic`.
     availability: Availability,
+
+    #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
     device: Option<Device>,
 }
 
@@ -36,7 +50,10 @@ impl Default for AvailabilityMode {
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 #[cfg_attr(feature = "serde", serde(rename_all = "snake_case"))]
 pub enum Availability {
+    /// A list of MQTT topics subscribed to receive availability (online/offline) updates. Must not be used together with `availability_topic`.
     Availability(CustomAvailability),
+
+    /// The MQTT topic subscribed to receive availability (online/offline) updates. Must not be used together with `availability`.
     AvailabilityTopic(String),
 }
 
@@ -44,9 +61,16 @@ pub enum Availability {
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 #[cfg_attr(feature = "serde", serde(rename_all = "snake_case"))]
 pub struct CustomAvailability {
+    /// The payload that represents the available state.
+    #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
     payload_available: Option<String>,
+    /// The payload that represents the unavailable state.
+    #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
     payload_not_available: Option<String>,
+    /// An MQTT topic subscribed to receive availability (online/offline) updates.
     topic: String,
+    /// Defines a [template](/docs/configuration/templating/#using-templates-with-the-mqtt-integration) to extract device's availability from the `topic`. To determine the devices's availability result of this template will be compared to `payload_available` and `payload_not_available`.
+    #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
     value_template: Option<Template>,
 }
 
@@ -56,36 +80,47 @@ pub struct CustomAvailability {
 /// Information about the device this light is a part of to tie it into the device registry. Only works when unique_id is set. At least one of identifiers or connections must be present to identify the device.
 pub struct Device {
     /// A link to the webpage that can manage the configuration of this device. Can be either an http://, https:// or an internal homeassistant:// URL.
+    #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
     configuration_url: Option<String>,
 
     /// A list of connections of the device to the outside world as a list of tuples [connection_type, connection_identifier]. For example the MAC address of a network interface: "connections": [["mac", "02:5b:26:a8:dc:12"]].
+    #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
     connections: Option<Vec<String>>,
 
     /// The hardware version of the device.
+    #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
     hw_version: Option<String>,
 
     /// A list of IDs that uniquely identify the device. For example a serial number.
+    #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
     identifiers: Option<Either<String, Vec<String>>>,
 
     /// The manufacturer of the device.
+    #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
     manufacturer: Option<String>,
 
     /// The model of the device.
+    #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
     model: Option<String>,
 
     /// The name of the device.
+    #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
     name: Option<String>,
 
     /// The serial number of the device.
+    #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
     serial_number: Option<String>,
 
     /// Suggest an area if the device isn't in one yet.
+    #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
     suggested_area: Option<String>,
 
     /// The firmware version of the device.
+    #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
     sw_version: Option<String>,
 
     /// Identifier of a device that routes messages between this device and Home Assistant. Examples of such devices are hubs, or parent devices of a sub-device. This is used to show device topology in Home Assistant.
+    #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
     via_device: Option<String>,
 }