Merge pull request #306 from cyberjunky/mfa

Added support for MFA

README.md

@@ -3,39 +3,26 @@
 # Garmin Connect
 The Garmin Connect integration allows you to expose data from Garmin Connect to Home Assistant.
 
-NOTE: This integration doesn't support 2FA on Garmin Connect yet (support is coming), so if you have enabled it -and want to keep it- this integration doesn't work, it will try to login repeatedly and generate lots of 2FA codes via email.
-The change of adding support for it is unlikely since the Garmin Connect API is closed source, and will not be open for open-sourced projects.
+## Install via HACS
+
+- The installation is done inside [HACS](https://hacs.xyz/) (Home Assistant Community Store).
+- If you already have HACS installed click on the MyHomeAssistant button below, otherwise install HACS before adding this integration.  
+  You can find installation instructions [here.](https://hacs.xyz/docs/setup/download)
+- Once HACS is installed, search for `garmin connect` and click on "Download". Once downloaded, restart HomeAssistant.
 
 ## Installation
 
-### HACS - Recommended
-- Have [HACS](https://hacs.xyz) installed, this will allow you to easily manage and track updates.
-- Inside HACS click 'Explore & download repositories'
-- Search for 'Garmin Connect'.
-- Click on found integration.
-- Click Download this repository with HACS.
-- Restart Home-Assistant.
-- Follow configuration steps below.
-
-### Manual
-- Copy directory `custom_components/garmin_connect` to your `<config dir>/custom_components` directory.
-- Restart Home-Assistant.
-- Follow configuration steps below.
+[![Open your Home Assistant instance and open a repository inside the Home Assistant Community Store.](https://my.home-assistant.io/badges/hacs_repository.svg)](https://my.home-assistant.io/redirect/hacs_repository/?owner=cyberjunky&repository=home-assistant-garmin_connect&category=integration)
 
 ## Configuration
 
-Adding Garmin Connect to your Home Assistant instance can be done via the integrations user interface.
+- In the sidebar, click 'Configuration', then 'Devices & Services'. Click the + icon to add "Garmin Connect" to your Home Assistant installation.
+  - Enter the credentials of the Garmin Connect account you want to add.
+  - Optionally -when MFA is enabled- it will ask for your MFA code.
 
-- Browse to your Home Assistant instance.
-- In the sidebar click on Configuration.
-- From the configuration menu select: Integrations.
-- In the bottom right, click on the Add Integration button.
-- From the list, search and select “Garmin Connect”.
-- Follow the instruction on screen to complete the set up
+After successful set up a standard set of sensors are enabled. You can enable more if needed by using the Entities page under Devices and services. (Filter on disabled state)
 
-After successful set up a standard set of sensors are enabled. You can enable more if needed by using the Integrations page.
-
-Please be aware that Garmin Connect has very low rate limits, max. once every ~5 minutes.
+The integration will fetch new data every 5 minutes, make sure your devices sync to the Garmin Connect website.
 
 ## Available Sensors
 
@@ -84,6 +71,15 @@ Next Alarm Time
 Total Sleep Duration
 HRV Status
 Gear Sensors
+Chronological Age
+Fitness Age
+Achievable Fitness Age
+Previous Fitness Age
+Hydration
+Hydration Goal
+Hydration Daily Average
+Hydration Sweat Loss
+Hydration Activity Intake
 ```
 
 Disabled by default:
@@ -229,4 +225,5 @@ logger:
 ```
 
 ## Donation
+
 [![Donate](https://img.shields.io/badge/Donate-PayPal-green.svg)](https://www.paypal.me/cyberjunkynl/)

custom_components/garmin_connect/__init__.py

@@ -5,7 +5,7 @@ from collections.abc import Awaitable
 from datetime import datetime, timedelta
 import logging
 from zoneinfo import ZoneInfo
-
+import requests
 from garminconnect import (
     Garmin,
     GarminConnectAuthenticationError,
@@ -13,12 +13,10 @@ from garminconnect import (
     GarminConnectTooManyRequestsError,
 )
 from homeassistant.config_entries import ConfigEntry
-from homeassistant.const import CONF_PASSWORD, CONF_USERNAME
+from homeassistant.const import CONF_TOKEN
 from homeassistant.core import HomeAssistant
-from homeassistant.exceptions import ConfigEntryNotReady
-from homeassistant.helpers.update_coordinator import DataUpdateCoordinator, UpdateFailed
-import requests
-
+from homeassistant.exceptions import ConfigEntryAuthFailed, ConfigEntryNotReady
+from homeassistant.helpers.update_coordinator import DataUpdateCoordinator
 from .const import (
     DATA_COORDINATOR,
     DAY_TO_NUMBER,
@@ -63,44 +61,92 @@ class GarminConnectDataUpdateCoordinator(DataUpdateCoordinator):
     """Garmin Connect Data Update Coordinator."""
 
     def __init__(self, hass: HomeAssistant, entry: ConfigEntry) -> None:
-        """Initialize the Garmin Connect hub."""
+        """
+        Initialize the Garmin Connect data update coordinator for Home Assistant.
+        
+        Configures the Garmin API client, determines if the user is located in China, sets the time zone, and establishes the data update interval for the integration.
+        """
         self.entry = entry
         self.hass = hass
-        self.in_china = False
+        self._in_china = False
 
-        self.country = self.hass.config.country
-        if self.country == "CN":
-            self.in_china = True
-        _LOGGER.debug("Country: %s", self.country)
+        # Check if the user resides in China
+        country = self.hass.config.country
+        if country == "CN":
+            self._in_china = True
+        _LOGGER.debug("Country: %s", country)
 
         self.time_zone = self.hass.config.time_zone
         _LOGGER.debug("Time zone: %s", self.time_zone)
 
-        self.api = Garmin(entry.data[CONF_USERNAME], entry.data[CONF_PASSWORD], self.in_china)
+        self.api = Garmin(is_cn=self._in_china)
 
-        super().__init__(hass, _LOGGER, name=DOMAIN, update_interval=DEFAULT_UPDATE_INTERVAL)
+        super().__init__(hass, _LOGGER, name=DOMAIN,
+                         update_interval=DEFAULT_UPDATE_INTERVAL)
 
     async def async_login(self) -> bool:
-        """Login to Garmin Connect."""
+        """
+        Asynchronously authenticates with Garmin Connect using a stored token.
+        
+        Attempts to log in with the token from the configuration entry, handling authentication failures, rate limiting, connection errors, and missing tokens by raising Home Assistant exceptions or returning False for recoverable errors.
+        
+        Returns:
+            bool: True if login succeeds; False if rate limited or an unknown error occurs.
+        
+        Raises:
+            ConfigEntryAuthFailed: If authentication fails or the token is missing.
+            ConfigEntryNotReady: If a connection error occurs.
+        """
         try:
-            await self.hass.async_add_executor_job(self.api.login)
-        except (
-            GarminConnectAuthenticationError,
-            GarminConnectTooManyRequestsError,
-        ) as err:
-            _LOGGER.error("Error occurred during Garmin Connect login request: %s", err)
+            # Check if the token exists in the entry data
+            if CONF_TOKEN not in self.entry.data:
+                raise KeyError("Token not found, migrating config entry")
+
+            await self.hass.async_add_executor_job(self.api.login, self.entry.data[CONF_TOKEN])
+        except GarminConnectAuthenticationError as err:
+            _LOGGER.error(
+                "Authentication error occurred during login: %s", err.response.text)
+            raise ConfigEntryAuthFailed from err
+        except GarminConnectTooManyRequestsError as err:
+            _LOGGER.error(
+                "Too many request error occurred during login: %s", err)
             return False
         except GarminConnectConnectionError as err:
-            _LOGGER.error("Connection error occurred during Garmin Connect login request: %s", err)
+            _LOGGER.error(
+                "Connection error occurred during login: %s", err)
             raise ConfigEntryNotReady from err
-        except Exception:  # pylint: disable=broad-except
-            _LOGGER.exception("Unknown error occurred during Garmin Connect login request")
+        except requests.exceptions.HTTPError as err:
+            if err.response.status_code == 401:
+                _LOGGER.error(
+                    "Authentication error occurred during login: %s", err.response.text)
+                raise ConfigEntryAuthFailed from err
+            if err.response.status_code == 429:
+                _LOGGER.error(
+                    "Too many requests error occurred during login: %s", err.response.text)
+                return False
+            _LOGGER.error(
+                "Unknown HTTP error occurred during login: %s", err)
+            return False
+        except KeyError as err:
+            _LOGGER.error(
+                "Found old config during login: %s", err)
+            raise ConfigEntryAuthFailed from err
+        except Exception as err:  # pylint: disable=broad-except
+            _LOGGER.exception(
+                "Unknown error occurred during login: %s", err)
             return False
 
         return True
 
     async def _async_update_data(self) -> dict:
-        """Fetch data from Garmin Connect."""
+        """
+        Fetches and aggregates comprehensive user data from Garmin Connect for the current day.
+        
+        This asynchronous method retrieves and consolidates user summary, body composition, recent activities, badges, alarms, activity types, sleep metrics, HRV data, fitness age, hydration, and gear information. It calculates user points and level, determines the next scheduled alarms, and extracts key sleep and HRV metrics. Handles authentication, connection, and rate limiting errors by raising Home Assistant exceptions or returning empty results as appropriate.
+        
+        Returns:
+            dict: A dictionary containing consolidated Garmin Connect data, including user summary, body composition, activities, badges, alarms, activity types, sleep metrics, HRV status, fitness age, hydration, gear details, user points, user level, next alarms, sleep score, and sleep time.
+        """
         summary = {}
         body = {}
         alarms = {}
@@ -123,13 +169,19 @@ class GarminConnectDataUpdateCoordinator(DataUpdateCoordinator):
             summary = await self.hass.async_add_executor_job(
                 self.api.get_user_summary, today.isoformat()
             )
-            _LOGGER.debug("Summary data fetched: %s", summary)
+            if summary:
+                _LOGGER.debug("User summary data fetched: %s", summary)
+            else:
+                _LOGGER.debug("No user summary data found")
 
             # Body composition
             body = await self.hass.async_add_executor_job(
                 self.api.get_body_composition, today.isoformat()
             )
-            _LOGGER.debug("Body data fetched: %s", body)
+            if body:
+                _LOGGER.debug("Body data fetched: %s", body)
+            else:
+                _LOGGER.debug("No body data found")
 
             # Last activities
             last_activities = await self.hass.async_add_executor_job(
@@ -137,20 +189,33 @@ class GarminConnectDataUpdateCoordinator(DataUpdateCoordinator):
                 (today - timedelta(days=7)).isoformat(),
                 (today + timedelta(days=1)).isoformat(),
             )
-            _LOGGER.debug("Activities data fetched: %s", last_activities)
+            if last_activities:
+                _LOGGER.debug("Last activities data fetched: %s",
+                              last_activities)
+            else:
+                _LOGGER.debug("No last activities data found")
+
+            # Add last activities to summary
             summary["lastActivities"] = last_activities
             summary["lastActivity"] = last_activities[0] if last_activities else {}
 
             # Badges
             badges = await self.hass.async_add_executor_job(self.api.get_earned_badges)
-            _LOGGER.debug("Badges data fetched: %s", badges)
+            if badges:
+                _LOGGER.debug("Badges data fetched: %s", badges)
+            else:
+                _LOGGER.debug("No badges data found")
+
+            # Add badges to summary
             summary["badges"] = badges
 
             # Calculate user points and user level
             user_points = 0
             for badge in badges:
-                user_points += badge["badgePoints"] * badge["badgeEarnedNumber"]
+                user_points += badge["badgePoints"] * \
+                    badge["badgeEarnedNumber"]
 
+            # Add user points to summary
             summary["userPoints"] = user_points
 
             user_level = 0
@@ -158,90 +223,176 @@ class GarminConnectDataUpdateCoordinator(DataUpdateCoordinator):
                 if user_points >= points:
                     user_level = level
 
+            # Add user level to summary
             summary["userLevel"] = user_level
 
             # Alarms
             alarms = await self.hass.async_add_executor_job(self.api.get_device_alarms)
-            _LOGGER.debug("Alarms data fetched: %s", alarms)
+            if alarms:
+                _LOGGER.debug("Alarms data fetched: %s", alarms)
+            else:
+                _LOGGER.debug("No alarms data found")
 
+            # Add alarms to summary
             next_alarms = calculate_next_active_alarms(alarms, self.time_zone)
 
             # Activity types
             activity_types = await self.hass.async_add_executor_job(self.api.get_activity_types)
-            _LOGGER.debug("Activity types data fetched: %s", activity_types)
+            if activity_types:
+                _LOGGER.debug("Activity types data fetched: %s",
+                              activity_types)
+            else:
+                _LOGGER.debug("No activity types data found")
 
             # Sleep data
             sleep_data = await self.hass.async_add_executor_job(
                 self.api.get_sleep_data, today.isoformat()
             )
-            _LOGGER.debug("Sleep data fetched: %s", sleep_data)
+            if sleep_data:
+                _LOGGER.debug("Sleep data fetched: %s", sleep_data)
+            else:
+                _LOGGER.debug("No sleep data found")
 
             # HRV data
             hrv_data = await self.hass.async_add_executor_job(
                 self.api.get_hrv_data, today.isoformat()
             )
-            _LOGGER.debug("HRV data fetched: %s", hrv_data)
-        except (
-            GarminConnectAuthenticationError,
-            GarminConnectTooManyRequestsError,
-            GarminConnectConnectionError,
-        ) as error:
-            _LOGGER.debug("Trying to relogin to Garmin Connect")
-            if not await self.async_login():
-                raise UpdateFailed(error) from error
+            if hrv_data:
+                _LOGGER.debug("HRV data fetched: %s", hrv_data)
+            else:
+                _LOGGER.debug("No HRV data found")
+
+            # Fitness age data
+            fitnessage_data = await self.hass.async_add_executor_job(
+                self.api.get_fitnessage_data, today.isoformat()
+            )
+            if fitnessage_data:
+                _LOGGER.debug("Fitness age data fetched: %s", fitnessage_data)
+            else:
+                _LOGGER.debug("No fitness age data found")
+
+            # Hyrdation data
+            hydration_data = await self.hass.async_add_executor_job(
+                self.api.get_hydration_data, today.isoformat()
+            )
+            if hydration_data:
+                _LOGGER.debug("Hydration data fetched: %s", hydration_data)
+            else:
+                _LOGGER.debug("No hydration data found")
+
+        except GarminConnectAuthenticationError as err:
+            _LOGGER.error(
+                "Authentication error occurred during update: %s", err.response.text)
+            raise ConfigEntryAuthFailed from err
+        except GarminConnectTooManyRequestsError as err:
+            _LOGGER.error(
+                "Too many request error occurred during update: %s", err)
+            return {}
+        except GarminConnectConnectionError as err:
+            _LOGGER.error(
+                "Connection error occurred during update: %s", err)
+            raise ConfigEntryNotReady from err
+        except requests.exceptions.HTTPError as err:
+            if err.response.status_code == 401:
+                _LOGGER.error(
+                    "Authentication error occurred during update: %s", err.response.text)
+                raise ConfigEntryAuthFailed from err
+            if err.response.status_code == 429:
+                _LOGGER.error(
+                    "Too many requests error occurred during update: %s", err.response.text)
+                return {}
+            _LOGGER.error(
+                "Unknown HTTP error occurred during update: %s", err)
+            return False
+        except Exception as err:  # pylint: disable=broad-except
+            _LOGGER.exception(
+                "Unknown error occurred during update: %s", err)
+            return {}
 
-        # Gear data
         try:
+            # Gear data like shoes, bike, etc.
             gear = await self.hass.async_add_executor_job(
                 self.api.get_gear, summary[Gear.USERPROFILE_ID]
             )
-            _LOGGER.debug("Gear data fetched: %s", gear)
+            if gear:
+                _LOGGER.debug("Gear data fetched: %s", gear)
+            else:
+                _LOGGER.debug("No gear data found")
 
-            gear_defaults = await self.hass.async_add_executor_job(
-                self.api.get_gear_defaults, summary[Gear.USERPROFILE_ID]
-            )
-            _LOGGER.debug("Gear defaults data fetched: %s", gear_defaults)
-        except (KeyError, TypeError, ValueError, ConnectionError) as err:
-            _LOGGER.debug("Error while fetching Gear data: %s", err)
-
-        # Gear stats data
-        try:
+            # Gear stats data like distance, time, etc.
             tasks: list[Awaitable] = [
-                self.hass.async_add_executor_job(self.api.get_gear_stats, gear_item[Gear.UUID])
+                self.hass.async_add_executor_job(
+                    self.api.get_gear_stats, gear_item[Gear.UUID])
                 for gear_item in gear
             ]
             gear_stats = await asyncio.gather(*tasks)
-            _LOGGER.debug("Gear stats data fetched: %s", gear_stats)
-        except (
-            KeyError,
-            TypeError,
-            ValueError,
-            ConnectionError,
-            requests.exceptions.HTTPError,
-        ) as err:
-            _LOGGER.debug("Error while fetching Gear stats data: %s", err)
+            if gear_stats:
+                _LOGGER.debug("Gear statistics data fetched: %s", gear_stats)
+            else:
+                _LOGGER.debug("No gear statistics data found")
+
+            # Gear defaults data like shoe, bike, etc.
+            gear_defaults = await self.hass.async_add_executor_job(
+                self.api.get_gear_defaults, summary[Gear.USERPROFILE_ID]
+            )
+            if gear_defaults:
+                _LOGGER.debug("Gear defaults data fetched: %s", gear_defaults)
+            else:
+                _LOGGER.debug("No gear defaults data found")
+        except GarminConnectAuthenticationError as err:
+            _LOGGER.error(
+                "Authentication error occurred while fetching Gear data: %s", err.response.text)
+            raise ConfigEntryAuthFailed from err
+        except GarminConnectTooManyRequestsError as err:
+            _LOGGER.error(
+                "Too many request error occurred while fetching Gear data: %s", err)
+            raise ConfigEntryNotReady from err
+        except GarminConnectConnectionError as err:
+            _LOGGER.error(
+                "Connection error occurred while fetching Gear data: %s", err)
+            raise ConfigEntryNotReady from err
+        except requests.exceptions.HTTPError as err:
+            if err.response.status_code == 401:
+                _LOGGER.error(
+                    "Authentication error while fetching Gear data: %s", err.response.text)
+            elif err.response.status_code == 404:
+                _LOGGER.error(
+                    "URL not found error while fetching Gear data: %s", err.response.text)
+            elif err.response.status_code == 429:
+                _LOGGER.error(
+                    "Too many requests error while fetching Gear data: %s", err.response.text)
+            else:
+                _LOGGER.error(
+                    "Unknown HTTP error occurred while fetching Gear data: %s", err)
+        except (KeyError, TypeError, ValueError, ConnectionError) as err:
+            _LOGGER.debug("Error occurred while fetching Gear data: %s", err)
 
         # Sleep score data
         try:
             sleep_score = sleep_data["dailySleepDTO"]["sleepScores"]["overall"]["value"]
             _LOGGER.debug("Sleep score data: %s", sleep_score)
         except KeyError:
-            _LOGGER.debug("Sleep score data is not available")
+            _LOGGER.debug("No sleep score data found")
 
         # Sleep time seconds data
         try:
             sleep_time_seconds = sleep_data["dailySleepDTO"]["sleepTimeSeconds"]
-            _LOGGER.debug("Sleep time seconds data: %s", sleep_time_seconds)
+            if sleep_time_seconds:
+                _LOGGER.debug("Sleep time seconds data: %s",
+                              sleep_time_seconds)
+            else:
+                _LOGGER.debug("No sleep time seconds data found")
         except KeyError:
-            _LOGGER.debug("Sleep time seconds data is not available")
+            _LOGGER.debug("No sleep time seconds data found")
 
         # HRV data
         try:
             if hrv_data and "hrvSummary" in hrv_data:
                 hrv_status = hrv_data["hrvSummary"]
-                _LOGGER.debug("HRV summary: %s", hrv_status)
+                _LOGGER.debug("HRV summary status: %s", hrv_status)
         except KeyError:
-            _LOGGER.debug("HRV data is not available")
+            _LOGGER.debug(
+                "Error occurred while processing HRV summary status data")
 
         return {
             **summary,
@@ -254,18 +405,29 @@ class GarminConnectDataUpdateCoordinator(DataUpdateCoordinator):
             "sleepScore": sleep_score,
             "sleepTimeSeconds": sleep_time_seconds,
             "hrvStatus": hrv_status,
+            **fitnessage_data,
+            **hydration_data,
         }
 
 
 def calculate_next_active_alarms(alarms, time_zone):
     """
-    Calculate garmin next active alarms from settings.
-    Alarms are sorted by time.
-
-    Example of alarms data:
-    Alarms data fetched: [{'alarmMode': 'OFF', 'alarmTime': 1233, 'alarmDays': ['ONCE'], 'alarmSound': 'TONE_AND_VIBRATION', 'alarmId': 1737308355, 'changeState': 'UNCHANGED', 'backlight': 'ON', 'enabled': None, 'alarmMessage': None, 'alarmImageId': None, 'alarmIcon': None, 'alarmType': None}]
+    Calculate the next scheduled active Garmin alarms based on alarm settings and the current time.
+    
+    Filters alarms that are enabled and computes the next scheduled datetime for each alarm day, handling both one-time and recurring alarms. Returns a sorted list of ISO-formatted datetimes for upcoming alarms, or None if no active alarms are scheduled.
+    
+    Parameters:
+        alarms: List of alarm setting dictionaries from Garmin devices.
+        time_zone: Time zone string used to localize alarm times.
+    
+    Returns:
+        A sorted list of ISO-formatted datetimes for the next active alarms, or None if none are scheduled.
     """
     active_alarms = []
+
+    if not alarms:
+        return active_alarms
+
     now = datetime.now(ZoneInfo(time_zone))
     _LOGGER.debug("Now: %s, Alarms: %s", now, alarms)
 
@@ -295,8 +457,10 @@ def calculate_next_active_alarms(alarms, time_zone):
                 )
 
                 days_to_add = DAY_TO_NUMBER[day] % 7
-                alarm = start_of_week + timedelta(minutes=alarm_time, days=days_to_add)
-                _LOGGER.debug("Start of week: %s, Alarm: %s", start_of_week, alarm)
+                alarm = start_of_week + \
+                    timedelta(minutes=alarm_time, days=days_to_add)
+                _LOGGER.debug("Start of week: %s, Alarm: %s",
+                              start_of_week, alarm)
 
                 # If the alarm time is in the past, move it to the next week
                 if alarm < now:

custom_components/garmin_connect/config_flow.py

@@ -1,72 +1,211 @@
 """Config flow for Garmin Connect integration."""
 
 import logging
-
+from collections.abc import Mapping
+from typing import Any, cast
+import requests
 from garminconnect import (
     Garmin,
     GarminConnectAuthenticationError,
     GarminConnectConnectionError,
     GarminConnectTooManyRequestsError,
 )
-from homeassistant import config_entries
-from homeassistant.const import CONF_ID, CONF_PASSWORD, CONF_USERNAME
+from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
+from homeassistant.const import CONF_ID, CONF_TOKEN, CONF_PASSWORD, CONF_USERNAME
 import voluptuous as vol
+import garth
 
-from .const import DOMAIN
+from .const import CONF_MFA, DOMAIN
 
 _LOGGER = logging.getLogger(__name__)
 
 
-class GarminConnectConfigFlowHandler(config_entries.ConfigFlow, domain=DOMAIN):
+class GarminConnectConfigFlowHandler(ConfigFlow, domain=DOMAIN):
     """Handle a config flow for Garmin Connect."""
 
     VERSION = 1
 
-    async def _show_setup_form(self, errors=None):
-        """Show the setup form to the user."""
-        return self.async_show_form(
-            step_id="user",
-            data_schema=vol.Schema(
-                {vol.Required(CONF_USERNAME): str, vol.Required(CONF_PASSWORD): str}
-            ),
-            errors=errors or {},
-        )
+    def __init__(self) -> None:
+        """
+        Initialize schemas and internal state for the Garmin Connect configuration flow handler.
+        
+        Sets up validation schemas for user credentials and MFA input, and initializes variables for API client, login results, MFA code, credentials, and region detection.
+        """
+        self.data_schema = {
+            vol.Required(CONF_USERNAME): str,
+            vol.Required(CONF_PASSWORD): str,
+        }
+        self.mfa_data_schema = {
+            vol.Required(CONF_MFA): str,
+        }
 
-    async def async_step_user(self, user_input=None):
-        """Handle the initial step."""
-        if user_input is None:
-            return await self._show_setup_form()
-
-        username = user_input[CONF_USERNAME]
-        password = user_input[CONF_PASSWORD]
-
-        api = Garmin(username, password)
+        self._api = None
+        self._login_result1: Any = None
+        self._login_result2: Any = None
+        self._mfa_code: str | None = None
+        self._username: str | None = None
+        self._password: str | None = None
+        self._in_china = False
 
+    async def _async_garmin_connect_login(self, step_id: str) -> ConfigFlowResult:
+        """
+        Authenticate the user with Garmin Connect and handle login errors or multi-factor authentication requirements.
+        
+        If the user is located in China, configures the API client for the region. Initiates the login process and, if multi-factor authentication is needed, transitions to the MFA step. Handles specific authentication and connection errors, returning appropriate error messages to the user. On successful authentication, proceeds to create or update the configuration entry.
+        
+        Parameters:
+            step_id (str): The current step identifier in the configuration flow.
+        
+        Returns:
+            ConfigFlowResult: The result of the configuration flow step, which may be a form with errors, a transition to MFA, or entry creation.
+        """
         errors = {}
+
+        # Check if the user resides in China
+        country = self.hass.config.country
+        if country == "CN":
+            self._in_china = True
+
+        self._api = Garmin(email=self._username,
+                           password=self._password, return_on_mfa=True, is_cn=self._in_china)
+
         try:
-            await self.hass.async_add_executor_job(api.login)
+            self._login_result1, self._login_result2 = await self.hass.async_add_executor_job(self._api.login)
+
+            if self._login_result1 == "needs_mfa":  # MFA is required
+                return await self.async_step_mfa()
+
         except GarminConnectConnectionError:
-            errors["base"] = "cannot_connect"
-            return await self._show_setup_form(errors)
+            errors = {"base": "cannot_connect"}
         except GarminConnectAuthenticationError:
-            errors["base"] = "invalid_auth"
-            return await self._show_setup_form(errors)
+            errors = {"base": "invalid_auth"}
         except GarminConnectTooManyRequestsError:
-            errors["base"] = "too_many_requests"
-            return await self._show_setup_form(errors)
+            errors = {"base": "too_many_requests"}
+        except requests.exceptions.HTTPError as err:
+            if err.response.status_code == 403:
+                errors = {"base": "invalid_auth"}
+            elif err.response.status_code == 429:
+                errors = {"base": "too_many_requests"}
+            else:
+                errors = {"base": "cannot_connect"}
         except Exception:  # pylint: disable=broad-except
             _LOGGER.exception("Unexpected exception")
-            errors["base"] = "unknown"
-            return await self._show_setup_form(errors)
+            errors = {"base": "unknown"}
 
-        await self.async_set_unique_id(username)
-        self._abort_if_unique_id_configured()
+        if errors:
+            return self.async_show_form(
+                step_id=step_id, data_schema=vol.Schema(self.data_schema), errors=errors
+            )
+
+        return await self._async_create_entry()
+
+    async def _async_garmin_connect_mfa_login(self) -> ConfigFlowResult:
+        """
+        Complete the Garmin Connect authentication process using the stored multi-factor authentication (MFA) code.
+        
+        If the MFA code is invalid or an error occurs, prompts the user to re-enter the code. On successful authentication, creates or updates the configuration entry.
+        """
+        try:
+            await self.hass.async_add_executor_job(self._api.resume_login, self._login_result2, self._mfa_code)
+
+        except garth.exc.GarthException as err:
+            _LOGGER.error("Error during MFA login: %s", err)
+            return self.async_show_form(
+                step_id="mfa",
+                data_schema=vol.Schema(self.mfa_data_schema),
+                errors={"base": "invalid_mfa_code"},
+            )
+
+        return await self._async_create_entry()
+
+    async def _async_create_entry(self) -> ConfigFlowResult:
+        """
+        Create or update the configuration entry for the Garmin Connect integration using the current user's credentials and API token.
+        
+        If an entry with the same username exists, its data is updated and the entry is reloaded; otherwise, a new entry is created with the username as the unique ID and the serialized API token.
+        """
+        config_data = {
+            CONF_ID: self._username,
+            CONF_USERNAME: self._username,
+            CONF_TOKEN: self._api.garth.dumps(),
+        }
+        existing_entry = await self.async_set_unique_id(self._username)
+
+        if existing_entry:
+            return self.async_update_reload_and_abort(existing_entry, data=config_data)
 
         return self.async_create_entry(
-            title=username,
-            data={
-                CONF_ID: username,
-                CONF_USERNAME: username,
-                CONF_PASSWORD: password,
-            },
+            title=cast(str, self._username), data=config_data
         )
+
+    async def async_step_user(
+            self, user_input: dict[str, Any] | None = None
+    ) -> ConfigFlowResult:
+        """
+            Handle the initial user step of the configuration flow.
+            
+            If no input is provided, displays a form to collect username and password. If credentials are submitted, stores them and attempts authentication with Garmin Connect.
+            """
+        if user_input is None:
+            return self.async_show_form(
+                step_id="user", data_schema=vol.Schema(self.data_schema)
+            )
+
+        self._username = user_input[CONF_USERNAME]
+        self._password = user_input[CONF_PASSWORD]
+
+        return await self._async_garmin_connect_login(step_id="user")
+
+    async def async_step_mfa(
+        self, user_input: dict[str, Any] | None = None
+    ) -> ConfigFlowResult:
+        """
+        Handle the multi-factor authentication (MFA) step in the configuration flow.
+        
+        If user input is not provided, displays a form to collect the MFA code. If input is provided, stores the MFA code and proceeds with MFA authentication.
+        """
+        if user_input is None:
+            return self.async_show_form(
+                step_id="mfa", data_schema=vol.Schema(self.mfa_data_schema)
+            )
+
+        self._mfa_code = user_input[CONF_MFA]
+        _LOGGER.debug("MFA code received")
+
+        return await self._async_garmin_connect_mfa_login()
+
+    async def async_step_reauth(
+        self, entry_data: Mapping[str, Any]
+    ) -> ConfigFlowResult:
+        """
+        Start the reauthorization process using existing configuration entry data.
+        
+        Extracts the username from the entry data and advances to the reauthorization confirmation step.
+        """
+        self._username = entry_data[CONF_USERNAME]
+
+        return await self.async_step_reauth_confirm()
+
+    async def async_step_reauth_confirm(
+        self, user_input: dict[str, Any] | None = None
+    ) -> ConfigFlowResult:
+        """
+        Prompt the user to re-enter their username and password to confirm reauthorization of the Garmin Connect integration.
+        
+        If credentials are provided, attempts to log in and complete the reauthorization process.
+        """
+        if user_input is None:
+            return self.async_show_form(
+                step_id="reauth_confirm",
+                data_schema=vol.Schema(
+                    {
+                        vol.Required(CONF_USERNAME, default=self._username): str,
+                        vol.Required(CONF_PASSWORD): str,
+                    }
+                ),
+            )
+
+        self._username = user_input[CONF_USERNAME]
+        self._password = user_input[CONF_PASSWORD]
+
+        return await self._async_garmin_connect_login(step_id="reauth_confirm")

custom_components/garmin_connect/const.py

@@ -4,12 +4,12 @@ from datetime import timedelta
 from typing import NamedTuple
 
 from homeassistant.components.sensor import SensorDeviceClass, SensorStateClass
-from homeassistant.const import PERCENTAGE, UnitOfLength, UnitOfMass, UnitOfTime
+from homeassistant.const import PERCENTAGE, UnitOfLength, UnitOfMass, UnitOfTime, UnitOfVolume
 
 DOMAIN = "garmin_connect"
 DATA_COORDINATOR = "coordinator"
 DEFAULT_UPDATE_INTERVAL = timedelta(minutes=5)
-
+CONF_MFA = "mfa_code"
 DAY_TO_NUMBER = {
     "Mo": 1,
     "M": 1,
@@ -657,6 +657,78 @@ GARMIN_ENTITY_LIST = {
         None,
         True,
     ],
+    "chronologicalAge": [
+        "Chronological Age",
+        UnitOfTime.YEARS,
+        "mdi:calendar-heart",
+        None,
+        SensorStateClass.MEASUREMENT,
+        True,
+    ],
+    "fitnessAge": [
+        "Fitness Age",
+        UnitOfTime.YEARS,
+        "mdi:calendar-heart",
+        None,
+        SensorStateClass.MEASUREMENT,
+        True,
+    ],
+    "achievableFitnessAge": [
+        "Achievable Fitness Age",
+        UnitOfTime.YEARS,
+        "mdi:calendar-heart",
+        None,
+        SensorStateClass.MEASUREMENT,
+        True,
+    ],
+    "previousFitnessAge": [
+        "Previous Fitness Age",
+        UnitOfTime.YEARS,
+        "mdi:calendar-heart",
+        None,
+        SensorStateClass.MEASUREMENT,
+        True,
+    ],
+    "valueInML": [
+        "Hydration",
+        UnitOfVolume.MILLILITERS,
+        "mdi:water",
+        None,
+        SensorStateClass.MEASUREMENT,
+        True,
+    ],
+    "goalInML": [
+        "Hydration Goal",
+        UnitOfVolume.MILLILITERS,
+        "mdi:water",
+        None,
+        SensorStateClass.MEASUREMENT,
+        True,
+    ],
+    "dailyAverageInML": [
+        "Hydration Daily Average",
+        UnitOfVolume.MILLILITERS,
+        "mdi:water",
+        None,
+        SensorStateClass.MEASUREMENT,
+        True,
+    ],
+    "sweatLossInML": [
+        "Hydration Sweat Loss",
+        UnitOfVolume.MILLILITERS,
+        "mdi:water",
+        None,
+        SensorStateClass.MEASUREMENT,
+        True,
+    ],
+    "activityIntakeInML": [
+        "Hydration Activity Intake",
+        UnitOfVolume.MILLILITERS,
+        "mdi:water",
+        None,
+        SensorStateClass.MEASUREMENT,
+        True,
+    ],
 }
 
 GEAR_ICONS = {

custom_components/garmin_connect/manifest.json

@@ -7,6 +7,6 @@
   "documentation": "https://github.com/cyberjunky/home-assistant-garmin_connect",
   "iot_class": "cloud_polling",
   "issue_tracker": "https://github.com/cyberjunky/home-assistant-garmin_connect/issues",
-  "requirements": ["garminconnect>=0.2.24"],
-  "version": "0.2.30"
+  "requirements": ["garminconnect>=0.2.27"],
+  "version": "0.2.32"
 }

custom_components/garmin_connect/sensor.py

@@ -187,7 +187,11 @@ class GarminConnectSensor(CoordinatorEntity, SensorEntity):
 
     @property
     def native_value(self):
-        """Return the state of the sensor."""
+        """
+        Return the current value of the sensor, applying type-specific formatting and conversions.
+        
+        For activity and badge sensors, returns the count. For last activity, returns the activity name. HRV status and stress qualifier values are capitalized. Duration and seconds values are converted from seconds to minutes, and mass values from grams to kilograms. For alarms, returns the next active alarm if available. Timestamp values are converted to timezone-aware datetime objects. Returns None if data is unavailable.
+        """
         if not self.coordinator.data:
             return None
 
@@ -212,8 +216,8 @@ class GarminConnectSensor(CoordinatorEntity, SensorEntity):
 
         elif self._type == "nextAlarm":
             active_alarms = self.coordinator.data[self._type]
-            _LOGGER.debug("Active alarms: %s", active_alarms)
             if active_alarms:
+                _LOGGER.debug("Active alarms: %s", active_alarms)
                 _LOGGER.debug("Next alarm: %s", active_alarms[0])
                 value = active_alarms[0]
             else:
@@ -231,7 +235,11 @@ class GarminConnectSensor(CoordinatorEntity, SensorEntity):
 
     @property
     def extra_state_attributes(self):
-        """Return attributes for sensor."""
+        """
+        Return additional state attributes for the sensor entity.
+        
+        Includes the last sync timestamp and, depending on the sensor type, recent activities (up to 5), badges (up to 10), alarms, or HRV status details (excluding the status string). Returns an empty dictionary if no coordinator data is available.
+        """
         if not self.coordinator.data:
             return {}
 
@@ -239,16 +247,17 @@ class GarminConnectSensor(CoordinatorEntity, SensorEntity):
             "last_synced": self.coordinator.data["lastSyncTimestampGMT"],
         }
 
-        # Only add the last 5 activities for performance reasons
+        # Only keep the last 5 activities for performance reasons
         if self._type == "lastActivities":
             activities = self.coordinator.data.get(self._type, [])
-            sorted_activities = sorted(activities, key=lambda x: x["activityId"])
+            sorted_activities = sorted(
+                activities, key=lambda x: x["activityId"])
             attributes["last_activities"] = sorted_activities[-5:]
 
         if self._type == "lastActivity":
             attributes = {**attributes, **self.coordinator.data[self._type]}
 
-        # Only add the last 10 badges for performance reasons
+        # Only keep the last 10 badges for performance reasons
         if self._type == "badges":
             badges = self.coordinator.data.get(self._type, [])
             sorted_badges = sorted(badges, key=lambda x: x["badgeEarnedDate"])
@@ -279,11 +288,20 @@ class GarminConnectSensor(CoordinatorEntity, SensorEntity):
 
     @property
     def available(self) -> bool:
-        """Return True if entity is available."""
+        """
+        Indicates whether the sensor entity is available based on coordinator data presence and the sensor type.
+        """
         return super().available and self.coordinator.data and self._type in self.coordinator.data
 
     async def add_body_composition(self, **kwargs):
-        """Handle the service call to add body composition."""
+        """
+        Add a new body composition measurement to Garmin Connect.
+        
+        Extracts body composition metrics from keyword arguments and submits them to the Garmin Connect API. Ensures the user is logged in before attempting to add the record.
+        
+        Raises:
+            IntegrationError: If login to Garmin Connect fails.
+        """
         weight = kwargs.get("weight")
         timestamp = kwargs.get("timestamp")
         percent_fat = kwargs.get("percent_fat")
@@ -300,7 +318,8 @@ class GarminConnectSensor(CoordinatorEntity, SensorEntity):
 
         """Check for login."""
         if not await self.coordinator.async_login():
-            raise IntegrationError("Failed to login to Garmin Connect, unable to update")
+            raise IntegrationError(
+                "Failed to login to Garmin Connect, unable to update")
 
         """Record a weigh in/body composition."""
         await self.hass.async_add_executor_job(
@@ -321,7 +340,19 @@ class GarminConnectSensor(CoordinatorEntity, SensorEntity):
         )
 
     async def add_blood_pressure(self, **kwargs):
-        """Handle the service call to add blood pressure."""
+        """
+        Add a blood pressure measurement to Garmin Connect using the provided values.
+        
+        Parameters:
+            systolic: Systolic blood pressure value.
+            diastolic: Diastolic blood pressure value.
+            pulse: Pulse rate.
+            timestamp: Optional timestamp for the measurement.
+            notes: Optional notes for the measurement.
+        
+        Raises:
+            IntegrationError: If unable to log in to Garmin Connect.
+        """
         timestamp = kwargs.get("timestamp")
         systolic = kwargs.get("systolic")
         diastolic = kwargs.get("diastolic")
@@ -330,7 +361,8 @@ class GarminConnectSensor(CoordinatorEntity, SensorEntity):
 
         """Check for login."""
         if not await self.coordinator.async_login():
-            raise IntegrationError("Failed to login to Garmin Connect, unable to update")
+            raise IntegrationError(
+                "Failed to login to Garmin Connect, unable to update")
 
         """Record a blood pressure measurement."""
         await self.hass.async_add_executor_job(
@@ -387,12 +419,17 @@ class GarminConnectGearSensor(CoordinatorEntity, SensorEntity):
 
     @property
     def extra_state_attributes(self):
-        """Return attributes for sensor."""
+        """
+        Return additional state attributes for the gear sensor entity.
+        
+        Includes metadata such as last sync time, total activities, creation and update dates, gear make/model/status, custom model, maximum distance, and a comma-separated list of activity types for which this gear is set as default. Returns an empty dictionary if required data is missing.
+        """
         gear = self._gear()
         stats = self._stats()
         gear_defaults = self._gear_defaults()
         activity_types = self.coordinator.data["activityTypes"]
-        default_for_activity = self._activity_names_for_gear_defaults(gear_defaults, activity_types)
+        default_for_activity = self._activity_names_for_gear_defaults(
+            gear_defaults, activity_types)
 
         if not self.coordinator.data or not gear or not stats:
             return {}
@@ -454,7 +491,12 @@ class GarminConnectGearSensor(CoordinatorEntity, SensorEntity):
                 return gear_item
 
     def _gear_defaults(self):
-        """Get gear defaults"""
+        """
+        Return a list of default gear settings for this gear UUID.
+        
+        Returns:
+            List of gear default dictionaries where this gear is set as the default.
+        """
         return list(
             filter(
                 lambda d: d[Gear.UUID] == self.uuid and d["defaultGear"] is True,
@@ -463,13 +505,23 @@ class GarminConnectGearSensor(CoordinatorEntity, SensorEntity):
         )
 
     async def set_active_gear(self, **kwargs):
-        """Handle the service call to set active gear."""
+        """
+        Set this gear as active or default for a specified activity type in Garmin Connect.
+        
+        Parameters:
+            activity_type (str): The activity type key for which to update the gear setting.
+            setting (str): The desired gear setting, indicating whether to set as default or as the only default.
+        
+        Raises:
+            IntegrationError: If unable to log in to Garmin Connect.
+        """
         activity_type = kwargs.get("activity_type")
         setting = kwargs.get("setting")
 
         """Check for login."""
         if not await self.coordinator.async_login():
-            raise IntegrationError("Failed to login to Garmin Connect, unable to update")
+            raise IntegrationError(
+                "Failed to login to Garmin Connect, unable to update")
 
         """Update Garmin Gear settings."""
         activity_type_id = next(

custom_components/garmin_connect/strings.json

@@ -1,22 +1,37 @@
 {
   "config": {
-    "abort": {
-      "already_configured": "[%key:common::config_flow::abort::already_configured_account%]"
+    "step": {
+      "user": {
+        "title": "Enter your Garmin Connect login information",
+        "data": {
+          "username": "[%key:common::config_flow::data::username%]",
+          "password": "[%key:common::config_flow::data::password%]"
+        }
+      },
+      "mfa": {
+        "title": "Enter your Garmin Connect MFA code",
+        "data": {
+          "mfa_code": "MFA code (6-digits)"
+        }
+      },
+      "reauth_confirm": {
+        "title": "[%key:component::garmin_connect::config::step::user::title%]",
+        "data": {
+          "username": "[%key:common::config_flow::data::username%]",
+          "password": "[%key:common::config_flow::data::password%]"
+        }
+      }
     },
     "error": {
       "cannot_connect": "[%key:common::config_flow::error::cannot_connect%]",
       "invalid_auth": "[%key:common::config_flow::error::invalid_auth%]",
-      "too_many_requests": "Too many requests, retry later.",
-      "unknown": "[%key:common::config_flow::error::unknown%]"
+      "too_many_requests": "Too many requests, retry later",
+      "unknown": "[%key:common::config_flow::error::unknown%]",
+      "invalid_mfa_code": "Invalid MFA code"
     },
-    "step": {
-      "user": {
-        "data": {
-          "password": "[%key:common::config_flow::data::password%]",
-          "username": "[%key:common::config_flow::data::username%]"
-        },
-        "description": "Enter your credentials."
-      }
+    "abort": {
+      "already_configured": "[%key:common::config_flow::abort::already_configured_account%]",
+      "reauth_successful": "[%key:common::config_flow::abort::reauth_successful%]"
     }
   }
 }

custom_components/garmin_connect/translations/ca.json

@@ -1,23 +0,0 @@
-{
-    "config": {
-        "abort": {
-            "already_configured": "[%key::common::config_flow::abort::already_configured_account%]"
-        },
-        "error": {
-            "cannot_connect": "Ha fallat la connexi\u00f3",
-            "invalid_auth": "Autenticaci\u00f3 inv\u00e0lida",
-            "too_many_requests": "Massa sol\u00b7licituds, torna-ho a intentar m\u00e9s tard.",
-            "unknown": "Error inesperat"
-        },
-        "step": {
-            "user": {
-                "data": {
-                    "password": "Contrasenya",
-                    "username": "Nom d'usuari"
-                },
-                "description": "Introdueix les teves credencials.",
-                "title": "Garmin Connect"
-            }
-        }
-    }
-}

custom_components/garmin_connect/translations/cs.json

@@ -1,23 +0,0 @@
-{
-    "config": {
-        "abort": {
-            "already_configured": "\u00da\u010det je ji\u017e nastaven"
-        },
-        "error": {
-            "cannot_connect": "Nepoda\u0159ilo se p\u0159ipojit",
-            "invalid_auth": "Neplatn\u00e9 ov\u011b\u0159en\u00ed",
-            "too_many_requests": "P\u0159\u00edli\u0161 mnoho po\u017eadavk\u016f, opakujte to pozd\u011bji.",
-            "unknown": "Neo\u010dek\u00e1van\u00e1 chyba"
-        },
-        "step": {
-            "user": {
-                "data": {
-                    "password": "Heslo",
-                    "username": "U\u017eivatelsk\u00e9 jm\u00e9no"
-                },
-                "description": "Zadejte sv\u00e9 p\u0159ihla\u0161ovac\u00ed \u00fadaje.",
-                "title": "Garmin Connect"
-            }
-        }
-    }
-}

custom_components/garmin_connect/translations/da.json

@@ -1,23 +0,0 @@
-{
-    "config": {
-        "abort": {
-            "already_configured": "Denne konto er allerede konfigureret."
-        },
-        "error": {
-            "cannot_connect": "Kunne ikke oprette forbindelse - pr\u00f8v igen.",
-            "invalid_auth": "Ugyldig godkendelse.",
-            "too_many_requests": "For mange anmodninger - pr\u00f8v igen senere.",
-            "unknown": "Uventet fejl."
-        },
-        "step": {
-            "user": {
-                "data": {
-                    "password": "Adgangskode",
-                    "username": "Brugernavn"
-                },
-                "description": "Indtast dine legitimationsoplysninger.",
-                "title": "Garmin Connect"
-            }
-        }
-    }
-}

custom_components/garmin_connect/translations/de.json

@@ -1,23 +0,0 @@
-{
-    "config": {
-        "abort": {
-            "already_configured": "Dieses Konto ist bereits konfiguriert."
-        },
-        "error": {
-            "cannot_connect": "Verbindung fehlgeschlagen",
-            "invalid_auth": "Ung\u00fcltige Authentifizierung",
-            "too_many_requests": "Zu viele Anfragen, versuche es sp\u00e4ter erneut.",
-            "unknown": "Unerwarteter Fehler"
-        },
-        "step": {
-            "user": {
-                "data": {
-                    "password": "Passwort",
-                    "username": "Benutzername"
-                },
-                "description": "Geben Sie Ihre Zugangsdaten ein.",
-                "title": "Garmin Connect"
-            }
-        }
-    }
-}

custom_components/garmin_connect/translations/en.json

@@ -1,22 +1,38 @@
 {
     "config": {
-        "abort": {
-            "already_configured": "Account is already configured"
-        },
-        "error": {
-            "cannot_connect": "Failed to connect",
-            "invalid_auth": "Invalid authentication",
-            "too_many_requests": "Too many requests, retry later.",
-            "unknown": "Unexpected error"
-        },
         "step": {
             "user": {
+                "title": "Enter your Garmin Connect credentials",
                 "data": {
                     "password": "Password",
                     "username": "Username"
                 },
                 "description": "Enter your credentials."
+            },
+            "mfa": {
+                "title": "Enter your Garmin Connect MFA code",
+                "data": {
+                    "mfa_code": "MFA code (6-digits)"
+                }
+            },
+            "reauth_confirm": {
+                "title": "Enter your Garmin Connect credentials",
+                "data": {
+                    "password": "Password",
+                    "username": "Username"
+                }
             }
+        },
+        "abort": {
+            "already_configured": "Account is already configured",
+            "reauth_successful": "Reauthentication successful"
+        },
+        "error": {
+            "cannot_connect": "Failed to connect",
+            "invalid_auth": "Invalid authentication",
+            "too_many_requests": "Too many requests, retry later",
+            "unknown": "Unexpected error",
+            "invalid_mfa_code": "Invalid MFA code"
         }
     }
-}
+}

custom_components/garmin_connect/translations/es-419.json

@@ -1,23 +0,0 @@
-{
-    "config": {
-        "abort": {
-            "already_configured": "Esta cuenta ya est\u00e1 configurada."
-        },
-        "error": {
-            "cannot_connect": "No se pudo conectar, intente nuevamente.",
-            "invalid_auth": "Autenticaci\u00f3n inv\u00e1lida",
-            "too_many_requests": "Demasiadas solicitudes, vuelva a intentarlo m\u00e1s tarde.",
-            "unknown": "Error inesperado."
-        },
-        "step": {
-            "user": {
-                "data": {
-                    "password": "Contrase\u00f1a",
-                    "username": "Nombre de usuario"
-                },
-                "description": "Ingrese sus credenciales.",
-                "title": "Garmin Connect"
-            }
-        }
-    }
-}

custom_components/garmin_connect/translations/es.json

@@ -1,23 +0,0 @@
-{
-    "config": {
-        "abort": {
-            "already_configured": "La cuenta ya ha sido configurada"
-        },
-        "error": {
-            "cannot_connect": "No se pudo conectar",
-            "invalid_auth": "Autenticaci\u00f3n no v\u00e1lida",
-            "too_many_requests": "Demasiadas solicitudes, vuelva a intentarlo m\u00e1s tarde.",
-            "unknown": "Error inesperado"
-        },
-        "step": {
-            "user": {
-                "data": {
-                    "password": "Contrase\u00f1a",
-                    "username": "Usuario"
-                },
-                "description": "Introduzca sus credenciales.",
-                "title": "Garmin Connect"
-            }
-        }
-    }
-}

custom_components/garmin_connect/translations/et.json

@@ -1,23 +0,0 @@
-{
-    "config": {
-        "abort": {
-            "already_configured": "Konto on juba seadistatud"
-        },
-        "error": {
-            "cannot_connect": "\u00dchendamine nurjus",
-            "invalid_auth": "Tuvastamine nurjus",
-            "too_many_requests": "Liiga palju taotlusi, proovi hiljem uuesti.",
-            "unknown": "Tundmatu viga"
-        },
-        "step": {
-            "user": {
-                "data": {
-                    "password": "Salas\u00f5na",
-                    "username": "Kasutajanimi"
-                },
-                "description": "Sisesta oma mandaat.",
-                "title": ""
-            }
-        }
-    }
-}

custom_components/garmin_connect/translations/fr.json

@@ -1,23 +0,0 @@
-{
-    "config": {
-        "abort": {
-            "already_configured": "Ce compte est d\u00e9j\u00e0 configur\u00e9."
-        },
-        "error": {
-            "cannot_connect": "Impossible de se connecter, veuillez r\u00e9essayer.",
-            "invalid_auth": "Authentification non valide.",
-            "too_many_requests": "Trop de demandes, r\u00e9essayez plus tard.",
-            "unknown": "Erreur inattendue."
-        },
-        "step": {
-            "user": {
-                "data": {
-                    "password": "Mot de passe",
-                    "username": "Nom d'utilisateur"
-                },
-                "description": "Entrez vos informations d'identification.",
-                "title": "Garmin Connect"
-            }
-        }
-    }
-}

custom_components/garmin_connect/translations/he.json

@@ -1,21 +0,0 @@
-{
-    "config": {
-        "abort": {
-            "already_configured": "\u05ea\u05e6\u05d5\u05e8\u05ea \u05d4\u05d7\u05e9\u05d1\u05d5\u05df \u05db\u05d1\u05e8 \u05e0\u05e7\u05d1\u05e2\u05d4"
-        },
-        "error": {
-            "cannot_connect": "\u05d4\u05d4\u05ea\u05d7\u05d1\u05e8\u05d5\u05ea \u05e0\u05db\u05e9\u05dc\u05d4",
-            "invalid_auth": "\u05d0\u05d9\u05de\u05d5\u05ea \u05dc\u05d0 \u05d7\u05d5\u05e7\u05d9",
-            "too_many_requests": "\u05d1\u05e7\u05e9\u05d5\u05ea \u05e8\u05d1\u05d5\u05ea \u05de\u05d3\u05d9, \u05e0\u05d0 \u05dc\u05e0\u05e1\u05d5\u05ea \u05e9\u05e0\u05d9\u05ea \u05de\u05d0\u05d5\u05d7\u05e8 \u05d9\u05d5\u05ea\u05e8.",
-            "unknown": "\u05e9\u05d2\u05d9\u05d0\u05d4 \u05d1\u05dc\u05ea\u05d9 \u05e6\u05e4\u05d5\u05d9\u05d4"
-        },
-        "step": {
-            "user": {
-                "data": {
-                    "password": "\u05e1\u05d9\u05e1\u05de\u05d4",
-                    "username": "\u05e9\u05dd \u05de\u05e9\u05ea\u05de\u05e9"
-                }
-            }
-        }
-    }
-}

custom_components/garmin_connect/translations/hu.json

@@ -1,23 +0,0 @@
-{
-    "config": {
-        "abort": {
-            "already_configured": "A fi\u00f3k m\u00e1r konfigur\u00e1lva van"
-        },
-        "error": {
-            "cannot_connect": "Sikertelen csatlakoz\u00e1s",
-            "invalid_auth": "\u00c9rv\u00e9nytelen hiteles\u00edt\u00e9s",
-            "too_many_requests": "T\u00fal sok k\u00e9r\u00e9s, pr\u00f3b\u00e1lkozzon k\u00e9s\u0151bb \u00fajra.",
-            "unknown": "V\u00e1ratlan hiba t\u00f6rt\u00e9nt"
-        },
-        "step": {
-            "user": {
-                "data": {
-                    "password": "Jelsz\u00f3",
-                    "username": "Felhaszn\u00e1l\u00f3n\u00e9v"
-                },
-                "description": "Adja meg a hiteles\u00edt\u0151 adatait.",
-                "title": "Garmin Csatlakoz\u00e1s"
-            }
-        }
-    }
-}

custom_components/garmin_connect/translations/id.json

@@ -1,23 +0,0 @@
-{
-    "config": {
-        "abort": {
-            "already_configured": "Akun sudah dikonfigurasi"
-        },
-        "error": {
-            "cannot_connect": "Gagal terhubung",
-            "invalid_auth": "Autentikasi tidak valid",
-            "too_many_requests": "Terlalu banyak permintaan, coba lagi nanti.",
-            "unknown": "Kesalahan yang tidak diharapkan"
-        },
-        "step": {
-            "user": {
-                "data": {
-                    "password": "Kata Sandi",
-                    "username": "Nama Pengguna"
-                },
-                "description": "Masukkan kredensial Anda.",
-                "title": "Garmin Connect"
-            }
-        }
-    }
-}

custom_components/garmin_connect/translations/it.json

@@ -1,23 +0,0 @@
-{
-    "config": {
-        "abort": {
-            "already_configured": "L'account \u00e8 gi\u00e0 configurato"
-        },
-        "error": {
-            "cannot_connect": "Impossibile connettersi",
-            "invalid_auth": "Autenticazione non valida",
-            "too_many_requests": "Troppe richieste, riprovare pi\u00f9 tardi.",
-            "unknown": "Errore imprevisto"
-        },
-        "step": {
-            "user": {
-                "data": {
-                    "password": "Password",
-                    "username": "Nome utente"
-                },
-                "description": "Inserisci le tue credenziali",
-                "title": "Garmin Connect"
-            }
-        }
-    }
-}

custom_components/garmin_connect/translations/ko.json

@@ -1,23 +0,0 @@
-{
-    "config": {
-        "abort": {
-            "already_configured": "\uacc4\uc815\uc774 \uc774\ubbf8 \uad6c\uc131\ub418\uc5c8\uc2b5\ub2c8\ub2e4"
-        },
-        "error": {
-            "cannot_connect": "\uc5f0\uacb0\ud558\uc9c0 \ubabb\ud588\uc2b5\ub2c8\ub2e4",
-            "invalid_auth": "\uc778\uc99d\uc774 \uc798\ubabb\ub418\uc5c8\uc2b5\ub2c8\ub2e4",
-            "too_many_requests": "\uc694\uccad\uc774 \ub108\ubb34 \ub9ce\uc2b5\ub2c8\ub2e4. \ub098\uc911\uc5d0 \ub2e4\uc2dc \uc2dc\ub3c4\ud574\uc8fc\uc138\uc694.",
-            "unknown": "\uc608\uc0c1\uce58 \ubabb\ud55c \uc624\ub958\uac00 \ubc1c\uc0dd\ud588\uc2b5\ub2c8\ub2e4"
-        },
-        "step": {
-            "user": {
-                "data": {
-                    "password": "\ube44\ubc00\ubc88\ud638",
-                    "username": "\uc0ac\uc6a9\uc790 \uc774\ub984"
-                },
-                "description": "\uc790\uaca9 \uc99d\uba85\uc744 \uc785\ub825\ud574\uc8fc\uc138\uc694",
-                "title": "Garmin Connect"
-            }
-        }
-    }
-}

custom_components/garmin_connect/translations/lb.json

@@ -1,23 +0,0 @@
-{
-    "config": {
-        "abort": {
-            "already_configured": "Kont ass scho konfigur\u00e9iert"
-        },
-        "error": {
-            "cannot_connect": "Feeler beim verbannen",
-            "invalid_auth": "Ong\u00eblteg Authentifikatioun",
-            "too_many_requests": "Ze vill Ufroen, prob\u00e9iert sp\u00e9ider nach emol.",
-            "unknown": "Onerwaarte Feeler"
-        },
-        "step": {
-            "user": {
-                "data": {
-                    "password": "Passwuert",
-                    "username": "Benotzernumm"
-                },
-                "description": "F\u00ebllt \u00e4r Umeldungs Informatiounen aus.",
-                "title": "Garmin Connect"
-            }
-        }
-    }
-}

custom_components/garmin_connect/translations/lv.json

@@ -1,12 +0,0 @@
-{
-    "config": {
-        "step": {
-            "user": {
-                "data": {
-                    "password": "Parole",
-                    "username": "Lietot\u0101jv\u0101rds"
-                }
-            }
-        }
-    }
-}

custom_components/garmin_connect/translations/nl.json

@@ -1,23 +0,0 @@
-{
-    "config": {
-        "abort": {
-            "already_configured": "Account is al geconfigureerd"
-        },
-        "error": {
-            "cannot_connect": "Kan geen verbinding maken",
-            "invalid_auth": "Ongeldige authenticatie",
-            "too_many_requests": "Te veel aanvragen, probeer het later opnieuw.",
-            "unknown": "Onverwachte fout"
-        },
-        "step": {
-            "user": {
-                "data": {
-                    "password": "Wachtwoord",
-                    "username": "Gebruikersnaam"
-                },
-                "description": "Voer uw gegevens in",
-                "title": "Garmin Connect"
-            }
-        }
-    }
-}

custom_components/garmin_connect/translations/no.json

@@ -1,23 +0,0 @@
-{
-    "config": {
-        "abort": {
-            "already_configured": "Kontoen er allerede konfigurert"
-        },
-        "error": {
-            "cannot_connect": "Tilkobling mislyktes",
-            "invalid_auth": "Ugyldig godkjenning",
-            "too_many_requests": "For mange foresp\u00f8rsler, pr\u00f8v p\u00e5 nytt senere.",
-            "unknown": "Uventet feil"
-        },
-        "step": {
-            "user": {
-                "data": {
-                    "password": "Passord",
-                    "username": "Brukernavn"
-                },
-                "description": "Fyll inn legitimasjonen din.",
-                "title": ""
-            }
-        }
-    }
-}

custom_components/garmin_connect/translations/pl.json

@@ -1,23 +0,0 @@
-{
-    "config": {
-        "abort": {
-            "already_configured": "Konto jest ju\u017c skonfigurowane"
-        },
-        "error": {
-            "cannot_connect": "Nie mo\u017cna nawi\u0105za\u0107 po\u0142\u0105czenia",
-            "invalid_auth": "Niepoprawne uwierzytelnienie",
-            "too_many_requests": "Zbyt wiele \u017c\u0105da\u0144, spr\u00f3buj ponownie p\u00f3\u017aniej",
-            "unknown": "Nieoczekiwany b\u0142\u0105d"
-        },
-        "step": {
-            "user": {
-                "data": {
-                    "password": "Has\u0142o",
-                    "username": "Nazwa u\u017cytkownika"
-                },
-                "description": "Wprowad\u017a dane uwierzytelniaj\u0105ce",
-                "title": "Garmin Connect"
-            }
-        }
-    }
-}

custom_components/garmin_connect/translations/pt-BR.json

@@ -1,10 +0,0 @@
-{
-    "config": {
-        "step": {
-            "user": {
-                "description": "Digite suas credenciais.",
-                "title": "Garmin Connect"
-            }
-        }
-    }
-}

custom_components/garmin_connect/translations/pt.json

@@ -1,22 +0,0 @@
-{
-    "config": {
-        "abort": {
-            "already_configured": "Conta j\u00e1 configurada"
-        },
-        "error": {
-            "cannot_connect": "Falha na liga\u00e7\u00e3o",
-            "invalid_auth": "Autentica\u00e7\u00e3o inv\u00e1lida",
-            "unknown": "Erro desconhecido"
-        },
-        "step": {
-            "user": {
-                "data": {
-                    "password": "Palavra-passe",
-                    "username": "Nome de Utilizador"
-                },
-                "description": "Introduza as suas credenciais.",
-                "title": "Garmin Connect"
-            }
-        }
-    }
-}

custom_components/garmin_connect/translations/ru.json

@@ -1,23 +0,0 @@
-{
-    "config": {
-        "abort": {
-            "already_configured": "\u042d\u0442\u0430 \u0443\u0447\u0451\u0442\u043d\u0430\u044f \u0437\u0430\u043f\u0438\u0441\u044c \u0443\u0436\u0435 \u0434\u043e\u0431\u0430\u0432\u043b\u0435\u043d\u0430 \u0432 Home Assistant."
-        },
-        "error": {
-            "cannot_connect": "\u041d\u0435 \u0443\u0434\u0430\u043b\u043e\u0441\u044c \u043f\u043e\u0434\u043a\u043b\u044e\u0447\u0438\u0442\u044c\u0441\u044f.",
-            "invalid_auth": "\u041e\u0448\u0438\u0431\u043a\u0430 \u0430\u0443\u0442\u0435\u043d\u0442\u0438\u0444\u0438\u043a\u0430\u0446\u0438\u0438.",
-            "too_many_requests": "\u0421\u043b\u0438\u0448\u043a\u043e\u043c \u043c\u043d\u043e\u0433\u043e \u0437\u0430\u043f\u0440\u043e\u0441\u043e\u0432, \u043f\u043e\u0432\u0442\u043e\u0440\u0438\u0442\u0435 \u043f\u043e\u043f\u044b\u0442\u043a\u0443 \u043f\u043e\u0437\u0436\u0435.",
-            "unknown": "\u041d\u0435\u043f\u0440\u0435\u0434\u0432\u0438\u0434\u0435\u043d\u043d\u0430\u044f \u043e\u0448\u0438\u0431\u043a\u0430."
-        },
-        "step": {
-            "user": {
-                "data": {
-                    "password": "\u041f\u0430\u0440\u043e\u043b\u044c",
-                    "username": "\u0418\u043c\u044f \u043f\u043e\u043b\u044c\u0437\u043e\u0432\u0430\u0442\u0435\u043b\u044f"
-                },
-                "description": "\u0412\u0432\u0435\u0434\u0438\u0442\u0435 \u0412\u0430\u0448\u0438 \u0443\u0447\u0451\u0442\u043d\u044b\u0435 \u0434\u0430\u043d\u043d\u044b\u0435.",
-                "title": "Garmin Connect"
-            }
-        }
-    }
-}

custom_components/garmin_connect/translations/sk.json

@@ -1,23 +0,0 @@
-{
-    "config": {
-        "abort": {
-            "already_configured": "Účet je už nakonfigurovaný"
-        },
-        "error": {
-            "cannot_connect": "Nepodarilo sa pripojiť",
-            "invalid_auth": "Neplatné overenie",
-            "too_many_requests": "Príliš veľa žiadostí, skúste to neskôr.",
-            "unknown": "Neočakávaná chyba"
-        },
-        "step": {
-            "user": {
-                "data": {
-                    "password": "Heslo",
-                    "username": "Užívateľské meno"
-                },
-                "description": "Zadajte svoje poverovacie údaje.",
-                "title": "Garmin Connect"
-            }
-        }
-    }
-}

custom_components/garmin_connect/translations/sl.json

@@ -1,23 +0,0 @@
-{
-    "config": {
-        "abort": {
-            "already_configured": "Ta ra\u010dun je \u017ee konfiguriran."
-        },
-        "error": {
-            "cannot_connect": "Povezava ni uspela, poskusite znova.",
-            "invalid_auth": "Neveljavna avtentikacija.",
-            "too_many_requests": "Preve\u010d zahtev, poskusite pozneje.",
-            "unknown": "Nepri\u010dakovana napaka."
-        },
-        "step": {
-            "user": {
-                "data": {
-                    "password": "Geslo",
-                    "username": "Uporabni\u0161ko ime"
-                },
-                "description": "Vnesite svoje poverilnice.",
-                "title": "Garmin Connect"
-            }
-        }
-    }
-}

custom_components/garmin_connect/translations/sv.json

@@ -1,23 +0,0 @@
-{
-    "config": {
-        "abort": {
-            "already_configured": "Det h\u00e4r kontot har redan konfigurerats."
-        },
-        "error": {
-            "cannot_connect": "Kunde inte ansluta, var god f\u00f6rs\u00f6k igen.",
-            "invalid_auth": "Ogiltig autentisering.",
-            "too_many_requests": "F\u00f6r m\u00e5nga f\u00f6rfr\u00e5gningar, f\u00f6rs\u00f6k igen senare.",
-            "unknown": "Ov\u00e4ntat fel."
-        },
-        "step": {
-            "user": {
-                "data": {
-                    "password": "L\u00f6senord",
-                    "username": "Anv\u00e4ndarnamn"
-                },
-                "description": "Ange dina anv\u00e4ndaruppgifter.",
-                "title": "Garmin Connect"
-            }
-        }
-    }
-}

custom_components/garmin_connect/translations/tr.json

@@ -1,20 +0,0 @@
-{
-    "config": {
-        "abort": {
-            "already_configured": "Hesap zaten yap\u0131land\u0131r\u0131lm\u0131\u015f"
-        },
-        "error": {
-            "cannot_connect": "Ba\u011flanma hatas\u0131",
-            "invalid_auth": "Ge\u00e7ersiz kimlik do\u011frulama",
-            "unknown": "Beklenmeyen hata"
-        },
-        "step": {
-            "user": {
-                "data": {
-                    "password": "Parola",
-                    "username": "Kullan\u0131c\u0131 Ad\u0131"
-                }
-            }
-        }
-    }
-}

custom_components/garmin_connect/translations/uk.json

@@ -1,23 +0,0 @@
-{
-    "config": {
-        "abort": {
-            "already_configured": "\u0426\u0435\u0439 \u043e\u0431\u043b\u0456\u043a\u043e\u0432\u0438\u0439 \u0437\u0430\u043f\u0438\u0441 \u0432\u0436\u0435 \u0434\u043e\u0434\u0430\u043d\u043e \u0432 Home Assistant."
-        },
-        "error": {
-            "cannot_connect": "\u041d\u0435 \u0432\u0434\u0430\u043b\u043e\u0441\u044f \u043f\u0456\u0434'\u0454\u0434\u043d\u0430\u0442\u0438\u0441\u044f",
-            "invalid_auth": "\u041d\u0435\u0432\u0456\u0440\u043d\u0430 \u0430\u0443\u0442\u0435\u043d\u0442\u0438\u0444\u0456\u043a\u0430\u0446\u0456\u044f.",
-            "too_many_requests": "\u0417\u0430\u043d\u0430\u0434\u0442\u043e \u0431\u0430\u0433\u0430\u0442\u043e \u0437\u0430\u043f\u0438\u0442\u0456\u0432, \u0441\u043f\u0440\u043e\u0431\u0443\u0439\u0442\u0435 \u0449\u0435 \u0440\u0430\u0437 \u043f\u0456\u0437\u043d\u0456\u0448\u0435.",
-            "unknown": "\u041d\u0435\u043e\u0447\u0456\u043a\u0443\u0432\u0430\u043d\u0430 \u043f\u043e\u043c\u0438\u043b\u043a\u0430"
-        },
-        "step": {
-            "user": {
-                "data": {
-                    "password": "\u041f\u0430\u0440\u043e\u043b\u044c",
-                    "username": "\u0406\u043c'\u044f \u043a\u043e\u0440\u0438\u0441\u0442\u0443\u0432\u0430\u0447\u0430"
-                },
-                "description": "\u0412\u0432\u0435\u0434\u0456\u0442\u044c \u0412\u0430\u0448\u0456 \u043e\u0431\u043b\u0456\u043a\u043e\u0432\u0456 \u0434\u0430\u043d\u0456.",
-                "title": "Garmin Connect"
-            }
-        }
-    }
-}

custom_components/garmin_connect/translations/zh-Hans.json

@@ -1,11 +0,0 @@
-{
-    "config": {
-        "step": {
-            "user": {
-                "data": {
-                    "username": "\u7528\u6237\u540d"
-                }
-            }
-        }
-    }
-}

custom_components/garmin_connect/translations/zh-Hant.json

@@ -1,23 +0,0 @@
-{
-    "config": {
-        "abort": {
-            "already_configured": "\u5e33\u865f\u5df2\u7d93\u8a2d\u5b9a\u5b8c\u6210"
-        },
-        "error": {
-            "cannot_connect": "\u9023\u7dda\u5931\u6557",
-            "invalid_auth": "\u9a57\u8b49\u78bc\u7121\u6548",
-            "too_many_requests": "\u8acb\u6c42\u6b21\u6578\u904e\u591a\uff0c\u8acb\u7a0d\u5f8c\u91cd\u8a66\u3002",
-            "unknown": "\u672a\u9810\u671f\u932f\u8aa4"
-        },
-        "step": {
-            "user": {
-                "data": {
-                    "password": "\u5bc6\u78bc",
-                    "username": "\u4f7f\u7528\u8005\u540d\u7a31"
-                },
-                "description": "\u8f38\u5165\u6191\u8b49\u3002",
-                "title": "Garmin Connect"
-            }
-        }
-    }
-}