Migrate metoffice to runtime_data (#164606)

Co-authored-by: Joost Lekkerkerker <joostlek@outlook.com>

.github/workflows/builder.yml

@@ -182,7 +182,7 @@ jobs:
           fi
 
       - name: Download translations
-        uses: actions/download-artifact@37930b1c2abaa49bbe596cd826c3c89aef350131 # v7.0.0
+        uses: actions/download-artifact@70fc10c6e5e1ce46ad2ea6f2b72d43f7d47b13c3 # v8.0.0
         with:
           name: translations
 
@@ -544,7 +544,7 @@ jobs:
           python-version: ${{ env.DEFAULT_PYTHON }}
 
       - name: Download translations
-        uses: actions/download-artifact@37930b1c2abaa49bbe596cd826c3c89aef350131 # v7.0.0
+        uses: actions/download-artifact@70fc10c6e5e1ce46ad2ea6f2b72d43f7d47b13c3 # v8.0.0
         with:
           name: translations
 

.github/workflows/ci.yaml

@@ -978,7 +978,7 @@ jobs:
         run: |
           echo "::add-matcher::.github/workflows/matchers/pytest-slow.json"
       - name: Download pytest_buckets
-        uses: actions/download-artifact@37930b1c2abaa49bbe596cd826c3c89aef350131 # v7.0.0
+        uses: actions/download-artifact@70fc10c6e5e1ce46ad2ea6f2b72d43f7d47b13c3 # v8.0.0
         with:
           name: pytest_buckets
       - name: Compile English translations
@@ -1387,7 +1387,7 @@ jobs:
         with:
           persist-credentials: false
       - name: Download all coverage artifacts
-        uses: actions/download-artifact@37930b1c2abaa49bbe596cd826c3c89aef350131 # v7.0.0
+        uses: actions/download-artifact@70fc10c6e5e1ce46ad2ea6f2b72d43f7d47b13c3 # v8.0.0
         with:
           pattern: coverage-*
       - name: Upload coverage to Codecov
@@ -1558,7 +1558,7 @@ jobs:
         with:
           persist-credentials: false
       - name: Download all coverage artifacts
-        uses: actions/download-artifact@37930b1c2abaa49bbe596cd826c3c89aef350131 # v7.0.0
+        uses: actions/download-artifact@70fc10c6e5e1ce46ad2ea6f2b72d43f7d47b13c3 # v8.0.0
         with:
           pattern: coverage-*
       - name: Upload coverage to Codecov
@@ -1587,7 +1587,7 @@ jobs:
       && needs.info.outputs.skip_coverage != 'true' && !cancelled()
     steps:
       - name: Download all coverage artifacts
-        uses: actions/download-artifact@37930b1c2abaa49bbe596cd826c3c89aef350131 # v7.0.0
+        uses: actions/download-artifact@70fc10c6e5e1ce46ad2ea6f2b72d43f7d47b13c3 # v8.0.0
         with:
           pattern: test-results-*
       - name: Upload test results to Codecov

.github/workflows/codeql.yml

@@ -28,11 +28,11 @@ jobs:
           persist-credentials: false
 
       - name: Initialize CodeQL
-        uses: github/codeql-action/init@9e907b5e64f6b83e7804b09294d44122997950d6 # v4.32.3
+        uses: github/codeql-action/init@89a39a4e59826350b863aa6b6252a07ad50cf83e # v4.32.4
         with:
           languages: python
 
       - name: Perform CodeQL Analysis
-        uses: github/codeql-action/analyze@9e907b5e64f6b83e7804b09294d44122997950d6 # v4.32.3
+        uses: github/codeql-action/analyze@89a39a4e59826350b863aa6b6252a07ad50cf83e # v4.32.4
         with:
           category: "/language:python"

.github/workflows/wheels.yml

@@ -124,12 +124,12 @@ jobs:
           persist-credentials: false
 
       - name: Download env_file
-        uses: actions/download-artifact@37930b1c2abaa49bbe596cd826c3c89aef350131 # v7.0.0
+        uses: actions/download-artifact@70fc10c6e5e1ce46ad2ea6f2b72d43f7d47b13c3 # v8.0.0
         with:
           name: env_file
 
       - name: Download requirements_diff
-        uses: actions/download-artifact@37930b1c2abaa49bbe596cd826c3c89aef350131 # v7.0.0
+        uses: actions/download-artifact@70fc10c6e5e1ce46ad2ea6f2b72d43f7d47b13c3 # v8.0.0
         with:
           name: requirements_diff
 
@@ -175,17 +175,17 @@ jobs:
           persist-credentials: false
 
       - name: Download env_file
-        uses: actions/download-artifact@37930b1c2abaa49bbe596cd826c3c89aef350131 # v7.0.0
+        uses: actions/download-artifact@70fc10c6e5e1ce46ad2ea6f2b72d43f7d47b13c3 # v8.0.0
         with:
           name: env_file
 
       - name: Download requirements_diff
-        uses: actions/download-artifact@37930b1c2abaa49bbe596cd826c3c89aef350131 # v7.0.0
+        uses: actions/download-artifact@70fc10c6e5e1ce46ad2ea6f2b72d43f7d47b13c3 # v8.0.0
         with:
           name: requirements_diff
 
       - name: Download requirements_all_wheels
-        uses: actions/download-artifact@37930b1c2abaa49bbe596cd826c3c89aef350131 # v7.0.0
+        uses: actions/download-artifact@70fc10c6e5e1ce46ad2ea6f2b72d43f7d47b13c3 # v8.0.0
         with:
           name: requirements_all_wheels
 

.strict-typing

@@ -545,6 +545,7 @@ homeassistant.components.tcp.*
 homeassistant.components.technove.*
 homeassistant.components.tedee.*
 homeassistant.components.telegram_bot.*
+homeassistant.components.teslemetry.*
 homeassistant.components.text.*
 homeassistant.components.thethingsnetwork.*
 homeassistant.components.threshold.*

homeassistant/bootstrap.py

@@ -70,7 +70,7 @@ from .const import (
     SIGNAL_BOOTSTRAP_INTEGRATIONS,
 )
 from .core_config import async_process_ha_core_config
-from .exceptions import HomeAssistantError
+from .exceptions import HomeAssistantError, UnsupportedStorageVersionError
 from .helpers import (
     area_registry,
     category_registry,
@@ -433,32 +433,56 @@ def _init_blocking_io_modules_in_executor() -> None:
     is_docker_env()
 
 
-async def async_load_base_functionality(hass: core.HomeAssistant) -> None:
-    """Load the registries and modules that will do blocking I/O."""
+async def async_load_base_functionality(hass: core.HomeAssistant) -> bool:
+    """Load the registries and modules that will do blocking I/O.
+
+    Return whether loading succeeded.
+    """
     if DATA_REGISTRIES_LOADED in hass.data:
-        return
+        return True
+
     hass.data[DATA_REGISTRIES_LOADED] = None
     entity.async_setup(hass)
     frame.async_setup(hass)
     template.async_setup(hass)
     translation.async_setup(hass)
-    await asyncio.gather(
-        create_eager_task(get_internal_store_manager(hass).async_initialize()),
-        create_eager_task(area_registry.async_load(hass)),
-        create_eager_task(category_registry.async_load(hass)),
-        create_eager_task(device_registry.async_load(hass)),
-        create_eager_task(entity_registry.async_load(hass)),
-        create_eager_task(floor_registry.async_load(hass)),
-        create_eager_task(issue_registry.async_load(hass)),
-        create_eager_task(label_registry.async_load(hass)),
-        hass.async_add_executor_job(_init_blocking_io_modules_in_executor),
-        create_eager_task(template.async_load_custom_templates(hass)),
-        create_eager_task(restore_state.async_load(hass)),
-        create_eager_task(hass.config_entries.async_initialize()),
-        create_eager_task(async_get_system_info(hass)),
-        create_eager_task(condition.async_setup(hass)),
-        create_eager_task(trigger.async_setup(hass)),
-    )
+
+    recovery = hass.config.recovery_mode
+    try:
+        await asyncio.gather(
+            create_eager_task(get_internal_store_manager(hass).async_initialize()),
+            create_eager_task(area_registry.async_load(hass, load_empty=recovery)),
+            create_eager_task(category_registry.async_load(hass, load_empty=recovery)),
+            create_eager_task(device_registry.async_load(hass, load_empty=recovery)),
+            create_eager_task(entity_registry.async_load(hass, load_empty=recovery)),
+            create_eager_task(floor_registry.async_load(hass, load_empty=recovery)),
+            create_eager_task(issue_registry.async_load(hass, load_empty=recovery)),
+            create_eager_task(label_registry.async_load(hass, load_empty=recovery)),
+            hass.async_add_executor_job(_init_blocking_io_modules_in_executor),
+            create_eager_task(template.async_load_custom_templates(hass)),
+            create_eager_task(restore_state.async_load(hass, load_empty=recovery)),
+            create_eager_task(hass.config_entries.async_initialize()),
+            create_eager_task(async_get_system_info(hass)),
+            create_eager_task(condition.async_setup(hass)),
+            create_eager_task(trigger.async_setup(hass)),
+        )
+    except UnsupportedStorageVersionError as err:
+        # If we're already in recovery mode, we don't want to handle the exception
+        # and activate recovery mode again, as that would lead to an infinite loop.
+        if recovery:
+            raise
+
+        _LOGGER.error(
+            "Storage file %s was created by a newer version of Home Assistant"
+            " (storage version %s > %s); activating recovery mode; on-disk data"
+            " is preserved; upgrade Home Assistant or restore from a backup",
+            err.storage_key,
+            err.found_version,
+            err.max_supported_version,
+        )
+        return False
+
+    return True
 
 
 async def async_from_config_dict(
@@ -475,7 +499,9 @@ async def async_from_config_dict(
     # Prime custom component cache early so we know if registry entries are tied
     # to a custom integration
     await loader.async_get_custom_components(hass)
-    await async_load_base_functionality(hass)
+
+    if not await async_load_base_functionality(hass):
+        return None
 
     # Set up core.
     _LOGGER.debug("Setting up %s", CORE_INTEGRATIONS)

homeassistant/brands/ubisys.json

@@ -0,0 +1,5 @@
+{
+  "domain": "ubisys",
+  "name": "Ubisys",
+  "iot_standards": ["zigbee"]
+}

homeassistant/components/accuweather/weather.py

@@ -191,7 +191,7 @@ class AccuWeatherEntity(
             {
                 ATTR_FORECAST_TIME: utc_from_timestamp(item["EpochDate"]).isoformat(),
                 ATTR_FORECAST_CLOUD_COVERAGE: item["CloudCoverDay"],
-                ATTR_FORECAST_HUMIDITY: item["RelativeHumidityDay"]["Average"],
+                ATTR_FORECAST_HUMIDITY: item["RelativeHumidityDay"].get("Average"),
                 ATTR_FORECAST_NATIVE_TEMP: item["TemperatureMax"][ATTR_VALUE],
                 ATTR_FORECAST_NATIVE_TEMP_LOW: item["TemperatureMin"][ATTR_VALUE],
                 ATTR_FORECAST_NATIVE_APPARENT_TEMP: item["RealFeelTemperatureMax"][

homeassistant/components/airobot/number.py

@@ -93,7 +93,6 @@ class AirobotNumber(AirobotEntity, NumberEntity):
             raise ServiceValidationError(
                 translation_domain=DOMAIN,
                 translation_key="set_value_failed",
-                translation_placeholders={"error": str(err)},
             ) from err
         else:
             await self.coordinator.async_request_refresh()

homeassistant/components/airobot/strings.json

@@ -112,7 +112,7 @@
       "message": "Failed to set temperature to {temperature}."
     },
     "set_value_failed": {
-      "message": "Failed to set value: {error}"
+      "message": "Failed to set value."
     },
     "switch_turn_off_failed": {
       "message": "Failed to turn off {switch}."

homeassistant/components/alarm_control_panel/trigger.py

@@ -44,7 +44,7 @@ def make_entity_state_trigger_required_features(
     class CustomTrigger(EntityStateTriggerRequiredFeatures):
         """Trigger for entity state changes."""
 
-        _domain = domain
+        _domains = {domain}
         _to_states = {to_state}
         _required_features = required_features
 

homeassistant/components/alexa_devices/manifest.json

@@ -8,5 +8,5 @@
   "iot_class": "cloud_polling",
   "loggers": ["aioamazondevices"],
   "quality_scale": "platinum",
-  "requirements": ["aioamazondevices==12.0.0"]
+  "requirements": ["aioamazondevices==12.0.2"]
 }

homeassistant/components/anthropic/entity.py

@@ -400,8 +400,8 @@ def _convert_content(
                 # If there is only one text block, simplify the content to a string
                 messages[-1]["content"] = messages[-1]["content"][0]["text"]
         else:
-            # Note: We don't pass SystemContent here as its passed to the API as the prompt
-            raise TypeError(f"Unexpected content type: {type(content)}")
+            # Note: We don't pass SystemContent here as it's passed to the API as the prompt
+            raise HomeAssistantError("Unexpected content type in chat log")
 
     return messages, container_id
 
@@ -442,8 +442,8 @@ async def _transform_stream(  # noqa: C901 - This is complex, but better to have
 
     Each message could contain multiple blocks of the same type.
     """
-    if stream is None:
-        raise TypeError("Expected a stream of messages")
+    if stream is None or not hasattr(stream, "__aiter__"):
+        raise HomeAssistantError("Expected a stream of messages")
 
     current_tool_block: ToolUseBlockParam | ServerToolUseBlockParam | None = None
     current_tool_args: str
@@ -456,8 +456,6 @@ async def _transform_stream(  # noqa: C901 - This is complex, but better to have
         LOGGER.debug("Received response: %s", response)
 
         if isinstance(response, RawMessageStartEvent):
-            if response.message.role != "assistant":
-                raise ValueError("Unexpected message role")
             input_usage = response.message.usage
             first_block = True
         elif isinstance(response, RawContentBlockStartEvent):
@@ -666,7 +664,7 @@ class AnthropicBaseLLMEntity(Entity):
 
         system = chat_log.content[0]
         if not isinstance(system, conversation.SystemContent):
-            raise TypeError("First message must be a system message")
+            raise HomeAssistantError("First message must be a system message")
 
         # System prompt with caching enabled
         system_prompt: list[TextBlockParam] = [

homeassistant/components/anthropic/quality_scale.yaml

@@ -31,10 +31,7 @@ rules:
   test-before-setup: done
   unique-config-entry: done
   # Silver
-  action-exceptions:
-    status: todo
-    comment: |
-      Reevaluate exceptions for entity services.
+  action-exceptions: done
   config-entry-unloading: done
   docs-configuration-parameters: done
   docs-installation-parameters: done

homeassistant/components/aquostv/media_player.py

@@ -117,6 +117,7 @@ class SharpAquosTVDevice(MediaPlayerEntity):
         | MediaPlayerEntityFeature.VOLUME_SET
         | MediaPlayerEntityFeature.PLAY
     )
+    _attr_volume_step = 2 / 60
 
     def __init__(
         self, name: str, remote: sharp_aquos_rc.TV, power_on_enabled: bool = False
@@ -161,22 +162,6 @@ class SharpAquosTVDevice(MediaPlayerEntity):
         """Turn off tvplayer."""
         self._remote.power(0)
 
-    @_retry
-    def volume_up(self) -> None:
-        """Volume up the media player."""
-        if self.volume_level is None:
-            _LOGGER.debug("Unknown volume in volume_up")
-            return
-        self._remote.volume(int(self.volume_level * 60) + 2)
-
-    @_retry
-    def volume_down(self) -> None:
-        """Volume down media player."""
-        if self.volume_level is None:
-            _LOGGER.debug("Unknown volume in volume_down")
-            return
-        self._remote.volume(int(self.volume_level * 60) - 2)
-
     @_retry
     def set_volume_level(self, volume: float) -> None:
         """Set Volume media player."""

homeassistant/components/august/manifest.json

@@ -30,5 +30,5 @@
   "integration_type": "hub",
   "iot_class": "cloud_push",
   "loggers": ["pubnub", "yalexs"],
-  "requirements": ["yalexs==9.2.0", "yalexs-ble==3.2.4"]
+  "requirements": ["yalexs==9.2.0", "yalexs-ble==3.2.7"]
 }

homeassistant/components/backup/store.py

@@ -29,12 +29,17 @@ class StoredBackupData(TypedDict):
 class _BackupStore(Store[StoredBackupData]):
     """Class to help storing backup data."""
 
+    # Maximum version we support reading for forward compatibility.
+    # This allows reading data written by a newer HA version after downgrade.
+    _MAX_READABLE_VERSION = 2
+
     def __init__(self, hass: HomeAssistant) -> None:
         """Initialize storage class."""
         super().__init__(
             hass,
             STORAGE_VERSION,
             STORAGE_KEY,
+            max_readable_version=self._MAX_READABLE_VERSION,
             minor_version=STORAGE_VERSION_MINOR,
         )
 
@@ -86,8 +91,8 @@ class _BackupStore(Store[StoredBackupData]):
         # data["config"]["schedule"]["state"] will be removed. The bump to 2 is
         # planned to happen after a 6 month quiet period with no minor version
         # changes.
-        # Reject if major version is higher than 2.
-        if old_major_version > 2:
+        # Reject if major version is higher than _MAX_READABLE_VERSION.
+        if old_major_version > self._MAX_READABLE_VERSION:
             raise NotImplementedError
         return data
 

homeassistant/components/binary_sensor/trigger.py

@@ -24,7 +24,7 @@ class BinarySensorOnOffTrigger(EntityTargetStateTriggerBase):
     """Class for binary sensor on/off triggers."""
 
     _device_class: BinarySensorDeviceClass | None
-    _domain: str = DOMAIN
+    _domains = {DOMAIN}
 
     def entity_filter(self, entities: set[str]) -> set[str]:
         """Filter entities of this domain."""

homeassistant/components/bitcoin/sensor.py

@@ -190,7 +190,7 @@ class BitcoinSensor(SensorEntity):
         elif sensor_type == "miners_revenue_usd":
             self._attr_native_value = f"{stats.miners_revenue_usd:.0f}"
         elif sensor_type == "btc_mined":
-            self._attr_native_value = str(stats.btc_mined * 0.00000001)
+            self._attr_native_value = str(stats.btc_mined * 1e-8)
         elif sensor_type == "trade_volume_usd":
             self._attr_native_value = f"{stats.trade_volume_usd:.1f}"
         elif sensor_type == "difficulty":
@@ -208,13 +208,13 @@ class BitcoinSensor(SensorEntity):
         elif sensor_type == "blocks_size":
             self._attr_native_value = f"{stats.blocks_size:.1f}"
         elif sensor_type == "total_fees_btc":
-            self._attr_native_value = f"{stats.total_fees_btc * 0.00000001:.2f}"
+            self._attr_native_value = f"{stats.total_fees_btc * 1e-8:.2f}"
         elif sensor_type == "total_btc_sent":
-            self._attr_native_value = f"{stats.total_btc_sent * 0.00000001:.2f}"
+            self._attr_native_value = f"{stats.total_btc_sent * 1e-8:.2f}"
         elif sensor_type == "estimated_btc_sent":
-            self._attr_native_value = f"{stats.estimated_btc_sent * 0.00000001:.2f}"
+            self._attr_native_value = f"{stats.estimated_btc_sent * 1e-8:.2f}"
         elif sensor_type == "total_btc":
-            self._attr_native_value = f"{stats.total_btc * 0.00000001:.2f}"
+            self._attr_native_value = f"{stats.total_btc * 1e-8:.2f}"
         elif sensor_type == "total_blocks":
             self._attr_native_value = f"{stats.total_blocks:.0f}"
         elif sensor_type == "next_retarget":
@@ -222,7 +222,7 @@ class BitcoinSensor(SensorEntity):
         elif sensor_type == "estimated_transaction_volume_usd":
             self._attr_native_value = f"{stats.estimated_transaction_volume_usd:.2f}"
         elif sensor_type == "miners_revenue_btc":
-            self._attr_native_value = f"{stats.miners_revenue_btc * 0.00000001:.1f}"
+            self._attr_native_value = f"{stats.miners_revenue_btc * 1e-8:.1f}"
         elif sensor_type == "market_price_usd":
             self._attr_native_value = f"{stats.market_price_usd:.2f}"
 

homeassistant/components/bluesound/media_player.py

@@ -85,6 +85,7 @@ class BluesoundPlayer(CoordinatorEntity[BluesoundCoordinator], MediaPlayerEntity
     _attr_media_content_type = MediaType.MUSIC
     _attr_has_entity_name = True
     _attr_name = None
+    _attr_volume_step = 0.01
 
     def __init__(
         self,
@@ -688,24 +689,6 @@ class BluesoundPlayer(CoordinatorEntity[BluesoundCoordinator], MediaPlayerEntity
 
         await self._player.play_url(url)
 
-    async def async_volume_up(self) -> None:
-        """Volume up the media player."""
-        if self.volume_level is None:
-            return
-
-        new_volume = self.volume_level + 0.01
-        new_volume = min(1, new_volume)
-        await self.async_set_volume_level(new_volume)
-
-    async def async_volume_down(self) -> None:
-        """Volume down the media player."""
-        if self.volume_level is None:
-            return
-
-        new_volume = self.volume_level - 0.01
-        new_volume = max(0, new_volume)
-        await self.async_set_volume_level(new_volume)
-
     async def async_set_volume_level(self, volume: float) -> None:
         """Send volume_up command to media player."""
         volume = int(round(volume * 100))

homeassistant/components/button/trigger.py

@@ -14,7 +14,7 @@ from . import DOMAIN
 class ButtonPressedTrigger(EntityTriggerBase):
     """Trigger for button entity presses."""
 
-    _domain = DOMAIN
+    _domains = {DOMAIN}
     _schema = ENTITY_STATE_TRIGGER_SCHEMA
 
     def is_valid_transition(self, from_state: State, to_state: State) -> bool:

homeassistant/components/cambridge_audio/icons.json

@@ -29,6 +29,12 @@
       "early_update": {
         "default": "mdi:update"
       },
+      "equalizer": {
+        "default": "mdi:equalizer",
+        "state": {
+          "off": "mdi:equalizer-outline"
+        }
+      },
       "pre_amp": {
         "default": "mdi:volume-high",
         "state": {

homeassistant/components/cambridge_audio/strings.json

@@ -65,6 +65,9 @@
       "early_update": {
         "name": "Early update"
       },
+      "equalizer": {
+        "name": "Equalizer"
+      },
       "pre_amp": {
         "name": "Pre-Amp"
       },

homeassistant/components/cambridge_audio/switch.py

@@ -33,6 +33,13 @@ def room_correction_enabled(client: StreamMagicClient) -> bool:
     return client.audio.tilt_eq.enabled
 
 
+def equalizer_enabled(client: StreamMagicClient) -> bool:
+    """Check if equalizer is enabled."""
+    if TYPE_CHECKING:
+        assert client.audio.user_eq is not None
+    return client.audio.user_eq.enabled
+
+
 CONTROL_ENTITIES: tuple[CambridgeAudioSwitchEntityDescription, ...] = (
     CambridgeAudioSwitchEntityDescription(
         key="pre_amp",
@@ -56,6 +63,14 @@ CONTROL_ENTITIES: tuple[CambridgeAudioSwitchEntityDescription, ...] = (
         value_fn=room_correction_enabled,
         set_value_fn=lambda client, value: client.set_room_correction_mode(value),
     ),
+    CambridgeAudioSwitchEntityDescription(
+        key="equalizer",
+        translation_key="equalizer",
+        entity_category=EntityCategory.CONFIG,
+        load_fn=lambda client: client.audio.user_eq is not None,
+        value_fn=equalizer_enabled,
+        set_value_fn=lambda client, value: client.set_equalizer_mode(value),
+    ),
 )
 
 

homeassistant/components/climate/trigger.py

@@ -43,7 +43,7 @@ HVAC_MODE_CHANGED_TRIGGER_SCHEMA = ENTITY_STATE_TRIGGER_SCHEMA_FIRST_LAST.extend
 class HVACModeChangedTrigger(EntityTargetStateTriggerBase):
     """Trigger for entity state changes."""
 
-    _domain = DOMAIN
+    _domains = {DOMAIN}
     _schema = HVAC_MODE_CHANGED_TRIGGER_SCHEMA
 
     def __init__(self, hass: HomeAssistant, config: TriggerConfig) -> None:

homeassistant/components/conversation/http.py

@@ -48,6 +48,8 @@ def async_setup(hass: HomeAssistant) -> None:
         vol.Optional("conversation_id"): vol.Any(str, None),
         vol.Optional("language"): str,
         vol.Optional("agent_id"): agent_id_validator,
+        vol.Optional("device_id"): vol.Any(str, None),
+        vol.Optional("satellite_id"): vol.Any(str, None),
     }
 )
 @websocket_api.async_response
@@ -64,6 +66,8 @@ async def websocket_process(
         context=connection.context(msg),
         language=msg.get("language"),
         agent_id=msg.get("agent_id"),
+        device_id=msg.get("device_id"),
+        satellite_id=msg.get("satellite_id"),
     )
     connection.send_result(msg["id"], result.as_dict())
 
@@ -248,6 +252,8 @@ class ConversationProcessView(http.HomeAssistantView):
                 vol.Optional("conversation_id"): str,
                 vol.Optional("language"): str,
                 vol.Optional("agent_id"): agent_id_validator,
+                vol.Optional("device_id"): vol.Any(str, None),
+                vol.Optional("satellite_id"): vol.Any(str, None),
             }
         )
     )
@@ -262,6 +268,8 @@ class ConversationProcessView(http.HomeAssistantView):
             context=self.context(request),
             language=data.get("language"),
             agent_id=data.get("agent_id"),
+            device_id=data.get("device_id"),
+            satellite_id=data.get("satellite_id"),
         )
 
         return self.json(result.as_dict())

homeassistant/components/daikin/climate.py

@@ -112,11 +112,12 @@ def _zone_is_configured(zone: DaikinZone) -> bool:
 
 def _zone_temperature_lists(device: Appliance) -> tuple[list[str], list[str]]:
     """Return the decoded zone temperature lists."""
-    try:
-        heating = device.represent(DAIKIN_ZONE_TEMP_HEAT)[1]
-        cooling = device.represent(DAIKIN_ZONE_TEMP_COOL)[1]
-    except AttributeError, KeyError:
+    values = device.values
+    if DAIKIN_ZONE_TEMP_HEAT not in values or DAIKIN_ZONE_TEMP_COOL not in values:
         return ([], [])
+
+    heating = device.represent(DAIKIN_ZONE_TEMP_HEAT)[1]
+    cooling = device.represent(DAIKIN_ZONE_TEMP_COOL)[1]
     return (list(heating or []), list(cooling or []))
 
 

homeassistant/components/demo/media_player.py

@@ -139,18 +139,6 @@ class AbstractDemoPlayer(MediaPlayerEntity):
         self._attr_is_volume_muted = mute
         self.schedule_update_ha_state()
 
-    def volume_up(self) -> None:
-        """Increase volume."""
-        assert self.volume_level is not None
-        self._attr_volume_level = min(1.0, self.volume_level + 0.1)
-        self.schedule_update_ha_state()
-
-    def volume_down(self) -> None:
-        """Decrease volume."""
-        assert self.volume_level is not None
-        self._attr_volume_level = max(0.0, self.volume_level - 0.1)
-        self.schedule_update_ha_state()
-
     def set_volume_level(self, volume: float) -> None:
         """Set the volume level, range 0..1."""
         self._attr_volume_level = volume

homeassistant/components/dsmr/manifest.json

@@ -7,5 +7,5 @@
   "integration_type": "hub",
   "iot_class": "local_push",
   "loggers": ["dsmr_parser"],
-  "requirements": ["dsmr-parser==1.4.3"]
+  "requirements": ["dsmr-parser==1.5.0"]
 }

homeassistant/components/eafm/__init__.py

@@ -2,14 +2,39 @@
 
 from homeassistant.const import Platform
 from homeassistant.core import HomeAssistant
+from homeassistant.helpers import device_registry as dr
 
+from .const import DOMAIN
 from .coordinator import EafmConfigEntry, EafmCoordinator
 
 PLATFORMS = [Platform.SENSOR]
 
 
+def _fix_device_registry_identifiers(
+    hass: HomeAssistant, entry: EafmConfigEntry
+) -> None:
+    """Fix invalid identifiers in device registry.
+
+    Added in 2026.4, can be removed in 2026.10 or later.
+    """
+    device_registry = dr.async_get(hass)
+    for device_entry in dr.async_entries_for_config_entry(
+        device_registry, entry.entry_id
+    ):
+        old_identifier = (DOMAIN, "measure-id", entry.data["station"])
+        if old_identifier not in device_entry.identifiers:  # type: ignore[comparison-overlap]
+            continue
+        new_identifiers = device_entry.identifiers.copy()
+        new_identifiers.discard(old_identifier)  # type: ignore[arg-type]
+        new_identifiers.add((DOMAIN, entry.data["station"]))
+        device_registry.async_update_device(
+            device_entry.id, new_identifiers=new_identifiers
+        )
+
+
 async def async_setup_entry(hass: HomeAssistant, entry: EafmConfigEntry) -> bool:
     """Set up flood monitoring sensors for this config entry."""
+    _fix_device_registry_identifiers(hass, entry)
     coordinator = EafmCoordinator(hass, entry=entry)
     await coordinator.async_config_entry_first_refresh()
     entry.runtime_data = coordinator

homeassistant/components/eafm/sensor.py

@@ -94,11 +94,11 @@ class Measurement(CoordinatorEntity, SensorEntity):
         return self.coordinator.data["measures"][self.key]["parameterName"]
 
     @property
-    def device_info(self):
+    def device_info(self) -> DeviceInfo:
         """Return the device info."""
         return DeviceInfo(
             entry_type=DeviceEntryType.SERVICE,
-            identifiers={(DOMAIN, "measure-id", self.station_id)},
+            identifiers={(DOMAIN, self.station_id)},
             manufacturer="https://environment.data.gov.uk/",
             model=self.parameter_name,
             name=f"{self.station_name} {self.parameter_name} {self.qualifier}",

homeassistant/components/environment_canada/manifest.json

@@ -7,5 +7,5 @@
   "integration_type": "service",
   "iot_class": "cloud_polling",
   "loggers": ["env_canada"],
-  "requirements": ["env-canada==0.12.4"]
+  "requirements": ["env-canada==0.13.2"]
 }

homeassistant/components/esphome/entity.py

@@ -189,6 +189,7 @@ async def platform_async_setup_entry(
     info_type: type[_InfoT],
     entity_type: type[_EntityT],
     state_type: type[_StateT],
+    info_filter: Callable[[_InfoT], bool] | None = None,
 ) -> None:
     """Set up an esphome platform.
 
@@ -208,10 +209,22 @@ async def platform_async_setup_entry(
         entity_type,
         state_type,
     )
+
+    if info_filter is not None:
+
+        def on_filtered_update(infos: list[EntityInfo]) -> None:
+            on_static_info_update(
+                [info for info in infos if info_filter(cast(_InfoT, info))]
+            )
+
+        info_callback = on_filtered_update
+    else:
+        info_callback = on_static_info_update
+
     entry_data.cleanup_callbacks.append(
         entry_data.async_register_static_info_callback(
             info_type,
-            on_static_info_update,
+            info_callback,
         )
     )
 

homeassistant/components/esphome/entry_data.py

@@ -29,6 +29,7 @@ from aioesphomeapi import (
     Event,
     EventInfo,
     FanInfo,
+    InfraredInfo,
     LightInfo,
     LockInfo,
     MediaPlayerInfo,
@@ -85,6 +86,7 @@ INFO_TYPE_TO_PLATFORM: dict[type[EntityInfo], Platform] = {
     DateTimeInfo: Platform.DATETIME,
     EventInfo: Platform.EVENT,
     FanInfo: Platform.FAN,
+    InfraredInfo: Platform.INFRARED,
     LightInfo: Platform.LIGHT,
     LockInfo: Platform.LOCK,
     MediaPlayerInfo: Platform.MEDIA_PLAYER,

homeassistant/components/esphome/infrared.py

@@ -0,0 +1,59 @@
+"""Infrared platform for ESPHome."""
+
+from __future__ import annotations
+
+from functools import partial
+import logging
+
+from aioesphomeapi import EntityState, InfraredCapability, InfraredInfo
+
+from homeassistant.components.infrared import InfraredCommand, InfraredEntity
+from homeassistant.core import callback
+
+from .entity import (
+    EsphomeEntity,
+    convert_api_error_ha_error,
+    platform_async_setup_entry,
+)
+
+_LOGGER = logging.getLogger(__name__)
+
+PARALLEL_UPDATES = 0
+
+
+class EsphomeInfraredEntity(EsphomeEntity[InfraredInfo, EntityState], InfraredEntity):
+    """ESPHome infrared entity using native API."""
+
+    @callback
+    def _on_device_update(self) -> None:
+        """Call when device updates or entry data changes."""
+        super()._on_device_update()
+        if self._entry_data.available:
+            # Infrared entities should go available as soon as the device comes online
+            self.async_write_ha_state()
+
+    @convert_api_error_ha_error
+    async def async_send_command(self, command: InfraredCommand) -> None:
+        """Send an IR command."""
+        timings = [
+            interval
+            for timing in command.get_raw_timings()
+            for interval in (timing.high_us, -timing.low_us)
+        ]
+        _LOGGER.debug("Sending command: %s", timings)
+
+        self._client.infrared_rf_transmit_raw_timings(
+            self._static_info.key,
+            carrier_frequency=command.modulation,
+            timings=timings,
+            device_id=self._static_info.device_id,
+        )
+
+
+async_setup_entry = partial(
+    platform_async_setup_entry,
+    info_type=InfraredInfo,
+    entity_type=EsphomeInfraredEntity,
+    state_type=EntityState,
+    info_filter=lambda info: bool(info.capabilities & InfraredCapability.TRANSMITTER),
+)

homeassistant/components/esphome/light.py

@@ -241,7 +241,7 @@ class EsphomeLight(EsphomeEntity[LightInfo, LightState], LightEntity):
 
         if (color_temp_k := kwargs.get(ATTR_COLOR_TEMP_KELVIN)) is not None:
             # Do not use kelvin_to_mired here to prevent precision loss
-            data["color_temperature"] = 1000000.0 / color_temp_k
+            data["color_temperature"] = 1_000_000.0 / color_temp_k
             if color_temp_modes := _filter_color_modes(
                 color_modes, LightColorCapability.COLOR_TEMPERATURE
             ):

homeassistant/components/frontend/manifest.json

@@ -21,5 +21,5 @@
   "integration_type": "system",
   "preview_features": { "winter_mode": {} },
   "quality_scale": "internal",
-  "requirements": ["home-assistant-frontend==20260226.0"]
+  "requirements": ["home-assistant-frontend==20260302.0"]
 }

homeassistant/components/fully_kiosk/manifest.json

@@ -14,5 +14,5 @@
   "iot_class": "local_polling",
   "mqtt": ["fully/deviceInfo/+"],
   "quality_scale": "bronze",
-  "requirements": ["python-fullykiosk==0.0.14"]
+  "requirements": ["python-fullykiosk==0.0.15"]
 }

homeassistant/components/github/coordinator.py

@@ -78,6 +78,12 @@ query ($owner: String!, $repository: String!) {
         number
       }
     }
+    merged_pull_request: pullRequests(
+      first:1
+      states: MERGED
+    ) {
+      total: totalCount
+    }
     release: latestRelease {
       name
       url

homeassistant/components/github/icons.json

@@ -28,6 +28,9 @@
       "latest_tag": {
         "default": "mdi:tag"
       },
+      "merged_pulls_count": {
+        "default": "mdi:source-merge"
+      },
       "pulls_count": {
         "default": "mdi:source-pull"
       },

homeassistant/components/github/manifest.json

@@ -7,5 +7,5 @@
   "integration_type": "service",
   "iot_class": "cloud_polling",
   "loggers": ["aiogithubapi"],
-  "requirements": ["aiogithubapi==24.6.0"]
+  "requirements": ["aiogithubapi==26.0.0"]
 }

homeassistant/components/github/sensor.py

@@ -75,6 +75,13 @@ SENSOR_DESCRIPTIONS: tuple[GitHubSensorEntityDescription, ...] = (
         state_class=SensorStateClass.MEASUREMENT,
         value_fn=lambda data: data["pull_request"]["total"],
     ),
+    GitHubSensorEntityDescription(
+        key="merged_pulls_count",
+        translation_key="merged_pulls_count",
+        entity_category=EntityCategory.DIAGNOSTIC,
+        state_class=SensorStateClass.TOTAL,
+        value_fn=lambda data: data["merged_pull_request"]["total"],
+    ),
     GitHubSensorEntityDescription(
         key="latest_commit",
         translation_key="latest_commit",

homeassistant/components/github/strings.json

@@ -48,6 +48,10 @@
       "latest_tag": {
         "name": "Latest tag"
       },
+      "merged_pulls_count": {
+        "name": "Merged pull requests",
+        "unit_of_measurement": "pull requests"
+      },
       "pulls_count": {
         "name": "Pull requests",
         "unit_of_measurement": "pull requests"

homeassistant/components/govee_ble/manifest.json

@@ -54,6 +54,10 @@
       "connectable": false,
       "local_name": "GVH5110*"
     },
+    {
+      "connectable": false,
+      "local_name": "GV5140*"
+    },
     {
       "connectable": false,
       "manufacturer_id": 1,
@@ -140,5 +144,5 @@
   "documentation": "https://www.home-assistant.io/integrations/govee_ble",
   "integration_type": "device",
   "iot_class": "local_push",
-  "requirements": ["govee-ble==0.44.0"]
+  "requirements": ["govee-ble==1.2.0"]
 }

homeassistant/components/govee_ble/sensor.py

@@ -21,6 +21,7 @@ from homeassistant.components.sensor import (
 )
 from homeassistant.const import (
     CONCENTRATION_MICROGRAMS_PER_CUBIC_METER,
+    CONCENTRATION_PARTS_PER_MILLION,
     PERCENTAGE,
     SIGNAL_STRENGTH_DECIBELS_MILLIWATT,
     UnitOfTemperature,
@@ -72,6 +73,12 @@ SENSOR_DESCRIPTIONS = {
         native_unit_of_measurement=CONCENTRATION_MICROGRAMS_PER_CUBIC_METER,
         state_class=SensorStateClass.MEASUREMENT,
     ),
+    (DeviceClass.CO2, Units.CONCENTRATION_PARTS_PER_MILLION): SensorEntityDescription(
+        key=f"{DeviceClass.CO2}_{Units.CONCENTRATION_PARTS_PER_MILLION}",
+        device_class=SensorDeviceClass.CO2,
+        native_unit_of_measurement=CONCENTRATION_PARTS_PER_MILLION,
+        state_class=SensorStateClass.MEASUREMENT,
+    ),
 }
 
 

homeassistant/components/group/media_player.py

@@ -423,6 +423,20 @@ class MediaPlayerGroup(MediaPlayerEntity):
             context=self._context,
         )
 
+    async def async_volume_up(self) -> None:
+        """Turn volume up for media player(s)."""
+        for entity in self._features[KEY_VOLUME]:
+            volume_level = self.hass.states.get(entity).attributes["volume_level"]  # type: ignore[union-attr]
+            if volume_level < 1:
+                await self.async_set_volume_level(min(1, volume_level + 0.1))
+
+    async def async_volume_down(self) -> None:
+        """Turn volume down for media player(s)."""
+        for entity in self._features[KEY_VOLUME]:
+            volume_level = self.hass.states.get(entity).attributes["volume_level"]  # type: ignore[union-attr]
+            if volume_level > 0:
+                await self.async_set_volume_level(max(0, volume_level - 0.1))
+
     @callback
     def async_update_group_state(self) -> None:
         """Query all members and determine the media group state."""

homeassistant/components/hive/manifest.json

@@ -10,5 +10,5 @@
   "integration_type": "hub",
   "iot_class": "cloud_polling",
   "loggers": ["apyhiveapi"],
-  "requirements": ["pyhive-integration==1.0.7"]
+  "requirements": ["pyhive-integration==1.0.8"]
 }

homeassistant/components/knx/manifest.json

@@ -13,7 +13,7 @@
   "requirements": [
     "xknx==3.15.0",
     "xknxproject==3.8.2",
-    "knx-frontend==2026.2.25.165736"
+    "knx-frontend==2026.3.2.183756"
   ],
   "single_config_entry": true
 }

homeassistant/components/light/trigger.py

@@ -23,7 +23,7 @@ def _convert_uint8_to_percentage(value: Any) -> float:
 class BrightnessChangedTrigger(EntityNumericalStateAttributeChangedTriggerBase):
     """Trigger for brightness changed."""
 
-    _domain = DOMAIN
+    _domains = {DOMAIN}
     _attribute = ATTR_BRIGHTNESS
 
     _converter = staticmethod(_convert_uint8_to_percentage)
@@ -34,7 +34,7 @@ class BrightnessCrossedThresholdTrigger(
 ):
     """Trigger for brightness crossed threshold."""
 
-    _domain = DOMAIN
+    _domains = {DOMAIN}
     _attribute = ATTR_BRIGHTNESS
     _converter = staticmethod(_convert_uint8_to_percentage)
 

homeassistant/components/lutron_caseta/manifest.json

@@ -10,7 +10,7 @@
   "integration_type": "hub",
   "iot_class": "local_push",
   "loggers": ["pylutron_caseta"],
-  "requirements": ["pylutron-caseta==0.26.0"],
+  "requirements": ["pylutron-caseta==0.27.0"],
   "zeroconf": [
     {
       "properties": {

homeassistant/components/matter/const.py

@@ -2,6 +2,8 @@
 
 import logging
 
+from chip.clusters import Objects as clusters
+
 ADDON_SLUG = "core_matter_server"
 
 CONF_INTEGRATION_CREATED_ADDON = "integration_created_addon"
@@ -15,3 +17,100 @@ ID_TYPE_DEVICE_ID = "deviceid"
 ID_TYPE_SERIAL = "serial"
 
 FEATUREMAP_ATTRIBUTE_ID = 65532
+
+# --- Lock domain constants ---
+
+# Shared field keys
+ATTR_CREDENTIAL_RULE = "credential_rule"
+ATTR_MAX_CREDENTIALS_PER_USER = "max_credentials_per_user"
+ATTR_MAX_PIN_USERS = "max_pin_users"
+ATTR_MAX_RFID_USERS = "max_rfid_users"
+ATTR_MAX_USERS = "max_users"
+ATTR_SUPPORTS_USER_MGMT = "supports_user_management"
+ATTR_USER_INDEX = "user_index"
+ATTR_USER_NAME = "user_name"
+ATTR_USER_STATUS = "user_status"
+ATTR_USER_TYPE = "user_type"
+
+# Magic values
+CLEAR_ALL_INDEX = 0xFFFE  # Matter spec: pass to ClearUser/ClearCredential to clear all
+
+# Timed request timeout for lock commands that modify state.
+# 10 seconds accounts for Thread network latency and retransmissions.
+LOCK_TIMED_REQUEST_TIMEOUT_MS = 10000
+
+# Credential field keys
+ATTR_CREDENTIAL_DATA = "credential_data"
+ATTR_CREDENTIAL_INDEX = "credential_index"
+ATTR_CREDENTIAL_TYPE = "credential_type"
+
+# Credential type strings
+CRED_TYPE_FACE = "face"
+CRED_TYPE_FINGERPRINT = "fingerprint"
+CRED_TYPE_FINGER_VEIN = "finger_vein"
+CRED_TYPE_PIN = "pin"
+CRED_TYPE_RFID = "rfid"
+
+# User status mapping (Matter DoorLock UserStatusEnum)
+_UserStatus = clusters.DoorLock.Enums.UserStatusEnum
+USER_STATUS_MAP: dict[int, str] = {
+    _UserStatus.kAvailable: "available",
+    _UserStatus.kOccupiedEnabled: "occupied_enabled",
+    _UserStatus.kOccupiedDisabled: "occupied_disabled",
+}
+USER_STATUS_REVERSE_MAP: dict[str, int] = {v: k for k, v in USER_STATUS_MAP.items()}
+
+# User type mapping (Matter DoorLock UserTypeEnum)
+_UserType = clusters.DoorLock.Enums.UserTypeEnum
+USER_TYPE_MAP: dict[int, str] = {
+    _UserType.kUnrestrictedUser: "unrestricted_user",
+    _UserType.kYearDayScheduleUser: "year_day_schedule_user",
+    _UserType.kWeekDayScheduleUser: "week_day_schedule_user",
+    _UserType.kProgrammingUser: "programming_user",
+    _UserType.kNonAccessUser: "non_access_user",
+    _UserType.kForcedUser: "forced_user",
+    _UserType.kDisposableUser: "disposable_user",
+    _UserType.kExpiringUser: "expiring_user",
+    _UserType.kScheduleRestrictedUser: "schedule_restricted_user",
+    _UserType.kRemoteOnlyUser: "remote_only_user",
+}
+USER_TYPE_REVERSE_MAP: dict[str, int] = {v: k for k, v in USER_TYPE_MAP.items()}
+
+# Credential type mapping (Matter DoorLock CredentialTypeEnum)
+_CredentialType = clusters.DoorLock.Enums.CredentialTypeEnum
+CREDENTIAL_TYPE_MAP: dict[int, str] = {
+    _CredentialType.kProgrammingPIN: "programming_pin",
+    _CredentialType.kPin: CRED_TYPE_PIN,
+    _CredentialType.kRfid: CRED_TYPE_RFID,
+    _CredentialType.kFingerprint: CRED_TYPE_FINGERPRINT,
+    _CredentialType.kFingerVein: CRED_TYPE_FINGER_VEIN,
+    _CredentialType.kFace: CRED_TYPE_FACE,
+    _CredentialType.kAliroCredentialIssuerKey: "aliro_credential_issuer_key",
+    _CredentialType.kAliroEvictableEndpointKey: "aliro_evictable_endpoint_key",
+    _CredentialType.kAliroNonEvictableEndpointKey: "aliro_non_evictable_endpoint_key",
+}
+
+# Credential rule mapping (Matter DoorLock CredentialRuleEnum)
+_CredentialRule = clusters.DoorLock.Enums.CredentialRuleEnum
+CREDENTIAL_RULE_MAP: dict[int, str] = {
+    _CredentialRule.kSingle: "single",
+    _CredentialRule.kDual: "dual",
+    _CredentialRule.kTri: "tri",
+}
+CREDENTIAL_RULE_REVERSE_MAP: dict[str, int] = {
+    v: k for k, v in CREDENTIAL_RULE_MAP.items()
+}
+
+# Reverse mapping for credential types (str -> int)
+CREDENTIAL_TYPE_REVERSE_MAP: dict[str, int] = {
+    v: k for k, v in CREDENTIAL_TYPE_MAP.items()
+}
+
+# Credential types allowed in set/clear services (excludes programming_pin, aliro_*)
+SERVICE_CREDENTIAL_TYPES = [
+    CRED_TYPE_PIN,
+    CRED_TYPE_RFID,
+    CRED_TYPE_FINGERPRINT,
+    CRED_TYPE_FINGER_VEIN,
+    CRED_TYPE_FACE,
+]

homeassistant/components/matter/icons.json

@@ -174,6 +174,27 @@
     }
   },
   "services": {
+    "clear_lock_credential": {
+      "service": "mdi:key-remove"
+    },
+    "clear_lock_user": {
+      "service": "mdi:account-remove"
+    },
+    "get_lock_credential_status": {
+      "service": "mdi:key-chain"
+    },
+    "get_lock_info": {
+      "service": "mdi:lock-question"
+    },
+    "get_lock_users": {
+      "service": "mdi:account-multiple"
+    },
+    "set_lock_credential": {
+      "service": "mdi:key-plus"
+    },
+    "set_lock_user": {
+      "service": "mdi:account-lock"
+    },
     "water_heater_boost": {
       "service": "mdi:water-boiler"
     }

homeassistant/components/matter/lock.py

@@ -7,6 +7,7 @@ from dataclasses import dataclass
 from typing import Any
 
 from chip.clusters import Objects as clusters
+from matter_server.common.errors import MatterError
 from matter_server.common.models import EventType, MatterNodeEvent
 
 from homeassistant.components.lock import (
@@ -17,32 +18,56 @@ from homeassistant.components.lock import (
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import ATTR_CODE, Platform
 from homeassistant.core import HomeAssistant, callback
+from homeassistant.exceptions import HomeAssistantError
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
-from .const import LOGGER
+from .const import (
+    ATTR_CREDENTIAL_DATA,
+    ATTR_CREDENTIAL_INDEX,
+    ATTR_CREDENTIAL_RULE,
+    ATTR_CREDENTIAL_TYPE,
+    ATTR_USER_INDEX,
+    ATTR_USER_NAME,
+    ATTR_USER_STATUS,
+    ATTR_USER_TYPE,
+    LOCK_TIMED_REQUEST_TIMEOUT_MS,
+    LOGGER,
+)
 from .entity import MatterEntity, MatterEntityDescription
 from .helpers import get_matter
+from .lock_helpers import (
+    DoorLockFeature,
+    GetLockCredentialStatusResult,
+    GetLockInfoResult,
+    GetLockUsersResult,
+    SetLockCredentialResult,
+    clear_lock_credential,
+    clear_lock_user,
+    get_lock_credential_status,
+    get_lock_info,
+    get_lock_users,
+    set_lock_credential,
+    set_lock_user,
+)
 from .models import MatterDiscoverySchema
 
-DOOR_LOCK_OPERATION_SOURCE = {
-    # mapping from operation source id's to textual representation
-    0: "Unspecified",
-    1: "Manual",  # [Optional]
-    2: "Proprietary Remote",  # [Optional]
-    3: "Keypad",  # [Optional]
-    4: "Auto",  # [Optional]
-    5: "Button",  # [Optional]
-    6: "Schedule",  # [HDSCH]
-    7: "Remote",  # [M]
-    8: "RFID",  # [RID]
-    9: "Biometric",  # [USR]
-    10: "Aliro",  # [Aliro]
+# Door lock operation source mapping (Matter DoorLock OperationSourceEnum)
+_OperationSource = clusters.DoorLock.Enums.OperationSourceEnum
+DOOR_LOCK_OPERATION_SOURCE: dict[int, str] = {
+    _OperationSource.kUnspecified: "Unspecified",
+    _OperationSource.kManual: "Manual",
+    _OperationSource.kProprietaryRemote: "Proprietary Remote",
+    _OperationSource.kKeypad: "Keypad",
+    _OperationSource.kAuto: "Auto",
+    _OperationSource.kButton: "Button",
+    _OperationSource.kSchedule: "Schedule",
+    _OperationSource.kRemote: "Remote",
+    _OperationSource.kRfid: "RFID",
+    _OperationSource.kBiometric: "Biometric",
+    _OperationSource.kAliro: "Aliro",
 }
 
 
-DoorLockFeature = clusters.DoorLock.Bitmaps.Feature
-
-
 async def async_setup_entry(
     hass: HomeAssistant,
     config_entry: ConfigEntry,
@@ -98,17 +123,15 @@ class MatterLock(MatterEntity, LockEntity):
             node_event.data,
         )
 
-        # handle the DoorLock events
+        # Handle the DoorLock events
         node_event_data: dict[str, int] = node_event.data or {}
         match node_event.event_id:
-            case (
-                clusters.DoorLock.Events.LockOperation.event_id
-            ):  # Lock cluster event 2
-                # update the changed_by attribute to indicate lock operation source
+            case clusters.DoorLock.Events.LockOperation.event_id:
                 operation_source: int = node_event_data.get("operationSource", -1)
-                self._attr_changed_by = DOOR_LOCK_OPERATION_SOURCE.get(
+                source_name = DOOR_LOCK_OPERATION_SOURCE.get(
                     operation_source, "Unknown"
                 )
+                self._attr_changed_by = source_name
                 self.async_write_ha_state()
 
     @property
@@ -146,7 +169,7 @@ class MatterLock(MatterEntity, LockEntity):
         code_bytes = code.encode() if code else None
         await self.send_device_command(
             command=clusters.DoorLock.Commands.LockDoor(code_bytes),
-            timed_request_timeout_ms=1000,
+            timed_request_timeout_ms=LOCK_TIMED_REQUEST_TIMEOUT_MS,
         )
 
     async def async_unlock(self, **kwargs: Any) -> None:
@@ -168,12 +191,12 @@ class MatterLock(MatterEntity, LockEntity):
             # and unlatch on the HA 'open' command.
             await self.send_device_command(
                 command=clusters.DoorLock.Commands.UnboltDoor(code_bytes),
-                timed_request_timeout_ms=1000,
+                timed_request_timeout_ms=LOCK_TIMED_REQUEST_TIMEOUT_MS,
             )
         else:
             await self.send_device_command(
                 command=clusters.DoorLock.Commands.UnlockDoor(code_bytes),
-                timed_request_timeout_ms=1000,
+                timed_request_timeout_ms=LOCK_TIMED_REQUEST_TIMEOUT_MS,
             )
 
     async def async_open(self, **kwargs: Any) -> None:
@@ -190,7 +213,7 @@ class MatterLock(MatterEntity, LockEntity):
         code_bytes = code.encode() if code else None
         await self.send_device_command(
             command=clusters.DoorLock.Commands.UnlockDoor(code_bytes),
-            timed_request_timeout_ms=1000,
+            timed_request_timeout_ms=LOCK_TIMED_REQUEST_TIMEOUT_MS,
         )
 
     @callback
@@ -256,6 +279,109 @@ class MatterLock(MatterEntity, LockEntity):
             supported_features |= LockEntityFeature.OPEN
         self._attr_supported_features = supported_features
 
+    # --- Entity service methods ---
+
+    async def async_set_lock_user(self, **kwargs: Any) -> None:
+        """Set a lock user (full CRUD)."""
+        try:
+            await set_lock_user(
+                self.matter_client,
+                self._endpoint.node,
+                user_index=kwargs.get(ATTR_USER_INDEX),
+                user_name=kwargs.get(ATTR_USER_NAME),
+                user_type=kwargs.get(ATTR_USER_TYPE),
+                credential_rule=kwargs.get(ATTR_CREDENTIAL_RULE),
+            )
+        except MatterError as err:
+            raise HomeAssistantError(
+                f"Failed to set lock user on {self.entity_id}: {err}"
+            ) from err
+
+    async def async_clear_lock_user(self, **kwargs: Any) -> None:
+        """Clear a lock user."""
+        try:
+            await clear_lock_user(
+                self.matter_client,
+                self._endpoint.node,
+                kwargs[ATTR_USER_INDEX],
+            )
+        except MatterError as err:
+            raise HomeAssistantError(
+                f"Failed to clear lock user on {self.entity_id}: {err}"
+            ) from err
+
+    async def async_get_lock_info(self) -> GetLockInfoResult:
+        """Get lock capabilities and configuration info."""
+        try:
+            return await get_lock_info(
+                self.matter_client,
+                self._endpoint.node,
+            )
+        except MatterError as err:
+            raise HomeAssistantError(
+                f"Failed to get lock info for {self.entity_id}: {err}"
+            ) from err
+
+    async def async_get_lock_users(self) -> GetLockUsersResult:
+        """Get all users from the lock."""
+        try:
+            return await get_lock_users(
+                self.matter_client,
+                self._endpoint.node,
+            )
+        except MatterError as err:
+            raise HomeAssistantError(
+                f"Failed to get lock users for {self.entity_id}: {err}"
+            ) from err
+
+    async def async_set_lock_credential(self, **kwargs: Any) -> SetLockCredentialResult:
+        """Set a credential on the lock."""
+        try:
+            return await set_lock_credential(
+                self.matter_client,
+                self._endpoint.node,
+                credential_type=kwargs[ATTR_CREDENTIAL_TYPE],
+                credential_data=kwargs[ATTR_CREDENTIAL_DATA],
+                credential_index=kwargs.get(ATTR_CREDENTIAL_INDEX),
+                user_index=kwargs.get(ATTR_USER_INDEX),
+                user_status=kwargs.get(ATTR_USER_STATUS),
+                user_type=kwargs.get(ATTR_USER_TYPE),
+            )
+        except MatterError as err:
+            raise HomeAssistantError(
+                f"Failed to set lock credential on {self.entity_id}: {err}"
+            ) from err
+
+    async def async_clear_lock_credential(self, **kwargs: Any) -> None:
+        """Clear a credential from the lock."""
+        try:
+            await clear_lock_credential(
+                self.matter_client,
+                self._endpoint.node,
+                credential_type=kwargs[ATTR_CREDENTIAL_TYPE],
+                credential_index=kwargs[ATTR_CREDENTIAL_INDEX],
+            )
+        except MatterError as err:
+            raise HomeAssistantError(
+                f"Failed to clear lock credential on {self.entity_id}: {err}"
+            ) from err
+
+    async def async_get_lock_credential_status(
+        self, **kwargs: Any
+    ) -> GetLockCredentialStatusResult:
+        """Get the status of a credential slot on the lock."""
+        try:
+            return await get_lock_credential_status(
+                self.matter_client,
+                self._endpoint.node,
+                credential_type=kwargs[ATTR_CREDENTIAL_TYPE],
+                credential_index=kwargs[ATTR_CREDENTIAL_INDEX],
+            )
+        except MatterError as err:
+            raise HomeAssistantError(
+                f"Failed to get credential status for {self.entity_id}: {err}"
+            ) from err
+
 
 DISCOVERY_SCHEMAS = [
     MatterDiscoverySchema(

homeassistant/components/matter/lock_helpers.py

@@ -0,0 +1,843 @@
+"""Lock-specific helpers for the Matter integration.
+
+Provides DoorLock cluster endpoint resolution, feature detection, and
+business logic for lock user/credential management.
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any, TypedDict
+
+from chip.clusters import Objects as clusters
+from chip.clusters.Types import NullValue
+
+from homeassistant.exceptions import HomeAssistantError, ServiceValidationError
+
+from .const import (
+    CRED_TYPE_FACE,
+    CRED_TYPE_FINGER_VEIN,
+    CRED_TYPE_FINGERPRINT,
+    CRED_TYPE_PIN,
+    CRED_TYPE_RFID,
+    CREDENTIAL_RULE_MAP,
+    CREDENTIAL_RULE_REVERSE_MAP,
+    CREDENTIAL_TYPE_MAP,
+    CREDENTIAL_TYPE_REVERSE_MAP,
+    LOCK_TIMED_REQUEST_TIMEOUT_MS,
+    USER_STATUS_MAP,
+    USER_STATUS_REVERSE_MAP,
+    USER_TYPE_MAP,
+    USER_TYPE_REVERSE_MAP,
+)
+
+# Error translation keys (used in ServiceValidationError/HomeAssistantError)
+ERR_CREDENTIAL_TYPE_NOT_SUPPORTED = "credential_type_not_supported"
+ERR_INVALID_CREDENTIAL_DATA = "invalid_credential_data"
+
+# SetCredential response status mapping (Matter DlStatus)
+_DlStatus = clusters.DoorLock.Enums.DlStatus
+SET_CREDENTIAL_STATUS_MAP: dict[int, str] = {
+    _DlStatus.kSuccess: "success",
+    _DlStatus.kFailure: "failure",
+    _DlStatus.kDuplicate: "duplicate",
+    _DlStatus.kOccupied: "occupied",
+}
+
+if TYPE_CHECKING:
+    from matter_server.client import MatterClient
+    from matter_server.client.models.node import MatterEndpoint, MatterNode
+
+# DoorLock Feature bitmap from Matter SDK
+DoorLockFeature = clusters.DoorLock.Bitmaps.Feature
+
+
+# --- TypedDicts for service action responses ---
+
+
+class LockUserCredentialData(TypedDict):
+    """Credential data within a user response."""
+
+    type: str
+    index: int | None
+
+
+class LockUserData(TypedDict):
+    """User data returned from lock queries."""
+
+    user_index: int | None
+    user_name: str | None
+    user_unique_id: int | None
+    user_status: str
+    user_type: str
+    credential_rule: str
+    credentials: list[LockUserCredentialData]
+    next_user_index: int | None
+
+
+class SetLockUserResult(TypedDict):
+    """Result of set_lock_user service action."""
+
+    user_index: int
+
+
+class GetLockUsersResult(TypedDict):
+    """Result of get_lock_users service action."""
+
+    max_users: int
+    users: list[LockUserData]
+
+
+class GetLockInfoResult(TypedDict):
+    """Result of get_lock_info service action."""
+
+    supports_user_management: bool
+    supported_credential_types: list[str]
+    max_users: int | None
+    max_pin_users: int | None
+    max_rfid_users: int | None
+    max_credentials_per_user: int | None
+    min_pin_length: int | None
+    max_pin_length: int | None
+    min_rfid_length: int | None
+    max_rfid_length: int | None
+
+
+class SetLockCredentialResult(TypedDict):
+    """Result of set_lock_credential service action."""
+
+    credential_index: int
+    user_index: int | None
+    next_credential_index: int | None
+
+
+class GetLockCredentialStatusResult(TypedDict):
+    """Result of get_lock_credential_status service action."""
+
+    credential_exists: bool
+    user_index: int | None
+    next_credential_index: int | None
+
+
+def _get_lock_endpoint_from_node(node: MatterNode) -> MatterEndpoint | None:
+    """Get the DoorLock endpoint from a node.
+
+    Returns the first endpoint that has the DoorLock cluster, or None if not found.
+    """
+    for endpoint in node.endpoints.values():
+        if endpoint.has_cluster(clusters.DoorLock):
+            return endpoint
+    return None
+
+
+def _get_feature_map(endpoint: MatterEndpoint) -> int | None:
+    """Read the DoorLock FeatureMap attribute from an endpoint."""
+    value: int | None = endpoint.get_attribute_value(
+        None, clusters.DoorLock.Attributes.FeatureMap
+    )
+    return value
+
+
+def _lock_supports_usr_feature(endpoint: MatterEndpoint) -> bool:
+    """Check if lock endpoint supports USR (User) feature.
+
+    The USR feature indicates the lock supports user and credential management
+    commands like SetUser, GetUser, SetCredential, etc.
+    """
+    feature_map = _get_feature_map(endpoint)
+    if feature_map is None:
+        return False
+    return bool(feature_map & DoorLockFeature.kUser)
+
+
+# --- Pure utility functions ---
+
+
+def _get_attr(obj: Any, attr: str) -> Any:
+    """Get attribute from object or dict.
+
+    Matter SDK responses can be either dataclass objects or dicts depending on
+    the SDK version and serialization context. NullValue (a truthy,
+    non-iterable singleton) is normalized to None.
+    """
+    if isinstance(obj, dict):
+        value = obj.get(attr)
+    else:
+        value = getattr(obj, attr, None)
+    # The Matter SDK uses NullValue for nullable fields instead of None.
+    if value is NullValue:
+        return None
+    return value
+
+
+def _get_supported_credential_types(feature_map: int) -> list[str]:
+    """Get list of supported credential types from feature map."""
+    types = []
+    if feature_map & DoorLockFeature.kPinCredential:
+        types.append(CRED_TYPE_PIN)
+    if feature_map & DoorLockFeature.kRfidCredential:
+        types.append(CRED_TYPE_RFID)
+    if feature_map & DoorLockFeature.kFingerCredentials:
+        types.append(CRED_TYPE_FINGERPRINT)
+    if feature_map & DoorLockFeature.kFaceCredentials:
+        types.append(CRED_TYPE_FACE)
+    return types
+
+
+def _format_user_response(user_data: Any) -> LockUserData | None:
+    """Format GetUser response to API response format.
+
+    Returns None if the user slot is empty (no userStatus).
+    """
+    if user_data is None:
+        return None
+
+    user_status = _get_attr(user_data, "userStatus")
+    if user_status is None:
+        return None
+
+    creds = _get_attr(user_data, "credentials")
+    credentials: list[LockUserCredentialData] = [
+        LockUserCredentialData(
+            type=CREDENTIAL_TYPE_MAP.get(_get_attr(cred, "credentialType"), "unknown"),
+            index=_get_attr(cred, "credentialIndex"),
+        )
+        for cred in (creds or [])
+    ]
+
+    return LockUserData(
+        user_index=_get_attr(user_data, "userIndex"),
+        user_name=_get_attr(user_data, "userName"),
+        user_unique_id=_get_attr(user_data, "userUniqueID"),
+        user_status=USER_STATUS_MAP.get(user_status, "unknown"),
+        user_type=USER_TYPE_MAP.get(_get_attr(user_data, "userType"), "unknown"),
+        credential_rule=CREDENTIAL_RULE_MAP.get(
+            _get_attr(user_data, "credentialRule"), "unknown"
+        ),
+        credentials=credentials,
+        next_user_index=_get_attr(user_data, "nextUserIndex"),
+    )
+
+
+# --- Credential management helpers ---
+
+
+class LockEndpointNotFoundError(HomeAssistantError):
+    """Lock endpoint not found on node."""
+
+
+class UsrFeatureNotSupportedError(ServiceValidationError):
+    """Lock does not support USR (user management) feature."""
+
+
+class UserSlotEmptyError(ServiceValidationError):
+    """User slot is empty."""
+
+
+class NoAvailableUserSlotsError(ServiceValidationError):
+    """No available user slots on the lock."""
+
+
+class CredentialTypeNotSupportedError(ServiceValidationError):
+    """Lock does not support the requested credential type."""
+
+
+class CredentialDataInvalidError(ServiceValidationError):
+    """Credential data fails validation."""
+
+
+class SetCredentialFailedError(HomeAssistantError):
+    """SetCredential command returned a non-success status."""
+
+
+def _get_lock_endpoint_or_raise(node: MatterNode) -> MatterEndpoint:
+    """Get the DoorLock endpoint from a node or raise an error."""
+    lock_endpoint = _get_lock_endpoint_from_node(node)
+    if lock_endpoint is None:
+        raise LockEndpointNotFoundError("No lock endpoint found on this device")
+    return lock_endpoint
+
+
+def _ensure_usr_support(lock_endpoint: MatterEndpoint) -> None:
+    """Ensure the lock endpoint supports USR (user management) feature.
+
+    Raises UsrFeatureNotSupportedError if the lock doesn't support user management.
+    """
+    if not _lock_supports_usr_feature(lock_endpoint):
+        raise UsrFeatureNotSupportedError(
+            "Lock does not support user/credential management"
+        )
+
+
+# --- High-level business logic functions ---
+
+
+async def get_lock_info(
+    matter_client: MatterClient,
+    node: MatterNode,
+) -> GetLockInfoResult:
+    """Get lock capabilities and configuration info.
+
+    Returns a typed dict with lock capability information.
+    Raises HomeAssistantError if lock endpoint not found.
+    """
+    lock_endpoint = _get_lock_endpoint_or_raise(node)
+    supports_usr = _lock_supports_usr_feature(lock_endpoint)
+
+    # Get feature map for credential type detection
+    feature_map = (
+        lock_endpoint.get_attribute_value(None, clusters.DoorLock.Attributes.FeatureMap)
+        or 0
+    )
+
+    result = GetLockInfoResult(
+        supports_user_management=supports_usr,
+        supported_credential_types=_get_supported_credential_types(feature_map),
+        max_users=None,
+        max_pin_users=None,
+        max_rfid_users=None,
+        max_credentials_per_user=None,
+        min_pin_length=None,
+        max_pin_length=None,
+        min_rfid_length=None,
+        max_rfid_length=None,
+    )
+
+    # Populate capacity info if USR feature is supported
+    if supports_usr:
+        result["max_users"] = lock_endpoint.get_attribute_value(
+            None, clusters.DoorLock.Attributes.NumberOfTotalUsersSupported
+        )
+        result["max_pin_users"] = lock_endpoint.get_attribute_value(
+            None, clusters.DoorLock.Attributes.NumberOfPINUsersSupported
+        )
+        result["max_rfid_users"] = lock_endpoint.get_attribute_value(
+            None, clusters.DoorLock.Attributes.NumberOfRFIDUsersSupported
+        )
+        result["max_credentials_per_user"] = lock_endpoint.get_attribute_value(
+            None, clusters.DoorLock.Attributes.NumberOfCredentialsSupportedPerUser
+        )
+        result["min_pin_length"] = lock_endpoint.get_attribute_value(
+            None, clusters.DoorLock.Attributes.MinPINCodeLength
+        )
+        result["max_pin_length"] = lock_endpoint.get_attribute_value(
+            None, clusters.DoorLock.Attributes.MaxPINCodeLength
+        )
+        result["min_rfid_length"] = lock_endpoint.get_attribute_value(
+            None, clusters.DoorLock.Attributes.MinRFIDCodeLength
+        )
+        result["max_rfid_length"] = lock_endpoint.get_attribute_value(
+            None, clusters.DoorLock.Attributes.MaxRFIDCodeLength
+        )
+
+    return result
+
+
+async def set_lock_user(
+    matter_client: MatterClient,
+    node: MatterNode,
+    *,
+    user_index: int | None = None,
+    user_name: str | None = None,
+    user_unique_id: int | None = None,
+    user_status: str | None = None,
+    user_type: str | None = None,
+    credential_rule: str | None = None,
+) -> SetLockUserResult:
+    """Add or update a user on the lock.
+
+    When user_status, user_type, or credential_rule is None, defaults are used
+    for new users and existing values are preserved for modifications.
+
+    Returns typed dict with user_index on success.
+    Raises HomeAssistantError on failure.
+    """
+    lock_endpoint = _get_lock_endpoint_or_raise(node)
+    _ensure_usr_support(lock_endpoint)
+
+    if user_index is None:
+        # Adding new user - find first available slot
+        max_users = (
+            lock_endpoint.get_attribute_value(
+                None, clusters.DoorLock.Attributes.NumberOfTotalUsersSupported
+            )
+            or 0
+        )
+
+        for idx in range(1, max_users + 1):
+            get_user_response = await matter_client.send_device_command(
+                node_id=node.node_id,
+                endpoint_id=lock_endpoint.endpoint_id,
+                command=clusters.DoorLock.Commands.GetUser(userIndex=idx),
+            )
+            if _get_attr(get_user_response, "userStatus") is None:
+                user_index = idx
+                break
+
+        if user_index is None:
+            raise NoAvailableUserSlotsError("No available user slots on the lock")
+
+        user_status_enum = (
+            USER_STATUS_REVERSE_MAP.get(
+                user_status,
+                clusters.DoorLock.Enums.UserStatusEnum.kOccupiedEnabled,
+            )
+            if user_status is not None
+            else clusters.DoorLock.Enums.UserStatusEnum.kOccupiedEnabled
+        )
+
+        await matter_client.send_device_command(
+            node_id=node.node_id,
+            endpoint_id=lock_endpoint.endpoint_id,
+            command=clusters.DoorLock.Commands.SetUser(
+                operationType=clusters.DoorLock.Enums.DataOperationTypeEnum.kAdd,
+                userIndex=user_index,
+                userName=user_name,
+                userUniqueID=user_unique_id,
+                userStatus=user_status_enum,
+                userType=USER_TYPE_REVERSE_MAP.get(
+                    user_type,
+                    clusters.DoorLock.Enums.UserTypeEnum.kUnrestrictedUser,
+                )
+                if user_type is not None
+                else clusters.DoorLock.Enums.UserTypeEnum.kUnrestrictedUser,
+                credentialRule=CREDENTIAL_RULE_REVERSE_MAP.get(
+                    credential_rule,
+                    clusters.DoorLock.Enums.CredentialRuleEnum.kSingle,
+                )
+                if credential_rule is not None
+                else clusters.DoorLock.Enums.CredentialRuleEnum.kSingle,
+            ),
+            timed_request_timeout_ms=LOCK_TIMED_REQUEST_TIMEOUT_MS,
+        )
+    else:
+        # Updating existing user - preserve existing values when not specified
+        get_user_response = await matter_client.send_device_command(
+            node_id=node.node_id,
+            endpoint_id=lock_endpoint.endpoint_id,
+            command=clusters.DoorLock.Commands.GetUser(userIndex=user_index),
+        )
+
+        if _get_attr(get_user_response, "userStatus") is None:
+            raise UserSlotEmptyError(f"User slot {user_index} is empty")
+
+        resolved_user_name = (
+            user_name
+            if user_name is not None
+            else _get_attr(get_user_response, "userName")
+        )
+        resolved_unique_id = (
+            user_unique_id
+            if user_unique_id is not None
+            else _get_attr(get_user_response, "userUniqueID")
+        )
+
+        resolved_status = (
+            USER_STATUS_REVERSE_MAP[user_status]
+            if user_status is not None
+            else _get_attr(get_user_response, "userStatus")
+        )
+
+        resolved_type = (
+            USER_TYPE_REVERSE_MAP[user_type]
+            if user_type is not None
+            else _get_attr(get_user_response, "userType")
+        )
+
+        resolved_rule = (
+            CREDENTIAL_RULE_REVERSE_MAP[credential_rule]
+            if credential_rule is not None
+            else _get_attr(get_user_response, "credentialRule")
+        )
+
+        await matter_client.send_device_command(
+            node_id=node.node_id,
+            endpoint_id=lock_endpoint.endpoint_id,
+            command=clusters.DoorLock.Commands.SetUser(
+                operationType=clusters.DoorLock.Enums.DataOperationTypeEnum.kModify,
+                userIndex=user_index,
+                userName=resolved_user_name,
+                userUniqueID=resolved_unique_id,
+                userStatus=resolved_status,
+                userType=resolved_type,
+                credentialRule=resolved_rule,
+            ),
+            timed_request_timeout_ms=LOCK_TIMED_REQUEST_TIMEOUT_MS,
+        )
+
+    return SetLockUserResult(user_index=user_index)
+
+
+async def get_lock_users(
+    matter_client: MatterClient,
+    node: MatterNode,
+) -> GetLockUsersResult:
+    """Get all users from the lock.
+
+    Returns typed dict with users list and max_users capacity.
+    Raises HomeAssistantError on failure.
+    """
+    lock_endpoint = _get_lock_endpoint_or_raise(node)
+    _ensure_usr_support(lock_endpoint)
+
+    max_users = (
+        lock_endpoint.get_attribute_value(
+            None, clusters.DoorLock.Attributes.NumberOfTotalUsersSupported
+        )
+        or 0
+    )
+
+    users: list[LockUserData] = []
+    current_index = 1
+
+    # Iterate through users using next_user_index for efficiency
+    while current_index is not None and current_index <= max_users:
+        get_user_response = await matter_client.send_device_command(
+            node_id=node.node_id,
+            endpoint_id=lock_endpoint.endpoint_id,
+            command=clusters.DoorLock.Commands.GetUser(
+                userIndex=current_index,
+            ),
+        )
+
+        user_data = _format_user_response(get_user_response)
+        if user_data is not None:
+            users.append(user_data)
+
+        # Move to next user index
+        next_index = _get_attr(get_user_response, "nextUserIndex")
+        if next_index is None or next_index <= current_index:
+            break
+        current_index = next_index
+
+    return GetLockUsersResult(
+        max_users=max_users,
+        users=users,
+    )
+
+
+async def clear_lock_user(
+    matter_client: MatterClient,
+    node: MatterNode,
+    user_index: int,
+) -> None:
+    """Clear a user from the lock.
+
+    Per the Matter spec, ClearUser also clears all associated credentials
+    and schedules for the user.
+    Use index 0xFFFE (CLEAR_ALL_INDEX) to clear all users.
+    Raises HomeAssistantError on failure.
+    """
+    lock_endpoint = _get_lock_endpoint_or_raise(node)
+    _ensure_usr_support(lock_endpoint)
+
+    await matter_client.send_device_command(
+        node_id=node.node_id,
+        endpoint_id=lock_endpoint.endpoint_id,
+        command=clusters.DoorLock.Commands.ClearUser(
+            userIndex=user_index,
+        ),
+        timed_request_timeout_ms=LOCK_TIMED_REQUEST_TIMEOUT_MS,
+    )
+
+
+# --- Credential validation helpers ---
+
+# Map credential type strings to the feature bit that must be set
+_CREDENTIAL_TYPE_FEATURE_MAP: dict[str, int] = {
+    CRED_TYPE_PIN: DoorLockFeature.kPinCredential,
+    CRED_TYPE_RFID: DoorLockFeature.kRfidCredential,
+    CRED_TYPE_FINGERPRINT: DoorLockFeature.kFingerCredentials,
+    CRED_TYPE_FINGER_VEIN: DoorLockFeature.kFingerCredentials,
+    CRED_TYPE_FACE: DoorLockFeature.kFaceCredentials,
+}
+
+# Map credential type strings to the capacity attribute for slot iteration.
+# Biometric types have no dedicated capacity attribute; fall back to total users.
+_CREDENTIAL_TYPE_CAPACITY_ATTR = {
+    CRED_TYPE_PIN: clusters.DoorLock.Attributes.NumberOfPINUsersSupported,
+    CRED_TYPE_RFID: clusters.DoorLock.Attributes.NumberOfRFIDUsersSupported,
+}
+
+
+def _validate_credential_type_support(
+    lock_endpoint: MatterEndpoint, credential_type: str
+) -> None:
+    """Validate the lock supports the requested credential type.
+
+    Raises CredentialTypeNotSupportedError if not supported.
+    """
+    required_bit = _CREDENTIAL_TYPE_FEATURE_MAP.get(credential_type)
+    if required_bit is None:
+        raise CredentialTypeNotSupportedError(
+            translation_domain="matter",
+            translation_key=ERR_CREDENTIAL_TYPE_NOT_SUPPORTED,
+            translation_placeholders={"credential_type": credential_type},
+        )
+
+    feature_map = _get_feature_map(lock_endpoint) or 0
+    if not (feature_map & required_bit):
+        raise CredentialTypeNotSupportedError(
+            translation_domain="matter",
+            translation_key=ERR_CREDENTIAL_TYPE_NOT_SUPPORTED,
+            translation_placeholders={"credential_type": credential_type},
+        )
+
+
+def _validate_credential_data(
+    lock_endpoint: MatterEndpoint, credential_type: str, credential_data: str
+) -> None:
+    """Validate credential data against lock constraints.
+
+    For PIN: checks digits-only and length against Min/MaxPINCodeLength.
+    For RFID: checks valid hex and byte length against Min/MaxRFIDCodeLength.
+    Raises CredentialDataInvalidError on failure.
+    """
+    if credential_type == CRED_TYPE_PIN:
+        if not credential_data.isdigit():
+            raise CredentialDataInvalidError(
+                translation_domain="matter",
+                translation_key=ERR_INVALID_CREDENTIAL_DATA,
+                translation_placeholders={"reason": "PIN must contain only digits"},
+            )
+        min_len = (
+            lock_endpoint.get_attribute_value(
+                None, clusters.DoorLock.Attributes.MinPINCodeLength
+            )
+            or 0
+        )
+        max_len = (
+            lock_endpoint.get_attribute_value(
+                None, clusters.DoorLock.Attributes.MaxPINCodeLength
+            )
+            or 255
+        )
+        if not min_len <= len(credential_data) <= max_len:
+            raise CredentialDataInvalidError(
+                translation_domain="matter",
+                translation_key=ERR_INVALID_CREDENTIAL_DATA,
+                translation_placeholders={
+                    "reason": (f"PIN length must be between {min_len} and {max_len}")
+                },
+            )
+
+    elif credential_type == CRED_TYPE_RFID:
+        try:
+            rfid_bytes = bytes.fromhex(credential_data)
+        except ValueError as err:
+            raise CredentialDataInvalidError(
+                translation_domain="matter",
+                translation_key=ERR_INVALID_CREDENTIAL_DATA,
+                translation_placeholders={
+                    "reason": "RFID data must be valid hexadecimal"
+                },
+            ) from err
+        min_len = (
+            lock_endpoint.get_attribute_value(
+                None, clusters.DoorLock.Attributes.MinRFIDCodeLength
+            )
+            or 0
+        )
+        max_len = (
+            lock_endpoint.get_attribute_value(
+                None, clusters.DoorLock.Attributes.MaxRFIDCodeLength
+            )
+            or 255
+        )
+        if not min_len <= len(rfid_bytes) <= max_len:
+            raise CredentialDataInvalidError(
+                translation_domain="matter",
+                translation_key=ERR_INVALID_CREDENTIAL_DATA,
+                translation_placeholders={
+                    "reason": (
+                        f"RFID data length must be between"
+                        f" {min_len} and {max_len} bytes"
+                    )
+                },
+            )
+
+
+def _credential_data_to_bytes(credential_type: str, credential_data: str) -> bytes:
+    """Convert credential data string to bytes for the Matter command."""
+    if credential_type == CRED_TYPE_RFID:
+        return bytes.fromhex(credential_data)
+    # PIN and other types: encode as UTF-8
+    return credential_data.encode()
+
+
+# --- Credential business logic functions ---
+
+
+async def set_lock_credential(
+    matter_client: MatterClient,
+    node: MatterNode,
+    *,
+    credential_type: str,
+    credential_data: str,
+    credential_index: int | None = None,
+    user_index: int | None = None,
+    user_status: str | None = None,
+    user_type: str | None = None,
+) -> SetLockCredentialResult:
+    """Add or modify a credential on the lock.
+
+    Returns typed dict with credential_index, user_index, and next_credential_index.
+    Raises ServiceValidationError for validation failures.
+    Raises HomeAssistantError for device communication failures.
+    """
+    lock_endpoint = _get_lock_endpoint_or_raise(node)
+    _ensure_usr_support(lock_endpoint)
+    _validate_credential_type_support(lock_endpoint, credential_type)
+    _validate_credential_data(lock_endpoint, credential_type, credential_data)
+
+    cred_type_int = CREDENTIAL_TYPE_REVERSE_MAP[credential_type]
+    cred_data_bytes = _credential_data_to_bytes(credential_type, credential_data)
+
+    # Determine operation type and credential index
+    operation_type = clusters.DoorLock.Enums.DataOperationTypeEnum.kAdd
+
+    if credential_index is None:
+        # Auto-find first available credential slot.
+        # Use the credential-type-specific capacity as the upper bound.
+        max_creds_attr = _CREDENTIAL_TYPE_CAPACITY_ATTR.get(
+            credential_type,
+            clusters.DoorLock.Attributes.NumberOfTotalUsersSupported,
+        )
+        max_creds_raw = lock_endpoint.get_attribute_value(None, max_creds_attr)
+        max_creds = (
+            max_creds_raw if isinstance(max_creds_raw, int) and max_creds_raw > 0 else 5
+        )
+        for idx in range(1, max_creds + 1):
+            status_response = await matter_client.send_device_command(
+                node_id=node.node_id,
+                endpoint_id=lock_endpoint.endpoint_id,
+                command=clusters.DoorLock.Commands.GetCredentialStatus(
+                    credential=clusters.DoorLock.Structs.CredentialStruct(
+                        credentialType=cred_type_int,
+                        credentialIndex=idx,
+                    ),
+                ),
+            )
+            if not _get_attr(status_response, "credentialExists"):
+                credential_index = idx
+                break
+
+        if credential_index is None:
+            raise NoAvailableUserSlotsError("No available credential slots on the lock")
+    else:
+        # Check if slot is occupied to determine Add vs Modify
+        status_response = await matter_client.send_device_command(
+            node_id=node.node_id,
+            endpoint_id=lock_endpoint.endpoint_id,
+            command=clusters.DoorLock.Commands.GetCredentialStatus(
+                credential=clusters.DoorLock.Structs.CredentialStruct(
+                    credentialType=cred_type_int,
+                    credentialIndex=credential_index,
+                ),
+            ),
+        )
+        if _get_attr(status_response, "credentialExists"):
+            operation_type = clusters.DoorLock.Enums.DataOperationTypeEnum.kModify
+
+    # Resolve optional user_status and user_type enums
+    resolved_user_status = (
+        USER_STATUS_REVERSE_MAP.get(user_status) if user_status is not None else None
+    )
+    resolved_user_type = (
+        USER_TYPE_REVERSE_MAP.get(user_type) if user_type is not None else None
+    )
+
+    set_cred_response = await matter_client.send_device_command(
+        node_id=node.node_id,
+        endpoint_id=lock_endpoint.endpoint_id,
+        command=clusters.DoorLock.Commands.SetCredential(
+            operationType=operation_type,
+            credential=clusters.DoorLock.Structs.CredentialStruct(
+                credentialType=cred_type_int,
+                credentialIndex=credential_index,
+            ),
+            credentialData=cred_data_bytes,
+            userIndex=user_index,
+            userStatus=resolved_user_status,
+            userType=resolved_user_type,
+        ),
+        timed_request_timeout_ms=LOCK_TIMED_REQUEST_TIMEOUT_MS,
+    )
+
+    status_code = _get_attr(set_cred_response, "status")
+    status_str = SET_CREDENTIAL_STATUS_MAP.get(status_code, f"unknown({status_code})")
+    if status_str != "success":
+        raise SetCredentialFailedError(
+            translation_domain="matter",
+            translation_key="set_credential_failed",
+            translation_placeholders={"status": status_str},
+        )
+
+    return SetLockCredentialResult(
+        credential_index=credential_index,
+        user_index=_get_attr(set_cred_response, "userIndex"),
+        next_credential_index=_get_attr(set_cred_response, "nextCredentialIndex"),
+    )
+
+
+async def clear_lock_credential(
+    matter_client: MatterClient,
+    node: MatterNode,
+    *,
+    credential_type: str,
+    credential_index: int,
+) -> None:
+    """Clear a credential from the lock.
+
+    Raises HomeAssistantError on failure.
+    """
+    lock_endpoint = _get_lock_endpoint_or_raise(node)
+    _ensure_usr_support(lock_endpoint)
+
+    cred_type_int = CREDENTIAL_TYPE_REVERSE_MAP[credential_type]
+
+    await matter_client.send_device_command(
+        node_id=node.node_id,
+        endpoint_id=lock_endpoint.endpoint_id,
+        command=clusters.DoorLock.Commands.ClearCredential(
+            credential=clusters.DoorLock.Structs.CredentialStruct(
+                credentialType=cred_type_int,
+                credentialIndex=credential_index,
+            ),
+        ),
+        timed_request_timeout_ms=LOCK_TIMED_REQUEST_TIMEOUT_MS,
+    )
+
+
+async def get_lock_credential_status(
+    matter_client: MatterClient,
+    node: MatterNode,
+    *,
+    credential_type: str,
+    credential_index: int,
+) -> GetLockCredentialStatusResult:
+    """Get the status of a credential slot on the lock.
+
+    Returns typed dict with credential_exists, user_index, next_credential_index.
+    Raises HomeAssistantError on failure.
+    """
+    lock_endpoint = _get_lock_endpoint_or_raise(node)
+    _ensure_usr_support(lock_endpoint)
+
+    cred_type_int = CREDENTIAL_TYPE_REVERSE_MAP[credential_type]
+
+    response = await matter_client.send_device_command(
+        node_id=node.node_id,
+        endpoint_id=lock_endpoint.endpoint_id,
+        command=clusters.DoorLock.Commands.GetCredentialStatus(
+            credential=clusters.DoorLock.Structs.CredentialStruct(
+                credentialType=cred_type_int,
+                credentialIndex=credential_index,
+            ),
+        ),
+    )
+
+    return GetLockCredentialStatusResult(
+        credential_exists=bool(_get_attr(response, "credentialExists")),
+        user_index=_get_attr(response, "userIndex"),
+        next_credential_index=_get_attr(response, "nextCredentialIndex"),
+    )

homeassistant/components/matter/services.py

@@ -4,11 +4,27 @@ from __future__ import annotations
 
 import voluptuous as vol
 
+from homeassistant.components.lock import DOMAIN as LOCK_DOMAIN
 from homeassistant.components.water_heater import DOMAIN as WATER_HEATER_DOMAIN
-from homeassistant.core import HomeAssistant, callback
+from homeassistant.core import HomeAssistant, SupportsResponse, callback
 from homeassistant.helpers import config_validation as cv, service
 
-from .const import DOMAIN
+from .const import (
+    ATTR_CREDENTIAL_DATA,
+    ATTR_CREDENTIAL_INDEX,
+    ATTR_CREDENTIAL_RULE,
+    ATTR_CREDENTIAL_TYPE,
+    ATTR_USER_INDEX,
+    ATTR_USER_NAME,
+    ATTR_USER_STATUS,
+    ATTR_USER_TYPE,
+    CLEAR_ALL_INDEX,
+    CREDENTIAL_RULE_REVERSE_MAP,
+    CREDENTIAL_TYPE_REVERSE_MAP,
+    DOMAIN,
+    SERVICE_CREDENTIAL_TYPES,
+    USER_TYPE_REVERSE_MAP,
+)
 
 ATTR_DURATION = "duration"
 ATTR_EMERGENCY_BOOST = "emergency_boost"
@@ -36,3 +52,108 @@ def async_setup_services(hass: HomeAssistant) -> None:
         },
         func="async_set_boost",
     )
+
+    # Lock services - Full user CRUD
+    service.async_register_platform_entity_service(
+        hass,
+        DOMAIN,
+        "set_lock_user",
+        entity_domain=LOCK_DOMAIN,
+        schema={
+            vol.Optional(ATTR_USER_INDEX): vol.All(vol.Coerce(int), vol.Range(min=1)),
+            vol.Optional(ATTR_USER_NAME): vol.Any(str, None),
+            vol.Optional(ATTR_USER_TYPE): vol.In(USER_TYPE_REVERSE_MAP.keys()),
+            vol.Optional(ATTR_CREDENTIAL_RULE): vol.In(
+                CREDENTIAL_RULE_REVERSE_MAP.keys()
+            ),
+        },
+        func="async_set_lock_user",
+    )
+
+    service.async_register_platform_entity_service(
+        hass,
+        DOMAIN,
+        "clear_lock_user",
+        entity_domain=LOCK_DOMAIN,
+        schema={
+            vol.Required(ATTR_USER_INDEX): vol.All(
+                vol.Coerce(int),
+                vol.Any(vol.Range(min=1), CLEAR_ALL_INDEX),
+            ),
+        },
+        func="async_clear_lock_user",
+    )
+
+    # Lock services - Query operations
+    service.async_register_platform_entity_service(
+        hass,
+        DOMAIN,
+        "get_lock_info",
+        entity_domain=LOCK_DOMAIN,
+        schema={},
+        func="async_get_lock_info",
+        supports_response=SupportsResponse.ONLY,
+    )
+
+    service.async_register_platform_entity_service(
+        hass,
+        DOMAIN,
+        "get_lock_users",
+        entity_domain=LOCK_DOMAIN,
+        schema={},
+        func="async_get_lock_users",
+        supports_response=SupportsResponse.ONLY,
+    )
+
+    # Lock services - Credential management
+    service.async_register_platform_entity_service(
+        hass,
+        DOMAIN,
+        "set_lock_credential",
+        entity_domain=LOCK_DOMAIN,
+        schema={
+            vol.Required(ATTR_CREDENTIAL_TYPE): vol.In(SERVICE_CREDENTIAL_TYPES),
+            vol.Required(ATTR_CREDENTIAL_DATA): str,
+            vol.Optional(ATTR_CREDENTIAL_INDEX): vol.All(
+                vol.Coerce(int), vol.Range(min=0)
+            ),
+            vol.Optional(ATTR_USER_INDEX): vol.All(vol.Coerce(int), vol.Range(min=1)),
+            vol.Optional(ATTR_USER_STATUS): vol.In(
+                ["occupied_enabled", "occupied_disabled"]
+            ),
+            vol.Optional(ATTR_USER_TYPE): vol.In(USER_TYPE_REVERSE_MAP.keys()),
+        },
+        func="async_set_lock_credential",
+        supports_response=SupportsResponse.ONLY,
+    )
+
+    service.async_register_platform_entity_service(
+        hass,
+        DOMAIN,
+        "clear_lock_credential",
+        entity_domain=LOCK_DOMAIN,
+        schema={
+            vol.Required(ATTR_CREDENTIAL_TYPE): vol.In(SERVICE_CREDENTIAL_TYPES),
+            vol.Required(ATTR_CREDENTIAL_INDEX): vol.All(
+                vol.Coerce(int), vol.Range(min=0)
+            ),
+        },
+        func="async_clear_lock_credential",
+    )
+
+    service.async_register_platform_entity_service(
+        hass,
+        DOMAIN,
+        "get_lock_credential_status",
+        entity_domain=LOCK_DOMAIN,
+        schema={
+            vol.Required(ATTR_CREDENTIAL_TYPE): vol.In(
+                CREDENTIAL_TYPE_REVERSE_MAP.keys()
+            ),
+            vol.Required(ATTR_CREDENTIAL_INDEX): vol.All(
+                vol.Coerce(int), vol.Range(min=0)
+            ),
+        },
+        func="async_get_lock_credential_status",
+        supports_response=SupportsResponse.ONLY,
+    )

homeassistant/components/matter/services.yaml

@@ -1,3 +1,177 @@
+clear_lock_credential:
+  target:
+    entity:
+      domain: lock
+      integration: matter
+  fields:
+    credential_type:
+      selector:
+        select:
+          options:
+            - pin
+            - rfid
+            - fingerprint
+            - finger_vein
+            - face
+      required: true
+    credential_index:
+      selector:
+        number:
+          min: 0
+          max: 65534
+          step: 1
+          mode: box
+      required: true
+
+clear_lock_user:
+  target:
+    entity:
+      domain: lock
+      integration: matter
+  fields:
+    user_index:
+      selector:
+        number:
+          min: 1
+          max: 65534
+          step: 1
+          mode: box
+      required: true
+
+get_lock_credential_status:
+  target:
+    entity:
+      domain: lock
+      integration: matter
+  fields:
+    credential_type:
+      selector:
+        select:
+          options:
+            - programming_pin
+            - pin
+            - rfid
+            - fingerprint
+            - finger_vein
+            - face
+            - aliro_credential_issuer_key
+            - aliro_evictable_endpoint_key
+            - aliro_non_evictable_endpoint_key
+      required: true
+    credential_index:
+      selector:
+        number:
+          min: 0
+          max: 65534
+          step: 1
+          mode: box
+      required: true
+
+get_lock_info:
+  target:
+    entity:
+      domain: lock
+      integration: matter
+
+get_lock_users:
+  target:
+    entity:
+      domain: lock
+      integration: matter
+
+set_lock_credential:
+  target:
+    entity:
+      domain: lock
+      integration: matter
+  fields:
+    credential_type:
+      selector:
+        select:
+          options:
+            - pin
+            - rfid
+            - fingerprint
+            - finger_vein
+            - face
+      required: true
+    credential_data:
+      selector:
+        text:
+      required: true
+    credential_index:
+      selector:
+        number:
+          min: 0
+          max: 65534
+          step: 1
+          mode: box
+    user_index:
+      selector:
+        number:
+          min: 1
+          max: 65534
+          step: 1
+          mode: box
+    user_status:
+      selector:
+        select:
+          options:
+            - occupied_enabled
+            - occupied_disabled
+    user_type:
+      selector:
+        select:
+          options:
+            - unrestricted_user
+            - year_day_schedule_user
+            - week_day_schedule_user
+            - programming_user
+            - non_access_user
+            - forced_user
+            - disposable_user
+            - expiring_user
+            - schedule_restricted_user
+            - remote_only_user
+
+set_lock_user:
+  target:
+    entity:
+      domain: lock
+      integration: matter
+  fields:
+    user_index:
+      selector:
+        number:
+          min: 1
+          max: 255
+          step: 1
+          mode: box
+    user_name:
+      selector:
+        text:
+    user_type:
+      selector:
+        select:
+          options:
+            - unrestricted_user
+            - year_day_schedule_user
+            - week_day_schedule_user
+            - programming_user
+            - non_access_user
+            - forced_user
+            - disposable_user
+            - expiring_user
+            - schedule_restricted_user
+            - remote_only_user
+    credential_rule:
+      selector:
+        select:
+          options:
+            - single
+            - dual
+            - tri
+
 water_heater_boost:
   target:
     entity:

homeassistant/components/matter/strings.json

@@ -619,6 +619,17 @@
       }
     }
   },
+  "exceptions": {
+    "credential_type_not_supported": {
+      "message": "The lock does not support credential type `{credential_type}`."
+    },
+    "invalid_credential_data": {
+      "message": "Invalid credential data: {reason}."
+    },
+    "set_credential_failed": {
+      "message": "Failed to set credential: lock returned status `{status}`."
+    }
+  },
   "issues": {
     "server_version_version_too_new": {
       "description": "The version of the Matter Server you are currently running is too new for this version of Home Assistant. Please update Home Assistant or downgrade the Matter Server to an older version to fix this issue.",
@@ -630,6 +641,52 @@
     }
   },
   "services": {
+    "clear_lock_credential": {
+      "description": "Removes a credential from a lock.",
+      "fields": {
+        "credential_index": {
+          "description": "The credential slot index to clear.",
+          "name": "Credential index"
+        },
+        "credential_type": {
+          "description": "The type of credential to clear.",
+          "name": "Credential type"
+        }
+      },
+      "name": "Clear lock credential"
+    },
+    "clear_lock_user": {
+      "description": "Deletes a lock user and all associated credentials. Use index 65534 to clear all users.",
+      "fields": {
+        "user_index": {
+          "description": "The user slot index (1-based) to clear, or 65534 to clear all.",
+          "name": "User index"
+        }
+      },
+      "name": "Clear lock user"
+    },
+    "get_lock_credential_status": {
+      "description": "Returns the status of a credential slot on a lock.",
+      "fields": {
+        "credential_index": {
+          "description": "The credential slot index to query.",
+          "name": "Credential index"
+        },
+        "credential_type": {
+          "description": "The type of credential to query.",
+          "name": "Credential type"
+        }
+      },
+      "name": "Get lock credential status"
+    },
+    "get_lock_info": {
+      "description": "Returns lock capabilities including supported credential types, user capacity, and PIN length constraints.",
+      "name": "Get lock info"
+    },
+    "get_lock_users": {
+      "description": "Returns all users configured on a lock with their credentials.",
+      "name": "Get lock users"
+    },
     "open_commissioning_window": {
       "description": "Allows adding one of your devices to another Matter network by opening the commissioning window for this Matter device for 60 seconds.",
       "fields": {
@@ -640,6 +697,58 @@
       },
       "name": "Open commissioning window"
     },
+    "set_lock_credential": {
+      "description": "Adds or updates a credential on a lock.",
+      "fields": {
+        "credential_data": {
+          "description": "The credential data. For PIN: digits only. For RFID: hexadecimal string.",
+          "name": "Credential data"
+        },
+        "credential_index": {
+          "description": "The credential slot index. Leave empty to auto-find an available slot.",
+          "name": "Credential index"
+        },
+        "credential_type": {
+          "description": "The type of credential (e.g., pin, rfid, fingerprint).",
+          "name": "Credential type"
+        },
+        "user_index": {
+          "description": "The user index to associate the credential with. Leave empty for automatic assignment.",
+          "name": "User index"
+        },
+        "user_status": {
+          "description": "The user status to set when creating a new user for this credential.",
+          "name": "User status"
+        },
+        "user_type": {
+          "description": "The user type to set when creating a new user for this credential.",
+          "name": "User type"
+        }
+      },
+      "name": "Set lock credential"
+    },
+    "set_lock_user": {
+      "description": "Creates or updates a lock user.",
+      "fields": {
+        "credential_rule": {
+          "description": "The credential rule for the user.",
+          "name": "Credential rule"
+        },
+        "user_index": {
+          "description": "The user slot index (1-based). Leave empty to auto-find an available slot.",
+          "name": "User index"
+        },
+        "user_name": {
+          "description": "The name for the user.",
+          "name": "User name"
+        },
+        "user_type": {
+          "description": "The type of user to create.",
+          "name": "User type"
+        }
+      },
+      "name": "Set lock user"
+    },
     "water_heater_boost": {
       "description": "Enables water heater boost for a specific duration.",
       "fields": {

homeassistant/components/medcom_ble/__init__.py

@@ -3,19 +3,17 @@
 from __future__ import annotations
 
 from homeassistant.components import bluetooth
-from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import Platform
 from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import ConfigEntryNotReady
 
-from .const import DOMAIN
-from .coordinator import MedcomBleUpdateCoordinator
+from .coordinator import MedcomBleConfigEntry, MedcomBleUpdateCoordinator
 
 # Supported platforms
 PLATFORMS: list[Platform] = [Platform.SENSOR]
 
 
-async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
+async def async_setup_entry(hass: HomeAssistant, entry: MedcomBleConfigEntry) -> bool:
     """Set up Medcom BLE radiation monitor from a config entry."""
 
     address = entry.unique_id
@@ -31,16 +29,13 @@ async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
 
     await coordinator.async_config_entry_first_refresh()
 
-    hass.data.setdefault(DOMAIN, {})[entry.entry_id] = coordinator
+    entry.runtime_data = coordinator
 
     await hass.config_entries.async_forward_entry_setups(entry, PLATFORMS)
 
     return True
 
 
-async def async_unload_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
+async def async_unload_entry(hass: HomeAssistant, entry: MedcomBleConfigEntry) -> bool:
     """Unload a config entry."""
-    if unload_ok := await hass.config_entries.async_unload_platforms(entry, PLATFORMS):
-        hass.data[DOMAIN].pop(entry.entry_id)
-
-    return unload_ok
+    return await hass.config_entries.async_unload_platforms(entry, PLATFORMS)

homeassistant/components/medcom_ble/coordinator.py

@@ -18,13 +18,17 @@ from .const import DEFAULT_SCAN_INTERVAL, DOMAIN
 
 _LOGGER = logging.getLogger(__name__)
 
+type MedcomBleConfigEntry = ConfigEntry[MedcomBleUpdateCoordinator]
+
 
 class MedcomBleUpdateCoordinator(DataUpdateCoordinator[MedcomBleDevice]):
     """Coordinator for Medcom BLE radiation monitor data."""
 
-    config_entry: ConfigEntry
+    config_entry: MedcomBleConfigEntry
 
-    def __init__(self, hass: HomeAssistant, entry: ConfigEntry, address: str) -> None:
+    def __init__(
+        self, hass: HomeAssistant, entry: MedcomBleConfigEntry, address: str
+    ) -> None:
         """Initialize the coordinator."""
         super().__init__(
             hass,

homeassistant/components/medcom_ble/sensor.py

@@ -4,7 +4,6 @@ from __future__ import annotations
 
 import logging
 
-from homeassistant import config_entries
 from homeassistant.components.sensor import (
     SensorEntity,
     SensorEntityDescription,
@@ -15,8 +14,8 @@ from homeassistant.helpers.device_registry import CONNECTION_BLUETOOTH, DeviceIn
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from homeassistant.helpers.update_coordinator import CoordinatorEntity
 
-from .const import DOMAIN, UNIT_CPM
-from .coordinator import MedcomBleUpdateCoordinator
+from .const import UNIT_CPM
+from .coordinator import MedcomBleConfigEntry, MedcomBleUpdateCoordinator
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -32,12 +31,12 @@ SENSORS_MAPPING_TEMPLATE: dict[str, SensorEntityDescription] = {
 
 async def async_setup_entry(
     hass: HomeAssistant,
-    entry: config_entries.ConfigEntry,
+    entry: MedcomBleConfigEntry,
     async_add_entities: AddConfigEntryEntitiesCallback,
 ) -> None:
     """Set up Medcom BLE radiation monitor sensors."""
 
-    coordinator: MedcomBleUpdateCoordinator = hass.data[DOMAIN][entry.entry_id]
+    coordinator = entry.runtime_data
 
     entities = []
     _LOGGER.debug("got sensors: %s", coordinator.data.sensors)

homeassistant/components/meteoclimatic/__init__.py

@@ -1,25 +1,27 @@
 """Support for Meteoclimatic weather data."""
 
-from homeassistant.config_entries import ConfigEntry
 from homeassistant.core import HomeAssistant
 
-from .const import DOMAIN, PLATFORMS
-from .coordinator import MeteoclimaticUpdateCoordinator
+from .const import PLATFORMS
+from .coordinator import MeteoclimaticConfigEntry, MeteoclimaticUpdateCoordinator
 
 
-async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
+async def async_setup_entry(
+    hass: HomeAssistant, entry: MeteoclimaticConfigEntry
+) -> bool:
     """Set up a Meteoclimatic entry."""
     coordinator = MeteoclimaticUpdateCoordinator(hass, entry)
     await coordinator.async_config_entry_first_refresh()
 
-    hass.data.setdefault(DOMAIN, {})
-    hass.data[DOMAIN][entry.entry_id] = coordinator
+    entry.runtime_data = coordinator
 
     await hass.config_entries.async_forward_entry_setups(entry, PLATFORMS)
 
     return True
 
 
-async def async_unload_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
+async def async_unload_entry(
+    hass: HomeAssistant, entry: MeteoclimaticConfigEntry
+) -> bool:
     """Unload a config entry."""
     return await hass.config_entries.async_unload_platforms(entry, PLATFORMS)

homeassistant/components/meteoclimatic/coordinator.py

@@ -14,13 +14,15 @@ from .const import CONF_STATION_CODE, SCAN_INTERVAL
 
 _LOGGER = logging.getLogger(__name__)
 
+type MeteoclimaticConfigEntry = ConfigEntry[MeteoclimaticUpdateCoordinator]
+
 
 class MeteoclimaticUpdateCoordinator(DataUpdateCoordinator[dict[str, Any]]):
     """Coordinator for Meteoclimatic weather data."""
 
-    config_entry: ConfigEntry
+    config_entry: MeteoclimaticConfigEntry
 
-    def __init__(self, hass: HomeAssistant, entry: ConfigEntry) -> None:
+    def __init__(self, hass: HomeAssistant, entry: MeteoclimaticConfigEntry) -> None:
         """Initialize the coordinator."""
         self._station_code = entry.data[CONF_STATION_CODE]
         super().__init__(

homeassistant/components/meteoclimatic/sensor.py

@@ -6,7 +6,6 @@ from homeassistant.components.sensor import (
     SensorEntityDescription,
     SensorStateClass,
 )
-from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import (
     DEGREE,
     PERCENTAGE,
@@ -21,7 +20,7 @@ from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from homeassistant.helpers.update_coordinator import CoordinatorEntity
 
 from .const import ATTRIBUTION, DOMAIN, MANUFACTURER, MODEL
-from .coordinator import MeteoclimaticUpdateCoordinator
+from .coordinator import MeteoclimaticConfigEntry, MeteoclimaticUpdateCoordinator
 
 SENSOR_TYPES: tuple[SensorEntityDescription, ...] = (
     SensorEntityDescription(
@@ -113,11 +112,11 @@ SENSOR_TYPES: tuple[SensorEntityDescription, ...] = (
 
 async def async_setup_entry(
     hass: HomeAssistant,
-    entry: ConfigEntry,
+    entry: MeteoclimaticConfigEntry,
     async_add_entities: AddConfigEntryEntitiesCallback,
 ) -> None:
     """Set up the Meteoclimatic sensor platform."""
-    coordinator: MeteoclimaticUpdateCoordinator = hass.data[DOMAIN][entry.entry_id]
+    coordinator = entry.runtime_data
 
     async_add_entities(
         [MeteoclimaticSensor(coordinator, description) for description in SENSOR_TYPES],

homeassistant/components/meteoclimatic/weather.py

@@ -5,7 +5,6 @@ from typing import TYPE_CHECKING
 from meteoclimatic import Condition
 
 from homeassistant.components.weather import WeatherEntity
-from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import UnitOfPressure, UnitOfSpeed, UnitOfTemperature
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.device_registry import DeviceEntryType, DeviceInfo
@@ -13,7 +12,7 @@ from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from homeassistant.helpers.update_coordinator import CoordinatorEntity
 
 from .const import ATTRIBUTION, CONDITION_MAP, DOMAIN, MANUFACTURER, MODEL
-from .coordinator import MeteoclimaticUpdateCoordinator
+from .coordinator import MeteoclimaticConfigEntry, MeteoclimaticUpdateCoordinator
 
 
 def format_condition(condition):
@@ -27,11 +26,11 @@ def format_condition(condition):
 
 async def async_setup_entry(
     hass: HomeAssistant,
-    entry: ConfigEntry,
+    entry: MeteoclimaticConfigEntry,
     async_add_entities: AddConfigEntryEntitiesCallback,
 ) -> None:
     """Set up the Meteoclimatic weather platform."""
-    coordinator: MeteoclimaticUpdateCoordinator = hass.data[DOMAIN][entry.entry_id]
+    coordinator = entry.runtime_data
 
     async_add_entities([MeteoclimaticWeather(coordinator)], False)
 

homeassistant/components/metoffice/__init__.py

@@ -3,9 +3,7 @@
 from __future__ import annotations
 
 import asyncio
-import logging
 
-from datapoint.Forecast import Forecast
 from datapoint.Manager import Manager
 
 from homeassistant.config_entries import ConfigEntry
@@ -19,93 +17,71 @@ from homeassistant.const import (
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers import device_registry as dr
 from homeassistant.helpers.device_registry import DeviceInfo
-from homeassistant.helpers.update_coordinator import TimestampDataUpdateCoordinator
 
-from .const import (
-    DEFAULT_SCAN_INTERVAL,
-    DOMAIN,
-    METOFFICE_COORDINATES,
-    METOFFICE_DAILY_COORDINATOR,
-    METOFFICE_HOURLY_COORDINATOR,
-    METOFFICE_NAME,
-    METOFFICE_TWICE_DAILY_COORDINATOR,
+from .const import DOMAIN
+from .coordinator import (
+    MetOfficeConfigEntry,
+    MetOfficeRuntimeData,
+    MetOfficeUpdateCoordinator,
 )
-from .helpers import fetch_data
-
-_LOGGER = logging.getLogger(__name__)
 
 PLATFORMS = [Platform.SENSOR, Platform.WEATHER]
 
 
-async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
+async def async_setup_entry(hass: HomeAssistant, entry: MetOfficeConfigEntry) -> bool:
     """Set up a Met Office entry."""
 
-    latitude = entry.data[CONF_LATITUDE]
-    longitude = entry.data[CONF_LONGITUDE]
-    api_key = entry.data[CONF_API_KEY]
-    site_name = entry.data[CONF_NAME]
-
-    coordinates = f"{latitude}_{longitude}"
+    latitude: float = entry.data[CONF_LATITUDE]
+    longitude: float = entry.data[CONF_LONGITUDE]
+    api_key: str = entry.data[CONF_API_KEY]
+    site_name: str = entry.data[CONF_NAME]
 
     connection = Manager(api_key=api_key)
 
-    async def async_update_hourly() -> Forecast:
-        return await hass.async_add_executor_job(
-            fetch_data, connection, latitude, longitude, "hourly"
-        )
-
-    async def async_update_daily() -> Forecast:
-        return await hass.async_add_executor_job(
-            fetch_data, connection, latitude, longitude, "daily"
-        )
-
-    async def async_update_twice_daily() -> Forecast:
-        return await hass.async_add_executor_job(
-            fetch_data, connection, latitude, longitude, "twice-daily"
-        )
-
-    metoffice_hourly_coordinator = TimestampDataUpdateCoordinator(
+    metoffice_hourly_coordinator = MetOfficeUpdateCoordinator(
         hass,
-        _LOGGER,
-        config_entry=entry,
+        entry,
         name=f"MetOffice Hourly Coordinator for {site_name}",
-        update_method=async_update_hourly,
-        update_interval=DEFAULT_SCAN_INTERVAL,
+        connection=connection,
+        latitude=latitude,
+        longitude=longitude,
+        frequency="hourly",
     )
 
-    metoffice_daily_coordinator = TimestampDataUpdateCoordinator(
+    metoffice_daily_coordinator = MetOfficeUpdateCoordinator(
         hass,
-        _LOGGER,
-        config_entry=entry,
+        entry,
         name=f"MetOffice Daily Coordinator for {site_name}",
-        update_method=async_update_daily,
-        update_interval=DEFAULT_SCAN_INTERVAL,
+        connection=connection,
+        latitude=latitude,
+        longitude=longitude,
+        frequency="daily",
     )
 
-    metoffice_twice_daily_coordinator = TimestampDataUpdateCoordinator(
+    metoffice_twice_daily_coordinator = MetOfficeUpdateCoordinator(
         hass,
-        _LOGGER,
-        config_entry=entry,
+        entry,
         name=f"MetOffice Twice Daily Coordinator for {site_name}",
-        update_method=async_update_twice_daily,
-        update_interval=DEFAULT_SCAN_INTERVAL,
+        connection=connection,
+        latitude=latitude,
+        longitude=longitude,
+        frequency="twice-daily",
     )
 
-    metoffice_hass_data = hass.data.setdefault(DOMAIN, {})
-    metoffice_hass_data[entry.entry_id] = {
-        METOFFICE_HOURLY_COORDINATOR: metoffice_hourly_coordinator,
-        METOFFICE_DAILY_COORDINATOR: metoffice_daily_coordinator,
-        METOFFICE_TWICE_DAILY_COORDINATOR: metoffice_twice_daily_coordinator,
-        METOFFICE_NAME: site_name,
-        METOFFICE_COORDINATES: coordinates,
-    }
-
     # Fetch initial data so we have data when entities subscribe
     await asyncio.gather(
         metoffice_hourly_coordinator.async_config_entry_first_refresh(),
         metoffice_daily_coordinator.async_config_entry_first_refresh(),
     )
 
+    entry.runtime_data = MetOfficeRuntimeData(
+        coordinates=f"{latitude}_{longitude}",
+        hourly_coordinator=metoffice_hourly_coordinator,
+        daily_coordinator=metoffice_daily_coordinator,
+        twice_daily_coordinator=metoffice_twice_daily_coordinator,
+        name=site_name,
+    )
+
     await hass.config_entries.async_forward_entry_setups(entry, PLATFORMS)
 
     return True
@@ -113,12 +89,7 @@ async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
 
 async def async_unload_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
     """Unload a config entry."""
-    unload_ok = await hass.config_entries.async_unload_platforms(entry, PLATFORMS)
-    if unload_ok:
-        hass.data[DOMAIN].pop(entry.entry_id)
-        if not hass.data[DOMAIN]:
-            hass.data.pop(DOMAIN)
-    return unload_ok
+    return await hass.config_entries.async_unload_platforms(entry, PLATFORMS)
 
 
 def get_device_info(coordinates: str, name: str) -> DeviceInfo:

homeassistant/components/metoffice/const.py

@@ -38,13 +38,6 @@ ATTRIBUTION = "Data provided by the Met Office"
 
 DEFAULT_SCAN_INTERVAL = timedelta(minutes=15)
 
-METOFFICE_COORDINATES = "metoffice_coordinates"
-METOFFICE_HOURLY_COORDINATOR = "metoffice_hourly_coordinator"
-METOFFICE_DAILY_COORDINATOR = "metoffice_daily_coordinator"
-METOFFICE_TWICE_DAILY_COORDINATOR = "metoffice_twice_daily_coordinator"
-METOFFICE_MONITORED_CONDITIONS = "metoffice_monitored_conditions"
-METOFFICE_NAME = "metoffice_name"
-
 CONDITION_CLASSES: dict[str, list[int]] = {
     ATTR_CONDITION_CLEAR_NIGHT: [0],
     ATTR_CONDITION_CLOUDY: [7, 8],

homeassistant/components/metoffice/coordinator.py

@@ -0,0 +1,96 @@
+"""Data update coordinator for the Met Office integration."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+import logging
+from typing import Literal
+
+from datapoint.exceptions import APIException
+from datapoint.Forecast import Forecast
+from datapoint.Manager import Manager
+from requests import HTTPError
+
+from homeassistant.config_entries import ConfigEntry
+from homeassistant.core import HomeAssistant
+from homeassistant.exceptions import ConfigEntryAuthFailed
+from homeassistant.helpers.update_coordinator import (
+    TimestampDataUpdateCoordinator,
+    UpdateFailed,
+)
+
+from .const import DEFAULT_SCAN_INTERVAL
+
+_LOGGER = logging.getLogger(__name__)
+
+type MetOfficeConfigEntry = ConfigEntry[MetOfficeRuntimeData]
+
+
+@dataclass
+class MetOfficeRuntimeData:
+    """Met Office config entry."""
+
+    coordinates: str
+    hourly_coordinator: MetOfficeUpdateCoordinator
+    daily_coordinator: MetOfficeUpdateCoordinator
+    twice_daily_coordinator: MetOfficeUpdateCoordinator
+    name: str
+
+
+class MetOfficeUpdateCoordinator(TimestampDataUpdateCoordinator[Forecast]):
+    """Coordinator for Met Office forecast data."""
+
+    config_entry: ConfigEntry
+
+    def __init__(
+        self,
+        hass: HomeAssistant,
+        entry: ConfigEntry,
+        name: str,
+        connection: Manager,
+        latitude: float,
+        longitude: float,
+        frequency: Literal["daily", "twice-daily", "hourly"],
+    ) -> None:
+        """Initialize the coordinator."""
+        super().__init__(
+            hass,
+            _LOGGER,
+            name=name,
+            config_entry=entry,
+            update_interval=DEFAULT_SCAN_INTERVAL,
+        )
+        self._connection = connection
+        self._latitude = latitude
+        self._longitude = longitude
+        self._frequency = frequency
+
+    async def _async_update_data(self) -> Forecast:
+        """Get data from Met Office."""
+        return await self.hass.async_add_executor_job(
+            fetch_data,
+            self._connection,
+            self._latitude,
+            self._longitude,
+            self._frequency,
+        )
+
+
+def fetch_data(
+    connection: Manager,
+    latitude: float,
+    longitude: float,
+    frequency: Literal["daily", "twice-daily", "hourly"],
+) -> Forecast:
+    """Fetch weather and forecast from Datapoint API."""
+    try:
+        return connection.get_forecast(
+            latitude, longitude, frequency, convert_weather_code=False
+        )
+    except (ValueError, APIException) as err:
+        _LOGGER.error("Check Met Office connection: %s", err.args)
+        raise UpdateFailed from err
+    except HTTPError as err:
+        if err.response.status_code == 401:
+            raise ConfigEntryAuthFailed from err
+        raise

homeassistant/components/metoffice/helpers.py

@@ -2,38 +2,7 @@
 
 from __future__ import annotations
 
-import logging
-from typing import Any, Literal
-
-from datapoint.exceptions import APIException
-from datapoint.Forecast import Forecast
-from datapoint.Manager import Manager
-from requests import HTTPError
-
-from homeassistant.exceptions import ConfigEntryAuthFailed
-from homeassistant.helpers.update_coordinator import UpdateFailed
-
-_LOGGER = logging.getLogger(__name__)
-
-
-def fetch_data(
-    connection: Manager,
-    latitude: float,
-    longitude: float,
-    frequency: Literal["daily", "twice-daily", "hourly"],
-) -> Forecast:
-    """Fetch weather and forecast from Datapoint API."""
-    try:
-        return connection.get_forecast(
-            latitude, longitude, frequency, convert_weather_code=False
-        )
-    except (ValueError, APIException) as err:
-        _LOGGER.error("Check Met Office connection: %s", err.args)
-        raise UpdateFailed from err
-    except HTTPError as err:
-        if err.response.status_code == 401:
-            raise ConfigEntryAuthFailed from err
-        raise
+from typing import Any
 
 
 def get_attribute(data: dict[str, Any] | None, attr_name: str) -> Any | None:

homeassistant/components/metoffice/sensor.py

@@ -5,8 +5,6 @@ from __future__ import annotations
 from dataclasses import dataclass
 from typing import Any
 
-from datapoint.Forecast import Forecast
-
 from homeassistant.components.sensor import (
     DOMAIN as SENSOR_DOMAIN,
     EntityCategory,
@@ -15,7 +13,6 @@ from homeassistant.components.sensor import (
     SensorEntityDescription,
     SensorStateClass,
 )
-from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import (
     DEGREE,
     PERCENTAGE,
@@ -29,19 +26,14 @@ from homeassistant.core import HomeAssistant
 from homeassistant.helpers import entity_registry as er
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from homeassistant.helpers.typing import StateType
-from homeassistant.helpers.update_coordinator import (
-    CoordinatorEntity,
-    DataUpdateCoordinator,
-)
+from homeassistant.helpers.update_coordinator import CoordinatorEntity
 
 from . import get_device_info
-from .const import (
-    ATTRIBUTION,
-    CONDITION_MAP,
-    DOMAIN,
-    METOFFICE_COORDINATES,
-    METOFFICE_HOURLY_COORDINATOR,
-    METOFFICE_NAME,
+from .const import ATTRIBUTION, CONDITION_MAP, DOMAIN
+from .coordinator import (
+    MetOfficeConfigEntry,
+    MetOfficeRuntimeData,
+    MetOfficeUpdateCoordinator,
 )
 from .helpers import get_attribute
 
@@ -176,19 +168,19 @@ SENSOR_TYPES: tuple[MetOfficeSensorEntityDescription, ...] = (
 
 async def async_setup_entry(
     hass: HomeAssistant,
-    entry: ConfigEntry,
+    entry: MetOfficeConfigEntry,
     async_add_entities: AddConfigEntryEntitiesCallback,
 ) -> None:
     """Set up the Met Office weather sensor platform."""
     entity_registry = er.async_get(hass)
-    hass_data = hass.data[DOMAIN][entry.entry_id]
+    hass_data = entry.runtime_data
 
     # Remove daily entities from legacy config entries
     for description in SENSOR_TYPES:
         if entity_id := entity_registry.async_get_entity_id(
             SENSOR_DOMAIN,
             DOMAIN,
-            f"{description.key}_{hass_data[METOFFICE_COORDINATES]}_daily",
+            f"{description.key}_{hass_data.coordinates}_daily",
         ):
             entity_registry.async_remove(entity_id)
 
@@ -196,20 +188,20 @@ async def async_setup_entry(
     if entity_id := entity_registry.async_get_entity_id(
         SENSOR_DOMAIN,
         DOMAIN,
-        f"visibility_distance_{hass_data[METOFFICE_COORDINATES]}_daily",
+        f"visibility_distance_{hass_data.coordinates}_daily",
     ):
         entity_registry.async_remove(entity_id)
     if entity_id := entity_registry.async_get_entity_id(
         SENSOR_DOMAIN,
         DOMAIN,
-        f"visibility_distance_{hass_data[METOFFICE_COORDINATES]}",
+        f"visibility_distance_{hass_data.coordinates}",
     ):
         entity_registry.async_remove(entity_id)
 
     async_add_entities(
         [
             MetOfficeCurrentSensor(
-                hass_data[METOFFICE_HOURLY_COORDINATOR],
+                hass_data.hourly_coordinator,
                 hass_data,
                 description,
             )
@@ -220,7 +212,7 @@ async def async_setup_entry(
 
 
 class MetOfficeCurrentSensor(
-    CoordinatorEntity[DataUpdateCoordinator[Forecast]], SensorEntity
+    CoordinatorEntity[MetOfficeUpdateCoordinator], SensorEntity
 ):
     """Implementation of a Met Office current weather condition sensor."""
 
@@ -231,8 +223,8 @@ class MetOfficeCurrentSensor(
 
     def __init__(
         self,
-        coordinator: DataUpdateCoordinator[Forecast],
-        hass_data: dict[str, Any],
+        coordinator: MetOfficeUpdateCoordinator,
+        hass_data: MetOfficeRuntimeData,
         description: MetOfficeSensorEntityDescription,
     ) -> None:
         """Initialize the sensor."""
@@ -241,9 +233,9 @@ class MetOfficeCurrentSensor(
         self.entity_description = description
 
         self._attr_device_info = get_device_info(
-            coordinates=hass_data[METOFFICE_COORDINATES], name=hass_data[METOFFICE_NAME]
+            coordinates=hass_data.coordinates, name=hass_data.name
         )
-        self._attr_unique_id = f"{description.key}_{hass_data[METOFFICE_COORDINATES]}"
+        self._attr_unique_id = f"{description.key}_{hass_data.coordinates}"
 
     @property
     def native_value(self) -> StateType:

homeassistant/components/metoffice/weather.py

@@ -5,8 +5,6 @@ from __future__ import annotations
 from datetime import datetime
 from typing import Any, cast
 
-from datapoint.Forecast import Forecast
-
 from homeassistant.components.weather import (
     ATTR_FORECAST_CONDITION,
     ATTR_FORECAST_IS_DAYTIME,
@@ -25,7 +23,6 @@ from homeassistant.components.weather import (
     Forecast as WeatherForecast,
     WeatherEntityFeature,
 )
-from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import (
     UnitOfLength,
     UnitOfPressure,
@@ -35,7 +32,6 @@ from homeassistant.const import (
 from homeassistant.core import HomeAssistant, callback
 from homeassistant.helpers import entity_registry as er
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
-from homeassistant.helpers.update_coordinator import TimestampDataUpdateCoordinator
 
 from . import get_device_info
 from .const import (
@@ -45,39 +41,39 @@ from .const import (
     DAY_FORECAST_ATTRIBUTE_MAP,
     DOMAIN,
     HOURLY_FORECAST_ATTRIBUTE_MAP,
-    METOFFICE_COORDINATES,
-    METOFFICE_DAILY_COORDINATOR,
-    METOFFICE_HOURLY_COORDINATOR,
-    METOFFICE_NAME,
-    METOFFICE_TWICE_DAILY_COORDINATOR,
     NIGHT_FORECAST_ATTRIBUTE_MAP,
 )
+from .coordinator import (
+    MetOfficeConfigEntry,
+    MetOfficeRuntimeData,
+    MetOfficeUpdateCoordinator,
+)
 from .helpers import get_attribute
 
 
 async def async_setup_entry(
     hass: HomeAssistant,
-    entry: ConfigEntry,
+    entry: MetOfficeConfigEntry,
     async_add_entities: AddConfigEntryEntitiesCallback,
 ) -> None:
     """Set up the Met Office weather sensor platform."""
     entity_registry = er.async_get(hass)
-    hass_data = hass.data[DOMAIN][entry.entry_id]
+    hass_data = entry.runtime_data
 
     # Remove daily entity from legacy config entries
     if entity_id := entity_registry.async_get_entity_id(
         WEATHER_DOMAIN,
         DOMAIN,
-        f"{hass_data[METOFFICE_COORDINATES]}_daily",
+        f"{hass_data.coordinates}_daily",
     ):
         entity_registry.async_remove(entity_id)
 
     async_add_entities(
         [
             MetOfficeWeather(
-                hass_data[METOFFICE_DAILY_COORDINATOR],
-                hass_data[METOFFICE_HOURLY_COORDINATOR],
-                hass_data[METOFFICE_TWICE_DAILY_COORDINATOR],
+                hass_data.daily_coordinator,
+                hass_data.hourly_coordinator,
+                hass_data.twice_daily_coordinator,
                 hass_data,
             )
         ],
@@ -153,9 +149,9 @@ def _populate_forecast_data(
 
 class MetOfficeWeather(
     CoordinatorWeatherEntity[
-        TimestampDataUpdateCoordinator[Forecast],
-        TimestampDataUpdateCoordinator[Forecast],
-        TimestampDataUpdateCoordinator[Forecast],
+        MetOfficeUpdateCoordinator,
+        MetOfficeUpdateCoordinator,
+        MetOfficeUpdateCoordinator,
     ]
 ):
     """Implementation of a Met Office weather condition."""
@@ -177,10 +173,10 @@ class MetOfficeWeather(
 
     def __init__(
         self,
-        coordinator_daily: TimestampDataUpdateCoordinator[Forecast],
-        coordinator_hourly: TimestampDataUpdateCoordinator[Forecast],
-        coordinator_twice_daily: TimestampDataUpdateCoordinator[Forecast],
-        hass_data: dict[str, Any],
+        coordinator_daily: MetOfficeUpdateCoordinator,
+        coordinator_hourly: MetOfficeUpdateCoordinator,
+        coordinator_twice_daily: MetOfficeUpdateCoordinator,
+        hass_data: MetOfficeRuntimeData,
     ) -> None:
         """Initialise the platform with a data instance."""
         observation_coordinator = coordinator_hourly
@@ -192,9 +188,9 @@ class MetOfficeWeather(
         )
 
         self._attr_device_info = get_device_info(
-            coordinates=hass_data[METOFFICE_COORDINATES], name=hass_data[METOFFICE_NAME]
+            coordinates=hass_data.coordinates, name=hass_data.name
         )
-        self._attr_unique_id = hass_data[METOFFICE_COORDINATES]
+        self._attr_unique_id = hass_data.coordinates
 
     @property
     def condition(self) -> str | None:
@@ -266,7 +262,7 @@ class MetOfficeWeather(
     def _async_forecast_daily(self) -> list[WeatherForecast] | None:
         """Return the daily forecast in native units."""
         coordinator = cast(
-            TimestampDataUpdateCoordinator[Forecast],
+            MetOfficeUpdateCoordinator,
             self.forecast_coordinators["daily"],
         )
         timesteps = coordinator.data.timesteps
@@ -283,7 +279,7 @@ class MetOfficeWeather(
     def _async_forecast_hourly(self) -> list[WeatherForecast] | None:
         """Return the hourly forecast in native units."""
         coordinator = cast(
-            TimestampDataUpdateCoordinator[Forecast],
+            MetOfficeUpdateCoordinator,
             self.forecast_coordinators["hourly"],
         )
 
@@ -301,7 +297,7 @@ class MetOfficeWeather(
     def _async_forecast_twice_daily(self) -> list[WeatherForecast] | None:
         """Return the twice daily forecast in native units."""
         coordinator = cast(
-            TimestampDataUpdateCoordinator[Forecast],
+            MetOfficeUpdateCoordinator,
             self.forecast_coordinators["twice_daily"],
         )
         timesteps = coordinator.data.timesteps

homeassistant/components/microbees/__init__.py

@@ -13,22 +13,25 @@ from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import ConfigEntryAuthFailed, ConfigEntryNotReady
 from homeassistant.helpers import config_entry_oauth2_flow
 
-from .const import DOMAIN, PLATFORMS
+from .const import PLATFORMS
 from .coordinator import MicroBeesUpdateCoordinator
 
 _LOGGER = logging.getLogger(__name__)
 
 
+type MicroBeesConfigEntry = ConfigEntry[HomeAssistantMicroBeesData]
+
+
 @dataclass(frozen=True, kw_only=True)
 class HomeAssistantMicroBeesData:
-    """Microbees data stored in the Home Assistant data object."""
+    """Microbees data stored in the config entry runtime_data."""
 
     connector: MicroBees
     coordinator: MicroBeesUpdateCoordinator
     session: config_entry_oauth2_flow.OAuth2Session
 
 
-async def async_migrate_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
+async def async_migrate_entry(hass: HomeAssistant, entry: MicroBeesConfigEntry) -> bool:
     """Migrate entry."""
     _LOGGER.debug("Migrating from version %s.%s", entry.version, entry.minor_version)
 
@@ -45,7 +48,7 @@ async def async_migrate_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
     return True
 
 
-async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
+async def async_setup_entry(hass: HomeAssistant, entry: MicroBeesConfigEntry) -> bool:
     """Set up microBees from a config entry."""
     implementation = (
         await config_entry_oauth2_flow.async_get_config_entry_implementation(
@@ -67,7 +70,7 @@ async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
     microbees = MicroBees(token=session.token[CONF_ACCESS_TOKEN])
     coordinator = MicroBeesUpdateCoordinator(hass, entry, microbees)
     await coordinator.async_config_entry_first_refresh()
-    hass.data.setdefault(DOMAIN, {})[entry.entry_id] = HomeAssistantMicroBeesData(
+    entry.runtime_data = HomeAssistantMicroBeesData(
         connector=microbees,
         coordinator=coordinator,
         session=session,
@@ -76,9 +79,6 @@ async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
     return True
 
 
-async def async_unload_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
+async def async_unload_entry(hass: HomeAssistant, entry: MicroBeesConfigEntry) -> bool:
     """Unload a config entry."""
-    if unload_ok := await hass.config_entries.async_unload_platforms(entry, PLATFORMS):
-        hass.data[DOMAIN].pop(entry.entry_id)
-
-    return unload_ok
+    return await hass.config_entries.async_unload_platforms(entry, PLATFORMS)

homeassistant/components/microbees/binary_sensor.py

@@ -7,11 +7,10 @@ from homeassistant.components.binary_sensor import (
     BinarySensorEntity,
     BinarySensorEntityDescription,
 )
-from homeassistant.config_entries import ConfigEntry
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
-from .const import DOMAIN
+from . import MicroBeesConfigEntry
 from .coordinator import MicroBeesUpdateCoordinator
 from .entity import MicroBeesEntity
 
@@ -37,13 +36,11 @@ BINARYSENSOR_TYPES = {
 
 async def async_setup_entry(
     hass: HomeAssistant,
-    entry: ConfigEntry,
+    entry: MicroBeesConfigEntry,
     async_add_entities: AddConfigEntryEntitiesCallback,
 ) -> None:
     """Set up the microBees binary sensor platform."""
-    coordinator: MicroBeesUpdateCoordinator = hass.data[DOMAIN][
-        entry.entry_id
-    ].coordinator
+    coordinator = entry.runtime_data.coordinator
     async_add_entities(
         MBBinarySensor(coordinator, entity_description, bee_id, binary_sensor.id)
         for bee_id, bee in coordinator.data.bees.items()

homeassistant/components/microbees/button.py

@@ -3,11 +3,10 @@
 from typing import Any
 
 from homeassistant.components.button import ButtonEntity
-from homeassistant.config_entries import ConfigEntry
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
-from .const import DOMAIN
+from . import MicroBeesConfigEntry
 from .coordinator import MicroBeesUpdateCoordinator
 from .entity import MicroBeesActuatorEntity
 
@@ -16,13 +15,11 @@ BUTTON_TRANSLATIONS = {51: "button_gate", 91: "button_panic"}
 
 async def async_setup_entry(
     hass: HomeAssistant,
-    entry: ConfigEntry,
+    entry: MicroBeesConfigEntry,
     async_add_entities: AddConfigEntryEntitiesCallback,
 ) -> None:
     """Set up the microBees button platform."""
-    coordinator: MicroBeesUpdateCoordinator = hass.data[DOMAIN][
-        entry.entry_id
-    ].coordinator
+    coordinator = entry.runtime_data.coordinator
     async_add_entities(
         MBButton(coordinator, bee_id, button.id)
         for bee_id, bee in coordinator.data.bees.items()

homeassistant/components/microbees/climate.py

@@ -7,13 +7,12 @@ from homeassistant.components.climate import (
     ClimateEntityFeature,
     HVACMode,
 )
-from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import ATTR_TEMPERATURE, UnitOfTemperature
 from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import HomeAssistantError
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
-from .const import DOMAIN
+from . import MicroBeesConfigEntry
 from .coordinator import MicroBeesUpdateCoordinator
 from .entity import MicroBeesActuatorEntity
 
@@ -27,13 +26,11 @@ THERMOVALVE_SENSOR_ID = 782
 
 async def async_setup_entry(
     hass: HomeAssistant,
-    entry: ConfigEntry,
+    entry: MicroBeesConfigEntry,
     async_add_entities: AddConfigEntryEntitiesCallback,
 ) -> None:
     """Set up the microBees climate platform."""
-    coordinator: MicroBeesUpdateCoordinator = hass.data[DOMAIN][
-        entry.entry_id
-    ].coordinator
+    coordinator = entry.runtime_data.coordinator
     async_add_entities(
         MBClimate(
             coordinator,

homeassistant/components/microbees/coordinator.py

@@ -1,19 +1,24 @@
 """The microBees Coordinator."""
 
+from __future__ import annotations
+
 import asyncio
 from dataclasses import dataclass
 from datetime import timedelta
 from http import HTTPStatus
 import logging
+from typing import TYPE_CHECKING
 
 import aiohttp
 from microBeesPy import Actuator, Bee, MicroBees, MicroBeesException, Sensor
 
-from homeassistant.config_entries import ConfigEntry
 from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import ConfigEntryAuthFailed
 from homeassistant.helpers.update_coordinator import DataUpdateCoordinator, UpdateFailed
 
+if TYPE_CHECKING:
+    from . import MicroBeesConfigEntry
+
 _LOGGER = logging.getLogger(__name__)
 
 
@@ -29,10 +34,13 @@ class MicroBeesCoordinatorData:
 class MicroBeesUpdateCoordinator(DataUpdateCoordinator[MicroBeesCoordinatorData]):
     """MicroBees coordinator."""
 
-    config_entry: ConfigEntry
+    config_entry: MicroBeesConfigEntry
 
     def __init__(
-        self, hass: HomeAssistant, config_entry: ConfigEntry, microbees: MicroBees
+        self,
+        hass: HomeAssistant,
+        config_entry: MicroBeesConfigEntry,
+        microbees: MicroBees,
     ) -> None:
         """Initialize microBees coordinator."""
         super().__init__(

homeassistant/components/microbees/cover.py

@@ -9,14 +9,12 @@ from homeassistant.components.cover import (
     CoverEntity,
     CoverEntityFeature,
 )
-from homeassistant.config_entries import ConfigEntry
 from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import HomeAssistantError
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from homeassistant.helpers.event import async_call_later
 
-from .const import DOMAIN
-from .coordinator import MicroBeesUpdateCoordinator
+from . import MicroBeesConfigEntry
 from .entity import MicroBeesEntity
 
 COVER_IDS = {47: "roller_shutter"}
@@ -24,13 +22,11 @@ COVER_IDS = {47: "roller_shutter"}
 
 async def async_setup_entry(
     hass: HomeAssistant,
-    entry: ConfigEntry,
+    entry: MicroBeesConfigEntry,
     async_add_entities: AddConfigEntryEntitiesCallback,
 ) -> None:
     """Set up the microBees cover platform."""
-    coordinator: MicroBeesUpdateCoordinator = hass.data[DOMAIN][
-        entry.entry_id
-    ].coordinator
+    coordinator = entry.runtime_data.coordinator
 
     async_add_entities(
         MBCover(

homeassistant/components/microbees/light.py

@@ -3,25 +3,22 @@
 from typing import Any
 
 from homeassistant.components.light import ATTR_RGBW_COLOR, ColorMode, LightEntity
-from homeassistant.config_entries import ConfigEntry
 from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import HomeAssistantError
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
-from .const import DOMAIN
+from . import MicroBeesConfigEntry
 from .coordinator import MicroBeesUpdateCoordinator
 from .entity import MicroBeesActuatorEntity
 
 
 async def async_setup_entry(
     hass: HomeAssistant,
-    entry: ConfigEntry,
+    entry: MicroBeesConfigEntry,
     async_add_entities: AddConfigEntryEntitiesCallback,
 ) -> None:
     """Config entry."""
-    coordinator: MicroBeesUpdateCoordinator = hass.data[DOMAIN][
-        entry.entry_id
-    ].coordinator
+    coordinator = entry.runtime_data.coordinator
     async_add_entities(
         MBLight(coordinator, bee_id, light.id)
         for bee_id, bee in coordinator.data.bees.items()

homeassistant/components/microbees/sensor.py

@@ -8,7 +8,6 @@ from homeassistant.components.sensor import (
     SensorEntityDescription,
     SensorStateClass,
 )
-from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import (
     CONCENTRATION_PARTS_PER_MILLION,
     LIGHT_LUX,
@@ -19,7 +18,7 @@ from homeassistant.const import (
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
-from .const import DOMAIN
+from . import MicroBeesConfigEntry
 from .coordinator import MicroBeesUpdateCoordinator
 from .entity import MicroBeesEntity
 
@@ -64,11 +63,11 @@ SENSOR_TYPES = {
 
 async def async_setup_entry(
     hass: HomeAssistant,
-    entry: ConfigEntry,
+    entry: MicroBeesConfigEntry,
     async_add_entities: AddConfigEntryEntitiesCallback,
 ) -> None:
     """Config entry."""
-    coordinator = hass.data[DOMAIN][entry.entry_id].coordinator
+    coordinator = entry.runtime_data.coordinator
 
     async_add_entities(
         MBSensor(coordinator, desc, bee_id, sensor.id)

homeassistant/components/microbees/switch.py

@@ -3,12 +3,11 @@
 from typing import Any
 
 from homeassistant.components.switch import SwitchEntity
-from homeassistant.config_entries import ConfigEntry
 from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import HomeAssistantError
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
-from .const import DOMAIN
+from . import MicroBeesConfigEntry
 from .coordinator import MicroBeesUpdateCoordinator
 from .entity import MicroBeesActuatorEntity
 
@@ -18,11 +17,11 @@ SWITCH_PRODUCT_IDS = {25, 26, 27, 35, 38, 46, 63, 64, 65, 86}
 
 async def async_setup_entry(
     hass: HomeAssistant,
-    entry: ConfigEntry,
+    entry: MicroBeesConfigEntry,
     async_add_entities: AddConfigEntryEntitiesCallback,
 ) -> None:
     """Config entry."""
-    coordinator = hass.data[DOMAIN][entry.entry_id].coordinator
+    coordinator = entry.runtime_data.coordinator
 
     async_add_entities(
         MBSwitch(coordinator, bee_id, switch.id)

homeassistant/components/moat/__init__.py

@@ -14,27 +14,26 @@ from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import Platform
 from homeassistant.core import HomeAssistant
 
-from .const import DOMAIN
-
 PLATFORMS: list[Platform] = [Platform.SENSOR]
 
 _LOGGER = logging.getLogger(__name__)
 
+type MoatConfigEntry = ConfigEntry[PassiveBluetoothProcessorCoordinator]
 
-async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
+
+async def async_setup_entry(hass: HomeAssistant, entry: MoatConfigEntry) -> bool:
     """Set up Moat BLE device from a config entry."""
     address = entry.unique_id
     assert address is not None
     data = MoatBluetoothDeviceData()
-    coordinator = hass.data.setdefault(DOMAIN, {})[entry.entry_id] = (
-        PassiveBluetoothProcessorCoordinator(
-            hass,
-            _LOGGER,
-            address=address,
-            mode=BluetoothScanningMode.PASSIVE,
-            update_method=data.update,
-        )
+    coordinator = PassiveBluetoothProcessorCoordinator(
+        hass,
+        _LOGGER,
+        address=address,
+        mode=BluetoothScanningMode.PASSIVE,
+        update_method=data.update,
     )
+    entry.runtime_data = coordinator
     await hass.config_entries.async_forward_entry_setups(entry, PLATFORMS)
     entry.async_on_unload(
         coordinator.async_start()
@@ -42,9 +41,6 @@ async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
     return True
 
 
-async def async_unload_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
+async def async_unload_entry(hass: HomeAssistant, entry: MoatConfigEntry) -> bool:
     """Unload a config entry."""
-    if unload_ok := await hass.config_entries.async_unload_platforms(entry, PLATFORMS):
-        hass.data[DOMAIN].pop(entry.entry_id)
-
-    return unload_ok
+    return await hass.config_entries.async_unload_platforms(entry, PLATFORMS)

homeassistant/components/moat/sensor.py

@@ -4,12 +4,10 @@ from __future__ import annotations
 
 from moat_ble import DeviceClass, DeviceKey, SensorUpdate, Units
 
-from homeassistant import config_entries
 from homeassistant.components.bluetooth.passive_update_processor import (
     PassiveBluetoothDataProcessor,
     PassiveBluetoothDataUpdate,
     PassiveBluetoothEntityKey,
-    PassiveBluetoothProcessorCoordinator,
     PassiveBluetoothProcessorEntity,
 )
 from homeassistant.components.sensor import (
@@ -28,7 +26,7 @@ from homeassistant.core import HomeAssistant
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from homeassistant.helpers.sensor import sensor_device_info_to_hass_device_info
 
-from .const import DOMAIN
+from . import MoatConfigEntry
 
 SENSOR_DESCRIPTIONS = {
     (DeviceClass.TEMPERATURE, Units.TEMP_CELSIUS): SensorEntityDescription(
@@ -104,13 +102,11 @@ def sensor_update_to_bluetooth_data_update(
 
 async def async_setup_entry(
     hass: HomeAssistant,
-    entry: config_entries.ConfigEntry,
+    entry: MoatConfigEntry,
     async_add_entities: AddConfigEntryEntitiesCallback,
 ) -> None:
     """Set up the Moat BLE sensors."""
-    coordinator: PassiveBluetoothProcessorCoordinator = hass.data[DOMAIN][
-        entry.entry_id
-    ]
+    coordinator = entry.runtime_data
     processor = PassiveBluetoothDataProcessor(sensor_update_to_bluetooth_data_update)
     entry.async_on_unload(
         processor.async_add_entities_listener(

homeassistant/components/mobile_app/entity.py

@@ -13,6 +13,7 @@ from homeassistant.const import (
     STATE_UNKNOWN,
 )
 from homeassistant.core import State, callback
+from homeassistant.helpers.device_registry import DeviceInfo
 from homeassistant.helpers.dispatcher import async_dispatcher_connect
 from homeassistant.helpers.restore_state import RestoreEntity
 
@@ -95,7 +96,7 @@ class MobileAppEntity(RestoreEntity):
                 config[ATTR_SENSOR_ICON] = last_state.attributes[ATTR_ICON]
 
     @property
-    def device_info(self):
+    def device_info(self) -> DeviceInfo:
         """Return device registry information for this entity."""
         return device_info(self._registration)
 

homeassistant/components/mobile_app/helpers.py

@@ -193,7 +193,7 @@ def webhook_response(
     )
 
 
-def device_info(registration: dict) -> DeviceInfo:
+def device_info(registration: Mapping[str, Any]) -> DeviceInfo:
     """Return the device info for this registration."""
     return DeviceInfo(
         identifiers={(DOMAIN, registration[ATTR_DEVICE_ID])},

homeassistant/components/modem_callerid/__init__.py

@@ -3,16 +3,20 @@
 from phone_modem import PhoneModem
 
 from homeassistant.config_entries import ConfigEntry
-from homeassistant.const import CONF_DEVICE, Platform
-from homeassistant.core import HomeAssistant
+from homeassistant.const import CONF_DEVICE, EVENT_HOMEASSISTANT_STOP, Platform
+from homeassistant.core import Event, HomeAssistant
 from homeassistant.exceptions import ConfigEntryNotReady
 
-from .const import DATA_KEY_API, DOMAIN, EXCEPTIONS
+from .const import EXCEPTIONS
 
 PLATFORMS = [Platform.BUTTON, Platform.SENSOR]
 
+type ModemCallerIdConfigEntry = ConfigEntry[PhoneModem]
 
-async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
+
+async def async_setup_entry(
+    hass: HomeAssistant, entry: ModemCallerIdConfigEntry
+) -> bool:
     """Set up Modem Caller ID from a config entry."""
     device = entry.data[CONF_DEVICE]
     api = PhoneModem(device)
@@ -21,17 +25,25 @@ async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
     except EXCEPTIONS as ex:
         raise ConfigEntryNotReady(f"Unable to open port: {device}") from ex
 
-    hass.data.setdefault(DOMAIN, {})[entry.entry_id] = {DATA_KEY_API: api}
+    entry.async_on_unload(api.close)
+
+    async def _async_on_hass_stop(event: Event) -> None:
+        """HA is shutting down, close modem port."""
+        api.close()
+
+    entry.async_on_unload(
+        hass.bus.async_listen_once(EVENT_HOMEASSISTANT_STOP, _async_on_hass_stop)
+    )
+
+    entry.runtime_data = api
+
     await hass.config_entries.async_forward_entry_setups(entry, PLATFORMS)
 
     return True
 
 
-async def async_unload_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
+async def async_unload_entry(
+    hass: HomeAssistant, entry: ModemCallerIdConfigEntry
+) -> bool:
     """Unload a config entry."""
-    unload_ok = await hass.config_entries.async_unload_platforms(entry, PLATFORMS)
-    if unload_ok:
-        api = hass.data[DOMAIN].pop(entry.entry_id)[DATA_KEY_API]
-        await api.close()
-
-    return unload_ok
+    return await hass.config_entries.async_unload_platforms(entry, PLATFORMS)

homeassistant/components/modem_callerid/button.py

@@ -5,26 +5,25 @@ from __future__ import annotations
 from phone_modem import PhoneModem
 
 from homeassistant.components.button import ButtonEntity
-from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import CONF_DEVICE
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.device_registry import DeviceInfo
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
-from .const import DATA_KEY_API, DOMAIN
+from . import ModemCallerIdConfigEntry
+from .const import DOMAIN
 
 
 async def async_setup_entry(
     hass: HomeAssistant,
-    entry: ConfigEntry,
+    entry: ModemCallerIdConfigEntry,
     async_add_entities: AddConfigEntryEntitiesCallback,
 ) -> None:
     """Set up the Modem Caller ID sensor."""
-    api = hass.data[DOMAIN][entry.entry_id][DATA_KEY_API]
     async_add_entities(
         [
             PhoneModemButton(
-                api,
+                entry.runtime_data,
                 entry.data[CONF_DEVICE],
                 entry.entry_id,
             )

homeassistant/components/modem_callerid/const.py

@@ -5,7 +5,6 @@ from typing import Final
 from phone_modem import exceptions
 from serial import SerialException
 
-DATA_KEY_API = "api"
 DEFAULT_NAME = "Phone Modem"
 DOMAIN = "modem_callerid"
 

homeassistant/components/modem_callerid/sensor.py

@@ -5,40 +5,30 @@ from __future__ import annotations
 from phone_modem import PhoneModem
 
 from homeassistant.components.sensor import RestoreSensor
-from homeassistant.config_entries import ConfigEntry
-from homeassistant.const import EVENT_HOMEASSISTANT_STOP, STATE_IDLE
-from homeassistant.core import Event, HomeAssistant, callback
+from homeassistant.const import STATE_IDLE
+from homeassistant.core import HomeAssistant, callback
 from homeassistant.helpers.device_registry import DeviceInfo
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
-from .const import CID, DATA_KEY_API, DOMAIN
+from . import ModemCallerIdConfigEntry
+from .const import CID, DOMAIN
 
 
 async def async_setup_entry(
     hass: HomeAssistant,
-    entry: ConfigEntry,
+    entry: ModemCallerIdConfigEntry,
     async_add_entities: AddConfigEntryEntitiesCallback,
 ) -> None:
     """Set up the Modem Caller ID sensor."""
-    api = hass.data[DOMAIN][entry.entry_id][DATA_KEY_API]
     async_add_entities(
         [
             ModemCalleridSensor(
-                api,
+                entry.runtime_data,
                 entry.entry_id,
             )
         ]
     )
 
-    async def _async_on_hass_stop(event: Event) -> None:
-        """HA is shutting down, close modem port."""
-        if hass.data[DOMAIN][entry.entry_id][DATA_KEY_API]:
-            await hass.data[DOMAIN][entry.entry_id][DATA_KEY_API].close()
-
-    entry.async_on_unload(
-        hass.bus.async_listen_once(EVENT_HOMEASSISTANT_STOP, _async_on_hass_stop)
-    )
-
 
 class ModemCalleridSensor(RestoreSensor):
     """Implementation of USB modem caller ID sensor."""

homeassistant/components/modern_forms/__init__.py

@@ -8,12 +8,10 @@ from typing import Any, Concatenate
 
 from aiomodernforms import ModernFormsConnectionError, ModernFormsError
 
-from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import Platform
 from homeassistant.core import HomeAssistant
 
-from .const import DOMAIN
-from .coordinator import ModernFormsDataUpdateCoordinator
+from .coordinator import ModernFormsConfigEntry, ModernFormsDataUpdateCoordinator
 from .entity import ModernFormsDeviceEntity
 
 PLATFORMS = [
@@ -26,15 +24,14 @@ PLATFORMS = [
 _LOGGER = logging.getLogger(__name__)
 
 
-async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
+async def async_setup_entry(hass: HomeAssistant, entry: ModernFormsConfigEntry) -> bool:
     """Set up a Modern Forms device from a config entry."""
 
     # Create Modern Forms instance for this entry
     coordinator = ModernFormsDataUpdateCoordinator(hass, entry)
     await coordinator.async_config_entry_first_refresh()
 
-    hass.data.setdefault(DOMAIN, {})
-    hass.data[DOMAIN][entry.entry_id] = coordinator
+    entry.runtime_data = coordinator
 
     # Set up all platforms for this device/entry.
     await hass.config_entries.async_forward_entry_setups(entry, PLATFORMS)
@@ -42,17 +39,11 @@ async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
     return True
 
 
-async def async_unload_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
+async def async_unload_entry(
+    hass: HomeAssistant, entry: ModernFormsConfigEntry
+) -> bool:
     """Unload Modern Forms config entry."""
-    unload_ok = await hass.config_entries.async_unload_platforms(entry, PLATFORMS)
-
-    if unload_ok:
-        del hass.data[DOMAIN][entry.entry_id]
-
-    if not hass.data[DOMAIN]:
-        del hass.data[DOMAIN]
-
-    return unload_ok
+    return await hass.config_entries.async_unload_platforms(entry, PLATFORMS)
 
 
 def modernforms_exception_handler[

homeassistant/components/modern_forms/binary_sensor.py

@@ -3,23 +3,22 @@
 from __future__ import annotations
 
 from homeassistant.components.binary_sensor import BinarySensorEntity
-from homeassistant.config_entries import ConfigEntry
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from homeassistant.util import dt as dt_util
 
-from .const import CLEAR_TIMER, DOMAIN
-from .coordinator import ModernFormsDataUpdateCoordinator
+from .const import CLEAR_TIMER
+from .coordinator import ModernFormsConfigEntry, ModernFormsDataUpdateCoordinator
 from .entity import ModernFormsDeviceEntity
 
 
 async def async_setup_entry(
     hass: HomeAssistant,
-    entry: ConfigEntry,
+    entry: ModernFormsConfigEntry,
     async_add_entities: AddConfigEntryEntitiesCallback,
 ) -> None:
     """Set up Modern Forms binary sensors."""
-    coordinator: ModernFormsDataUpdateCoordinator = hass.data[DOMAIN][entry.entry_id]
+    coordinator = entry.runtime_data
 
     binary_sensors: list[ModernFormsBinarySensor] = [
         ModernFormsFanSleepTimerActive(entry.entry_id, coordinator),

homeassistant/components/modern_forms/coordinator.py

@@ -20,6 +20,9 @@ SCAN_INTERVAL = timedelta(seconds=5)
 _LOGGER = logging.getLogger(__name__)
 
 
+type ModernFormsConfigEntry = ConfigEntry[ModernFormsDataUpdateCoordinator]
+
+
 class ModernFormsDataUpdateCoordinator(DataUpdateCoordinator[ModernFormsDeviceState]):
     """Class to manage fetching Modern Forms data from single endpoint."""
 

homeassistant/components/modern_forms/diagnostics.py

@@ -3,27 +3,23 @@
 from __future__ import annotations
 
 from dataclasses import asdict
-from typing import TYPE_CHECKING, Any
+from typing import Any
 
 from homeassistant.components.diagnostics import async_redact_data
-from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import CONF_MAC
 from homeassistant.core import HomeAssistant
 
-from .const import DOMAIN
-from .coordinator import ModernFormsDataUpdateCoordinator
+from .coordinator import ModernFormsConfigEntry
 
 REDACT_CONFIG = {CONF_MAC}
 REDACT_DEVICE_INFO = {"mac_address", "owner"}
 
 
 async def async_get_config_entry_diagnostics(
-    hass: HomeAssistant, entry: ConfigEntry
+    hass: HomeAssistant, entry: ModernFormsConfigEntry
 ) -> dict[str, Any]:
     """Return diagnostics for a config entry."""
-    coordinator: ModernFormsDataUpdateCoordinator = hass.data[DOMAIN][entry.entry_id]
-    if TYPE_CHECKING:
-        assert coordinator is not None
+    coordinator = entry.runtime_data
 
     return {
         "config_entry": async_redact_data(entry.as_dict(), REDACT_CONFIG),

homeassistant/components/modern_forms/fan.py

@@ -8,7 +8,6 @@ from aiomodernforms.const import FAN_POWER_OFF, FAN_POWER_ON
 import voluptuous as vol
 
 from homeassistant.components.fan import FanEntity, FanEntityFeature
-from homeassistant.config_entries import ConfigEntry
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers import entity_platform
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
@@ -22,26 +21,23 @@ from . import modernforms_exception_handler
 from .const import (
     ATTR_SLEEP_TIME,
     CLEAR_TIMER,
-    DOMAIN,
     OPT_ON,
     OPT_SPEED,
     SERVICE_CLEAR_FAN_SLEEP_TIMER,
     SERVICE_SET_FAN_SLEEP_TIMER,
 )
-from .coordinator import ModernFormsDataUpdateCoordinator
+from .coordinator import ModernFormsConfigEntry, ModernFormsDataUpdateCoordinator
 from .entity import ModernFormsDeviceEntity
 
 
 async def async_setup_entry(
     hass: HomeAssistant,
-    config_entry: ConfigEntry,
+    config_entry: ModernFormsConfigEntry,
     async_add_entities: AddConfigEntryEntitiesCallback,
 ) -> None:
     """Set up a Modern Forms platform from config entry."""
 
-    coordinator: ModernFormsDataUpdateCoordinator = hass.data[DOMAIN][
-        config_entry.entry_id
-    ]
+    coordinator = config_entry.runtime_data
 
     platform = entity_platform.async_get_current_platform()
 

homeassistant/components/modern_forms/light.py

@@ -8,7 +8,6 @@ from aiomodernforms.const import LIGHT_POWER_OFF, LIGHT_POWER_ON
 import voluptuous as vol
 
 from homeassistant.components.light import ATTR_BRIGHTNESS, ColorMode, LightEntity
-from homeassistant.config_entries import ConfigEntry
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers import entity_platform
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
@@ -21,13 +20,12 @@ from . import modernforms_exception_handler
 from .const import (
     ATTR_SLEEP_TIME,
     CLEAR_TIMER,
-    DOMAIN,
     OPT_BRIGHTNESS,
     OPT_ON,
     SERVICE_CLEAR_LIGHT_SLEEP_TIMER,
     SERVICE_SET_LIGHT_SLEEP_TIMER,
 )
-from .coordinator import ModernFormsDataUpdateCoordinator
+from .coordinator import ModernFormsConfigEntry, ModernFormsDataUpdateCoordinator
 from .entity import ModernFormsDeviceEntity
 
 BRIGHTNESS_RANGE = (1, 255)
@@ -35,14 +33,12 @@ BRIGHTNESS_RANGE = (1, 255)
 
 async def async_setup_entry(
     hass: HomeAssistant,
-    config_entry: ConfigEntry,
+    config_entry: ModernFormsConfigEntry,
     async_add_entities: AddConfigEntryEntitiesCallback,
 ) -> None:
     """Set up a Modern Forms platform from config entry."""
 
-    coordinator: ModernFormsDataUpdateCoordinator = hass.data[DOMAIN][
-        config_entry.entry_id
-    ]
+    coordinator = config_entry.runtime_data
 
     # if no light unit installed no light entity
     if not coordinator.data.info.light_type:

homeassistant/components/modern_forms/sensor.py

@@ -5,24 +5,23 @@ from __future__ import annotations
 from datetime import datetime
 
 from homeassistant.components.sensor import SensorDeviceClass, SensorEntity
-from homeassistant.config_entries import ConfigEntry
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from homeassistant.helpers.typing import StateType
 from homeassistant.util import dt as dt_util
 
-from .const import CLEAR_TIMER, DOMAIN
-from .coordinator import ModernFormsDataUpdateCoordinator
+from .const import CLEAR_TIMER
+from .coordinator import ModernFormsConfigEntry, ModernFormsDataUpdateCoordinator
 from .entity import ModernFormsDeviceEntity
 
 
 async def async_setup_entry(
     hass: HomeAssistant,
-    entry: ConfigEntry,
+    entry: ModernFormsConfigEntry,
     async_add_entities: AddConfigEntryEntitiesCallback,
 ) -> None:
     """Set up Modern Forms sensor based on a config entry."""
-    coordinator: ModernFormsDataUpdateCoordinator = hass.data[DOMAIN][entry.entry_id]
+    coordinator = entry.runtime_data
 
     sensors: list[ModernFormsSensor] = [
         ModernFormsFanTimerRemainingTimeSensor(entry.entry_id, coordinator),

homeassistant/components/modern_forms/switch.py

@@ -5,23 +5,21 @@ from __future__ import annotations
 from typing import Any
 
 from homeassistant.components.switch import SwitchEntity
-from homeassistant.config_entries import ConfigEntry
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
 from . import modernforms_exception_handler
-from .const import DOMAIN
-from .coordinator import ModernFormsDataUpdateCoordinator
+from .coordinator import ModernFormsConfigEntry, ModernFormsDataUpdateCoordinator
 from .entity import ModernFormsDeviceEntity
 
 
 async def async_setup_entry(
     hass: HomeAssistant,
-    entry: ConfigEntry,
+    entry: ModernFormsConfigEntry,
     async_add_entities: AddConfigEntryEntitiesCallback,
 ) -> None:
     """Set up Modern Forms switch based on a config entry."""
-    coordinator: ModernFormsDataUpdateCoordinator = hass.data[DOMAIN][entry.entry_id]
+    coordinator = entry.runtime_data
 
     switches = [
         ModernFormsAwaySwitch(entry.entry_id, coordinator),

homeassistant/components/moehlenhoff_alpha2/__init__.py

@@ -4,41 +4,33 @@ from __future__ import annotations
 
 from moehlenhoff_alpha2 import Alpha2Base
 
-from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import CONF_HOST, Platform
 from homeassistant.core import HomeAssistant
 
-from .const import DOMAIN
-from .coordinator import Alpha2BaseCoordinator
+from .coordinator import Alpha2BaseCoordinator, Alpha2ConfigEntry
 
 PLATFORMS = [Platform.BINARY_SENSOR, Platform.BUTTON, Platform.CLIMATE, Platform.SENSOR]
 
 
-async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
+async def async_setup_entry(hass: HomeAssistant, entry: Alpha2ConfigEntry) -> bool:
     """Set up a config entry."""
     base = Alpha2Base(entry.data[CONF_HOST])
     coordinator = Alpha2BaseCoordinator(hass, entry, base)
 
     await coordinator.async_config_entry_first_refresh()
 
-    hass.data.setdefault(DOMAIN, {})
-    hass.data[DOMAIN][entry.entry_id] = coordinator
+    entry.runtime_data = coordinator
 
     await hass.config_entries.async_forward_entry_setups(entry, PLATFORMS)
 
     return True
 
 
-async def async_unload_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
+async def async_unload_entry(hass: HomeAssistant, entry: Alpha2ConfigEntry) -> bool:
     """Unload a config entry."""
-    unload_ok = await hass.config_entries.async_unload_platforms(entry, PLATFORMS)
-
-    if unload_ok and entry.entry_id in hass.data[DOMAIN]:
-        hass.data[DOMAIN].pop(entry.entry_id)
-
-    return unload_ok
+    return await hass.config_entries.async_unload_platforms(entry, PLATFORMS)
 
 
-async def update_listener(hass: HomeAssistant, entry: ConfigEntry) -> None:
+async def update_listener(hass: HomeAssistant, entry: Alpha2ConfigEntry) -> None:
     """Handle options update."""
     await hass.config_entries.async_reload(entry.entry_id)

homeassistant/components/moehlenhoff_alpha2/binary_sensor.py

@@ -4,24 +4,22 @@ from homeassistant.components.binary_sensor import (
     BinarySensorDeviceClass,
     BinarySensorEntity,
 )
-from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import EntityCategory
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from homeassistant.helpers.update_coordinator import CoordinatorEntity
 
-from .const import DOMAIN
-from .coordinator import Alpha2BaseCoordinator
+from .coordinator import Alpha2BaseCoordinator, Alpha2ConfigEntry
 
 
 async def async_setup_entry(
     hass: HomeAssistant,
-    config_entry: ConfigEntry,
+    config_entry: Alpha2ConfigEntry,
     async_add_entities: AddConfigEntryEntitiesCallback,
 ) -> None:
     """Add Alpha2 sensor entities from a config_entry."""
 
-    coordinator: Alpha2BaseCoordinator = hass.data[DOMAIN][config_entry.entry_id]
+    coordinator = config_entry.runtime_data
 
     async_add_entities(
         Alpha2IODeviceBatterySensor(coordinator, io_device_id)

homeassistant/components/moehlenhoff_alpha2/button.py

@@ -1,25 +1,23 @@
 """Button entity to set the time of the Alpha2 base."""
 
 from homeassistant.components.button import ButtonEntity
-from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import EntityCategory
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from homeassistant.helpers.update_coordinator import CoordinatorEntity
 from homeassistant.util import dt as dt_util
 
-from .const import DOMAIN
-from .coordinator import Alpha2BaseCoordinator
+from .coordinator import Alpha2BaseCoordinator, Alpha2ConfigEntry
 
 
 async def async_setup_entry(
     hass: HomeAssistant,
-    config_entry: ConfigEntry,
+    config_entry: Alpha2ConfigEntry,
     async_add_entities: AddConfigEntryEntitiesCallback,
 ) -> None:
     """Add Alpha2 button entities."""
 
-    coordinator: Alpha2BaseCoordinator = hass.data[DOMAIN][config_entry.entry_id]
+    coordinator = config_entry.runtime_data
 
     async_add_entities([Alpha2TimeSyncButton(coordinator, config_entry.entry_id)])
 

homeassistant/components/moehlenhoff_alpha2/climate.py

@@ -1,6 +1,5 @@
 """Support for Alpha2 room control unit via Alpha2 base."""
 
-import logging
 from typing import Any
 
 from homeassistant.components.climate import (
@@ -9,26 +8,23 @@ from homeassistant.components.climate import (
     HVACAction,
     HVACMode,
 )
-from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import ATTR_TEMPERATURE, UnitOfTemperature
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from homeassistant.helpers.update_coordinator import CoordinatorEntity
 
-from .const import DOMAIN, PRESET_AUTO, PRESET_DAY, PRESET_NIGHT
-from .coordinator import Alpha2BaseCoordinator
-
-_LOGGER = logging.getLogger(__name__)
+from .const import PRESET_AUTO, PRESET_DAY, PRESET_NIGHT
+from .coordinator import Alpha2BaseCoordinator, Alpha2ConfigEntry
 
 
 async def async_setup_entry(
     hass: HomeAssistant,
-    config_entry: ConfigEntry,
+    config_entry: Alpha2ConfigEntry,
     async_add_entities: AddConfigEntryEntitiesCallback,
 ) -> None:
     """Add Alpha2Climate entities from a config_entry."""
 
-    coordinator: Alpha2BaseCoordinator = hass.data[DOMAIN][config_entry.entry_id]
+    coordinator = config_entry.runtime_data
 
     async_add_entities(
         Alpha2Climate(coordinator, heat_area_id)

homeassistant/components/moehlenhoff_alpha2/coordinator.py

@@ -17,14 +17,16 @@ _LOGGER = logging.getLogger(__name__)
 
 UPDATE_INTERVAL = timedelta(seconds=60)
 
+type Alpha2ConfigEntry = ConfigEntry[Alpha2BaseCoordinator]
+
 
 class Alpha2BaseCoordinator(DataUpdateCoordinator[dict[str, dict]]):
     """Keep the base instance in one place and centralize the update."""
 
-    config_entry: ConfigEntry
+    config_entry: Alpha2ConfigEntry
 
     def __init__(
-        self, hass: HomeAssistant, config_entry: ConfigEntry, base: Alpha2Base
+        self, hass: HomeAssistant, config_entry: Alpha2ConfigEntry, base: Alpha2Base
     ) -> None:
         """Initialize Alpha2Base data updater."""
         self.base = base