# This file was auto-generated by Fern from our API Definition.

import typing
import urllib.parse
from json.decoder import JSONDecodeError

from ...core.api_error import ApiError
from ...core.client_wrapper import AsyncClientWrapper, SyncClientWrapper
from ...core.remove_none_from_dict import remove_none_from_dict
from ...errors.unprocessable_entity_error import UnprocessableEntityError
from ...types.client_facing_blood_oxygen_timeseries import ClientFacingBloodOxygenTimeseries
from ...types.client_facing_blood_pressure_timeseries import ClientFacingBloodPressureTimeseries
from ...types.client_facing_caffeine_timeseries import ClientFacingCaffeineTimeseries
from ...types.client_facing_calories_active_timeseries import ClientFacingCaloriesActiveTimeseries
from ...types.client_facing_calories_basal_timeseries import ClientFacingCaloriesBasalTimeseries
from ...types.client_facing_cholesterol_timeseries import ClientFacingCholesterolTimeseries
from ...types.client_facing_distance_timeseries import ClientFacingDistanceTimeseries
from ...types.client_facing_floors_climbed_timeseries import ClientFacingFloorsClimbedTimeseries
from ...types.client_facing_glucose_timeseries import ClientFacingGlucoseTimeseries
from ...types.client_facing_heart_rate_timeseries import ClientFacingHeartRateTimeseries
from ...types.client_facing_hrv_timeseries import ClientFacingHrvTimeseries
from ...types.client_facing_hypnogram_timeseries import ClientFacingHypnogramTimeseries
from ...types.client_facing_ige_timeseries import ClientFacingIgeTimeseries
from ...types.client_facing_igg_timeseries import ClientFacingIggTimeseries
from ...types.client_facing_mindfulness_minutes_timeseries import ClientFacingMindfulnessMinutesTimeseries
from ...types.client_facing_respiratory_rate_timeseries import ClientFacingRespiratoryRateTimeseries
from ...types.client_facing_steps_timeseries import ClientFacingStepsTimeseries
from ...types.client_facing_water_timeseries import ClientFacingWaterTimeseries
from ...types.http_validation_error import HttpValidationError

try:
    import pydantic.v1 as pydantic  # type: ignore
except ImportError:
    import pydantic  # type: ignore


class VitalsClient:
    def __init__(self, *, client_wrapper: SyncClientWrapper):
        self._client_wrapper = client_wrapper

    def mindfulness_minutes(
        self,
        user_id: str,
        *,
        provider: typing.Optional[str] = None,
        start_date: str,
        end_date: typing.Optional[str] = None,
    ) -> typing.List[ClientFacingMindfulnessMinutesTimeseries]:
        """
        Get timeseries data for user

        Parameters:
            - user_id: str.

            - provider: typing.Optional[str]. Provider oura/strava etc

            - start_date: str. Date from in YYYY-MM-DD or ISO formatted date time. If a date is provided without a time, the time will be set to 00:00:00

            - end_date: typing.Optional[str]. Date to YYYY-MM-DD or ISO formatted date time. If a date is provided without a time, the time will be set to 23:59:59
        ---
        from vital.client import Vital

        client = Vital(
            api_key="YOUR_API_KEY",
        )
        client.mindfulness_minutes(
            user_id="user-id",
            start_date="start-date",
        )
        """
        _response = self._client_wrapper.httpx_client.request(
            "GET",
            urllib.parse.urljoin(
                f"{self._client_wrapper.get_base_url()}/", f"v2/timeseries/{user_id}/mindfulness_minutes"
            ),
            params=remove_none_from_dict({"provider": provider, "start_date": start_date, "end_date": end_date}),
            headers=self._client_wrapper.get_headers(),
            timeout=60,
        )
        if 200 <= _response.status_code < 300:
            return pydantic.parse_obj_as(typing.List[ClientFacingMindfulnessMinutesTimeseries], _response.json())  # type: ignore
        if _response.status_code == 422:
            raise UnprocessableEntityError(pydantic.parse_obj_as(HttpValidationError, _response.json()))  # type: ignore
        try:
            _response_json = _response.json()
        except JSONDecodeError:
            raise ApiError(status_code=_response.status_code, body=_response.text)
        raise ApiError(status_code=_response.status_code, body=_response_json)

    def caffeine(
        self,
        user_id: str,
        *,
        provider: typing.Optional[str] = None,
        start_date: str,
        end_date: typing.Optional[str] = None,
    ) -> typing.List[ClientFacingCaffeineTimeseries]:
        """
        Get timeseries data for user

        Parameters:
            - user_id: str.

            - provider: typing.Optional[str]. Provider oura/strava etc

            - start_date: str. Date from in YYYY-MM-DD or ISO formatted date time. If a date is provided without a time, the time will be set to 00:00:00

            - end_date: typing.Optional[str]. Date to YYYY-MM-DD or ISO formatted date time. If a date is provided without a time, the time will be set to 23:59:59
        ---
        from vital.client import Vital

        client = Vital(
            api_key="YOUR_API_KEY",
        )
        client.caffeine(
            user_id="user-id",
            start_date="start-date",
        )
        """
        _response = self._client_wrapper.httpx_client.request(
            "GET",
            urllib.parse.urljoin(f"{self._client_wrapper.get_base_url()}/", f"v2/timeseries/{user_id}/caffeine"),
            params=remove_none_from_dict({"provider": provider, "start_date": start_date, "end_date": end_date}),
            headers=self._client_wrapper.get_headers(),
            timeout=60,
        )
        if 200 <= _response.status_code < 300:
            return pydantic.parse_obj_as(typing.List[ClientFacingCaffeineTimeseries], _response.json())  # type: ignore
        if _response.status_code == 422:
            raise UnprocessableEntityError(pydantic.parse_obj_as(HttpValidationError, _response.json()))  # type: ignore
        try:
            _response_json = _response.json()
        except JSONDecodeError:
            raise ApiError(status_code=_response.status_code, body=_response.text)
        raise ApiError(status_code=_response.status_code, body=_response_json)

    def water(
        self,
        user_id: str,
        *,
        provider: typing.Optional[str] = None,
        start_date: str,
        end_date: typing.Optional[str] = None,
    ) -> typing.List[ClientFacingWaterTimeseries]:
        """
        Get timeseries data for user

        Parameters:
            - user_id: str.

            - provider: typing.Optional[str]. Provider oura/strava etc

            - start_date: str. Date from in YYYY-MM-DD or ISO formatted date time. If a date is provided without a time, the time will be set to 00:00:00

            - end_date: typing.Optional[str]. Date to YYYY-MM-DD or ISO formatted date time. If a date is provided without a time, the time will be set to 23:59:59
        ---
        from vital.client import Vital

        client = Vital(
            api_key="YOUR_API_KEY",
        )
        client.water(
            user_id="user-id",
            start_date="start-date",
        )
        """
        _response = self._client_wrapper.httpx_client.request(
            "GET",
            urllib.parse.urljoin(f"{self._client_wrapper.get_base_url()}/", f"v2/timeseries/{user_id}/water"),
            params=remove_none_from_dict({"provider": provider, "start_date": start_date, "end_date": end_date}),
            headers=self._client_wrapper.get_headers(),
            timeout=60,
        )
        if 200 <= _response.status_code < 300:
            return pydantic.parse_obj_as(typing.List[ClientFacingWaterTimeseries], _response.json())  # type: ignore
        if _response.status_code == 422:
            raise UnprocessableEntityError(pydantic.parse_obj_as(HttpValidationError, _response.json()))  # type: ignore
        try:
            _response_json = _response.json()
        except JSONDecodeError:
            raise ApiError(status_code=_response.status_code, body=_response.text)
        raise ApiError(status_code=_response.status_code, body=_response_json)

    def steps(
        self,
        user_id: str,
        *,
        provider: typing.Optional[str] = None,
        start_date: str,
        end_date: typing.Optional[str] = None,
    ) -> typing.List[ClientFacingStepsTimeseries]:
        """
        Get timeseries data for user

        Parameters:
            - user_id: str.

            - provider: typing.Optional[str]. Provider oura/strava etc

            - start_date: str. Date from in YYYY-MM-DD or ISO formatted date time. If a date is provided without a time, the time will be set to 00:00:00

            - end_date: typing.Optional[str]. Date to YYYY-MM-DD or ISO formatted date time. If a date is provided without a time, the time will be set to 23:59:59
        ---
        from vital.client import Vital

        client = Vital(
            api_key="YOUR_API_KEY",
        )
        client.steps(
            user_id="user-id",
            start_date="start-date",
        )
        """
        _response = self._client_wrapper.httpx_client.request(
            "GET",
            urllib.parse.urljoin(f"{self._client_wrapper.get_base_url()}/", f"v2/timeseries/{user_id}/steps"),
            params=remove_none_from_dict({"provider": provider, "start_date": start_date, "end_date": end_date}),
            headers=self._client_wrapper.get_headers(),
            timeout=60,
        )
        if 200 <= _response.status_code < 300:
            return pydantic.parse_obj_as(typing.List[ClientFacingStepsTimeseries], _response.json())  # type: ignore
        if _response.status_code == 422:
            raise UnprocessableEntityError(pydantic.parse_obj_as(HttpValidationError, _response.json()))  # type: ignore
        try:
            _response_json = _response.json()
        except JSONDecodeError:
            raise ApiError(status_code=_response.status_code, body=_response.text)
        raise ApiError(status_code=_response.status_code, body=_response_json)

    def floors_climbed(
        self,
        user_id: str,
        *,
        provider: typing.Optional[str] = None,
        start_date: str,
        end_date: typing.Optional[str] = None,
    ) -> typing.List[ClientFacingFloorsClimbedTimeseries]:
        """
        Get timeseries data for user

        Parameters:
            - user_id: str.

            - provider: typing.Optional[str]. Provider oura/strava etc

            - start_date: str. Date from in YYYY-MM-DD or ISO formatted date time. If a date is provided without a time, the time will be set to 00:00:00

            - end_date: typing.Optional[str]. Date to YYYY-MM-DD or ISO formatted date time. If a date is provided without a time, the time will be set to 23:59:59
        ---
        from vital.client import Vital

        client = Vital(
            api_key="YOUR_API_KEY",
        )
        client.floors_climbed(
            user_id="user-id",
            start_date="start-date",
        )
        """
        _response = self._client_wrapper.httpx_client.request(
            "GET",
            urllib.parse.urljoin(f"{self._client_wrapper.get_base_url()}/", f"v2/timeseries/{user_id}/floors_climbed"),
            params=remove_none_from_dict({"provider": provider, "start_date": start_date, "end_date": end_date}),
            headers=self._client_wrapper.get_headers(),
            timeout=60,
        )
        if 200 <= _response.status_code < 300:
            return pydantic.parse_obj_as(typing.List[ClientFacingFloorsClimbedTimeseries], _response.json())  # type: ignore
        if _response.status_code == 422:
            raise UnprocessableEntityError(pydantic.parse_obj_as(HttpValidationError, _response.json()))  # type: ignore
        try:
            _response_json = _response.json()
        except JSONDecodeError:
            raise ApiError(status_code=_response.status_code, body=_response.text)
        raise ApiError(status_code=_response.status_code, body=_response_json)

    def distance(
        self,
        user_id: str,
        *,
        provider: typing.Optional[str] = None,
        start_date: str,
        end_date: typing.Optional[str] = None,
    ) -> typing.List[ClientFacingDistanceTimeseries]:
        """
        Get timeseries data for user

        Parameters:
            - user_id: str.

            - provider: typing.Optional[str]. Provider oura/strava etc

            - start_date: str. Date from in YYYY-MM-DD or ISO formatted date time. If a date is provided without a time, the time will be set to 00:00:00

            - end_date: typing.Optional[str]. Date to YYYY-MM-DD or ISO formatted date time. If a date is provided without a time, the time will be set to 23:59:59
        ---
        from vital.client import Vital

        client = Vital(
            api_key="YOUR_API_KEY",
        )
        client.distance(
            user_id="user-id",
            start_date="start-date",
        )
        """
        _response = self._client_wrapper.httpx_client.request(
            "GET",
            urllib.parse.urljoin(f"{self._client_wrapper.get_base_url()}/", f"v2/timeseries/{user_id}/distance"),
            params=remove_none_from_dict({"provider": provider, "start_date": start_date, "end_date": end_date}),
            headers=self._client_wrapper.get_headers(),
            timeout=60,
        )
        if 200 <= _response.status_code < 300:
            return pydantic.parse_obj_as(typing.List[ClientFacingDistanceTimeseries], _response.json())  # type: ignore
        if _response.status_code == 422:
            raise UnprocessableEntityError(pydantic.parse_obj_as(HttpValidationError, _response.json()))  # type: ignore
        try:
            _response_json = _response.json()
        except JSONDecodeError:
            raise ApiError(status_code=_response.status_code, body=_response.text)
        raise ApiError(status_code=_response.status_code, body=_response_json)

    def calories_basal(
        self,
        user_id: str,
        *,
        provider: typing.Optional[str] = None,
        start_date: str,
        end_date: typing.Optional[str] = None,
    ) -> typing.List[ClientFacingCaloriesBasalTimeseries]:
        """
        Get timeseries data for user

        Parameters:
            - user_id: str.

            - provider: typing.Optional[str]. Provider oura/strava etc

            - start_date: str. Date from in YYYY-MM-DD or ISO formatted date time. If a date is provided without a time, the time will be set to 00:00:00

            - end_date: typing.Optional[str]. Date to YYYY-MM-DD or ISO formatted date time. If a date is provided without a time, the time will be set to 23:59:59
        ---
        from vital.client import Vital

        client = Vital(
            api_key="YOUR_API_KEY",
        )
        client.calories_basal(
            user_id="user-id",
            start_date="start-date",
        )
        """
        _response = self._client_wrapper.httpx_client.request(
            "GET",
            urllib.parse.urljoin(f"{self._client_wrapper.get_base_url()}/", f"v2/timeseries/{user_id}/calories_basal"),
            params=remove_none_from_dict({"provider": provider, "start_date": start_date, "end_date": end_date}),
            headers=self._client_wrapper.get_headers(),
            timeout=60,
        )
        if 200 <= _response.status_code < 300:
            return pydantic.parse_obj_as(typing.List[ClientFacingCaloriesBasalTimeseries], _response.json())  # type: ignore
        if _response.status_code == 422:
            raise UnprocessableEntityError(pydantic.parse_obj_as(HttpValidationError, _response.json()))  # type: ignore
        try:
            _response_json = _response.json()
        except JSONDecodeError:
            raise ApiError(status_code=_response.status_code, body=_response.text)
        raise ApiError(status_code=_response.status_code, body=_response_json)

    def calories_active(
        self,
        user_id: str,
        *,
        provider: typing.Optional[str] = None,
        start_date: str,
        end_date: typing.Optional[str] = None,
    ) -> typing.List[ClientFacingCaloriesActiveTimeseries]:
        """
        Get timeseries data for user

        Parameters:
            - user_id: str.

            - provider: typing.Optional[str]. Provider oura/strava etc

            - start_date: str. Date from in YYYY-MM-DD or ISO formatted date time. If a date is provided without a time, the time will be set to 00:00:00

            - end_date: typing.Optional[str]. Date to YYYY-MM-DD or ISO formatted date time. If a date is provided without a time, the time will be set to 23:59:59
        ---
        from vital.client import Vital

        client = Vital(
            api_key="YOUR_API_KEY",
        )
        client.calories_active(
            user_id="user-id",
            start_date="start-date",
        )
        """
        _response = self._client_wrapper.httpx_client.request(
            "GET",
            urllib.parse.urljoin(f"{self._client_wrapper.get_base_url()}/", f"v2/timeseries/{user_id}/calories_active"),
            params=remove_none_from_dict({"provider": provider, "start_date": start_date, "end_date": end_date}),
            headers=self._client_wrapper.get_headers(),
            timeout=60,
        )
        if 200 <= _response.status_code < 300:
            return pydantic.parse_obj_as(typing.List[ClientFacingCaloriesActiveTimeseries], _response.json())  # type: ignore
        if _response.status_code == 422:
            raise UnprocessableEntityError(pydantic.parse_obj_as(HttpValidationError, _response.json()))  # type: ignore
        try:
            _response_json = _response.json()
        except JSONDecodeError:
            raise ApiError(status_code=_response.status_code, body=_response.text)
        raise ApiError(status_code=_response.status_code, body=_response_json)

    def respiratory_rate(
        self,
        user_id: str,
        *,
        provider: typing.Optional[str] = None,
        start_date: str,
        end_date: typing.Optional[str] = None,
    ) -> typing.List[ClientFacingRespiratoryRateTimeseries]:
        """
        Get timeseries data for user

        Parameters:
            - user_id: str.

            - provider: typing.Optional[str]. Provider oura/strava etc

            - start_date: str. Date from in YYYY-MM-DD or ISO formatted date time. If a date is provided without a time, the time will be set to 00:00:00

            - end_date: typing.Optional[str]. Date to YYYY-MM-DD or ISO formatted date time. If a date is provided without a time, the time will be set to 23:59:59
        ---
        from vital.client import Vital

        client = Vital(
            api_key="YOUR_API_KEY",
        )
        client.respiratory_rate(
            user_id="user-id",
            start_date="start-date",
        )
        """
        _response = self._client_wrapper.httpx_client.request(
            "GET",
            urllib.parse.urljoin(
                f"{self._client_wrapper.get_base_url()}/", f"v2/timeseries/{user_id}/respiratory_rate"
            ),
            params=remove_none_from_dict({"provider": provider, "start_date": start_date, "end_date": end_date}),
            headers=self._client_wrapper.get_headers(),
            timeout=60,
        )
        if 200 <= _response.status_code < 300:
            return pydantic.parse_obj_as(typing.List[ClientFacingRespiratoryRateTimeseries], _response.json())  # type: ignore
        if _response.status_code == 422:
            raise UnprocessableEntityError(pydantic.parse_obj_as(HttpValidationError, _response.json()))  # type: ignore
        try:
            _response_json = _response.json()
        except JSONDecodeError:
            raise ApiError(status_code=_response.status_code, body=_response.text)
        raise ApiError(status_code=_response.status_code, body=_response_json)

    def ige(
        self,
        user_id: str,
        *,
        provider: typing.Optional[str] = None,
        start_date: str,
        end_date: typing.Optional[str] = None,
    ) -> typing.List[ClientFacingIgeTimeseries]:
        """
        Get timeseries data for user

        Parameters:
            - user_id: str.

            - provider: typing.Optional[str]. Provider oura/strava etc

            - start_date: str. Date from in YYYY-MM-DD or ISO formatted date time. If a date is provided without a time, the time will be set to 00:00:00

            - end_date: typing.Optional[str]. Date to YYYY-MM-DD or ISO formatted date time. If a date is provided without a time, the time will be set to 23:59:59
        ---
        from vital.client import Vital

        client = Vital(
            api_key="YOUR_API_KEY",
        )
        client.ige(
            user_id="user-id",
            start_date="start-date",
        )
        """
        _response = self._client_wrapper.httpx_client.request(
            "GET",
            urllib.parse.urljoin(f"{self._client_wrapper.get_base_url()}/", f"v2/timeseries/{user_id}/ige"),
            params=remove_none_from_dict({"provider": provider, "start_date": start_date, "end_date": end_date}),
            headers=self._client_wrapper.get_headers(),
            timeout=60,
        )
        if 200 <= _response.status_code < 300:
            return pydantic.parse_obj_as(typing.List[ClientFacingIgeTimeseries], _response.json())  # type: ignore
        if _response.status_code == 422:
            raise UnprocessableEntityError(pydantic.parse_obj_as(HttpValidationError, _response.json()))  # type: ignore
        try:
            _response_json = _response.json()
        except JSONDecodeError:
            raise ApiError(status_code=_response.status_code, body=_response.text)
        raise ApiError(status_code=_response.status_code, body=_response_json)

    def igg(
        self,
        user_id: str,
        *,
        provider: typing.Optional[str] = None,
        start_date: str,
        end_date: typing.Optional[str] = None,
    ) -> typing.List[ClientFacingIggTimeseries]:
        """
        Get timeseries data for user

        Parameters:
            - user_id: str.

            - provider: typing.Optional[str]. Provider oura/strava etc

            - start_date: str. Date from in YYYY-MM-DD or ISO formatted date time. If a date is provided without a time, the time will be set to 00:00:00

            - end_date: typing.Optional[str]. Date to YYYY-MM-DD or ISO formatted date time. If a date is provided without a time, the time will be set to 23:59:59
        ---
        from vital.client import Vital

        client = Vital(
            api_key="YOUR_API_KEY",
        )
        client.igg(
            user_id="user-id",
            start_date="start-date",
        )
        """
        _response = self._client_wrapper.httpx_client.request(
            "GET",
            urllib.parse.urljoin(f"{self._client_wrapper.get_base_url()}/", f"v2/timeseries/{user_id}/igg"),
            params=remove_none_from_dict({"provider": provider, "start_date": start_date, "end_date": end_date}),
            headers=self._client_wrapper.get_headers(),
            timeout=60,
        )
        if 200 <= _response.status_code < 300:
            return pydantic.parse_obj_as(typing.List[ClientFacingIggTimeseries], _response.json())  # type: ignore
        if _response.status_code == 422:
            raise UnprocessableEntityError(pydantic.parse_obj_as(HttpValidationError, _response.json()))  # type: ignore
        try:
            _response_json = _response.json()
        except JSONDecodeError:
            raise ApiError(status_code=_response.status_code, body=_response.text)
        raise ApiError(status_code=_response.status_code, body=_response_json)

    def hypnogram(
        self,
        user_id: str,
        *,
        provider: typing.Optional[str] = None,
        start_date: str,
        end_date: typing.Optional[str] = None,
    ) -> typing.List[ClientFacingHypnogramTimeseries]:
        """
        Get timeseries data for user

        Parameters:
            - user_id: str.

            - provider: typing.Optional[str]. Provider oura/strava etc

            - start_date: str. Date from in YYYY-MM-DD or ISO formatted date time. If a date is provided without a time, the time will be set to 00:00:00

            - end_date: typing.Optional[str]. Date to YYYY-MM-DD or ISO formatted date time. If a date is provided without a time, the time will be set to 23:59:59
        ---
        from vital.client import Vital

        client = Vital(
            api_key="YOUR_API_KEY",
        )
        client.hypnogram(
            user_id="user-id",
            start_date="start-date",
        )
        """
        _response = self._client_wrapper.httpx_client.request(
            "GET",
            urllib.parse.urljoin(f"{self._client_wrapper.get_base_url()}/", f"v2/timeseries/{user_id}/hypnogram"),
            params=remove_none_from_dict({"provider": provider, "start_date": start_date, "end_date": end_date}),
            headers=self._client_wrapper.get_headers(),
            timeout=60,
        )
        if 200 <= _response.status_code < 300:
            return pydantic.parse_obj_as(typing.List[ClientFacingHypnogramTimeseries], _response.json())  # type: ignore
        if _response.status_code == 422:
            raise UnprocessableEntityError(pydantic.parse_obj_as(HttpValidationError, _response.json()))  # type: ignore
        try:
            _response_json = _response.json()
        except JSONDecodeError:
            raise ApiError(status_code=_response.status_code, body=_response.text)
        raise ApiError(status_code=_response.status_code, body=_response_json)

    def hrv(
        self,
        user_id: str,
        *,
        provider: typing.Optional[str] = None,
        start_date: str,
        end_date: typing.Optional[str] = None,
    ) -> typing.List[ClientFacingHrvTimeseries]:
        """
        Get timeseries data for user

        Parameters:
            - user_id: str.

            - provider: typing.Optional[str]. Provider oura/strava etc

            - start_date: str. Date from in YYYY-MM-DD or ISO formatted date time. If a date is provided without a time, the time will be set to 00:00:00

            - end_date: typing.Optional[str]. Date to YYYY-MM-DD or ISO formatted date time. If a date is provided without a time, the time will be set to 23:59:59
        ---
        from vital.client import Vital

        client = Vital(
            api_key="YOUR_API_KEY",
        )
        client.hrv(
            user_id="user-id",
            start_date="start-date",
        )
        """
        _response = self._client_wrapper.httpx_client.request(
            "GET",
            urllib.parse.urljoin(f"{self._client_wrapper.get_base_url()}/", f"v2/timeseries/{user_id}/hrv"),
            params=remove_none_from_dict({"provider": provider, "start_date": start_date, "end_date": end_date}),
            headers=self._client_wrapper.get_headers(),
            timeout=60,
        )
        if 200 <= _response.status_code < 300:
            return pydantic.parse_obj_as(typing.List[ClientFacingHrvTimeseries], _response.json())  # type: ignore
        if _response.status_code == 422:
            raise UnprocessableEntityError(pydantic.parse_obj_as(HttpValidationError, _response.json()))  # type: ignore
        try:
            _response_json = _response.json()
        except JSONDecodeError:
            raise ApiError(status_code=_response.status_code, body=_response.text)
        raise ApiError(status_code=_response.status_code, body=_response_json)

    def heartrate(
        self,
        user_id: str,
        *,
        provider: typing.Optional[str] = None,
        start_date: str,
        end_date: typing.Optional[str] = None,
    ) -> typing.List[ClientFacingHeartRateTimeseries]:
        """
        Get timeseries data for user

        Parameters:
            - user_id: str.

            - provider: typing.Optional[str]. Provider oura/strava etc

            - start_date: str. Date from in YYYY-MM-DD or ISO formatted date time. If a date is provided without a time, the time will be set to 00:00:00

            - end_date: typing.Optional[str]. Date to YYYY-MM-DD or ISO formatted date time. If a date is provided without a time, the time will be set to 23:59:59
        ---
        from vital.client import Vital

        client = Vital(
            api_key="YOUR_API_KEY",
        )
        client.heartrate(
            user_id="user-id",
            start_date="start-date",
        )
        """
        _response = self._client_wrapper.httpx_client.request(
            "GET",
            urllib.parse.urljoin(f"{self._client_wrapper.get_base_url()}/", f"v2/timeseries/{user_id}/heartrate"),
            params=remove_none_from_dict({"provider": provider, "start_date": start_date, "end_date": end_date}),
            headers=self._client_wrapper.get_headers(),
            timeout=60,
        )
        if 200 <= _response.status_code < 300:
            return pydantic.parse_obj_as(typing.List[ClientFacingHeartRateTimeseries], _response.json())  # type: ignore
        if _response.status_code == 422:
            raise UnprocessableEntityError(pydantic.parse_obj_as(HttpValidationError, _response.json()))  # type: ignore
        try:
            _response_json = _response.json()
        except JSONDecodeError:
            raise ApiError(status_code=_response.status_code, body=_response.text)
        raise ApiError(status_code=_response.status_code, body=_response_json)

    def glucose(
        self,
        user_id: str,
        *,
        provider: typing.Optional[str] = None,
        start_date: str,
        end_date: typing.Optional[str] = None,
    ) -> typing.List[ClientFacingGlucoseTimeseries]:
        """
        Get timeseries data for user

        Parameters:
            - user_id: str.

            - provider: typing.Optional[str]. Provider oura/strava etc

            - start_date: str. Date from in YYYY-MM-DD or ISO formatted date time. If a date is provided without a time, the time will be set to 00:00:00

            - end_date: typing.Optional[str]. Date to YYYY-MM-DD or ISO formatted date time. If a date is provided without a time, the time will be set to 23:59:59
        ---
        from vital.client import Vital

        client = Vital(
            api_key="YOUR_API_KEY",
        )
        client.glucose(
            user_id="user-id",
            start_date="start-date",
        )
        """
        _response = self._client_wrapper.httpx_client.request(
            "GET",
            urllib.parse.urljoin(f"{self._client_wrapper.get_base_url()}/", f"v2/timeseries/{user_id}/glucose"),
            params=remove_none_from_dict({"provider": provider, "start_date": start_date, "end_date": end_date}),
            headers=self._client_wrapper.get_headers(),
            timeout=60,
        )
        if 200 <= _response.status_code < 300:
            return pydantic.parse_obj_as(typing.List[ClientFacingGlucoseTimeseries], _response.json())  # type: ignore
        if _response.status_code == 422:
            raise UnprocessableEntityError(pydantic.parse_obj_as(HttpValidationError, _response.json()))  # type: ignore
        try:
            _response_json = _response.json()
        except JSONDecodeError:
            raise ApiError(status_code=_response.status_code, body=_response.text)
        raise ApiError(status_code=_response.status_code, body=_response_json)

    def triglycerides(
        self,
        user_id: str,
        *,
        provider: typing.Optional[str] = None,
        start_date: str,
        end_date: typing.Optional[str] = None,
    ) -> typing.List[ClientFacingCholesterolTimeseries]:
        """
        Get timeseries data for user

        Parameters:
            - user_id: str.

            - provider: typing.Optional[str]. Provider oura/strava etc

            - start_date: str. Date from in YYYY-MM-DD or ISO formatted date time. If a date is provided without a time, the time will be set to 00:00:00

            - end_date: typing.Optional[str]. Date to YYYY-MM-DD or ISO formatted date time. If a date is provided without a time, the time will be set to 23:59:59
        ---
        from vital.client import Vital

        client = Vital(
            api_key="YOUR_API_KEY",
        )
        client.triglycerides(
            user_id="user-id",
            start_date="start-date",
        )
        """
        _response = self._client_wrapper.httpx_client.request(
            "GET",
            urllib.parse.urljoin(
                f"{self._client_wrapper.get_base_url()}/", f"v2/timeseries/{user_id}/cholesterol/triglycerides"
            ),
            params=remove_none_from_dict({"provider": provider, "start_date": start_date, "end_date": end_date}),
            headers=self._client_wrapper.get_headers(),
            timeout=60,
        )
        if 200 <= _response.status_code < 300:
            return pydantic.parse_obj_as(typing.List[ClientFacingCholesterolTimeseries], _response.json())  # type: ignore
        if _response.status_code == 422:
            raise UnprocessableEntityError(pydantic.parse_obj_as(HttpValidationError, _response.json()))  # type: ignore
        try:
            _response_json = _response.json()
        except JSONDecodeError:
            raise ApiError(status_code=_response.status_code, body=_response.text)
        raise ApiError(status_code=_response.status_code, body=_response_json)

    def cholesterol_total(
        self,
        user_id: str,
        *,
        provider: typing.Optional[str] = None,
        start_date: str,
        end_date: typing.Optional[str] = None,
    ) -> typing.List[ClientFacingCholesterolTimeseries]:
        """
        Get timeseries data for user

        Parameters:
            - user_id: str.

            - provider: typing.Optional[str]. Provider oura/strava etc

            - start_date: str. Date from in YYYY-MM-DD or ISO formatted date time. If a date is provided without a time, the time will be set to 00:00:00

            - end_date: typing.Optional[str]. Date to YYYY-MM-DD or ISO formatted date time. If a date is provided without a time, the time will be set to 23:59:59
        ---
        from vital.client import Vital

        client = Vital(
            api_key="YOUR_API_KEY",
        )
        client.cholesterol_total(
            user_id="user-id",
            start_date="start-date",
        )
        """
        _response = self._client_wrapper.httpx_client.request(
            "GET",
            urllib.parse.urljoin(
                f"{self._client_wrapper.get_base_url()}/", f"v2/timeseries/{user_id}/cholesterol/total"
            ),
            params=remove_none_from_dict({"provider": provider, "start_date": start_date, "end_date": end_date}),
            headers=self._client_wrapper.get_headers(),
            timeout=60,
        )
        if 200 <= _response.status_code < 300:
            return pydantic.parse_obj_as(typing.List[ClientFacingCholesterolTimeseries], _response.json())  # type: ignore
        if _response.status_code == 422:
            raise UnprocessableEntityError(pydantic.parse_obj_as(HttpValidationError, _response.json()))  # type: ignore
        try:
            _response_json = _response.json()
        except JSONDecodeError:
            raise ApiError(status_code=_response.status_code, body=_response.text)
        raise ApiError(status_code=_response.status_code, body=_response_json)

    def cholesterol_hdl(
        self,
        user_id: str,
        *,
        provider: typing.Optional[str] = None,
        start_date: str,
        end_date: typing.Optional[str] = None,
    ) -> typing.List[ClientFacingCholesterolTimeseries]:
        """
        Get timeseries data for user

        Parameters:
            - user_id: str.

            - provider: typing.Optional[str]. Provider oura/strava etc

            - start_date: str. Date from in YYYY-MM-DD or ISO formatted date time. If a date is provided without a time, the time will be set to 00:00:00

            - end_date: typing.Optional[str]. Date to YYYY-MM-DD or ISO formatted date time. If a date is provided without a time, the time will be set to 23:59:59
        ---
        from vital.client import Vital

        client = Vital(
            api_key="YOUR_API_KEY",
        )
        client.cholesterol_hdl(
            user_id="user-id",
            start_date="start-date",
        )
        """
        _response = self._client_wrapper.httpx_client.request(
            "GET",
            urllib.parse.urljoin(f"{self._client_wrapper.get_base_url()}/", f"v2/timeseries/{user_id}/cholesterol/hdl"),
            params=remove_none_from_dict({"provider": provider, "start_date": start_date, "end_date": end_date}),
            headers=self._client_wrapper.get_headers(),
            timeout=60,
        )
        if 200 <= _response.status_code < 300:
            return pydantic.parse_obj_as(typing.List[ClientFacingCholesterolTimeseries], _response.json())  # type: ignore
        if _response.status_code == 422:
            raise UnprocessableEntityError(pydantic.parse_obj_as(HttpValidationError, _response.json()))  # type: ignore
        try:
            _response_json = _response.json()
        except JSONDecodeError:
            raise ApiError(status_code=_response.status_code, body=_response.text)
        raise ApiError(status_code=_response.status_code, body=_response_json)

    def cholesterol_ldl(
        self,
        user_id: str,
        *,
        provider: typing.Optional[str] = None,
        start_date: str,
        end_date: typing.Optional[str] = None,
    ) -> typing.List[ClientFacingCholesterolTimeseries]:
        """
        Get timeseries data for user

        Parameters:
            - user_id: str.

            - provider: typing.Optional[str]. Provider oura/strava etc

            - start_date: str. Date from in YYYY-MM-DD or ISO formatted date time. If a date is provided without a time, the time will be set to 00:00:00

            - end_date: typing.Optional[str]. Date to YYYY-MM-DD or ISO formatted date time. If a date is provided without a time, the time will be set to 23:59:59
        ---
        from vital.client import Vital

        client = Vital(
            api_key="YOUR_API_KEY",
        )
        client.cholesterol_ldl(
            user_id="user-id",
            start_date="start-date",
        )
        """
        _response = self._client_wrapper.httpx_client.request(
            "GET",
            urllib.parse.urljoin(f"{self._client_wrapper.get_base_url()}/", f"v2/timeseries/{user_id}/cholesterol/ldl"),
            params=remove_none_from_dict({"provider": provider, "start_date": start_date, "end_date": end_date}),
            headers=self._client_wrapper.get_headers(),
            timeout=60,
        )
        if 200 <= _response.status_code < 300:
            return pydantic.parse_obj_as(typing.List[ClientFacingCholesterolTimeseries], _response.json())  # type: ignore
        if _response.status_code == 422:
            raise UnprocessableEntityError(pydantic.parse_obj_as(HttpValidationError, _response.json()))  # type: ignore
        try:
            _response_json = _response.json()
        except JSONDecodeError:
            raise ApiError(status_code=_response.status_code, body=_response.text)
        raise ApiError(status_code=_response.status_code, body=_response_json)

    def cholesterol(
        self,
        user_id: str,
        *,
        provider: typing.Optional[str] = None,
        start_date: str,
        end_date: typing.Optional[str] = None,
    ) -> typing.List[ClientFacingCholesterolTimeseries]:
        """
        Get timeseries data for user

        Parameters:
            - user_id: str.

            - provider: typing.Optional[str]. Provider oura/strava etc

            - start_date: str. Date from in YYYY-MM-DD or ISO formatted date time. If a date is provided without a time, the time will be set to 00:00:00

            - end_date: typing.Optional[str]. Date to YYYY-MM-DD or ISO formatted date time. If a date is provided without a time, the time will be set to 23:59:59
        ---
        from vital.client import Vital

        client = Vital(
            api_key="YOUR_API_KEY",
        )
        client.cholesterol(
            user_id="user-id",
            start_date="start-date",
        )
        """
        _response = self._client_wrapper.httpx_client.request(
            "GET",
            urllib.parse.urljoin(f"{self._client_wrapper.get_base_url()}/", f"v2/timeseries/{user_id}/cholesterol"),
            params=remove_none_from_dict({"provider": provider, "start_date": start_date, "end_date": end_date}),
            headers=self._client_wrapper.get_headers(),
            timeout=60,
        )
        if 200 <= _response.status_code < 300:
            return pydantic.parse_obj_as(typing.List[ClientFacingCholesterolTimeseries], _response.json())  # type: ignore
        if _response.status_code == 422:
            raise UnprocessableEntityError(pydantic.parse_obj_as(HttpValidationError, _response.json()))  # type: ignore
        try:
            _response_json = _response.json()
        except JSONDecodeError:
            raise ApiError(status_code=_response.status_code, body=_response.text)
        raise ApiError(status_code=_response.status_code, body=_response_json)

    def blood_oxygen(
        self,
        user_id: str,
        *,
        provider: typing.Optional[str] = None,
        start_date: str,
        end_date: typing.Optional[str] = None,
    ) -> typing.List[ClientFacingBloodOxygenTimeseries]:
        """
        Get timeseries data for user

        Parameters:
            - user_id: str.

            - provider: typing.Optional[str]. Provider oura/strava etc

            - start_date: str. Date from in YYYY-MM-DD or ISO formatted date time. If a date is provided without a time, the time will be set to 00:00:00

            - end_date: typing.Optional[str]. Date to YYYY-MM-DD or ISO formatted date time. If a date is provided without a time, the time will be set to 23:59:59
        ---
        from vital.client import Vital

        client = Vital(
            api_key="YOUR_API_KEY",
        )
        client.blood_oxygen(
            user_id="user-id",
            start_date="start-date",
        )
        """
        _response = self._client_wrapper.httpx_client.request(
            "GET",
            urllib.parse.urljoin(f"{self._client_wrapper.get_base_url()}/", f"v2/timeseries/{user_id}/blood_oxygen"),
            params=remove_none_from_dict({"provider": provider, "start_date": start_date, "end_date": end_date}),
            headers=self._client_wrapper.get_headers(),
            timeout=60,
        )
        if 200 <= _response.status_code < 300:
            return pydantic.parse_obj_as(typing.List[ClientFacingBloodOxygenTimeseries], _response.json())  # type: ignore
        if _response.status_code == 422:
            raise UnprocessableEntityError(pydantic.parse_obj_as(HttpValidationError, _response.json()))  # type: ignore
        try:
            _response_json = _response.json()
        except JSONDecodeError:
            raise ApiError(status_code=_response.status_code, body=_response.text)
        raise ApiError(status_code=_response.status_code, body=_response_json)

    def blood_pressure(
        self,
        user_id: str,
        *,
        provider: typing.Optional[str] = None,
        start_date: str,
        end_date: typing.Optional[str] = None,
    ) -> typing.List[ClientFacingBloodPressureTimeseries]:
        """
        Get timeseries data for user

        Parameters:
            - user_id: str.

            - provider: typing.Optional[str]. Provider oura/strava etc

            - start_date: str. Date from in YYYY-MM-DD or ISO formatted date time. If a date is provided without a time, the time will be set to 00:00:00

            - end_date: typing.Optional[str]. Date to YYYY-MM-DD or ISO formatted date time. If a date is provided without a time, the time will be set to 23:59:59
        ---
        from vital.client import Vital

        client = Vital(
            api_key="YOUR_API_KEY",
        )
        client.blood_pressure(
            user_id="user-id",
            start_date="start-date",
        )
        """
        _response = self._client_wrapper.httpx_client.request(
            "GET",
            urllib.parse.urljoin(f"{self._client_wrapper.get_base_url()}/", f"v2/timeseries/{user_id}/blood_pressure"),
            params=remove_none_from_dict({"provider": provider, "start_date": start_date, "end_date": end_date}),
            headers=self._client_wrapper.get_headers(),
            timeout=60,
        )
        if 200 <= _response.status_code < 300:
            return pydantic.parse_obj_as(typing.List[ClientFacingBloodPressureTimeseries], _response.json())  # type: ignore
        if _response.status_code == 422:
            raise UnprocessableEntityError(pydantic.parse_obj_as(HttpValidationError, _response.json()))  # type: ignore
        try:
            _response_json = _response.json()
        except JSONDecodeError:
            raise ApiError(status_code=_response.status_code, body=_response.text)
        raise ApiError(status_code=_response.status_code, body=_response_json)


class AsyncVitalsClient:
    def __init__(self, *, client_wrapper: AsyncClientWrapper):
        self._client_wrapper = client_wrapper

    async def mindfulness_minutes(
        self,
        user_id: str,
        *,
        provider: typing.Optional[str] = None,
        start_date: str,
        end_date: typing.Optional[str] = None,
    ) -> typing.List[ClientFacingMindfulnessMinutesTimeseries]:
        """
        Get timeseries data for user

        Parameters:
            - user_id: str.

            - provider: typing.Optional[str]. Provider oura/strava etc

            - start_date: str. Date from in YYYY-MM-DD or ISO formatted date time. If a date is provided without a time, the time will be set to 00:00:00

            - end_date: typing.Optional[str]. Date to YYYY-MM-DD or ISO formatted date time. If a date is provided without a time, the time will be set to 23:59:59
        ---
        from vital.client import AsyncVital

        client = AsyncVital(
            api_key="YOUR_API_KEY",
        )
        await client.mindfulness_minutes(
            user_id="user-id",
            start_date="start-date",
        )
        """
        _response = await self._client_wrapper.httpx_client.request(
            "GET",
            urllib.parse.urljoin(
                f"{self._client_wrapper.get_base_url()}/", f"v2/timeseries/{user_id}/mindfulness_minutes"
            ),
            params=remove_none_from_dict({"provider": provider, "start_date": start_date, "end_date": end_date}),
            headers=self._client_wrapper.get_headers(),
            timeout=60,
        )
        if 200 <= _response.status_code < 300:
            return pydantic.parse_obj_as(typing.List[ClientFacingMindfulnessMinutesTimeseries], _response.json())  # type: ignore
        if _response.status_code == 422:
            raise UnprocessableEntityError(pydantic.parse_obj_as(HttpValidationError, _response.json()))  # type: ignore
        try:
            _response_json = _response.json()
        except JSONDecodeError:
            raise ApiError(status_code=_response.status_code, body=_response.text)
        raise ApiError(status_code=_response.status_code, body=_response_json)

    async def caffeine(
        self,
        user_id: str,
        *,
        provider: typing.Optional[str] = None,
        start_date: str,
        end_date: typing.Optional[str] = None,
    ) -> typing.List[ClientFacingCaffeineTimeseries]:
        """
        Get timeseries data for user

        Parameters:
            - user_id: str.

            - provider: typing.Optional[str]. Provider oura/strava etc

            - start_date: str. Date from in YYYY-MM-DD or ISO formatted date time. If a date is provided without a time, the time will be set to 00:00:00

            - end_date: typing.Optional[str]. Date to YYYY-MM-DD or ISO formatted date time. If a date is provided without a time, the time will be set to 23:59:59
        ---
        from vital.client import AsyncVital

        client = AsyncVital(
            api_key="YOUR_API_KEY",
        )
        await client.caffeine(
            user_id="user-id",
            start_date="start-date",
        )
        """
        _response = await self._client_wrapper.httpx_client.request(
            "GET",
            urllib.parse.urljoin(f"{self._client_wrapper.get_base_url()}/", f"v2/timeseries/{user_id}/caffeine"),
            params=remove_none_from_dict({"provider": provider, "start_date": start_date, "end_date": end_date}),
            headers=self._client_wrapper.get_headers(),
            timeout=60,
        )
        if 200 <= _response.status_code < 300:
            return pydantic.parse_obj_as(typing.List[ClientFacingCaffeineTimeseries], _response.json())  # type: ignore
        if _response.status_code == 422:
            raise UnprocessableEntityError(pydantic.parse_obj_as(HttpValidationError, _response.json()))  # type: ignore
        try:
            _response_json = _response.json()
        except JSONDecodeError:
            raise ApiError(status_code=_response.status_code, body=_response.text)
        raise ApiError(status_code=_response.status_code, body=_response_json)

    async def water(
        self,
        user_id: str,
        *,
        provider: typing.Optional[str] = None,
        start_date: str,
        end_date: typing.Optional[str] = None,
    ) -> typing.List[ClientFacingWaterTimeseries]:
        """
        Get timeseries data for user

        Parameters:
            - user_id: str.

            - provider: typing.Optional[str]. Provider oura/strava etc

            - start_date: str. Date from in YYYY-MM-DD or ISO formatted date time. If a date is provided without a time, the time will be set to 00:00:00

            - end_date: typing.Optional[str]. Date to YYYY-MM-DD or ISO formatted date time. If a date is provided without a time, the time will be set to 23:59:59
        ---
        from vital.client import AsyncVital

        client = AsyncVital(
            api_key="YOUR_API_KEY",
        )
        await client.water(
            user_id="user-id",
            start_date="start-date",
        )
        """
        _response = await self._client_wrapper.httpx_client.request(
            "GET",
            urllib.parse.urljoin(f"{self._client_wrapper.get_base_url()}/", f"v2/timeseries/{user_id}/water"),
            params=remove_none_from_dict({"provider": provider, "start_date": start_date, "end_date": end_date}),
            headers=self._client_wrapper.get_headers(),
            timeout=60,
        )
        if 200 <= _response.status_code < 300:
            return pydantic.parse_obj_as(typing.List[ClientFacingWaterTimeseries], _response.json())  # type: ignore
        if _response.status_code == 422:
            raise UnprocessableEntityError(pydantic.parse_obj_as(HttpValidationError, _response.json()))  # type: ignore
        try:
            _response_json = _response.json()
        except JSONDecodeError:
            raise ApiError(status_code=_response.status_code, body=_response.text)
        raise ApiError(status_code=_response.status_code, body=_response_json)

    async def steps(
        self,
        user_id: str,
        *,
        provider: typing.Optional[str] = None,
        start_date: str,
        end_date: typing.Optional[str] = None,
    ) -> typing.List[ClientFacingStepsTimeseries]:
        """
        Get timeseries data for user

        Parameters:
            - user_id: str.

            - provider: typing.Optional[str]. Provider oura/strava etc

            - start_date: str. Date from in YYYY-MM-DD or ISO formatted date time. If a date is provided without a time, the time will be set to 00:00:00

            - end_date: typing.Optional[str]. Date to YYYY-MM-DD or ISO formatted date time. If a date is provided without a time, the time will be set to 23:59:59
        ---
        from vital.client import AsyncVital

        client = AsyncVital(
            api_key="YOUR_API_KEY",
        )
        await client.steps(
            user_id="user-id",
            start_date="start-date",
        )
        """
        _response = await self._client_wrapper.httpx_client.request(
            "GET",
            urllib.parse.urljoin(f"{self._client_wrapper.get_base_url()}/", f"v2/timeseries/{user_id}/steps"),
            params=remove_none_from_dict({"provider": provider, "start_date": start_date, "end_date": end_date}),
            headers=self._client_wrapper.get_headers(),
            timeout=60,
        )
        if 200 <= _response.status_code < 300:
            return pydantic.parse_obj_as(typing.List[ClientFacingStepsTimeseries], _response.json())  # type: ignore
        if _response.status_code == 422:
            raise UnprocessableEntityError(pydantic.parse_obj_as(HttpValidationError, _response.json()))  # type: ignore
        try:
            _response_json = _response.json()
        except JSONDecodeError:
            raise ApiError(status_code=_response.status_code, body=_response.text)
        raise ApiError(status_code=_response.status_code, body=_response_json)

    async def floors_climbed(
        self,
        user_id: str,
        *,
        provider: typing.Optional[str] = None,
        start_date: str,
        end_date: typing.Optional[str] = None,
    ) -> typing.List[ClientFacingFloorsClimbedTimeseries]:
        """
        Get timeseries data for user

        Parameters:
            - user_id: str.

            - provider: typing.Optional[str]. Provider oura/strava etc

            - start_date: str. Date from in YYYY-MM-DD or ISO formatted date time. If a date is provided without a time, the time will be set to 00:00:00

            - end_date: typing.Optional[str]. Date to YYYY-MM-DD or ISO formatted date time. If a date is provided without a time, the time will be set to 23:59:59
        ---
        from vital.client import AsyncVital

        client = AsyncVital(
            api_key="YOUR_API_KEY",
        )
        await client.floors_climbed(
            user_id="user-id",
            start_date="start-date",
        )
        """
        _response = await self._client_wrapper.httpx_client.request(
            "GET",
            urllib.parse.urljoin(f"{self._client_wrapper.get_base_url()}/", f"v2/timeseries/{user_id}/floors_climbed"),
            params=remove_none_from_dict({"provider": provider, "start_date": start_date, "end_date": end_date}),
            headers=self._client_wrapper.get_headers(),
            timeout=60,
        )
        if 200 <= _response.status_code < 300:
            return pydantic.parse_obj_as(typing.List[ClientFacingFloorsClimbedTimeseries], _response.json())  # type: ignore
        if _response.status_code == 422:
            raise UnprocessableEntityError(pydantic.parse_obj_as(HttpValidationError, _response.json()))  # type: ignore
        try:
            _response_json = _response.json()
        except JSONDecodeError:
            raise ApiError(status_code=_response.status_code, body=_response.text)
        raise ApiError(status_code=_response.status_code, body=_response_json)

    async def distance(
        self,
        user_id: str,
        *,
        provider: typing.Optional[str] = None,
        start_date: str,
        end_date: typing.Optional[str] = None,
    ) -> typing.List[ClientFacingDistanceTimeseries]:
        """
        Get timeseries data for user

        Parameters:
            - user_id: str.

            - provider: typing.Optional[str]. Provider oura/strava etc

            - start_date: str. Date from in YYYY-MM-DD or ISO formatted date time. If a date is provided without a time, the time will be set to 00:00:00

            - end_date: typing.Optional[str]. Date to YYYY-MM-DD or ISO formatted date time. If a date is provided without a time, the time will be set to 23:59:59
        ---
        from vital.client import AsyncVital

        client = AsyncVital(
            api_key="YOUR_API_KEY",
        )
        await client.distance(
            user_id="user-id",
            start_date="start-date",
        )
        """
        _response = await self._client_wrapper.httpx_client.request(
            "GET",
            urllib.parse.urljoin(f"{self._client_wrapper.get_base_url()}/", f"v2/timeseries/{user_id}/distance"),
            params=remove_none_from_dict({"provider": provider, "start_date": start_date, "end_date": end_date}),
            headers=self._client_wrapper.get_headers(),
            timeout=60,
        )
        if 200 <= _response.status_code < 300:
            return pydantic.parse_obj_as(typing.List[ClientFacingDistanceTimeseries], _response.json())  # type: ignore
        if _response.status_code == 422:
            raise UnprocessableEntityError(pydantic.parse_obj_as(HttpValidationError, _response.json()))  # type: ignore
        try:
            _response_json = _response.json()
        except JSONDecodeError:
            raise ApiError(status_code=_response.status_code, body=_response.text)
        raise ApiError(status_code=_response.status_code, body=_response_json)

    async def calories_basal(
        self,
        user_id: str,
        *,
        provider: typing.Optional[str] = None,
        start_date: str,
        end_date: typing.Optional[str] = None,
    ) -> typing.List[ClientFacingCaloriesBasalTimeseries]:
        """
        Get timeseries data for user

        Parameters:
            - user_id: str.

            - provider: typing.Optional[str]. Provider oura/strava etc

            - start_date: str. Date from in YYYY-MM-DD or ISO formatted date time. If a date is provided without a time, the time will be set to 00:00:00

            - end_date: typing.Optional[str]. Date to YYYY-MM-DD or ISO formatted date time. If a date is provided without a time, the time will be set to 23:59:59
        ---
        from vital.client import AsyncVital

        client = AsyncVital(
            api_key="YOUR_API_KEY",
        )
        await client.calories_basal(
            user_id="user-id",
            start_date="start-date",
        )
        """
        _response = await self._client_wrapper.httpx_client.request(
            "GET",
            urllib.parse.urljoin(f"{self._client_wrapper.get_base_url()}/", f"v2/timeseries/{user_id}/calories_basal"),
            params=remove_none_from_dict({"provider": provider, "start_date": start_date, "end_date": end_date}),
            headers=self._client_wrapper.get_headers(),
            timeout=60,
        )
        if 200 <= _response.status_code < 300:
            return pydantic.parse_obj_as(typing.List[ClientFacingCaloriesBasalTimeseries], _response.json())  # type: ignore
        if _response.status_code == 422:
            raise UnprocessableEntityError(pydantic.parse_obj_as(HttpValidationError, _response.json()))  # type: ignore
        try:
            _response_json = _response.json()
        except JSONDecodeError:
            raise ApiError(status_code=_response.status_code, body=_response.text)
        raise ApiError(status_code=_response.status_code, body=_response_json)

    async def calories_active(
        self,
        user_id: str,
        *,
        provider: typing.Optional[str] = None,
        start_date: str,
        end_date: typing.Optional[str] = None,
    ) -> typing.List[ClientFacingCaloriesActiveTimeseries]:
        """
        Get timeseries data for user

        Parameters:
            - user_id: str.

            - provider: typing.Optional[str]. Provider oura/strava etc

            - start_date: str. Date from in YYYY-MM-DD or ISO formatted date time. If a date is provided without a time, the time will be set to 00:00:00

            - end_date: typing.Optional[str]. Date to YYYY-MM-DD or ISO formatted date time. If a date is provided without a time, the time will be set to 23:59:59
        ---
        from vital.client import AsyncVital

        client = AsyncVital(
            api_key="YOUR_API_KEY",
        )
        await client.calories_active(
            user_id="user-id",
            start_date="start-date",
        )
        """
        _response = await self._client_wrapper.httpx_client.request(
            "GET",
            urllib.parse.urljoin(f"{self._client_wrapper.get_base_url()}/", f"v2/timeseries/{user_id}/calories_active"),
            params=remove_none_from_dict({"provider": provider, "start_date": start_date, "end_date": end_date}),
            headers=self._client_wrapper.get_headers(),
            timeout=60,
        )
        if 200 <= _response.status_code < 300:
            return pydantic.parse_obj_as(typing.List[ClientFacingCaloriesActiveTimeseries], _response.json())  # type: ignore
        if _response.status_code == 422:
            raise UnprocessableEntityError(pydantic.parse_obj_as(HttpValidationError, _response.json()))  # type: ignore
        try:
            _response_json = _response.json()
        except JSONDecodeError:
            raise ApiError(status_code=_response.status_code, body=_response.text)
        raise ApiError(status_code=_response.status_code, body=_response_json)

    async def respiratory_rate(
        self,
        user_id: str,
        *,
        provider: typing.Optional[str] = None,
        start_date: str,
        end_date: typing.Optional[str] = None,
    ) -> typing.List[ClientFacingRespiratoryRateTimeseries]:
        """
        Get timeseries data for user

        Parameters:
            - user_id: str.

            - provider: typing.Optional[str]. Provider oura/strava etc

            - start_date: str. Date from in YYYY-MM-DD or ISO formatted date time. If a date is provided without a time, the time will be set to 00:00:00

            - end_date: typing.Optional[str]. Date to YYYY-MM-DD or ISO formatted date time. If a date is provided without a time, the time will be set to 23:59:59
        ---
        from vital.client import AsyncVital

        client = AsyncVital(
            api_key="YOUR_API_KEY",
        )
        await client.respiratory_rate(
            user_id="user-id",
            start_date="start-date",
        )
        """
        _response = await self._client_wrapper.httpx_client.request(
            "GET",
            urllib.parse.urljoin(
                f"{self._client_wrapper.get_base_url()}/", f"v2/timeseries/{user_id}/respiratory_rate"
            ),
            params=remove_none_from_dict({"provider": provider, "start_date": start_date, "end_date": end_date}),
            headers=self._client_wrapper.get_headers(),
            timeout=60,
        )
        if 200 <= _response.status_code < 300:
            return pydantic.parse_obj_as(typing.List[ClientFacingRespiratoryRateTimeseries], _response.json())  # type: ignore
        if _response.status_code == 422:
            raise UnprocessableEntityError(pydantic.parse_obj_as(HttpValidationError, _response.json()))  # type: ignore
        try:
            _response_json = _response.json()
        except JSONDecodeError:
            raise ApiError(status_code=_response.status_code, body=_response.text)
        raise ApiError(status_code=_response.status_code, body=_response_json)

    async def ige(
        self,
        user_id: str,
        *,
        provider: typing.Optional[str] = None,
        start_date: str,
        end_date: typing.Optional[str] = None,
    ) -> typing.List[ClientFacingIgeTimeseries]:
        """
        Get timeseries data for user

        Parameters:
            - user_id: str.

            - provider: typing.Optional[str]. Provider oura/strava etc

            - start_date: str. Date from in YYYY-MM-DD or ISO formatted date time. If a date is provided without a time, the time will be set to 00:00:00

            - end_date: typing.Optional[str]. Date to YYYY-MM-DD or ISO formatted date time. If a date is provided without a time, the time will be set to 23:59:59
        ---
        from vital.client import AsyncVital

        client = AsyncVital(
            api_key="YOUR_API_KEY",
        )
        await client.ige(
            user_id="user-id",
            start_date="start-date",
        )
        """
        _response = await self._client_wrapper.httpx_client.request(
            "GET",
            urllib.parse.urljoin(f"{self._client_wrapper.get_base_url()}/", f"v2/timeseries/{user_id}/ige"),
            params=remove_none_from_dict({"provider": provider, "start_date": start_date, "end_date": end_date}),
            headers=self._client_wrapper.get_headers(),
            timeout=60,
        )
        if 200 <= _response.status_code < 300:
            return pydantic.parse_obj_as(typing.List[ClientFacingIgeTimeseries], _response.json())  # type: ignore
        if _response.status_code == 422:
            raise UnprocessableEntityError(pydantic.parse_obj_as(HttpValidationError, _response.json()))  # type: ignore
        try:
            _response_json = _response.json()
        except JSONDecodeError:
            raise ApiError(status_code=_response.status_code, body=_response.text)
        raise ApiError(status_code=_response.status_code, body=_response_json)

    async def igg(
        self,
        user_id: str,
        *,
        provider: typing.Optional[str] = None,
        start_date: str,
        end_date: typing.Optional[str] = None,
    ) -> typing.List[ClientFacingIggTimeseries]:
        """
        Get timeseries data for user

        Parameters:
            - user_id: str.

            - provider: typing.Optional[str]. Provider oura/strava etc

            - start_date: str. Date from in YYYY-MM-DD or ISO formatted date time. If a date is provided without a time, the time will be set to 00:00:00

            - end_date: typing.Optional[str]. Date to YYYY-MM-DD or ISO formatted date time. If a date is provided without a time, the time will be set to 23:59:59
        ---
        from vital.client import AsyncVital

        client = AsyncVital(
            api_key="YOUR_API_KEY",
        )
        await client.igg(
            user_id="user-id",
            start_date="start-date",
        )
        """
        _response = await self._client_wrapper.httpx_client.request(
            "GET",
            urllib.parse.urljoin(f"{self._client_wrapper.get_base_url()}/", f"v2/timeseries/{user_id}/igg"),
            params=remove_none_from_dict({"provider": provider, "start_date": start_date, "end_date": end_date}),
            headers=self._client_wrapper.get_headers(),
            timeout=60,
        )
        if 200 <= _response.status_code < 300:
            return pydantic.parse_obj_as(typing.List[ClientFacingIggTimeseries], _response.json())  # type: ignore
        if _response.status_code == 422:
            raise UnprocessableEntityError(pydantic.parse_obj_as(HttpValidationError, _response.json()))  # type: ignore
        try:
            _response_json = _response.json()
        except JSONDecodeError:
            raise ApiError(status_code=_response.status_code, body=_response.text)
        raise ApiError(status_code=_response.status_code, body=_response_json)

    async def hypnogram(
        self,
        user_id: str,
        *,
        provider: typing.Optional[str] = None,
        start_date: str,
        end_date: typing.Optional[str] = None,
    ) -> typing.List[ClientFacingHypnogramTimeseries]:
        """
        Get timeseries data for user

        Parameters:
            - user_id: str.

            - provider: typing.Optional[str]. Provider oura/strava etc

            - start_date: str. Date from in YYYY-MM-DD or ISO formatted date time. If a date is provided without a time, the time will be set to 00:00:00

            - end_date: typing.Optional[str]. Date to YYYY-MM-DD or ISO formatted date time. If a date is provided without a time, the time will be set to 23:59:59
        ---
        from vital.client import AsyncVital

        client = AsyncVital(
            api_key="YOUR_API_KEY",
        )
        await client.hypnogram(
            user_id="user-id",
            start_date="start-date",
        )
        """
        _response = await self._client_wrapper.httpx_client.request(
            "GET",
            urllib.parse.urljoin(f"{self._client_wrapper.get_base_url()}/", f"v2/timeseries/{user_id}/hypnogram"),
            params=remove_none_from_dict({"provider": provider, "start_date": start_date, "end_date": end_date}),
            headers=self._client_wrapper.get_headers(),
            timeout=60,
        )
        if 200 <= _response.status_code < 300:
            return pydantic.parse_obj_as(typing.List[ClientFacingHypnogramTimeseries], _response.json())  # type: ignore
        if _response.status_code == 422:
            raise UnprocessableEntityError(pydantic.parse_obj_as(HttpValidationError, _response.json()))  # type: ignore
        try:
            _response_json = _response.json()
        except JSONDecodeError:
            raise ApiError(status_code=_response.status_code, body=_response.text)
        raise ApiError(status_code=_response.status_code, body=_response_json)

    async def hrv(
        self,
        user_id: str,
        *,
        provider: typing.Optional[str] = None,
        start_date: str,
        end_date: typing.Optional[str] = None,
    ) -> typing.List[ClientFacingHrvTimeseries]:
        """
        Get timeseries data for user

        Parameters:
            - user_id: str.

            - provider: typing.Optional[str]. Provider oura/strava etc

            - start_date: str. Date from in YYYY-MM-DD or ISO formatted date time. If a date is provided without a time, the time will be set to 00:00:00

            - end_date: typing.Optional[str]. Date to YYYY-MM-DD or ISO formatted date time. If a date is provided without a time, the time will be set to 23:59:59
        ---
        from vital.client import AsyncVital

        client = AsyncVital(
            api_key="YOUR_API_KEY",
        )
        await client.hrv(
            user_id="user-id",
            start_date="start-date",
        )
        """
        _response = await self._client_wrapper.httpx_client.request(
            "GET",
            urllib.parse.urljoin(f"{self._client_wrapper.get_base_url()}/", f"v2/timeseries/{user_id}/hrv"),
            params=remove_none_from_dict({"provider": provider, "start_date": start_date, "end_date": end_date}),
            headers=self._client_wrapper.get_headers(),
            timeout=60,
        )
        if 200 <= _response.status_code < 300:
            return pydantic.parse_obj_as(typing.List[ClientFacingHrvTimeseries], _response.json())  # type: ignore
        if _response.status_code == 422:
            raise UnprocessableEntityError(pydantic.parse_obj_as(HttpValidationError, _response.json()))  # type: ignore
        try:
            _response_json = _response.json()
        except JSONDecodeError:
            raise ApiError(status_code=_response.status_code, body=_response.text)
        raise ApiError(status_code=_response.status_code, body=_response_json)

    async def heartrate(
        self,
        user_id: str,
        *,
        provider: typing.Optional[str] = None,
        start_date: str,
        end_date: typing.Optional[str] = None,
    ) -> typing.List[ClientFacingHeartRateTimeseries]:
        """
        Get timeseries data for user

        Parameters:
            - user_id: str.

            - provider: typing.Optional[str]. Provider oura/strava etc

            - start_date: str. Date from in YYYY-MM-DD or ISO formatted date time. If a date is provided without a time, the time will be set to 00:00:00

            - end_date: typing.Optional[str]. Date to YYYY-MM-DD or ISO formatted date time. If a date is provided without a time, the time will be set to 23:59:59
        ---
        from vital.client import AsyncVital

        client = AsyncVital(
            api_key="YOUR_API_KEY",
        )
        await client.heartrate(
            user_id="user-id",
            start_date="start-date",
        )
        """
        _response = await self._client_wrapper.httpx_client.request(
            "GET",
            urllib.parse.urljoin(f"{self._client_wrapper.get_base_url()}/", f"v2/timeseries/{user_id}/heartrate"),
            params=remove_none_from_dict({"provider": provider, "start_date": start_date, "end_date": end_date}),
            headers=self._client_wrapper.get_headers(),
            timeout=60,
        )
        if 200 <= _response.status_code < 300:
            return pydantic.parse_obj_as(typing.List[ClientFacingHeartRateTimeseries], _response.json())  # type: ignore
        if _response.status_code == 422:
            raise UnprocessableEntityError(pydantic.parse_obj_as(HttpValidationError, _response.json()))  # type: ignore
        try:
            _response_json = _response.json()
        except JSONDecodeError:
            raise ApiError(status_code=_response.status_code, body=_response.text)
        raise ApiError(status_code=_response.status_code, body=_response_json)

    async def glucose(
        self,
        user_id: str,
        *,
        provider: typing.Optional[str] = None,
        start_date: str,
        end_date: typing.Optional[str] = None,
    ) -> typing.List[ClientFacingGlucoseTimeseries]:
        """
        Get timeseries data for user

        Parameters:
            - user_id: str.

            - provider: typing.Optional[str]. Provider oura/strava etc

            - start_date: str. Date from in YYYY-MM-DD or ISO formatted date time. If a date is provided without a time, the time will be set to 00:00:00

            - end_date: typing.Optional[str]. Date to YYYY-MM-DD or ISO formatted date time. If a date is provided without a time, the time will be set to 23:59:59
        ---
        from vital.client import AsyncVital

        client = AsyncVital(
            api_key="YOUR_API_KEY",
        )
        await client.glucose(
            user_id="user-id",
            start_date="start-date",
        )
        """
        _response = await self._client_wrapper.httpx_client.request(
            "GET",
            urllib.parse.urljoin(f"{self._client_wrapper.get_base_url()}/", f"v2/timeseries/{user_id}/glucose"),
            params=remove_none_from_dict({"provider": provider, "start_date": start_date, "end_date": end_date}),
            headers=self._client_wrapper.get_headers(),
            timeout=60,
        )
        if 200 <= _response.status_code < 300:
            return pydantic.parse_obj_as(typing.List[ClientFacingGlucoseTimeseries], _response.json())  # type: ignore
        if _response.status_code == 422:
            raise UnprocessableEntityError(pydantic.parse_obj_as(HttpValidationError, _response.json()))  # type: ignore
        try:
            _response_json = _response.json()
        except JSONDecodeError:
            raise ApiError(status_code=_response.status_code, body=_response.text)
        raise ApiError(status_code=_response.status_code, body=_response_json)

    async def triglycerides(
        self,
        user_id: str,
        *,
        provider: typing.Optional[str] = None,
        start_date: str,
        end_date: typing.Optional[str] = None,
    ) -> typing.List[ClientFacingCholesterolTimeseries]:
        """
        Get timeseries data for user

        Parameters:
            - user_id: str.

            - provider: typing.Optional[str]. Provider oura/strava etc

            - start_date: str. Date from in YYYY-MM-DD or ISO formatted date time. If a date is provided without a time, the time will be set to 00:00:00

            - end_date: typing.Optional[str]. Date to YYYY-MM-DD or ISO formatted date time. If a date is provided without a time, the time will be set to 23:59:59
        ---
        from vital.client import AsyncVital

        client = AsyncVital(
            api_key="YOUR_API_KEY",
        )
        await client.triglycerides(
            user_id="user-id",
            start_date="start-date",
        )
        """
        _response = await self._client_wrapper.httpx_client.request(
            "GET",
            urllib.parse.urljoin(
                f"{self._client_wrapper.get_base_url()}/", f"v2/timeseries/{user_id}/cholesterol/triglycerides"
            ),
            params=remove_none_from_dict({"provider": provider, "start_date": start_date, "end_date": end_date}),
            headers=self._client_wrapper.get_headers(),
            timeout=60,
        )
        if 200 <= _response.status_code < 300:
            return pydantic.parse_obj_as(typing.List[ClientFacingCholesterolTimeseries], _response.json())  # type: ignore
        if _response.status_code == 422:
            raise UnprocessableEntityError(pydantic.parse_obj_as(HttpValidationError, _response.json()))  # type: ignore
        try:
            _response_json = _response.json()
        except JSONDecodeError:
            raise ApiError(status_code=_response.status_code, body=_response.text)
        raise ApiError(status_code=_response.status_code, body=_response_json)

    async def cholesterol_total(
        self,
        user_id: str,
        *,
        provider: typing.Optional[str] = None,
        start_date: str,
        end_date: typing.Optional[str] = None,
    ) -> typing.List[ClientFacingCholesterolTimeseries]:
        """
        Get timeseries data for user

        Parameters:
            - user_id: str.

            - provider: typing.Optional[str]. Provider oura/strava etc

            - start_date: str. Date from in YYYY-MM-DD or ISO formatted date time. If a date is provided without a time, the time will be set to 00:00:00

            - end_date: typing.Optional[str]. Date to YYYY-MM-DD or ISO formatted date time. If a date is provided without a time, the time will be set to 23:59:59
        ---
        from vital.client import AsyncVital

        client = AsyncVital(
            api_key="YOUR_API_KEY",
        )
        await client.cholesterol_total(
            user_id="user-id",
            start_date="start-date",
        )
        """
        _response = await self._client_wrapper.httpx_client.request(
            "GET",
            urllib.parse.urljoin(
                f"{self._client_wrapper.get_base_url()}/", f"v2/timeseries/{user_id}/cholesterol/total"
            ),
            params=remove_none_from_dict({"provider": provider, "start_date": start_date, "end_date": end_date}),
            headers=self._client_wrapper.get_headers(),
            timeout=60,
        )
        if 200 <= _response.status_code < 300:
            return pydantic.parse_obj_as(typing.List[ClientFacingCholesterolTimeseries], _response.json())  # type: ignore
        if _response.status_code == 422:
            raise UnprocessableEntityError(pydantic.parse_obj_as(HttpValidationError, _response.json()))  # type: ignore
        try:
            _response_json = _response.json()
        except JSONDecodeError:
            raise ApiError(status_code=_response.status_code, body=_response.text)
        raise ApiError(status_code=_response.status_code, body=_response_json)

    async def cholesterol_hdl(
        self,
        user_id: str,
        *,
        provider: typing.Optional[str] = None,
        start_date: str,
        end_date: typing.Optional[str] = None,
    ) -> typing.List[ClientFacingCholesterolTimeseries]:
        """
        Get timeseries data for user

        Parameters:
            - user_id: str.

            - provider: typing.Optional[str]. Provider oura/strava etc

            - start_date: str. Date from in YYYY-MM-DD or ISO formatted date time. If a date is provided without a time, the time will be set to 00:00:00

            - end_date: typing.Optional[str]. Date to YYYY-MM-DD or ISO formatted date time. If a date is provided without a time, the time will be set to 23:59:59
        ---
        from vital.client import AsyncVital

        client = AsyncVital(
            api_key="YOUR_API_KEY",
        )
        await client.cholesterol_hdl(
            user_id="user-id",
            start_date="start-date",
        )
        """
        _response = await self._client_wrapper.httpx_client.request(
            "GET",
            urllib.parse.urljoin(f"{self._client_wrapper.get_base_url()}/", f"v2/timeseries/{user_id}/cholesterol/hdl"),
            params=remove_none_from_dict({"provider": provider, "start_date": start_date, "end_date": end_date}),
            headers=self._client_wrapper.get_headers(),
            timeout=60,
        )
        if 200 <= _response.status_code < 300:
            return pydantic.parse_obj_as(typing.List[ClientFacingCholesterolTimeseries], _response.json())  # type: ignore
        if _response.status_code == 422:
            raise UnprocessableEntityError(pydantic.parse_obj_as(HttpValidationError, _response.json()))  # type: ignore
        try:
            _response_json = _response.json()
        except JSONDecodeError:
            raise ApiError(status_code=_response.status_code, body=_response.text)
        raise ApiError(status_code=_response.status_code, body=_response_json)

    async def cholesterol_ldl(
        self,
        user_id: str,
        *,
        provider: typing.Optional[str] = None,
        start_date: str,
        end_date: typing.Optional[str] = None,
    ) -> typing.List[ClientFacingCholesterolTimeseries]:
        """
        Get timeseries data for user

        Parameters:
            - user_id: str.

            - provider: typing.Optional[str]. Provider oura/strava etc

            - start_date: str. Date from in YYYY-MM-DD or ISO formatted date time. If a date is provided without a time, the time will be set to 00:00:00

            - end_date: typing.Optional[str]. Date to YYYY-MM-DD or ISO formatted date time. If a date is provided without a time, the time will be set to 23:59:59
        ---
        from vital.client import AsyncVital

        client = AsyncVital(
            api_key="YOUR_API_KEY",
        )
        await client.cholesterol_ldl(
            user_id="user-id",
            start_date="start-date",
        )
        """
        _response = await self._client_wrapper.httpx_client.request(
            "GET",
            urllib.parse.urljoin(f"{self._client_wrapper.get_base_url()}/", f"v2/timeseries/{user_id}/cholesterol/ldl"),
            params=remove_none_from_dict({"provider": provider, "start_date": start_date, "end_date": end_date}),
            headers=self._client_wrapper.get_headers(),
            timeout=60,
        )
        if 200 <= _response.status_code < 300:
            return pydantic.parse_obj_as(typing.List[ClientFacingCholesterolTimeseries], _response.json())  # type: ignore
        if _response.status_code == 422:
            raise UnprocessableEntityError(pydantic.parse_obj_as(HttpValidationError, _response.json()))  # type: ignore
        try:
            _response_json = _response.json()
        except JSONDecodeError:
            raise ApiError(status_code=_response.status_code, body=_response.text)
        raise ApiError(status_code=_response.status_code, body=_response_json)

    async def cholesterol(
        self,
        user_id: str,
        *,
        provider: typing.Optional[str] = None,
        start_date: str,
        end_date: typing.Optional[str] = None,
    ) -> typing.List[ClientFacingCholesterolTimeseries]:
        """
        Get timeseries data for user

        Parameters:
            - user_id: str.

            - provider: typing.Optional[str]. Provider oura/strava etc

            - start_date: str. Date from in YYYY-MM-DD or ISO formatted date time. If a date is provided without a time, the time will be set to 00:00:00

            - end_date: typing.Optional[str]. Date to YYYY-MM-DD or ISO formatted date time. If a date is provided without a time, the time will be set to 23:59:59
        ---
        from vital.client import AsyncVital

        client = AsyncVital(
            api_key="YOUR_API_KEY",
        )
        await client.cholesterol(
            user_id="user-id",
            start_date="start-date",
        )
        """
        _response = await self._client_wrapper.httpx_client.request(
            "GET",
            urllib.parse.urljoin(f"{self._client_wrapper.get_base_url()}/", f"v2/timeseries/{user_id}/cholesterol"),
            params=remove_none_from_dict({"provider": provider, "start_date": start_date, "end_date": end_date}),
            headers=self._client_wrapper.get_headers(),
            timeout=60,
        )
        if 200 <= _response.status_code < 300:
            return pydantic.parse_obj_as(typing.List[ClientFacingCholesterolTimeseries], _response.json())  # type: ignore
        if _response.status_code == 422:
            raise UnprocessableEntityError(pydantic.parse_obj_as(HttpValidationError, _response.json()))  # type: ignore
        try:
            _response_json = _response.json()
        except JSONDecodeError:
            raise ApiError(status_code=_response.status_code, body=_response.text)
        raise ApiError(status_code=_response.status_code, body=_response_json)

    async def blood_oxygen(
        self,
        user_id: str,
        *,
        provider: typing.Optional[str] = None,
        start_date: str,
        end_date: typing.Optional[str] = None,
    ) -> typing.List[ClientFacingBloodOxygenTimeseries]:
        """
        Get timeseries data for user

        Parameters:
            - user_id: str.

            - provider: typing.Optional[str]. Provider oura/strava etc

            - start_date: str. Date from in YYYY-MM-DD or ISO formatted date time. If a date is provided without a time, the time will be set to 00:00:00

            - end_date: typing.Optional[str]. Date to YYYY-MM-DD or ISO formatted date time. If a date is provided without a time, the time will be set to 23:59:59
        ---
        from vital.client import AsyncVital

        client = AsyncVital(
            api_key="YOUR_API_KEY",
        )
        await client.blood_oxygen(
            user_id="user-id",
            start_date="start-date",
        )
        """
        _response = await self._client_wrapper.httpx_client.request(
            "GET",
            urllib.parse.urljoin(f"{self._client_wrapper.get_base_url()}/", f"v2/timeseries/{user_id}/blood_oxygen"),
            params=remove_none_from_dict({"provider": provider, "start_date": start_date, "end_date": end_date}),
            headers=self._client_wrapper.get_headers(),
            timeout=60,
        )
        if 200 <= _response.status_code < 300:
            return pydantic.parse_obj_as(typing.List[ClientFacingBloodOxygenTimeseries], _response.json())  # type: ignore
        if _response.status_code == 422:
            raise UnprocessableEntityError(pydantic.parse_obj_as(HttpValidationError, _response.json()))  # type: ignore
        try:
            _response_json = _response.json()
        except JSONDecodeError:
            raise ApiError(status_code=_response.status_code, body=_response.text)
        raise ApiError(status_code=_response.status_code, body=_response_json)

    async def blood_pressure(
        self,
        user_id: str,
        *,
        provider: typing.Optional[str] = None,
        start_date: str,
        end_date: typing.Optional[str] = None,
    ) -> typing.List[ClientFacingBloodPressureTimeseries]:
        """
        Get timeseries data for user

        Parameters:
            - user_id: str.

            - provider: typing.Optional[str]. Provider oura/strava etc

            - start_date: str. Date from in YYYY-MM-DD or ISO formatted date time. If a date is provided without a time, the time will be set to 00:00:00

            - end_date: typing.Optional[str]. Date to YYYY-MM-DD or ISO formatted date time. If a date is provided without a time, the time will be set to 23:59:59
        ---
        from vital.client import AsyncVital

        client = AsyncVital(
            api_key="YOUR_API_KEY",
        )
        await client.blood_pressure(
            user_id="user-id",
            start_date="start-date",
        )
        """
        _response = await self._client_wrapper.httpx_client.request(
            "GET",
            urllib.parse.urljoin(f"{self._client_wrapper.get_base_url()}/", f"v2/timeseries/{user_id}/blood_pressure"),
            params=remove_none_from_dict({"provider": provider, "start_date": start_date, "end_date": end_date}),
            headers=self._client_wrapper.get_headers(),
            timeout=60,
        )
        if 200 <= _response.status_code < 300:
            return pydantic.parse_obj_as(typing.List[ClientFacingBloodPressureTimeseries], _response.json())  # type: ignore
        if _response.status_code == 422:
            raise UnprocessableEntityError(pydantic.parse_obj_as(HttpValidationError, _response.json()))  # type: ignore
        try:
            _response_json = _response.json()
        except JSONDecodeError:
            raise ApiError(status_code=_response.status_code, body=_response.text)
        raise ApiError(status_code=_response.status_code, body=_response_json)
