Remove not needed guards for integration migrations from future versions (#173301 )

Fix homeassistant hardware unique id migration (#173258 )
Add individual code owner for Fluss (#173276 )
2026-06-08 15:57:25 -04:00 · 2026-06-08 21:39:19 +02:00 · 2026-06-08 21:38:49 +02:00 · 2026-06-08 20:36:54 +02:00 · 2026-06-08 14:22:17 -04:00 · 2026-06-08 20:17:00 +02:00
292 changed files with 5413 additions and 1257 deletions
@@ -96,6 +96,7 @@ homeassistant.components.aprs.*
 homeassistant.components.apsystems.*
 homeassistant.components.aqualogic.*
 homeassistant.components.aquostv.*
+homeassistant.components.aqvify.*
 homeassistant.components.aranet.*
 homeassistant.components.arcam_fmj.*
 homeassistant.components.arris_tg2492lg.*
@@ -162,6 +162,8 @@ CLAUDE.md @home-assistant/core
 /tests/components/apsystems/ @mawoka-myblock @SonnenladenGmbH
 /homeassistant/components/aquacell/ @Jordi1990
 /tests/components/aquacell/ @Jordi1990
+/homeassistant/components/aqvify/ @astrandb
+/tests/components/aqvify/ @astrandb
 /homeassistant/components/aranet/ @aschmitz @thecode @anrijs
 /tests/components/aranet/ @aschmitz @thecode @anrijs
 /homeassistant/components/arcam_fmj/ @elupus
@@ -574,8 +576,8 @@ CLAUDE.md @home-assistant/core
 /tests/components/flo/ @dmulcahey
 /homeassistant/components/flume/ @ChrisMandich @bdraco @jeeftor
 /tests/components/flume/ @ChrisMandich @bdraco @jeeftor
-/homeassistant/components/fluss/ @fluss
-/tests/components/fluss/ @fluss
+/homeassistant/components/fluss/ @fluss @Marcello17
+/tests/components/fluss/ @fluss @Marcello17
 /homeassistant/components/flux_led/ @icemanch
 /tests/components/flux_led/ @icemanch
 /homeassistant/components/forecast_solar/ @klaasnicolaas @frenck
@@ -116,10 +116,6 @@ async def async_setup_entry(hass: HomeAssistant, entry: AirOSConfigEntry) -> boo
 async def async_migrate_entry(hass: HomeAssistant, entry: AirOSConfigEntry) -> bool:
    """Migrate old config entry."""

-    # This means the user has downgraded from a future version
-    if entry.version > 2:
-        return False
-
    # 1.1 Migrate config_entry to add advanced ssl settings
    if entry.version == 1 and entry.minor_version == 1:
        new_minor_version = 2
@@ -65,10 +65,6 @@ async def async_setup_entry(hass: HomeAssistant, entry: AmazonConfigEntry) -> bo
 async def async_migrate_entry(hass: HomeAssistant, entry: AmazonConfigEntry) -> bool:
    """Migrate old entry."""

-    if entry.version > 1:
-        # This means the user has downgraded from a future version
-        return False
-
    if entry.version == 1 and entry.minor_version < 3:
        if CONF_SITE in entry.data:
            # Site in data (wrong place), just move to login data
@@ -75,10 +75,6 @@ async def async_migrate_entry(hass: HomeAssistant, entry: AnovaConfigEntry) -> b
    """Migrate entry."""
    _LOGGER.debug("Migrating from version %s:%s", entry.version, entry.minor_version)

-    if entry.version > 1:
-        # This means the user has downgraded from a future version
-        return False
-
    if entry.version == 1 and entry.minor_version == 1:
        new_data = {**entry.data}
        if CONF_DEVICES in new_data:
@@ -178,10 +178,6 @@ async def async_migrate_entry(hass: HomeAssistant, entry: AnthropicConfigEntry)
    """Migrate entry."""
    LOGGER.debug("Migrating from version %s:%s", entry.version, entry.minor_version)

-    if entry.version > 2:
-        # This means the user has downgraded from a future version
-        return False
-
    if entry.version == 2 and entry.minor_version == 1:
        # Correct broken device migration in Home Assistant Core 2025.7.0b0-2025.7.0b1
        device_registry = dr.async_get(hass)
@@ -0,0 +1,28 @@
+"""The Aqvify integration."""
+
+import logging
+
+from homeassistant.const import Platform
+from homeassistant.core import HomeAssistant
+
+from .coordinator import AqvifyConfigEntry, AqvifyCoordinator
+
+_LOGGER = logging.getLogger(__name__)
+PLATFORMS: list[Platform] = [Platform.SENSOR]
+
+
+async def async_setup_entry(hass: HomeAssistant, entry: AqvifyConfigEntry) -> bool:
+    """Set up Aqvify from a config entry."""
+
+    coordinator = AqvifyCoordinator(hass, entry)
+    await coordinator.async_config_entry_first_refresh()
+    entry.runtime_data = coordinator
+
+    await hass.config_entries.async_forward_entry_setups(entry, PLATFORMS)
+
+    return True
+
+
+async def async_unload_entry(hass: HomeAssistant, entry: AqvifyConfigEntry) -> bool:
+    """Unload Aqvify config entry."""
+    return await hass.config_entries.async_unload_platforms(entry, PLATFORMS)
@@ -0,0 +1,61 @@
+"""Config flow for the Aqvify integration."""
+
+import logging
+from typing import Any
+
+from aiohttp import ClientResponseError
+from pyaqvify import AqvifyAPI, AqvifyAuthException
+import voluptuous as vol
+
+from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
+from homeassistant.const import CONF_API_KEY
+from homeassistant.helpers.aiohttp_client import async_get_clientsession
+
+from .const import DOMAIN
+
+_LOGGER = logging.getLogger(__name__)
+
+STEP_USER_DATA_SCHEMA = vol.Schema(
+    {
+        vol.Required(CONF_API_KEY): str,
+    }
+)
+
+
+class AqvifyConfigFlow(ConfigFlow, domain=DOMAIN):
+    """Handle a config flow for Aqvify."""
+
+    VERSION = 1
+
+    async def async_step_user(
+        self, user_input: dict[str, Any] | None = None
+    ) -> ConfigFlowResult:
+        """Handle the initial step."""
+        errors: dict[str, str] = {}
+        if user_input is not None:
+            hub = AqvifyAPI(
+                user_input[CONF_API_KEY],
+                websession=async_get_clientsession(self.hass),
+            )
+            try:
+                account_data = await hub.async_get_account_id()
+            except AqvifyAuthException:
+                errors["base"] = "invalid_auth"
+            except ClientResponseError:
+                errors["base"] = "cannot_connect"
+            except Exception:
+                _LOGGER.exception("Unexpected exception")
+                errors["base"] = "unknown"
+            else:
+                await self.async_set_unique_id(account_data.account_id)
+                self._abort_if_unique_id_configured()
+                return self.async_create_entry(title="Aqvify", data=user_input)
+
+        return self.async_show_form(
+            step_id="user",
+            data_schema=STEP_USER_DATA_SCHEMA,
+            errors=errors,
+            description_placeholders={
+                "aqvify_url": "https://app.aqvify.com/User",
+            },
+        )
@@ -0,0 +1,3 @@
+"""Constants for the Aqvify integration."""
+
+DOMAIN = "aqvify"
@@ -0,0 +1,92 @@
+"""Coordinator for Aqvify integration."""
+
+from dataclasses import dataclass
+from datetime import timedelta
+import logging
+
+from aiohttp import ClientResponseError
+from pyaqvify import AqvifyAPI, AqvifyAuthException, AqvifyDeviceData, AqvifyDevices
+
+from homeassistant.config_entries import ConfigEntry
+from homeassistant.const import CONF_API_KEY
+from homeassistant.core import HomeAssistant
+from homeassistant.exceptions import ConfigEntryAuthFailed, ConfigEntryNotReady
+from homeassistant.helpers.aiohttp_client import async_get_clientsession
+from homeassistant.helpers.update_coordinator import DataUpdateCoordinator, UpdateFailed
+
+from .const import DOMAIN
+
+_LOGGER = logging.getLogger(__name__)
+
+UPDATE_INTERVAL = timedelta(seconds=60)
+
+type AqvifyConfigEntry = ConfigEntry[AqvifyCoordinator]
+
+
+@dataclass
+class AqvifyCoordinatorData:
+    """Data class for storing coordinator data."""
+
+    devices: AqvifyDevices
+    device_data: dict[str, AqvifyDeviceData]
+
+
+class AqvifyCoordinator(DataUpdateCoordinator[AqvifyCoordinatorData]):
+    """Data update coordinator for Aqvify devices."""
+
+    config_entry: AqvifyConfigEntry
+
+    def __init__(self, hass: HomeAssistant, entry: AqvifyConfigEntry) -> None:
+        """Initialize the Aqvify data update coordinator."""
+        super().__init__(
+            hass,
+            logger=_LOGGER,
+            name=DOMAIN,
+            update_interval=UPDATE_INTERVAL,
+            config_entry=entry,
+        )
+
+        self.api_client = AqvifyAPI(
+            entry.data[CONF_API_KEY], websession=async_get_clientsession(hass)
+        )
+
+    async def _async_setup(self) -> None:
+        """Set up the coordinator."""
+        try:
+            await self.api_client.async_get_account_id()
+        except AqvifyAuthException as err:
+            raise ConfigEntryAuthFailed(f"Invalid Aqvify API key: {err}") from err
+        except (ClientResponseError, TimeoutError) as err:
+            raise ConfigEntryNotReady(
+                f"Failed to connect to Aqvify API: {err}"
+            ) from err
+
+    async def _async_update_data(self) -> AqvifyCoordinatorData:
+        """Fetch device state."""
+        try:
+            devices = await self.api_client.async_get_devices()
+        except ClientResponseError as err:
+            raise UpdateFailed(f"Error communicating with Aqvify API: {err}") from err
+        except TimeoutError as err:
+            raise UpdateFailed(f"Timeout communicating with Aqvify API: {err}") from err
+
+        device_data = {}
+        for device in devices.devices.values():
+            try:
+                device_key = str(device.device_key)
+                device_data[
+                    device_key
+                ] = await self.api_client.async_get_device_latest_data(device_key)
+            except ClientResponseError as err:
+                raise UpdateFailed(
+                    f"Error communicating with Aqvify API: {err}"
+                ) from err
+            except TimeoutError as err:
+                raise UpdateFailed(
+                    f"Timeout communicating with Aqvify API: {err}"
+                ) from err
+
+        return AqvifyCoordinatorData(
+            devices=devices,
+            device_data=device_data,
+        )
@@ -0,0 +1,35 @@
+"""Defines a base Aqvify entity."""
+
+from homeassistant.helpers.device_registry import DeviceInfo
+from homeassistant.helpers.entity import EntityDescription
+from homeassistant.helpers.update_coordinator import CoordinatorEntity
+
+from .const import DOMAIN
+from .coordinator import AqvifyCoordinator
+
+
+class AqvifyBaseEntity(CoordinatorEntity[AqvifyCoordinator]):
+    """Defines a base Aqvify entity."""
+
+    _attr_has_entity_name = True
+
+    def __init__(
+        self,
+        coordinator: AqvifyCoordinator,
+        description: EntityDescription,
+        device_key: str,
+    ) -> None:
+        """Initialize the Aqvify entity."""
+        super().__init__(coordinator)
+
+        account_id = self.coordinator.config_entry.unique_id
+        self.device_key = device_key
+        self._attr_device_info = DeviceInfo(
+            identifiers={(DOMAIN, f"{account_id}_{device_key}")},
+            name=coordinator.data.devices.devices[device_key].name,
+            manufacturer="Aqvify",
+            configuration_url="https://app.aqvify.com",
+            serial_number=device_key,
+        )
+        self._attr_unique_id = f"{account_id}_{device_key}_{description.key}"
+        self.entity_description = description
@@ -0,0 +1,12 @@
+{
+  "entity": {
+    "sensor": {
+      "meter_value": {
+        "default": "mdi:waves-arrow-up"
+      },
+      "water_level": {
+        "default": "mdi:waves"
+      }
+    }
+  }
+}
@@ -0,0 +1,12 @@
+{
+  "domain": "aqvify",
+  "name": "Aqvify",
+  "codeowners": ["@astrandb"],
+  "config_flow": true,
+  "documentation": "https://www.home-assistant.io/integrations/aqvify",
+  "integration_type": "hub",
+  "iot_class": "cloud_polling",
+  "loggers": ["pyaqvify"],
+  "quality_scale": "bronze",
+  "requirements": ["pyaqvify==0.0.8"]
+}
@@ -0,0 +1,69 @@
+rules:
+  # Bronze
+  action-setup:
+    status: exempt
+    comment: |
+      No actions in this integration.
+  appropriate-polling: done
+  brands: done
+  common-modules: done
+  config-flow-test-coverage: done
+  config-flow: done
+  dependency-transparency: done
+  docs-actions:
+    status: exempt
+    comment: |
+      The integration does not provide any actions.
+  docs-high-level-description: done
+  docs-installation-instructions: done
+  docs-removal-instructions: done
+  entity-event-setup:
+    status: exempt
+    comment: |
+      Entities of this integration do not explicitly subscribe to events.
+  entity-unique-id: done
+  has-entity-name: done
+  runtime-data: done
+  test-before-configure: done
+  test-before-setup: done
+  unique-config-entry: done
+
+  # Silver
+  action-exceptions: todo
+  config-entry-unloading: done
+  docs-configuration-parameters: todo
+  docs-installation-parameters: todo
+  entity-unavailable: todo
+  integration-owner: todo
+  log-when-unavailable: todo
+  parallel-updates: done
+  reauthentication-flow: todo
+  test-coverage: todo
+
+  # Gold
+  devices: todo
+  diagnostics: todo
+  discovery-update-info: todo
+  discovery: todo
+  docs-data-update: todo
+  docs-examples: todo
+  docs-known-limitations: todo
+  docs-supported-devices: todo
+  docs-supported-functions: todo
+  docs-troubleshooting: todo
+  docs-use-cases: todo
+  dynamic-devices: todo
+  entity-category: todo
+  entity-device-class: todo
+  entity-disabled-by-default: todo
+  entity-translations: todo
+  exception-translations: todo
+  icon-translations: done
+  reconfiguration-flow: todo
+  repair-issues: todo
+  stale-devices: todo
+
+  # Platinum
+  async-dependency: todo
+  inject-websession: todo
+  strict-typing: todo
@@ -0,0 +1,79 @@
+"""Sensor platform for Aqvify integration."""
+
+from collections.abc import Callable
+from dataclasses import dataclass
+from datetime import datetime
+
+from pyaqvify import AqvifyDeviceData
+
+from homeassistant.components.sensor import (
+    SensorDeviceClass,
+    SensorEntity,
+    SensorEntityDescription,
+    SensorStateClass,
+    StateType,
+)
+from homeassistant.const import UnitOfLength
+from homeassistant.core import HomeAssistant
+from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
+
+from .coordinator import AqvifyConfigEntry
+from .entity import AqvifyBaseEntity
+
+# Coordinator is used to centralize the data updates.
+PARALLEL_UPDATES = 0
+
+
+@dataclass(frozen=True, kw_only=True)
+class AqvifySensorEntityDescription(SensorEntityDescription):
+    """Description of an Aqvify sensor entity."""
+
+    value_fn: Callable[[AqvifyDeviceData], float | int | None]
+
+
+ENTITIES: tuple[AqvifySensorEntityDescription, ...] = (
+    AqvifySensorEntityDescription(
+        key="meter_value",
+        translation_key="meter_value",
+        native_unit_of_measurement=UnitOfLength.METERS,
+        state_class=SensorStateClass.MEASUREMENT,
+        device_class=SensorDeviceClass.DISTANCE,
+        suggested_display_precision=2,
+        value_fn=lambda value: value.meter_value,
+    ),
+    AqvifySensorEntityDescription(
+        key="water_level",
+        translation_key="water_level",
+        native_unit_of_measurement=UnitOfLength.METERS,
+        state_class=SensorStateClass.MEASUREMENT,
+        device_class=SensorDeviceClass.DISTANCE,
+        suggested_display_precision=2,
+        value_fn=lambda value: value.water_level,
+    ),
+)
+
+
+async def async_setup_entry(
+    hass: HomeAssistant,
+    entry: AqvifyConfigEntry,
+    async_add_entities: AddConfigEntryEntitiesCallback,
+) -> None:
+    """Set up Aqvify sensor entities from a config entry."""
+    async_add_entities(
+        AqvifySensor(entry.runtime_data, description, device_key)
+        for description in ENTITIES
+        for device_key in entry.runtime_data.data.devices.devices
+    )
+
+
+class AqvifySensor(AqvifyBaseEntity, SensorEntity):
+    """Representation of an Aqvify sensor entity."""
+
+    entity_description: AqvifySensorEntityDescription
+
+    @property
+    def native_value(self) -> StateType | datetime | None:
+        """Return the state of the sensor."""
+        return self.entity_description.value_fn(
+            self.coordinator.data.device_data[self.device_key]
+        )
@@ -0,0 +1,33 @@
+{
+  "config": {
+    "abort": {
+      "already_configured": "[%key:common::config_flow::abort::already_configured_device%]"
+    },
+    "error": {
+      "cannot_connect": "[%key:common::config_flow::error::cannot_connect%]",
+      "invalid_auth": "[%key:common::config_flow::error::invalid_auth%]",
+      "unknown": "[%key:common::config_flow::error::unknown%]"
+    },
+    "step": {
+      "user": {
+        "data": {
+          "api_key": "API key"
+        },
+        "data_description": {
+          "api_key": "Your Aqvify API key"
+        },
+        "description": "Navigate to your [Aqvify account]({aqvify_url}), copy your API key, and paste it below."
+      }
+    }
+  },
+  "entity": {
+    "sensor": {
+      "meter_value": {
+        "name": "Meter value"
+      },
+      "water_level": {
+        "name": "Water level"
+      }
+    }
+  }
+}
@@ -1816,6 +1816,11 @@ class PipelineInput:
                            await self.run.text_to_speech(tts_input)

        except PipelineError as err:
+            if self.run.tts_stream:
+                # Clean up TTS stream
+                self.run.tts_stream.delete()
+                self.run.tts_stream = None
+
            self.run.process_event(
                PipelineEvent(
                    PipelineEventType.ERROR,
@@ -1885,15 +1890,17 @@ class PipelineInput:
        ):
            prepare_tasks.append(self.run.prepare_recognize_intent(self.session))

+        if prepare_tasks:
+            await asyncio.gather(*prepare_tasks)
+
+        # Do TTS prepare separately so we don't create a ResultStream if the
+        # pipeline is invalid.
        if (
            start_stage_index
            <= PIPELINE_STAGE_ORDER.index(PipelineStage.TTS)
            <= end_stage_index
        ):
-            prepare_tasks.append(self.run.prepare_text_to_speech())
-
-        if prepare_tasks:
-            await asyncio.gather(*prepare_tasks)
+            await self.run.prepare_text_to_speech()


 class PipelinePreferred(CollectionError):
@@ -3,6 +3,7 @@
 from dataclasses import asdict
 import logging
 from pathlib import Path
+import re
 from typing import Any

 from hassil.parse_expression import parse_sentence
@@ -204,6 +205,8 @@ async def async_unload_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
 def has_no_punctuation(value: list[str]) -> list[str]:
    """Validate result does not contain punctuation."""
    for sentence in value:
+        # Exclude {list_references} which may contain punctuation characters.
+        sentence = _remove_list_references(sentence)
        if (
            PUNCTUATION_START.search(sentence)
            or PUNCTUATION_END.search(sentence)
@@ -215,6 +218,11 @@ def has_no_punctuation(value: list[str]) -> list[str]:
    return value


+def _remove_list_references(sentence: str) -> str:
+    """Remove {list_references} from a sentence for linting."""
+    return re.sub(r"(?<!\\)\{[^{}]*\}", "", sentence)
+
+
 def is_valid_sentence(value: list[str]) -> list[str]:
    """Validate result can be parsed by hassil."""
    for sentence in value:
@@ -222,7 +230,6 @@ def is_valid_sentence(value: list[str]) -> list[str]:
            parse_sentence(sentence)
        except ParseError as err:
            raise vol.Invalid(f"invalid sentence: {err}") from err
-
    return value


@@ -18,6 +18,9 @@
      }
    },
    "sensor": {
+      "open_status": {
+        "default": "mdi:window-open"
+      },
      "power_consumption": {
        "default": "mdi:lightning-bolt"
      }
@@ -50,21 +50,25 @@ SENSOR_TYPES: tuple[BleBoxSensorEntityDescription, ...] = (
        key="pm1",
        device_class=SensorDeviceClass.PM1,
        native_unit_of_measurement=CONCENTRATION_MICROGRAMS_PER_CUBIC_METER,
+        state_class=SensorStateClass.MEASUREMENT,
    ),
    BleBoxSensorEntityDescription(
        key="pm2_5",
        device_class=SensorDeviceClass.PM25,
        native_unit_of_measurement=CONCENTRATION_MICROGRAMS_PER_CUBIC_METER,
+        state_class=SensorStateClass.MEASUREMENT,
    ),
    BleBoxSensorEntityDescription(
        key="pm10",
        device_class=SensorDeviceClass.PM10,
        native_unit_of_measurement=CONCENTRATION_MICROGRAMS_PER_CUBIC_METER,
+        state_class=SensorStateClass.MEASUREMENT,
    ),
    BleBoxSensorEntityDescription(
        key="temperature",
        device_class=SensorDeviceClass.TEMPERATURE,
        native_unit_of_measurement=UnitOfTemperature.CELSIUS,
+        state_class=SensorStateClass.MEASUREMENT,
    ),
    BleBoxSensorEntityDescription(
        key="powerConsumption",
@@ -76,62 +80,72 @@ SENSOR_TYPES: tuple[BleBoxSensorEntityDescription, ...] = (
        key="humidity",
        device_class=SensorDeviceClass.HUMIDITY,
        native_unit_of_measurement=PERCENTAGE,
+        state_class=SensorStateClass.MEASUREMENT,
    ),
    BleBoxSensorEntityDescription(
        key="wind",
        device_class=SensorDeviceClass.WIND_SPEED,
        native_unit_of_measurement=UnitOfSpeed.METERS_PER_SECOND,
+        state_class=SensorStateClass.MEASUREMENT,
    ),
    BleBoxSensorEntityDescription(
        key="illuminance",
        device_class=SensorDeviceClass.ILLUMINANCE,
        native_unit_of_measurement=LIGHT_LUX,
+        state_class=SensorStateClass.MEASUREMENT,
    ),
    BleBoxSensorEntityDescription(
        key="forwardActiveEnergy",
        device_class=SensorDeviceClass.ENERGY,
        native_unit_of_measurement=UnitOfEnergy.KILO_WATT_HOUR,
+        state_class=SensorStateClass.TOTAL_INCREASING,
    ),
    BleBoxSensorEntityDescription(
        key="reverseActiveEnergy",
        device_class=SensorDeviceClass.ENERGY,
        native_unit_of_measurement=UnitOfEnergy.KILO_WATT_HOUR,
+        state_class=SensorStateClass.TOTAL_INCREASING,
    ),
    BleBoxSensorEntityDescription(
        key="reactivePower",
        device_class=SensorDeviceClass.POWER,
        native_unit_of_measurement=UnitOfReactivePower.VOLT_AMPERE_REACTIVE,
+        state_class=SensorStateClass.MEASUREMENT,
    ),
    BleBoxSensorEntityDescription(
        key="activePower",
        device_class=SensorDeviceClass.POWER,
        native_unit_of_measurement=UnitOfPower.WATT,
+        state_class=SensorStateClass.MEASUREMENT,
    ),
    BleBoxSensorEntityDescription(
        key="apparentPower",
        device_class=SensorDeviceClass.APPARENT_POWER,
        native_unit_of_measurement=UnitOfApparentPower.VOLT_AMPERE,
+        state_class=SensorStateClass.MEASUREMENT,
    ),
    BleBoxSensorEntityDescription(
        key="voltage",
        device_class=SensorDeviceClass.VOLTAGE,
        native_unit_of_measurement=UnitOfElectricPotential.VOLT,
+        state_class=SensorStateClass.MEASUREMENT,
    ),
    BleBoxSensorEntityDescription(
        key="current",
        device_class=SensorDeviceClass.CURRENT,
        native_unit_of_measurement=UnitOfElectricCurrent.MILLIAMPERE,
+        state_class=SensorStateClass.MEASUREMENT,
    ),
    BleBoxSensorEntityDescription(
        key="frequency",
        device_class=SensorDeviceClass.FREQUENCY,
        native_unit_of_measurement=UnitOfFrequency.HERTZ,
+        state_class=SensorStateClass.MEASUREMENT,
    ),
    BleBoxSensorEntityDescription(
        key="openStatus",
        translation_key="open_status",
        device_class=SensorDeviceClass.ENUM,
-        icon="mdi:window-open",
        options=list(OPEN_STATUS.values()),
        value_fn=lambda v: OPEN_STATUS.get(int(v)) if v is not None else None,
    ),
@@ -230,10 +230,6 @@ async def async_migrate_entry(hass: HomeAssistant, entry: BSBLanConfigEntry) ->
        entry.minor_version,
    )

-    if entry.version > 1:
-        # Downgraded from a future version; cannot migrate.
-        return False
-
    # 1.1 -> 1.2: Add CONF_HEATING_CIRCUITS. Attempt to discover available
    # heating circuits from the device; fall back to [1] (pre-multi-circuit
    # default) if the device is unreachable or the endpoint is unsupported.
@@ -6,5 +6,5 @@
  "documentation": "https://www.home-assistant.io/integrations/chacon_dio",
  "iot_class": "cloud_push",
  "loggers": ["dio_chacon_api"],
-  "requirements": ["dio-chacon-wifi-api==1.2.2"]
+  "requirements": ["dio-chacon-wifi-api==1.3.0"]
 }
@@ -87,10 +87,6 @@ async def async_migrate_entry(
 ) -> bool:
    """Migrate old entry."""

-    if config_entry.version > 1:
-        # This means the user has downgraded from a future version
-        return False
-
    if config_entry.version == 1 and config_entry.minor_version == 1:
        device_registry = dr.async_get(hass)

@@ -1,6 +1,7 @@
 """Offer sentence based automation rules."""

 from collections.abc import Awaitable, Callable
+import re
 from typing import Any

 from hassil.parse_expression import parse_sentence
@@ -33,6 +34,8 @@ TRIGGER_CALLBACK_TYPE = Callable[
 def has_no_punctuation(value: list[str]) -> list[str]:
    """Validate result does not contain punctuation."""
    for sentence in value:
+        # Exclude {list_references} which may contain punctuation characters.
+        sentence = _remove_list_references(sentence)
        if (
            PUNCTUATION_START.search(sentence)
            or PUNCTUATION_END.search(sentence)
@@ -44,6 +47,11 @@ def has_no_punctuation(value: list[str]) -> list[str]:
    return value


+def _remove_list_references(sentence: str) -> str:
+    """Remove {list_references} from a sentence for linting."""
+    return re.sub(r"(?<!\\)\{[^{}]*\}", "", sentence)
+
+
 def is_valid_sentence(value: list[str]) -> list[str]:
    """Validate result can be parsed by hassil."""
    for sentence in value:
@@ -51,7 +59,6 @@ def is_valid_sentence(value: list[str]) -> list[str]:
            parse_sentence(sentence)
        except ParseError as err:
            raise vol.Invalid(f"invalid sentence: {err}") from err
-
    return value


@@ -5,7 +5,7 @@ import logging
 from typing import Any

 from aiohttp import ClientError, ClientResponseError
-from data_grand_lyon_ha import DataGrandLyonClient
+from data_grand_lyon_ha import DataGrandLyonClient, TclStop, find_tcl_stop_by_id
 import voluptuous as vol

 from homeassistant.config_entries import (
@@ -18,6 +18,12 @@ from homeassistant.config_entries import (
 from homeassistant.const import CONF_PASSWORD, CONF_USERNAME
 from homeassistant.core import callback
 from homeassistant.helpers.aiohttp_client import async_get_clientsession
+from homeassistant.helpers.selector import (
+    SelectOptionDict,
+    SelectSelector,
+    SelectSelectorConfig,
+    SelectSelectorMode,
+)

 from .const import (
    CONF_LINE,
@@ -43,13 +49,6 @@ STEP_RECONFIGURE_SCHEMA = vol.Schema(
    }
 )

-STEP_STOP_DATA_SCHEMA = vol.Schema(
-    {
-        vol.Required(CONF_LINE): str,
-        vol.Required(CONF_STOP_ID): vol.Coerce(int),
-    }
-)
-
 STEP_VELOV_STATION_DATA_SCHEMA = vol.Schema(
    {
        vol.Required(CONF_STATION_ID): vol.Coerce(int),
@@ -179,33 +178,126 @@ class DataGrandLyonConfigFlow(ConfigFlow, domain=DOMAIN):
 class StopSubentryFlowHandler(ConfigSubentryFlow):
    """Handle a subentry flow for adding a Data Grand Lyon stop."""

+    def __init__(self) -> None:
+        """Initialize the flow."""
+        self._stops: list[TclStop] = []
+        self._selected_stop: TclStop | None = None
+        self._selected_stop_id: int | None = None
+
    async def async_step_user(
        self, user_input: dict[str, Any] | None = None
    ) -> SubentryFlowResult:
-        """Handle the user step to add a new stop."""
-        entry = self._get_entry()
+        """Pick a stop from the list fetched from the API, or enter one manually."""
+        if not self._stops:
+            if error := await self._async_load_stops():
+                return self.async_abort(reason=error)

+        errors: dict[str, str] = {}
        if user_input is not None:
-            line = user_input[CONF_LINE]
-            stop_id = user_input[CONF_STOP_ID]
-            unique_id = f"{line}_{stop_id}"
+            try:
+                stop_id = int(user_input[CONF_STOP_ID])
+            except ValueError:
+                errors[CONF_STOP_ID] = "invalid_stop_id"
+            else:
+                self._selected_stop_id = stop_id
+                self._selected_stop = find_tcl_stop_by_id(self._stops, stop_id)
+                return await self.async_step_pick_line()

-            for subentry in entry.subentries.values():
-                if subentry.unique_id == unique_id:
-                    return self.async_abort(reason="already_configured")
-
-            name = f"{line} - Stop {stop_id}"
-            return self.async_create_entry(
-                title=name,
-                data={CONF_LINE: line, CONF_STOP_ID: stop_id},
-                unique_id=unique_id,
+        options = [
+            SelectOptionDict(value=str(stop.id), label=_stop_label(stop))
+            for stop in sorted(
+                self._stops, key=lambda s: (s.nom, s.commune or "", s.id or 0)
            )
-
+        ]
+        schema = vol.Schema(
+            {
+                vol.Required(CONF_STOP_ID): SelectSelector(
+                    SelectSelectorConfig(
+                        options=options,
+                        mode=SelectSelectorMode.DROPDOWN,
+                        sort=False,
+                        custom_value=True,
+                    )
+                )
+            }
+        )
        return self.async_show_form(
            step_id="user",
-            data_schema=STEP_STOP_DATA_SCHEMA,
+            data_schema=schema,
+            errors=errors,
        )

+    async def async_step_pick_line(
+        self, user_input: dict[str, Any] | None = None
+    ) -> SubentryFlowResult:
+        """Pick a line from the selected stop's desserte, or enter one manually."""
+        assert self._selected_stop_id is not None
+        if user_input is not None:
+            return self._create_stop(
+                line=user_input[CONF_LINE], stop_id=self._selected_stop_id
+            )
+
+        options = self._selected_stop.desserte if self._selected_stop else []
+        schema = vol.Schema(
+            {
+                vol.Required(CONF_LINE): SelectSelector(
+                    SelectSelectorConfig(
+                        options=options,
+                        mode=SelectSelectorMode.DROPDOWN,
+                        custom_value=True,
+                    )
+                )
+            }
+        )
+        return self.async_show_form(step_id="pick_line", data_schema=schema)
+
+    async def _async_load_stops(self) -> str | None:
+        """Fetch TCL stops from the API, returning an error key on failure."""
+        entry = self._get_entry()
+        session = async_get_clientsession(self.hass)
+        client = DataGrandLyonClient(
+            session=session,
+            username=entry.data[CONF_USERNAME],
+            password=entry.data[CONF_PASSWORD],
+        )
+        try:
+            self._stops = await client.get_tcl_stops()
+        except ClientResponseError as err:
+            if err.status in (401, 403):
+                return "invalid_auth"
+            return "cannot_connect"
+        except ClientError, TimeoutError:
+            return "cannot_connect"
+        except Exception:
+            _LOGGER.exception("Unexpected error fetching Data Grand Lyon TCL stops")
+            return "unknown"
+        return None
+
+    def _create_stop(self, line: str, stop_id: int) -> SubentryFlowResult:
+        """Create the stop subentry, aborting on duplicate."""
+        entry = self._get_entry()
+        unique_id = f"{line}_{stop_id}"
+        for subentry in entry.subentries.values():
+            if subentry.unique_id == unique_id:
+                return self.async_abort(reason="already_configured")
+
+        return self.async_create_entry(
+            title=f"{line} - Stop {stop_id}",
+            data={CONF_LINE: line, CONF_STOP_ID: stop_id},
+            unique_id=unique_id,
+        )
+
+
+def _stop_label(stop: TclStop) -> str:
+    label = stop.nom
+    # variable extracted to please codespell.
+    address = stop.adresse  # codespell:ignore adresse
+    if address or stop.commune:
+        label += " (" + ", ".join(filter(None, [address, stop.commune])) + ")"
+    label += f" - {stop.id}"
+
+    return label
+

 class VelovStationSubentryFlowHandler(ConfigSubentryFlow):
    """Handle a subentry flow for adding a Vélo'v station."""
@@ -46,17 +46,30 @@
  "config_subentries": {
    "stop": {
      "abort": {
-        "already_configured": "[%key:common::config_flow::abort::already_configured_service%]"
+        "already_configured": "[%key:common::config_flow::abort::already_configured_service%]",
+        "cannot_connect": "[%key:common::config_flow::error::cannot_connect%]",
+        "invalid_auth": "[%key:common::config_flow::error::invalid_auth%]",
+        "unknown": "[%key:common::config_flow::error::unknown%]"
      },
      "entry_type": "Transit stop",
+      "error": {
+        "invalid_stop_id": "Stop ID must be a number."
+      },
      "initiate_flow": {
        "user": "Add transit stop"
      },
      "step": {
+        "pick_line": {
+          "data": {
+            "line": "Line"
+          }
+        },
        "user": {
          "data": {
-            "line": "Line",
-            "stop_id": "Stop ID"
+            "stop_id": "Stop"
+          },
+          "data_description": {
+            "stop_id": "Search by stop name, address or city, or enter a stop ID directly."
          }
        }
      }
@@ -54,10 +54,6 @@ async def async_migrate_entry(hass: HomeAssistant, config_entry: ConfigEntry) ->
        config_entry.minor_version,
    )

-    if config_entry.version > 1:
-        # This means the user has downgraded from a future version
-        return False
-
    if config_entry.version == 1:
        if config_entry.minor_version < 2:
            new_options = {**config_entry.options}
@@ -51,7 +51,7 @@ async def async_setup_entry(hass: HomeAssistant, entry: DnsIPConfigEntry) -> boo
            tcp_port=entry.options[CONF_PORT],
            udp_port=entry.options[CONF_PORT],
        )
-        queries.append(resolver_ipv4.query(hostname, "A"))
+        queries.append(resolver_ipv4.query_dns(hostname, "A"))

    if entry.data[CONF_IPV6]:
        resolver_ipv6 = aiodns.DNSResolver(
@@ -59,7 +59,7 @@ async def async_setup_entry(hass: HomeAssistant, entry: DnsIPConfigEntry) -> boo
            tcp_port=entry.options[CONF_PORT_IPV6],
            udp_port=entry.options[CONF_PORT_IPV6],
        )
-        queries.append(resolver_ipv6.query(hostname, "AAAA"))
+        queries.append(resolver_ipv6.query_dns(hostname, "AAAA"))

    async def _close_resolvers() -> None:
        if resolver_ipv4 is not None:
@@ -111,10 +111,6 @@ async def async_migrate_entry(
 ) -> bool:
    """Migrate old entry to a newer version."""

-    if config_entry.version > 1:
-        # This means the user has downgraded from a future version
-        return False
-
    if config_entry.version < 2 and config_entry.minor_version < 2:
        _LOGGER.debug(
            "Migrating configuration from version %s.%s",
@@ -72,7 +72,7 @@ async def async_validate_hostname(
            _resolver = aiodns.DNSResolver(
                nameservers=[resolver], udp_port=port, tcp_port=port
            )
-            result = bool(await _resolver.query(hostname, qtype))
+            result = bool(await _resolver.query_dns(hostname, qtype))

        return result

@@ -8,6 +8,7 @@ from typing import TYPE_CHECKING, Literal

 import aiodns
 from aiodns.error import DNSError
+import pycares

 from homeassistant.components.sensor import SensorEntity
 from homeassistant.const import CONF_NAME, CONF_PORT
@@ -148,7 +149,7 @@ class WanIpSensor(SensorEntity):
        response = None
        try:
            async with asyncio.timeout(10):
-                response = await self._resolver.query(self.hostname, self.querytype)
+                response = await self._resolver.query_dns(self.hostname, self.querytype)
        except TimeoutError as err:
            _LOGGER.debug("Timeout while resolving host: %s", err)
            await self._resolver.close()
@@ -157,9 +158,19 @@ class WanIpSensor(SensorEntity):
            await self._resolver.close()

        if response:
-            sorted_ips = sort_ips(
-                [res.host for res in response], querytype=self.querytype
-            )
+            if TYPE_CHECKING:
+                assert all(
+                    isinstance(res.data, (pycares.ARecordData, pycares.AAAARecordData))
+                    for res in response.answer
+                )
+            _ips = []
+            for res in response.answer:
+                if TYPE_CHECKING:
+                    assert isinstance(
+                        res.data, (pycares.ARecordData, pycares.AAAARecordData)
+                    )
+                _ips.append(res.data.addr)
+            sorted_ips = sort_ips(_ips, querytype=self.querytype)
            self._attr_native_value = sorted_ips[0]
            self._attr_extra_state_attributes["ip_addresses"] = sorted_ips
            self._attr_available = True
@@ -98,10 +98,6 @@ async def async_migrate_entry(
        config_entry.minor_version,
    )

-    if config_entry.version > 1:
-        # This means the user has downgraded from a future version
-        return False
-
    if config_entry.version == 1:
        new_options = {**config_entry.options}

@@ -8,9 +8,12 @@ from env_canada import ECAirQuality, ECMap, ECWeather
 from homeassistant.const import CONF_LANGUAGE, CONF_LATITUDE, CONF_LONGITUDE, Platform
 from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import ConfigEntryNotReady
+from homeassistant.helpers import config_validation as cv
+from homeassistant.helpers.typing import ConfigType

-from .const import CONF_STATION
+from .const import CONF_STATION, DOMAIN
 from .coordinator import ECConfigEntry, ECDataUpdateCoordinator, ECRuntimeData
+from .services import async_setup_services

 DEFAULT_RADAR_UPDATE_INTERVAL = timedelta(minutes=5)
 DEFAULT_WEATHER_UPDATE_INTERVAL = timedelta(minutes=5)
@@ -19,6 +22,14 @@ PLATFORMS = [Platform.CAMERA, Platform.SENSOR, Platform.WEATHER]

 _LOGGER = logging.getLogger(__name__)

+CONFIG_SCHEMA = cv.config_entry_only_config_schema(DOMAIN)
+
+
+async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
+    """Set up the Environment Canada services."""
+    async_setup_services(hass)
+    return True
+

 async def async_setup_entry(hass: HomeAssistant, config_entry: ECConfigEntry) -> bool:
    """Set up EC as config entry."""
@@ -19,6 +19,9 @@
    }
  },
  "services": {
+    "get_alerts": {
+      "service": "mdi:bell-alert"
+    },
    "get_forecasts": {
      "service": "mdi:weather-cloudy-clock"
    },
@@ -0,0 +1,56 @@
+"""Define services for the Environment Canada integration."""
+
+from typing import Any
+
+from env_canada import ECWeather
+import voluptuous as vol
+
+from homeassistant.const import ATTR_CONFIG_ENTRY_ID
+from homeassistant.core import HomeAssistant, ServiceCall, SupportsResponse, callback
+from homeassistant.exceptions import HomeAssistantError
+from homeassistant.helpers import config_validation as cv, service
+
+from .const import DOMAIN
+
+SERVICE_GET_ALERTS = "get_alerts"
+SERVICE_GET_ALERTS_SCHEMA = vol.Schema({vol.Required(ATTR_CONFIG_ENTRY_ID): cv.string})
+
+SNAKE_MAPPING = {
+    "alertColourLevel": "alert_colour_level",
+    "expiryTime": "expiry_time",
+}
+
+
+async def _async_get_alerts(call: ServiceCall) -> dict[str, Any]:
+    """Return the active alerts."""
+    entry = service.async_get_config_entry(
+        call.hass, DOMAIN, call.data[ATTR_CONFIG_ENTRY_ID]
+    )
+
+    ec: ECWeather | None = entry.runtime_data.weather_coordinator.ec_data
+    if ec is None:
+        raise HomeAssistantError(
+            translation_domain=DOMAIN,
+            translation_key="not_connected",
+        )
+
+    data: dict[str, Any] = ec.alerts
+    return {
+        k: [
+            {SNAKE_MAPPING.get(ik, ik): iv for ik, iv in item.items()}
+            for item in v["value"]
+        ]
+        for k, v in data.items()
+    }
+
+
+@callback
+def async_setup_services(hass: HomeAssistant) -> None:
+    """Set up the services for the Environment Canada integration."""
+    hass.services.async_register(
+        DOMAIN,
+        SERVICE_GET_ALERTS,
+        _async_get_alerts,
+        schema=SERVICE_GET_ALERTS_SCHEMA,
+        supports_response=SupportsResponse.ONLY,
+    )
@@ -1,3 +1,11 @@
+get_alerts:
+  fields:
+    config_entry_id:
+      required: true
+      selector:
+        config_entry:
+          integration: environment_canada
+
 get_forecasts:
  target:
    entity:
@@ -112,7 +112,22 @@
      }
    }
  },
+  "exceptions": {
+    "not_connected": {
+      "message": "Environment Canada is not connected"
+    }
+  },
  "services": {
+    "get_alerts": {
+      "description": "Retrieves the alerts from the selected weather service.",
+      "fields": {
+        "config_entry_id": {
+          "description": "The Environment Canada service to retrieve alerts from.",
+          "name": "Environment Canada service"
+        }
+      },
+      "name": "Get alerts"
+    },
    "get_forecasts": {
      "description": "Retrieves the forecast from selected weather services.",
      "name": "Get forecasts"
@@ -88,10 +88,6 @@ async def async_migrate_entry(
        config_entry.minor_version,
    )

-    if config_entry.version > 1 or config_entry.minor_version > 1:
-        # This means the user has downgraded from a future version
-        return False
-
    if config_entry.version == 1 and config_entry.minor_version == 1:
        new_data = {**config_entry.data}
        new_data[CONF_CONNECTION_TYPE] = HTTP
@@ -53,9 +53,6 @@ async def async_unload_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:

 async def async_migrate_entry(hass: HomeAssistant, config_entry: ConfigEntry) -> bool:
    """Migrate config entry."""
-    if config_entry.version > 2:
-        # Downgraded from future
-        return False

    if config_entry.version < 2:
        # Move optional fields from data to options in config entry
@@ -1,7 +1,7 @@
 {
  "domain": "fluss",
  "name": "Fluss+",
-  "codeowners": ["@fluss"],
+  "codeowners": ["@fluss", "@Marcello17"],
  "config_flow": true,
  "documentation": "https://www.home-assistant.io/integrations/fluss",
  "iot_class": "cloud_polling",
@@ -48,8 +48,6 @@ async def async_unload_entry(hass: HomeAssistant, entry: FGLairConfigEntry) -> b

 async def async_migrate_entry(hass: HomeAssistant, entry: FGLairConfigEntry) -> bool:
    """Migrate old entry."""
-    if entry.version > 1:
-        return False

    if entry.version == 1:
        new_data = {**entry.data}
@@ -65,10 +65,6 @@ async def async_migrate_entry(
    """Migrate old entry."""
    _LOGGER.debug("Migrating from version %s", config_entry.version)

-    if config_entry.version > 1:
-        # This means the user has downgraded from a future version
-        return False
-
    if config_entry.version == 1:
        if config_entry.minor_version < 2:
            new = {**config_entry.data}
@@ -59,10 +59,6 @@ async def async_migrate_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
    """Migrate entry."""
    _LOGGER.debug("Migrating from version %s:%s", entry.version, entry.minor_version)

-    if entry.version > 2:
-        # This means the user has downgraded from a future version
-        return False
-
    if entry.version == 1:
        # Migrate to advanced section
        new_options = {**entry.options}
@@ -148,9 +148,6 @@ async def async_migrate_entry(hass: HomeAssistant, config_entry: ConfigEntry) ->
        "Migrating from version %s.%s", config_entry.version, config_entry.minor_version
    )

-    if config_entry.version > 1:
-        # This means the user has downgraded from a future version
-        return False
    if config_entry.version == 1:
        options = {**config_entry.options}
        if config_entry.minor_version < 2:
@@ -76,9 +76,6 @@ async def async_migrate_entry(hass: HomeAssistant, config_entry: ConfigEntry) ->
        "Migrating from version %s.%s", config_entry.version, config_entry.minor_version
    )

-    if config_entry.version > 1:
-        # This means the user has downgraded from a future version
-        return False
    if config_entry.version == 1:
        options = {**config_entry.options}
        if config_entry.minor_version < 2:
@@ -98,10 +98,6 @@ async def async_migrate_entry(
 ) -> bool:
    """Migrate old config entries."""

-    if config_entry.version > 2:
-        # This means the user has downgraded from a future version
-        return False
-
    if config_entry.version == 1:
        # Update from version 1 to version 2 adding the PROTOCOL to the config entry
        host = config_entry.data[CONF_HOST]
@@ -226,10 +226,6 @@ async def async_migrate_entry(
    """Migrate entry."""
    LOGGER.debug("Migrating from version %s:%s", entry.version, entry.minor_version)

-    if entry.version > 2:
-        # This means the user has downgraded from a future version
-        return False
-
    if entry.version == 2 and entry.minor_version == 1:
        # Add TTS subentry which was missing in 2025.7.0b0
        if not any(
@@ -100,9 +100,6 @@ async def async_migrate_entry(hass: HomeAssistant, config_entry: ConfigEntry) ->
        "Migrating from version %s.%s", config_entry.version, config_entry.minor_version
    )

-    if config_entry.version > 1:
-        # This means the user has downgraded from a future version
-        return False
    if config_entry.version == 1:
        options = {**config_entry.options}
        if config_entry.minor_version < 2:
@@ -108,10 +108,6 @@ async def async_migrate_entry(
        config_entry.minor_version,
    )

-    if config_entry.version > 1:
-        # This means the user has downgraded from a future version
-        return False
-
    if config_entry.version == 1:
        if config_entry.minor_version == 1:
            serial_number = config_entry.data[SERIAL_NUMBER]
@@ -135,7 +131,24 @@ async def async_migrate_entry(
            )

            if canonical.entry_id != config_entry.entry_id:
-                # The canonical entry's migration will remove this duplicate.
+                if canonical.minor_version < 2:
+                    # The canonical entry has not been migrated yet and its
+                    # migration will remove this duplicate.
+                    return False
+
+                # The canonical entry is already fully migrated and will not run
+                # a migration that removes this duplicate, so remove it here. The
+                # entry can't remove itself while its setup lock is held, so
+                # schedule the removal instead.
+                _LOGGER.debug(
+                    "Removing duplicate config entry %s for serial %s in favor of %s",
+                    config_entry.entry_id,
+                    serial_number,
+                    canonical.entry_id,
+                )
+                hass.async_create_task(
+                    hass.config_entries.async_remove(config_entry.entry_id)
+                )
                return False

            for duplicate in duplicates:
@@ -140,10 +140,6 @@ async def async_migrate_entry(
        "Migrating from version %s.%s", config_entry.version, config_entry.minor_version
    )

-    if config_entry.version > 1:
-        # This means the user has downgraded from a future version
-        return False
-
    if config_entry.version == 1:
        if config_entry.minor_version == 1:
            # Add-on startup with type service get started before
@@ -239,7 +235,24 @@ async def async_migrate_entry(
            )

            if canonical.entry_id != config_entry.entry_id:
-                # The canonical entry's migration will remove this duplicate.
+                if canonical.minor_version < 5:
+                    # The canonical entry has not been migrated yet and its
+                    # migration will remove this duplicate.
+                    return False
+
+                # The canonical entry is already fully migrated and will not run
+                # a migration that removes this duplicate, so remove it here. The
+                # entry can't remove itself while its setup lock is held, so
+                # schedule the removal instead.
+                _LOGGER.warning(
+                    "Removing duplicate config entry %s for serial %s in favor of %s",
+                    config_entry.entry_id,
+                    serial_number,
+                    canonical.entry_id,
+                )
+                hass.async_create_task(
+                    hass.config_entries.async_remove(config_entry.entry_id)
+                )
                return False

            for duplicate in duplicates:
@@ -126,8 +126,6 @@ async def async_migrate_entry(
    hass: HomeAssistant, config_entry: config_entries.ConfigEntry
 ) -> bool:
    """Migrate the config entry from version 1 to version 2."""
-    if config_entry.version > 2:
-        return False

    if config_entry.version == 1:
        _LOGGER.debug("Migrating HomematicIP Cloud config entry to version 2")
@@ -1,9 +1,16 @@
 """The coordinator for Hypontech Cloud integration."""

+import asyncio
 from dataclasses import dataclass
 from datetime import timedelta

-from hyponcloud import HyponCloud, OverviewData, PlantData, RequestError
+from hyponcloud import (
+    HyponCloud,
+    OverviewData,
+    PlantData,
+    PlantMonitorData,
+    RequestError,
+)

 from homeassistant.config_entries import ConfigEntry
 from homeassistant.core import HomeAssistant
@@ -12,12 +19,20 @@ from homeassistant.helpers.update_coordinator import DataUpdateCoordinator, Upda
 from .const import DOMAIN, LOGGER


+@dataclass
+class HypontechPlant:
+    """Store a plant together with its real-time monitor data."""
+
+    info: PlantData
+    monitor: PlantMonitorData
+
+
@dataclass
 class HypontechCoordinatorData:
    """Store coordinator data."""

    overview: OverviewData
-    plants: dict[str, PlantData]
+    plants: dict[str, HypontechPlant]


 type HypontechConfigEntry = ConfigEntry[HypontechDataCoordinator]
@@ -50,11 +65,17 @@ class HypontechDataCoordinator(DataUpdateCoordinator[HypontechCoordinatorData]):
        try:
            overview = await self.api.get_overview()
            plants = await self.api.get_list()
+            monitors = await asyncio.gather(
+                *(self.api.get_monitor(plant.plant_id) for plant in plants)
+            )
        except RequestError as ex:
            raise UpdateFailed(
                translation_domain=DOMAIN, translation_key="connection_error"
            ) from ex
        return HypontechCoordinatorData(
            overview=overview,
-            plants={plant.plant_id: plant for plant in plants},
+            plants={
+                plant.plant_id: HypontechPlant(info=plant, monitor=monitor)
+                for plant, monitor in zip(plants, monitors, strict=True)
+            },
        )
@@ -1,12 +1,10 @@
 """Base entity for the Hypontech Cloud integration."""

-from hyponcloud import PlantData
-
 from homeassistant.helpers.device_registry import DeviceInfo
 from homeassistant.helpers.update_coordinator import CoordinatorEntity

 from .const import DOMAIN
-from .coordinator import HypontechDataCoordinator
+from .coordinator import HypontechDataCoordinator, HypontechPlant


 class HypontechEntity(CoordinatorEntity[HypontechDataCoordinator]):
@@ -36,12 +34,13 @@ class HypontechPlantEntity(CoordinatorEntity[HypontechDataCoordinator]):
        plant = coordinator.data.plants[plant_id]
        self._attr_device_info = DeviceInfo(
            identifiers={(DOMAIN, plant_id)},
-            name=plant.plant_name,
+            name=plant.info.plant_name,
            manufacturer="Hypontech",
+            model=plant.info.plant_type,
        )

    @property
-    def plant(self) -> PlantData:
+    def plant(self) -> HypontechPlant:
        """Return the plant data."""
        return self.coordinator.data.plants[self.plant_id]

@@ -11,11 +11,11 @@ from homeassistant.components.sensor import (
    SensorEntityDescription,
    SensorStateClass,
 )
-from homeassistant.const import UnitOfEnergy, UnitOfPower
+from homeassistant.const import PERCENTAGE, UnitOfEnergy, UnitOfPower
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback

-from .coordinator import HypontechConfigEntry, HypontechDataCoordinator
+from .coordinator import HypontechConfigEntry, HypontechDataCoordinator, HypontechPlant
 from .entity import HypontechEntity, HypontechPlantEntity


@@ -36,8 +36,8 @@ class HypontechSensorDescription(SensorEntityDescription):
 class HypontechPlantSensorDescription(SensorEntityDescription):
    """Describes Hypontech plant sensor entity."""

-    value_fn: Callable[[PlantData], float | None]
-    unit_fn: Callable[[PlantData], str] | None = None
+    value_fn: Callable[[HypontechPlant], float | None]
+    unit_fn: Callable[[HypontechPlant], str] | None = None


 OVERVIEW_SENSORS: tuple[HypontechSensorDescription, ...] = (
@@ -67,12 +67,24 @@ OVERVIEW_SENSORS: tuple[HypontechSensorDescription, ...] = (
 )

 PLANT_SENSORS: tuple[HypontechPlantSensorDescription, ...] = (
+    # Historically keyed "pv_power" when total power was the only reading (no
+    # battery support). Now it carries the PV-only power from the monitor
+    # endpoint; the plant endpoint's total power is exposed as "total_power".
    HypontechPlantSensorDescription(
        key="pv_power",
+        translation_key="pv_power",
+        native_unit_of_measurement=UnitOfPower.WATT,
        device_class=SensorDeviceClass.POWER,
        state_class=SensorStateClass.MEASUREMENT,
-        value_fn=lambda c: c.power,
-        unit_fn=_power_unit,
+        value_fn=lambda c: c.monitor.power_pv,
+    ),
+    HypontechPlantSensorDescription(
+        key="total_power",
+        translation_key="total_power",
+        device_class=SensorDeviceClass.POWER,
+        state_class=SensorStateClass.MEASUREMENT,
+        value_fn=lambda c: c.info.power,
+        unit_fn=lambda c: _power_unit(c.info),
    ),
    HypontechPlantSensorDescription(
        key="lifetime_energy",
@@ -80,7 +92,7 @@ PLANT_SENSORS: tuple[HypontechPlantSensorDescription, ...] = (
        native_unit_of_measurement=UnitOfEnergy.KILO_WATT_HOUR,
        device_class=SensorDeviceClass.ENERGY,
        state_class=SensorStateClass.TOTAL_INCREASING,
-        value_fn=lambda c: c.e_total,
+        value_fn=lambda c: c.info.e_total,
    ),
    HypontechPlantSensorDescription(
        key="today_energy",
@@ -88,7 +100,44 @@ PLANT_SENSORS: tuple[HypontechPlantSensorDescription, ...] = (
        native_unit_of_measurement=UnitOfEnergy.KILO_WATT_HOUR,
        device_class=SensorDeviceClass.ENERGY,
        state_class=SensorStateClass.TOTAL_INCREASING,
-        value_fn=lambda c: c.e_today,
+        value_fn=lambda c: c.info.e_today,
+    ),
+    HypontechPlantSensorDescription(
+        key="load_power",
+        translation_key="load_power",
+        native_unit_of_measurement=UnitOfPower.WATT,
+        device_class=SensorDeviceClass.POWER,
+        state_class=SensorStateClass.MEASUREMENT,
+        value_fn=lambda c: c.monitor.power_load,
+    ),
+    HypontechPlantSensorDescription(
+        key="grid_power",
+        translation_key="grid_power",
+        native_unit_of_measurement=UnitOfPower.WATT,
+        device_class=SensorDeviceClass.POWER,
+        state_class=SensorStateClass.MEASUREMENT,
+        value_fn=lambda c: c.monitor.meter_power,
+    ),
+)
+
+# Sensors only added for plants that have a battery (storage) system.
+BATTERY_SENSORS: tuple[HypontechPlantSensorDescription, ...] = (
+    HypontechPlantSensorDescription(
+        key="battery_power",
+        translation_key="battery_power",
+        native_unit_of_measurement=UnitOfPower.WATT,
+        device_class=SensorDeviceClass.POWER,
+        state_class=SensorStateClass.MEASUREMENT,
+        # Positive while the battery is discharging, negative while charging.
+        value_fn=lambda c: c.monitor.w_cha,
+    ),
+    HypontechPlantSensorDescription(
+        key="battery_state_of_charge",
+        translation_key="battery_state_of_charge",
+        native_unit_of_measurement=PERCENTAGE,
+        device_class=SensorDeviceClass.BATTERY,
+        state_class=SensorStateClass.MEASUREMENT,
+        value_fn=lambda c: c.monitor.soc,
    ),
 )

@@ -105,11 +154,15 @@ async def async_setup_entry(
        HypontechOverviewSensor(coordinator, desc) for desc in OVERVIEW_SENSORS
    ]

-    entities.extend(
-        HypontechPlantSensor(coordinator, plant_id, desc)
-        for plant_id in coordinator.data.plants
-        for desc in PLANT_SENSORS
-    )
+    for plant_id, plant in coordinator.data.plants.items():
+        entities.extend(
+            HypontechPlantSensor(coordinator, plant_id, desc) for desc in PLANT_SENSORS
+        )
+        if plant.info.plant_type.endswith("Storage"):
+            entities.extend(
+                HypontechPlantSensor(coordinator, plant_id, desc)
+                for desc in BATTERY_SENSORS
+            )

    async_add_entities(entities)

@@ -36,11 +36,29 @@
  },
  "entity": {
    "sensor": {
+      "battery_power": {
+        "name": "Battery power"
+      },
+      "battery_state_of_charge": {
+        "name": "Battery state of charge"
+      },
+      "grid_power": {
+        "name": "Grid power"
+      },
      "lifetime_energy": {
        "name": "Lifetime energy"
      },
+      "load_power": {
+        "name": "Load power"
+      },
+      "pv_power": {
+        "name": "PV power"
+      },
      "today_energy": {
        "name": "Today energy"
+      },
+      "total_power": {
+        "name": "Total power"
      }
    }
  },
@@ -49,9 +49,6 @@ async def async_migrate_entry(hass: HomeAssistant, config_entry: ConfigEntry) ->
        "Migrating from version %s.%s", config_entry.version, config_entry.minor_version
    )

-    if config_entry.version > 1:
-        # This means the user has downgraded from a future version
-        return False
    if config_entry.version == 1:
        options = {**config_entry.options}
        if config_entry.minor_version < 2:
@@ -52,9 +52,6 @@ async def async_migrate_entry(
    """Migrate old entry."""
    _LOGGER.debug("Migrating from version %s", config_entry.version)

-    if config_entry.version > 1:
-        # This means the user has downgraded from a future version
-        return False
    if config_entry.version == 1:
        new = {**config_entry.data}
        if config_entry.minor_version < 2:
@@ -2,6 +2,7 @@

 from typing import Any

+from homeassistant.const import CONF_URL
 from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import ConfigEntryAuthFailed, ConfigEntryNotReady
 from homeassistant.helpers import config_validation as cv, device_registry as dr
@@ -65,6 +66,15 @@ async def async_setup_entry(hass: HomeAssistant, entry: JellyfinConfigEntry) ->
    return True


+async def async_migrate_entry(hass: HomeAssistant, entry: JellyfinConfigEntry) -> bool:
+    """Migrate an old config entry."""
+    if entry.version == 1 and entry.minor_version < 2:
+        new_data = {**entry.data, CONF_URL: entry.data[CONF_URL].rstrip("/")}
+        hass.config_entries.async_update_entry(entry, data=new_data, minor_version=2)
+
+    return True
+
+
 async def async_unload_entry(hass: HomeAssistant, entry: JellyfinConfigEntry) -> bool:
    """Unload a config entry."""
    return await hass.config_entries.async_unload_platforms(entry, PLATFORMS)
@@ -46,6 +46,7 @@ class JellyfinConfigFlow(ConfigFlow, domain=DOMAIN):
    """Handle a config flow for Jellyfin."""

    VERSION = 1
+    MINOR_VERSION = 2

    def __init__(self) -> None:
        """Initialize the Jellyfin config flow."""
@@ -58,6 +59,8 @@ class JellyfinConfigFlow(ConfigFlow, domain=DOMAIN):
        errors: dict[str, str] = {}

        if user_input is not None:
+            user_input[CONF_URL] = user_input[CONF_URL].rstrip("/")
+
            if self.client_device_id is None:
                self.client_device_id = _generate_client_device_id()

@@ -131,10 +131,6 @@ async def async_migrate_entry(
            return {"new_unique_id": new_unique_id}
        return None

-    if config_entry.version > 2:
-        # This means the user has downgraded from a future version
-        return False
-
    if config_entry.version == 1:
        await er.async_migrate_entries(hass, config_entry.entry_id, update_unique_id)
        hass.config_entries.async_update_entry(config_entry, version=2)
@@ -2,8 +2,14 @@

 from homeassistant.const import Platform
 from homeassistant.core import HomeAssistant
+from homeassistant.helpers import config_validation as cv
+from homeassistant.helpers.typing import ConfigType

+from .const import DOMAIN
 from .coordinator import KioskerConfigEntry, KioskerDataUpdateCoordinator
+from .services import async_setup_services
+
+CONFIG_SCHEMA = cv.config_entry_only_config_schema(DOMAIN)

 _PLATFORMS: list[Platform] = [
    Platform.BINARY_SENSOR,
@@ -13,6 +19,12 @@ _PLATFORMS: list[Platform] = [
 ]


+async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
+    """Set up the Kiosker integration."""
+    async_setup_services(hass)
+    return True
+
+
 async def async_setup_entry(hass: HomeAssistant, entry: KioskerConfigEntry) -> bool:
    """Set up Kiosker from a config entry."""

@@ -8,3 +8,16 @@ POLL_INTERVAL = 15
 DEFAULT_SSL = False
 DEFAULT_SSL_VERIFY = False
 REFRESH_DELAY = 0.5
+
+# Service attribute keys
+ATTR_URL = "url"
+ATTR_VISIBLE = "visible"
+ATTR_TEXT = "text"
+ATTR_BACKGROUND = "background"
+ATTR_FOREGROUND = "foreground"
+ATTR_EXPIRE = "expire"
+ATTR_DISMISSIBLE = "dismissible"
+ATTR_BUTTON_BACKGROUND = "button_background"
+ATTR_BUTTON_FOREGROUND = "button_foreground"
+ATTR_BUTTON_TEXT = "button_text"
+ATTR_SOUND = "sound"
@@ -65,5 +65,13 @@
        "default": "mdi:power-sleep"
      }
    }
+  },
+  "services": {
+    "navigate_url": {
+      "service": "mdi:web"
+    },
+    "set_blackout": {
+      "service": "mdi:monitor-off"
+    }
  }
 }
@@ -1,23 +1,17 @@
 rules:
  # Bronze
-  action-setup:
-    status: exempt
-    comment: Integration does not register custom actions
+  action-setup: done
  appropriate-polling: done
  brands: done
  common-modules: done
  config-flow-test-coverage: done
  config-flow: done
  dependency-transparency: done
-  docs-actions:
-    status: exempt
-    comment: Integration does not provide custom actions to document
+  docs-actions: done
  docs-high-level-description: done
  docs-installation-instructions: done
  docs-removal-instructions: done
-  entity-event-setup:
-    status: exempt
-    comment: Integration is polling-only and does not subscribe to external events
+  entity-event-setup: done
  entity-unique-id: done
  has-entity-name: done
  runtime-data: done
@@ -26,9 +20,7 @@ rules:
  unique-config-entry: done

  # Silver
-  action-exceptions:
-    status: exempt
-    comment: Integration does not provide custom actions
+  action-exceptions: done
  config-entry-unloading: done
  docs-configuration-parameters: done
  docs-installation-parameters: done
@@ -0,0 +1,168 @@
+"""Services for the Kiosker integration."""
+
+from collections.abc import Awaitable, Callable, Coroutine
+import functools
+from typing import Any
+
+from kiosker import (
+    AuthenticationError,
+    BadRequestError,
+    Blackout,
+    ConnectionError,
+    IPAuthenticationError,
+    TLSVerificationError,
+)
+import voluptuous as vol
+
+from homeassistant.config_entries import ConfigEntryState
+from homeassistant.const import ATTR_DEVICE_ID, ATTR_ICON
+from homeassistant.core import HomeAssistant, ServiceCall, ServiceResponse, callback
+from homeassistant.exceptions import HomeAssistantError, ServiceValidationError
+from homeassistant.helpers import (
+    config_validation as cv,
+    device_registry as dr,
+    selector,
+)
+
+from .const import (
+    ATTR_BACKGROUND,
+    ATTR_BUTTON_BACKGROUND,
+    ATTR_BUTTON_FOREGROUND,
+    ATTR_BUTTON_TEXT,
+    ATTR_DISMISSIBLE,
+    ATTR_EXPIRE,
+    ATTR_FOREGROUND,
+    ATTR_SOUND,
+    ATTR_TEXT,
+    ATTR_URL,
+    ATTR_VISIBLE,
+    DOMAIN,
+)
+from .coordinator import KioskerDataUpdateCoordinator
+
+NAVIGATE_URL_SCHEMA = vol.Schema(
+    {
+        vol.Required(ATTR_DEVICE_ID): str,
+        vol.Required(ATTR_URL): str,
+    }
+)
+
+SET_BLACKOUT_SCHEMA = vol.Schema(
+    {
+        vol.Required(ATTR_DEVICE_ID): str,
+        vol.Optional(ATTR_VISIBLE, default=True): cv.boolean,
+        vol.Optional(ATTR_TEXT): str,
+        vol.Optional(ATTR_BACKGROUND, default=[0, 0, 0]): selector.ColorRGBSelector(),
+        vol.Optional(
+            ATTR_FOREGROUND, default=[255, 255, 255]
+        ): selector.ColorRGBSelector(),
+        vol.Optional(ATTR_ICON): str,
+        vol.Optional(ATTR_EXPIRE, default=60): vol.All(
+            vol.Coerce(int), vol.Range(min=0, max=100000)
+        ),
+        vol.Optional(ATTR_DISMISSIBLE, default=False): cv.boolean,
+        vol.Optional(
+            ATTR_BUTTON_BACKGROUND, default=[255, 255, 255]
+        ): selector.ColorRGBSelector(),
+        vol.Optional(
+            ATTR_BUTTON_FOREGROUND, default=[0, 0, 0]
+        ): selector.ColorRGBSelector(),
+        vol.Optional(ATTR_BUTTON_TEXT): str,
+        vol.Optional(ATTR_SOUND): str,
+    }
+)
+
+
+def handle_kiosker_api_errors(
+    func: Callable[[ServiceCall], Awaitable[None]],
+) -> Callable[[ServiceCall], Coroutine[Any, Any, ServiceResponse]]:
+    """Decorator to handle Kiosker API errors consistently across all service calls."""
+
+    @functools.wraps(func)
+    async def wrapper(call: ServiceCall) -> ServiceResponse:
+        try:
+            await func(call)
+        except ConnectionError as ex:
+            raise HomeAssistantError(f"Unable to connect to Kiosker: {ex}") from ex
+        except AuthenticationError as ex:
+            raise ServiceValidationError(
+                "Authentication failed. Check your API token."
+            ) from ex
+        except IPAuthenticationError as ex:
+            raise ServiceValidationError(
+                "IP authentication failed. Check your IP whitelist."
+            ) from ex
+        except TLSVerificationError as ex:
+            raise ServiceValidationError(f"TLS verification failed: {ex}") from ex
+        except BadRequestError as ex:
+            raise ServiceValidationError(f"Bad request: {ex}") from ex
+        else:
+            return None
+
+    return wrapper
+
+
+async def _get_coordinator(
+    call: ServiceCall,
+) -> KioskerDataUpdateCoordinator:
+    """Get the coordinator for the targeted device."""
+    registry = dr.async_get(call.hass)
+    device_id: str = call.data[ATTR_DEVICE_ID]
+    device = registry.async_get(device_id)
+
+    if device:
+        for entry_id in device.config_entries:
+            entry = call.hass.config_entries.async_get_entry(entry_id)
+            if entry and entry.domain == DOMAIN:
+                if entry.state != ConfigEntryState.LOADED:
+                    raise HomeAssistantError(f"{entry.title} is not loaded")
+                return entry.runtime_data
+
+    raise ServiceValidationError(f"No {DOMAIN} devices found in targeted selection")
+
+
+def _rgb_to_hex(rgb: list[int]) -> str:
+    """Convert an [r, g, b] list to a hex color string."""
+    return f"#{rgb[0]:02x}{rgb[1]:02x}{rgb[2]:02x}"
+
+
+@handle_kiosker_api_errors
+async def navigate_url(call: ServiceCall) -> None:
+    """Navigate to a URL on the Kiosker device."""
+    coordinator = await _get_coordinator(call)
+    await call.hass.async_add_executor_job(
+        coordinator.api.navigate_url, call.data[ATTR_URL]
+    )
+
+
+@handle_kiosker_api_errors
+async def set_blackout(call: ServiceCall) -> None:
+    """Set blackout mode on the Kiosker device."""
+    blackout = Blackout(
+        visible=call.data[ATTR_VISIBLE],
+        text=call.data.get(ATTR_TEXT),
+        background=_rgb_to_hex(call.data[ATTR_BACKGROUND]),
+        foreground=_rgb_to_hex(call.data[ATTR_FOREGROUND]),
+        icon=call.data.get(ATTR_ICON),
+        expire=call.data[ATTR_EXPIRE],
+        dismissible=call.data[ATTR_DISMISSIBLE],
+        buttonBackground=_rgb_to_hex(call.data[ATTR_BUTTON_BACKGROUND]),
+        buttonForeground=_rgb_to_hex(call.data[ATTR_BUTTON_FOREGROUND]),
+        buttonText=call.data.get(ATTR_BUTTON_TEXT),
+        sound=call.data.get(ATTR_SOUND),
+    )
+
+    coordinator = await _get_coordinator(call)
+    await call.hass.async_add_executor_job(coordinator.api.blackout_set, blackout)
+    await coordinator.async_request_refresh()
+
+
+@callback
+def async_setup_services(hass: HomeAssistant) -> None:
+    """Set up the services for the Kiosker integration."""
+    hass.services.async_register(
+        DOMAIN, "navigate_url", navigate_url, schema=NAVIGATE_URL_SCHEMA
+    )
+    hass.services.async_register(
+        DOMAIN, "set_blackout", set_blackout, schema=SET_BLACKOUT_SCHEMA
+    )
@@ -0,0 +1,62 @@
+navigate_url:
+  fields:
+    device_id:
+      required: true
+      selector:
+        device:
+          integration: kiosker
+    url:
+      required: true
+      selector:
+        text:
+
+set_blackout:
+  fields:
+    device_id:
+      required: true
+      selector:
+        device:
+          integration: kiosker
+    visible:
+      default: true
+      selector:
+        boolean:
+    text:
+      selector:
+        text:
+    background:
+      default: [0, 0, 0]
+      selector:
+        color_rgb:
+    foreground:
+      default: [255, 255, 255]
+      selector:
+        color_rgb:
+    icon:
+      selector:
+        text:
+    expire:
+      default: 60
+      selector:
+        number:
+          min: 0
+          max: 3600
+          unit_of_measurement: seconds
+    dismissible:
+      default: false
+      selector:
+        boolean:
+    button_background:
+      default: [255, 255, 255]
+      selector:
+        color_rgb:
+    button_foreground:
+      default: [0, 0, 0]
+      selector:
+        color_rgb:
+    button_text:
+      selector:
+        text:
+    sound:
+      selector:
+        text:
@@ -104,5 +104,75 @@
        "name": "Disable screensaver"
      }
    }
+  },
+  "services": {
+    "navigate_url": {
+      "description": "Navigate to a specific URL",
+      "fields": {
+        "device_id": {
+          "description": "The Kiosker device to control",
+          "name": "Device"
+        },
+        "url": {
+          "description": "The URL to navigate to",
+          "name": "URL"
+        }
+      },
+      "name": "Navigate to URL"
+    },
+    "set_blackout": {
+      "description": "Set blackout screen with custom message",
+      "fields": {
+        "background": {
+          "description": "Background color in rgb format",
+          "name": "Background color"
+        },
+        "button_background": {
+          "description": "Background color of the dismiss button in rgb format",
+          "name": "Button background color"
+        },
+        "button_foreground": {
+          "description": "Text color of the dismiss button in rgb format",
+          "name": "Button foreground color"
+        },
+        "button_text": {
+          "description": "Text to display on the dismiss button",
+          "name": "Button text"
+        },
+        "device_id": {
+          "description": "The Kiosker device to control",
+          "name": "Device"
+        },
+        "dismissible": {
+          "description": "Whether the blackout can be dismissed by user interaction",
+          "name": "Dismissible"
+        },
+        "expire": {
+          "description": "Time in seconds before the blackout expires",
+          "name": "Expire time"
+        },
+        "foreground": {
+          "description": "Text color in rgb format",
+          "name": "Foreground color"
+        },
+        "icon": {
+          "description": "Icon to display (SF Symbols name)",
+          "name": "Icon"
+        },
+        "sound": {
+          "description": "Sound to play when blackout is displayed (SystemSoundID, e.g., 1007)",
+          "name": "Sound"
+        },
+        "text": {
+          "description": "Text to display on blackout screen",
+          "name": "Text"
+        },
+        "visible": {
+          "description": "Whether the blackout is visible",
+          "name": "Visible"
+        }
+      },
+      "name": "Set blackout"
+    }
  }
 }
@@ -217,9 +217,6 @@ async def async_migrate_entry(
    hass: HomeAssistant, entry: LaMarzoccoConfigEntry
 ) -> bool:
    """Migrate config entry."""
-    if entry.version > 4:
-        # guard against downgrade from a future version
-        return False

    if entry.version in (1, 2):
        _LOGGER.error(
@@ -48,9 +48,6 @@ async def async_migrate_entry(
        entry.minor_version,
    )

-    if entry.version > 1:
-        return False
-
    if entry.minor_version < 2:
        account = Account(websession=async_get_clientsession(hass))
        try:
@@ -99,10 +99,6 @@ async def async_migrate_entry(hass: HomeAssistant, config_entry: ConfigEntry) ->
        config_entry.minor_version,
    )

-    if config_entry.version > 1:
-        # This means the user has downgraded from a future version
-        return False
-
    if config_entry.version == 1:
        if config_entry.minor_version < 2:
            # Remove the mold indicator config entry from the source device
@@ -467,10 +467,6 @@ async def async_migrate_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
    _LOGGER.debug("Migrating from version %s.%s", entry.version, entry.minor_version)
    data: dict[str, Any] = dict(entry.data)
    options: dict[str, Any] = dict(entry.options)
-    if entry.version > 2 or (entry.version == 2 and entry.minor_version > 1):
-        # This means the user has downgraded from a future version
-        # We allow read support for version 2.1
-        return False

    if entry.version == 1 and entry.minor_version < 2:
        # Can be removed when the config entry is bumped to version 2.1
@@ -44,9 +44,6 @@ async def async_migrate_entry(hass: HomeAssistant, entry: NinaConfigEntry) -> bo
    minor_version = entry.minor_version

    _LOGGER.debug("Migrating from version %s.%s", version, minor_version)
-    if entry.version > 1:
-        # This means the user has downgraded from a future version
-        return False

    new_data: dict[str, Any] = {**entry.data, CONF_FILTERS: {}}

@@ -116,10 +116,6 @@ async def async_migrate_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
        "Migrating configuration from version %s.%s", entry.version, entry.minor_version
    )

-    if entry.version > 1:
-        # This means the user has downgraded from a future version
-        return False
-
    if entry.version == 1:
        new_options = {**entry.options}
        if entry.minor_version < 2:
@@ -236,10 +236,6 @@ async def async_migrate_entry(hass: HomeAssistant, entry: OllamaConfigEntry) ->
    """Migrate entry."""
    _LOGGER.debug("Migrating from version %s:%s", entry.version, entry.minor_version)

-    if entry.version > 3:
-        # This means the user has downgraded from a future version
-        return False
-
    if entry.version == 2 and entry.minor_version == 1:
        # Correct broken device migration in Home Assistant Core 2025.7.0b0-2025.7.0b1
        device_registry = dr.async_get(hass)
@@ -133,9 +133,6 @@ async def _migrate_backup_files(client: OneDriveClient, backup_folder_id: str) -

 async def async_migrate_entry(hass: HomeAssistant, entry: OneDriveConfigEntry) -> bool:
    """Migrate old entry."""
-    if entry.version > 1:
-        # This means the user has downgraded from a future version
-        return False

    if (version := entry.version) == 1 and (minor_version := entry.minor_version) == 1:
        _LOGGER.debug(
@@ -63,9 +63,6 @@ async def async_migrate_entry(
    """Migrate config entry."""
    LOGGER.debug("Migrating from version %s.%s", entry.version, entry.minor_version)

-    if entry.version > 1 or (entry.version == 1 and entry.minor_version > 2):
-        return False
-
    if entry.version == 1 and entry.minor_version < 2:
        for subentry in entry.subentries.values():
            if CONF_WEB_SEARCH in subentry.data:
@@ -428,10 +428,6 @@ async def async_migrate_entry(hass: HomeAssistant, entry: OpenAIConfigEntry) ->
    """Migrate entry."""
    LOGGER.debug("Migrating from version %s:%s", entry.version, entry.minor_version)

-    if entry.version > 2:
-        # This means the user has downgraded from a future version
-        return False
-
    if entry.version == 2 and entry.minor_version == 1:
        # Correct broken device migration in Home Assistant Core 2025.7.0b0-2025.7.0b1
        device_registry = dr.async_get(hass)
@@ -201,8 +201,6 @@ async def async_migrate_entry(
    hass: HomeAssistant, entry: OverkizDataConfigEntry
 ) -> bool:
    """Migrate old entry."""
-    if entry.version > 1:
-        return False

    if entry.version == 1 and entry.minor_version < 2:
        await _async_migrate_strenum_unique_ids(hass, entry)
@@ -113,6 +113,36 @@ class OVHcloudAIEndpointsConfigFlow(ConfigFlow, domain=DOMAIN):
            errors=errors,
        )

+    async def async_step_reconfigure(
+        self, user_input: dict[str, Any] | None = None
+    ) -> ConfigFlowResult:
+        """Reconfigure the API key on an existing entry."""
+        errors: dict[str, str] = {}
+        entry = self._get_reconfigure_entry()
+        if user_input is not None:
+            self._async_abort_entries_match(user_input)
+            client = _create_client(self.hass, user_input[CONF_API_KEY])
+            try:
+                await _validate_api_key(client)
+            except AuthenticationError, PermissionDeniedError:
+                errors["base"] = "invalid_auth"
+            except OpenAIError:
+                errors["base"] = "cannot_connect"
+            except Exception:
+                _LOGGER.exception("Unexpected exception")
+                errors["base"] = "unknown"
+            else:
+                return self.async_update_reload_and_abort(
+                    entry, data_updates=user_input
+                )
+        return self.async_show_form(
+            step_id="reconfigure",
+            data_schema=self.add_suggested_values_to_schema(
+                STEP_REAUTH_DATA_SCHEMA, user_input or entry.data
+            ),
+            errors=errors,
+        )
+

 class ConversationFlowHandler(ConfigSubentryFlow):
    """Handle conversation subentry flow."""
@@ -136,6 +166,51 @@ class ConversationFlowHandler(ConfigSubentryFlow):
        self.options = RECOMMENDED_CONVERSATION_OPTIONS.copy()
        return await self.async_step_init(user_input)

+    async def async_step_reconfigure(
+        self, user_input: dict[str, Any] | None = None
+    ) -> SubentryFlowResult:
+        """Reconfigure a conversation agent (prompt + LLM APIs; model is fixed)."""
+        subentry = self._get_reconfigure_subentry()
+        existing = subentry.data
+
+        if user_input is not None:
+            if not user_input.get(CONF_LLM_HASS_API):
+                user_input.pop(CONF_LLM_HASS_API, None)
+            user_input[CONF_MODEL] = existing[CONF_MODEL]
+            return self.async_update_and_abort(
+                self._get_entry(), subentry, data=user_input
+            )
+
+        hass_apis: list[SelectOptionDict] = [
+            SelectOptionDict(label=api.name, value=api.id)
+            for api in llm.async_get_apis(self.hass)
+        ]
+        return self.async_show_form(
+            step_id="reconfigure",
+            data_schema=vol.Schema(
+                {
+                    vol.Optional(
+                        CONF_PROMPT,
+                        description={
+                            "suggested_value": existing.get(
+                                CONF_PROMPT,
+                                RECOMMENDED_CONVERSATION_OPTIONS[CONF_PROMPT],
+                            )
+                        },
+                    ): TemplateSelector(),
+                    vol.Optional(
+                        CONF_LLM_HASS_API,
+                        default=existing.get(
+                            CONF_LLM_HASS_API,
+                            RECOMMENDED_CONVERSATION_OPTIONS[CONF_LLM_HASS_API],
+                        ),
+                    ): SelectSelector(
+                        SelectSelectorConfig(options=hass_apis, multiple=True)
+                    ),
+                }
+            ),
+        )
+
    async def async_step_init(
        self, user_input: dict[str, Any] | None = None
    ) -> SubentryFlowResult:
@@ -82,7 +82,7 @@ rules:
    comment: conversation entity name comes from subentry title
  exception-translations: todo
  icon-translations: todo
-  reconfiguration-flow: todo
+  reconfiguration-flow: done
  repair-issues:
    status: exempt
    comment: the integration has no repairs
@@ -2,7 +2,8 @@
  "config": {
    "abort": {
      "already_configured": "[%key:common::config_flow::abort::already_configured_service%]",
-      "reauth_successful": "[%key:common::config_flow::abort::reauth_successful%]"
+      "reauth_successful": "[%key:common::config_flow::abort::reauth_successful%]",
+      "reconfigure_successful": "[%key:common::config_flow::abort::reconfigure_successful%]"
    },
    "error": {
      "cannot_connect": "[%key:common::config_flow::error::cannot_connect%]",
@@ -19,6 +20,15 @@
        },
        "description": "The OVHcloud AI Endpoints API key is no longer valid. Please enter a new one."
      },
+      "reconfigure": {
+        "data": {
+          "api_key": "[%key:common::config_flow::data::api_key%]"
+        },
+        "data_description": {
+          "api_key": "[%key:component::ovhcloud_ai_endpoints::config::step::user::data_description::api_key%]"
+        },
+        "description": "Update the API key used to authenticate with OVHcloud AI Endpoints."
+      },
      "user": {
        "data": {
          "api_key": "[%key:common::config_flow::data::api_key%]"
@@ -34,6 +44,7 @@
      "abort": {
        "cannot_connect": "[%key:common::config_flow::error::cannot_connect%]",
        "entry_not_loaded": "The main integration entry is not loaded. Please ensure the integration is loaded before configuring.",
+        "reconfigure_successful": "[%key:common::config_flow::abort::reconfigure_successful%]",
        "unknown": "[%key:common::config_flow::error::unknown%]"
      },
      "entry_type": "Conversation agent",
@@ -53,6 +64,17 @@
            "prompt": "Instruct how the LLM should respond. This can be a template."
          },
          "description": "Configure the conversation agent"
+        },
+        "reconfigure": {
+          "data": {
+            "llm_hass_api": "[%key:common::config_flow::data::llm_hass_api%]",
+            "prompt": "[%key:common::config_flow::data::prompt%]"
+          },
+          "data_description": {
+            "llm_hass_api": "[%key:component::ovhcloud_ai_endpoints::config_subentries::conversation::step::init::data_description::llm_hass_api%]",
+            "prompt": "[%key:component::ovhcloud_ai_endpoints::config_subentries::conversation::step::init::data_description::prompt%]"
+          },
+          "description": "Update the prompt and Home Assistant LLM APIs for this conversation agent. Create a new conversation agent to use a different model."
        }
      }
    }
@@ -8,5 +8,5 @@
  "iot_class": "cloud_polling",
  "loggers": ["renault_api"],
  "quality_scale": "silver",
-  "requirements": ["renault-api==0.5.11"]
+  "requirements": ["renault-api==0.5.12"]
 }
@@ -369,7 +369,11 @@ class ReolinkHost:
                )

        # start long polling if ONVIF push failed immediately
-        if not self._onvif_push_supported and not self._api.baichuan.privacy_mode():
+        if (
+            self._onvif_long_poll_supported
+            and not self._onvif_push_supported
+            and not self._api.baichuan.privacy_mode()
+        ):
            _LOGGER.debug(
                "Camera model %s does not support ONVIF push,"
                " using ONVIF long polling instead",
@@ -378,14 +382,8 @@ class ReolinkHost:
            try:
                await self._async_start_long_polling(initial=True)
            except NotSupportedError:
-                _LOGGER.debug(
-                    "Camera model %s does not support ONVIF long"
-                    " polling, using fast polling instead",
-                    self._api.model,
-                )
                self._onvif_long_poll_supported = False
                await self._api.unsubscribe()
-                await self._async_poll_all_motion()
            else:
                self._cancel_long_poll_check = async_call_later(
                    self._hass,
@@ -393,6 +391,13 @@ class ReolinkHost:
                    self._async_check_onvif_long_poll,
                )

+        if not self._onvif_long_poll_supported:
+            _LOGGER.debug(
+                "Camera model %s does not support ONVIF push and long polling, using fast polling instead",
+                self._api.model,
+            )
+            await self._async_poll_all_motion()
+
        self._cancel_tcp_push_check = None

    async def _async_check_onvif(self, *_: Any) -> None:
@@ -822,7 +827,7 @@ class ReolinkHost:
            return

        try:
-            if self._api.session_active:
+            if self._api.session_active and not self._api.baichuan.privacy_mode():
                await self._api.get_motion_state_all_ch()
        except ReolinkError as err:
            if not self._fast_poll_error:
@@ -834,7 +839,7 @@ class ReolinkHost:
                )
            self._fast_poll_error = True
        else:
-            if self._api.session_active:
+            if self._api.session_active and not self._api.baichuan.privacy_mode():
                self._fast_poll_error = False
        finally:
            # schedule next poll
@@ -253,9 +253,6 @@ async def async_migrate_entry(hass: HomeAssistant, entry: RoborockConfigEntry) -
        entry.version,
        entry.minor_version,
    )
-    if entry.version > 1:
-        # Downgrade from future version
-        return False

    # 1->2: Migrate from unique id as email address to unique id as rruid
    if entry.minor_version == 1:
@@ -4,6 +4,8 @@ from collections.abc import Callable
 from dataclasses import dataclass

 from roborock.data import CleanFluidStatus, RoborockStateCode
+from roborock.data.v1.v1_containers import StatusField, StatusV2
+from roborock.devices.traits.v1 import PropertiesApi
 from roborock.roborock_message import RoborockZeoProtocol

 from homeassistant.components.binary_sensor import (
@@ -38,6 +40,9 @@ class RoborockBinarySensorDescription(BinarySensorEntityDescription):
    is_dock_entity: bool = False
    """Whether this sensor is for the dock."""

+    support_fn: Callable[[PropertiesApi], bool] = lambda _: True
+    """Function to determine if binary sensor is supported by the device."""
+

@dataclass(frozen=True, kw_only=True)
 class RoborockBinarySensorDescriptionA01(BinarySensorEntityDescription):
@@ -55,6 +60,9 @@ BINARY_SENSOR_DESCRIPTIONS = [
        entity_category=EntityCategory.DIAGNOSTIC,
        value_fn=lambda data: data.status.dry_status,
        is_dock_entity=True,
+        support_fn=lambda api: api.device_features.is_field_supported(
+            StatusV2, StatusField.DRY_STATUS
+        ),
    ),
    RoborockBinarySensorDescription(
        key="water_box_carriage_status",
@@ -62,6 +70,7 @@ BINARY_SENSOR_DESCRIPTIONS = [
        device_class=BinarySensorDeviceClass.CONNECTIVITY,
        entity_category=EntityCategory.DIAGNOSTIC,
        value_fn=lambda data: data.status.water_box_carriage_status,
+        support_fn=lambda api: api.device_features.is_support_water_mode,
    ),
    RoborockBinarySensorDescription(
        key="water_box_status",
@@ -69,6 +78,7 @@ BINARY_SENSOR_DESCRIPTIONS = [
        device_class=BinarySensorDeviceClass.CONNECTIVITY,
        entity_category=EntityCategory.DIAGNOSTIC,
        value_fn=lambda data: data.status.water_box_status,
+        support_fn=lambda api: api.device_features.is_support_water_mode,
    ),
    RoborockBinarySensorDescription(
        key="water_shortage",
@@ -76,6 +86,7 @@ BINARY_SENSOR_DESCRIPTIONS = [
        device_class=BinarySensorDeviceClass.PROBLEM,
        entity_category=EntityCategory.DIAGNOSTIC,
        value_fn=lambda data: data.status.water_shortage_status,
+        support_fn=lambda api: api.device_features.is_support_water_mode,
    ),
    RoborockBinarySensorDescription(
        key="dirty_box_full",
@@ -84,6 +95,7 @@ BINARY_SENSOR_DESCRIPTIONS = [
        entity_category=EntityCategory.DIAGNOSTIC,
        value_fn=lambda data: data.status.dirty_water_box_status,
        is_dock_entity=True,
+        support_fn=lambda api: api.wash_towel_mode is not None,
    ),
    RoborockBinarySensorDescription(
        key="clean_box_empty",
@@ -92,6 +104,7 @@ BINARY_SENSOR_DESCRIPTIONS = [
        entity_category=EntityCategory.DIAGNOSTIC,
        value_fn=lambda data: data.status.clear_water_box_status,
        is_dock_entity=True,
+        support_fn=lambda api: api.wash_towel_mode is not None,
    ),
    RoborockBinarySensorDescription(
        key="clean_fluid_empty",
@@ -104,6 +117,10 @@ BINARY_SENSOR_DESCRIPTIONS = [
            else None
        ),
        is_dock_entity=True,
+        support_fn=lambda api: (
+            api.wash_towel_mode is not None
+            and api.device_features.is_clean_fluid_delivery_supported
+        ),
    ),
    RoborockBinarySensorDescription(
        key="in_cleaning",
@@ -157,12 +174,7 @@ async def async_setup_entry(
        )
        for coordinator in config_entry.runtime_data.v1
        for description in BINARY_SENSOR_DESCRIPTIONS
-        # Note: Currently coordinator.data is always available
-        # on startup but won't be in the future
-        if (
-            coordinator.data is not None
-            and description.value_fn(coordinator.data) is not None
-        )
+        if description.support_fn(coordinator.properties_api)
    ]
    entities.extend(
        RoborockBinarySensorEntityA01(
@@ -7,7 +7,6 @@ import itertools
 import logging
 from typing import Any

-from roborock.device_features import is_wash_n_fill_dock
 from roborock.devices.traits.v1.consumeable import ConsumableAttribute
 from roborock.exceptions import RoborockException
 from roborock.roborock_message import RoborockZeoProtocol
@@ -47,11 +46,6 @@ class RoborockButtonDescription(ButtonEntityDescription):
    is_supported: Callable[[RoborockDataUpdateCoordinator], bool] = lambda _: True


-def _supports_dock_consumables(coordinator: RoborockDataUpdateCoordinator) -> bool:
-    dock_type = coordinator.properties_api.status.dock_type
-    return dock_type is not None and is_wash_n_fill_dock(dock_type)
-
-
 CONSUMABLE_BUTTON_DESCRIPTIONS = [
    RoborockButtonDescription(
        key="reset_sensor_consumable",
@@ -88,7 +82,9 @@ CONSUMABLE_BUTTON_DESCRIPTIONS = [
        entity_category=EntityCategory.CONFIG,
        entity_registry_enabled_default=False,
        is_dock_entity=True,
-        is_supported=_supports_dock_consumables,
+        is_supported=lambda coordinator: (
+            coordinator.properties_api.wash_towel_mode is not None
+        ),
    ),
    RoborockButtonDescription(
        key="reset_dock_cleaning_brush_consumable",
@@ -97,7 +93,9 @@ CONSUMABLE_BUTTON_DESCRIPTIONS = [
        entity_category=EntityCategory.CONFIG,
        entity_registry_enabled_default=False,
        is_dock_entity=True,
-        is_supported=_supports_dock_consumables,
+        is_supported=lambda coordinator: (
+            coordinator.properties_api.wash_towel_mode is not None
+        ),
    ),
 ]

@@ -19,6 +19,7 @@ from roborock.data import (
 )
 from roborock.data.b01_q10.b01_q10_code_mappings import YXDeviceState
 from roborock.devices.traits.b01.q10.status import StatusTrait as Q10StatusTrait
+from roborock.devices.traits.v1 import PropertiesApi
 from roborock.roborock_message import RoborockDyadDataProtocol, RoborockZeoProtocol

 from homeassistant.components.sensor import (
@@ -64,6 +65,9 @@ class RoborockSensorDescription(SensorEntityDescription):
    # If it is a dock entity
    is_dock_entity: bool = False

+    support_fn: Callable[[PropertiesApi], bool] = lambda _: True
+    """Function to determine if sensor is supported by the device."""
+

@dataclass(frozen=True, kw_only=True)
 class RoborockSensorDescriptionA01(SensorEntityDescription):
@@ -131,6 +135,7 @@ SENSOR_DESCRIPTIONS = [
        value_fn=lambda data: data.consumable.cleaning_brush_time_left,
        entity_category=EntityCategory.DIAGNOSTIC,
        is_dock_entity=True,
+        support_fn=lambda api: api.wash_towel_mode is not None,
    ),
    RoborockSensorDescription(
        native_unit_of_measurement=UnitOfTime.HOURS,
@@ -140,6 +145,7 @@ SENSOR_DESCRIPTIONS = [
        value_fn=lambda data: data.consumable.strainer_time_left,
        entity_category=EntityCategory.DIAGNOSTIC,
        is_dock_entity=True,
+        support_fn=lambda api: api.wash_towel_mode is not None,
    ),
    RoborockSensorDescription(
        native_unit_of_measurement=UnitOfTime.SECONDS,
@@ -234,15 +240,14 @@ SENSOR_DESCRIPTIONS = [
        entity_category=EntityCategory.DIAGNOSTIC,
        device_class=SensorDeviceClass.TIMESTAMP,
    ),
-    # Only available on some newer models
    RoborockSensorDescription(
        key="clean_percent",
        translation_key="clean_percent",
        value_fn=lambda data: data.status.clean_percent,
        entity_category=EntityCategory.DIAGNOSTIC,
        native_unit_of_measurement=PERCENTAGE,
+        support_fn=lambda api: api.device_features.is_support_clean_estimate,
    ),
-    # Only available with more than just the basic dock
    RoborockSensorDescription(
        key="dock_error",
        translation_key="dock_error",
@@ -251,6 +256,9 @@ SENSOR_DESCRIPTIONS = [
        device_class=SensorDeviceClass.ENUM,
        options=RoborockDockErrorCode.keys(),
        is_dock_entity=True,
+        # Only available with more than just the basic dock. Dust collection
+        # mode is a proxy for any more complex dock type (e.g. Auto-empty).
+        support_fn=lambda api: api.dust_collection_mode is not None,
    ),
    RoborockSensorDescription(
        key="mop_clean_remaining",
@@ -261,6 +269,7 @@ SENSOR_DESCRIPTIONS = [
        translation_key="mop_drying_remaining_time",
        entity_category=EntityCategory.DIAGNOSTIC,
        is_dock_entity=True,
+        support_fn=lambda api: api.device_features.is_supported_drying,
    ),
 ]

@@ -536,12 +545,7 @@ async def async_setup_entry(
        )
        for coordinator in coordinators.v1
        for description in SENSOR_DESCRIPTIONS
-        # Note: Currently coordinator.data is always available
-        # on startup but won't be in the future
-        if (
-            coordinator.data is not None
-            and description.value_fn(coordinator.data) is not None
-        )
+        if description.support_fn(coordinator.properties_api)
    ]
    entities.extend(RoborockCurrentRoom(coordinator) for coordinator in coordinators.v1)
    entities.extend(
@@ -115,9 +115,6 @@ async def async_migrate_entry(
    hass: HomeAssistant, config_entry: RussoundConfigEntry
 ) -> bool:
    """Migrate old entry."""
-    if config_entry.version > 2:
-        # This means the user has downgraded from a future version
-        return False

    if config_entry.version == 1:
        (
@@ -121,10 +121,6 @@ async def async_migrate_entry(
        config_entry.minor_version,
    )

-    if config_entry.version > 2:
-        # This means the user has downgraded from a future version
-        return False
-
    # 1.2 Migrate subentries to include configured numbers to title
    if config_entry.version == 1 and config_entry.minor_version == 1:
        for subentry in config_entry.subentries.values():
@@ -153,10 +153,6 @@ async def async_setup_entry(hass: HomeAssistant, entry: ScrapeConfigEntry) -> bo
 async def async_migrate_entry(hass: HomeAssistant, entry: ScrapeConfigEntry) -> bool:
    """Migrate old entry."""

-    if entry.version > 2:
-        # Don't migrate from future version
-        return False
-
    if entry.version == 1:
        old_to_new_sensor_id = {}
        for sensor_config in entry.options[SENSOR_DOMAIN]:
@@ -134,8 +134,7 @@ async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:

 async def async_migrate_entry(hass: HomeAssistant, entry: ShellyConfigEntry) -> bool:
    """Migrate old config entries."""
-    if entry.version > 1 or (entry.version == 1 and entry.minor_version > 3):
-        return False
+
    if entry.minor_version < 3:
        # One-time flip of explicit Active scanning to Auto so existing
        # installs get the new battery-friendly default; Passive stays
@@ -47,10 +47,6 @@ async def async_unload_entry(hass: HomeAssistant, entry: SMHIConfigEntry) -> boo
 async def async_migrate_entry(hass: HomeAssistant, entry: SMHIConfigEntry) -> bool:
    """Migrate old entry."""

-    if entry.version > 3:
-        # Downgrade from future version
-        return False
-
    if entry.version == 1:
        new_data = {
            CONF_NAME: entry.data[CONF_NAME],
@@ -93,10 +93,6 @@ async def async_migrate_entry(
    """Migrate old entry."""
    _LOGGER.debug("Migrating from version %s", config_entry.version)

-    if config_entry.version > 1:
-        # This means the user has downgraded from a future version
-        return False
-
    if config_entry.version == 1:
        if config_entry.minor_version < 2:
            # migrate old entity unique id
@@ -108,10 +108,6 @@ async def async_migrate_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
    """Migrate old entry."""
    _LOGGER.debug("Migrating from version %s.%s", entry.version, entry.minor_version)

-    if entry.version > 1:
-        # This means the user has downgraded from a future version
-        return False
-
    if entry.version == 1:
        old_options = {**entry.options}
        new_data = {}
@@ -74,7 +74,7 @@ ATTR_QUERY_RESULT = "query_result"

 _LOGGER = logging.getLogger(__name__)

-PARALLEL_UPDATES = 1
+PARALLEL_UPDATES = 0

 ATTR_OTHER_PLAYER = "other_player"

@@ -22,7 +22,7 @@ from .entity import SqueezeboxEntity

 _LOGGER = logging.getLogger(__name__)

-PARALLEL_UPDATES = 1
+PARALLEL_UPDATES = 0


 async def async_setup_entry(
@@ -57,9 +57,6 @@ async def async_migrate_entry(hass: HomeAssistant, config_entry: ConfigEntry) ->
        "Migrating from version %s.%s", config_entry.version, config_entry.minor_version
    )

-    if config_entry.version > 1:
-        # This means the user has downgraded from a future version
-        return False
    if config_entry.version == 1:
        options = {**config_entry.options}
        if config_entry.minor_version < 2:
@@ -41,9 +41,6 @@ async def async_migrate_entry(
        config_entry.minor_version,
    )

-    if config_entry.version > 2:
-        return False
-
    if config_entry.version == 1:
        # Migrate to version 2
        counter_id = config_entry.data.get(CONF_COUNTER_ID)
@@ -120,10 +120,6 @@ async def async_migrate_entry(
    """Migrate config entry."""
    _LOGGER.debug("Migrating from version %s", config_entry.version)

-    if config_entry.version > 3:
-        # This means the user has downgraded from a future version
-        return False
-
    if config_entry.version == 1 and config_entry.minor_version == 1:
        # Remove wrongly registered devices and entries
        new_unique_id = unique_id_from_config(config_entry.data)
@@ -81,9 +81,6 @@ async def async_migrate_entry(hass: HomeAssistant, config_entry: ConfigEntry) ->
        "Migrating from version %s.%s", config_entry.version, config_entry.minor_version
    )

-    if config_entry.version > 1:
-        # This means the user has downgraded from a future version
-        return False
    if config_entry.version == 1:
        options = {**config_entry.options}
        if config_entry.minor_version < 2:
@@ -28,7 +28,6 @@ from homeassistant.helpers.aiohttp_client import async_get_clientsession
 from homeassistant.helpers.issue_registry import IssueSeverity, async_create_issue
 from homeassistant.helpers.typing import ConfigType

-from .config_flow import SystemBridgeConfigFlow
 from .const import DATA_WAIT_TIMEOUT, DOMAIN, MODULES
 from .coordinator import SystemBridgeConfigEntry, SystemBridgeDataUpdateCoordinator
 from .services import async_setup_services
@@ -215,9 +214,6 @@ async def async_migrate_entry(hass: HomeAssistant, config_entry: ConfigEntry) ->
        config_entry.minor_version,
    )

-    if config_entry.version > SystemBridgeConfigFlow.VERSION:
-        return False
-
    if config_entry.minor_version < 2:
        # Migrate to CONF_TOKEN, which was added in 1.2
        new_data = dict(config_entry.data)
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
G Johansson	7c33b953d3	Remove not needed guards for integration migrations from future versions (#173301 )	2026-06-08 15:57:25 -04:00
Martin Hjelmare	5ffd772868	Fix homeassistant hardware unique id migration (#173258 )	2026-06-08 21:39:19 +02:00
Marcello	392c7f97c8	Add individual code owner for Fluss (#173276 )	2026-06-08 21:38:49 +02:00
Allen Porter	0672c940a4	Use roboorck device capabilities to determine which entities are supported (#173282 )	2026-06-08 20:36:54 +02:00
Michael Hansen	03b0b4ad8b	Allow inline number ranges for sentence triggers (#173111 ) Co-authored-by: copilot-swe-agent[bot] <198982749+Copilot@users.noreply.github.com>	2026-06-08 14:22:17 -04:00
cnico	9b84fc9dba	Update dio-chacon-wifi-api to 1.3.0 (#173240 )	2026-06-08 20:17:00 +02:00
Michael Hansen	e38e6ecec8	Mitigate TTS ResultStream leak in pipeline (#173290 )	2026-06-08 12:13:53 -04:00
Simone Chemelli	37e4f1ab32	Bump renault-api to 0.5.12 (#173289 )	2026-06-08 17:52:22 +02:00
G Johansson	18d17a5346	Config entry migration error on downgrading (#173184 )	2026-06-08 17:45:24 +02:00
Crocmagnon	d10ede2264	data grand lyon: list stops and lines in config flow (#173117 )	2026-06-08 17:25:01 +02:00
Jeef	05088bf991	Add initial quality scale for Weatherflow local (#166022 ) Co-authored-by: Claude Sonnet 4.6 <noreply@anthropic.com> Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com> Co-authored-by: Markus Tuominen <3738613+Markus98@users.noreply.github.com>	2026-06-08 18:11:03 +03:00
epenet	fbf14c63c0	Fix incorrect use of Platform in atag (#173025 )	2026-06-08 16:55:50 +02:00
epenet	397c28b9b6	Use DOMAIN constant in test (async_setup_component h-n) (#173015 )	2026-06-08 16:28:17 +02:00
Glenn Waters	676a8c39eb	Environment Canada integration: add get_alerts action (#172393 )	2026-06-08 16:16:42 +02:00
epenet	d4accebb3b	Use DOMAIN constant in test (async_setup_component a-g) (#173013 )	2026-06-08 15:58:54 +02:00
Åke Strandberg	b8bdd2c47c	Add new Aqvify integration (#172936 )	2026-06-08 15:45:03 +02:00
Evan Severson	828ec639dd	Strip trailing slash from Jellyfin server URL (#173049 )	2026-06-08 15:43:58 +02:00
Martin Claesson	df4fbc91f9	Add Kiosker service platform (#171094 )	2026-06-08 15:42:34 +02:00
G Johansson	1a4a95df83	Use query_dns from aiodns in dnsip (#173257 )	2026-06-08 15:11:41 +02:00
Crocmagnon	e4b5818b56	ovhcloud_ai_endpoints: add reconfigure flow (#172583 )	2026-06-08 14:00:09 +02:00
starkillerOG	c9ad482293	Adjust ONVIF event fallbacks for battery cameras (#173214 ) Co-authored-by: Copilot Autofix powered by AI <175728472+Copilot@users.noreply.github.com>	2026-06-08 13:51:10 +02:00
peteS-UK	78cc155e56	Update PARALLEL_UPDATES to 0 for Squeezebox platforms (#172906 )	2026-06-08 13:45:29 +02:00
Hai-Nam Nguyen	145639d048	Add load, grid, and battery sensors to Hypontech (#173150 ) Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com>	2026-06-08 13:40:37 +02:00
bkobus-bbx	3e3e9af30d	Add state_class to blebox sensors (#173253 ) Co-authored-by: Joost Lekkerkerker <joostlek@outlook.com>	2026-06-08 12:04:04 +02:00