Bump pyTibber to 0.37.5 (#169981 )

Signed-off-by: Daniel Hjelseth Høyer <github@dahoiv.net>
netatmo: add doortag direct category fetch (#169711 )
2026-05-07 10:26:51 +02:00 · 2026-05-07 09:41:08 +02:00 · 2026-05-07 09:18:39 +02:00 · 2026-05-07 09:15:21 +02:00 · 2026-05-07 08:30:41 +02:00 · 2026-05-07 07:33:28 +02:00
216 changed files with 6190 additions and 2515 deletions
@@ -323,7 +323,7 @@ jobs:
          exclude-list: '["odroid-xu","qemuarm","qemux86","raspberrypi","raspberrypi2","raspberrypi3","raspberrypi4","tinker"]'

  publish_container:
-    name: Publish meta container for ${{ matrix.registry }}
+    name: Publish to ${{ matrix.registry }}
    environment: ${{ needs.init.outputs.channel }}
    if: github.repository_owner == 'home-assistant'
    needs: ["init", "build_base"]
@@ -281,7 +281,7 @@ jobs:
          echo "::add-matcher::.github/workflows/matchers/check-executables-have-shebangs.json"
          echo "::add-matcher::.github/workflows/matchers/codespell.json"
      - name: Run prek
-        uses: j178/prek-action@cbc2f23eb5539cf20d82d1aabd0d0ecbcc56f4e3 # v2.0.2
+        uses: j178/prek-action@6ad80277337ad479fe43bd70701c3f7f8aa74db3 # v2.0.3
        env:
          PREK_SKIP: no-commit-to-branch,mypy,pylint,gen_requirements_all,hassfest,hassfest-metadata,hassfest-mypy-config,zizmor
          RUFF_OUTPUT_FORMAT: github
@@ -302,7 +302,7 @@ jobs:
        with:
          persist-credentials: false
      - name: Run zizmor
-        uses: j178/prek-action@cbc2f23eb5539cf20d82d1aabd0d0ecbcc56f4e3 # v2.0.2
+        uses: j178/prek-action@6ad80277337ad479fe43bd70701c3f7f8aa74db3 # v2.0.3
        with:
          extra-args: --all-files zizmor

@@ -1495,8 +1495,8 @@ CLAUDE.md @home-assistant/core
 /tests/components/roku/ @ctalkington
 /homeassistant/components/romy/ @xeniter
 /tests/components/romy/ @xeniter
-/homeassistant/components/roomba/ @pschmitt @cyr-ius @shenxn @Orhideous
-/tests/components/roomba/ @pschmitt @cyr-ius @shenxn @Orhideous
+/homeassistant/components/roomba/ @pschmitt @cyr-ius @shenxn
+/tests/components/roomba/ @pschmitt @cyr-ius @shenxn
 /homeassistant/components/roon/ @pavoni
 /tests/components/roon/ @pavoni
 /homeassistant/components/route_b_smart_meter/ @SeraphicRav
@@ -0,0 +1,5 @@
+{
+  "domain": "sensereo",
+  "name": "Sensereo",
+  "iot_standards": ["matter"]
+}
@@ -0,0 +1,5 @@
+{
+  "domain": "zunzunbee",
+  "name": "Zunzunbee",
+  "iot_standards": ["zigbee"]
+}
@@ -5,5 +5,5 @@
  "documentation": "https://www.home-assistant.io/integrations/acer_projector",
  "iot_class": "local_polling",
  "quality_scale": "legacy",
-  "requirements": ["serialx==1.4.1"]
+  "requirements": ["serialx==1.7.1"]
 }
@@ -899,12 +899,13 @@ class AutomationEntity(BaseAutomationEntity, RestoreEntity):
    async def async_will_remove_from_hass(self) -> None:
        """Remove listeners when removing automation from Home Assistant."""
        await super().async_will_remove_from_hass()
-        await self._async_disable()
        if self.registry_entry and self.registry_entry.entity_id != self.entity_id:
            # Entity ID change, do not unload the script or conditions as they will
            # be reused.
+            await self._async_disable()
            return
-        self.action_script.async_unload()
+        await self._async_disable(stop_actions=False)
+        await self.action_script.async_unload()
        if self._condition is not None:
            self._condition.async_unload()

@@ -1,36 +1,16 @@
 """Provides triggers for buttons."""

-from homeassistant.const import STATE_UNAVAILABLE, STATE_UNKNOWN
-from homeassistant.core import HomeAssistant, State
+from homeassistant.core import HomeAssistant
 from homeassistant.helpers.automation import DomainSpec
-from homeassistant.helpers.trigger import (
-    ENTITY_STATE_TRIGGER_SCHEMA,
-    EntityTriggerBase,
-    Trigger,
-)
+from homeassistant.helpers.trigger import StatelessEntityTriggerBase, Trigger

 from . import DOMAIN


-class ButtonPressedTrigger(EntityTriggerBase):
+class ButtonPressedTrigger(StatelessEntityTriggerBase):
    """Trigger for button entity presses."""

    _domain_specs = {DOMAIN: DomainSpec()}
-    _schema = ENTITY_STATE_TRIGGER_SCHEMA
-
-    def is_valid_transition(self, from_state: State, to_state: State) -> bool:
-        """Check if the origin state is valid and different from the current state."""
-
-        # UNKNOWN is a valid from_state, otherwise the first time the button is pressed
-        # would not trigger
-        if from_state.state == STATE_UNAVAILABLE:
-            return False
-
-        return from_state.state != to_state.state
-
-    def is_valid_state(self, state: State) -> bool:
-        """Check if the new state is not invalid."""
-        return state.state not in (STATE_UNAVAILABLE, STATE_UNKNOWN)


 TRIGGERS: dict[str, type[Trigger]] = {
@@ -13,8 +13,8 @@ from homeassistant.helpers.condition import (
    Condition,
    ConditionConfig,
    EntityConditionBase,
+    EntityNumericalConditionBase,
    EntityNumericalConditionWithUnitBase,
-    make_entity_numerical_condition,
    make_entity_state_condition,
 )
 from homeassistant.util.unit_conversion import TemperatureConverter
@@ -59,12 +59,33 @@ class ClimateTargetTemperatureCondition(EntityNumericalConditionWithUnitBase):
    _domain_specs = {DOMAIN: DomainSpec(value_source=ATTR_TEMPERATURE)}
    _unit_converter = TemperatureConverter

+    def _should_include(self, state: State) -> bool:
+        """Skip climate entities that do not expose a target temperature."""
+        return (
+            super()._should_include(state)
+            and state.attributes.get(ATTR_TEMPERATURE) is not None
+        )
+
    def _get_entity_unit(self, entity_state: State) -> str | None:
        """Get the temperature unit of a climate entity from its state."""
        # Climate entities convert temperatures to the system unit via show_temp
        return self._hass.config.units.temperature_unit


+class ClimateTargetHumidityCondition(EntityNumericalConditionBase):
+    """Condition for climate target humidity."""
+
+    _domain_specs = {DOMAIN: DomainSpec(value_source=ATTR_HUMIDITY)}
+    _valid_unit = "%"
+
+    def _should_include(self, state: State) -> bool:
+        """Skip climate entities that do not expose a target humidity."""
+        return (
+            super()._should_include(state)
+            and state.attributes.get(ATTR_HUMIDITY) is not None
+        )
+
+
 CONDITIONS: dict[str, type[Condition]] = {
    "is_hvac_mode": ClimateHVACModeCondition,
    "is_off": make_entity_state_condition(DOMAIN, HVACMode.OFF),
@@ -88,10 +109,7 @@ CONDITIONS: dict[str, type[Condition]] = {
    "is_heating": make_entity_state_condition(
        {DOMAIN: DomainSpec(value_source=ATTR_HVAC_ACTION)}, HVACAction.HEATING
    ),
-    "target_humidity": make_entity_numerical_condition(
-        {DOMAIN: DomainSpec(value_source=ATTR_HUMIDITY)},
-        valid_unit="%",
-    ),
+    "target_humidity": ClimateTargetHumidityCondition,
    "target_temperature": ClimateTargetTemperatureCondition,
 }

@@ -8,14 +8,15 @@ from homeassistant.helpers import config_validation as cv
 from homeassistant.helpers.automation import DomainSpec
 from homeassistant.helpers.trigger import (
    ENTITY_STATE_TRIGGER_SCHEMA_FIRST_LAST,
+    EntityNumericalStateChangedTriggerBase,
    EntityNumericalStateChangedTriggerWithUnitBase,
+    EntityNumericalStateCrossedThresholdTriggerBase,
    EntityNumericalStateCrossedThresholdTriggerWithUnitBase,
+    EntityNumericalStateTriggerBase,
    EntityNumericalStateTriggerWithUnitBase,
    EntityTargetStateTriggerBase,
    Trigger,
    TriggerConfig,
-    make_entity_numerical_state_changed_trigger,
-    make_entity_numerical_state_crossed_threshold_trigger,
    make_entity_target_state_trigger,
    make_entity_transition_trigger,
 )
@@ -55,6 +56,13 @@ class _ClimateTargetTemperatureTriggerMixin(EntityNumericalStateTriggerWithUnitB
    _domain_specs = {DOMAIN: DomainSpec(value_source=ATTR_TEMPERATURE)}
    _unit_converter = TemperatureConverter

+    def _should_include(self, state: State) -> bool:
+        """Skip climate entities that do not expose a target temperature."""
+        return (
+            super()._should_include(state)
+            and state.attributes.get(ATTR_TEMPERATURE) is not None
+        )
+
    def _get_entity_unit(self, state: State) -> str | None:
        """Get the temperature unit of a climate entity from its state."""
        # Climate entities convert temperatures to the system unit via show_temp
@@ -75,6 +83,32 @@ class ClimateTargetTemperatureCrossedThresholdTrigger(
    """Trigger for climate target temperature value crossing a threshold."""


+class _ClimateTargetHumidityTriggerMixin(EntityNumericalStateTriggerBase):
+    """Mixin for climate target humidity triggers."""
+
+    _domain_specs = {DOMAIN: DomainSpec(value_source=ATTR_HUMIDITY)}
+    _valid_unit = "%"
+
+    def _should_include(self, state: State) -> bool:
+        """Skip climate entities that do not expose a target humidity."""
+        return (
+            super()._should_include(state)
+            and state.attributes.get(ATTR_HUMIDITY) is not None
+        )
+
+
+class ClimateTargetHumidityChangedTrigger(
+    _ClimateTargetHumidityTriggerMixin, EntityNumericalStateChangedTriggerBase
+):
+    """Trigger for climate target humidity value changes."""
+
+
+class ClimateTargetHumidityCrossedThresholdTrigger(
+    _ClimateTargetHumidityTriggerMixin, EntityNumericalStateCrossedThresholdTriggerBase
+):
+    """Trigger for climate target humidity value crossing a threshold."""
+
+
 TRIGGERS: dict[str, type[Trigger]] = {
    "hvac_mode_changed": HVACModeChangedTrigger,
    "started_cooling": make_entity_target_state_trigger(
@@ -83,14 +117,8 @@ TRIGGERS: dict[str, type[Trigger]] = {
    "started_drying": make_entity_target_state_trigger(
        {DOMAIN: DomainSpec(value_source=ATTR_HVAC_ACTION)}, HVACAction.DRYING
    ),
-    "target_humidity_changed": make_entity_numerical_state_changed_trigger(
-        {DOMAIN: DomainSpec(value_source=ATTR_HUMIDITY)},
-        valid_unit="%",
-    ),
-    "target_humidity_crossed_threshold": make_entity_numerical_state_crossed_threshold_trigger(
-        {DOMAIN: DomainSpec(value_source=ATTR_HUMIDITY)},
-        valid_unit="%",
-    ),
+    "target_humidity_changed": ClimateTargetHumidityChangedTrigger,
+    "target_humidity_crossed_threshold": ClimateTargetHumidityCrossedThresholdTrigger,
    "target_temperature_changed": ClimateTargetTemperatureChangedTrigger,
    "target_temperature_crossed_threshold": ClimateTargetTemperatureCrossedThresholdTrigger,
    "turned_off": make_entity_target_state_trigger(DOMAIN, HVACMode.OFF),
@@ -6,5 +6,5 @@
  "documentation": "https://www.home-assistant.io/integrations/conversation",
  "integration_type": "entity",
  "quality_scale": "internal",
-  "requirements": ["hassil==3.5.0", "home-assistant-intents==2026.3.24"]
+  "requirements": ["hassil==3.5.0", "home-assistant-intents==2026.5.5"]
 }
@@ -6,39 +6,22 @@ from homeassistant.components.event import (
    DoorbellEventType,
    EventDeviceClass,
 )
-from homeassistant.const import STATE_UNAVAILABLE, STATE_UNKNOWN
 from homeassistant.core import HomeAssistant, State
 from homeassistant.helpers.automation import DomainSpec
-from homeassistant.helpers.trigger import (
-    ENTITY_STATE_TRIGGER_SCHEMA,
-    EntityTriggerBase,
-    Trigger,
-)
+from homeassistant.helpers.trigger import StatelessEntityTriggerBase, Trigger


-class DoorbellRangTrigger(EntityTriggerBase):
+class DoorbellRangTrigger(StatelessEntityTriggerBase):
    """Trigger for doorbell event entity when a ring event is received."""

    _domain_specs = {EVENT_DOMAIN: DomainSpec(device_class=EventDeviceClass.DOORBELL)}
-    _schema = ENTITY_STATE_TRIGGER_SCHEMA

    def is_valid_state(self, state: State) -> bool:
        """Check if the entity is available and the event type is ring."""
-        return (
-            state.state not in (STATE_UNAVAILABLE, STATE_UNKNOWN)
-            and state.attributes.get(ATTR_EVENT_TYPE) == DoorbellEventType.RING
+        return super().is_valid_state(state) and (
+            state.attributes.get(ATTR_EVENT_TYPE) == DoorbellEventType.RING
        )

-    def is_valid_transition(self, from_state: State, to_state: State) -> bool:
-        """Check if the origin state is valid and different from the current state."""
-
-        # UNKNOWN is a valid from_state, otherwise the first time the event is received
-        # would not trigger
-        if from_state.state == STATE_UNAVAILABLE:
-            return False
-
-        return from_state.state != to_state.state
-

 TRIGGERS: dict[str, type[Trigger]] = {
    "rang": DoorbellRangTrigger,
@@ -13,6 +13,9 @@ from homeassistant.exceptions import HomeAssistantError
 from .const import DOMAIN
 from .coordinator import DucoConfigEntry

+# MAC addresses and serial numbers are redacted because a Duco installer or
+# manufacturer could cross-reference them against an installation registry to
+# identify the physical location of the device.
 TO_REDACT = {
    CONF_HOST,
    "mac",
@@ -31,9 +34,15 @@ async def async_get_config_entry_diagnostics(
    coordinator = entry.runtime_data

    board = asdict(coordinator.board_info)
+    # `time` is a Unix epoch timestamp of the last board info fetch; not useful for support triage.
    board.pop("time")
+    if board["public_api_version"] is None:
+        board.pop("public_api_version")
+    if board["software_version"] is None:
+        board.pop("software_version")

    try:
+        api_info_obj = await coordinator.client.async_get_api_info()
        lan_info = await coordinator.client.async_get_lan_info()
        duco_diags = await coordinator.client.async_get_diagnostics()
        write_remaining = await coordinator.client.async_get_write_req_remaining()
@@ -43,10 +52,15 @@ async def async_get_config_entry_diagnostics(
            translation_key="connection_error",
        ) from err

+    api_info: dict[str, Any] = {"public_api_version": api_info_obj.public_api_version}
+    if api_info_obj.reported_api_version is not None:
+        api_info["reported_api_version"] = api_info_obj.reported_api_version
+
    return async_redact_data(
        {
            "entry_data": entry.data,
            "board_info": board,
+            "api_info": api_info,
            "lan_info": asdict(lan_info),
            "nodes": {
                str(node_id): asdict(node)
@@ -137,10 +137,6 @@ class EcovacsConfigFlow(ConfigFlow, domain=DOMAIN):
        self, user_input: dict[str, Any] | None = None
    ) -> ConfigFlowResult:
        """Handle the initial step."""
-
-        if not self.show_advanced_options:
-            return await self.async_step_auth()
-
        if user_input:
            self._mode = user_input[CONF_MODE]
            return await self.async_step_auth()
@@ -16,5 +16,5 @@
  "integration_type": "hub",
  "iot_class": "local_push",
  "loggers": ["elkm1_lib"],
-  "requirements": ["elkm1-lib==2.2.13"]
+  "requirements": ["elkm1-lib==2.2.15"]
 }
@@ -199,7 +199,9 @@ class ElkSetting(ElkSensor):
    _element: Setting

    def _element_changed(self, element: Element, changeset: dict[str, Any]) -> None:
-        self._attr_native_value = self._element.value
+        self._attr_native_value = (
+            None if self._element.value is None else str(self._element.value)
+        )

    @property
    def extra_state_attributes(self) -> dict[str, Any]:
@@ -2,13 +2,13 @@

 import voluptuous as vol

-from homeassistant.const import CONF_OPTIONS, STATE_UNAVAILABLE, STATE_UNKNOWN
+from homeassistant.const import CONF_OPTIONS
 from homeassistant.core import HomeAssistant, State
 from homeassistant.helpers import config_validation as cv
 from homeassistant.helpers.automation import DomainSpec
 from homeassistant.helpers.trigger import (
    ENTITY_STATE_TRIGGER_SCHEMA,
-    EntityTriggerBase,
+    StatelessEntityTriggerBase,
    Trigger,
    TriggerConfig,
 )
@@ -28,7 +28,7 @@ EVENT_RECEIVED_TRIGGER_SCHEMA = ENTITY_STATE_TRIGGER_SCHEMA.extend(
 )


-class EventReceivedTrigger(EntityTriggerBase):
+class EventReceivedTrigger(StatelessEntityTriggerBase):
    """Trigger for event entity when it receives a matching event."""

    _domain_specs = {DOMAIN: DomainSpec()}
@@ -39,21 +39,10 @@ class EventReceivedTrigger(EntityTriggerBase):
        super().__init__(hass, config)
        self._event_types = set(self._options[CONF_EVENT_TYPE])

-    def is_valid_transition(self, from_state: State, to_state: State) -> bool:
-        """Check if the origin state is valid and different from the current state."""
-
-        # UNKNOWN is a valid from_state, otherwise the first time the event is received
-        # would not trigger
-        if from_state.state == STATE_UNAVAILABLE:
-            return False
-
-        return from_state.state != to_state.state
-
    def is_valid_state(self, state: State) -> bool:
-        """Check if the event type is valid and matches one of the configured types."""
-        return (
-            state.state not in (STATE_UNAVAILABLE, STATE_UNKNOWN)
-            and state.attributes.get(ATTR_EVENT_TYPE) in self._event_types
+        """Check if the event type matches one of the configured types."""
+        return super().is_valid_state(state) and (
+            state.attributes.get(ATTR_EVENT_TYPE) in self._event_types
        )


@@ -1,7 +1,5 @@
 """DataUpdateCoordinator for Fluss+ integration."""

-from __future__ import annotations
-
 import asyncio
 from typing import Any

@@ -21,5 +21,5 @@
  "integration_type": "system",
  "preview_features": { "winter_mode": {} },
  "quality_scale": "internal",
-  "requirements": ["home-assistant-frontend==20260429.2"]
+  "requirements": ["home-assistant-frontend==20260429.3"]
 }
@@ -15,5 +15,5 @@
  "integration_type": "device",
  "iot_class": "local_polling",
  "loggers": ["bleak", "bleak_esphome", "gardena_bluetooth"],
-  "requirements": ["gardena-bluetooth==2.4.0"]
+  "requirements": ["gardena-bluetooth==2.8.1"]
 }
@@ -596,7 +596,9 @@ class GrowattCoordinator(DataUpdateCoordinator[dict[str, Any]]):
        if not self.data:
            await self.async_refresh()

-        return self.api.sph_read_ac_charge_times(settings_data=self.data)
+        return self.api.sph_read_ac_charge_times(
+            self.device_id, settings_data=self.data
+        )

    async def read_ac_discharge_times(self) -> dict:
        """Read AC discharge time settings from SPH device cache."""
@@ -609,4 +611,6 @@ class GrowattCoordinator(DataUpdateCoordinator[dict[str, Any]]):
        if not self.data:
            await self.async_refresh()

-        return self.api.sph_read_ac_discharge_times(settings_data=self.data)
+        return self.api.sph_read_ac_discharge_times(
+            self.device_id, settings_data=self.data
+        )
@@ -8,5 +8,5 @@
  "iot_class": "cloud_polling",
  "loggers": ["growattServer"],
  "quality_scale": "silver",
-  "requirements": ["growattServer==1.9.0"]
+  "requirements": ["growattServer==2.1.0"]
 }
@@ -12,6 +12,7 @@ import voluptuous as vol
 from homeassistant.auth.models import User
 from homeassistant.auth.providers import homeassistant as auth_ha
 from homeassistant.components.http import KEY_HASS, KEY_HASS_USER, HomeAssistantView
+from homeassistant.components.http.const import is_supervisor_unix_socket_request
 from homeassistant.components.http.data_validator import RequestDataValidator
 from homeassistant.core import HomeAssistant, callback
 from homeassistant.helpers import config_validation as cv
@@ -41,14 +42,18 @@ class HassIOBaseAuth(HomeAssistantView):

    def _check_access(self, request: web.Request) -> None:
        """Check if this call is from Supervisor."""
-        # Check caller IP
-        hassio_ip = os.environ["SUPERVISOR"].split(":")[0]
-        assert request.transport
-        if ip_address(request.transport.get_extra_info("peername")[0]) != ip_address(
-            hassio_ip
-        ):
-            _LOGGER.error("Invalid auth request from %s", request.remote)
-            raise HTTPUnauthorized
+        # Requests over the Supervisor Unix socket are authenticated by the
+        # http auth middleware as the Supervisor user, so the caller-IP check
+        # below does not apply (and would crash, since `peername` is empty for
+        # Unix sockets). The user-ID check still runs to ensure only the
+        # Supervisor user can reach this endpoint.
+        if not is_supervisor_unix_socket_request(request):
+            hassio_ip = os.environ["SUPERVISOR"].split(":")[0]
+            assert request.transport
+            peername = request.transport.get_extra_info("peername")
+            if not peername or ip_address(peername[0]) != ip_address(hassio_ip):
+                _LOGGER.error("Invalid auth request from %s", request.remote)
+                raise HTTPUnauthorized

        # Check caller token
        if request[KEY_HASS_USER].id != self.user.id:
@@ -44,14 +44,20 @@ async def async_setup_entry(hass: HomeAssistant, entry: HiveConfigEntry) -> bool
    except HiveReauthRequired as err:
        raise ConfigEntryAuthFailed from err

+    hub_data = devices["parent"][0]
+    connections: set[tuple[str, str]] = set()
+    if mac := hub_data.get("macAddress"):
+        connections.add((dr.CONNECTION_NETWORK_MAC, dr.format_mac(mac)))
+
    device_registry = dr.async_get(hass)
    device_registry.async_get_or_create(
        config_entry_id=entry.entry_id,
-        identifiers={(DOMAIN, devices["parent"][0]["device_id"])},
-        name=devices["parent"][0]["hiveName"],
-        model=devices["parent"][0]["deviceData"]["model"],
-        sw_version=devices["parent"][0]["deviceData"]["version"],
-        manufacturer=devices["parent"][0]["deviceData"]["manufacturer"],
+        identifiers={(DOMAIN, hub_data["device_id"])},
+        connections=connections,
+        name=hub_data["hiveName"],
+        model=hub_data["deviceData"]["model"],
+        sw_version=hub_data["deviceData"]["version"],
+        manufacturer=hub_data["deviceData"]["manufacturer"],
    )

    await hass.config_entries.async_forward_entry_setups(
@@ -5,5 +5,5 @@
  "config_flow": true,
  "documentation": "https://www.home-assistant.io/integrations/holiday",
  "iot_class": "local_polling",
-  "requirements": ["holidays==0.95", "babel==2.15.0"]
+  "requirements": ["holidays==0.96", "babel==2.15.0"]
 }
@@ -7,5 +7,5 @@
  "integration_type": "hub",
  "iot_class": "cloud_push",
  "loggers": ["homematicip"],
-  "requirements": ["homematicip==2.9.0"]
+  "requirements": ["homematicip==2.10.0"]
 }
@@ -5,7 +5,7 @@ from typing import TYPE_CHECKING
 import voluptuous as vol

 from homeassistant.const import ATTR_MODE, CONF_OPTIONS, PERCENTAGE, STATE_OFF, STATE_ON
-from homeassistant.core import HomeAssistant
+from homeassistant.core import HomeAssistant, State
 from homeassistant.exceptions import HomeAssistantError
 from homeassistant.helpers import config_validation as cv
 from homeassistant.helpers.automation import DomainSpec
@@ -13,8 +13,8 @@ from homeassistant.helpers.condition import (
    ENTITY_STATE_CONDITION_SCHEMA_ANY_ALL,
    Condition,
    ConditionConfig,
+    EntityNumericalConditionBase,
    EntityStateConditionBase,
-    make_entity_numerical_condition,
    make_entity_state_condition,
 )
 from homeassistant.helpers.entity import get_supported_features
@@ -46,6 +46,20 @@ def _supports_feature(hass: HomeAssistant, entity_id: str, features: int) -> boo
        return False


+class IsTargetHumidityCondition(EntityNumericalConditionBase):
+    """Condition for humidifier target humidity."""
+
+    _domain_specs = {DOMAIN: DomainSpec(value_source=ATTR_HUMIDITY)}
+    _valid_unit = PERCENTAGE
+
+    def _should_include(self, state: State) -> bool:
+        """Skip humidifier entities that do not expose a target humidity."""
+        return (
+            super()._should_include(state)
+            and state.attributes.get(ATTR_HUMIDITY) is not None
+        )
+
+
 class IsModeCondition(EntityStateConditionBase):
    """Condition for humidifier mode."""

@@ -79,10 +93,7 @@ CONDITIONS: dict[str, type[Condition]] = {
        {DOMAIN: DomainSpec(value_source=ATTR_ACTION)}, HumidifierAction.HUMIDIFYING
    ),
    "is_mode": IsModeCondition,
-    "is_target_humidity": make_entity_numerical_condition(
-        {DOMAIN: DomainSpec(value_source=ATTR_HUMIDITY)},
-        valid_unit=PERCENTAGE,
-    ),
+    "is_target_humidity": IsTargetHumidityCondition,
 }


@@ -14,9 +14,9 @@ from homeassistant.components.weather import (
    DOMAIN as WEATHER_DOMAIN,
 )
 from homeassistant.const import PERCENTAGE
-from homeassistant.core import HomeAssistant
+from homeassistant.core import HomeAssistant, State
 from homeassistant.helpers.automation import DomainSpec
-from homeassistant.helpers.condition import Condition, make_entity_numerical_condition
+from homeassistant.helpers.condition import Condition, EntityNumericalConditionBase

 HUMIDITY_DOMAIN_SPECS = {
    CLIMATE_DOMAIN: DomainSpec(
@@ -31,8 +31,31 @@ HUMIDITY_DOMAIN_SPECS = {
    ),
 }

+
+class HumidityCondition(EntityNumericalConditionBase):
+    """Condition for humidity value across multiple domains."""
+
+    _domain_specs = HUMIDITY_DOMAIN_SPECS
+    _valid_unit = PERCENTAGE
+
+    def _should_include(self, state: State) -> bool:
+        """Skip attribute-source entities that lack the humidity attribute.
+
+        Mirrors the humidity trigger: for climate / humidifier / weather
+        (attribute-based), the entity is filtered when the source attribute
+        is absent; sensor entities (state-value-based) fall through to the
+        base impl.
+        """
+        if not super()._should_include(state):
+            return False
+        domain_spec = self._domain_specs[state.domain]
+        if domain_spec.value_source is None:
+            return True
+        return state.attributes.get(domain_spec.value_source) is not None
+
+
 CONDITIONS: dict[str, type[Condition]] = {
-    "is_value": make_entity_numerical_condition(HUMIDITY_DOMAIN_SPECS, PERCENTAGE),
+    "is_value": HumidityCondition,
 }


@@ -13,12 +13,13 @@ from homeassistant.components.weather import (
    ATTR_WEATHER_HUMIDITY,
    DOMAIN as WEATHER_DOMAIN,
 )
-from homeassistant.core import HomeAssistant
+from homeassistant.core import HomeAssistant, State
 from homeassistant.helpers.automation import DomainSpec
 from homeassistant.helpers.trigger import (
+    EntityNumericalStateChangedTriggerBase,
+    EntityNumericalStateCrossedThresholdTriggerBase,
+    EntityNumericalStateTriggerBase,
    Trigger,
-    make_entity_numerical_state_changed_trigger,
-    make_entity_numerical_state_crossed_threshold_trigger,
 )

 HUMIDITY_DOMAIN_SPECS: dict[str, DomainSpec] = {
@@ -36,13 +37,46 @@ HUMIDITY_DOMAIN_SPECS: dict[str, DomainSpec] = {
    ),
 }

+
+class _HumidityTriggerMixin(EntityNumericalStateTriggerBase):
+    """Mixin for humidity triggers providing entity filtering."""
+
+    _domain_specs = HUMIDITY_DOMAIN_SPECS
+    _valid_unit = "%"
+
+    def _should_include(self, state: State) -> bool:
+        """Skip attribute-source entities that lack the humidity attribute.
+
+        For domains whose tracked value comes from an attribute
+        (climate / humidifier / weather), require the attribute to be
+        present; otherwise the all/count check would treat an entity that
+        cannot report a humidity as a non-match and block behavior=last.
+        Sensor entities source their value from `state.state`, so they
+        fall through to the base impl.
+        """
+        if not super()._should_include(state):
+            return False
+        domain_spec = self._domain_specs[state.domain]
+        if domain_spec.value_source is None:
+            return True
+        return state.attributes.get(domain_spec.value_source) is not None
+
+
+class HumidityChangedTrigger(
+    _HumidityTriggerMixin, EntityNumericalStateChangedTriggerBase
+):
+    """Trigger for humidity value changes across multiple domains."""
+
+
+class HumidityCrossedThresholdTrigger(
+    _HumidityTriggerMixin, EntityNumericalStateCrossedThresholdTriggerBase
+):
+    """Trigger for humidity value crossing a threshold across multiple domains."""
+
+
 TRIGGERS: dict[str, type[Trigger]] = {
-    "changed": make_entity_numerical_state_changed_trigger(
-        HUMIDITY_DOMAIN_SPECS, valid_unit="%"
-    ),
-    "crossed_threshold": make_entity_numerical_state_crossed_threshold_trigger(
-        HUMIDITY_DOMAIN_SPECS, valid_unit="%"
-    ),
+    "changed": HumidityChangedTrigger,
+    "crossed_threshold": HumidityCrossedThresholdTrigger,
 }


@@ -13,5 +13,5 @@
  "documentation": "https://www.home-assistant.io/integrations/husqvarna_automower_ble",
  "integration_type": "device",
  "iot_class": "local_polling",
-  "requirements": ["automower-ble==0.2.8", "gardena-bluetooth==2.4.0"]
+  "requirements": ["automower-ble==0.2.8", "gardena-bluetooth==2.8.1"]
 }
@@ -76,14 +76,12 @@ CONFIG_SCHEMA = vol.Schema(
        vol.Optional(CONF_SEARCH, default="UnSeen UnDeleted"): str,
        # The default for new entries is to not include text and headers
        vol.Optional(CONF_EVENT_MESSAGE_DATA, default=[]): EVENT_MESSAGE_DATA_SELECTOR,
+        vol.Optional(
+            CONF_SSL_CIPHER_LIST, default=SSLCipherList.PYTHON_DEFAULT
+        ): CIPHER_SELECTOR,
+        vol.Optional(CONF_VERIFY_SSL, default=True): BOOLEAN_SELECTOR,
    }
 )
-CONFIG_SCHEMA_ADVANCED = {
-    vol.Optional(
-        CONF_SSL_CIPHER_LIST, default=SSLCipherList.PYTHON_DEFAULT
-    ): CIPHER_SELECTOR,
-    vol.Optional(CONF_VERIFY_SSL, default=True): BOOLEAN_SELECTOR,
-}

 OPTIONS_SCHEMA = vol.Schema(
    {
@@ -93,18 +91,15 @@ OPTIONS_SCHEMA = vol.Schema(
        vol.Optional(
            CONF_EVENT_MESSAGE_DATA, default=MESSAGE_DATA_OPTIONS
        ): EVENT_MESSAGE_DATA_SELECTOR,
+        vol.Optional(CONF_CUSTOM_EVENT_DATA_TEMPLATE): TEMPLATE_SELECTOR,
+        vol.Optional(CONF_MAX_MESSAGE_SIZE, default=DEFAULT_MAX_MESSAGE_SIZE): vol.All(
+            cv.positive_int,
+            vol.Range(min=DEFAULT_MAX_MESSAGE_SIZE, max=MAX_MESSAGE_SIZE_LIMIT),
+        ),
+        vol.Optional(CONF_ENABLE_PUSH, default=True): BOOLEAN_SELECTOR,
    }
 )

-OPTIONS_SCHEMA_ADVANCED = {
-    vol.Optional(CONF_CUSTOM_EVENT_DATA_TEMPLATE): TEMPLATE_SELECTOR,
-    vol.Optional(CONF_MAX_MESSAGE_SIZE, default=DEFAULT_MAX_MESSAGE_SIZE): vol.All(
-        cv.positive_int,
-        vol.Range(min=DEFAULT_MAX_MESSAGE_SIZE, max=MAX_MESSAGE_SIZE_LIMIT),
-    ),
-    vol.Optional(CONF_ENABLE_PUSH, default=True): BOOLEAN_SELECTOR,
-}
-

 async def validate_input(
    hass: HomeAssistant, user_input: dict[str, Any]
@@ -151,8 +146,6 @@ class IMAPConfigFlow(ConfigFlow, domain=DOMAIN):
        """Handle the initial step."""

        schema = CONFIG_SCHEMA
-        if self.show_advanced_options:
-            schema = schema.extend(CONFIG_SCHEMA_ADVANCED)

        if user_input is None:
            return self.async_show_form(step_id="user", data_schema=schema)
@@ -250,8 +243,6 @@ class ImapOptionsFlow(OptionsFlow):
                    return self.async_create_entry(data={})

        schema = OPTIONS_SCHEMA
-        if self.show_advanced_options:
-            schema = schema.extend(OPTIONS_SCHEMA_ADVANCED)
        schema = self.add_suggested_values_to_schema(schema, entry_data)

        return self.async_show_form(step_id="init", data_schema=schema, errors=errors)
@@ -77,10 +77,9 @@ async def async_reload(hass: HomeAssistant, service_call: ServiceCall) -> None:
    existing_intents = hass.data[DOMAIN]

    for intent_type, conf in existing_intents.items():
-        if isinstance(conf.get(CONF_ACTION), script.Script):
-            await conf[CONF_ACTION].async_stop()
-            conf[CONF_ACTION].async_unload()
        intent.async_remove(hass, intent_type)
+        if isinstance(conf.get(CONF_ACTION), script.Script):
+            await conf[CONF_ACTION].async_unload()

    if not new_config or DOMAIN not in new_config:
        hass.data[DOMAIN] = {}
@@ -251,8 +251,10 @@ class MatterFan(MatterEntity, FanEntity):
            return
        self._feature_map = feature_map
        self._attr_supported_features = FanEntityFeature(0)
+        # Reset to default so a featuremap change from MultiSpeed -> non-MultiSpeed
+        # does not leave a stale speed_count / percentage_step.
+        self._attr_speed_count = 100
        if feature_map & FanControlFeature.kMultiSpeed:
-            self._attr_supported_features |= FanEntityFeature.SET_SPEED
            self._attr_speed_count = int(
                self.get_matter_attribute_value(clusters.FanControl.Attributes.SpeedMax)
            )
@@ -302,8 +304,12 @@ class MatterFan(MatterEntity, FanEntity):
        if feature_map & FanControlFeature.kAirflowDirection:
            self._attr_supported_features |= FanEntityFeature.DIRECTION

+        # PercentSetting is always a mandatory attribute of the FanControl cluster,
+        # so percentage-based speed control is always available.
        self._attr_supported_features |= (
-            FanEntityFeature.TURN_OFF | FanEntityFeature.TURN_ON
+            FanEntityFeature.SET_SPEED
+            | FanEntityFeature.TURN_OFF
+            | FanEntityFeature.TURN_ON
        )


@@ -1,11 +1,108 @@
 """Provides conditions for media players."""

-from homeassistant.core import HomeAssistant
-from homeassistant.helpers.condition import Condition, make_entity_state_condition
+from datetime import datetime
+from typing import Any

+from homeassistant.core import HomeAssistant, State
+from homeassistant.helpers.automation import DomainSpec
+from homeassistant.helpers.condition import (
+    Condition,
+    EntityConditionBase,
+    EntityNumericalConditionBase,
+    make_entity_state_condition,
+)
+
+from . import ATTR_MEDIA_VOLUME_LEVEL, ATTR_MEDIA_VOLUME_MUTED
 from .const import DOMAIN, MediaPlayerState

+
+class _MediaPlayerMutedConditionBase(EntityConditionBase):
+    """Base class for media player is_muted/is_unmuted conditions."""
+
+    _domain_specs = {DOMAIN: DomainSpec()}
+    _target_muted: bool
+
+    def _state_valid_since(self, state: State) -> datetime:
+        """Anchor `for:` durations to `last_updated` for the muted attribute.
+
+        Needed because the domain spec does not reflect that the condition
+        reads from the muted and volume attributes.
+        """
+        return state.last_updated
+
+    def _has_volume_attributes(self, state: State) -> bool:
+        """Check if the state has volume muted or volume level attributes."""
+        return (
+            state.attributes.get(ATTR_MEDIA_VOLUME_MUTED) is not None
+            or state.attributes.get(ATTR_MEDIA_VOLUME_LEVEL) is not None
+        )
+
+    def _should_include(self, state: State) -> bool:
+        """Skip entities without volume attributes from the all/count check."""
+        return super()._should_include(state) and self._has_volume_attributes(state)
+
+    def _is_muted(self, state: State) -> bool:
+        """Check if the media player is muted."""
+        return (
+            state.attributes.get(ATTR_MEDIA_VOLUME_MUTED) is True
+            or state.attributes.get(ATTR_MEDIA_VOLUME_LEVEL) == 0
+        )
+
+    def is_valid_state(self, entity_state: State) -> bool:
+        """Check if the entity state matches the targeted muted state."""
+        if not self._has_volume_attributes(entity_state):
+            return False
+        return self._is_muted(entity_state) is self._target_muted
+
+
+class MediaPlayerIsMutedCondition(_MediaPlayerMutedConditionBase):
+    """Condition that passes when the media player is muted."""
+
+    _target_muted = True
+
+
+class MediaPlayerIsUnmutedCondition(_MediaPlayerMutedConditionBase):
+    """Condition that passes when the media player is not muted."""
+
+    _target_muted = False
+
+
+class MediaPlayerIsVolumeCondition(EntityNumericalConditionBase):
+    """Condition for media player volume level with 0.0-1.0 to percentage conversion."""
+
+    _domain_specs = {DOMAIN: DomainSpec(value_source=ATTR_MEDIA_VOLUME_LEVEL)}
+    _valid_unit = "%"
+
+    def _get_tracked_value(self, entity_state: State) -> Any:
+        """Get the volume value converted from 0.0-1.0 to percentage (0-100)."""
+        raw = super()._get_tracked_value(entity_state)
+        if raw is None:
+            return None
+        try:
+            return float(raw) * 100.0
+        except TypeError, ValueError:
+            return None
+
+    def _should_include(self, state: State) -> bool:
+        """Skip media players that do not expose a volume_level attribute."""
+        return (
+            super()._should_include(state)
+            and state.attributes.get(ATTR_MEDIA_VOLUME_LEVEL) is not None
+        )
+
+
 CONDITIONS: dict[str, type[Condition]] = {
+    "is_muted": MediaPlayerIsMutedCondition,
+    "is_not_playing": make_entity_state_condition(
+        DOMAIN,
+        {
+            MediaPlayerState.BUFFERING,
+            MediaPlayerState.IDLE,
+            MediaPlayerState.OFF,
+            MediaPlayerState.ON,
+            MediaPlayerState.PAUSED,
+        },
+    ),
    "is_off": make_entity_state_condition(DOMAIN, MediaPlayerState.OFF),
    "is_on": make_entity_state_condition(
        DOMAIN,
@@ -17,18 +114,10 @@ CONDITIONS: dict[str, type[Condition]] = {
            MediaPlayerState.PLAYING,
        },
    ),
-    "is_not_playing": make_entity_state_condition(
-        DOMAIN,
-        {
-            MediaPlayerState.BUFFERING,
-            MediaPlayerState.IDLE,
-            MediaPlayerState.OFF,
-            MediaPlayerState.ON,
-            MediaPlayerState.PAUSED,
-        },
-    ),
    "is_paused": make_entity_state_condition(DOMAIN, MediaPlayerState.PAUSED),
    "is_playing": make_entity_state_condition(DOMAIN, MediaPlayerState.PLAYING),
+    "is_unmuted": MediaPlayerIsUnmutedCondition,
+    "is_volume": MediaPlayerIsVolumeCondition,
 }


@@ -1,22 +1,51 @@
 .condition_common: &condition_common
-  target:
+  target: &condition_media_player_target
    entity:
      domain: media_player
  fields:
-    behavior:
+    behavior: &condition_behavior
      required: true
      default: any
      selector:
        automation_behavior:
          mode: condition
-    for:
+    for: &condition_for
      required: true
      default: 00:00:00
      selector:
        duration:

+.volume_threshold_entity: &volume_threshold_entity
+  - domain: input_number
+    unit_of_measurement: "%"
+  - domain: number
+    unit_of_measurement: "%"
+  - domain: sensor
+    unit_of_measurement: "%"
+
+.volume_threshold_number: &volume_threshold_number
+  min: 0
+  max: 100
+  mode: box
+  unit_of_measurement: "%"
+
+is_muted: *condition_common
 is_off: *condition_common
 is_on: *condition_common
 is_not_playing: *condition_common
 is_paused: *condition_common
 is_playing: *condition_common
+is_unmuted: *condition_common
+
+is_volume:
+  target: *condition_media_player_target
+  fields:
+    behavior: *condition_behavior
+    for: *condition_for
+    threshold:
+      required: true
+      selector:
+        numeric_threshold:
+          entity: *volume_threshold_entity
+          mode: is
+          number: *volume_threshold_number
@@ -1,5 +1,8 @@
 {
  "conditions": {
+    "is_muted": {
+      "condition": "mdi:volume-mute"
+    },
    "is_not_playing": {
      "condition": "mdi:stop"
    },
@@ -14,6 +17,12 @@
    },
    "is_playing": {
      "condition": "mdi:play"
+    },
+    "is_unmuted": {
+      "condition": "mdi:volume-high"
+    },
+    "is_volume": {
+      "condition": "mdi:volume-medium"
    }
  },
  "entity_component": {
@@ -143,6 +152,12 @@
    },
    "unmuted": {
      "trigger": "mdi:volume-high"
+    },
+    "volume_changed": {
+      "trigger": "mdi:volume-medium"
+    },
+    "volume_crossed_threshold": {
+      "trigger": "mdi:volume-medium"
    }
  }
 }
@@ -2,10 +2,24 @@
  "common": {
    "condition_behavior_name": "Condition passes if",
    "condition_for_name": "For at least",
+    "condition_threshold_name": "Threshold",
    "trigger_behavior_name": "Trigger when",
-    "trigger_for_name": "For at least"
+    "trigger_for_name": "For at least",
+    "trigger_threshold_name": "Threshold"
  },
  "conditions": {
+    "is_muted": {
+      "description": "Tests if one or more media players are muted.",
+      "fields": {
+        "behavior": {
+          "name": "[%key:component::media_player::common::condition_behavior_name%]"
+        },
+        "for": {
+          "name": "[%key:component::media_player::common::condition_for_name%]"
+        }
+      },
+      "name": "Media player is muted"
+    },
    "is_not_playing": {
      "description": "Tests if one or more media players are not playing.",
      "fields": {
@@ -65,6 +79,33 @@
        }
      },
      "name": "Media player is playing"
+    },
+    "is_unmuted": {
+      "description": "Tests if one or more media players are not muted.",
+      "fields": {
+        "behavior": {
+          "name": "[%key:component::media_player::common::condition_behavior_name%]"
+        },
+        "for": {
+          "name": "[%key:component::media_player::common::condition_for_name%]"
+        }
+      },
+      "name": "Media player is not muted"
+    },
+    "is_volume": {
+      "description": "Tests the volume of one or more media players.",
+      "fields": {
+        "behavior": {
+          "name": "[%key:component::media_player::common::condition_behavior_name%]"
+        },
+        "for": {
+          "name": "[%key:component::media_player::common::condition_for_name%]"
+        },
+        "threshold": {
+          "name": "[%key:component::media_player::common::condition_threshold_name%]"
+        }
+      },
+      "name": "Volume"
    }
  },
  "device_automation": {
@@ -520,6 +561,30 @@
        }
      },
      "name": "Media player unmuted"
+    },
+    "volume_changed": {
+      "description": "Triggers after the volume of one or more media players changes.",
+      "fields": {
+        "threshold": {
+          "name": "[%key:component::media_player::common::trigger_threshold_name%]"
+        }
+      },
+      "name": "Media player volume changed"
+    },
+    "volume_crossed_threshold": {
+      "description": "Triggers after the volume of one or more media players crosses a threshold.",
+      "fields": {
+        "behavior": {
+          "name": "[%key:component::media_player::common::trigger_behavior_name%]"
+        },
+        "for": {
+          "name": "[%key:component::media_player::common::trigger_for_name%]"
+        },
+        "threshold": {
+          "name": "[%key:component::media_player::common::trigger_threshold_name%]"
+        }
+      },
+      "name": "Media player volume crossed threshold"
    }
  }
 }
@@ -4,6 +4,9 @@ from homeassistant.const import STATE_UNAVAILABLE, STATE_UNKNOWN
 from homeassistant.core import HomeAssistant, State
 from homeassistant.helpers.automation import DomainSpec
 from homeassistant.helpers.trigger import (
+    EntityNumericalStateChangedTriggerBase,
+    EntityNumericalStateCrossedThresholdTriggerBase,
+    EntityNumericalStateTriggerBase,
    EntityTriggerBase,
    Trigger,
    make_entity_transition_trigger,
@@ -12,6 +15,10 @@ from homeassistant.helpers.trigger import (
 from . import ATTR_MEDIA_VOLUME_LEVEL, ATTR_MEDIA_VOLUME_MUTED, MediaPlayerState
 from .const import DOMAIN

+VOLUME_DOMAIN_SPECS = {
+    DOMAIN: DomainSpec(value_source=ATTR_MEDIA_VOLUME_LEVEL),
+}
+

 class _MediaPlayerMutedStateTriggerBase(EntityTriggerBase):
    """Base class for media player muted/unmuted triggers."""
@@ -33,27 +40,7 @@ class _MediaPlayerMutedStateTriggerBase(EntityTriggerBase):
        excluded from the check - otherwise an "all" check would never
        pass when there are media players without volume support.
        """
-        return state.state not in self._excluded_states and self._has_volume_attributes(
-            state
-        )
-
-    def check_all_match(self, entity_ids: set[str]) -> bool:
-        """Check if all mutable entity states match."""
-        return all(
-            self.is_valid_state(state)
-            for entity_id in entity_ids
-            if (state := self._hass.states.get(entity_id)) is not None
-            and self._should_include(state)
-        )
-
-    def count_matches(self, entity_ids: set[str]) -> int:
-        """Count matching mutable entities."""
-        return sum(
-            self.is_valid_state(state)
-            for entity_id in entity_ids
-            if (state := self._hass.states.get(entity_id)) is not None
-            and self._should_include(state)
-        )
+        return super()._should_include(state) and self._has_volume_attributes(state)

    def is_muted(self, state: State) -> bool:
        """Check if the media player is muted."""
@@ -91,9 +78,48 @@ class MediaPlayerUnmutedTrigger(_MediaPlayerMutedStateTriggerBase):
    _target_muted = False


+class VolumeTriggerMixin(EntityNumericalStateTriggerBase):
+    """Mixin for volume triggers."""
+
+    _domain_specs = VOLUME_DOMAIN_SPECS
+    _valid_unit = "%"
+
+    def _get_tracked_value(self, state: State) -> float | None:
+        """Get tracked volume as a percentage."""
+        value = super()._get_tracked_value(state)
+        if value is None:
+            return None
+        # Convert 0.0-1.0 range to percentage (0-100)
+        return value * 100.0
+
+    def _should_include(self, state: State) -> bool:
+        """Check if an entity should participate in all/count checks.
+
+        Entities without a volume level cannot have their volume tracked,
+        so they are excluded - otherwise an "all" check would never pass
+        when there are media players without volume support.
+        """
+        return (
+            super()._should_include(state)
+            and state.attributes.get(ATTR_MEDIA_VOLUME_LEVEL) is not None
+        )
+
+
+class VolumeChangedTrigger(EntityNumericalStateChangedTriggerBase, VolumeTriggerMixin):
+    """Trigger for media player volume changes."""
+
+
+class VolumeCrossedThresholdTrigger(
+    EntityNumericalStateCrossedThresholdTriggerBase, VolumeTriggerMixin
+):
+    """Trigger for media player volume crossing a threshold."""
+
+
 TRIGGERS: dict[str, type[Trigger]] = {
    "muted": MediaPlayerMutedTrigger,
    "unmuted": MediaPlayerUnmutedTrigger,
+    "volume_changed": VolumeChangedTrigger,
+    "volume_crossed_threshold": VolumeCrossedThresholdTrigger,
    "paused_playing": make_entity_transition_trigger(
        DOMAIN,
        from_states={
@@ -1,20 +1,34 @@
 .trigger_common: &trigger_common
-  target:
+  target: &trigger_media_player_target
    entity:
      domain: media_player
  fields:
-    behavior:
+    behavior: &trigger_behavior
      required: true
      default: any
      selector:
        automation_behavior:
          mode: trigger
-    for:
+    for: &trigger_for
      required: true
      default: 00:00:00
      selector:
        duration:

+.volume_threshold_entity: &volume_threshold_entity
+  - domain: input_number
+    unit_of_measurement: "%"
+  - domain: number
+    unit_of_measurement: "%"
+  - domain: sensor
+    unit_of_measurement: "%"
+
+.volume_threshold_number: &volume_threshold_number
+  min: 0
+  max: 100
+  mode: box
+  unit_of_measurement: "%"
+
 muted: *trigger_common
 unmuted: *trigger_common
 paused_playing: *trigger_common
@@ -22,3 +36,27 @@ started_playing: *trigger_common
 stopped_playing: *trigger_common
 turned_off: *trigger_common
 turned_on: *trigger_common
+
+volume_changed:
+  target: *trigger_media_player_target
+  fields:
+    threshold:
+      required: true
+      selector:
+        numeric_threshold:
+          entity: *volume_threshold_entity
+          mode: changed
+          number: *volume_threshold_number
+
+volume_crossed_threshold:
+  target: *trigger_media_player_target
+  fields:
+    behavior: *trigger_behavior
+    for: *trigger_for
+    threshold:
+      required: true
+      selector:
+        numeric_threshold:
+          entity: *volume_threshold_entity
+          mode: crossed
+          number: *volume_threshold_number
@@ -5,30 +5,31 @@ from datetime import timedelta
 from mill import Mill
 from mill_local import Mill as MillLocal

-from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import CONF_IP_ADDRESS, CONF_PASSWORD, CONF_USERNAME, Platform
 from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import ConfigEntryNotReady
 from homeassistant.helpers.aiohttp_client import async_get_clientsession

 from .const import CLOUD, CONNECTION_TYPE, DOMAIN, LOCAL
-from .coordinator import MillDataUpdateCoordinator, MillHistoricDataUpdateCoordinator
+from .coordinator import (
+    MillConfigEntry,
+    MillDataUpdateCoordinator,
+    MillHistoricDataUpdateCoordinator,
+)

 PLATFORMS = [Platform.CLIMATE, Platform.NUMBER, Platform.SENSOR]

+__all__ = ["CLOUD", "CONNECTION_TYPE", "DOMAIN", "LOCAL"]

-async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
+
+async def async_setup_entry(hass: HomeAssistant, entry: MillConfigEntry) -> bool:
    """Set up the Mill heater."""
-    hass.data.setdefault(DOMAIN, {LOCAL: {}, CLOUD: {}})
-
    if entry.data.get(CONNECTION_TYPE) == LOCAL:
        mill_data_connection = MillLocal(
            entry.data[CONF_IP_ADDRESS],
            websession=async_get_clientsession(hass),
        )
        update_interval = timedelta(seconds=15)
-        key = entry.data[CONF_IP_ADDRESS]
-        conn_type = LOCAL
    else:
        mill_data_connection = Mill(
            entry.data[CONF_USERNAME],
@@ -36,8 +37,6 @@ async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
            websession=async_get_clientsession(hass),
        )
        update_interval = timedelta(seconds=30)
-        key = entry.data[CONF_USERNAME]
-        conn_type = CLOUD

        historic_data_coordinator = MillHistoricDataUpdateCoordinator(
            hass,
@@ -56,14 +55,12 @@ async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
    )

    await data_coordinator.async_config_entry_first_refresh()
-    # Uses legacy hass.data[DOMAIN] pattern
-    # pylint: disable-next=hass-use-runtime-data
-    hass.data[DOMAIN][conn_type][key] = data_coordinator
+    entry.runtime_data = data_coordinator

    await hass.config_entries.async_forward_entry_setups(entry, PLATFORMS)
    return True


-async def async_unload_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
+async def async_unload_entry(hass: HomeAssistant, entry: MillConfigEntry) -> bool:
    """Unload a config entry."""
    return await hass.config_entries.async_unload_platforms(entry, PLATFORMS)
@@ -1,5 +1,4 @@
 """Support for mill wifi-enabled home heaters."""
-# pylint: disable=hass-use-runtime-data  # Uses legacy hass.data[DOMAIN] pattern

 from typing import Any

@@ -14,14 +13,7 @@ from homeassistant.components.climate import (
    HVACAction,
    HVACMode,
 )
-from homeassistant.config_entries import ConfigEntry
-from homeassistant.const import (
-    ATTR_TEMPERATURE,
-    CONF_IP_ADDRESS,
-    CONF_USERNAME,
-    PRECISION_TENTHS,
-    UnitOfTemperature,
-)
+from homeassistant.const import ATTR_TEMPERATURE, PRECISION_TENTHS, UnitOfTemperature
 from homeassistant.core import HomeAssistant, ServiceCall, callback
 from homeassistant.helpers import config_validation as cv
 from homeassistant.helpers.device_registry import CONNECTION_NETWORK_MAC, DeviceInfo
@@ -33,7 +25,6 @@ from .const import (
    ATTR_COMFORT_TEMP,
    ATTR_ROOM_NAME,
    ATTR_SLEEP_TEMP,
-    CLOUD,
    CONNECTION_TYPE,
    DOMAIN,
    LOCAL,
@@ -42,7 +33,7 @@ from .const import (
    MIN_TEMP,
    SERVICE_SET_ROOM_TEMP,
 )
-from .coordinator import MillDataUpdateCoordinator
+from .coordinator import MillConfigEntry, MillDataUpdateCoordinator
 from .entity import MillBaseEntity

 SET_ROOM_TEMP_SCHEMA = vol.Schema(
@@ -57,17 +48,16 @@ SET_ROOM_TEMP_SCHEMA = vol.Schema(

 async def async_setup_entry(
    hass: HomeAssistant,
-    entry: ConfigEntry,
+    entry: MillConfigEntry,
    async_add_entities: AddConfigEntryEntitiesCallback,
 ) -> None:
    """Set up the Mill climate."""
+    mill_data_coordinator = entry.runtime_data
+
    if entry.data.get(CONNECTION_TYPE) == LOCAL:
-        mill_data_coordinator = hass.data[DOMAIN][LOCAL][entry.data[CONF_IP_ADDRESS]]
        async_add_entities([LocalMillHeater(mill_data_coordinator)])
        return

-    mill_data_coordinator = hass.data[DOMAIN][CLOUD][entry.data[CONF_USERNAME]]
-
    entities = [
        MillHeater(mill_data_coordinator, mill_device)
        for mill_device in mill_data_coordinator.data.values()
@@ -57,6 +57,9 @@ class MillDataUpdateCoordinator(DataUpdateCoordinator):
        )


+type MillConfigEntry = ConfigEntry[MillDataUpdateCoordinator]
+
+
 class MillHistoricDataUpdateCoordinator(DataUpdateCoordinator):
    """Class to manage fetching Mill historic data."""

@@ -3,28 +3,23 @@
 from mill import Heater, MillDevice

 from homeassistant.components.number import NumberDeviceClass, NumberEntity
-from homeassistant.config_entries import ConfigEntry
-from homeassistant.const import CONF_USERNAME, UnitOfPower
+from homeassistant.const import UnitOfPower
 from homeassistant.core import HomeAssistant, callback
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback

-from .const import CLOUD, CONNECTION_TYPE, DOMAIN
-from .coordinator import MillDataUpdateCoordinator
+from .const import CLOUD, CONNECTION_TYPE
+from .coordinator import MillConfigEntry, MillDataUpdateCoordinator
 from .entity import MillBaseEntity


 async def async_setup_entry(
    hass: HomeAssistant,
-    entry: ConfigEntry,
+    entry: MillConfigEntry,
    async_add_entities: AddConfigEntryEntitiesCallback,
 ) -> None:
    """Set up the Mill Number."""
    if entry.data.get(CONNECTION_TYPE) == CLOUD:
-        # Uses legacy hass.data[DOMAIN] pattern
-        # pylint: disable-next=hass-use-runtime-data
-        mill_data_coordinator: MillDataUpdateCoordinator = hass.data[DOMAIN][CLOUD][
-            entry.data[CONF_USERNAME]
-        ]
+        mill_data_coordinator = entry.runtime_data

        async_add_entities(
            MillNumber(mill_data_coordinator, mill_device)
@@ -1,5 +1,4 @@
 """Support for mill wifi-enabled home heaters."""
-# pylint: disable=hass-use-runtime-data  # Uses legacy hass.data[DOMAIN] pattern

 import mill

@@ -9,12 +8,9 @@ from homeassistant.components.sensor import (
    SensorEntityDescription,
    SensorStateClass,
 )
-from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import (
    CONCENTRATION_PARTS_PER_BILLION,
    CONCENTRATION_PARTS_PER_MILLION,
-    CONF_IP_ADDRESS,
-    CONF_USERNAME,
    PERCENTAGE,
    EntityCategory,
    UnitOfEnergy,
@@ -29,11 +25,9 @@ from homeassistant.helpers.update_coordinator import CoordinatorEntity

 from .const import (
    BATTERY,
-    CLOUD,
    CONNECTION_TYPE,
    CONSUMPTION_TODAY,
    CONSUMPTION_YEAR,
-    DOMAIN,
    ECO2,
    HUMIDITY,
    LOCAL,
@@ -41,7 +35,7 @@ from .const import (
    TEMPERATURE,
    TVOC,
 )
-from .coordinator import MillDataUpdateCoordinator
+from .coordinator import MillConfigEntry, MillDataUpdateCoordinator
 from .entity import MillBaseEntity

 HEATER_SENSOR_TYPES: tuple[SensorEntityDescription, ...] = (
@@ -146,13 +140,13 @@ SOCKET_SENSOR_TYPES: tuple[SensorEntityDescription, ...] = (

 async def async_setup_entry(
    hass: HomeAssistant,
-    entry: ConfigEntry,
+    entry: MillConfigEntry,
    async_add_entities: AddConfigEntryEntitiesCallback,
 ) -> None:
    """Set up the Mill sensor."""
-    if entry.data.get(CONNECTION_TYPE) == LOCAL:
-        mill_data_coordinator = hass.data[DOMAIN][LOCAL][entry.data[CONF_IP_ADDRESS]]
+    mill_data_coordinator = entry.runtime_data

+    if entry.data.get(CONNECTION_TYPE) == LOCAL:
        async_add_entities(
            LocalMillSensor(
                mill_data_coordinator,
@@ -162,8 +156,6 @@ async def async_setup_entry(
        )
        return

-    mill_data_coordinator = hass.data[DOMAIN][CLOUD][entry.data[CONF_USERNAME]]
-
    entities = [
        MillSensor(
            mill_data_coordinator,
@@ -1,7 +1,5 @@
 """Mitsubishi Comfort integration for Home Assistant."""

-from __future__ import annotations
-
 import asyncio
 import logging

@@ -1,7 +1,5 @@
 """Climate entity for Mitsubishi Comfort integration."""

-from __future__ import annotations
-
 from typing import Any

 from mitsubishi_comfort import FanSpeed, IndoorUnit, Mode, VaneDirection
@@ -1,7 +1,5 @@
 """Config flow for Mitsubishi Comfort integration."""

-from __future__ import annotations
-
 import logging
 from typing import Any

@@ -1,7 +1,5 @@
 """DataUpdateCoordinator for Mitsubishi Comfort devices."""

-from __future__ import annotations
-
 import logging

 from mitsubishi_comfort import IndoorUnit, KumoStation
@@ -1,7 +1,5 @@
 """Base entity for Mitsubishi Comfort integration."""

-from __future__ import annotations
-
 from mitsubishi_comfort import IndoorUnit, KumoStation

 from homeassistant.helpers.device_registry import CONNECTION_NETWORK_MAC, DeviceInfo
@@ -82,6 +82,7 @@ ATTR_SENSOR_UOM = "unit_of_measurement"

 SIGNAL_SENSOR_UPDATE = f"{DOMAIN}_sensor_update"
 SIGNAL_LOCATION_UPDATE = DOMAIN + "_location_update_{}"
+SIGNAL_RECORD_NOTIFICATION = f"{DOMAIN}_record_notification"

 ATTR_CAMERA_ENTITY_ID = "camera_entity_id"

@@ -21,9 +21,13 @@ from homeassistant.components.notify import (
 )
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import ATTR_DEVICE_ID
-from homeassistant.core import HomeAssistant
+from homeassistant.core import HomeAssistant, callback
 from homeassistant.exceptions import HomeAssistantError
 from homeassistant.helpers.aiohttp_client import async_get_clientsession
+from homeassistant.helpers.dispatcher import (
+    async_dispatcher_connect,
+    async_dispatcher_send,
+)
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from homeassistant.helpers.typing import ConfigType, DiscoveryInfoType
 from homeassistant.util import dt as dt_util
@@ -46,6 +50,7 @@ from .const import (
    DATA_NOTIFY,
    DATA_PUSH_CHANNEL,
    DOMAIN,
+    SIGNAL_RECORD_NOTIFICATION,
 )
 from .helpers import device_info
 from .push_notification import PushChannel
@@ -111,6 +116,21 @@ class MobileAppNotifyEntity(NotifyEntity):
                translation_placeholders={"device_name": self._config_entry.title},
            )

+    @callback
+    def _async_handle_notification(self, webhook_id: str) -> None:
+        """Handle notifications triggered externally."""
+        if webhook_id == self._config_entry.data[ATTR_WEBHOOK_ID]:
+            self._async_record_notification()
+
+    async def async_added_to_hass(self) -> None:
+        """Register callback."""
+
+        self.async_on_remove(
+            async_dispatcher_connect(
+                self.hass, SIGNAL_RECORD_NOTIFICATION, self._async_handle_notification
+            )
+        )
+

 def push_registrations(hass: HomeAssistant) -> dict[str, str]:
    """Return a dictionary of push enabled registrations."""
@@ -195,6 +215,7 @@ class MobileAppNotificationService(BaseNotificationService):
                    data,
                    partial(self._async_send_remote_message_target, entry),
                )
+                async_dispatcher_send(self.hass, SIGNAL_RECORD_NOTIFICATION, target)
                continue

            # Test if local push only.
@@ -203,6 +224,7 @@ class MobileAppNotificationService(BaseNotificationService):
                continue

            await self._async_send_remote_message_target(entry, data)
+            async_dispatcher_send(self.hass, SIGNAL_RECORD_NOTIFICATION, target)

        if failed_targets:
            raise HomeAssistantError(
@@ -11,7 +11,12 @@ import voluptuous as vol
 from homeassistant import config as conf_util
 from homeassistant.components import websocket_api
 from homeassistant.config_entries import ConfigEntry
-from homeassistant.const import CONF_DISCOVERY, CONF_PLATFORM, SERVICE_RELOAD
+from homeassistant.const import (
+    CONF_DISCOVERY,
+    CONF_PLATFORM,
+    CONF_PROTOCOL,
+    SERVICE_RELOAD,
+)
 from homeassistant.core import HomeAssistant, ServiceCall, callback
 from homeassistant.exceptions import (
    ConfigValidationError,
@@ -27,6 +32,7 @@ from homeassistant.helpers import (
 from homeassistant.helpers.device_registry import DeviceEntry
 from homeassistant.helpers.dispatcher import async_dispatcher_connect
 from homeassistant.helpers.entity_platform import async_get_platforms
+from homeassistant.helpers.issue_registry import IssueSeverity, async_create_issue
 from homeassistant.helpers.reload import async_integration_yaml_config
 from homeassistant.helpers.service import async_register_admin_service
 from homeassistant.helpers.typing import ConfigType
@@ -73,12 +79,14 @@ from .const import (
    DEFAULT_DISCOVERY,
    DEFAULT_ENCODING,
    DEFAULT_PREFIX,
+    DEFAULT_PROTOCOL,
    DEFAULT_QOS,
    DEFAULT_RETAIN,
    DOMAIN,
    ENTITY_PLATFORMS,
    ENTRY_OPTION_FIELDS,
    MQTT_CONNECTION_STATE,
+    PROTOCOL_311,
    TEMPLATE_ERRORS,
    Platform,
 )
@@ -424,6 +432,26 @@ async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
    """Load a config entry."""
    mqtt_data: MqttData

+    if (protocol := entry.data.get(CONF_PROTOCOL, PROTOCOL_311)) != DEFAULT_PROTOCOL:
+        broker: str = entry.data[CONF_BROKER]
+        async_create_issue(
+            hass,
+            DOMAIN,
+            "protocol_5_migration",
+            issue_domain=DOMAIN,
+            is_fixable=True,
+            breaks_in_ha_version="2027.1.0",
+            severity=IssueSeverity.WARNING,
+            learn_more_url="https://www.home-assistant.io/integrations/mqtt/#mqtt-protocol",
+            data={
+                "entry_id": entry.entry_id,
+                "broker": broker,
+                "protocol": protocol,
+            },
+            translation_placeholders={"broker": broker, "protocol": protocol},
+            translation_key="protocol_5_migration",
+        )
+
    async def _setup_client() -> tuple[MqttData, dict[str, Any]]:
        """Set up the MQTT client."""
        # Fetch configuration
@@ -16,6 +16,8 @@ from typing import TYPE_CHECKING, Any
 from uuid import uuid4

 import certifi
+import paho.mqtt.client as mqtt
+from paho.mqtt.matcher import MQTTMatcher

 from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import (
@@ -47,6 +49,7 @@ from homeassistant.setup import SetupPhases, async_pause_setup
 from homeassistant.util.collection import chunked_or_all
 from homeassistant.util.logging import catch_log_exception, log_exception

+from .async_client import AsyncMQTTClient
 from .const import (
    CONF_BIRTH_MESSAGE,
    CONF_BROKER,
@@ -63,7 +66,6 @@ from .const import (
    DEFAULT_ENCODING,
    DEFAULT_KEEPALIVE,
    DEFAULT_PORT,
-    DEFAULT_PROTOCOL,
    DEFAULT_QOS,
    DEFAULT_TRANSPORT,
    DEFAULT_WILL,
@@ -74,6 +76,7 @@ from .const import (
    MQTT_PROCESSED_SUBSCRIPTIONS,
    PROTOCOL_5,
    PROTOCOL_31,
+    PROTOCOL_311,
    TRANSPORT_WEBSOCKETS,
 )
 from .models import (
@@ -86,13 +89,6 @@ from .models import (
 )
 from .util import EnsureJobAfterCooldown, get_file_path, mqtt_config_entry_enabled

-if TYPE_CHECKING:
-    # Only import for paho-mqtt type checking here, imports are done locally
-    # because integrations should be able to optionally rely on MQTT.
-    import paho.mqtt.client as mqtt
-
-    from .async_client import AsyncMQTTClient
-
 _LOGGER = logging.getLogger(__name__)

 MIN_BUFFER_SIZE = 131072  # Minimum buffer size to use if preferred size fails
@@ -323,15 +319,12 @@ class MqttClientSetup:
        The setup of the MQTT client should be run in an executor job,
        because it accesses files, so it does IO.
        """
-        # We don't import on the top because some integrations
-        # should be able to optionally rely on MQTT.
-        from paho.mqtt import client as mqtt  # noqa: PLC0415
-
-        from .async_client import AsyncMQTTClient  # noqa: PLC0415
-
        config = self._config
        clean_session: bool | None = None
-        if (protocol := config.get(CONF_PROTOCOL, DEFAULT_PROTOCOL)) == PROTOCOL_31:
+        # If no protocol setting is set in the config entry data
+        # we assume the config was migrated from YAML, and the
+        # protocol version is defaulting to legacy version 3.1.1.
+        if (protocol := config.get(CONF_PROTOCOL, PROTOCOL_311)) == PROTOCOL_31:
            proto = mqtt.MQTTv31
            clean_session = True
        elif protocol == PROTOCOL_5:
@@ -420,7 +413,10 @@ class MQTT:
        self.loop = hass.loop
        self.config_entry = config_entry
        self.conf = conf
-        self.is_mqttv5 = conf.get(CONF_PROTOCOL, DEFAULT_PROTOCOL) == PROTOCOL_5
+        # If no protocol setting is set in the config entry data
+        # we assume the config was migrated from YAML, and the
+        # protocol version is defaulting to legacy version 3.1.1.
+        self.is_mqttv5 = conf.get(CONF_PROTOCOL, PROTOCOL_311) == PROTOCOL_5

        self._simple_subscriptions: defaultdict[str, set[Subscription]] = defaultdict(
            set
@@ -555,7 +551,6 @@ class MQTT:
        """Start the misc periodic."""
        assert self._misc_timer is None, "Misc periodic already started"
        _LOGGER.debug("%s: Starting client misc loop", self.config_entry.title)
-        import paho.mqtt.client as mqtt  # noqa: PLC0415

        # Inner function to avoid having to check late import
        # each time the function is called.
@@ -699,7 +694,6 @@ class MQTT:

    async def async_connect(self, client_available: asyncio.Future[bool]) -> None:
        """Connect to the host. Does not process messages yet."""
-        import paho.mqtt.client as mqtt  # noqa: PLC0415

        result: int | None = None
        self._available_future = client_available
@@ -757,7 +751,6 @@ class MQTT:

    async def _reconnect_loop(self) -> None:
        """Reconnect to the MQTT server."""
-        import paho.mqtt.client as mqtt  # noqa: PLC0415

        while True:
            if not self.connected:
@@ -1259,9 +1252,6 @@ class MQTT:
    @callback
    def _async_handle_callback_exception(self, status: mqtt.MQTTErrorCode) -> None:
        """Handle a callback exception."""
-        # We don't import on the top because some integrations
-        # should be able to optionally rely on MQTT.
-        import paho.mqtt.client as mqtt  # noqa: PLC0415

        _LOGGER.warning(
            "Error returned from MQTT server: %s",
@@ -1306,8 +1296,6 @@ class MQTT:
    ) -> None:
        """Wait for ACK from broker or raise on error."""
        if result_code != 0:
-            import paho.mqtt.client as mqtt  # noqa: PLC0415
-
            raise HomeAssistantError(
                translation_domain=DOMAIN,
                translation_key="mqtt_broker_error",
@@ -1354,8 +1342,6 @@ class MQTT:


 def _matcher_for_topic(subscription: str) -> Callable[[str], bool]:
-    from paho.mqtt.matcher import MQTTMatcher  # noqa: PLC0415
-
    matcher = MQTTMatcher()  # type: ignore[no-untyped-call]
    matcher[subscription] = True

@@ -22,6 +22,7 @@ from cryptography.hazmat.primitives.serialization import (
    load_pem_private_key,
 )
 from cryptography.x509 import load_der_x509_certificate, load_pem_x509_certificate
+import paho.mqtt.client as mqtt
 import voluptuous as vol
 import yaml

@@ -4073,6 +4074,7 @@ class FlowHandler(ConfigFlow, domain=DOMAIN):
            config: dict[str, Any] = {
                CONF_BROKER: addon_discovery_config[CONF_HOST],
                CONF_PORT: addon_discovery_config[CONF_PORT],
+                CONF_PROTOCOL: DEFAULT_PROTOCOL,
                CONF_USERNAME: addon_discovery_config.get(CONF_USERNAME),
                CONF_PASSWORD: addon_discovery_config.get(CONF_PASSWORD),
                CONF_DISCOVERY: DEFAULT_DISCOVERY,
@@ -4301,6 +4303,7 @@ class FlowHandler(ConfigFlow, domain=DOMAIN):
        if user_input is not None:
            data: dict[str, Any] = self._hassio_discovery.copy()
            data[CONF_BROKER] = data.pop(CONF_HOST)
+            data[CONF_PROTOCOL] = DEFAULT_PROTOCOL
            can_connect = await self.hass.async_add_executor_job(
                try_connection,
                data,
@@ -4312,6 +4315,7 @@ class FlowHandler(ConfigFlow, domain=DOMAIN):
                    data={
                        CONF_BROKER: data[CONF_BROKER],
                        CONF_PORT: data[CONF_PORT],
+                        CONF_PROTOCOL: DEFAULT_PROTOCOL,
                        CONF_USERNAME: data.get(CONF_USERNAME),
                        CONF_PASSWORD: data.get(CONF_PASSWORD),
                        CONF_DISCOVERY: DEFAULT_DISCOVERY,
@@ -5178,6 +5182,8 @@ async def async_get_broker_settings(  # noqa: C901
    ) -> bool:
        """Additional validation on broker settings for better error messages."""

+        if CONF_PROTOCOL not in validated_user_input:
+            validated_user_input[CONF_PROTOCOL] = DEFAULT_PROTOCOL
        # Get current certificate settings from config entry
        certificate: str | None = (
            "auto"
@@ -5366,12 +5372,9 @@ async def async_get_broker_settings(  # noqa: C901
            description={"suggested_value": current_pass},
        )
    ] = PASSWORD_SELECTOR
-    # show advanced options checkbox if requested and
-    # advanced options are enabled
-    # or when the defaults of advanced options are overridden
+    # show advanced options checkbox if no defaults
+    # of the advanced options are overridden
    if not advanced_broker_options:
-        if not flow.show_advanced_options:
-            return False
        fields[
            vol.Optional(
                ADVANCED_OPTIONS,
@@ -5477,10 +5480,6 @@ def try_connection(
    user_input: dict[str, Any],
 ) -> bool:
    """Test if we can connect to an MQTT broker."""
-    # We don't import on the top because some integrations
-    # should be able to optionally rely on MQTT.
-    import paho.mqtt.client as mqtt  # noqa: PLC0415
-
    mqtt_client_setup = MqttClientSetup(user_input)
    mqtt_client_setup.setup()
    client = mqtt_client_setup.client
@@ -347,14 +347,14 @@ REMOTE_CODE_TEXT = "REMOTE_CODE_TEXT"
 PROTOCOL_31 = "3.1"
 PROTOCOL_311 = "3.1.1"
 PROTOCOL_5 = "5"
-SUPPORTED_PROTOCOLS = [PROTOCOL_31, PROTOCOL_311, PROTOCOL_5]
+SUPPORTED_PROTOCOLS = [PROTOCOL_5, PROTOCOL_311, PROTOCOL_31]

 TRANSPORT_TCP = "tcp"
 TRANSPORT_WEBSOCKETS = "websockets"

 DEFAULT_PORT = 1883
 DEFAULT_KEEPALIVE = 60
-DEFAULT_PROTOCOL = PROTOCOL_311
+DEFAULT_PROTOCOL = PROTOCOL_5
 DEFAULT_TRANSPORT = TRANSPORT_TCP

 DEFAULT_BIRTH = {
@@ -9,6 +9,8 @@ from enum import StrEnum
 import logging
 from typing import TYPE_CHECKING, Any, TypedDict

+from paho.mqtt.client import MQTTMessage
+
 from homeassistant.const import ATTR_ENTITY_ID, ATTR_NAME, Platform
 from homeassistant.core import CALLBACK_TYPE, callback
 from homeassistant.exceptions import ServiceValidationError, TemplateError
@@ -24,8 +26,6 @@ from homeassistant.helpers.typing import (
 from homeassistant.util.hass_dict import HassKey

 if TYPE_CHECKING:
-    from paho.mqtt.client import MQTTMessage
-
    from .client import MQTT, Subscription
    from .debug_info import TimestampedPublishMessage
    from .device_trigger import Trigger
@@ -6,10 +6,16 @@ import voluptuous as vol

 from homeassistant import data_entry_flow
 from homeassistant.components.repairs import RepairsFlow
+from homeassistant.const import CONF_PORT, CONF_PROTOCOL
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers import device_registry as dr

-from .const import DOMAIN
+from .config_flow import try_connection
+from .const import DEFAULT_PORT, DOMAIN, PROTOCOL_5
+
+URL_MQTT_BROKER_CONFIGURATION = (
+    "https://www.home-assistant.io/integrations/mqtt/#broker-configuration"
+)


 class MQTTDeviceEntryMigration(RepairsFlow):
@@ -50,6 +56,55 @@ class MQTTDeviceEntryMigration(RepairsFlow):
        )


+class MQTTProtocolV5Migration(RepairsFlow):
+    """Handler to migrate to MQTT protocol version 5."""
+
+    def __init__(self, entry_id: str, broker: str, protocol: str) -> None:
+        """Initialize the flow."""
+        self.entry_id = entry_id
+        self.broker = broker
+        self.protocol = protocol
+
+    async def async_step_init(
+        self, user_input: dict[str, str] | None = None
+    ) -> data_entry_flow.FlowResult:
+        """Handle the first step of a fix flow."""
+        return await self.async_step_confirm()
+
+    async def async_step_confirm(
+        self, user_input: dict[str, str] | None = None
+    ) -> data_entry_flow.FlowResult:
+        """Handle the confirm step of a fix flow."""
+        if user_input is not None:
+            entry = self.hass.config_entries.async_get_entry(self.entry_id)
+            if TYPE_CHECKING:
+                assert entry is not None
+            new_entry_data = entry.data.copy()
+            new_entry_data[CONF_PROTOCOL] = PROTOCOL_5
+            # Try the connection with protocol version 5
+            if await self.hass.async_add_executor_job(
+                try_connection,
+                {CONF_PORT: DEFAULT_PORT} | new_entry_data,
+            ):
+                self.hass.config_entries.async_update_entry(entry, data=new_entry_data)
+                return self.async_create_entry(data={})
+
+            return self.async_abort(
+                reason="mqtt_broker_migration_to_v5_failed",
+                description_placeholders={
+                    "broker": self.broker,
+                    "protocol": self.protocol,
+                    "url_mqtt_broker_configuration": URL_MQTT_BROKER_CONFIGURATION,
+                },
+            )
+
+        return self.async_show_form(
+            step_id="confirm",
+            data_schema=vol.Schema({}),
+            description_placeholders={"broker": self.broker, "protocol": self.protocol},
+        )
+
+
 async def async_create_fix_flow(
    hass: HomeAssistant,
    issue_id: str,
@@ -58,13 +113,13 @@ async def async_create_fix_flow(
    """Create flow."""
    if TYPE_CHECKING:
        assert data is not None
-    entry_id = data["entry_id"]
-    subentry_id = data["subentry_id"]
-    name = data["name"]
-    if TYPE_CHECKING:
-        assert isinstance(entry_id, str)
-        assert isinstance(subentry_id, str)
-        assert isinstance(name, str)
+    entry_id: str = data["entry_id"]  # type: ignore[assignment]
+    if issue_id == "protocol_5_migration":
+        broker: str = data["broker"]  # type: ignore[assignment]
+        protocol: str = data["protocol"]  # type: ignore[assignment]
+        return MQTTProtocolV5Migration(entry_id, broker, protocol)
+    subentry_id: str = data["subentry_id"]  # type: ignore[assignment]
+    name: str = data["name"]  # type: ignore[assignment]
    return MQTTDeviceEntryMigration(
        entry_id=entry_id,
        subentry_id=subentry_id,
@@ -1120,6 +1120,20 @@
      "description": "Home Assistant detected an invalid config for a manually configured item.\n\nPlatform domain: **{domain}**\nConfiguration file: **{config_file}**\nNear line: **{line}**\nConfiguration found:\n```yaml\n{config}\n```\nError: **{error}**.\n\nMake sure the configuration is valid and [reload](/config/developer-tools/yaml) the manually configured MQTT items or restart Home Assistant to fix this issue.",
      "title": "Invalid config found for MQTT {domain} item"
    },
+    "protocol_5_migration": {
+      "fix_flow": {
+        "abort": {
+          "mqtt_broker_migration_to_v5_failed": "Migrating the broker ({broker}) protocol version from {protocol} to 5 failed, and the migration has been aborted.\n\nYour broker may not support MQTT protocol version 5.\n\nPlease [reconfigure your MQTT broker settings]({url_mqtt_broker_configuration}) or upgrade your broker to support MQTT protocol version 5 to fix this issue."
+        },
+        "step": {
+          "confirm": {
+            "description": "Home Assistant is migrating to MQTT protocol version 5. The currently configured protocol version for broker {broker} is {protocol}. This protocol version is deprecated, and support for it will be removed.\n\nSubmitting this form will try to migrate your MQTT broker configuration to use protocol version 5 to fix this issue.",
+            "title": "MQTT protocol change required"
+          }
+        }
+      },
+      "title": "Deprecated MQTT protocol {protocol} in use"
+    },
    "subentry_migration_discovery": {
      "fix_flow": {
        "step": {
@@ -67,25 +67,11 @@ OPENING_CATEGORY_TO_DEVICE_CLASS: Final[dict[str | None, BinarySensorDeviceClass


 def get_opening_category(netatmo_device: NetatmoDevice) -> str:
-    """Helper function to get opening category from Netatmo API raw data."""
+    """Helper function to get opening category for doortag."""

-    # Iterate through each home in the raw data.
-    for home in netatmo_device.data_handler.account.raw_data["homes"]:
-        # Check if the modules list exists for the current home.
-        if "modules" in home:
-            # Iterate through each module to find a matching ID.
-            for module in home["modules"]:
-                if module["id"] == netatmo_device.device.entity_id:
-                    # We found the matching device. Get its category.
-                    if module.get("category") is not None:
-                        return cast(str, module["category"])
-                    raise ValueError(
-                        f"Device {netatmo_device.device.entity_id} found, "
-                        "but 'category' is missing in raw data."
-                    )
-
-    raise ValueError(
-        f"Device {netatmo_device.device.entity_id} not found in Netatmo raw data."
+    return (
+        getattr(netatmo_device.device, "doortag_category", None)
+        or DOORTAG_CATEGORY_OTHER
    )


@@ -12,6 +12,7 @@ from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from .const import CONF_URL_CONTROL, NETATMO_CREATE_BUTTON
 from .data_handler import HOME, SIGNAL_NAME, NetatmoConfigEntry, NetatmoDevice
 from .entity import NetatmoModuleEntity
+from .helper import device_type_to_str

 _LOGGER = logging.getLogger(__name__)

@@ -55,9 +56,7 @@ class NetatmoCoverPreferredPositionButton(NetatmoModuleEntity, ButtonEntity):
                },
            ]
        )
-        self._attr_unique_id = (
-            f"{self.device.entity_id}-{self.device_type}-preferred_position"
-        )
+        self._attr_unique_id = f"{self.device.entity_id}-{device_type_to_str(self.device_type)}-preferred_position"

    @callback
    def async_update_callback(self) -> None:
@@ -42,6 +42,7 @@ from .const import (
 )
 from .data_handler import EVENT, HOME, SIGNAL_NAME, NetatmoConfigEntry, NetatmoDevice
 from .entity import NetatmoModuleEntity
+from .helper import device_type_to_str

 _LOGGER = logging.getLogger(__name__)

@@ -102,7 +103,9 @@ class NetatmoCamera(NetatmoModuleEntity, Camera):
        Camera.__init__(self)
        super().__init__(netatmo_device)

-        self._attr_unique_id = f"{netatmo_device.device.entity_id}-{self.device_type}"
+        self._attr_unique_id = (
+            f"{netatmo_device.device.entity_id}-{device_type_to_str(self.device_type)}"
+        )
        self._light_state = None

        self._publishers.extend(
@@ -54,6 +54,7 @@ from .const import (
 )
 from .data_handler import HOME, SIGNAL_NAME, NetatmoConfigEntry, NetatmoRoom
 from .entity import NetatmoRoomEntity
+from .helper import device_type_to_str

 _LOGGER = logging.getLogger(__name__)

@@ -219,7 +220,9 @@ class NetatmoThermostat(NetatmoRoomEntity, ClimateEntity):
        if self.device_type is NA_THERM:
            self._attr_hvac_modes.append(HVACMode.OFF)

-        self._attr_unique_id = f"{self.device.entity_id}-{self.device_type}"
+        self._attr_unique_id = (
+            f"{self.device.entity_id}-{device_type_to_str(self.device_type)}"
+        )

    async def async_added_to_hass(self) -> None:
        """Entity created."""
@@ -18,6 +18,7 @@ from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from .const import CONF_URL_CONTROL, NETATMO_CREATE_COVER
 from .data_handler import HOME, SIGNAL_NAME, NetatmoConfigEntry, NetatmoDevice
 from .entity import NetatmoModuleEntity
+from .helper import device_type_to_str

 _LOGGER = logging.getLogger(__name__)

@@ -70,7 +71,9 @@ class NetatmoCover(NetatmoModuleEntity, CoverEntity):
                },
            ]
        )
-        self._attr_unique_id = f"{self.device.entity_id}-{self.device_type}"
+        self._attr_unique_id = (
+            f"{self.device.entity_id}-{device_type_to_str(self.device_type)}"
+        )

    async def async_close_cover(self, **kwargs: Any) -> None:
        """Close the cover."""
@@ -13,6 +13,7 @@ from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from .const import CONF_URL_CONTROL, NETATMO_CREATE_FAN
 from .data_handler import HOME, SIGNAL_NAME, NetatmoConfigEntry, NetatmoDevice
 from .entity import NetatmoModuleEntity
+from .helper import device_type_to_str

 _LOGGER = logging.getLogger(__name__)

@@ -62,7 +63,9 @@ class NetatmoFan(NetatmoModuleEntity, FanEntity):
            ]
        )

-        self._attr_unique_id = f"{self.device.entity_id}-{self.device_type}"
+        self._attr_unique_id = (
+            f"{self.device.entity_id}-{device_type_to_str(self.device_type)}"
+        )

    async def async_set_preset_mode(self, preset_mode: str) -> None:
        """Set the preset mode of the fan."""
@@ -3,6 +3,16 @@
 from dataclasses import dataclass
 from uuid import UUID, uuid4

+from pyatmo.modules.device_types import DeviceType as NetatmoDeviceType
+
+
+def device_type_to_str(device_type: NetatmoDeviceType) -> str:
+    """Convert a device type to a string.
+
+    Used to generate backwards compatible unique ids.
+    """
+    return f"{type(device_type).__name__}.{device_type}"
+

@dataclass
 class NetatmoArea:
@@ -12,5 +12,5 @@
  "integration_type": "hub",
  "iot_class": "cloud_polling",
  "loggers": ["pyatmo"],
-  "requirements": ["pyatmo==9.2.3"]
+  "requirements": ["pyatmo==9.4.0"]
 }
@@ -13,6 +13,7 @@ from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from .const import CONF_URL_CONTROL, NETATMO_CREATE_SWITCH
 from .data_handler import HOME, SIGNAL_NAME, NetatmoConfigEntry, NetatmoDevice
 from .entity import NetatmoModuleEntity
+from .helper import device_type_to_str

 _LOGGER = logging.getLogger(__name__)

@@ -58,7 +59,9 @@ class NetatmoSwitch(NetatmoModuleEntity, SwitchEntity):
                },
            ]
        )
-        self._attr_unique_id = f"{self.device.entity_id}-{self.device_type}"
+        self._attr_unique_id = (
+            f"{self.device.entity_id}-{device_type_to_str(self.device_type)}"
+        )
        self._attr_is_on = self.device.on

    @callback
@@ -72,7 +72,6 @@ UNSUPPORTED_MODELS: list[str] = [
 ]

 UNSUPPORTED_WEB_SEARCH_MODELS: list[str] = [
-    "gpt-5-nano",
    "gpt-3.5",
    "gpt-4-turbo",
    "gpt-4.1-nano",
@@ -2,7 +2,7 @@

 from collections.abc import Mapping
 import logging
-from typing import TYPE_CHECKING, Any
+from typing import TYPE_CHECKING, Any, Literal

 from openai import OpenAIError
 from propcache.api import cached_property
@@ -164,14 +164,15 @@ class OpenAITTSEntity(TextToSpeechEntity, OpenAIBaseLLMEntity):
        client = self.entry.runtime_data

        response_format = options[ATTR_PREFERRED_FORMAT]
-        if response_format not in self._supported_formats:
-            # common aliases
-            if response_format == "ogg":
-                response_format = "opus"
-            elif response_format == "raw":
-                response_format = "pcm"
-            else:
-                response_format = self.default_options[ATTR_PREFERRED_FORMAT]
+        if response_format in ("ogg", "oga"):
+            codec: Literal["mp3", "opus", "aac", "flac", "wav", "pcm"] = "opus"
+        elif response_format == "raw":
+            response_format = codec = "pcm"
+        elif response_format not in self._supported_formats:
+            response_format = self.default_options[ATTR_PREFERRED_FORMAT]
+            codec = response_format
+        else:
+            codec = response_format

        try:
            async with client.audio.speech.with_streaming_response.create(
@@ -180,7 +181,7 @@ class OpenAITTSEntity(TextToSpeechEntity, OpenAIBaseLLMEntity):
                input=message,
                instructions=str(options.get(CONF_PROMPT)),
                speed=options.get(CONF_TTS_SPEED, RECOMMENDED_TTS_SPEED),
-                response_format=response_format,
+                response_format=codec,
            ) as response:
                response_data = bytearray()
                async for chunk in response.iter_bytes():
@@ -1,7 +1,5 @@
 """Services for the Overkiz integration."""

-from __future__ import annotations
-
 import voluptuous as vol

 from homeassistant.components.cover import (
@@ -1,7 +1,7 @@
 {
  "domain": "roomba",
  "name": "iRobot Roomba and Braava",
-  "codeowners": ["@pschmitt", "@cyr-ius", "@shenxn", "@Orhideous"],
+  "codeowners": ["@pschmitt", "@cyr-ius", "@shenxn"],
  "config_flow": true,
  "dhcp": [
    {
@@ -8,5 +8,5 @@
  "iot_class": "local_push",
  "loggers": ["satel_integra"],
  "quality_scale": "bronze",
-  "requirements": ["satel-integra==1.3.0"]
+  "requirements": ["satel-integra==1.3.1"]
 }
@@ -1,36 +1,16 @@
 """Provides triggers for scenes."""

-from homeassistant.const import STATE_UNAVAILABLE, STATE_UNKNOWN
-from homeassistant.core import HomeAssistant, State
+from homeassistant.core import HomeAssistant
 from homeassistant.helpers.automation import DomainSpec
-from homeassistant.helpers.trigger import (
-    ENTITY_STATE_TRIGGER_SCHEMA,
-    EntityTriggerBase,
-    Trigger,
-)
+from homeassistant.helpers.trigger import StatelessEntityTriggerBase, Trigger

 from . import DOMAIN


-class SceneActivatedTrigger(EntityTriggerBase):
+class SceneActivatedTrigger(StatelessEntityTriggerBase):
    """Trigger for scene entity activations."""

    _domain_specs = {DOMAIN: DomainSpec()}
-    _schema = ENTITY_STATE_TRIGGER_SCHEMA
-
-    def is_valid_transition(self, from_state: State, to_state: State) -> bool:
-        """Check if the origin state is valid and different from the current state."""
-
-        # UNKNOWN is a valid from_state, otherwise the first time the scene is activated
-        # it would not trigger
-        if from_state.state == STATE_UNAVAILABLE:
-            return False
-
-        return from_state.state != to_state.state
-
-    def is_valid_state(self, state: State) -> bool:
-        """Check if the new state is not invalid."""
-        return state.state not in (STATE_UNAVAILABLE, STATE_UNKNOWN)


 TRIGGERS: dict[str, type[Trigger]] = {
@@ -766,14 +766,14 @@ class ScriptEntity(BaseScriptEntity, RestoreEntity):

    async def async_will_remove_from_hass(self) -> None:
        """Stop script and remove service when it will be removed from HA."""
-        await self.script.async_stop()
-        if not self.registry_entry or self.registry_entry.entity_id == self.entity_id:
-            # Entity ID not changed, unload the script as it will not be reused.
-            self.script.async_unload()
-
-        # remove service
        self.hass.services.async_remove(DOMAIN, self._attr_unique_id)

+        if self.registry_entry and self.registry_entry.entity_id != self.entity_id:
+            # Entity ID change, do not unload the script as it will be reused.
+            await self.script.async_stop()
+            return
+        await self.script.async_unload()
+

@websocket_api.websocket_command({"type": "script/config", "entity_id": str})
 def websocket_config(
@@ -4,5 +4,5 @@
  "codeowners": ["@fabaff"],
  "documentation": "https://www.home-assistant.io/integrations/serial",
  "iot_class": "local_polling",
-  "requirements": ["serialx==1.4.1"]
+  "requirements": ["serialx==1.7.1"]
 }
@@ -56,6 +56,7 @@ PLATFORMS_BY_TYPE = {
    SupportedModels.HYGROMETER.value: [Platform.SENSOR],
    SupportedModels.HYGROMETER_CO2.value: [
        Platform.BUTTON,
+        Platform.NUMBER,
        Platform.SENSOR,
        Platform.SELECT,
    ],
@@ -0,0 +1,77 @@
+"""Number platform for SwitchBot devices."""
+
+from datetime import timedelta
+import logging
+
+import switchbot
+from switchbot import SwitchbotOperationError
+from switchbot.devices.meter_pro import MAX_TIME_OFFSET
+
+from homeassistant.components.number import NumberDeviceClass, NumberEntity
+from homeassistant.const import EntityCategory, UnitOfTime
+from homeassistant.core import HomeAssistant
+from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
+
+from .coordinator import SwitchbotConfigEntry, SwitchbotDataUpdateCoordinator
+from .entity import SwitchbotEntity, exception_handler
+
+PARALLEL_UPDATES = 0
+SCAN_INTERVAL = timedelta(days=7)
+_LOGGER = logging.getLogger(__name__)
+_SECONDS_IN_MINUTE = 60
+_MAX_TIME_OFFSET_MINUTES = MAX_TIME_OFFSET // _SECONDS_IN_MINUTE
+
+
+async def async_setup_entry(
+    hass: HomeAssistant,
+    entry: SwitchbotConfigEntry,
+    async_add_entities: AddConfigEntryEntitiesCallback,
+) -> None:
+    """Set up SwitchBot number platform."""
+    coordinator = entry.runtime_data
+
+    if isinstance(coordinator.device, switchbot.SwitchbotMeterProCO2):
+        async_add_entities(
+            [SwitchBotMeterProCO2DisplayTimeOffsetNumber(coordinator)], True
+        )
+
+
+class SwitchBotMeterProCO2DisplayTimeOffsetNumber(SwitchbotEntity, NumberEntity):
+    """Number entity to set the time offset for Meter Pro CO2 devices."""
+
+    _device: switchbot.SwitchbotMeterProCO2
+    _attr_device_class = NumberDeviceClass.DURATION
+    _attr_entity_category = EntityCategory.CONFIG
+    _attr_translation_key = "display_time_offset"
+    _attr_native_min_value = -_MAX_TIME_OFFSET_MINUTES
+    _attr_native_max_value = _MAX_TIME_OFFSET_MINUTES
+    _attr_native_step = 1.0
+    _attr_native_unit_of_measurement = UnitOfTime.MINUTES
+    _attr_should_poll = True
+    _attr_entity_registry_enabled_default = False
+
+    def __init__(self, coordinator: SwitchbotDataUpdateCoordinator) -> None:
+        """Initialize the number entity."""
+        super().__init__(coordinator)
+        self._attr_unique_id = f"{coordinator.base_unique_id}_display_time_offset"
+
+    @exception_handler
+    async def async_set_native_value(self, value: float) -> None:
+        """Set the time offset."""
+        _LOGGER.debug("Setting time offset to %s minutes for %s", value, self._address)
+        offset_minutes = round(value)
+        offset_seconds = offset_minutes * _SECONDS_IN_MINUTE
+        await self._device.set_time_offset(offset_seconds)
+        self._attr_native_value = offset_minutes
+        self.async_write_ha_state()
+
+    async def async_update(self) -> None:
+        """Fetch the latest time offset from the device."""
+        try:
+            offset_seconds = await self._device.get_time_offset()
+        except SwitchbotOperationError:
+            _LOGGER.debug(
+                "Failed to update time offset for %s", self._address, exc_info=True
+            )
+            return
+        self._attr_native_value = round(offset_seconds / _SECONDS_IN_MINUTE)
@@ -272,6 +272,11 @@
        }
      }
    },
+    "number": {
+      "display_time_offset": {
+        "name": "Display time offset"
+      }
+    },
    "select": {
      "time_format": {
        "name": "Time format",
@@ -46,6 +46,21 @@ class TemperatureCondition(EntityNumericalConditionWithUnitBase):
    _domain_specs = TEMPERATURE_DOMAIN_SPECS
    _unit_converter = TemperatureConverter

+    def _should_include(self, state: State) -> bool:
+        """Skip attribute-source entities that lack the temperature attribute.
+
+        Mirrors the temperature trigger: for climate / water_heater /
+        weather (attribute-based), the entity is filtered when the source
+        attribute is absent; sensor entities (state-value-based) fall
+        through to the base impl.
+        """
+        if not super()._should_include(state):
+            return False
+        domain_spec = self._domain_specs[state.domain]
+        if domain_spec.value_source is None:
+            return True
+        return state.attributes.get(domain_spec.value_source) is not None
+
    def _get_entity_unit(self, entity_state: State) -> str | None:
        """Get the temperature unit of an entity from its state."""
        if entity_state.domain == SENSOR_DOMAIN:
@@ -46,6 +46,23 @@ class _TemperatureTriggerMixin(EntityNumericalStateTriggerWithUnitBase):
    _domain_specs = TEMPERATURE_DOMAIN_SPECS
    _unit_converter = TemperatureConverter

+    def _should_include(self, state: State) -> bool:
+        """Skip attribute-source entities that lack the temperature attribute.
+
+        For domains whose tracked value comes from an attribute
+        (climate / water_heater / weather), require the attribute to be
+        present; otherwise the all/count check would treat an entity that
+        cannot report a temperature as a non-match and block behavior=last.
+        Sensor entities source their value from `state.state`, so they
+        fall through to the base impl.
+        """
+        if not super()._should_include(state):
+            return False
+        domain_spec = self._domain_specs[state.domain]
+        if domain_spec.value_source is None:
+            return True
+        return state.attributes.get(domain_spec.value_source) is not None
+
    def _get_entity_unit(self, state: State) -> str | None:
        """Get the temperature unit of an entity from its state."""
        if state.domain == SENSOR_DOMAIN:
@@ -1,8 +1,8 @@
 """Data update coordinator for trigger based template entities."""

-from collections.abc import Callable, Mapping
+from collections.abc import Callable
 import logging
-from typing import TYPE_CHECKING, Any, cast
+from typing import TYPE_CHECKING, cast

 from homeassistant.components.blueprint import CONF_USE_BLUEPRINT
 from homeassistant.const import (
@@ -37,7 +37,7 @@ class TriggerUpdateCoordinator(DataUpdateCoordinator):
            hass, _LOGGER, config_entry=None, name="Trigger Update Coordinator"
        )
        self.config = config
-        self._cond_func: Callable[[Mapping[str, Any] | None], bool] | None = None
+        self._cond_func: condition.ConditionsChecker | None = None
        self._unsub_start: Callable[[], None] | None = None
        self._unsub_trigger: Callable[[], None] | None = None
        self._script: Script | None = None
@@ -69,7 +69,9 @@ class TriggerUpdateCoordinator(DataUpdateCoordinator):
            self._unsub_trigger()
            self._unsub_trigger = None
        if self._script is not None:
-            await self._script.async_stop()
+            await self._script.async_unload()
+        if self._cond_func is not None:
+            self._cond_func.async_unload()

    async def async_setup(self, hass_config: ConfigType) -> None:
        """Set up the trigger and create entities."""
@@ -158,7 +160,7 @@ class TriggerUpdateCoordinator(DataUpdateCoordinator):
    def _check_condition(self, run_variables: TemplateVarsType) -> bool:
        if not self._cond_func:
            return True
-        condition_result = self._cond_func(run_variables)
+        condition_result = self._cond_func.async_check(variables=run_variables)
        if condition_result is False:
            _LOGGER.debug(
                "Conditions not met, aborting template trigger update. Condition summary: %s",
@@ -169,9 +169,15 @@ class AbstractTemplateEntity(Entity):
        )

    async def async_will_remove_from_hass(self) -> None:
-        """Stop scripts when removing from Home Assistant."""
-        for action_script in self._action_scripts.values():
-            await action_script.async_stop()
+        """Clean up scripts when removing from Home Assistant."""
+        if not self.registry_entry or self.registry_entry.entity_id == self.entity_id:
+            # Entity ID not changed, unload scripts as they will not be reused.
+            for action_script in self._action_scripts.values():
+                await action_script.async_unload()
+        else:
+            # Entity ID changed, just stop scripts
+            for action_script in self._action_scripts.values():
+                await action_script.async_stop()

    async def async_run_script(
        self,
@@ -25,19 +25,12 @@ from homeassistant.components.weather import (
    ATTR_CONDITION_WINDY_VARIANT,
    DOMAIN as WEATHER_DOMAIN,
    ENTITY_ID_FORMAT,
-    PLATFORM_SCHEMA as WEATHER_PLATFORM_SCHEMA,
    Forecast,
    WeatherEntity,
    WeatherEntityFeature,
 )
 from homeassistant.config_entries import ConfigEntry
-from homeassistant.const import (
-    CONF_NAME,
-    CONF_TEMPERATURE_UNIT,
-    CONF_UNIQUE_ID,
-    STATE_UNAVAILABLE,
-    STATE_UNKNOWN,
-)
+from homeassistant.const import CONF_TEMPERATURE_UNIT, STATE_UNAVAILABLE, STATE_UNKNOWN
 from homeassistant.core import HomeAssistant, callback
 from homeassistant.helpers import config_validation as cv
 from homeassistant.helpers.entity_platform import (
@@ -230,18 +223,6 @@ WEATHER_MODERN_YAML_SCHEMA = WEATHER_COMMON_MODERN_SCHEMA.extend(
    make_template_entity_common_modern_schema(WEATHER_DOMAIN, DEFAULT_NAME).schema
 )

-PLATFORM_SCHEMA = (
-    vol.Schema(
-        {
-            vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.template,
-            vol.Optional(CONF_UNIQUE_ID): cv.string,
-        }
-    )
-    .extend(WEATHER_COMMON_LEGACY_SCHEMA.schema)
-    .extend(WEATHER_PLATFORM_SCHEMA.schema)
-)
-
-
 WEATHER_CONFIG_ENTRY_SCHEMA = WEATHER_COMMON_MODERN_SCHEMA.extend(
    TEMPLATE_ENTITY_COMMON_CONFIG_ENTRY_SCHEMA.schema
 )
@@ -257,21 +238,23 @@ async def async_setup_platform(

    # Rewrite the configuration options to modern keys.
    if discovery_info is None:
-        # Legacy
-        config = rewrite_legacy_to_modern_config(hass, config, LEGACY_FIELDS)
-    else:
-        # Modern and Trigger
-        entity_configs: list[ConfigType] = discovery_info["entities"]
-        modified_entity_configs = []
-        for entity_config in entity_configs:
-            entity_config = rewrite_legacy_to_modern_config(
-                hass, entity_config, LEGACY_FIELDS
-            )
+        _LOGGER.warning(
+            "Template weather entities can only be configured under template:"
+        )
+        return

-            modified_entity_configs.append(entity_config)
+    # Modern and Trigger
+    entity_configs: list[ConfigType] = discovery_info["entities"]
+    modified_entity_configs = []
+    for entity_config in entity_configs:
+        entity_config = rewrite_legacy_to_modern_config(
+            hass, entity_config, LEGACY_FIELDS
+        )

-        if modified_entity_configs:
-            discovery_info["entities"] = modified_entity_configs
+        modified_entity_configs.append(entity_config)
+
+    if modified_entity_configs:
+        discovery_info["entities"] = modified_entity_configs

    await async_setup_template_platform(
        hass,
@@ -8,5 +8,5 @@
  "integration_type": "hub",
  "iot_class": "cloud_polling",
  "loggers": ["tibber"],
-  "requirements": ["pyTibber==0.37.3"]
+  "requirements": ["pyTibber==0.37.5"]
 }
@@ -45,6 +45,9 @@
    },
    "started": {
      "trigger": "mdi:timer-play"
+    },
+    "time_remaining": {
+      "trigger": "mdi:timer-alert-outline"
    }
  }
 }
@@ -183,6 +183,15 @@
        }
      },
      "name": "Timer started"
+    },
+    "time_remaining": {
+      "description": "Triggers when one or more timers reach a specific remaining time.",
+      "fields": {
+        "remaining": {
+          "name": "Time remaining"
+        }
+      },
+      "name": "Timer time remaining"
    }
  }
 }
@@ -1,10 +1,160 @@
 """Provides triggers for timers."""

-from homeassistant.core import HomeAssistant
-from homeassistant.helpers.automation import DomainSpec
-from homeassistant.helpers.trigger import Trigger, make_entity_target_state_trigger
+from datetime import datetime, timedelta
+from typing import cast, override
+
+import voluptuous as vol
+
+from homeassistant.const import ATTR_ENTITY_ID, CONF_OPTIONS
+from homeassistant.core import CALLBACK_TYPE, Context, HomeAssistant, State, callback
+from homeassistant.helpers import config_validation as cv
+from homeassistant.helpers.automation import DomainSpec, filter_by_domain_specs
+from homeassistant.helpers.event import async_track_point_in_utc_time
+from homeassistant.helpers.target import (
+    TargetStateChangedData,
+    async_track_target_selector_state_change_event,
+)
+from homeassistant.helpers.trigger import (
+    ENTITY_STATE_TRIGGER_SCHEMA,
+    Trigger,
+    TriggerActionRunner,
+    TriggerConfig,
+    make_entity_target_state_trigger,
+)
+from homeassistant.helpers.typing import ConfigType
+from homeassistant.util import dt as dt_util
+
+from . import ATTR_FINISHES_AT, ATTR_LAST_TRANSITION, DOMAIN, STATUS_ACTIVE
+
+CONF_REMAINING = "remaining"
+
+TIME_REMAINING_TRIGGER_SCHEMA = ENTITY_STATE_TRIGGER_SCHEMA.extend(
+    {
+        vol.Required(CONF_OPTIONS): {
+            vol.Required(CONF_REMAINING): cv.positive_time_period_dict,
+        },
+    }
+)
+
+
+class TimeRemainingTrigger(Trigger):
+    """Trigger when a timer has a specific amount of time remaining."""
+
+    _domain_specs: dict[str, DomainSpec] = {DOMAIN: DomainSpec()}
+    _schema = TIME_REMAINING_TRIGGER_SCHEMA
+
+    @override
+    @classmethod
+    async def async_validate_config(
+        cls, hass: HomeAssistant, config: ConfigType
+    ) -> ConfigType:
+        """Validate config."""
+        return cast(ConfigType, cls._schema(config))
+
+    def __init__(self, hass: HomeAssistant, config: TriggerConfig) -> None:
+        """Initialize the time remaining trigger."""
+        super().__init__(hass, config)
+        assert config.target is not None
+        self._target = config.target
+        options = config.options or {}
+        self._remaining: timedelta = options[CONF_REMAINING]
+
+    def entity_filter(self, entities: set[str]) -> set[str]:
+        """Filter entities to timer domain."""
+        return filter_by_domain_specs(self._hass, self._domain_specs, entities)
+
+    @override
+    async def async_attach_runner(
+        self, run_action: TriggerActionRunner
+    ) -> CALLBACK_TYPE:
+        """Attach the trigger to an action runner."""
+        scheduled: dict[str, CALLBACK_TYPE] = {}
+
+        @callback
+        def schedule_for_state(
+            entity_id: str,
+            to_state: State | None,
+            context: Context | None,
+        ) -> None:
+            """Schedule a fire for an active timer state, if applicable."""
+            if to_state is None:
+                return
+            if to_state.state != STATUS_ACTIVE:
+                return
+
+            finishes_at_str = to_state.attributes.get(ATTR_FINISHES_AT)
+            if finishes_at_str is None:
+                return
+
+            finishes_at = dt_util.parse_datetime(finishes_at_str)
+            if finishes_at is None:
+                return
+
+            fire_at = finishes_at - self._remaining
+            if fire_at <= dt_util.utcnow():
+                return
+
+            @callback
+            def fire_trigger(now: datetime) -> None:
+                """Fire the trigger."""
+                scheduled.pop(entity_id, None)
+                run_action(
+                    {
+                        ATTR_ENTITY_ID: entity_id,
+                        "to_state": to_state,
+                        "remaining": self._remaining,
+                    },
+                    f"time remaining of {entity_id}",
+                    context,
+                )
+
+            scheduled[entity_id] = async_track_point_in_utc_time(
+                self._hass, fire_trigger, fire_at
+            )
+
+        @callback
+        def state_change_listener(
+            target_state_change_data: TargetStateChangedData,
+        ) -> None:
+            """Listen for state changes and schedule trigger."""
+            event = target_state_change_data.state_change_event
+            entity_id: str = event.data["entity_id"]
+            to_state = event.data["new_state"]
+
+            # Cancel any previously scheduled callback for this entity
+            if entity_id in scheduled:
+                scheduled.pop(entity_id)()
+
+            schedule_for_state(entity_id, to_state, event.context)
+
+        @callback
+        def on_entities_update(added: set[str], removed: set[str]) -> None:
+            """Handle changes to the tracked entity set."""
+            for entity_id in removed:
+                if entity_id in scheduled:
+                    scheduled.pop(entity_id)()
+            for entity_id in added:
+                state = self._hass.states.get(entity_id)
+                schedule_for_state(entity_id, state, state.context if state else None)
+
+        unsub = async_track_target_selector_state_change_event(
+            self._hass,
+            self._target,
+            state_change_listener,
+            self.entity_filter,
+            on_entities_update,
+        )
+
+        @callback
+        def async_remove() -> None:
+            """Remove state listeners."""
+            unsub()
+            for cancel in scheduled.values():
+                cancel()
+            scheduled.clear()
+
+        return async_remove

-from . import ATTR_LAST_TRANSITION, DOMAIN

 TRIGGERS: dict[str, type[Trigger]] = {
    "cancelled": make_entity_target_state_trigger(
@@ -22,6 +172,7 @@ TRIGGERS: dict[str, type[Trigger]] = {
    "started": make_entity_target_state_trigger(
        {DOMAIN: DomainSpec(value_source=ATTR_LAST_TRANSITION)}, "started"
    ),
+    "time_remaining": TimeRemainingTrigger,
 }


@@ -20,3 +20,13 @@ finished: *trigger_common
 paused: *trigger_common
 restarted: *trigger_common
 started: *trigger_common
+
+time_remaining:
+  target:
+    entity:
+      domain: timer
+  fields:
+    remaining:
+      required: true
+      selector:
+        duration:
@@ -10,7 +10,7 @@ from typing import TYPE_CHECKING, cast, override

 import voluptuous as vol

-from homeassistant.const import ATTR_ENTITY_ID, CONF_TARGET
+from homeassistant.const import ATTR_ENTITY_ID, CONF_OPTIONS, CONF_TARGET
 from homeassistant.core import CALLBACK_TYPE, HomeAssistant, callback, split_entity_id
 from homeassistant.exceptions import HomeAssistantError
 from homeassistant.helpers import config_validation as cv
@@ -25,6 +25,7 @@ from .const import DATA_COMPONENT, DOMAIN, TodoItemStatus
 ITEM_TRIGGER_SCHEMA = vol.Schema(
    {
        vol.Required(CONF_TARGET): cv.TARGET_FIELDS,
+        vol.Required(CONF_OPTIONS, default={}): {},
    }
 )

@@ -28,6 +28,7 @@ from .const import (
    TUYA_DISCOVERY_NEW,
    TUYA_HA_SIGNAL_UPDATE_ENTITY,
 )
+from .util import get_device_info

 type TuyaConfigEntry = ConfigEntry[DeviceListener]

@@ -145,14 +146,7 @@ class DeviceListener(SharingDeviceListener):

        device_registry.async_get_or_create(
            config_entry_id=self._entry.entry_id,
-            identifiers={(DOMAIN, device.id)},
-            manufacturer="Tuya",
-            name=device.name,
-            # Note: the model is overridden via entity.device_info property
-            # when the entity is created. If no entities are generated, it will
-            # stay as unsupported
-            model=f"{device.product_name} (unsupported)",
-            model_id=device.product_id,
+            **get_device_info(device, initial=True),
        )

    def remove_device(self, device_id: str) -> None:
@@ -5,11 +5,11 @@ from typing import Any
 from tuya_device_handlers.device_wrapper import DeviceWrapper
 from tuya_sharing import CustomerDevice, Manager

-from homeassistant.helpers.device_registry import DeviceInfo
 from homeassistant.helpers.dispatcher import async_dispatcher_connect
 from homeassistant.helpers.entity import Entity, EntityDescription

-from .const import DOMAIN, LOGGER, TUYA_HA_SIGNAL_UPDATE_ENTITY
+from .const import LOGGER, TUYA_HA_SIGNAL_UPDATE_ENTITY
+from .util import get_device_info


 class TuyaEntity(Entity):
@@ -25,6 +25,7 @@ class TuyaEntity(Entity):
        description: EntityDescription,
    ) -> None:
        """Init TuyaEntity."""
+        self._attr_device_info = get_device_info(device)
        self._attr_unique_id = f"tuya.{device.id}{description.key}"
        self.entity_description = description
        # TuyaEntity initialize mq can subscribe
@@ -32,17 +33,6 @@ class TuyaEntity(Entity):
        self.device = device
        self.device_manager = device_manager

-    @property
-    def device_info(self) -> DeviceInfo:
-        """Return a device description for device registry."""
-        return DeviceInfo(
-            identifiers={(DOMAIN, self.device.id)},
-            manufacturer="Tuya",
-            name=self.device.name,
-            model=self.device.product_name,
-            model_id=self.device.product_id,
-        )
-
    @property
    def available(self) -> bool:
        """Return if the device is available."""
@@ -44,7 +44,7 @@
  "iot_class": "cloud_push",
  "loggers": ["tuya_sharing"],
  "requirements": [
-    "tuya-device-handlers==0.0.18",
+    "tuya-device-handlers==0.0.19",
    "tuya-device-sharing-sdk==0.2.8"
  ]
 }
@@ -3,31 +3,11 @@
 from tuya_sharing import CustomerDevice

 from homeassistant.exceptions import ServiceValidationError
+from homeassistant.helpers.device_registry import DeviceInfo

 from .const import DOMAIN, DPCode


-def get_dpcode(
-    device: CustomerDevice, dpcodes: str | tuple[str, ...] | None
-) -> str | None:
-    """Get the first matching DPCode from the device or return None."""
-    if dpcodes is None:
-        return None
-
-    if not isinstance(dpcodes, tuple):
-        dpcodes = (dpcodes,)
-
-    for dpcode in dpcodes:
-        if (
-            dpcode in device.function
-            or dpcode in device.status
-            or dpcode in device.status_range
-        ):
-            return dpcode
-
-    return None
-
-
 class ActionDPCodeNotFoundError(ServiceValidationError):
    """Custom exception for action DP code not found errors."""

@@ -52,3 +32,22 @@ class ActionDPCodeNotFoundError(ServiceValidationError):
                "available": str(sorted(device.function.keys())),
            },
        )
+
+
+def get_device_info(device: CustomerDevice, *, initial: bool = False) -> DeviceInfo:
+    """Get device info."""
+    model = device.product_name
+
+    if initial:
+        # Note: the model is overridden via entity.device_info property
+        # when the entity is created. If no entities are generated, it will
+        # stay as unsupported
+        model = f"{device.product_name} (unsupported)"
+
+    return DeviceInfo(
+        identifiers={(DOMAIN, device.id)},
+        manufacturer="Tuya",
+        name=device.name,
+        model=model,
+        model_id=device.product_id,
+    )
@@ -7,5 +7,5 @@
  "integration_type": "system",
  "iot_class": "local_push",
  "quality_scale": "internal",
-  "requirements": ["aiousbwatcher==1.1.2", "serialx==1.4.1"]
+  "requirements": ["aiousbwatcher==1.1.2", "serialx==1.7.1"]
 }
@@ -10,6 +10,7 @@ from .coordinator import V2CConfigEntry, V2CUpdateCoordinator

 PLATFORMS: list[Platform] = [
    Platform.BINARY_SENSOR,
+    Platform.LIGHT,
    Platform.NUMBER,
    Platform.SENSOR,
    Platform.SWITCH,
@@ -1,5 +1,13 @@
 {
  "entity": {
+    "light": {
+      "light_led": {
+        "default": "mdi:led-on"
+      },
+      "logo_led": {
+        "default": "mdi:led-on"
+      }
+    },
    "sensor": {
      "battery_power": {
        "default": "mdi:home-battery"
@@ -0,0 +1,126 @@
+"""Light platform for V2C EVSE LEDs."""
+
+from collections.abc import Callable, Coroutine
+from dataclasses import dataclass
+from typing import Any
+
+from pytrydan import Trydan, TrydanData
+
+from homeassistant.components.light import (
+    ATTR_BRIGHTNESS,
+    ColorMode,
+    LightEntity,
+    LightEntityDescription,
+)
+from homeassistant.core import HomeAssistant
+from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
+from homeassistant.util.color import brightness_to_value, value_to_brightness
+
+from .coordinator import V2CConfigEntry, V2CUpdateCoordinator
+from .entity import V2CBaseEntity
+
+LED_ON_VALUE = 100
+LED_OFF_VALUE = 0
+BRIGHTNESS_SCALE = (LED_OFF_VALUE, LED_ON_VALUE)
+
+
+@dataclass(frozen=True, kw_only=True)
+class V2CLightEntityDescription(LightEntityDescription):
+    """Describes V2C EVSE light entity."""
+
+    supports_brightness: bool = False
+    value_fn: Callable[[TrydanData], int | None]
+    update_fn: Callable[[Trydan, int], Coroutine[Any, Any, None]]
+
+
+TRYDAN_LIGHTS = (
+    V2CLightEntityDescription(
+        key="light_led",
+        translation_key="light_led",
+        entity_registry_enabled_default=False,
+        value_fn=lambda evse_data: evse_data.light_led,
+        update_fn=lambda evse, value: evse.light_led(value),
+    ),
+    V2CLightEntityDescription(
+        key="logo_led",
+        translation_key="logo_led",
+        supports_brightness=True,
+        value_fn=lambda evse_data: evse_data.logo_led,
+        update_fn=lambda evse, value: evse.logo_led(value),
+    ),
+)
+
+
+async def async_setup_entry(
+    hass: HomeAssistant,
+    config_entry: V2CConfigEntry,
+    async_add_entities: AddConfigEntryEntitiesCallback,
+) -> None:
+    """Set up V2C Trydan light platform."""
+    coordinator = config_entry.runtime_data
+    data = coordinator.data
+    assert data is not None
+
+    async_add_entities(
+        V2CLightEntity(
+            coordinator,
+            description,
+            config_entry.entry_id,
+        )
+        for description in TRYDAN_LIGHTS
+        if description.value_fn(data) is not None
+    )
+
+
+class V2CLightEntity(V2CBaseEntity, LightEntity):
+    """Representation of V2C EVSE LED light entity."""
+
+    entity_description: V2CLightEntityDescription
+
+    def __init__(
+        self,
+        coordinator: V2CUpdateCoordinator,
+        description: V2CLightEntityDescription,
+        entry_id: str,
+    ) -> None:
+        """Initialize the V2C light entity."""
+        super().__init__(coordinator, description)
+        self._attr_unique_id = f"{entry_id}_{description.key}"
+        self._attr_color_mode = (
+            ColorMode.BRIGHTNESS if description.supports_brightness else ColorMode.ONOFF
+        )
+        self._attr_supported_color_modes = {self._attr_color_mode}
+
+    @property
+    def brightness(self) -> int | None:
+        """Return the light brightness."""
+        if not self.entity_description.supports_brightness:
+            return None
+        value = self.entity_description.value_fn(self.data)
+        if value is None:
+            return None
+        return value_to_brightness(BRIGHTNESS_SCALE, value)
+
+    @property
+    def is_on(self) -> bool | None:
+        """Return true if the light is on."""
+        value = self.entity_description.value_fn(self.data)
+        if value is None:
+            return None
+        return value > 0
+
+    async def async_turn_on(self, **kwargs: Any) -> None:
+        """Turn on the LED."""
+        value = LED_ON_VALUE
+        if self.entity_description.supports_brightness:
+            brightness = kwargs.get(ATTR_BRIGHTNESS, 255)
+            value = round(brightness_to_value(BRIGHTNESS_SCALE, brightness))
+            if brightness:
+                value = max(value, 1)
+        await self.entity_description.update_fn(self.coordinator.evse, value)
+        await self.coordinator.async_request_refresh()
+
+    async def async_turn_off(self, **kwargs: Any) -> None:
+        """Turn off the LED."""
+        await self.entity_description.update_fn(self.coordinator.evse, LED_OFF_VALUE)
+        await self.coordinator.async_request_refresh()
@@ -30,6 +30,14 @@
        "name": "Ready"
      }
    },
+    "light": {
+      "light_led": {
+        "name": "Light LED"
+      },
+      "logo_led": {
+        "name": "Logo LED"
+      }
+    },
    "number": {
      "intensity": {
        "name": "Intensity"
@@ -12,5 +12,5 @@
  "integration_type": "hub",
  "iot_class": "cloud_polling",
  "loggers": ["PyViCare"],
-  "requirements": ["PyViCare==2.60.1"]
+  "requirements": ["PyViCare==2.60.2"]
 }
@@ -15,5 +15,5 @@
  "integration_type": "device",
  "iot_class": "local_push",
  "quality_scale": "bronze",
-  "requirements": ["victron-ble-ha-parser==0.6.3"]
+  "requirements": ["victron-ble-ha-parser==0.7.0"]
 }
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Daniel Hjelseth Høyer	c2ce313ec8	Bump pyTibber to 0.37.5 (#169981 ) Signed-off-by: Daniel Hjelseth Høyer <github@dahoiv.net>	2026-05-07 09:41:08 +02:00
Zoltán Farkasdi	b8ba1c123d	netatmo: add doortag direct category fetch (#169711 ) Co-authored-by: Copilot Autofix powered by AI <175728472+Copilot@users.noreply.github.com> Co-authored-by: Erik Montnemery <erik@montnemery.com>	2026-05-07 09:18:39 +02:00
Daniel Hjelseth Høyer	10f1cbb51e	Migrate mill to use entry.runtime_data (#169948 ) Signed-off-by: Daniel Hjelseth Høyer <github@dahoiv.net>	2026-05-07 09:15:21 +02:00
Christian Lackas	e3bcce06bf	Bump PyViCare to 2.60.2 (#169918 ) Co-authored-by: home-assistant[bot] <78085893+home-assistant[bot]@users.noreply.github.com>	2026-05-07 08:30:41 +02:00
Kamil Breguła	4e0472feb5	Add fixture for Tuya camera (knkaf1d0dytgyhix) (#169967 ) Co-authored-by: mik-laj <12058428+mik-laj@users.noreply.github.com>	2026-05-07 07:33:28 +02:00
Jan Bouwhuis	046298f2ca	No need for a local import of the paho mqtt client (#169925 )	2026-05-06 22:45:36 +02:00
Jan Bouwhuis	c92128b282	Remove advanced setting dependency for IMAP integration (#169827 )	2026-05-06 22:37:27 +02:00
Christian Lackas	886e66e7e3	Bump homematicip to 2.10.0 (#169950 )	2026-05-06 22:20:16 +02:00
Erik Montnemery	7da49570b5	Add support for options to todo triggers (#169947 )	2026-05-06 22:16:55 +02:00
G Johansson	b8baa3271b	Bump holidays to 0.96 (#169939 )	2026-05-06 22:08:38 +02:00
Erik Montnemery	65bc4bf1d0	Add missing trigger and condition tests (#169945 )	2026-05-06 21:53:40 +02:00
Erik Montnemery	27a8d185c9	Add StatelessEntityTriggerBase base class (#169937 )	2026-05-06 21:43:29 +02:00
Andriy Kushnir	1e5992f2b5	Remove myself as codeowner for roomba (#169922 )	2026-05-06 20:33:15 +02:00
puddly	ac84a14846	Bump serialx to 1.7.1 (#169928 )	2026-05-06 21:04:13 +03:00
Robert Resch	fa265b18ce	Shorten docker publish job name (#169926 )	2026-05-06 18:12:13 +02:00
Stefan Agner	38634ddd55	Fix hassio auth IndexError on Supervisor Unix socket requests (#169911 )	2026-05-06 17:48:35 +02:00
Joakim Plate	13dd831874	Update gardena ble to 2.8.1 (#169914 )	2026-05-06 16:25:37 +02:00
Tom Wilkie	3be5906398	Register Hive Hub MAC address as device connection (#169040 ) Signed-off-by: Tom Wilkie <tom.wilkie@gmail.com>	2026-05-06 16:12:59 +02:00
Erik Montnemery	cef918d6f8	Remove _get_tracked_value method from EntityConditionBase (#169906 )	2026-05-06 14:59:57 +02:00
Jan Bouwhuis	19aa1b6578	Remove advanced options dependency from MQTT integration (#169833 )	2026-05-06 14:52:07 +02:00
Daniel Hjelseth Høyer	b0eb69936e	Bump pyTibber to 0.37.4 (#169907 )	2026-05-06 14:47:10 +02:00
Erik Montnemery	b6096a71d1	Exclude incompatible humidifier entities from humidifier automations (#169905 )	2026-05-06 14:44:30 +02:00
Erik Montnemery	059d7011ba	Exclude incompatible water_heater entities from water_heater automations (#169904 )	2026-05-06 14:44:19 +02:00
epenet	bbe00ef79e	De-duplicate code to build Tuya device info (#169899 )	2026-05-06 14:29:47 +02:00
Erik Montnemery	7f447abc3a	Exclude incompatible climate entities from climate automations (#169903 )	2026-05-06 14:18:14 +02:00
Erik Montnemery	923e099467	Unload scripts and conditions created by template entities (#169366 )	2026-05-06 14:11:37 +02:00
Erik Montnemery	26714c6d9f	Add media_player volume condition (#169897 )	2026-05-06 13:15:01 +02:00
Erik Montnemery	5f1201dbbe	Exclude incompatible entities from temperature automations (#169901 )	2026-05-06 13:10:53 +02:00
Erik Montnemery	52e1d9443c	Exclude incompatible entities from humidity automations (#169898 )	2026-05-06 13:10:24 +02:00
Manu	824f5205e9	Record notification from legacy notify action in Mobile App (#169749 )	2026-05-06 12:57:57 +02:00
Erik Montnemery	cf8bc55add	Add media_player muted conditions (#169892 )	2026-05-06 12:38:05 +02:00
Bram Kragten	1e9244f4fc	Update frontend to 20260429.3 (#169893 )	2026-05-06 12:19:24 +02:00
Tom Matheussen	be4f4928d5	Bump satel_integra to 1.3.1 (#169889 )	2026-05-06 11:27:14 +02:00
Erik Montnemery	80f6f8ee31	Improve entity trigger tests (#169881 )	2026-05-06 10:48:36 +02:00
Erik Montnemery	267d52491a	Add media_player volume triggers (#169885 )	2026-05-06 10:48:10 +02:00
Ludovic BOUÉ	ee84d625cd	Expose SET_SPEED for all fans via PercentSetting in Matter (#169696 ) Co-authored-by: Ludovic BOUÉ <132135057+lboue@users.noreply.github.com>	2026-05-06 10:16:31 +02:00
dependabot[bot]	5d091d25d5	Bump j178/prek-action from 2.0.2 to 2.0.3 (#169882 )	2026-05-06 09:50:18 +02:00
Erik Montnemery	97b5f1cf64	Add method _should_include to EntityConditionBase (#169884 ) Co-authored-by: Copilot Autofix powered by AI <175728472+Copilot@users.noreply.github.com>	2026-05-06 09:49:22 +02:00
Zoltán Farkasdi	d89bcd83d9	netatmo: bump pyatmo v9.4.0 (#169735 ) Co-authored-by: Erik Montnemery <erik@montnemery.com>	2026-05-06 09:16:22 +02:00
Joost Lekkerkerker	073b20c4b2	Fix Zinvolt select options (#169886 )	2026-05-06 09:09:24 +02:00
epenet	2af9405750	Cleanup unused code in Tuya util (#169883 )	2026-05-06 08:42:05 +02:00
Erik Montnemery	10084c8c0c	Add trigger timer.time_remaining (#169763 )	2026-05-05 23:54:49 -04:00
Erik Montnemery	7e8f5365ce	Add method _should_include to EntityTriggerBase (#169837 )	2026-05-06 00:50:22 +02:00
Erik Montnemery	65f9dcd7bf	Improve condition test helper docstrings (#169871 )	2026-05-06 00:32:37 +02:00
epenet	4c8f37fef6	Bump tuya-device-handlers to 0.0.19 (#169848 )	2026-05-05 22:23:14 +02:00
Erik Montnemery	d1295fa260	Validate yaml matches implementation in automation options_supported tests (#169798 )	2026-05-05 22:20:28 +02:00
Diogo Gomes	9b2eea920f	Add V2C LED lights (#169778 ) Co-authored-by: Copilot Autofix powered by AI <175728472+Copilot@users.noreply.github.com>	2026-05-05 22:19:59 +02:00
Petro31	c81c1cbb14	Remove legacy weather template entities (#169734 )	2026-05-05 22:18:46 +02:00
Erik Montnemery	11ee05874a	Improve trigger test helper docstrings (#169869 )	2026-05-05 22:11:08 +02:00
puddly	7d7c47b56e	Bump serialx to 1.7.0 (#169867 )	2026-05-05 21:06:30 +02:00
epenet	dc4210595f	Fix flaky test_set_scan_interval_via_platform (#169856 ) Co-authored-by: Claude Opus 4.7 (1M context) <noreply@anthropic.com>	2026-05-05 20:49:15 +02:00
Freekers	7430366d9b	Enable web search support for gpt-5-nano (#169710 )	2026-05-05 20:47:52 +03:00
Crocmagnon	ae3bd54ca7	switchbot: remove unwanted future annotations import preventing build on all new PRs (#169863 )	2026-05-05 19:40:27 +02:00
Glenn Waters	e3ce7fb000	Bump elkm1-lib to 2.2.15 (#169843 ) Co-authored-by: Copilot Autofix powered by AI <175728472+Copilot@users.noreply.github.com>	2026-05-05 18:50:17 +02:00
epenet	9286b517d3	Add ruff rule to prevent __future__ annotations (#169852 ) Co-authored-by: Robert Resch <robert@resch.dev> Co-authored-by: Copilot Autofix powered by AI <175728472+Copilot@users.noreply.github.com>	2026-05-05 18:42:10 +02:00
elgris	4d62e4765d	Add a number entity to set display time offset (in minutes) for Switchbot Meter CO2 devices. (#169603 ) Co-authored-by: Copilot Autofix powered by AI <175728472+Copilot@users.noreply.github.com>	2026-05-05 17:45:47 +02:00
Michael Hansen	ea55ef90a6	Bump intents to 2026.5.5 (#169855 )	2026-05-05 18:22:22 +03:00
epenet	751765b97b	Cleanup from __future__ import annotations (#169850 )	2026-05-05 16:35:21 +02:00
Denis Shulyaka	11ed1fe20f	Return the requested format for OpenAI TTS (#169839 ) Co-authored-by: Copilot Autofix powered by AI <175728472+Copilot@users.noreply.github.com>	2026-05-05 10:28:20 -04:00
Joost Lekkerkerker	9b5166769a	Add Sensereo matter brand (#169836 )	2026-05-05 10:18:01 -04:00
Joost Lekkerkerker	70c2a323ce	Add Zunzunbee Zigbee brand (#169838 )	2026-05-05 10:17:49 -04:00
Ronald van der Meer	0ec5d6b273	Add API version to Duco diagnostics for support triage (#169802 )	2026-05-05 15:48:43 +02:00
Robert Resch	b1e8dc2ebb	Remove show_advanced_options in Ecovacs and always show all options (#169831 )	2026-05-05 15:42:08 +02:00
Artur Pragacz	e144804d28	Fix async_unload teardown race in scripts (#169562 )	2026-05-05 15:03:37 +02:00
cengelen	8521a49986	Bump growatt server to 2.1.0 (#169495 ) Co-authored-by: Copilot <copilot@github.com>	2026-05-05 14:11:50 +02:00
Raj Laud	3587f9613f	Bump victron-ble-ha-parser to 0.7.0 (#169736 ) Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>	2026-05-05 13:57:19 +02:00
Jan Bouwhuis	2f1dd3a817	Deprecate MQTT protocol versions 3.x and migrate to version 5 (#169759 ) Co-authored-by: Copilot Autofix powered by AI <175728472+Copilot@users.noreply.github.com>	2026-05-05 13:43:18 +02:00