homeassistant 2025.8.3__py3-none-any.whl → 2025.9.0b1__py3-none-any.whl

homeassistant/components/template/alarm_control_panel.py

@@ -47,12 +47,12 @@ from .helpers import (
     async_setup_template_platform,
     async_setup_template_preview,
 )
-from .template_entity import (
+from .schemas import (
     TEMPLATE_ENTITY_COMMON_CONFIG_ENTRY_SCHEMA,
     TEMPLATE_ENTITY_OPTIMISTIC_SCHEMA,
-    TemplateEntity,
     make_template_entity_common_modern_schema,
 )
+from .template_entity import TemplateEntity
 from .trigger_entity import TriggerEntity
 
 _LOGGER = logging.getLogger(__name__)
@@ -115,7 +115,11 @@ ALARM_CONTROL_PANEL_COMMON_SCHEMA = vol.Schema(
 
 ALARM_CONTROL_PANEL_YAML_SCHEMA = ALARM_CONTROL_PANEL_COMMON_SCHEMA.extend(
     TEMPLATE_ENTITY_OPTIMISTIC_SCHEMA
-).extend(make_template_entity_common_modern_schema(DEFAULT_NAME).schema)
+).extend(
+    make_template_entity_common_modern_schema(
+        ALARM_CONTROL_PANEL_DOMAIN, DEFAULT_NAME
+    ).schema
+)
 
 ALARM_CONTROL_PANEL_LEGACY_YAML_SCHEMA = vol.Schema(
     {

homeassistant/components/template/binary_sensor.py

@@ -48,23 +48,25 @@ from homeassistant.helpers.typing import ConfigType, DiscoveryInfoType
 from homeassistant.util import dt as dt_util
 
 from . import TriggerUpdateCoordinator
-from .const import CONF_AVAILABILITY_TEMPLATE
 from .helpers import (
     async_setup_template_entry,
     async_setup_template_platform,
     async_setup_template_preview,
 )
-from .template_entity import (
+from .schemas import (
+    TEMPLATE_ENTITY_ATTRIBUTES_SCHEMA_LEGACY,
+    TEMPLATE_ENTITY_AVAILABILITY_SCHEMA_LEGACY,
     TEMPLATE_ENTITY_COMMON_CONFIG_ENTRY_SCHEMA,
-    TEMPLATE_ENTITY_COMMON_SCHEMA,
-    TemplateEntity,
+    make_template_entity_common_modern_attributes_schema,
 )
+from .template_entity import TemplateEntity
 from .trigger_entity import TriggerEntity
 
+DEFAULT_NAME = "Template Binary Sensor"
+
 CONF_DELAY_ON = "delay_on"
 CONF_DELAY_OFF = "delay_off"
 CONF_AUTO_OFF = "auto_off"
-CONF_ATTRIBUTE_TEMPLATES = "attribute_templates"
 
 LEGACY_FIELDS = {
     CONF_FRIENDLY_NAME_TEMPLATE: CONF_NAME,
@@ -83,7 +85,9 @@ BINARY_SENSOR_COMMON_SCHEMA = vol.Schema(
 )
 
 BINARY_SENSOR_YAML_SCHEMA = BINARY_SENSOR_COMMON_SCHEMA.extend(
-    TEMPLATE_ENTITY_COMMON_SCHEMA.schema
+    make_template_entity_common_modern_attributes_schema(
+        BINARY_SENSOR_DOMAIN, DEFAULT_NAME
+    ).schema
 )
 
 BINARY_SENSOR_CONFIG_ENTRY_SCHEMA = BINARY_SENSOR_COMMON_SCHEMA.extend(
@@ -97,10 +101,6 @@ BINARY_SENSOR_LEGACY_YAML_SCHEMA = vol.All(
             vol.Required(CONF_VALUE_TEMPLATE): cv.template,
             vol.Optional(CONF_ICON_TEMPLATE): cv.template,
             vol.Optional(CONF_ENTITY_PICTURE_TEMPLATE): cv.template,
-            vol.Optional(CONF_AVAILABILITY_TEMPLATE): cv.template,
-            vol.Optional(CONF_ATTRIBUTE_TEMPLATES): vol.Schema(
-                {cv.string: cv.template}
-            ),
             vol.Optional(ATTR_FRIENDLY_NAME): cv.string,
             vol.Optional(ATTR_ENTITY_ID): cv.entity_ids,
             vol.Optional(CONF_DEVICE_CLASS): DEVICE_CLASSES_SCHEMA,
@@ -108,7 +108,9 @@ BINARY_SENSOR_LEGACY_YAML_SCHEMA = vol.All(
             vol.Optional(CONF_DELAY_OFF): vol.Any(cv.positive_time_period, cv.template),
             vol.Optional(CONF_UNIQUE_ID): cv.string,
         }
-    ),
+    )
+    .extend(TEMPLATE_ENTITY_ATTRIBUTES_SCHEMA_LEGACY.schema)
+    .extend(TEMPLATE_ENTITY_AVAILABILITY_SCHEMA_LEGACY.schema),
 )
 
 

homeassistant/components/template/button.py

@@ -25,11 +25,11 @@ from homeassistant.helpers.typing import ConfigType, DiscoveryInfoType
 
 from .const import CONF_PRESS, DOMAIN
 from .helpers import async_setup_template_entry, async_setup_template_platform
-from .template_entity import (
+from .schemas import (
     TEMPLATE_ENTITY_COMMON_CONFIG_ENTRY_SCHEMA,
-    TemplateEntity,
     make_template_entity_common_modern_schema,
 )
+from .template_entity import TemplateEntity
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -41,7 +41,7 @@ BUTTON_YAML_SCHEMA = vol.Schema(
         vol.Required(CONF_PRESS): cv.SCRIPT_SCHEMA,
         vol.Optional(CONF_DEVICE_CLASS): DEVICE_CLASSES_SCHEMA,
     }
-).extend(make_template_entity_common_modern_schema(DEFAULT_NAME).schema)
+).extend(make_template_entity_common_modern_schema(BUTTON_DOMAIN, DEFAULT_NAME).schema)
 
 BUTTON_CONFIG_ENTRY_SCHEMA = vol.Schema(
     {

homeassistant/components/template/config.py

@@ -17,6 +17,7 @@ from homeassistant.components.blueprint import (
 )
 from homeassistant.components.button import DOMAIN as DOMAIN_BUTTON
 from homeassistant.components.cover import DOMAIN as DOMAIN_COVER
+from homeassistant.components.event import DOMAIN as DOMAIN_EVENT
 from homeassistant.components.fan import DOMAIN as DOMAIN_FAN
 from homeassistant.components.image import DOMAIN as DOMAIN_IMAGE
 from homeassistant.components.light import DOMAIN as DOMAIN_LIGHT
@@ -25,6 +26,7 @@ from homeassistant.components.number import DOMAIN as DOMAIN_NUMBER
 from homeassistant.components.select import DOMAIN as DOMAIN_SELECT
 from homeassistant.components.sensor import DOMAIN as DOMAIN_SENSOR
 from homeassistant.components.switch import DOMAIN as DOMAIN_SWITCH
+from homeassistant.components.update import DOMAIN as DOMAIN_UPDATE
 from homeassistant.components.vacuum import DOMAIN as DOMAIN_VACUUM
 from homeassistant.components.weather import DOMAIN as DOMAIN_WEATHER
 from homeassistant.config import async_log_schema_error, config_without_domain
@@ -53,6 +55,7 @@ from . import (
     binary_sensor as binary_sensor_platform,
     button as button_platform,
     cover as cover_platform,
+    event as event_platform,
     fan as fan_platform,
     image as image_platform,
     light as light_platform,
@@ -61,6 +64,7 @@ from . import (
     select as select_platform,
     sensor as sensor_platform,
     switch as switch_platform,
+    update as update_platform,
     vacuum as vacuum_platform,
     weather as weather_platform,
 )
@@ -124,6 +128,9 @@ CONFIG_SECTION_SCHEMA = vol.All(
             vol.Optional(DOMAIN_COVER): vol.All(
                 cv.ensure_list, [cover_platform.COVER_YAML_SCHEMA]
             ),
+            vol.Optional(DOMAIN_EVENT): vol.All(
+                cv.ensure_list, [event_platform.EVENT_YAML_SCHEMA]
+            ),
             vol.Optional(DOMAIN_FAN): vol.All(
                 cv.ensure_list, [fan_platform.FAN_YAML_SCHEMA]
             ),
@@ -148,6 +155,9 @@ CONFIG_SECTION_SCHEMA = vol.All(
             vol.Optional(DOMAIN_SWITCH): vol.All(
                 cv.ensure_list, [switch_platform.SWITCH_YAML_SCHEMA]
             ),
+            vol.Optional(DOMAIN_UPDATE): vol.All(
+                cv.ensure_list, [update_platform.UPDATE_YAML_SCHEMA]
+            ),
             vol.Optional(DOMAIN_VACUUM): vol.All(
                 cv.ensure_list, [vacuum_platform.VACUUM_YAML_SCHEMA]
             ),
@@ -278,7 +288,7 @@ async def async_validate_config(hass: HomeAssistant, config: ConfigType) -> Conf
             )
             definitions.extend(
                 rewrite_legacy_to_modern_configs(
-                    hass, template_config[old_key], legacy_fields
+                    hass, new_key, template_config[old_key], legacy_fields
                 )
             )
             template_config = TemplateConfig({**template_config, new_key: definitions})

homeassistant/components/template/config_flow.py

@@ -12,6 +12,7 @@ from homeassistant.components import websocket_api
 from homeassistant.components.binary_sensor import BinarySensorDeviceClass
 from homeassistant.components.button import ButtonDeviceClass
 from homeassistant.components.cover import CoverDeviceClass
+from homeassistant.components.event import EventDeviceClass
 from homeassistant.components.sensor import (
     CONF_STATE_CLASS,
     DEVICE_CLASS_STATE_CLASSES,
@@ -19,6 +20,7 @@ from homeassistant.components.sensor import (
     SensorDeviceClass,
     SensorStateClass,
 )
+from homeassistant.components.update import UpdateDeviceClass
 from homeassistant.const import (
     CONF_DEVICE_CLASS,
     CONF_DEVICE_ID,
@@ -72,6 +74,7 @@ from .cover import (
     STOP_ACTION,
     async_create_preview_cover,
 )
+from .event import CONF_EVENT_TYPE, CONF_EVENT_TYPES, async_create_preview_event
 from .fan import (
     CONF_OFF_ACTION,
     CONF_ON_ACTION,
@@ -104,6 +107,19 @@ from .select import CONF_OPTIONS, CONF_SELECT_OPTION, async_create_preview_selec
 from .sensor import async_create_preview_sensor
 from .switch import async_create_preview_switch
 from .template_entity import TemplateEntity
+from .update import (
+    CONF_BACKUP,
+    CONF_IN_PROGRESS,
+    CONF_INSTALL,
+    CONF_INSTALLED_VERSION,
+    CONF_LATEST_VERSION,
+    CONF_RELEASE_SUMMARY,
+    CONF_RELEASE_URL,
+    CONF_SPECIFIC_VERSION,
+    CONF_TITLE,
+    CONF_UPDATE_PERCENTAGE,
+    async_create_preview_update,
+)
 from .vacuum import (
     CONF_FAN_SPEED,
     CONF_FAN_SPEED_LIST,
@@ -203,6 +219,24 @@ def generate_schema(domain: str, flow_type: str) -> vol.Schema:
                 )
             }
 
+    if domain == Platform.EVENT:
+        schema |= {
+            vol.Required(CONF_EVENT_TYPE): selector.TemplateSelector(),
+            vol.Required(CONF_EVENT_TYPES): selector.TemplateSelector(),
+        }
+
+        if flow_type == "config":
+            schema |= {
+                vol.Optional(CONF_DEVICE_CLASS): selector.SelectSelector(
+                    selector.SelectSelectorConfig(
+                        options=[cls.value for cls in EventDeviceClass],
+                        mode=selector.SelectSelectorMode.DROPDOWN,
+                        translation_key="event_device_class",
+                        sort=True,
+                    ),
+                )
+            }
+
     if domain == Platform.FAN:
         schema |= _SCHEMA_STATE | {
             vol.Required(CONF_ON_ACTION): selector.ActionSelector(),
@@ -315,6 +349,31 @@ def generate_schema(domain: str, flow_type: str) -> vol.Schema:
             vol.Optional(CONF_TURN_OFF): selector.ActionSelector(),
         }
 
+    if domain == Platform.UPDATE:
+        schema |= {
+            vol.Optional(CONF_INSTALLED_VERSION): selector.TemplateSelector(),
+            vol.Optional(CONF_LATEST_VERSION): selector.TemplateSelector(),
+            vol.Optional(CONF_INSTALL): selector.ActionSelector(),
+            vol.Optional(CONF_IN_PROGRESS): selector.TemplateSelector(),
+            vol.Optional(CONF_RELEASE_SUMMARY): selector.TemplateSelector(),
+            vol.Optional(CONF_RELEASE_URL): selector.TemplateSelector(),
+            vol.Optional(CONF_TITLE): selector.TemplateSelector(),
+            vol.Optional(CONF_UPDATE_PERCENTAGE): selector.TemplateSelector(),
+            vol.Optional(CONF_BACKUP): selector.BooleanSelector(),
+            vol.Optional(CONF_SPECIFIC_VERSION): selector.BooleanSelector(),
+        }
+        if flow_type == "config":
+            schema |= {
+                vol.Optional(CONF_DEVICE_CLASS): selector.SelectSelector(
+                    selector.SelectSelectorConfig(
+                        options=[cls.value for cls in UpdateDeviceClass],
+                        mode=selector.SelectSelectorMode.DROPDOWN,
+                        translation_key="update_device_class",
+                        sort=True,
+                    ),
+                ),
+            }
+
     if domain == Platform.VACUUM:
         schema |= _SCHEMA_STATE | {
             vol.Required(SERVICE_START): selector.ActionSelector(),
@@ -441,6 +500,7 @@ TEMPLATE_TYPES = [
     Platform.BINARY_SENSOR,
     Platform.BUTTON,
     Platform.COVER,
+    Platform.EVENT,
     Platform.FAN,
     Platform.IMAGE,
     Platform.LIGHT,
@@ -449,6 +509,7 @@ TEMPLATE_TYPES = [
     Platform.SELECT,
     Platform.SENSOR,
     Platform.SWITCH,
+    Platform.UPDATE,
     Platform.VACUUM,
 ]
 
@@ -473,6 +534,11 @@ CONFIG_FLOW = {
         preview="template",
         validate_user_input=validate_user_input(Platform.COVER),
     ),
+    Platform.EVENT: SchemaFlowFormStep(
+        config_schema(Platform.EVENT),
+        preview="template",
+        validate_user_input=validate_user_input(Platform.EVENT),
+    ),
     Platform.FAN: SchemaFlowFormStep(
         config_schema(Platform.FAN),
         preview="template",
@@ -513,6 +579,11 @@ CONFIG_FLOW = {
         preview="template",
         validate_user_input=validate_user_input(Platform.SWITCH),
     ),
+    Platform.UPDATE: SchemaFlowFormStep(
+        config_schema(Platform.UPDATE),
+        preview="template",
+        validate_user_input=validate_user_input(Platform.UPDATE),
+    ),
     Platform.VACUUM: SchemaFlowFormStep(
         config_schema(Platform.VACUUM),
         preview="template",
@@ -542,6 +613,11 @@ OPTIONS_FLOW = {
         preview="template",
         validate_user_input=validate_user_input(Platform.COVER),
     ),
+    Platform.EVENT: SchemaFlowFormStep(
+        options_schema(Platform.EVENT),
+        preview="template",
+        validate_user_input=validate_user_input(Platform.EVENT),
+    ),
     Platform.FAN: SchemaFlowFormStep(
         options_schema(Platform.FAN),
         preview="template",
@@ -582,6 +658,11 @@ OPTIONS_FLOW = {
         preview="template",
         validate_user_input=validate_user_input(Platform.SWITCH),
     ),
+    Platform.UPDATE: SchemaFlowFormStep(
+        options_schema(Platform.UPDATE),
+        preview="template",
+        validate_user_input=validate_user_input(Platform.UPDATE),
+    ),
     Platform.VACUUM: SchemaFlowFormStep(
         options_schema(Platform.VACUUM),
         preview="template",
@@ -596,6 +677,7 @@ CREATE_PREVIEW_ENTITY: dict[
     Platform.ALARM_CONTROL_PANEL: async_create_preview_alarm_control_panel,
     Platform.BINARY_SENSOR: async_create_preview_binary_sensor,
     Platform.COVER: async_create_preview_cover,
+    Platform.EVENT: async_create_preview_event,
     Platform.FAN: async_create_preview_fan,
     Platform.LIGHT: async_create_preview_light,
     Platform.LOCK: async_create_preview_lock,
@@ -603,6 +685,7 @@ CREATE_PREVIEW_ENTITY: dict[
     Platform.SELECT: async_create_preview_select,
     Platform.SENSOR: async_create_preview_sensor,
     Platform.SWITCH: async_create_preview_switch,
+    Platform.UPDATE: async_create_preview_update,
     Platform.VACUUM: async_create_preview_vacuum,
 }
 

homeassistant/components/template/const.py

@@ -1,9 +1,6 @@
 """Constants for the Template Platform Components."""
 
-import voluptuous as vol
-
-from homeassistant.const import CONF_ICON, CONF_NAME, CONF_UNIQUE_ID, Platform
-from homeassistant.helpers import config_validation as cv
+from homeassistant.const import Platform
 from homeassistant.helpers.typing import ConfigType
 
 CONF_ADVANCED_OPTIONS = "advanced_options"
@@ -11,24 +8,15 @@ CONF_ATTRIBUTE_TEMPLATES = "attribute_templates"
 CONF_ATTRIBUTES = "attributes"
 CONF_AVAILABILITY = "availability"
 CONF_AVAILABILITY_TEMPLATE = "availability_template"
+CONF_DEFAULT_ENTITY_ID = "default_entity_id"
 CONF_MAX = "max"
 CONF_MIN = "min"
-CONF_OBJECT_ID = "object_id"
 CONF_PICTURE = "picture"
 CONF_PRESS = "press"
 CONF_STEP = "step"
 CONF_TURN_OFF = "turn_off"
 CONF_TURN_ON = "turn_on"
 
-TEMPLATE_ENTITY_BASE_SCHEMA = vol.Schema(
-    {
-        vol.Optional(CONF_ICON): cv.template,
-        vol.Optional(CONF_NAME): cv.template,
-        vol.Optional(CONF_PICTURE): cv.template,
-        vol.Optional(CONF_UNIQUE_ID): cv.string,
-    }
-)
-
 DOMAIN = "template"
 
 PLATFORM_STORAGE_KEY = "template_platforms"
@@ -38,6 +26,7 @@ PLATFORMS = [
     Platform.BINARY_SENSOR,
     Platform.BUTTON,
     Platform.COVER,
+    Platform.EVENT,
     Platform.FAN,
     Platform.IMAGE,
     Platform.LIGHT,
@@ -46,6 +35,7 @@ PLATFORMS = [
     Platform.SELECT,
     Platform.SENSOR,
     Platform.SWITCH,
+    Platform.UPDATE,
     Platform.VACUUM,
     Platform.WEATHER,
 ]

homeassistant/components/template/cover.py

@@ -46,13 +46,13 @@ from .helpers import (
     async_setup_template_platform,
     async_setup_template_preview,
 )
-from .template_entity import (
+from .schemas import (
     TEMPLATE_ENTITY_COMMON_CONFIG_ENTRY_SCHEMA,
     TEMPLATE_ENTITY_COMMON_SCHEMA_LEGACY,
     TEMPLATE_ENTITY_OPTIMISTIC_SCHEMA,
-    TemplateEntity,
     make_template_entity_common_modern_schema,
 )
+from .template_entity import TemplateEntity
 from .trigger_entity import TriggerEntity
 
 _LOGGER = logging.getLogger(__name__)
@@ -122,7 +122,9 @@ COVER_YAML_SCHEMA = vol.All(
     )
     .extend(COVER_COMMON_SCHEMA.schema)
     .extend(TEMPLATE_ENTITY_OPTIMISTIC_SCHEMA)
-    .extend(make_template_entity_common_modern_schema(DEFAULT_NAME).schema),
+    .extend(
+        make_template_entity_common_modern_schema(COVER_DOMAIN, DEFAULT_NAME).schema
+    ),
     cv.has_at_least_one_key(OPEN_ACTION, POSITION_ACTION),
 )
 

homeassistant/components/template/entity.py

@@ -2,6 +2,7 @@
 
 from abc import abstractmethod
 from collections.abc import Sequence
+import logging
 from typing import Any
 
 from homeassistant.const import CONF_DEVICE_ID, CONF_OPTIMISTIC, CONF_STATE
@@ -12,7 +13,9 @@ from homeassistant.helpers.script import Script, _VarsType
 from homeassistant.helpers.template import Template, TemplateStateFromEntityId
 from homeassistant.helpers.typing import ConfigType
 
-from .const import CONF_OBJECT_ID
+from .const import CONF_DEFAULT_ENTITY_ID
+
+_LOGGER = logging.getLogger(__name__)
 
 
 class AbstractTemplateEntity(Entity):
@@ -49,7 +52,8 @@ class AbstractTemplateEntity(Entity):
                 optimistic is None and assumed_optimistic
             )
 
-        if (object_id := config.get(CONF_OBJECT_ID)) is not None:
+        if (default_entity_id := config.get(CONF_DEFAULT_ENTITY_ID)) is not None:
+            _, _, object_id = default_entity_id.partition(".")
             self.entity_id = async_generate_entity_id(
                 self._entity_id_format, object_id, hass=self.hass
             )

homeassistant/components/template/event.py

@@ -0,0 +1,237 @@
+"""Support for events which integrates with other components."""
+
+from __future__ import annotations
+
+import logging
+from typing import Any, Final
+
+import voluptuous as vol
+
+from homeassistant.components.event import (
+    DOMAIN as EVENT_DOMAIN,
+    ENTITY_ID_FORMAT,
+    EventDeviceClass,
+    EventEntity,
+)
+from homeassistant.config_entries import ConfigEntry
+from homeassistant.const import CONF_DEVICE_CLASS
+from homeassistant.core import HomeAssistant, callback
+from homeassistant.helpers import config_validation as cv
+from homeassistant.helpers.entity_platform import (
+    AddConfigEntryEntitiesCallback,
+    AddEntitiesCallback,
+)
+from homeassistant.helpers.restore_state import RestoreEntity
+from homeassistant.helpers.typing import ConfigType, DiscoveryInfoType
+
+from . import TriggerUpdateCoordinator
+from .entity import AbstractTemplateEntity
+from .helpers import (
+    async_setup_template_entry,
+    async_setup_template_platform,
+    async_setup_template_preview,
+)
+from .schemas import (
+    TEMPLATE_ENTITY_COMMON_CONFIG_ENTRY_SCHEMA,
+    make_template_entity_common_modern_attributes_schema,
+)
+from .template_entity import TemplateEntity
+from .trigger_entity import TriggerEntity
+
+_LOGGER = logging.getLogger(__name__)
+
+DEFAULT_NAME = "Template Event"
+
+CONF_EVENT_TYPE = "event_type"
+CONF_EVENT_TYPES = "event_types"
+
+DEVICE_CLASS_SCHEMA: Final = vol.All(vol.Lower, vol.Coerce(EventDeviceClass))
+
+EVENT_COMMON_SCHEMA = vol.Schema(
+    {
+        vol.Optional(CONF_DEVICE_CLASS): DEVICE_CLASS_SCHEMA,
+        vol.Required(CONF_EVENT_TYPE): cv.template,
+        vol.Required(CONF_EVENT_TYPES): cv.template,
+    }
+)
+
+EVENT_YAML_SCHEMA = EVENT_COMMON_SCHEMA.extend(
+    make_template_entity_common_modern_attributes_schema(
+        EVENT_DOMAIN, DEFAULT_NAME
+    ).schema
+)
+
+
+EVENT_CONFIG_ENTRY_SCHEMA = EVENT_COMMON_SCHEMA.extend(
+    TEMPLATE_ENTITY_COMMON_CONFIG_ENTRY_SCHEMA.schema
+)
+
+
+async def async_setup_platform(
+    hass: HomeAssistant,
+    config: ConfigType,
+    async_add_entities: AddEntitiesCallback,
+    discovery_info: DiscoveryInfoType | None = None,
+) -> None:
+    """Set up the template event."""
+    await async_setup_template_platform(
+        hass,
+        EVENT_DOMAIN,
+        config,
+        StateEventEntity,
+        TriggerEventEntity,
+        async_add_entities,
+        discovery_info,
+    )
+
+
+async def async_setup_entry(
+    hass: HomeAssistant,
+    config_entry: ConfigEntry,
+    async_add_entities: AddConfigEntryEntitiesCallback,
+) -> None:
+    """Initialize config entry."""
+    await async_setup_template_entry(
+        hass,
+        config_entry,
+        async_add_entities,
+        StateEventEntity,
+        EVENT_CONFIG_ENTRY_SCHEMA,
+        True,
+    )
+
+
+@callback
+def async_create_preview_event(
+    hass: HomeAssistant, name: str, config: dict[str, Any]
+) -> StateEventEntity:
+    """Create a preview event."""
+    return async_setup_template_preview(
+        hass,
+        name,
+        config,
+        StateEventEntity,
+        EVENT_CONFIG_ENTRY_SCHEMA,
+    )
+
+
+class AbstractTemplateEvent(AbstractTemplateEntity, EventEntity):
+    """Representation of a template event features."""
+
+    _entity_id_format = ENTITY_ID_FORMAT
+
+    # The super init is not called because TemplateEntity and TriggerEntity will call AbstractTemplateEntity.__init__.
+    # This ensures that the __init__ on AbstractTemplateEntity is not called twice.
+    def __init__(self, config: dict[str, Any]) -> None:  # pylint: disable=super-init-not-called
+        """Initialize the features."""
+        self._event_type_template = config[CONF_EVENT_TYPE]
+        self._event_types_template = config[CONF_EVENT_TYPES]
+
+        self._attr_device_class = config.get(CONF_DEVICE_CLASS)
+
+        self._event_type = None
+        self._attr_event_types = []
+
+    @callback
+    def _update_event_types(self, event_types: Any) -> None:
+        """Update the event types from the template."""
+        if event_types in (None, "None", ""):
+            self._attr_event_types = []
+            return
+
+        if not isinstance(event_types, list):
+            _LOGGER.error(
+                ("Received invalid event_types list: %s for entity %s. Expected list"),
+                event_types,
+                self.entity_id,
+            )
+            self._attr_event_types = []
+            return
+
+        self._attr_event_types = [str(event_type) for event_type in event_types]
+
+    @callback
+    def _update_event_type(self, event_type: Any) -> None:
+        """Update the effect from the template."""
+        try:
+            self._trigger_event(event_type)
+        except ValueError:
+            _LOGGER.error(
+                "Received invalid event_type: %s for entity %s. Expected one of: %s",
+                event_type,
+                self.entity_id,
+                self._attr_event_types,
+            )
+
+
+class StateEventEntity(TemplateEntity, AbstractTemplateEvent):
+    """Representation of a template event."""
+
+    _attr_should_poll = False
+
+    def __init__(
+        self,
+        hass: HomeAssistant,
+        config: dict[str, Any],
+        unique_id: str | None,
+    ) -> None:
+        """Initialize the select."""
+        TemplateEntity.__init__(self, hass, config, unique_id)
+        AbstractTemplateEvent.__init__(self, config)
+
+    @callback
+    def _async_setup_templates(self) -> None:
+        """Set up templates."""
+        self.add_template_attribute(
+            "_attr_event_types",
+            self._event_types_template,
+            None,
+            self._update_event_types,
+            none_on_template_error=True,
+        )
+        self.add_template_attribute(
+            "_event_type",
+            self._event_type_template,
+            None,
+            self._update_event_type,
+            none_on_template_error=True,
+        )
+        super()._async_setup_templates()
+
+
+class TriggerEventEntity(TriggerEntity, AbstractTemplateEvent, RestoreEntity):
+    """Event entity based on trigger data."""
+
+    domain = EVENT_DOMAIN
+    extra_template_keys_complex = (
+        CONF_EVENT_TYPE,
+        CONF_EVENT_TYPES,
+    )
+
+    def __init__(
+        self,
+        hass: HomeAssistant,
+        coordinator: TriggerUpdateCoordinator,
+        config: ConfigType,
+    ) -> None:
+        """Initialize the entity."""
+        TriggerEntity.__init__(self, hass, coordinator, config)
+        AbstractTemplateEvent.__init__(self, config)
+
+    @callback
+    def _handle_coordinator_update(self) -> None:
+        """Handle update of the data."""
+        self._process_data()
+
+        if not self.available:
+            self.async_write_ha_state()
+            return
+
+        for key, updater in (
+            (CONF_EVENT_TYPES, self._update_event_types),
+            (CONF_EVENT_TYPE, self._update_event_type),
+        ):
+            updater(self._rendered[key])
+
+        self.async_set_context(self.coordinator.data["context"])
+        self.async_write_ha_state()