Add trigger timer.time_remaining (#169763 )

Add method _should_include to EntityTriggerBase (#169837 )
Improve condition test helper docstrings (#169871 )
2026-05-06 08:36:42 +02:00 · 2026-05-05 23:54:49 -04:00 · 2026-05-06 00:50:22 +02:00 · 2026-05-06 00:32:37 +02:00 · 2026-05-05 22:23:14 +02:00 · 2026-05-05 22:20:28 +02:00
188 changed files with 8050 additions and 1972 deletions
@@ -108,7 +108,7 @@ jobs:

      - name: Download nightly wheels of frontend
        if: needs.init.outputs.channel == 'dev'
-        uses: dawidd6/action-download-artifact@8305c0f1062bb0d184d09ef4493ecb9288447732 # v20
+        uses: dawidd6/action-download-artifact@b6e2e70617bc3265edd6dab6c906732b2f1ae151 # v21
        with:
          github_token: ${{secrets.GITHUB_TOKEN}}
          repo: home-assistant/frontend
@@ -119,7 +119,7 @@ jobs:

      - name: Download nightly wheels of intents
        if: needs.init.outputs.channel == 'dev'
-        uses: dawidd6/action-download-artifact@8305c0f1062bb0d184d09ef4493ecb9288447732 # v20
+        uses: dawidd6/action-download-artifact@b6e2e70617bc3265edd6dab6c906732b2f1ae151 # v21
        with:
          github_token: ${{secrets.GITHUB_TOKEN}}
          repo: OHF-Voice/intents-package
@@ -442,6 +442,7 @@ homeassistant.components.private_ble_device.*
 homeassistant.components.prometheus.*
 homeassistant.components.proximity.*
 homeassistant.components.prusalink.*
+homeassistant.components.ptdevices.*
 homeassistant.components.pure_energie.*
 homeassistant.components.purpleair.*
 homeassistant.components.pushbullet.*
@@ -1092,6 +1092,8 @@ CLAUDE.md @home-assistant/core
 /tests/components/minecraft_server/ @elmurato @zachdeibert
 /homeassistant/components/minio/ @tkislan
 /tests/components/minio/ @tkislan
+/homeassistant/components/mitsubishi_comfort/ @nikolairahimi
+/tests/components/mitsubishi_comfort/ @nikolairahimi
 /homeassistant/components/moat/ @bdraco
 /tests/components/moat/ @bdraco
 /homeassistant/components/mobile_app/ @home-assistant/core
@@ -1378,6 +1380,8 @@ CLAUDE.md @home-assistant/core
 /tests/components/proxmoxve/ @Corbeno @erwindouna @CoMPaTech
 /homeassistant/components/ps4/ @ktnrg45
 /tests/components/ps4/ @ktnrg45
+/homeassistant/components/ptdevices/ @ParemTech-Inc @frogman85978
+/tests/components/ptdevices/ @ParemTech-Inc @frogman85978
 /homeassistant/components/pterodactyl/ @elmurato
 /tests/components/pterodactyl/ @elmurato
 /homeassistant/components/pure_energie/ @klaasnicolaas
@@ -0,0 +1,5 @@
+{
+  "domain": "sensereo",
+  "name": "Sensereo",
+  "iot_standards": ["matter"]
+}
@@ -0,0 +1,5 @@
+{
+  "domain": "zunzunbee",
+  "name": "Zunzunbee",
+  "iot_standards": ["zigbee"]
+}
@@ -5,5 +5,5 @@
  "documentation": "https://www.home-assistant.io/integrations/acer_projector",
  "iot_class": "local_polling",
  "quality_scale": "legacy",
-  "requirements": ["serialx==1.4.1"]
+  "requirements": ["serialx==1.7.0"]
 }
@@ -17,7 +17,13 @@
          "longitude": "[%key:common::config_flow::data::longitude%]",
          "radius": "Station radius (miles; optional)"
        },
-        "description": "To generate API key go to {api_key_url}"
+        "data_description": {
+          "api_key": "To generate an API key, go to {api_key_url}.",
+          "latitude": "The latitude of your location.",
+          "longitude": "The longitude of your location.",
+          "radius": "The radius in miles around your location to search for reporting stations."
+        },
+        "description": "To generate an API key, go to {api_key_url}."
      }
    }
  },
@@ -899,12 +899,13 @@ class AutomationEntity(BaseAutomationEntity, RestoreEntity):
    async def async_will_remove_from_hass(self) -> None:
        """Remove listeners when removing automation from Home Assistant."""
        await super().async_will_remove_from_hass()
-        await self._async_disable()
        if self.registry_entry and self.registry_entry.entity_id != self.entity_id:
            # Entity ID change, do not unload the script or conditions as they will
            # be reused.
+            await self._async_disable()
            return
-        self.action_script.async_unload()
+        await self._async_disable(stop_actions=False)
+        await self.action_script.async_unload()
        if self._condition is not None:
            self._condition.async_unload()

@@ -8,14 +8,15 @@ from homeassistant.helpers import config_validation as cv
 from homeassistant.helpers.automation import DomainSpec
 from homeassistant.helpers.trigger import (
    ENTITY_STATE_TRIGGER_SCHEMA_FIRST_LAST,
+    EntityNumericalStateChangedTriggerBase,
    EntityNumericalStateChangedTriggerWithUnitBase,
+    EntityNumericalStateCrossedThresholdTriggerBase,
    EntityNumericalStateCrossedThresholdTriggerWithUnitBase,
+    EntityNumericalStateTriggerBase,
    EntityNumericalStateTriggerWithUnitBase,
    EntityTargetStateTriggerBase,
    Trigger,
    TriggerConfig,
-    make_entity_numerical_state_changed_trigger,
-    make_entity_numerical_state_crossed_threshold_trigger,
    make_entity_target_state_trigger,
    make_entity_transition_trigger,
 )
@@ -75,6 +76,32 @@ class ClimateTargetTemperatureCrossedThresholdTrigger(
    """Trigger for climate target temperature value crossing a threshold."""


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

 import logging

-import voluptuous as vol
-
-from homeassistant.config_entries import SOURCE_IMPORT
-from homeassistant.const import CONF_ACCESS_TOKEN, CONF_DOMAIN
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers import config_validation as cv
 from homeassistant.helpers.typing import ConfigType
@@ -16,18 +12,7 @@ from .services import async_setup_services

 _LOGGER = logging.getLogger(__name__)

-
-CONFIG_SCHEMA = vol.Schema(
-    {
-        DOMAIN: vol.Schema(
-            {
-                vol.Required(CONF_DOMAIN): cv.string,
-                vol.Required(CONF_ACCESS_TOKEN): cv.string,
-            }
-        )
-    },
-    extra=vol.ALLOW_EXTRA,
-)
+CONFIG_SCHEMA = cv.config_entry_only_config_schema(DOMAIN)


 async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
@@ -35,15 +20,6 @@ async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:

    async_setup_services(hass)

-    if DOMAIN not in config:
-        return True
-
-    hass.async_create_task(
-        hass.config_entries.flow.async_init(
-            DOMAIN, context={"source": SOURCE_IMPORT}, data=config[DOMAIN]
-        )
-    )
-
    return True


@@ -16,7 +16,6 @@ from homeassistant.helpers.selector import (

 from .const import DOMAIN
 from .helpers import update_duckdns
-from .issue import deprecate_yaml_issue

 _LOGGER = logging.getLogger(__name__)

@@ -68,18 +67,6 @@ class DuckDnsConfigFlow(ConfigFlow, domain=DOMAIN):
            description_placeholders={"url": "https://www.duckdns.org/"},
        )

-    async def async_step_import(self, import_info: dict[str, Any]) -> ConfigFlowResult:
-        """Import config from yaml."""
-
-        self._async_abort_entries_match({CONF_DOMAIN: import_info[CONF_DOMAIN]})
-        result = await self.async_step_user(import_info)
-        if errors := result.get("errors"):
-            deprecate_yaml_issue(self.hass, import_success=False)
-            return self.async_abort(reason=errors["base"])
-
-        deprecate_yaml_issue(self.hass, import_success=True)
-        return result
-
    async def async_step_reconfigure(
        self, user_input: dict[str, Any] | None = None
    ) -> ConfigFlowResult:
@@ -1,45 +1,11 @@
 """Issues for Duck DNS integration."""

-from homeassistant.core import DOMAIN as HOMEASSISTANT_DOMAIN, HomeAssistant, callback
+from homeassistant.core import HomeAssistant
 from homeassistant.helpers.issue_registry import IssueSeverity, async_create_issue

 from .const import DOMAIN


-@callback
-def deprecate_yaml_issue(hass: HomeAssistant, *, import_success: bool) -> None:
-    """Deprecate yaml issue."""
-    if import_success:
-        async_create_issue(
-            hass,
-            HOMEASSISTANT_DOMAIN,
-            f"deprecated_yaml_{DOMAIN}",
-            is_fixable=False,
-            issue_domain=DOMAIN,
-            breaks_in_ha_version="2026.6.0",
-            severity=IssueSeverity.WARNING,
-            translation_key="deprecated_yaml",
-            translation_placeholders={
-                "domain": DOMAIN,
-                "integration_title": "Duck DNS",
-            },
-        )
-    else:
-        async_create_issue(
-            hass,
-            DOMAIN,
-            "deprecated_yaml_import_issue_error",
-            breaks_in_ha_version="2026.6.0",
-            is_fixable=False,
-            issue_domain=DOMAIN,
-            severity=IssueSeverity.WARNING,
-            translation_key="deprecated_yaml_import_issue_error",
-            translation_placeholders={
-                "url": "/config/integrations/dashboard/add?domain=duckdns"
-            },
-        )
-
-
 def action_called_without_config_entry(hass: HomeAssistant) -> None:
    """Deprecate the use of action without config entry."""

@@ -49,10 +49,6 @@
    "deprecated_call_without_config_entry": {
      "description": "Calling the `duckdns.set_txt` action without specifying a config entry is deprecated.\n\nThe `config_entry_id` field will be required in a future release.\n\nPlease update your automations and scripts to include the `config_entry_id` parameter.",
      "title": "Detected deprecated use of action without config entry"
-    },
-    "deprecated_yaml_import_issue_error": {
-      "description": "Configuring Duck DNS using YAML is being removed but there was an error when trying to import the YAML configuration.\n\nEnsure the YAML configuration is correct and restart Home Assistant to try again or remove the Duck DNS YAML configuration from your `configuration.yaml` file and continue to [set up the integration]({url}) manually.",
-      "title": "The Duck DNS YAML configuration import failed"
    }
  },
  "services": {
@@ -13,6 +13,9 @@ from homeassistant.exceptions import HomeAssistantError
 from .const import DOMAIN
 from .coordinator import DucoConfigEntry

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

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

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

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

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

    @property
    def extra_state_attributes(self) -> dict[str, Any]:
@@ -6,5 +6,5 @@
  "iot_class": "local_push",
  "loggers": ["sense_energy"],
  "quality_scale": "internal",
-  "requirements": ["sense-energy==0.14.0"]
+  "requirements": ["sense-energy==0.14.1"]
 }
@@ -1,7 +1,5 @@
 """DataUpdateCoordinator for Fluss+ integration."""

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

@@ -596,7 +596,9 @@ class GrowattCoordinator(DataUpdateCoordinator[dict[str, Any]]):
        if not self.data:
            await self.async_refresh()

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

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

-        return self.api.sph_read_ac_discharge_times(settings_data=self.data)
+        return self.api.sph_read_ac_discharge_times(
+            self.device_id, settings_data=self.data
+        )
@@ -8,5 +8,5 @@
  "iot_class": "cloud_polling",
  "loggers": ["growattServer"],
  "quality_scale": "silver",
-  "requirements": ["growattServer==1.9.0"]
+  "requirements": ["growattServer==2.1.0"]
 }
@@ -9,5 +9,5 @@
  "iot_class": "cloud_push",
  "loggers": ["aioautomower"],
  "quality_scale": "silver",
-  "requirements": ["aioautomower==2.7.4"]
+  "requirements": ["aioautomower==2.7.5"]
 }
@@ -6,6 +6,6 @@
  "documentation": "https://www.home-assistant.io/integrations/indevolt",
  "integration_type": "device",
  "iot_class": "local_polling",
-  "quality_scale": "bronze",
+  "quality_scale": "silver",
  "requirements": ["indevolt-api==1.7.1"]
 }
@@ -5,5 +5,5 @@
  "documentation": "https://www.home-assistant.io/integrations/infrared",
  "integration_type": "entity",
  "quality_scale": "internal",
-  "requirements": ["infrared-protocols==2.0.0"]
+  "requirements": ["infrared-protocols==2.1.0"]
 }
@@ -77,10 +77,9 @@ async def async_reload(hass: HomeAssistant, service_call: ServiceCall) -> None:
    existing_intents = hass.data[DOMAIN]

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

    if not new_config or DOMAIN not in new_config:
        hass.data[DOMAIN] = {}
@@ -12,7 +12,7 @@
  "quality_scale": "platinum",
  "requirements": [
    "xknx==3.15.0",
-    "xknxproject==3.8.2",
+    "xknxproject==3.9.0",
    "knx-frontend==2026.4.30.60856"
  ],
  "single_config_entry": true
@@ -4,7 +4,7 @@ from collections.abc import Callable
 from dataclasses import dataclass
 from typing import Generic

-from pylitterbot import LitterRobot, LitterRobot4, Robot
+from pylitterbot import FeederRobot, LitterRobot, LitterRobot3, LitterRobot4, Robot

 from homeassistant.components.binary_sensor import (
    BinarySensorDeviceClass,
@@ -30,8 +30,11 @@ class RobotBinarySensorEntityDescription(
    is_on_fn: Callable[[_WhiskerEntityT], bool]


-BINARY_SENSOR_MAP: dict[type[Robot], tuple[RobotBinarySensorEntityDescription, ...]] = {
-    LitterRobot: (  # type: ignore[type-abstract]  # only used for isinstance check
+BINARY_SENSOR_MAP: dict[
+    type[Robot] | tuple[type[Robot], ...],
+    tuple[RobotBinarySensorEntityDescription, ...],
+] = {
+    LitterRobot: (
        RobotBinarySensorEntityDescription[LitterRobot](
            key="sleeping",
            translation_key="sleeping",
@@ -56,14 +59,14 @@ BINARY_SENSOR_MAP: dict[type[Robot], tuple[RobotBinarySensorEntityDescription, .
            is_on_fn=lambda robot: not robot.is_hopper_removed,
        ),
    ),
-    Robot: (  # type: ignore[type-abstract]  # only used for isinstance check
-        RobotBinarySensorEntityDescription[Robot](
+    (FeederRobot, LitterRobot3, LitterRobot4): (
+        RobotBinarySensorEntityDescription[FeederRobot | LitterRobot3 | LitterRobot4](
            key="power_status",
            translation_key="power_status",
            device_class=BinarySensorDeviceClass.PLUG,
            entity_category=EntityCategory.DIAGNOSTIC,
            entity_registry_enabled_default=False,
-            is_on_fn=lambda robot: robot.power_status == "AC",
+            is_on_fn=lambda robot: robot.power_type == "AC",
        ),
    ),
 }
@@ -16,5 +16,5 @@
  "iot_class": "cloud_push",
  "loggers": ["pylitterbot"],
  "quality_scale": "platinum",
-  "requirements": ["pylitterbot==2025.3.2"]
+  "requirements": ["pylitterbot==2025.4.0"]
 }
@@ -123,6 +123,9 @@
    }
  },
  "triggers": {
+    "muted": {
+      "trigger": "mdi:volume-mute"
+    },
    "paused_playing": {
      "trigger": "mdi:pause"
    },
@@ -137,6 +140,9 @@
    },
    "turned_on": {
      "trigger": "mdi:power"
+    },
+    "unmuted": {
+      "trigger": "mdi:volume-high"
    }
  }
 }
@@ -437,6 +437,18 @@
  },
  "title": "Media player",
  "triggers": {
+    "muted": {
+      "description": "Triggers after one or more media players are muted.",
+      "fields": {
+        "behavior": {
+          "name": "[%key:component::media_player::common::trigger_behavior_name%]"
+        },
+        "for": {
+          "name": "[%key:component::media_player::common::trigger_for_name%]"
+        }
+      },
+      "name": "Media player muted"
+    },
    "paused_playing": {
      "description": "Triggers after one or more media players pause playing.",
      "fields": {
@@ -496,6 +508,18 @@
        }
      },
      "name": "Media player turned on"
+    },
+    "unmuted": {
+      "description": "Triggers after one or more media players are unmuted.",
+      "fields": {
+        "behavior": {
+          "name": "[%key:component::media_player::common::trigger_behavior_name%]"
+        },
+        "for": {
+          "name": "[%key:component::media_player::common::trigger_for_name%]"
+        }
+      },
+      "name": "Media player unmuted"
    }
  }
 }
@@ -1,12 +1,79 @@
 """Provides triggers for media players."""

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

-from . import MediaPlayerState
+from . import ATTR_MEDIA_VOLUME_LEVEL, ATTR_MEDIA_VOLUME_MUTED, MediaPlayerState
 from .const import DOMAIN

+
+class _MediaPlayerMutedStateTriggerBase(EntityTriggerBase):
+    """Base class for media player muted/unmuted triggers."""
+
+    _domain_specs = {DOMAIN: DomainSpec()}
+    _target_muted: bool
+
+    def _has_volume_attributes(self, state: State) -> bool:
+        """Check if the state has volume muted or volume level attributes."""
+        return (
+            state.attributes.get(ATTR_MEDIA_VOLUME_MUTED) is not None
+            or state.attributes.get(ATTR_MEDIA_VOLUME_LEVEL) is not None
+        )
+
+    def _should_include(self, state: State) -> bool:
+        """Check if an entity should participate in all/count checks.
+
+        Entities without volume attributes cannot be muted, so they are
+        excluded from the check - otherwise an "all" check would never
+        pass when there are media players without volume support.
+        """
+        return super()._should_include(state) and self._has_volume_attributes(state)
+
+    def is_muted(self, state: State) -> bool:
+        """Check if the media player is muted."""
+        return (
+            state.attributes.get(ATTR_MEDIA_VOLUME_MUTED) is True
+            or state.attributes.get(ATTR_MEDIA_VOLUME_LEVEL) == 0
+        )
+
+    def is_valid_transition(self, from_state: State, to_state: State) -> bool:
+        """Check if the origin state is valid and the state has changed."""
+        if from_state.state in (STATE_UNAVAILABLE, STATE_UNKNOWN):
+            return False
+
+        if not self._has_volume_attributes(to_state):
+            return False
+
+        return self.is_muted(from_state) != self.is_muted(to_state)
+
+    def is_valid_state(self, state: State) -> bool:
+        """Check if the new state matches the expected state."""
+        if not self._has_volume_attributes(state):
+            return False
+        return self.is_muted(state) is self._target_muted
+
+
+class MediaPlayerMutedTrigger(_MediaPlayerMutedStateTriggerBase):
+    """Class for media player muted triggers."""
+
+    _target_muted = True
+
+
+class MediaPlayerUnmutedTrigger(_MediaPlayerMutedStateTriggerBase):
+    """Class for media player unmuted triggers."""
+
+    _target_muted = False
+
+
 TRIGGERS: dict[str, type[Trigger]] = {
+    "muted": MediaPlayerMutedTrigger,
+    "unmuted": MediaPlayerUnmutedTrigger,
    "paused_playing": make_entity_transition_trigger(
        DOMAIN,
        from_states={
@@ -15,6 +15,8 @@
      selector:
        duration:

+muted: *trigger_common
+unmuted: *trigger_common
 paused_playing: *trigger_common
 started_playing: *trigger_common
 stopped_playing: *trigger_common
@@ -479,6 +479,7 @@ class WashingMachineProgramId(MieleEnum, missing_to_none=True):
    down_filled_items = 129
    cottons_eco = 133
    quick_power_wash = 146, 10031
+    quick_intense = 177
    eco_40_60 = 190, 10007
    bed_linen = 10047
    easy_care = 10016
@@ -0,0 +1,95 @@
+"""Mitsubishi Comfort integration for Home Assistant."""
+
+import asyncio
+import logging
+
+from mitsubishi_comfort import (
+    DeviceInfo,
+    IndoorUnit,
+    KumoStation,
+    MitsubishiCloudAccount,
+)
+from mitsubishi_comfort.exceptions import AuthenticationError, DeviceConnectionError
+
+from homeassistant.const import CONF_PASSWORD, CONF_USERNAME
+from homeassistant.core import HomeAssistant
+from homeassistant.exceptions import ConfigEntryError, ConfigEntryNotReady
+from homeassistant.helpers.aiohttp_client import async_get_clientsession
+
+from .const import DEFAULT_CONNECT_TIMEOUT, DEFAULT_RESPONSE_TIMEOUT, DOMAIN, PLATFORMS
+from .coordinator import MitsubishiComfortConfigEntry, MitsubishiComfortCoordinator
+
+_LOGGER = logging.getLogger(__name__)
+
+
+def _make_device(
+    info: DeviceInfo,
+    serial: str,
+    session,
+) -> IndoorUnit | KumoStation:
+    """Create the appropriate device instance from DeviceInfo."""
+    cls = IndoorUnit if info.is_indoor_unit else KumoStation
+    return cls(
+        name=info.label,
+        address=info.address,
+        password_b64=info.password,
+        crypto_serial_hex=info.crypto_serial,
+        serial=serial,
+        connect_timeout=DEFAULT_CONNECT_TIMEOUT,
+        response_timeout=DEFAULT_RESPONSE_TIMEOUT,
+        session=session,
+    )
+
+
+async def async_setup_entry(
+    hass: HomeAssistant, entry: MitsubishiComfortConfigEntry
+) -> bool:
+    """Set up Mitsubishi Comfort from a config entry."""
+    session = async_get_clientsession(hass)
+    account = MitsubishiCloudAccount(
+        entry.data[CONF_USERNAME], entry.data[CONF_PASSWORD], session=session
+    )
+
+    try:
+        await account.login()
+        devices = await account.discover_devices()
+    except AuthenticationError as err:
+        raise ConfigEntryError("Mitsubishi cloud authentication failed") from err
+    except DeviceConnectionError as err:
+        raise ConfigEntryNotReady("Cannot reach Mitsubishi cloud") from err
+
+    if not devices:
+        raise ConfigEntryError(
+            translation_domain=DOMAIN,
+            translation_key="no_devices",
+        )
+
+    coordinators: dict[str, MitsubishiComfortCoordinator] = {}
+    for serial, info in devices.items():
+        if not info.address or not info.password or not info.crypto_serial:
+            _LOGGER.warning("Device %s missing credentials, skipping", info.label)
+            continue
+        device = _make_device(info, serial, session)
+        coordinators[serial] = MitsubishiComfortCoordinator(
+            hass, entry, device, info.mac
+        )
+
+    await asyncio.gather(
+        *(c.async_config_entry_first_refresh() for c in coordinators.values())
+    )
+
+    entry.runtime_data = coordinators
+    await hass.config_entries.async_forward_entry_setups(entry, PLATFORMS)
+    return True
+
+
+async def async_unload_entry(
+    hass: HomeAssistant, entry: MitsubishiComfortConfigEntry
+) -> bool:
+    """Unload a config entry."""
+    if unload_ok := await hass.config_entries.async_unload_platforms(entry, PLATFORMS):
+        await asyncio.gather(
+            *(c.device.close() for c in entry.runtime_data.values()),
+            return_exceptions=True,
+        )
+    return unload_ok
@@ -0,0 +1,287 @@
+"""Climate entity for Mitsubishi Comfort integration."""
+
+from typing import Any
+
+from mitsubishi_comfort import FanSpeed, IndoorUnit, Mode, VaneDirection
+
+from homeassistant.components.climate import (
+    ATTR_TARGET_TEMP_HIGH,
+    ATTR_TARGET_TEMP_LOW,
+    ClimateEntity,
+    ClimateEntityFeature,
+    HVACAction,
+    HVACMode,
+)
+from homeassistant.const import ATTR_TEMPERATURE, UnitOfTemperature
+from homeassistant.core import HomeAssistant
+from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
+
+from .coordinator import MitsubishiComfortConfigEntry, MitsubishiComfortCoordinator
+from .entity import MitsubishiComfortEntity
+
+_MODE_TO_HVAC: dict[str, HVACMode] = {
+    "off": HVACMode.OFF,
+    "cool": HVACMode.COOL,
+    "heat": HVACMode.HEAT,
+    "dry": HVACMode.DRY,
+    "vent": HVACMode.FAN_ONLY,
+    "auto": HVACMode.HEAT_COOL,
+    "autoCool": HVACMode.HEAT_COOL,
+    "autoHeat": HVACMode.HEAT_COOL,
+}
+
+_HVAC_TO_MODE: dict[HVACMode, Mode] = {
+    HVACMode.OFF: Mode.OFF,
+    HVACMode.COOL: Mode.COOL,
+    HVACMode.HEAT: Mode.HEAT,
+    HVACMode.DRY: Mode.DRY,
+    HVACMode.FAN_ONLY: Mode.FAN,
+    HVACMode.HEAT_COOL: Mode.AUTO,
+}
+
+_LIB_MODE_TO_HVAC: dict[Mode, HVACMode] = {v: k for k, v in _HVAC_TO_MODE.items()}
+
+_MODE_TO_ACTION: dict[str, HVACAction] = {
+    "off": HVACAction.OFF,
+    "cool": HVACAction.COOLING,
+    "heat": HVACAction.HEATING,
+    "dry": HVACAction.DRYING,
+    "vent": HVACAction.FAN,
+    "auto": HVACAction.IDLE,
+    "autoCool": HVACAction.COOLING,
+    "autoHeat": HVACAction.HEATING,
+}
+
+_FAN_SPEED_MAP: dict[str, FanSpeed] = {s.value: s for s in FanSpeed}
+_VANE_DIR_MAP: dict[str, VaneDirection] = {d.value: d for d in VaneDirection}
+
+_OPT_MODE = "mode"
+_OPT_COOL_SETPOINT = "cool_setpoint"
+_OPT_HEAT_SETPOINT = "heat_setpoint"
+_OPT_FAN_SPEED = "fan_speed"
+_OPT_VANE_DIRECTION = "vane_direction"
+
+
+async def async_setup_entry(
+    hass: HomeAssistant,
+    entry: MitsubishiComfortConfigEntry,
+    async_add_entities: AddConfigEntryEntitiesCallback,
+) -> None:
+    """Set up Mitsubishi Comfort climate entities."""
+    coordinators = entry.runtime_data
+    async_add_entities(
+        MitsubishiComfortClimate(coordinator)
+        for coordinator in coordinators.values()
+        if isinstance(coordinator.device, IndoorUnit)
+    )
+
+
+class MitsubishiComfortClimate(MitsubishiComfortEntity, ClimateEntity):
+    """Climate entity for a Mitsubishi indoor unit."""
+
+    _attr_name = None
+    _attr_temperature_unit = UnitOfTemperature.CELSIUS
+    _enable_turn_on_off_backwards_compatibility = False
+
+    def __init__(self, coordinator: MitsubishiComfortCoordinator) -> None:
+        """Initialize."""
+        super().__init__(coordinator)
+        self._attr_unique_id = self._device.serial
+        self._optimistic: dict[str, Any] = {}
+
+    def _handle_coordinator_update(self) -> None:
+        """Clear optimistic state when real data arrives from device."""
+        self._optimistic.clear()
+        super()._handle_coordinator_update()
+
+    @property
+    def _effective_mode(self) -> str | None:
+        return self._optimistic.get(_OPT_MODE, self._device.status.mode)
+
+    @property
+    def hvac_mode(self) -> HVACMode | None:
+        """Return the current HVAC mode."""
+        mode = self._effective_mode
+        return _MODE_TO_HVAC.get(mode) if mode else None
+
+    @property
+    def hvac_action(self) -> HVACAction | None:
+        """Return the current HVAC action."""
+        mode = self._effective_mode
+        if mode and self._device.status.standby:
+            return HVACAction.IDLE
+        return _MODE_TO_ACTION.get(mode) if mode else None
+
+    @property
+    def hvac_modes(self) -> list[HVACMode]:
+        """Return the list of available HVAC modes."""
+        return [
+            _LIB_MODE_TO_HVAC[m]
+            for m in self._device.supported_modes
+            if m in _LIB_MODE_TO_HVAC
+        ]
+
+    @property
+    def current_temperature(self) -> float | None:
+        """Return the current temperature."""
+        return self._device.status.room_temperature
+
+    @property
+    def current_humidity(self) -> float | None:
+        """Return the current humidity."""
+        return self._device.status.current_humidity
+
+    @property
+    def target_temperature(self) -> float | None:
+        """Return the target temperature."""
+        mode = self._effective_mode
+        if mode in ("cool", "autoCool"):
+            return self._optimistic.get(
+                _OPT_COOL_SETPOINT, self._device.status.cool_setpoint
+            )
+        if mode in ("heat", "autoHeat"):
+            return self._optimistic.get(
+                _OPT_HEAT_SETPOINT, self._device.status.heat_setpoint
+            )
+        return None
+
+    @property
+    def target_temperature_high(self) -> float | None:
+        """Return the upper bound target temperature."""
+        if self._effective_mode in ("auto", "autoCool", "autoHeat"):
+            return self._optimistic.get(
+                _OPT_COOL_SETPOINT, self._device.status.cool_setpoint
+            )
+        return None
+
+    @property
+    def target_temperature_low(self) -> float | None:
+        """Return the lower bound target temperature."""
+        if self._effective_mode in ("auto", "autoCool", "autoHeat"):
+            return self._optimistic.get(
+                _OPT_HEAT_SETPOINT, self._device.status.heat_setpoint
+            )
+        return None
+
+    @property
+    def fan_mode(self) -> str | None:
+        """Return the current fan mode."""
+        return self._optimistic.get(_OPT_FAN_SPEED, self._device.status.fan_speed)
+
+    @property
+    def fan_modes(self) -> list[str]:
+        """Return the list of available fan modes."""
+        return [s.value for s in self._device.supported_fan_speeds]
+
+    @property
+    def swing_mode(self) -> str | None:
+        """Return the current swing mode."""
+        return self._optimistic.get(
+            _OPT_VANE_DIRECTION, self._device.status.vane_direction
+        )
+
+    @property
+    def swing_modes(self) -> list[str]:
+        """Return the list of available swing modes."""
+        return [d.value for d in self._device.supported_vane_directions]
+
+    @property
+    def min_temp(self) -> float:
+        """Return the minimum temperature."""
+        if self._effective_mode in ("heat", "autoHeat"):
+            if self._device.status.min_heat_setpoint is not None:
+                return self._device.status.min_heat_setpoint
+        if self._device.status.min_cool_setpoint is not None:
+            return self._device.status.min_cool_setpoint
+        return super().min_temp
+
+    @property
+    def max_temp(self) -> float:
+        """Return the maximum temperature."""
+        if self._effective_mode in ("heat", "autoHeat"):
+            if self._device.status.max_heat_setpoint is not None:
+                return self._device.status.max_heat_setpoint
+        if self._device.status.max_cool_setpoint is not None:
+            return self._device.status.max_cool_setpoint
+        return super().max_temp
+
+    @property
+    def supported_features(self) -> ClimateEntityFeature:
+        """Return the list of supported features."""
+        features = (
+            ClimateEntityFeature.TARGET_TEMPERATURE
+            | ClimateEntityFeature.FAN_MODE
+            | ClimateEntityFeature.TURN_OFF
+        )
+        if Mode.AUTO in self._device.supported_modes:
+            features |= ClimateEntityFeature.TARGET_TEMPERATURE_RANGE
+        if self._device.supported_vane_directions:
+            features |= ClimateEntityFeature.SWING_MODE
+        return features
+
+    async def async_set_hvac_mode(self, hvac_mode: HVACMode) -> None:
+        """Set the HVAC mode."""
+        lib_mode = _HVAC_TO_MODE.get(hvac_mode)
+        if lib_mode is None:
+            return
+        result = await self._device.set_mode(lib_mode)
+        if result.success:
+            self._optimistic[_OPT_MODE] = result.value
+            self.async_write_ha_state()
+
+    async def async_set_temperature(self, **kwargs: Any) -> None:
+        """Set the target temperature."""
+        mode = self._effective_mode
+        wrote = False
+
+        if ATTR_TARGET_TEMP_HIGH in kwargs:
+            result = await self._device.set_cool_setpoint(kwargs[ATTR_TARGET_TEMP_HIGH])
+            if result.success:
+                self._optimistic[_OPT_COOL_SETPOINT] = result.value
+                wrote = True
+
+        if ATTR_TARGET_TEMP_LOW in kwargs:
+            result = await self._device.set_heat_setpoint(kwargs[ATTR_TARGET_TEMP_LOW])
+            if result.success:
+                self._optimistic[_OPT_HEAT_SETPOINT] = result.value
+                wrote = True
+
+        temp = kwargs.get(ATTR_TEMPERATURE)
+        if temp is not None:
+            if mode in ("cool", "autoCool"):
+                result = await self._device.set_cool_setpoint(temp)
+                if result.success:
+                    self._optimistic[_OPT_COOL_SETPOINT] = result.value
+                    wrote = True
+            elif mode in ("heat", "autoHeat"):
+                result = await self._device.set_heat_setpoint(temp)
+                if result.success:
+                    self._optimistic[_OPT_HEAT_SETPOINT] = result.value
+                    wrote = True
+
+        if wrote:
+            self.async_write_ha_state()
+
+    async def async_set_fan_mode(self, fan_mode: str) -> None:
+        """Set the fan mode."""
+        speed = _FAN_SPEED_MAP.get(fan_mode)
+        if speed is None:
+            return
+        result = await self._device.set_fan_speed(speed)
+        if result.success:
+            self._optimistic[_OPT_FAN_SPEED] = result.value
+            self.async_write_ha_state()
+
+    async def async_set_swing_mode(self, swing_mode: str) -> None:
+        """Set the swing mode."""
+        direction = _VANE_DIR_MAP.get(swing_mode)
+        if direction is None:
+            return
+        result = await self._device.set_vane_direction(direction)
+        if result.success:
+            self._optimistic[_OPT_VANE_DIRECTION] = result.value
+            self.async_write_ha_state()
+
+    async def async_turn_off(self) -> None:
+        """Turn the entity off."""
+        await self.async_set_hvac_mode(HVACMode.OFF)
@@ -0,0 +1,73 @@
+"""Config flow for Mitsubishi Comfort integration."""
+
+import logging
+from typing import Any
+
+from mitsubishi_comfort import MitsubishiCloudAccount
+from mitsubishi_comfort.exceptions import AuthenticationError, DeviceConnectionError
+import voluptuous as vol
+
+from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
+from homeassistant.const import CONF_PASSWORD, CONF_USERNAME
+from homeassistant.helpers.aiohttp_client import async_get_clientsession
+
+from .const import DOMAIN
+
+_LOGGER = logging.getLogger(__name__)
+
+USER_SCHEMA = vol.Schema(
+    {
+        vol.Required(CONF_USERNAME): str,
+        vol.Required(CONF_PASSWORD): str,
+    }
+)
+
+
+class MitsubishiComfortConfigFlow(ConfigFlow, domain=DOMAIN):
+    """Handle config flow for Mitsubishi Comfort."""
+
+    VERSION = 1
+
+    async def async_step_user(
+        self, user_input: dict[str, Any] | None = None
+    ) -> ConfigFlowResult:
+        """Handle the user setup step."""
+        errors: dict[str, str] = {}
+
+        if user_input is not None:
+            account = MitsubishiCloudAccount(
+                user_input[CONF_USERNAME],
+                user_input[CONF_PASSWORD],
+                session=async_get_clientsession(self.hass),
+            )
+
+            devices: dict = {}
+            try:
+                await account.login()
+                devices = await account.discover_devices()
+            except AuthenticationError:
+                errors["base"] = "invalid_auth"
+            except DeviceConnectionError:
+                errors["base"] = "cannot_connect"
+            except Exception:
+                _LOGGER.exception("Unexpected error during setup")
+                errors["base"] = "unknown"
+
+            if not errors:
+                await self.async_set_unique_id(account.user_id)
+                self._abort_if_unique_id_configured()
+
+                if not devices:
+                    errors["base"] = "no_devices"
+                else:
+                    return self.async_create_entry(
+                        title=f"Mitsubishi Comfort ({user_input[CONF_USERNAME]})",
+                        data={
+                            CONF_USERNAME: user_input[CONF_USERNAME],
+                            CONF_PASSWORD: user_input[CONF_PASSWORD],
+                        },
+                    )
+
+        return self.async_show_form(
+            step_id="user", data_schema=USER_SCHEMA, errors=errors
+        )
@@ -0,0 +1,12 @@
+"""Constants for the Mitsubishi Comfort integration."""
+
+from datetime import timedelta
+from typing import Final
+
+from homeassistant.const import Platform
+
+DOMAIN: Final = "mitsubishi_comfort"
+PLATFORMS: Final = [Platform.CLIMATE]
+DEFAULT_SCAN_INTERVAL = timedelta(seconds=60)
+DEFAULT_CONNECT_TIMEOUT: Final = 1.2
+DEFAULT_RESPONSE_TIMEOUT: Final = 8.0
@@ -0,0 +1,56 @@
+"""DataUpdateCoordinator for Mitsubishi Comfort devices."""
+
+import logging
+
+from mitsubishi_comfort import IndoorUnit, KumoStation
+
+from homeassistant.config_entries import ConfigEntry
+from homeassistant.core import HomeAssistant
+from homeassistant.helpers.update_coordinator import DataUpdateCoordinator, UpdateFailed
+
+from .const import DEFAULT_SCAN_INTERVAL, DOMAIN
+
+_LOGGER = logging.getLogger(__name__)
+
+type MitsubishiComfortConfigEntry = ConfigEntry[dict[str, MitsubishiComfortCoordinator]]
+
+
+class MitsubishiComfortCoordinator(DataUpdateCoordinator[IndoorUnit | KumoStation]):
+    """Coordinator to poll a single Mitsubishi device."""
+
+    def __init__(
+        self,
+        hass: HomeAssistant,
+        entry: MitsubishiComfortConfigEntry,
+        device: IndoorUnit | KumoStation,
+        mac: str,
+    ) -> None:
+        """Initialize."""
+        super().__init__(
+            hass,
+            _LOGGER,
+            config_entry=entry,
+            name=f"mitsubishi_comfort_{device.serial}",
+            update_interval=DEFAULT_SCAN_INTERVAL,
+        )
+        self.device = device
+        self.mac = mac
+        self.data = device
+
+    async def _async_update_data(self) -> IndoorUnit | KumoStation:
+        """Poll the device and return it."""
+        try:
+            success = await self.device.update_status()
+        except Exception as err:
+            raise UpdateFailed(
+                translation_domain=DOMAIN,
+                translation_key="communication_error",
+                translation_placeholders={"device_name": self.device.name},
+            ) from err
+        if not success:
+            raise UpdateFailed(
+                translation_domain=DOMAIN,
+                translation_key="update_failed",
+                translation_placeholders={"device_name": self.device.name},
+            )
+        return self.device
@@ -0,0 +1,34 @@
+"""Base entity for Mitsubishi Comfort integration."""
+
+from mitsubishi_comfort import IndoorUnit, KumoStation
+
+from homeassistant.helpers.device_registry import CONNECTION_NETWORK_MAC, DeviceInfo
+from homeassistant.helpers.update_coordinator import CoordinatorEntity
+
+from .const import DOMAIN
+from .coordinator import MitsubishiComfortCoordinator
+
+
+class MitsubishiComfortEntity(CoordinatorEntity[MitsubishiComfortCoordinator]):
+    """Base class for all Mitsubishi Comfort entities."""
+
+    _attr_has_entity_name = True
+
+    def __init__(self, coordinator: MitsubishiComfortCoordinator) -> None:
+        """Initialize."""
+        super().__init__(coordinator)
+        device = coordinator.device
+        self._attr_device_info = DeviceInfo(
+            identifiers={(DOMAIN, device.serial)},
+            connections={(CONNECTION_NETWORK_MAC, coordinator.mac)},
+            name=device.name,
+            manufacturer="Mitsubishi",
+            serial_number=device.serial,
+            sw_version=device.status.firmware_version,
+            hw_version=device.status.hardware_version,
+        )
+
+    @property
+    def _device(self) -> IndoorUnit | KumoStation:
+        """Return the underlying device from coordinator data."""
+        return self.coordinator.data
@@ -0,0 +1,11 @@
+{
+  "domain": "mitsubishi_comfort",
+  "name": "Mitsubishi Comfort",
+  "codeowners": ["@nikolairahimi"],
+  "config_flow": true,
+  "documentation": "https://www.home-assistant.io/integrations/mitsubishi_comfort",
+  "integration_type": "hub",
+  "iot_class": "cloud_polling",
+  "quality_scale": "bronze",
+  "requirements": ["mitsubishi-comfort==0.3.0"]
+}
@@ -0,0 +1,72 @@
+rules:
+  # Bronze
+  action-setup:
+    status: exempt
+    comment: No service actions registered.
+  appropriate-polling: done
+  brands: done
+  common-modules: done
+  config-flow: done
+  config-flow-test-coverage: done
+  dependency-transparency: done
+  docs-actions:
+    status: exempt
+    comment: No service actions.
+  docs-high-level-description: done
+  docs-installation-instructions: done
+  docs-removal-instructions: done
+  entity-event-setup: done
+  entity-unique-id: done
+  has-entity-name: done
+  runtime-data: done
+  test-before-configure: done
+  test-before-setup: done
+  unique-config-entry: done
+
+  # Silver
+  config-entry-unloading: done
+  log-when-unavailable: done
+  entity-unavailable: done
+  action-exceptions:
+    status: exempt
+    comment: No service actions registered.
+  reauthentication-flow: todo
+  parallel-updates: todo
+  test-coverage: todo
+  integration-owner: done
+  docs-installation-parameters: done
+  docs-configuration-parameters:
+    status: exempt
+    comment: No options flow.
+
+  # Gold
+  entity-translations: todo
+  entity-device-class: todo
+  devices: done
+  entity-category:
+    status: exempt
+    comment: Single climate entity per device, no diagnostic entities yet.
+  entity-disabled-by-default:
+    status: exempt
+    comment: Single climate entity per device, enabled by default.
+  discovery: todo
+  stale-devices: todo
+  diagnostics: todo
+  exception-translations: todo
+  icon-translations: todo
+  reconfiguration-flow: todo
+  dynamic-devices: todo
+  discovery-update-info: todo
+  repair-issues: todo
+  docs-use-cases: done
+  docs-supported-devices: done
+  docs-supported-functions: done
+  docs-troubleshooting: done
+  docs-data-update: done
+  docs-known-limitations: done
+  docs-examples: done
+
+  # Platinum
+  async-dependency: done
+  inject-websession: done
+  strict-typing: todo
@@ -0,0 +1,36 @@
+{
+  "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%]",
+      "no_devices": "No devices were found on this account",
+      "unknown": "[%key:common::config_flow::error::unknown%]"
+    },
+    "step": {
+      "user": {
+        "data": {
+          "password": "[%key:common::config_flow::data::password%]",
+          "username": "[%key:common::config_flow::data::username%]"
+        },
+        "data_description": {
+          "password": "The password for your Kumo Cloud account.",
+          "username": "The email address for your Kumo Cloud account."
+        }
+      }
+    }
+  },
+  "exceptions": {
+    "communication_error": {
+      "message": "Error communicating with {device_name}"
+    },
+    "no_devices": {
+      "message": "No devices were found in your Mitsubishi Comfort account"
+    },
+    "update_failed": {
+      "message": "{device_name} returned no data"
+    }
+  }
+}
@@ -11,7 +11,12 @@ import voluptuous as vol
 from homeassistant import config as conf_util
 from homeassistant.components import websocket_api
 from homeassistant.config_entries import ConfigEntry
-from homeassistant.const import CONF_DISCOVERY, CONF_PLATFORM, SERVICE_RELOAD
+from homeassistant.const import (
+    CONF_DISCOVERY,
+    CONF_PLATFORM,
+    CONF_PROTOCOL,
+    SERVICE_RELOAD,
+)
 from homeassistant.core import HomeAssistant, ServiceCall, callback
 from homeassistant.exceptions import (
    ConfigValidationError,
@@ -27,6 +32,7 @@ from homeassistant.helpers import (
 from homeassistant.helpers.device_registry import DeviceEntry
 from homeassistant.helpers.dispatcher import async_dispatcher_connect
 from homeassistant.helpers.entity_platform import async_get_platforms
+from homeassistant.helpers.issue_registry import IssueSeverity, async_create_issue
 from homeassistant.helpers.reload import async_integration_yaml_config
 from homeassistant.helpers.service import async_register_admin_service
 from homeassistant.helpers.typing import ConfigType
@@ -73,12 +79,14 @@ from .const import (
    DEFAULT_DISCOVERY,
    DEFAULT_ENCODING,
    DEFAULT_PREFIX,
+    DEFAULT_PROTOCOL,
    DEFAULT_QOS,
    DEFAULT_RETAIN,
    DOMAIN,
    ENTITY_PLATFORMS,
    ENTRY_OPTION_FIELDS,
    MQTT_CONNECTION_STATE,
+    PROTOCOL_311,
    TEMPLATE_ERRORS,
    Platform,
 )
@@ -424,6 +432,26 @@ async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
    """Load a config entry."""
    mqtt_data: MqttData

+    if (protocol := entry.data.get(CONF_PROTOCOL, PROTOCOL_311)) != DEFAULT_PROTOCOL:
+        broker: str = entry.data[CONF_BROKER]
+        async_create_issue(
+            hass,
+            DOMAIN,
+            "protocol_5_migration",
+            issue_domain=DOMAIN,
+            is_fixable=True,
+            breaks_in_ha_version="2027.1.0",
+            severity=IssueSeverity.WARNING,
+            learn_more_url="https://www.home-assistant.io/integrations/mqtt/#mqtt-protocol",
+            data={
+                "entry_id": entry.entry_id,
+                "broker": broker,
+                "protocol": protocol,
+            },
+            translation_placeholders={"broker": broker, "protocol": protocol},
+            translation_key="protocol_5_migration",
+        )
+
    async def _setup_client() -> tuple[MqttData, dict[str, Any]]:
        """Set up the MQTT client."""
        # Fetch configuration
@@ -63,7 +63,6 @@ from .const import (
    DEFAULT_ENCODING,
    DEFAULT_KEEPALIVE,
    DEFAULT_PORT,
-    DEFAULT_PROTOCOL,
    DEFAULT_QOS,
    DEFAULT_TRANSPORT,
    DEFAULT_WILL,
@@ -74,6 +73,7 @@ from .const import (
    MQTT_PROCESSED_SUBSCRIPTIONS,
    PROTOCOL_5,
    PROTOCOL_31,
+    PROTOCOL_311,
    TRANSPORT_WEBSOCKETS,
 )
 from .models import (
@@ -331,7 +331,10 @@ class MqttClientSetup:

        config = self._config
        clean_session: bool | None = None
-        if (protocol := config.get(CONF_PROTOCOL, DEFAULT_PROTOCOL)) == PROTOCOL_31:
+        # If no protocol setting is set in the config entry data
+        # we assume the config was migrated from YAML, and the
+        # protocol version is defaulting to legacy version 3.1.1.
+        if (protocol := config.get(CONF_PROTOCOL, PROTOCOL_311)) == PROTOCOL_31:
            proto = mqtt.MQTTv31
            clean_session = True
        elif protocol == PROTOCOL_5:
@@ -420,7 +423,10 @@ class MQTT:
        self.loop = hass.loop
        self.config_entry = config_entry
        self.conf = conf
-        self.is_mqttv5 = conf.get(CONF_PROTOCOL, DEFAULT_PROTOCOL) == PROTOCOL_5
+        # If no protocol setting is set in the config entry data
+        # we assume the config was migrated from YAML, and the
+        # protocol version is defaulting to legacy version 3.1.1.
+        self.is_mqttv5 = conf.get(CONF_PROTOCOL, PROTOCOL_311) == PROTOCOL_5

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

+        if CONF_PROTOCOL not in validated_user_input:
+            validated_user_input[CONF_PROTOCOL] = DEFAULT_PROTOCOL
        # Get current certificate settings from config entry
        certificate: str | None = (
            "auto"
@@ -347,14 +347,14 @@ REMOTE_CODE_TEXT = "REMOTE_CODE_TEXT"
 PROTOCOL_31 = "3.1"
 PROTOCOL_311 = "3.1.1"
 PROTOCOL_5 = "5"
-SUPPORTED_PROTOCOLS = [PROTOCOL_31, PROTOCOL_311, PROTOCOL_5]
+SUPPORTED_PROTOCOLS = [PROTOCOL_5, PROTOCOL_311, PROTOCOL_31]

 TRANSPORT_TCP = "tcp"
 TRANSPORT_WEBSOCKETS = "websockets"

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

 DEFAULT_BIRTH = {
@@ -6,10 +6,16 @@ import voluptuous as vol

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

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


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


+class MQTTProtocolV5Migration(RepairsFlow):
+    """Handler to migrate to MQTT protocol version 5."""
+
+    def __init__(self, entry_id: str, broker: str, protocol: str) -> None:
+        """Initialize the flow."""
+        self.entry_id = entry_id
+        self.broker = broker
+        self.protocol = protocol
+
+    async def async_step_init(
+        self, user_input: dict[str, str] | None = None
+    ) -> data_entry_flow.FlowResult:
+        """Handle the first step of a fix flow."""
+        return await self.async_step_confirm()
+
+    async def async_step_confirm(
+        self, user_input: dict[str, str] | None = None
+    ) -> data_entry_flow.FlowResult:
+        """Handle the confirm step of a fix flow."""
+        if user_input is not None:
+            entry = self.hass.config_entries.async_get_entry(self.entry_id)
+            if TYPE_CHECKING:
+                assert entry is not None
+            new_entry_data = entry.data.copy()
+            new_entry_data[CONF_PROTOCOL] = PROTOCOL_5
+            # Try the connection with protocol version 5
+            if await self.hass.async_add_executor_job(
+                try_connection,
+                {CONF_PORT: DEFAULT_PORT} | new_entry_data,
+            ):
+                self.hass.config_entries.async_update_entry(entry, data=new_entry_data)
+                return self.async_create_entry(data={})
+
+            return self.async_abort(
+                reason="mqtt_broker_migration_to_v5_failed",
+                description_placeholders={
+                    "broker": self.broker,
+                    "protocol": self.protocol,
+                    "url_mqtt_broker_configuration": URL_MQTT_BROKER_CONFIGURATION,
+                },
+            )
+
+        return self.async_show_form(
+            step_id="confirm",
+            data_schema=vol.Schema({}),
+            description_placeholders={"broker": self.broker, "protocol": self.protocol},
+        )
+
+
 async def async_create_fix_flow(
    hass: HomeAssistant,
    issue_id: str,
@@ -58,13 +113,13 @@ async def async_create_fix_flow(
    """Create flow."""
    if TYPE_CHECKING:
        assert data is not None
-    entry_id = data["entry_id"]
-    subentry_id = data["subentry_id"]
-    name = data["name"]
-    if TYPE_CHECKING:
-        assert isinstance(entry_id, str)
-        assert isinstance(subentry_id, str)
-        assert isinstance(name, str)
+    entry_id: str = data["entry_id"]  # type: ignore[assignment]
+    if issue_id == "protocol_5_migration":
+        broker: str = data["broker"]  # type: ignore[assignment]
+        protocol: str = data["protocol"]  # type: ignore[assignment]
+        return MQTTProtocolV5Migration(entry_id, broker, protocol)
+    subentry_id: str = data["subentry_id"]  # type: ignore[assignment]
+    name: str = data["name"]  # type: ignore[assignment]
    return MQTTDeviceEntryMigration(
        entry_id=entry_id,
        subentry_id=subentry_id,
@@ -1120,6 +1120,20 @@
      "description": "Home Assistant detected an invalid config for a manually configured item.\n\nPlatform domain: **{domain}**\nConfiguration file: **{config_file}**\nNear line: **{line}**\nConfiguration found:\n```yaml\n{config}\n```\nError: **{error}**.\n\nMake sure the configuration is valid and [reload](/config/developer-tools/yaml) the manually configured MQTT items or restart Home Assistant to fix this issue.",
      "title": "Invalid config found for MQTT {domain} item"
    },
+    "protocol_5_migration": {
+      "fix_flow": {
+        "abort": {
+          "mqtt_broker_migration_to_v5_failed": "Migrating the broker ({broker}) protocol version from {protocol} to 5 failed, and the migration has been aborted.\n\nYour broker may not support MQTT protocol version 5.\n\nPlease [reconfigure your MQTT broker settings]({url_mqtt_broker_configuration}) or upgrade your broker to support MQTT protocol version 5 to fix this issue."
+        },
+        "step": {
+          "confirm": {
+            "description": "Home Assistant is migrating to MQTT protocol version 5. The currently configured protocol version for broker {broker} is {protocol}. This protocol version is deprecated, and support for it will be removed.\n\nSubmitting this form will try to migrate your MQTT broker configuration to use protocol version 5 to fix this issue.",
+            "title": "MQTT protocol change required"
+          }
+        }
+      },
+      "title": "Deprecated MQTT protocol {protocol} in use"
+    },
    "subentry_migration_discovery": {
      "fix_flow": {
        "step": {
@@ -0,0 +1,81 @@
+"""Binary sensor platform for Nord Pool integration."""
+
+from collections.abc import Callable
+from dataclasses import dataclass
+
+from homeassistant.components.binary_sensor import (
+    BinarySensorEntity,
+    BinarySensorEntityDescription,
+)
+from homeassistant.components.sensor import EntityCategory
+from homeassistant.core import HomeAssistant
+from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
+
+from . import NordPoolConfigEntry
+from .const import CONF_AREAS
+from .coordinator import NordPoolDataUpdateCoordinator
+from .entity import NordpoolBaseEntity
+
+PARALLEL_UPDATES = 0
+
+
+def get_tomorrow_price_available(
+    entity: NordpoolPriceBinarySensor,
+) -> bool:
+    """Return tomorrow price availability."""
+    data = entity.coordinator.get_data_tomorrow()
+    return bool(data and data.entries and entity.area in data.entries[0].entry)
+
+
+@dataclass(frozen=True, kw_only=True)
+class NordpoolBinarySensorEntityDescription(BinarySensorEntityDescription):
+    """Describes Nord Pool binary sensor entity."""
+
+    value_fn: Callable[[NordpoolPriceBinarySensor], bool | None]
+
+
+BINARY_SENSOR_TYPES: tuple[NordpoolBinarySensorEntityDescription, ...] = (
+    NordpoolBinarySensorEntityDescription(
+        key="tomorrow_price_available",
+        translation_key="tomorrow_price_available",
+        value_fn=get_tomorrow_price_available,
+        entity_category=EntityCategory.DIAGNOSTIC,
+    ),
+)
+
+
+async def async_setup_entry(
+    hass: HomeAssistant,
+    entry: NordPoolConfigEntry,
+    async_add_entities: AddConfigEntryEntitiesCallback,
+) -> None:
+    """Set up Nord Pool binary sensor platform."""
+
+    coordinator = entry.runtime_data
+    areas = coordinator.config_entry.data[CONF_AREAS]
+
+    async_add_entities(
+        NordpoolPriceBinarySensor(coordinator, description, area)
+        for description in BINARY_SENSOR_TYPES
+        for area in areas
+    )
+
+
+class NordpoolPriceBinarySensor(NordpoolBaseEntity, BinarySensorEntity):
+    """Representation of a Nord Pool binary sensor."""
+
+    entity_description: NordpoolBinarySensorEntityDescription
+
+    def __init__(
+        self,
+        coordinator: NordPoolDataUpdateCoordinator,
+        entity_description: NordpoolBinarySensorEntityDescription,
+        area: str,
+    ) -> None:
+        """Initiate Nord Pool binary sensor."""
+        super().__init__(coordinator, entity_description, area)
+
+    @property
+    def is_on(self) -> bool | None:
+        """Return true if the binary sensor is on."""
+        return self.entity_description.value_fn(self)
@@ -8,7 +8,7 @@ LOGGER = logging.getLogger(__package__)

 DEFAULT_SCAN_INTERVAL = 60
 DOMAIN = "nordpool"
-PLATFORMS = [Platform.SENSOR]
+PLATFORMS = [Platform.BINARY_SENSOR, Platform.SENSOR]
 DEFAULT_NAME = "Nord Pool"

 CONF_AREAS = "areas"
@@ -164,3 +164,8 @@ class NordPoolDataUpdateCoordinator(DataUpdateCoordinator[DeliveryPeriodsData]):
        """Return the current day data."""
        current_day = dt_util.now().date()
        return self.data.entries[current_day]
+
+    def get_data_tomorrow(self) -> DeliveryPeriodData | None:
+        """Return tomorrow's day data if available."""
+        tomorrow = dt_util.now().date() + timedelta(days=1)
+        return self.data.entries.get(tomorrow)
@@ -32,6 +32,11 @@
    }
  },
  "entity": {
+    "binary_sensor": {
+      "tomorrow_price_available": {
+        "name": "Tomorrow price available"
+      }
+    },
    "sensor": {
      "block_average": {
        "name": "{block} average"
@@ -72,7 +72,6 @@ UNSUPPORTED_MODELS: list[str] = [
 ]

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

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

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

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

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

-from __future__ import annotations
-
 import voluptuous as vol

 from homeassistant.components.cover import (
@@ -1,4 +1,12 @@
 """Constants for OwnTracks."""

-DOMAIN = "owntracks"
-ATTR_UPDATE_TIMESTAMP = "update_timestamp"
+from typing import Final
+
+DOMAIN: Final = "owntracks"
+
+ATTR_ADDRESS: Final = "address"
+ATTR_BATTERY_STATUS: Final = "battery_status"
+ATTR_COURSE: Final = "course"
+ATTR_TID: Final = "tid"
+ATTR_UPDATE_TIMESTAMP: Final = "update_timestamp"
+ATTR_VELOCITY: Final = "velocity"
@@ -21,8 +21,26 @@ from homeassistant.helpers import device_registry as dr
 from homeassistant.helpers.device_registry import DeviceInfo
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from homeassistant.helpers.restore_state import RestoreEntity
+from homeassistant.util import dt as dt_util

-from .const import DOMAIN
+from .const import (
+    ATTR_ADDRESS,
+    ATTR_BATTERY_STATUS,
+    ATTR_COURSE,
+    ATTR_TID,
+    ATTR_UPDATE_TIMESTAMP,
+    ATTR_VELOCITY,
+    DOMAIN,
+)
+
+_RESTORED_OWNTRACKS_ATTRIBUTES: tuple[str, ...] = (
+    ATTR_ADDRESS,
+    ATTR_BATTERY_STATUS,
+    ATTR_COURSE,
+    ATTR_TID,
+    ATTR_UPDATE_TIMESTAMP,
+    ATTR_VELOCITY,
+)


 async def async_setup_entry(
@@ -141,12 +159,19 @@ class OwnTracksEntity(TrackerEntity, RestoreEntity):
            return

        attr = state.attributes
+        attributes = {
+            key: attr[key] for key in _RESTORED_OWNTRACKS_ATTRIBUTES if key in attr
+        }
+        if isinstance(update_timestamp := attributes.get(ATTR_UPDATE_TIMESTAMP), str):
+            attributes[ATTR_UPDATE_TIMESTAMP] = dt_util.parse_datetime(update_timestamp)
+
        self._data = {
            "host_name": state.name,
            "gps": (attr.get(ATTR_LATITUDE), attr.get(ATTR_LONGITUDE)),
            "gps_accuracy": attr.get(ATTR_GPS_ACCURACY),
            "battery": attr.get(ATTR_BATTERY_LEVEL),
            "source_type": attr.get(ATTR_SOURCE_TYPE),
+            "attributes": attributes,
        }

    @callback
@@ -11,7 +11,14 @@ from homeassistant.components.device_tracker import SourceType
 from homeassistant.const import ATTR_LATITUDE, ATTR_LONGITUDE, STATE_HOME
 from homeassistant.util import decorator, dt as dt_util, slugify

-from .const import ATTR_UPDATE_TIMESTAMP
+from .const import (
+    ATTR_ADDRESS,
+    ATTR_BATTERY_STATUS,
+    ATTR_COURSE,
+    ATTR_TID,
+    ATTR_UPDATE_TIMESTAMP,
+    ATTR_VELOCITY,
+)
 from .helper import supports_encryption

 _LOGGER = logging.getLogger(__name__)
@@ -72,15 +79,15 @@ def _parse_see_args(message, subscribe_topic):
    if "batt" in message:
        kwargs["battery"] = message["batt"]
    if "vel" in message:
-        kwargs["attributes"]["velocity"] = message["vel"]
+        kwargs["attributes"][ATTR_VELOCITY] = message["vel"]
    if "tid" in message:
-        kwargs["attributes"]["tid"] = message["tid"]
+        kwargs["attributes"][ATTR_TID] = message["tid"]
    if "addr" in message:
-        kwargs["attributes"]["address"] = message["addr"]
+        kwargs["attributes"][ATTR_ADDRESS] = message["addr"]
    if "cog" in message:
-        kwargs["attributes"]["course"] = message["cog"]
+        kwargs["attributes"][ATTR_COURSE] = message["cog"]
    if "bs" in message:
-        kwargs["attributes"]["battery_status"] = message["bs"]
+        kwargs["attributes"][ATTR_BATTERY_STATUS] = message["bs"]
    if "t" in message:
        if message["t"] in ("c", "u"):
            kwargs["source_type"] = SourceType.GPS
@@ -236,5 +236,10 @@
      },
      "name": "Prune unused images"
    }
+  },
+  "system_health": {
+    "info": {
+      "can_reach_server": "Reach Portainer server"
+    }
  }
 }
@@ -0,0 +1,28 @@
+"""Provide info to system health."""
+
+from typing import Any
+
+from homeassistant.components import system_health
+from homeassistant.const import CONF_URL
+from homeassistant.core import HomeAssistant, callback
+
+from .const import DOMAIN
+
+
+@callback
+def async_register(
+    hass: HomeAssistant, register: system_health.SystemHealthRegistration
+) -> None:
+    """Register system health callbacks."""
+    register.async_register_info(system_health_info)
+
+
+async def system_health_info(hass: HomeAssistant) -> dict[str, Any]:
+    """Get info for the info page."""
+    config_entry = hass.config_entries.async_entries(DOMAIN)[0]
+
+    return {
+        "can_reach_server": system_health.async_check_can_reach_url(
+            hass, f"{config_entry.data[CONF_URL].rstrip('/')}/api/system/status"
+        ),
+    }
@@ -0,0 +1,46 @@
+"""The PTDevices integration."""
+
+from aioptdevices.configuration import Configuration
+from aioptdevices.interface import Interface
+
+from homeassistant.const import CONF_API_TOKEN, Platform
+from homeassistant.core import HomeAssistant
+from homeassistant.helpers.aiohttp_client import async_get_clientsession
+
+from .const import DEFAULT_URL
+from .coordinator import PTDevicesConfigEntry, PTDevicesCoordinator
+
+_PLATFORMS: list[Platform] = [
+    Platform.SENSOR,
+]
+
+
+async def async_setup_entry(
+    hass: HomeAssistant, config_entry: PTDevicesConfigEntry
+) -> bool:
+    """Set up PTDevices from a config entry."""
+    auth_token: str = config_entry.data[CONF_API_TOKEN]
+    session = async_get_clientsession(hass)
+    ptdevices_interface = Interface(
+        Configuration(
+            auth_token=auth_token,
+            device_id="*",  # Retrieve data for all devices in account
+            url=DEFAULT_URL,
+            session=session,
+        )
+    )
+
+    config_entry.runtime_data = coordinator = PTDevicesCoordinator(
+        hass,
+        config_entry,
+        ptdevices_interface,
+    )
+    await coordinator.async_config_entry_first_refresh()
+    await hass.config_entries.async_forward_entry_setups(config_entry, _PLATFORMS)
+
+    return True
+
+
+async def async_unload_entry(hass: HomeAssistant, entry: PTDevicesConfigEntry) -> bool:
+    """Unload a config entry."""
+    return await hass.config_entries.async_unload_platforms(entry, _PLATFORMS)
@@ -0,0 +1,118 @@
+"""Config flow for PTDevices integration."""
+
+import logging
+from typing import Any
+
+import aioptdevices
+from aioptdevices.configuration import Configuration
+from aioptdevices.interface import Interface
+import voluptuous as vol
+
+from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
+from homeassistant.const import CONF_API_TOKEN
+from homeassistant.core import HomeAssistant
+from homeassistant.exceptions import HomeAssistantError
+from homeassistant.helpers.aiohttp_client import async_get_clientsession
+
+from .const import DEFAULT_URL, DOMAIN
+
+_LOGGER = logging.getLogger(__name__)
+
+_CONF_SCHEMA = vol.Schema(
+    {
+        vol.Required(CONF_API_TOKEN): str,
+    }
+)
+
+
+async def validate_input(hass: HomeAssistant, data: dict[str, Any]) -> tuple[str, str]:
+    """Validate the user input allows us to connect.
+
+    Data has the keys from STEP_USER_DATA_SCHEMA with values provided by the user.
+    """
+
+    session = async_get_clientsession(hass)
+    ptdevices_interface = Interface(
+        Configuration(
+            auth_token=data[CONF_API_TOKEN],
+            device_id="*",  # Retrieve data for all devices in account
+            url=DEFAULT_URL,
+            session=session,
+        )
+    )
+
+    # Test Connection
+    try:
+        response = await ptdevices_interface.get_data()
+    except aioptdevices.PTDevicesRequestError as err:
+        raise CannotConnect from err
+
+    except aioptdevices.PTDevicesUnauthorizedError as err:
+        raise InvalidAuth from err
+
+    body = response["body"]
+
+    # Ensure the first device exists
+    first_device = next(iter(body.values()), None)
+    if first_device is None:
+        raise NoDevicesFound
+
+    user_name = first_device.get("user_name")
+    user_id = first_device.get("user_id")
+
+    title: str = str(user_name)
+    unique_id: str = str(user_id)
+
+    # Return title to be used for hub name
+    return (title, unique_id)
+
+
+class PTDevicesConfigFlow(ConfigFlow, domain=DOMAIN):
+    """Handle a config flow for PTDevices."""
+
+    VERSION = 1
+    MINOR_VERSION = 1
+
+    async def async_step_user(
+        self, user_input: dict[str, Any] | None = None
+    ) -> ConfigFlowResult:
+        """Handle the initial step."""
+
+        errors: dict[str, str] = {}
+
+        # Test connection when user data is available
+        if user_input is not None:
+            # Test connection
+            try:
+                title, unique_id = await validate_input(self.hass, user_input)
+            except CannotConnect:
+                errors["base"] = "cannot_connect"
+            except InvalidAuth:
+                errors["base"] = "invalid_access_token"
+            except NoDevicesFound:
+                errors["base"] = "no_devices_found"
+            except Exception:
+                _LOGGER.exception("Unexpected exception")
+                errors["base"] = "unknown"
+            else:
+                # Connection Successful
+                await self.async_set_unique_id(unique_id)
+                self._abort_if_unique_id_configured()
+                return self.async_create_entry(title=title, data=user_input)
+
+        # Show setup form
+        return self.async_show_form(
+            step_id="user", data_schema=_CONF_SCHEMA, errors=errors
+        )
+
+
+class CannotConnect(HomeAssistantError):
+    """Error to indicate we cannot connect."""
+
+
+class InvalidAuth(HomeAssistantError):
+    """Error to indicate there is invalid auth."""
+
+
+class NoDevicesFound(HomeAssistantError):
+    """No devices were found in the account."""
@@ -0,0 +1,4 @@
+"""Constants for the PTDevices integration."""
+
+DOMAIN = "ptdevices"
+DEFAULT_URL = "https://api.ptdevices.com/token/v1"
@@ -0,0 +1,88 @@
+"""Coordinator for PTDevices integration."""
+
+from datetime import timedelta
+import logging
+from typing import Final
+
+import aioptdevices
+from aioptdevices.interface import Interface, PTDevicesResponseData
+
+from homeassistant.config_entries import ConfigEntry
+from homeassistant.core import HomeAssistant
+from homeassistant.helpers import device_registry as dr
+from homeassistant.helpers.debounce import Debouncer
+from homeassistant.helpers.update_coordinator import (
+    REQUEST_REFRESH_DEFAULT_IMMEDIATE,
+    DataUpdateCoordinator,
+    UpdateFailed,
+)
+
+from .const import DOMAIN
+
+_LOGGER = logging.getLogger(__name__)
+REFRESH_COOLDOWN: Final = 30
+UPDATE_INTERVAL = timedelta(seconds=60)
+
+type PTDevicesConfigEntry = ConfigEntry[PTDevicesCoordinator]
+
+
+class PTDevicesCoordinator(DataUpdateCoordinator[PTDevicesResponseData]):
+    """Class for interacting with PTDevices get_data."""
+
+    config_entry: PTDevicesConfigEntry
+
+    def __init__(
+        self,
+        hass: HomeAssistant,
+        config_entry: PTDevicesConfigEntry,
+        ptdevices_interface: Interface,
+    ) -> None:
+        """Initialize the coordinator."""
+        super().__init__(
+            hass,
+            _LOGGER,
+            config_entry=config_entry,
+            name=DOMAIN,
+            update_interval=UPDATE_INTERVAL,
+            request_refresh_debouncer=Debouncer(
+                hass,
+                _LOGGER,
+                immediate=REQUEST_REFRESH_DEFAULT_IMMEDIATE,
+                cooldown=REFRESH_COOLDOWN,
+            ),
+        )
+
+        self.interface = ptdevices_interface
+
+    async def _async_update_data(self) -> PTDevicesResponseData:
+        try:
+            data = await self.interface.get_data()
+        except aioptdevices.PTDevicesRequestError as err:
+            raise UpdateFailed(
+                translation_domain=DOMAIN,
+                translation_key="cannot_connect",
+                translation_placeholders={"error": repr(err)},
+            ) from err
+        except aioptdevices.PTDevicesUnauthorizedError as err:
+            raise UpdateFailed(
+                translation_domain=DOMAIN,
+                translation_key="invalid_access_token",
+                translation_placeholders={"error": repr(err)},
+            ) from err
+
+        # Purge stale devices
+        device_reg = dr.async_get(self.hass)
+        identifiers = {
+            (DOMAIN, f"{device_data['user_id']}_{device_id}")
+            for device_id, device_data in data["body"].items()
+        }
+        for device in dr.async_entries_for_config_entry(
+            device_reg, self.config_entry.entry_id
+        ):
+            if not set(device.identifiers) & identifiers:
+                _LOGGER.debug("Removing stale device entry %s", device.name)
+                device_reg.async_update_device(
+                    device.id, remove_config_entry_id=self.config_entry.entry_id
+                )
+
+        return data["body"]
@@ -0,0 +1,49 @@
+"""PTDevices integration."""
+
+from typing import Any
+
+from homeassistant.helpers.device_registry import CONNECTION_NETWORK_MAC, DeviceInfo
+from homeassistant.helpers.update_coordinator import CoordinatorEntity
+
+from .const import DOMAIN
+from .coordinator import PTDevicesCoordinator
+
+
+class PTDevicesEntity(CoordinatorEntity[PTDevicesCoordinator]):
+    """Defines a base PTDevices entity."""
+
+    _attr_has_entity_name = True
+
+    def __init__(
+        self,
+        coordinator: PTDevicesCoordinator,
+        sensor_key: str,
+        device_id: str,
+    ) -> None:
+        """Initialize."""
+        super().__init__(coordinator=coordinator)
+        self._sensor_key = sensor_key
+        self._device_id = device_id
+        self._user_id = coordinator.data[self._device_id]["user_id"]
+
+        self._attr_unique_id = f"{self._user_id}_{device_id}_{sensor_key}"
+
+        self._attr_device_info = DeviceInfo(
+            identifiers={(DOMAIN, f"{self._user_id}_{self._device_id}")},
+            connections={(CONNECTION_NETWORK_MAC, self._device_id)},
+            configuration_url=f"https://www.ptdevices.com/device/level/{self.device['id']}",
+            manufacturer="ParemTech Inc.",
+            model=self.device["device_type"],
+            sw_version=str(self.device["version"]),
+            name=self.device["title"],
+        )
+
+    @property
+    def device(self) -> dict[str, Any]:
+        """Return the device data."""
+        return self.coordinator.data[self._device_id]
+
+    @property
+    def available(self) -> bool:
+        """Return if the device is available."""
+        return super().available and self._device_id in self.coordinator.data
@@ -0,0 +1,30 @@
+{
+  "entity": {
+    "sensor": {
+      "battery_voltage": {
+        "default": "mdi:battery"
+      },
+      "depth_level": {
+        "default": "mdi:water"
+      },
+      "percent_level": {
+        "default": "mdi:water-percent"
+      },
+      "probe_temperature": {
+        "default": "mdi:thermometer"
+      },
+      "status": {
+        "default": "mdi:information-outline"
+      },
+      "tx_signal": {
+        "default": "mdi:wifi"
+      },
+      "volume_level": {
+        "default": "mdi:water"
+      },
+      "wifi_signal": {
+        "default": "mdi:wifi"
+      }
+    }
+  }
+}
@@ -0,0 +1,12 @@
+{
+  "domain": "ptdevices",
+  "name": "PTDevices",
+  "codeowners": ["@ParemTech-Inc", "@frogman85978"],
+  "config_flow": true,
+  "documentation": "https://www.home-assistant.io/integrations/ptdevices",
+  "integration_type": "hub",
+  "iot_class": "cloud_polling",
+  "loggers": ["aioptdevices"],
+  "quality_scale": "bronze",
+  "requirements": ["aioptdevices==2026.03.2"]
+}
@@ -0,0 +1,75 @@
+rules:
+  # Bronze
+  action-setup:
+    status: exempt
+    comment: |
+      This integration does not provide any actions.
+  appropriate-polling: done
+  brands: done
+  common-modules: done
+  config-flow-test-coverage: done
+  config-flow: done
+  dependency-transparency: done
+  docs-actions:
+    status: exempt
+    comment: |
+      This 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:
+    status: exempt
+    comment: |
+      This integration does not provide any actions.
+  config-entry-unloading: done
+  docs-configuration-parameters:
+    status: exempt
+    comment: |
+      This integration does not provide any additional options.
+  docs-installation-parameters: done
+  entity-unavailable: done
+  integration-owner: done
+  log-when-unavailable: done
+  parallel-updates: done
+  reauthentication-flow: todo
+  test-coverage: todo
+
+  # Gold
+  devices: done
+  diagnostics: todo
+  discovery-update-info: todo
+  discovery: todo
+  docs-data-update: done
+  docs-examples: done
+  docs-known-limitations: done
+  docs-supported-devices: done
+  docs-supported-functions: done
+  docs-troubleshooting: todo
+  docs-use-cases: done
+  dynamic-devices: done
+  entity-category: done
+  entity-device-class: done
+  entity-disabled-by-default: done
+  entity-translations: done
+  exception-translations: done
+  icon-translations: done
+  reconfiguration-flow: todo
+  repair-issues: todo
+  stale-devices: done
+
+  # Platinum
+  async-dependency: done
+  inject-websession: done
+  strict-typing: done
@@ -0,0 +1,203 @@
+"""Sensors for PTDevices device."""
+
+from collections.abc import Callable
+from dataclasses import dataclass
+from enum import StrEnum
+from typing import cast
+
+from aioptdevices.interface import PTDevicesStatusStates
+
+from homeassistant.components.sensor import (
+    SensorDeviceClass,
+    SensorEntity,
+    SensorEntityDescription,
+    SensorStateClass,
+)
+from homeassistant.const import (
+    PERCENTAGE,
+    SIGNAL_STRENGTH_DECIBELS_MILLIWATT,
+    EntityCategory,
+    UnitOfElectricPotential,
+    UnitOfLength,
+    UnitOfTemperature,
+    UnitOfVolume,
+)
+from homeassistant.core import HomeAssistant
+from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
+
+from .coordinator import PTDevicesConfigEntry, PTDevicesCoordinator
+from .entity import PTDevicesEntity
+
+# Coordinator is used to centralize the data updates
+PARALLEL_UPDATES = 0
+
+
+class PTDevicesSensors(StrEnum):
+    """Store keys for PTDevices sensors."""
+
+    LEVEL_PERCENT = "percent_level"
+    LEVEL_VOLUME = "volume_level"
+    LEVEL_DEPTH = "depth_level"
+    PROBE_TEMPERATURE = "probe_temperature"
+    DEVICE_STATUS = "status"
+    DEVICE_WIFI_STRENGTH = "wifi_signal"
+    DEVICE_BATTERY_VOLTAGE = "battery_voltage"
+    TX_SIGNAL_STRENGTH = "tx_signal"
+
+
+@dataclass(kw_only=True, frozen=True)
+class PTDevicesSensorEntityDescription(SensorEntityDescription):
+    """Description for PTDevices sensor entities."""
+
+    value_fn: Callable[[dict[str, str | int | float | None]], str | int | float | None]
+
+
+SENSOR_DESCRIPTIONS: tuple[PTDevicesSensorEntityDescription, ...] = (
+    # Percent of water in the tank
+    PTDevicesSensorEntityDescription(
+        key=PTDevicesSensors.LEVEL_PERCENT,
+        translation_key=PTDevicesSensors.LEVEL_PERCENT,
+        native_unit_of_measurement=PERCENTAGE,
+        state_class=SensorStateClass.MEASUREMENT,
+        value_fn=lambda data: cast(float, data.get(PTDevicesSensors.LEVEL_PERCENT)),
+    ),
+    # Volume of water in the tank (Liters)
+    PTDevicesSensorEntityDescription(
+        key=PTDevicesSensors.LEVEL_VOLUME,
+        translation_key=PTDevicesSensors.LEVEL_VOLUME,
+        native_unit_of_measurement=UnitOfVolume.LITERS,
+        device_class=SensorDeviceClass.VOLUME_STORAGE,
+        state_class=SensorStateClass.MEASUREMENT,
+        value_fn=lambda data: cast(float, data.get(PTDevicesSensors.LEVEL_VOLUME)),
+    ),
+    # Depth of water in the tank (Meters)
+    PTDevicesSensorEntityDescription(
+        key=PTDevicesSensors.LEVEL_DEPTH,
+        translation_key=PTDevicesSensors.LEVEL_DEPTH,
+        native_unit_of_measurement=UnitOfLength.METERS,
+        device_class=SensorDeviceClass.DISTANCE,
+        state_class=SensorStateClass.MEASUREMENT,
+        value_fn=lambda data: cast(float, data.get(PTDevicesSensors.LEVEL_DEPTH)),
+        suggested_display_precision=3,
+    ),
+    # Temperature measured by external temperature probe (Celsius)
+    PTDevicesSensorEntityDescription(
+        key=PTDevicesSensors.PROBE_TEMPERATURE,
+        translation_key=PTDevicesSensors.PROBE_TEMPERATURE,
+        native_unit_of_measurement=UnitOfTemperature.CELSIUS,
+        device_class=SensorDeviceClass.TEMPERATURE,
+        state_class=SensorStateClass.MEASUREMENT,
+        value_fn=lambda data: cast(float, data.get(PTDevicesSensors.PROBE_TEMPERATURE)),
+    ),
+    # Status of the device
+    PTDevicesSensorEntityDescription(
+        key=PTDevicesSensors.DEVICE_STATUS,
+        translation_key=PTDevicesSensors.DEVICE_STATUS,
+        device_class=SensorDeviceClass.ENUM,
+        options=[
+            member.value
+            for member in PTDevicesStatusStates
+            if member.value != "unknown"
+        ],
+        value_fn=lambda data: (
+            cast(str, data.get(PTDevicesSensors.DEVICE_STATUS))
+            if cast(str, data.get(PTDevicesSensors.DEVICE_STATUS)) != "unknown"
+            else None
+        ),
+    ),
+    # Wifi signal strength (%)
+    PTDevicesSensorEntityDescription(
+        key=PTDevicesSensors.DEVICE_WIFI_STRENGTH,
+        translation_key=PTDevicesSensors.DEVICE_WIFI_STRENGTH,
+        native_unit_of_measurement=PERCENTAGE,
+        entity_registry_enabled_default=False,
+        entity_category=EntityCategory.DIAGNOSTIC,
+        state_class=SensorStateClass.MEASUREMENT,
+        value_fn=lambda data: cast(
+            int, data.get(PTDevicesSensors.DEVICE_WIFI_STRENGTH)
+        ),
+    ),
+    # LoRa signal strength (dBm)
+    PTDevicesSensorEntityDescription(
+        key=PTDevicesSensors.TX_SIGNAL_STRENGTH,
+        translation_key=PTDevicesSensors.TX_SIGNAL_STRENGTH,
+        native_unit_of_measurement=SIGNAL_STRENGTH_DECIBELS_MILLIWATT,
+        entity_registry_enabled_default=False,
+        device_class=SensorDeviceClass.SIGNAL_STRENGTH,
+        entity_category=EntityCategory.DIAGNOSTIC,
+        state_class=SensorStateClass.MEASUREMENT,
+        value_fn=lambda data: cast(
+            float, data.get(PTDevicesSensors.TX_SIGNAL_STRENGTH)
+        ),
+    ),
+    # Battery voltage (Volts)
+    PTDevicesSensorEntityDescription(
+        key=PTDevicesSensors.DEVICE_BATTERY_VOLTAGE,
+        translation_key=PTDevicesSensors.DEVICE_BATTERY_VOLTAGE,
+        device_class=SensorDeviceClass.VOLTAGE,
+        entity_registry_enabled_default=False,
+        state_class=SensorStateClass.MEASUREMENT,
+        native_unit_of_measurement=UnitOfElectricPotential.VOLT,
+        entity_category=EntityCategory.DIAGNOSTIC,
+        value_fn=lambda data: cast(
+            float, data.get(PTDevicesSensors.DEVICE_BATTERY_VOLTAGE)
+        ),
+        suggested_display_precision=2,
+    ),
+)
+
+
+async def async_setup_entry(
+    hass: HomeAssistant,
+    config_entry: PTDevicesConfigEntry,
+    async_add_entity: AddConfigEntryEntitiesCallback,
+) -> None:
+    """Set up PTDevices sensors from config entries."""
+    coordinator = config_entry.runtime_data
+
+    known_sensors: set[tuple[str, str]] = set()
+
+    def _check_device() -> None:
+        for device_id in sorted(coordinator.data):
+            device = coordinator.data[device_id]
+            new_sensors = [
+                sensor
+                for sensor in SENSOR_DESCRIPTIONS
+                if sensor.key in device and (device_id, sensor.key) not in known_sensors
+            ]
+            if not new_sensors:
+                continue
+            known_sensors.update((device_id, sensor.key) for sensor in new_sensors)
+            async_add_entity(
+                PTDevicesSensorEntity(config_entry.runtime_data, sensor, device_id)
+                for sensor in new_sensors
+            )
+
+    _check_device()
+    config_entry.async_on_unload(coordinator.async_add_listener(_check_device))
+
+
+class PTDevicesSensorEntity(PTDevicesEntity, SensorEntity):
+    """Sensor entity for PTDevices Integration."""
+
+    entity_description: PTDevicesSensorEntityDescription
+
+    def __init__(
+        self,
+        coordinator: PTDevicesCoordinator,
+        description: PTDevicesSensorEntityDescription,
+        device_id: str,
+    ) -> None:
+        """Initialize sensor."""
+        super().__init__(
+            coordinator,
+            description.key,
+            device_id,
+        )
+
+        self.entity_description = description
+
+    @property
+    def native_value(self) -> float | int | str | None:
+        """Return the state of the sensor."""
+        return self.entity_description.value_fn(self.device)
@@ -0,0 +1,69 @@
+{
+  "config": {
+    "abort": {
+      "already_configured": "[%key:common::config_flow::abort::already_configured_account%]",
+      "invalid_access_token": "[%key:common::config_flow::error::invalid_access_token%]"
+    },
+    "error": {
+      "cannot_connect": "[%key:common::config_flow::error::cannot_connect%]",
+      "invalid_access_token": "[%key:common::config_flow::error::invalid_access_token%]",
+      "no_devices_found": "No devices are registered to your PTDevices account.",
+      "unknown": "[%key:common::config_flow::error::unknown%]"
+    },
+    "step": {
+      "user": {
+        "data": {
+          "api_token": "[%key:common::config_flow::data::api_token%]"
+        },
+        "data_description": {
+          "api_token": "The API token for your PTDevices account."
+        },
+        "description": "Enter the API token for your PTDevices account"
+      }
+    }
+  },
+  "entity": {
+    "sensor": {
+      "battery_voltage": {
+        "name": "Battery voltage"
+      },
+      "depth_level": {
+        "name": "Level depth"
+      },
+      "percent_level": {
+        "name": "Level percent"
+      },
+      "probe_temperature": {
+        "name": "Probe temperature"
+      },
+      "status": {
+        "name": "Status",
+        "state": {
+          "not_connected": "Not connected",
+          "not_connected_yet": "Not connected yet",
+          "power_internet_out_or_receiver_not_working": "Power or internet out or receiver not working",
+          "press_transmitter_connect_button": "Press transmitter connect button",
+          "transmitter_not_reporting": "Transmitter not reporting",
+          "working": "Working"
+        }
+      },
+      "tx_signal": {
+        "name": "LoRa signal strength"
+      },
+      "volume_level": {
+        "name": "Level volume"
+      },
+      "wifi_signal": {
+        "name": "Wi-Fi signal strength"
+      }
+    }
+  },
+  "exceptions": {
+    "cannot_connect": {
+      "message": "[%key:common::config_flow::error::cannot_connect%]"
+    },
+    "invalid_access_token": {
+      "message": "[%key:common::config_flow::error::invalid_access_token%]"
+    }
+  }
+}
@@ -766,14 +766,14 @@ class ScriptEntity(BaseScriptEntity, RestoreEntity):

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

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

@websocket_api.websocket_command({"type": "script/config", "entity_id": str})
 def websocket_config(
@@ -21,5 +21,5 @@
  "integration_type": "hub",
  "iot_class": "cloud_polling",
  "loggers": ["sense_energy"],
-  "requirements": ["sense-energy==0.14.0"]
+  "requirements": ["sense-energy==0.14.1"]
 }
@@ -4,5 +4,5 @@
  "codeowners": ["@fabaff"],
  "documentation": "https://www.home-assistant.io/integrations/serial",
  "iot_class": "local_polling",
-  "requirements": ["serialx==1.4.1"]
+  "requirements": ["serialx==1.7.0"]
 }
@@ -1284,6 +1284,8 @@ CAPABILITY_TO_SENSORS: dict[
 UNITS = {
    "C": UnitOfTemperature.CELSIUS,
    "F": UnitOfTemperature.FAHRENHEIT,
+    "Celsius": UnitOfTemperature.CELSIUS,
+    "Fahrenheit": UnitOfTemperature.FAHRENHEIT,
    "ccf": UnitOfVolume.CENTUM_CUBIC_FEET,
    "lux": LIGHT_LUX,
    "mG": None,
@@ -56,6 +56,7 @@ PLATFORMS_BY_TYPE = {
    SupportedModels.HYGROMETER.value: [Platform.SENSOR],
    SupportedModels.HYGROMETER_CO2.value: [
        Platform.BUTTON,
+        Platform.NUMBER,
        Platform.SENSOR,
        Platform.SELECT,
    ],
@@ -0,0 +1,77 @@
+"""Number platform for SwitchBot devices."""
+
+from datetime import timedelta
+import logging
+
+import switchbot
+from switchbot import SwitchbotOperationError
+from switchbot.devices.meter_pro import MAX_TIME_OFFSET
+
+from homeassistant.components.number import NumberDeviceClass, NumberEntity
+from homeassistant.const import EntityCategory, UnitOfTime
+from homeassistant.core import HomeAssistant
+from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
+
+from .coordinator import SwitchbotConfigEntry, SwitchbotDataUpdateCoordinator
+from .entity import SwitchbotEntity, exception_handler
+
+PARALLEL_UPDATES = 0
+SCAN_INTERVAL = timedelta(days=7)
+_LOGGER = logging.getLogger(__name__)
+_SECONDS_IN_MINUTE = 60
+_MAX_TIME_OFFSET_MINUTES = MAX_TIME_OFFSET // _SECONDS_IN_MINUTE
+
+
+async def async_setup_entry(
+    hass: HomeAssistant,
+    entry: SwitchbotConfigEntry,
+    async_add_entities: AddConfigEntryEntitiesCallback,
+) -> None:
+    """Set up SwitchBot number platform."""
+    coordinator = entry.runtime_data
+
+    if isinstance(coordinator.device, switchbot.SwitchbotMeterProCO2):
+        async_add_entities(
+            [SwitchBotMeterProCO2DisplayTimeOffsetNumber(coordinator)], True
+        )
+
+
+class SwitchBotMeterProCO2DisplayTimeOffsetNumber(SwitchbotEntity, NumberEntity):
+    """Number entity to set the time offset for Meter Pro CO2 devices."""
+
+    _device: switchbot.SwitchbotMeterProCO2
+    _attr_device_class = NumberDeviceClass.DURATION
+    _attr_entity_category = EntityCategory.CONFIG
+    _attr_translation_key = "display_time_offset"
+    _attr_native_min_value = -_MAX_TIME_OFFSET_MINUTES
+    _attr_native_max_value = _MAX_TIME_OFFSET_MINUTES
+    _attr_native_step = 1.0
+    _attr_native_unit_of_measurement = UnitOfTime.MINUTES
+    _attr_should_poll = True
+    _attr_entity_registry_enabled_default = False
+
+    def __init__(self, coordinator: SwitchbotDataUpdateCoordinator) -> None:
+        """Initialize the number entity."""
+        super().__init__(coordinator)
+        self._attr_unique_id = f"{coordinator.base_unique_id}_display_time_offset"
+
+    @exception_handler
+    async def async_set_native_value(self, value: float) -> None:
+        """Set the time offset."""
+        _LOGGER.debug("Setting time offset to %s minutes for %s", value, self._address)
+        offset_minutes = round(value)
+        offset_seconds = offset_minutes * _SECONDS_IN_MINUTE
+        await self._device.set_time_offset(offset_seconds)
+        self._attr_native_value = offset_minutes
+        self.async_write_ha_state()
+
+    async def async_update(self) -> None:
+        """Fetch the latest time offset from the device."""
+        try:
+            offset_seconds = await self._device.get_time_offset()
+        except SwitchbotOperationError:
+            _LOGGER.debug(
+                "Failed to update time offset for %s", self._address, exc_info=True
+            )
+            return
+        self._attr_native_value = round(offset_seconds / _SECONDS_IN_MINUTE)
@@ -272,6 +272,11 @@
        }
      }
    },
+    "number": {
+      "display_time_offset": {
+        "name": "Display time offset"
+      }
+    },
    "select": {
      "time_format": {
        "name": "Time format",
@@ -204,7 +204,7 @@ async def _process_config(hass: HomeAssistant, hass_config: ConfigType) -> None:
    # Remove old ones
    if coordinators:
        for coordinator in coordinators:
-            coordinator.async_remove()
+            await coordinator.async_shutdown()

    async def init_coordinator(
        hass: HomeAssistant, conf_section: dict[str, Any]
@@ -59,13 +59,17 @@ class TriggerUpdateCoordinator(DataUpdateCoordinator):
        """Return unique ID for the entity."""
        return self.config.get("unique_id")

-    @callback
-    def async_remove(self) -> None:
-        """Signal that the entities need to remove themselves."""
+    async def async_shutdown(self) -> None:
+        """Shut down the coordinator and clean up resources."""
+        await super().async_shutdown()
        if self._unsub_start:
            self._unsub_start()
+            self._unsub_start = None
        if self._unsub_trigger:
            self._unsub_trigger()
+            self._unsub_trigger = None
+        if self._script is not None:
+            await self._script.async_stop()

    async def async_setup(self, hass_config: ConfigType) -> None:
        """Set up the trigger and create entities."""
@@ -168,6 +168,11 @@ class AbstractTemplateEntity(Entity):
            domain,
        )

+    async def async_will_remove_from_hass(self) -> None:
+        """Stop scripts when removing from Home Assistant."""
+        for action_script in self._action_scripts.values():
+            await action_script.async_stop()
+
    async def async_run_script(
        self,
        script: Script,
@@ -25,19 +25,12 @@ from homeassistant.components.weather import (
    ATTR_CONDITION_WINDY_VARIANT,
    DOMAIN as WEATHER_DOMAIN,
    ENTITY_ID_FORMAT,
-    PLATFORM_SCHEMA as WEATHER_PLATFORM_SCHEMA,
    Forecast,
    WeatherEntity,
    WeatherEntityFeature,
 )
 from homeassistant.config_entries import ConfigEntry
-from homeassistant.const import (
-    CONF_NAME,
-    CONF_TEMPERATURE_UNIT,
-    CONF_UNIQUE_ID,
-    STATE_UNAVAILABLE,
-    STATE_UNKNOWN,
-)
+from homeassistant.const import CONF_TEMPERATURE_UNIT, STATE_UNAVAILABLE, STATE_UNKNOWN
 from homeassistant.core import HomeAssistant, callback
 from homeassistant.helpers import config_validation as cv
 from homeassistant.helpers.entity_platform import (
@@ -230,18 +223,6 @@ WEATHER_MODERN_YAML_SCHEMA = WEATHER_COMMON_MODERN_SCHEMA.extend(
    make_template_entity_common_modern_schema(WEATHER_DOMAIN, DEFAULT_NAME).schema
 )

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

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

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

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

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

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

-from . import ATTR_LAST_TRANSITION, DOMAIN

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


@@ -20,3 +20,13 @@ finished: *trigger_common
 paused: *trigger_common
 restarted: *trigger_common
 started: *trigger_common
+
+time_remaining:
+  target:
+    entity:
+      domain: timer
+  fields:
+    remaining:
+      required: true
+      selector:
+        duration:
@@ -44,7 +44,7 @@
  "iot_class": "cloud_push",
  "loggers": ["tuya_sharing"],
  "requirements": [
-    "tuya-device-handlers==0.0.18",
+    "tuya-device-handlers==0.0.19",
    "tuya-device-sharing-sdk==0.2.8"
  ]
 }
@@ -7,5 +7,5 @@
  "integration_type": "system",
  "iot_class": "local_push",
  "quality_scale": "internal",
-  "requirements": ["aiousbwatcher==1.1.2", "serialx==1.4.1"]
+  "requirements": ["aiousbwatcher==1.1.2", "serialx==1.7.0"]
 }
@@ -10,6 +10,7 @@ from .coordinator import V2CConfigEntry, V2CUpdateCoordinator

 PLATFORMS: list[Platform] = [
    Platform.BINARY_SENSOR,
+    Platform.LIGHT,
    Platform.NUMBER,
    Platform.SENSOR,
    Platform.SWITCH,
@@ -1,5 +1,13 @@
 {
  "entity": {
+    "light": {
+      "light_led": {
+        "default": "mdi:led-on"
+      },
+      "logo_led": {
+        "default": "mdi:led-on"
+      }
+    },
    "sensor": {
      "battery_power": {
        "default": "mdi:home-battery"
@@ -0,0 +1,126 @@
+"""Light platform for V2C EVSE LEDs."""
+
+from collections.abc import Callable, Coroutine
+from dataclasses import dataclass
+from typing import Any
+
+from pytrydan import Trydan, TrydanData
+
+from homeassistant.components.light import (
+    ATTR_BRIGHTNESS,
+    ColorMode,
+    LightEntity,
+    LightEntityDescription,
+)
+from homeassistant.core import HomeAssistant
+from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
+from homeassistant.util.color import brightness_to_value, value_to_brightness
+
+from .coordinator import V2CConfigEntry, V2CUpdateCoordinator
+from .entity import V2CBaseEntity
+
+LED_ON_VALUE = 100
+LED_OFF_VALUE = 0
+BRIGHTNESS_SCALE = (LED_OFF_VALUE, LED_ON_VALUE)
+
+
+@dataclass(frozen=True, kw_only=True)
+class V2CLightEntityDescription(LightEntityDescription):
+    """Describes V2C EVSE light entity."""
+
+    supports_brightness: bool = False
+    value_fn: Callable[[TrydanData], int | None]
+    update_fn: Callable[[Trydan, int], Coroutine[Any, Any, None]]
+
+
+TRYDAN_LIGHTS = (
+    V2CLightEntityDescription(
+        key="light_led",
+        translation_key="light_led",
+        entity_registry_enabled_default=False,
+        value_fn=lambda evse_data: evse_data.light_led,
+        update_fn=lambda evse, value: evse.light_led(value),
+    ),
+    V2CLightEntityDescription(
+        key="logo_led",
+        translation_key="logo_led",
+        supports_brightness=True,
+        value_fn=lambda evse_data: evse_data.logo_led,
+        update_fn=lambda evse, value: evse.logo_led(value),
+    ),
+)
+
+
+async def async_setup_entry(
+    hass: HomeAssistant,
+    config_entry: V2CConfigEntry,
+    async_add_entities: AddConfigEntryEntitiesCallback,
+) -> None:
+    """Set up V2C Trydan light platform."""
+    coordinator = config_entry.runtime_data
+    data = coordinator.data
+    assert data is not None
+
+    async_add_entities(
+        V2CLightEntity(
+            coordinator,
+            description,
+            config_entry.entry_id,
+        )
+        for description in TRYDAN_LIGHTS
+        if description.value_fn(data) is not None
+    )
+
+
+class V2CLightEntity(V2CBaseEntity, LightEntity):
+    """Representation of V2C EVSE LED light entity."""
+
+    entity_description: V2CLightEntityDescription
+
+    def __init__(
+        self,
+        coordinator: V2CUpdateCoordinator,
+        description: V2CLightEntityDescription,
+        entry_id: str,
+    ) -> None:
+        """Initialize the V2C light entity."""
+        super().__init__(coordinator, description)
+        self._attr_unique_id = f"{entry_id}_{description.key}"
+        self._attr_color_mode = (
+            ColorMode.BRIGHTNESS if description.supports_brightness else ColorMode.ONOFF
+        )
+        self._attr_supported_color_modes = {self._attr_color_mode}
+
+    @property
+    def brightness(self) -> int | None:
+        """Return the light brightness."""
+        if not self.entity_description.supports_brightness:
+            return None
+        value = self.entity_description.value_fn(self.data)
+        if value is None:
+            return None
+        return value_to_brightness(BRIGHTNESS_SCALE, value)
+
+    @property
+    def is_on(self) -> bool | None:
+        """Return true if the light is on."""
+        value = self.entity_description.value_fn(self.data)
+        if value is None:
+            return None
+        return value > 0
+
+    async def async_turn_on(self, **kwargs: Any) -> None:
+        """Turn on the LED."""
+        value = LED_ON_VALUE
+        if self.entity_description.supports_brightness:
+            brightness = kwargs.get(ATTR_BRIGHTNESS, 255)
+            value = round(brightness_to_value(BRIGHTNESS_SCALE, brightness))
+            if brightness:
+                value = max(value, 1)
+        await self.entity_description.update_fn(self.coordinator.evse, value)
+        await self.coordinator.async_request_refresh()
+
+    async def async_turn_off(self, **kwargs: Any) -> None:
+        """Turn off the LED."""
+        await self.entity_description.update_fn(self.coordinator.evse, LED_OFF_VALUE)
+        await self.coordinator.async_request_refresh()
@@ -30,6 +30,14 @@
        "name": "Ready"
      }
    },
+    "light": {
+      "light_led": {
+        "name": "Light LED"
+      },
+      "logo_led": {
+        "name": "Logo LED"
+      }
+    },
    "number": {
      "intensity": {
        "name": "Intensity"
@@ -2,26 +2,16 @@

 from pyvlx import PyVLX, PyVLXException

-from homeassistant.config_entries import ConfigEntry, ConfigEntryState
+from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import (
    CONF_HOST,
    CONF_MAC,
    CONF_PASSWORD,
    EVENT_HOMEASSISTANT_STOP,
 )
-from homeassistant.core import Event, HomeAssistant, ServiceCall
-from homeassistant.exceptions import (
-    ConfigEntryAuthFailed,
-    ConfigEntryNotReady,
-    HomeAssistantError,
-    ServiceValidationError,
-)
-from homeassistant.helpers import (
-    config_validation as cv,
-    device_registry as dr,
-    issue_registry as ir,
-)
-from homeassistant.helpers.typing import ConfigType
+from homeassistant.core import Event, HomeAssistant
+from homeassistant.exceptions import ConfigEntryAuthFailed, ConfigEntryNotReady
+from homeassistant.helpers import config_validation as cv, device_registry as dr

 from .const import DOMAIN, LOGGER, PLATFORMS

@@ -30,47 +20,6 @@ type VeluxConfigEntry = ConfigEntry[PyVLX]
 CONFIG_SCHEMA = cv.config_entry_only_config_schema(DOMAIN)


-async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
-    """Set up the Velux component."""
-
-    async def async_reboot_gateway(service_call: ServiceCall) -> None:
-        """Reboot the gateway (deprecated - use button entity instead)."""
-        ir.async_create_issue(
-            hass,
-            DOMAIN,
-            "deprecated_reboot_service",
-            is_fixable=False,
-            issue_domain=DOMAIN,
-            severity=ir.IssueSeverity.WARNING,
-            translation_key="deprecated_reboot_service",
-            breaks_in_ha_version="2026.6.0",
-        )
-
-        # Find a loaded config entry to get the PyVLX instance
-        # We assume only one gateway is set up or we just reboot the first one found
-        # (this is no change to the previous behavior, the alternative would be to reboot all)
-        for entry in hass.config_entries.async_entries(DOMAIN):
-            if entry.state is ConfigEntryState.LOADED:
-                try:
-                    await entry.runtime_data.reboot_gateway()
-                except (OSError, PyVLXException) as err:
-                    raise HomeAssistantError(
-                        translation_domain=DOMAIN,
-                        translation_key="reboot_failed",
-                    ) from err
-                else:
-                    return
-
-        raise ServiceValidationError(
-            translation_domain=DOMAIN,
-            translation_key="no_gateway_loaded",
-        )
-
-    hass.services.async_register(DOMAIN, "reboot_gateway", async_reboot_gateway)
-
-    return True
-
-
 async def async_setup_entry(hass: HomeAssistant, entry: VeluxConfigEntry) -> bool:
    """Set up the velux component."""
    host = entry.data[CONF_HOST]
@@ -1,7 +0,0 @@
-{
-  "services": {
-    "reboot_gateway": {
-      "service": "mdi:restart"
-    }
-  }
-}
@@ -1,3 +0,0 @@
-# Velux Integration services
-
-reboot_gateway:
@@ -59,23 +59,8 @@
    "device_communication_error": {
      "message": "Failed to communicate with Velux device: {error}"
    },
-    "no_gateway_loaded": {
-      "message": "No loaded Velux gateway found"
-    },
    "reboot_failed": {
      "message": "Failed to reboot gateway. Try again in a few moments or power cycle the device manually"
    }
-  },
-  "issues": {
-    "deprecated_reboot_service": {
-      "description": "The `velux.reboot_gateway` action is deprecated and will be removed in Home Assistant 2026.6.0. Please use the 'Restart' button entity instead. You can find this button in the device page for your KLF 200 Gateway or by searching for 'restart' in your entity list.",
-      "title": "Velux 'Reboot gateway' action deprecated"
-    }
-  },
-  "services": {
-    "reboot_gateway": {
-      "description": "Reboots the KLF200 Gateway",
-      "name": "Reboot gateway"
-    }
  }
 }
@@ -15,5 +15,5 @@
  "integration_type": "device",
  "iot_class": "local_push",
  "quality_scale": "bronze",
-  "requirements": ["victron-ble-ha-parser==0.6.3"]
+  "requirements": ["victron-ble-ha-parser==0.7.0"]
 }
@@ -99,6 +99,7 @@ def _direction_value(field: VolvoCarsApiBaseModel) -> str | None:

 _CHARGING_POWER_STATUS_OPTIONS = [
    "fault",
+    "initialization",
    "power_available_but_not_activated",
    "providing_power",
    "no_power_available",
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Erik Montnemery	10084c8c0c	Add trigger timer.time_remaining (#169763 )	2026-05-05 23:54:49 -04:00
Erik Montnemery	7e8f5365ce	Add method _should_include to EntityTriggerBase (#169837 )	2026-05-06 00:50:22 +02:00
Erik Montnemery	65f9dcd7bf	Improve condition test helper docstrings (#169871 )	2026-05-06 00:32:37 +02:00
epenet	4c8f37fef6	Bump tuya-device-handlers to 0.0.19 (#169848 )	2026-05-05 22:23:14 +02:00
Erik Montnemery	d1295fa260	Validate yaml matches implementation in automation options_supported tests (#169798 )	2026-05-05 22:20:28 +02:00
Diogo Gomes	9b2eea920f	Add V2C LED lights (#169778 ) Co-authored-by: Copilot Autofix powered by AI <175728472+Copilot@users.noreply.github.com>	2026-05-05 22:19:59 +02:00
Petro31	c81c1cbb14	Remove legacy weather template entities (#169734 )	2026-05-05 22:18:46 +02:00
Erik Montnemery	11ee05874a	Improve trigger test helper docstrings (#169869 )	2026-05-05 22:11:08 +02:00
puddly	7d7c47b56e	Bump serialx to 1.7.0 (#169867 )	2026-05-05 21:06:30 +02:00
epenet	dc4210595f	Fix flaky test_set_scan_interval_via_platform (#169856 ) Co-authored-by: Claude Opus 4.7 (1M context) <noreply@anthropic.com>	2026-05-05 20:49:15 +02:00
Freekers	7430366d9b	Enable web search support for gpt-5-nano (#169710 )	2026-05-05 20:47:52 +03:00
Crocmagnon	ae3bd54ca7	switchbot: remove unwanted future annotations import preventing build on all new PRs (#169863 )	2026-05-05 19:40:27 +02:00
Glenn Waters	e3ce7fb000	Bump elkm1-lib to 2.2.15 (#169843 ) Co-authored-by: Copilot Autofix powered by AI <175728472+Copilot@users.noreply.github.com>	2026-05-05 18:50:17 +02:00
epenet	9286b517d3	Add ruff rule to prevent __future__ annotations (#169852 ) Co-authored-by: Robert Resch <robert@resch.dev> Co-authored-by: Copilot Autofix powered by AI <175728472+Copilot@users.noreply.github.com>	2026-05-05 18:42:10 +02:00
elgris	4d62e4765d	Add a number entity to set display time offset (in minutes) for Switchbot Meter CO2 devices. (#169603 ) Co-authored-by: Copilot Autofix powered by AI <175728472+Copilot@users.noreply.github.com>	2026-05-05 17:45:47 +02:00
Michael Hansen	ea55ef90a6	Bump intents to 2026.5.5 (#169855 )	2026-05-05 18:22:22 +03:00
epenet	751765b97b	Cleanup from __future__ import annotations (#169850 )	2026-05-05 16:35:21 +02:00
Denis Shulyaka	11ed1fe20f	Return the requested format for OpenAI TTS (#169839 ) Co-authored-by: Copilot Autofix powered by AI <175728472+Copilot@users.noreply.github.com>	2026-05-05 10:28:20 -04:00
Joost Lekkerkerker	9b5166769a	Add Sensereo matter brand (#169836 )	2026-05-05 10:18:01 -04:00
Joost Lekkerkerker	70c2a323ce	Add Zunzunbee Zigbee brand (#169838 )	2026-05-05 10:17:49 -04:00
Ronald van der Meer	0ec5d6b273	Add API version to Duco diagnostics for support triage (#169802 )	2026-05-05 15:48:43 +02:00
Robert Resch	b1e8dc2ebb	Remove show_advanced_options in Ecovacs and always show all options (#169831 )	2026-05-05 15:42:08 +02:00
Artur Pragacz	e144804d28	Fix async_unload teardown race in scripts (#169562 )	2026-05-05 15:03:37 +02:00
cengelen	8521a49986	Bump growatt server to 2.1.0 (#169495 ) Co-authored-by: Copilot <copilot@github.com>	2026-05-05 14:11:50 +02:00
Raj Laud	3587f9613f	Bump victron-ble-ha-parser to 0.7.0 (#169736 ) Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>	2026-05-05 13:57:19 +02:00
Jan Bouwhuis	2f1dd3a817	Deprecate MQTT protocol versions 3.x and migrate to version 5 (#169759 ) Co-authored-by: Copilot Autofix powered by AI <175728472+Copilot@users.noreply.github.com>	2026-05-05 13:43:18 +02:00
wollew	2c2e8db19f	Remove deprecated reboot service for Velux gateway (#169796 )	2026-05-05 11:08:00 +02:00
Erik Montnemery	64a3f91132	Improve template reload (#169480 )	2026-05-05 10:16:22 +02:00
dependabot[bot]	bd61c893e4	Bump dawidd6/action-download-artifact from 20 to 21 (#169793 ) Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>	2026-05-05 10:12:07 +02:00
renovate[bot]	6bb759b887	Update infrared-protocols to 2.1.0 (#169785 ) Co-authored-by: renovate[bot] <29139614+renovate[bot]@users.noreply.github.com>	2026-05-05 10:11:52 +02:00
Matthias Alphart	280b5ef388	Update xknxproject to 3.9.0 (#169775 )	2026-05-05 10:09:24 +02:00
Erik Montnemery	416d4e02a0	Add trigger media_player.unmuted (#169797 )	2026-05-05 09:45:45 +02:00
kw6423	c99f261a2d	Restore OwnTracks custom device tracker attributes (#169753 ) Co-authored-by: Ariel Ebersberger <ariel@ebersberger.io>	2026-05-05 09:44:53 +02:00
Thomas D	9c9a058eb0	Add missing initialization charging power status option to Volvo (#169727 )	2026-05-05 09:10:13 +02:00
Nathan Spencer	7b51b929ef	Bump pylitterbot to 2025.4.0 (#169652 )	2026-05-05 09:05:16 +02:00
Ronald van der Meer	74971ebcd1	Bump python-duco-client to 0.4.0 (#169776 )	2026-05-05 08:55:22 +02:00
Åke Strandberg	1f5d80ca44	Add missing code for miele washing machine (#169795 )	2026-05-05 08:54:12 +02:00
Erik Montnemery	9075c6a5cb	Add trigger media_player.muted (#156736 )	2026-05-05 08:22:03 +02:00
Manu	ab4162601f	Remove YAML import from Duck DNS integration (#169769 )	2026-05-05 07:45:40 +02:00
HoffmanEl	38de48ac9d	Add data_description to airnow config flow strings (#169783 )	2026-05-05 07:43:18 +02:00
Nikolai Rahimi	597d9a2ada	Add Mitsubishi Comfort integration (#167472 ) Co-authored-by: Nikolai Rahimi <nikolairahimi@users.noreply.github.com> Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com> Co-authored-by: Joostlek <joostlek@outlook.com>	2026-05-05 00:16:00 +02:00
optimusbasti	71494b6c97	Bump aioautomower to 2.7.5 (#169758 )	2026-05-04 22:27:46 +01:00
A. Gideonse	57e66baf53	Update Indevolt integration quality scale to silver (#167843 ) Co-authored-by: Joost Lekkerkerker <joostlek@outlook.com>	2026-05-04 23:05:11 +02:00
Nathan Spencer	63dfc97346	Limit power status binary sensor to non-LR5 devices (#169659 )	2026-05-04 22:51:17 +02:00
shbatm	1b4a7d55c0	Add precipitation device class to WeatherFlow Cloud accumulation sensors (#169638 ) Co-authored-by: Claude Opus 4.7 <noreply@anthropic.com>	2026-05-04 22:29:12 +02:00
Matthew Gibson	8c8a863867	Add ptdevices Integration (#156307 ) Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com> Co-authored-by: Joost Lekkerkerker <joostlek@outlook.com>	2026-05-04 22:15:52 +02:00
Keilin Bickar	28d65e987c	bump sense-energy to 0.14.1 (#169761 )	2026-05-04 21:22:45 +02:00
Daniel Hjelseth Høyer	d0c0f02311	Bump pyTibber to 0.37.3 (#169762 )	2026-05-04 21:21:57 +02:00
kernelpanic85	f90e9ceb6c	Add Celsius and Fahrenheit to Smartthings UNITS mapping (#169686 )	2026-05-04 21:20:04 +02:00
G Johansson	553ba5e7ab	Add binary sensor to Nord Pool (#169684 )	2026-05-04 21:10:06 +02:00
Erwin Douna	6633f16d13	Add system health to Portainer (#169698 )	2026-05-04 21:07:16 +02:00