homeassistant 2025.7.4__py3-none-any.whl → 2025.8.0b1__py3-none-any.whl

homeassistant/components/velbus/translations/zh-Hans.json

@@ -72,10 +72,6 @@
                 "config_entry": {
                     "description": "Velbus \u96c6\u6210\u7684\u914d\u7f6e\u6761\u76ee",
                     "name": "\u914d\u7f6e\u6761\u76ee"
-                },
-                "interface": {
-                    "description": "\u5c06\u547d\u4ee4\u53d1\u9001\u5230\u7684 Velbus \u63a5\u53e3\uff0c\u8be5\u503c\u4e0e\u914d\u7f6e\u671f\u95f4\u4f7f\u7528\u7684\u503c\u76f8\u540c\u3002",
-                    "name": "\u754c\u9762"
                 }
             },
             "name": "\u6e05\u9664\u7f13\u5b58"
@@ -86,10 +82,6 @@
                 "config_entry": {
                     "description": "Velbus \u96c6\u6210\u7684\u914d\u7f6e\u6761\u76ee",
                     "name": "\u914d\u7f6e\u6761\u76ee"
-                },
-                "interface": {
-                    "description": "\u5c06\u547d\u4ee4\u53d1\u9001\u5230\u7684 Velbus \u63a5\u53e3\uff0c\u8be5\u503c\u4e0e\u914d\u7f6e\u671f\u95f4\u4f7f\u7528\u7684\u503c\u76f8\u540c\u3002",
-                    "name": "\u754c\u9762"
                 }
             },
             "name": "\u626b\u63cf"
@@ -105,10 +97,6 @@
                     "description": "Velbus \u96c6\u6210\u7684\u914d\u7f6e\u6761\u76ee",
                     "name": "\u914d\u7f6e\u6761\u76ee"
                 },
-                "interface": {
-                    "description": "\u5c06\u547d\u4ee4\u53d1\u9001\u5230\u7684 Velbus \u63a5\u53e3\uff0c\u8be5\u503c\u4e0e\u914d\u7f6e\u671f\u95f4\u4f7f\u7528\u7684\u503c\u76f8\u540c\u3002",
-                    "name": "\u754c\u9762"
-                },
                 "memo_text": {
                     "description": "\u8981\u663e\u793a\u7684\u5b9e\u9645\u6587\u672c\u3002\u6587\u672c\u957f\u5ea6\u9650\u5236\u4e3a 64 \u4e2a\u5b57\u7b26\u3002",
                     "name": "\u5907\u6ce8\u6587\u5b57"
@@ -122,10 +110,6 @@
                 "config_entry": {
                     "description": "Velbus \u96c6\u6210\u7684\u914d\u7f6e\u6761\u76ee",
                     "name": "\u914d\u7f6e\u6761\u76ee"
-                },
-                "interface": {
-                    "description": "\u5c06\u547d\u4ee4\u53d1\u9001\u5230\u7684 Velbus \u63a5\u53e3\uff0c\u8be5\u503c\u4e0e\u914d\u7f6e\u671f\u95f4\u4f7f\u7528\u7684\u503c\u76f8\u540c\u3002",
-                    "name": "\u754c\u9762"
                 }
             },
             "name": "\u540c\u6b65\u65f6\u949f"

homeassistant/components/velbus/translations/zh-Hant.json

@@ -72,10 +72,6 @@
                 "config_entry": {
                     "description": "Velbus \u6574\u5408\u8a2d\u5b9a\u689d\u76ee",
                     "name": "\u8a2d\u5b9a\u689d\u76ee"
-                },
-                "interface": {
-                    "description": "\u6240\u8981\u50b3\u9001\u547d\u4ee4\u7684 Velbus \u4ecb\u9762\u3001\u8207\u8a2d\u5b9a\u671f\u9593\u4f7f\u7528\u6578\u503c\u76f8\u540c\u3002",
-                    "name": "\u4ecb\u9762"
                 }
             },
             "name": "\u6e05\u9664\u66ab\u5b58"
@@ -86,10 +82,6 @@
                 "config_entry": {
                     "description": "Velbus \u6574\u5408\u8a2d\u5b9a\u689d\u76ee",
                     "name": "\u8a2d\u5b9a\u689d\u76ee"
-                },
-                "interface": {
-                    "description": "\u6240\u8981\u50b3\u9001\u547d\u4ee4\u7684 Velbus \u4ecb\u9762\u3001\u8207\u8a2d\u5b9a\u671f\u9593\u4f7f\u7528\u6578\u503c\u76f8\u540c\u3002",
-                    "name": "\u4ecb\u9762"
                 }
             },
             "name": "\u6383\u63cf"
@@ -105,10 +97,6 @@
                     "description": "Velbus \u6574\u5408\u8a2d\u5b9a\u689d\u76ee",
                     "name": "\u8a2d\u5b9a\u689d\u76ee"
                 },
-                "interface": {
-                    "description": "\u6240\u8981\u50b3\u9001\u547d\u4ee4\u7684 Velbus \u4ecb\u9762\u3001\u8207\u8a2d\u5b9a\u671f\u9593\u4f7f\u7528\u6578\u503c\u76f8\u540c\u3002",
-                    "name": "\u4ecb\u9762"
-                },
                 "memo_text": {
                     "description": "\u6b32\u986f\u793a\u5be6\u969b\u6587\u5b57\u3001\u9650\u5236\u70ba 64 \u500b\u5b57\u5143\u3002",
                     "name": "\u5099\u5fd8\u9304\u6587\u5b57"
@@ -122,10 +110,6 @@
                 "config_entry": {
                     "description": "Velbus \u6574\u5408\u8a2d\u5b9a\u689d\u76ee",
                     "name": "\u8a2d\u5b9a\u689d\u76ee"
-                },
-                "interface": {
-                    "description": "\u6240\u8981\u50b3\u9001\u547d\u4ee4\u7684 Velbus \u4ecb\u9762\u3001\u8207\u8a2d\u5b9a\u671f\u9593\u4f7f\u7528\u6578\u503c\u76f8\u540c\u3002",
-                    "name": "\u4ecb\u9762"
                 }
             },
             "name": "\u540c\u6b65\u6642\u9418"

homeassistant/components/velux/binary_sensor.py

@@ -0,0 +1,63 @@
+"""Support for rain sensors build into some velux windows."""
+
+from __future__ import annotations
+
+from datetime import timedelta
+
+from pyvlx.exception import PyVLXException
+from pyvlx.opening_device import OpeningDevice, Window
+
+from homeassistant.components.binary_sensor import (
+    BinarySensorDeviceClass,
+    BinarySensorEntity,
+)
+from homeassistant.config_entries import ConfigEntry
+from homeassistant.core import HomeAssistant
+from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
+
+from .const import DOMAIN, LOGGER
+from .entity import VeluxEntity
+
+PARALLEL_UPDATES = 1
+SCAN_INTERVAL = timedelta(minutes=5)  # Use standard polling
+
+
+async def async_setup_entry(
+    hass: HomeAssistant,
+    config: ConfigEntry,
+    async_add_entities: AddConfigEntryEntitiesCallback,
+) -> None:
+    """Set up rain sensor(s) for Velux platform."""
+    module = hass.data[DOMAIN][config.entry_id]
+
+    async_add_entities(
+        VeluxRainSensor(node, config.entry_id)
+        for node in module.pyvlx.nodes
+        if isinstance(node, Window) and node.rain_sensor
+    )
+
+
+class VeluxRainSensor(VeluxEntity, BinarySensorEntity):
+    """Representation of a Velux rain sensor."""
+
+    node: Window
+    _attr_should_poll = True  # the rain sensor / opening limitations needs polling unlike the rest of the Velux devices
+    _attr_entity_registry_enabled_default = False
+    _attr_device_class = BinarySensorDeviceClass.MOISTURE
+
+    def __init__(self, node: OpeningDevice, config_entry_id: str) -> None:
+        """Initialize VeluxRainSensor."""
+        super().__init__(node, config_entry_id)
+        self._attr_unique_id = f"{self._attr_unique_id}_rain_sensor"
+        self._attr_name = f"{node.name} Rain sensor"
+
+    async def async_update(self) -> None:
+        """Fetch the latest state from the device."""
+        try:
+            limitation = await self.node.get_limitation()
+        except PyVLXException:
+            LOGGER.error("Error fetching limitation data for cover %s", self.name)
+            return
+
+        # Velux windows with rain sensors report an opening limitation of 93 when rain is detected.
+        self._attr_is_on = limitation.min_value == 93

homeassistant/components/velux/const.py

@@ -5,5 +5,5 @@ from logging import getLogger
 from homeassistant.const import Platform
 
 DOMAIN = "velux"
-PLATFORMS = [Platform.COVER, Platform.LIGHT, Platform.SCENE]
+PLATFORMS = [Platform.BINARY_SENSOR, Platform.COVER, Platform.LIGHT, Platform.SCENE]
 LOGGER = getLogger(__package__)

homeassistant/components/vera/__init__.py

@@ -143,7 +143,6 @@ async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
         hass.bus.async_listen_once(EVENT_HOMEASSISTANT_STOP, stop_subscription)
     )
 
-    entry.async_on_unload(entry.add_update_listener(_async_update_listener))
     return True
 
 
@@ -161,11 +160,6 @@ async def async_unload_entry(hass: HomeAssistant, config_entry: ConfigEntry) ->
     return True
 
 
-async def _async_update_listener(hass: HomeAssistant, entry: ConfigEntry) -> None:
-    """Handle options update."""
-    await hass.config_entries.async_reload(entry.entry_id)
-
-
 def map_vera_device(
     vera_device: veraApi.VeraDevice, remap: list[int]
 ) -> Platform | None:

homeassistant/components/vera/config_flow.py

@@ -17,7 +17,7 @@ from homeassistant.config_entries import (
     ConfigEntry,
     ConfigFlow,
     ConfigFlowResult,
-    OptionsFlow,
+    OptionsFlowWithReload,
 )
 from homeassistant.const import CONF_EXCLUDE, CONF_LIGHTS, CONF_SOURCE
 from homeassistant.core import callback
@@ -73,7 +73,7 @@ def options_data(user_input: dict[str, str]) -> dict[str, list[int]]:
     )
 
 
-class OptionsFlowHandler(OptionsFlow):
+class OptionsFlowHandler(OptionsFlowWithReload):
     """Options for the component."""
 
     async def async_step_init(

homeassistant/components/vesync/const.py

@@ -129,6 +129,7 @@ SKU_TO_BASE_DEVICE = {
     "LAP-V102S-WEU": "Vital100S",  # Alt ID Model Vital100S
     "LAP-V102S-WUK": "Vital100S",  # Alt ID Model Vital100S
     "LAP-V102S-AUSR": "Vital100S",  # Alt ID Model Vital100S
+    "LAP-V102S-WJP": "Vital100S",  # Alt ID Model Vital100S
     "EverestAir": "EverestAir",
     "LAP-EL551S-AUS": "EverestAir",  # Alt ID Model EverestAir
     "LAP-EL551S-AEUR": "EverestAir",  # Alt ID Model EverestAir

homeassistant/components/vesync/translations/it.json

@@ -30,7 +30,7 @@
         "select": {
             "night_light_level": {
                 "state": {
-                    "off": "Spento",
+                    "off": "Off",
                     "on": "On"
                 }
             }

homeassistant/components/vodafone_station/__init__.py

@@ -25,8 +25,6 @@ async def async_setup_entry(hass: HomeAssistant, entry: VodafoneConfigEntry) ->
 
     entry.runtime_data = coordinator
 
-    entry.async_on_unload(entry.add_update_listener(update_listener))
-
     await hass.config_entries.async_forward_entry_setups(entry, PLATFORMS)
 
     return True
@@ -39,9 +37,3 @@ async def async_unload_entry(hass: HomeAssistant, entry: VodafoneConfigEntry) ->
         await coordinator.api.logout()
 
     return unload_ok
-
-
-async def update_listener(hass: HomeAssistant, entry: VodafoneConfigEntry) -> None:
-    """Update when config_entry options update."""
-    if entry.options:
-        await hass.config_entries.async_reload(entry.entry_id)

homeassistant/components/vodafone_station/config_flow.py

@@ -12,7 +12,11 @@ from homeassistant.components.device_tracker import (
     CONF_CONSIDER_HOME,
     DEFAULT_CONSIDER_HOME,
 )
-from homeassistant.config_entries import ConfigFlow, ConfigFlowResult, OptionsFlow
+from homeassistant.config_entries import (
+    ConfigFlow,
+    ConfigFlowResult,
+    OptionsFlowWithReload,
+)
 from homeassistant.const import CONF_HOST, CONF_PASSWORD, CONF_USERNAME
 from homeassistant.core import HomeAssistant, callback
 
@@ -180,7 +184,7 @@ class VodafoneStationConfigFlow(ConfigFlow, domain=DOMAIN):
         )
 
 
-class VodafoneStationOptionsFlowHandler(OptionsFlow):
+class VodafoneStationOptionsFlowHandler(OptionsFlowWithReload):
     """Handle a option flow."""
 
     async def async_step_init(

homeassistant/components/volvo/__init__.py

@@ -0,0 +1,97 @@
+"""The Volvo integration."""
+
+from __future__ import annotations
+
+import asyncio
+
+from aiohttp import ClientResponseError
+from volvocarsapi.api import VolvoCarsApi
+from volvocarsapi.models import VolvoAuthException, VolvoCarsVehicle
+
+from homeassistant.const import CONF_API_KEY
+from homeassistant.core import HomeAssistant
+from homeassistant.exceptions import (
+    ConfigEntryAuthFailed,
+    ConfigEntryError,
+    ConfigEntryNotReady,
+)
+from homeassistant.helpers.aiohttp_client import async_get_clientsession
+from homeassistant.helpers.config_entry_oauth2_flow import (
+    OAuth2Session,
+    async_get_config_entry_implementation,
+)
+
+from .api import VolvoAuth
+from .const import CONF_VIN, DOMAIN, PLATFORMS
+from .coordinator import (
+    VolvoConfigEntry,
+    VolvoMediumIntervalCoordinator,
+    VolvoSlowIntervalCoordinator,
+    VolvoVerySlowIntervalCoordinator,
+)
+
+
+async def async_setup_entry(hass: HomeAssistant, entry: VolvoConfigEntry) -> bool:
+    """Set up Volvo from a config entry."""
+
+    api = await _async_auth_and_create_api(hass, entry)
+    vehicle = await _async_load_vehicle(api)
+
+    # Order is important! Faster intervals must come first.
+    coordinators = (
+        VolvoMediumIntervalCoordinator(hass, entry, api, vehicle),
+        VolvoSlowIntervalCoordinator(hass, entry, api, vehicle),
+        VolvoVerySlowIntervalCoordinator(hass, entry, api, vehicle),
+    )
+
+    await asyncio.gather(*(c.async_config_entry_first_refresh() for c in coordinators))
+
+    entry.runtime_data = coordinators
+    await hass.config_entries.async_forward_entry_setups(entry, PLATFORMS)
+
+    return True
+
+
+async def async_unload_entry(hass: HomeAssistant, entry: VolvoConfigEntry) -> bool:
+    """Unload a config entry."""
+    return await hass.config_entries.async_unload_platforms(entry, PLATFORMS)
+
+
+async def _async_auth_and_create_api(
+    hass: HomeAssistant, entry: VolvoConfigEntry
+) -> VolvoCarsApi:
+    implementation = await async_get_config_entry_implementation(hass, entry)
+    oauth_session = OAuth2Session(hass, entry, implementation)
+    web_session = async_get_clientsession(hass)
+    auth = VolvoAuth(web_session, oauth_session)
+
+    try:
+        await auth.async_get_access_token()
+    except ClientResponseError as err:
+        if err.status in (400, 401):
+            raise ConfigEntryAuthFailed from err
+
+        raise ConfigEntryNotReady from err
+
+    return VolvoCarsApi(
+        web_session,
+        auth,
+        entry.data[CONF_API_KEY],
+        entry.data[CONF_VIN],
+    )
+
+
+async def _async_load_vehicle(api: VolvoCarsApi) -> VolvoCarsVehicle:
+    try:
+        vehicle = await api.async_get_vehicle_details()
+    except VolvoAuthException as ex:
+        raise ConfigEntryAuthFailed(
+            translation_domain=DOMAIN,
+            translation_key="unauthorized",
+            translation_placeholders={"message": ex.message},
+        ) from ex
+
+    if vehicle is None:
+        raise ConfigEntryError(translation_domain=DOMAIN, translation_key="no_vehicle")
+
+    return vehicle

homeassistant/components/volvo/api.py

@@ -0,0 +1,38 @@
+"""API for Volvo bound to Home Assistant OAuth."""
+
+from typing import cast
+
+from aiohttp import ClientSession
+from volvocarsapi.auth import AccessTokenManager
+
+from homeassistant.helpers.config_entry_oauth2_flow import OAuth2Session
+
+
+class VolvoAuth(AccessTokenManager):
+    """Provide Volvo authentication tied to an OAuth2 based config entry."""
+
+    def __init__(self, websession: ClientSession, oauth_session: OAuth2Session) -> None:
+        """Initialize Volvo auth."""
+        super().__init__(websession)
+        self._oauth_session = oauth_session
+
+    async def async_get_access_token(self) -> str:
+        """Return a valid access token."""
+        await self._oauth_session.async_ensure_token_valid()
+        return cast(str, self._oauth_session.token["access_token"])
+
+
+class ConfigFlowVolvoAuth(AccessTokenManager):
+    """Provide Volvo authentication before a ConfigEntry exists.
+
+    This implementation directly provides the token without supporting refresh.
+    """
+
+    def __init__(self, websession: ClientSession, token: str) -> None:
+        """Initialize ConfigFlowVolvoAuth."""
+        super().__init__(websession)
+        self._token = token
+
+    async def async_get_access_token(self) -> str:
+        """Return the token for the Volvo API."""
+        return self._token

homeassistant/components/volvo/application_credentials.py

@@ -0,0 +1,37 @@
+"""Application credentials platform for the Volvo integration."""
+
+from __future__ import annotations
+
+from volvocarsapi.auth import AUTHORIZE_URL, TOKEN_URL
+from volvocarsapi.scopes import DEFAULT_SCOPES
+
+from homeassistant.components.application_credentials import ClientCredential
+from homeassistant.core import HomeAssistant
+from homeassistant.helpers.config_entry_oauth2_flow import (
+    LocalOAuth2ImplementationWithPkce,
+)
+
+
+async def async_get_auth_implementation(
+    hass: HomeAssistant, auth_domain: str, credential: ClientCredential
+) -> VolvoOAuth2Implementation:
+    """Return auth implementation for a custom auth implementation."""
+    return VolvoOAuth2Implementation(
+        hass,
+        auth_domain,
+        credential.client_id,
+        AUTHORIZE_URL,
+        TOKEN_URL,
+        credential.client_secret,
+    )
+
+
+class VolvoOAuth2Implementation(LocalOAuth2ImplementationWithPkce):
+    """Volvo oauth2 implementation."""
+
+    @property
+    def extra_authorize_data(self) -> dict:
+        """Extra data that needs to be appended to the authorize url."""
+        return super().extra_authorize_data | {
+            "scope": " ".join(DEFAULT_SCOPES),
+        }

homeassistant/components/volvo/config_flow.py

@@ -0,0 +1,239 @@
+"""Config flow for Volvo."""
+
+from __future__ import annotations
+
+from collections.abc import Mapping
+import logging
+from typing import Any
+
+import voluptuous as vol
+from volvocarsapi.api import VolvoCarsApi
+from volvocarsapi.models import VolvoApiException, VolvoCarsVehicle
+
+from homeassistant.config_entries import (
+    SOURCE_REAUTH,
+    SOURCE_RECONFIGURE,
+    ConfigFlowResult,
+)
+from homeassistant.const import CONF_ACCESS_TOKEN, CONF_API_KEY, CONF_NAME, CONF_TOKEN
+from homeassistant.core import HomeAssistant
+from homeassistant.helpers import aiohttp_client
+from homeassistant.helpers.config_entry_oauth2_flow import AbstractOAuth2FlowHandler
+from homeassistant.helpers.selector import (
+    SelectOptionDict,
+    SelectSelector,
+    SelectSelectorConfig,
+    TextSelector,
+    TextSelectorConfig,
+    TextSelectorType,
+)
+
+from .api import ConfigFlowVolvoAuth
+from .const import CONF_VIN, DOMAIN, MANUFACTURER
+
+_LOGGER = logging.getLogger(__name__)
+
+
+def _create_volvo_cars_api(
+    hass: HomeAssistant, access_token: str, api_key: str
+) -> VolvoCarsApi:
+    web_session = aiohttp_client.async_get_clientsession(hass)
+    auth = ConfigFlowVolvoAuth(web_session, access_token)
+    return VolvoCarsApi(web_session, auth, api_key)
+
+
+class VolvoOAuth2FlowHandler(AbstractOAuth2FlowHandler, domain=DOMAIN):
+    """Config flow to handle Volvo OAuth2 authentication."""
+
+    DOMAIN = DOMAIN
+
+    def __init__(self) -> None:
+        """Initialize Volvo config flow."""
+        super().__init__()
+
+        self._vehicles: list[VolvoCarsVehicle] = []
+        self._config_data: dict = {}
+
+    @property
+    def logger(self) -> logging.Logger:
+        """Return logger."""
+        return _LOGGER
+
+    async def async_oauth_create_entry(self, data: dict) -> ConfigFlowResult:
+        """Create an entry for the flow."""
+        self._config_data |= data
+        return await self.async_step_api_key()
+
+    async def async_step_reauth(self, _: Mapping[str, Any]) -> ConfigFlowResult:
+        """Perform reauth upon an API authentication error."""
+        return await self.async_step_reauth_confirm()
+
+    async def async_step_reconfigure(
+        self, _: dict[str, Any] | None = None
+    ) -> ConfigFlowResult:
+        """Reconfigure the entry."""
+        return await self.async_step_api_key()
+
+    async def async_step_reauth_confirm(
+        self, user_input: dict[str, Any] | None = None
+    ) -> ConfigFlowResult:
+        """Confirm reauth dialog."""
+        if user_input is None:
+            return self.async_show_form(
+                step_id="reauth_confirm",
+                description_placeholders={CONF_NAME: self._get_reauth_entry().title},
+            )
+        return await self.async_step_user()
+
+    async def async_step_api_key(
+        self, user_input: dict[str, Any] | None = None
+    ) -> ConfigFlowResult:
+        """Handle the API key step."""
+        errors: dict[str, str] = {}
+
+        if user_input is not None:
+            api = _create_volvo_cars_api(
+                self.hass,
+                self._config_data[CONF_TOKEN][CONF_ACCESS_TOKEN],
+                user_input[CONF_API_KEY],
+            )
+
+            # Try to load all vehicles on the account. If it succeeds
+            # it means that the given API key is correct. The vehicle info
+            # is used in the VIN step.
+            try:
+                await self._async_load_vehicles(api)
+            except VolvoApiException:
+                _LOGGER.exception("Unable to retrieve vehicles")
+                errors["base"] = "cannot_load_vehicles"
+
+            if not errors:
+                self._config_data |= user_input
+                return await self.async_step_vin()
+
+        if user_input is None:
+            if self.source == SOURCE_REAUTH:
+                user_input = self._config_data = dict(self._get_reauth_entry().data)
+                api = _create_volvo_cars_api(
+                    self.hass,
+                    self._config_data[CONF_TOKEN][CONF_ACCESS_TOKEN],
+                    self._config_data[CONF_API_KEY],
+                )
+
+                # Test if the configured API key is still valid. If not, show this
+                # form. If it is, skip this step and go directly to the next step.
+                try:
+                    await self._async_load_vehicles(api)
+                    return await self.async_step_vin()
+                except VolvoApiException:
+                    pass
+
+            elif self.source == SOURCE_RECONFIGURE:
+                user_input = self._config_data = dict(
+                    self._get_reconfigure_entry().data
+                )
+            else:
+                user_input = {}
+
+        schema = self.add_suggested_values_to_schema(
+            vol.Schema(
+                {
+                    vol.Required(CONF_API_KEY): TextSelector(
+                        TextSelectorConfig(
+                            type=TextSelectorType.TEXT, autocomplete="password"
+                        )
+                    ),
+                }
+            ),
+            {
+                CONF_API_KEY: user_input.get(CONF_API_KEY, ""),
+            },
+        )
+
+        return self.async_show_form(
+            step_id="api_key",
+            data_schema=schema,
+            errors=errors,
+            description_placeholders={
+                "volvo_dev_portal": "https://developer.volvocars.com/account/#your-api-applications"
+            },
+        )
+
+    async def async_step_vin(
+        self, user_input: dict[str, Any] | None = None
+    ) -> ConfigFlowResult:
+        """Handle the VIN step."""
+        errors: dict[str, str] = {}
+
+        if len(self._vehicles) == 1:
+            # If there is only one VIN, take that as value and
+            # immediately create the entry. No need to show
+            # the VIN step.
+            self._config_data[CONF_VIN] = self._vehicles[0].vin
+            return await self._async_create_or_update()
+
+        if self.source in (SOURCE_REAUTH, SOURCE_RECONFIGURE):
+            # Don't let users change the VIN. The entry should be
+            # recreated if they want to change the VIN.
+            return await self._async_create_or_update()
+
+        if user_input is not None:
+            self._config_data |= user_input
+            return await self._async_create_or_update()
+
+        if len(self._vehicles) == 0:
+            errors[CONF_VIN] = "no_vehicles"
+
+        schema = vol.Schema(
+            {
+                vol.Required(CONF_VIN): SelectSelector(
+                    SelectSelectorConfig(
+                        options=[
+                            SelectOptionDict(
+                                value=v.vin,
+                                label=f"{v.description.model} ({v.vin})",
+                            )
+                            for v in self._vehicles
+                        ],
+                        multiple=False,
+                    )
+                ),
+            },
+        )
+
+        return self.async_show_form(step_id="vin", data_schema=schema, errors=errors)
+
+    async def _async_create_or_update(self) -> ConfigFlowResult:
+        vin = self._config_data[CONF_VIN]
+        await self.async_set_unique_id(vin)
+
+        if self.source == SOURCE_REAUTH:
+            self._abort_if_unique_id_mismatch()
+            return self.async_update_reload_and_abort(
+                self._get_reauth_entry(),
+                data_updates=self._config_data,
+            )
+
+        if self.source == SOURCE_RECONFIGURE:
+            self._abort_if_unique_id_mismatch()
+            return self.async_update_reload_and_abort(
+                self._get_reconfigure_entry(),
+                data_updates=self._config_data,
+                reload_even_if_entry_is_unchanged=False,
+            )
+
+        self._abort_if_unique_id_configured()
+        return self.async_create_entry(
+            title=f"{MANUFACTURER} {vin}",
+            data=self._config_data,
+        )
+
+    async def _async_load_vehicles(self, api: VolvoCarsApi) -> None:
+        self._vehicles = []
+        vins = await api.async_get_vehicles()
+
+        for vin in vins:
+            vehicle = await api.async_get_vehicle_details(vin)
+
+            if vehicle:
+                self._vehicles.append(vehicle)