# 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_body_fat_timeseries import ClientFacingBodyFatTimeseries
from ...types.client_facing_body_weight_timeseries import ClientFacingBodyWeightTimeseries
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_electrocardiogram_voltage_timeseries import ClientFacingElectrocardiogramVoltageTimeseries
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_stress_level_timeseries import ClientFacingStressLevelTimeseries
from ...types.client_facing_vo_2_max_timeseries import ClientFacingVo2MaxTimeseries
from ...types.client_facing_water_timeseries import ClientFacingWaterTimeseries
from ...types.grouped_blood_oxygen_response import GroupedBloodOxygenResponse
from ...types.grouped_blood_pressure_response import GroupedBloodPressureResponse
from ...types.grouped_body_fat_response import GroupedBodyFatResponse
from ...types.grouped_body_weight_response import GroupedBodyWeightResponse
from ...types.grouped_caffeine_response import GroupedCaffeineResponse
from ...types.grouped_calories_active_response import GroupedCaloriesActiveResponse
from ...types.grouped_calories_basal_response import GroupedCaloriesBasalResponse
from ...types.grouped_cholesterol_response import GroupedCholesterolResponse
from ...types.grouped_distance_response import GroupedDistanceResponse
from ...types.grouped_electrocardiogram_voltage_response import GroupedElectrocardiogramVoltageResponse
from ...types.grouped_floors_climbed_response import GroupedFloorsClimbedResponse
from ...types.grouped_glucose_response import GroupedGlucoseResponse
from ...types.grouped_heart_rate_response import GroupedHeartRateResponse
from ...types.grouped_hrv_response import GroupedHrvResponse
from ...types.grouped_hypnogram_response import GroupedHypnogramResponse
from ...types.grouped_ige_response import GroupedIgeResponse
from ...types.grouped_igg_response import GroupedIggResponse
from ...types.grouped_mindfulness_minutes_response import GroupedMindfulnessMinutesResponse
from ...types.grouped_respiratory_rate_response import GroupedRespiratoryRateResponse
from ...types.grouped_steps_response import GroupedStepsResponse
from ...types.grouped_stress_level_response import GroupedStressLevelResponse
from ...types.grouped_vo_2_max_response import GroupedVo2MaxResponse
from ...types.grouped_water_response import GroupedWaterResponse
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 vo_2_max_grouped(
        self,
        user_id: str,
        *,
        cursor: typing.Optional[str] = None,
        provider: typing.Optional[str] = None,
        start_date: str,
        end_date: typing.Optional[str] = None,
    ) -> GroupedVo2MaxResponse:
        """
        Parameters:
            - user_id: str.

            - cursor: typing.Optional[str]. The cursor for fetching the next page, or `null` to fetch the first page.

            - 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.vitals.vo_2_max_grouped(
            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}/vo2_max/grouped"),
            params=remove_none_from_dict(
                {"cursor": cursor, "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(GroupedVo2MaxResponse, _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 stress_level_grouped(
        self,
        user_id: str,
        *,
        cursor: typing.Optional[str] = None,
        provider: typing.Optional[str] = None,
        start_date: str,
        end_date: typing.Optional[str] = None,
    ) -> GroupedStressLevelResponse:
        """
        Parameters:
            - user_id: str.

            - cursor: typing.Optional[str]. The cursor for fetching the next page, or `null` to fetch the first page.

            - 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.vitals.stress_level_grouped(
            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}/stress_level/grouped"
            ),
            params=remove_none_from_dict(
                {"cursor": cursor, "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(GroupedStressLevelResponse, _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 mindfulness_minutes_grouped(
        self,
        user_id: str,
        *,
        cursor: typing.Optional[str] = None,
        provider: typing.Optional[str] = None,
        start_date: str,
        end_date: typing.Optional[str] = None,
    ) -> GroupedMindfulnessMinutesResponse:
        """
        Parameters:
            - user_id: str.

            - cursor: typing.Optional[str]. The cursor for fetching the next page, or `null` to fetch the first page.

            - 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.vitals.mindfulness_minutes_grouped(
            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/grouped"
            ),
            params=remove_none_from_dict(
                {"cursor": cursor, "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(GroupedMindfulnessMinutesResponse, _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_grouped(
        self,
        user_id: str,
        *,
        cursor: typing.Optional[str] = None,
        provider: typing.Optional[str] = None,
        start_date: str,
        end_date: typing.Optional[str] = None,
    ) -> GroupedCaffeineResponse:
        """
        Parameters:
            - user_id: str.

            - cursor: typing.Optional[str]. The cursor for fetching the next page, or `null` to fetch the first page.

            - 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.vitals.caffeine_grouped(
            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/grouped"
            ),
            params=remove_none_from_dict(
                {"cursor": cursor, "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(GroupedCaffeineResponse, _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_grouped(
        self,
        user_id: str,
        *,
        cursor: typing.Optional[str] = None,
        provider: typing.Optional[str] = None,
        start_date: str,
        end_date: typing.Optional[str] = None,
    ) -> GroupedWaterResponse:
        """
        Parameters:
            - user_id: str.

            - cursor: typing.Optional[str]. The cursor for fetching the next page, or `null` to fetch the first page.

            - 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.vitals.water_grouped(
            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/grouped"),
            params=remove_none_from_dict(
                {"cursor": cursor, "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(GroupedWaterResponse, _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_grouped(
        self,
        user_id: str,
        *,
        cursor: typing.Optional[str] = None,
        provider: typing.Optional[str] = None,
        start_date: str,
        end_date: typing.Optional[str] = None,
    ) -> GroupedStepsResponse:
        """
        Parameters:
            - user_id: str.

            - cursor: typing.Optional[str]. The cursor for fetching the next page, or `null` to fetch the first page.

            - 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.vitals.steps_grouped(
            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/grouped"),
            params=remove_none_from_dict(
                {"cursor": cursor, "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(GroupedStepsResponse, _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_grouped(
        self,
        user_id: str,
        *,
        cursor: typing.Optional[str] = None,
        provider: typing.Optional[str] = None,
        start_date: str,
        end_date: typing.Optional[str] = None,
    ) -> GroupedFloorsClimbedResponse:
        """
        Parameters:
            - user_id: str.

            - cursor: typing.Optional[str]. The cursor for fetching the next page, or `null` to fetch the first page.

            - 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.vitals.floors_climbed_grouped(
            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/grouped"
            ),
            params=remove_none_from_dict(
                {"cursor": cursor, "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(GroupedFloorsClimbedResponse, _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_grouped(
        self,
        user_id: str,
        *,
        cursor: typing.Optional[str] = None,
        provider: typing.Optional[str] = None,
        start_date: str,
        end_date: typing.Optional[str] = None,
    ) -> GroupedDistanceResponse:
        """
        Parameters:
            - user_id: str.

            - cursor: typing.Optional[str]. The cursor for fetching the next page, or `null` to fetch the first page.

            - 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.vitals.distance_grouped(
            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/grouped"
            ),
            params=remove_none_from_dict(
                {"cursor": cursor, "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(GroupedDistanceResponse, _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_grouped(
        self,
        user_id: str,
        *,
        cursor: typing.Optional[str] = None,
        provider: typing.Optional[str] = None,
        start_date: str,
        end_date: typing.Optional[str] = None,
    ) -> GroupedCaloriesBasalResponse:
        """
        Parameters:
            - user_id: str.

            - cursor: typing.Optional[str]. The cursor for fetching the next page, or `null` to fetch the first page.

            - 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.vitals.calories_basal_grouped(
            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/grouped"
            ),
            params=remove_none_from_dict(
                {"cursor": cursor, "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(GroupedCaloriesBasalResponse, _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_grouped(
        self,
        user_id: str,
        *,
        cursor: typing.Optional[str] = None,
        provider: typing.Optional[str] = None,
        start_date: str,
        end_date: typing.Optional[str] = None,
    ) -> GroupedCaloriesActiveResponse:
        """
        Parameters:
            - user_id: str.

            - cursor: typing.Optional[str]. The cursor for fetching the next page, or `null` to fetch the first page.

            - 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.vitals.calories_active_grouped(
            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/grouped"
            ),
            params=remove_none_from_dict(
                {"cursor": cursor, "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(GroupedCaloriesActiveResponse, _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_grouped(
        self,
        user_id: str,
        *,
        cursor: typing.Optional[str] = None,
        provider: typing.Optional[str] = None,
        start_date: str,
        end_date: typing.Optional[str] = None,
    ) -> GroupedRespiratoryRateResponse:
        """
        Parameters:
            - user_id: str.

            - cursor: typing.Optional[str]. The cursor for fetching the next page, or `null` to fetch the first page.

            - 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.vitals.respiratory_rate_grouped(
            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/grouped"
            ),
            params=remove_none_from_dict(
                {"cursor": cursor, "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(GroupedRespiratoryRateResponse, _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_grouped(
        self,
        user_id: str,
        *,
        cursor: typing.Optional[str] = None,
        provider: typing.Optional[str] = None,
        start_date: str,
        end_date: typing.Optional[str] = None,
    ) -> GroupedIgeResponse:
        """
        Parameters:
            - user_id: str.

            - cursor: typing.Optional[str]. The cursor for fetching the next page, or `null` to fetch the first page.

            - 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.vitals.ige_grouped(
            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/grouped"),
            params=remove_none_from_dict(
                {"cursor": cursor, "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(GroupedIgeResponse, _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_grouped(
        self,
        user_id: str,
        *,
        cursor: typing.Optional[str] = None,
        provider: typing.Optional[str] = None,
        start_date: str,
        end_date: typing.Optional[str] = None,
    ) -> GroupedIggResponse:
        """
        Parameters:
            - user_id: str.

            - cursor: typing.Optional[str]. The cursor for fetching the next page, or `null` to fetch the first page.

            - 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.vitals.igg_grouped(
            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/grouped"),
            params=remove_none_from_dict(
                {"cursor": cursor, "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(GroupedIggResponse, _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_grouped(
        self,
        user_id: str,
        *,
        cursor: typing.Optional[str] = None,
        provider: typing.Optional[str] = None,
        start_date: str,
        end_date: typing.Optional[str] = None,
    ) -> GroupedHypnogramResponse:
        """
        Parameters:
            - user_id: str.

            - cursor: typing.Optional[str]. The cursor for fetching the next page, or `null` to fetch the first page.

            - 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.vitals.hypnogram_grouped(
            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/grouped"
            ),
            params=remove_none_from_dict(
                {"cursor": cursor, "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(GroupedHypnogramResponse, _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_grouped(
        self,
        user_id: str,
        *,
        cursor: typing.Optional[str] = None,
        provider: typing.Optional[str] = None,
        start_date: str,
        end_date: typing.Optional[str] = None,
    ) -> GroupedHrvResponse:
        """
        Parameters:
            - user_id: str.

            - cursor: typing.Optional[str]. The cursor for fetching the next page, or `null` to fetch the first page.

            - 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.vitals.hrv_grouped(
            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/grouped"),
            params=remove_none_from_dict(
                {"cursor": cursor, "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(GroupedHrvResponse, _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_grouped(
        self,
        user_id: str,
        *,
        cursor: typing.Optional[str] = None,
        provider: typing.Optional[str] = None,
        start_date: str,
        end_date: typing.Optional[str] = None,
    ) -> GroupedHeartRateResponse:
        """
        Parameters:
            - user_id: str.

            - cursor: typing.Optional[str]. The cursor for fetching the next page, or `null` to fetch the first page.

            - 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.vitals.heartrate_grouped(
            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/grouped"
            ),
            params=remove_none_from_dict(
                {"cursor": cursor, "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(GroupedHeartRateResponse, _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_grouped(
        self,
        user_id: str,
        *,
        cursor: typing.Optional[str] = None,
        provider: typing.Optional[str] = None,
        start_date: str,
        end_date: typing.Optional[str] = None,
    ) -> GroupedGlucoseResponse:
        """
        Parameters:
            - user_id: str.

            - cursor: typing.Optional[str]. The cursor for fetching the next page, or `null` to fetch the first page.

            - 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.vitals.glucose_grouped(
            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/grouped"),
            params=remove_none_from_dict(
                {"cursor": cursor, "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(GroupedGlucoseResponse, _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_grouped(
        self,
        user_id: str,
        *,
        cursor: typing.Optional[str] = None,
        provider: typing.Optional[str] = None,
        start_date: str,
        end_date: typing.Optional[str] = None,
    ) -> GroupedCholesterolResponse:
        """
        Parameters:
            - user_id: str.

            - cursor: typing.Optional[str]. The cursor for fetching the next page, or `null` to fetch the first page.

            - 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.vitals.cholesterol_grouped(
            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/grouped"
            ),
            params=remove_none_from_dict(
                {"cursor": cursor, "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(GroupedCholesterolResponse, _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 body_weight_grouped(
        self,
        user_id: str,
        *,
        cursor: typing.Optional[str] = None,
        provider: typing.Optional[str] = None,
        start_date: str,
        end_date: typing.Optional[str] = None,
    ) -> GroupedBodyWeightResponse:
        """
        Parameters:
            - user_id: str.

            - cursor: typing.Optional[str]. The cursor for fetching the next page, or `null` to fetch the first page.

            - 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.vitals.body_weight_grouped(
            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}/body_weight/grouped"
            ),
            params=remove_none_from_dict(
                {"cursor": cursor, "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(GroupedBodyWeightResponse, _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 body_fat_grouped(
        self,
        user_id: str,
        *,
        cursor: typing.Optional[str] = None,
        provider: typing.Optional[str] = None,
        start_date: str,
        end_date: typing.Optional[str] = None,
    ) -> GroupedBodyFatResponse:
        """
        Parameters:
            - user_id: str.

            - cursor: typing.Optional[str]. The cursor for fetching the next page, or `null` to fetch the first page.

            - 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.vitals.body_fat_grouped(
            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}/body_fat/grouped"
            ),
            params=remove_none_from_dict(
                {"cursor": cursor, "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(GroupedBodyFatResponse, _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_grouped(
        self,
        user_id: str,
        *,
        cursor: typing.Optional[str] = None,
        provider: typing.Optional[str] = None,
        start_date: str,
        end_date: typing.Optional[str] = None,
    ) -> GroupedBloodOxygenResponse:
        """
        Parameters:
            - user_id: str.

            - cursor: typing.Optional[str]. The cursor for fetching the next page, or `null` to fetch the first page.

            - 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.vitals.blood_oxygen_grouped(
            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/grouped"
            ),
            params=remove_none_from_dict(
                {"cursor": cursor, "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(GroupedBloodOxygenResponse, _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 electrocardiogram_voltage_grouped(
        self,
        user_id: str,
        *,
        cursor: typing.Optional[str] = None,
        provider: typing.Optional[str] = None,
        start_date: str,
        end_date: typing.Optional[str] = None,
    ) -> GroupedElectrocardiogramVoltageResponse:
        """
        Parameters:
            - user_id: str.

            - cursor: typing.Optional[str]. The cursor for fetching the next page, or `null` to fetch the first page.

            - 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.vitals.electrocardiogram_voltage_grouped(
            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}/electrocardiogram_voltage/grouped"
            ),
            params=remove_none_from_dict(
                {"cursor": cursor, "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(GroupedElectrocardiogramVoltageResponse, _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_grouped(
        self,
        user_id: str,
        *,
        cursor: typing.Optional[str] = None,
        provider: typing.Optional[str] = None,
        start_date: str,
        end_date: typing.Optional[str] = None,
    ) -> GroupedBloodPressureResponse:
        """
        Parameters:
            - user_id: str.

            - cursor: typing.Optional[str]. The cursor for fetching the next page, or `null` to fetch the first page.

            - 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.vitals.blood_pressure_grouped(
            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/grouped"
            ),
            params=remove_none_from_dict(
                {"cursor": cursor, "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(GroupedBloodPressureResponse, _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 vo_2_max(
        self,
        user_id: str,
        *,
        provider: typing.Optional[str] = None,
        start_date: str,
        end_date: typing.Optional[str] = None,
    ) -> typing.List[ClientFacingVo2MaxTimeseries]:
        """
        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.vitals.vo_2_max(
            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}/vo2_max"),
            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[ClientFacingVo2MaxTimeseries], _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 stress_level(
        self,
        user_id: str,
        *,
        provider: typing.Optional[str] = None,
        start_date: str,
        end_date: typing.Optional[str] = None,
    ) -> typing.List[ClientFacingStressLevelTimeseries]:
        """
        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.vitals.stress_level(
            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}/stress_level"),
            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[ClientFacingStressLevelTimeseries], _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 mindfulness_minutes(
        self,
        user_id: str,
        *,
        provider: typing.Optional[str] = None,
        start_date: str,
        end_date: typing.Optional[str] = None,
    ) -> typing.List[ClientFacingMindfulnessMinutesTimeseries]:
        """
        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.vitals.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]:
        """
        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.vitals.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]:
        """
        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.vitals.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]:
        """
        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.vitals.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]:
        """
        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.vitals.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]:
        """
        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.vitals.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]:
        """
        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.vitals.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]:
        """
        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.vitals.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]:
        """
        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.vitals.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]:
        """
        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.vitals.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]:
        """
        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.vitals.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]:
        """
        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.vitals.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]:
        """
        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.vitals.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]:
        """
        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.vitals.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]:
        """
        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.vitals.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 cholesterol_triglycerides(
        self,
        user_id: str,
        *,
        provider: typing.Optional[str] = None,
        start_date: str,
        end_date: typing.Optional[str] = None,
    ) -> typing.List[ClientFacingCholesterolTimeseries]:
        """
        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.vitals.cholesterol_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]:
        """
        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.vitals.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_ldl(
        self,
        user_id: str,
        *,
        provider: typing.Optional[str] = None,
        start_date: str,
        end_date: typing.Optional[str] = None,
    ) -> typing.List[ClientFacingCholesterolTimeseries]:
        """
        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.vitals.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_hdl(
        self,
        user_id: str,
        *,
        provider: typing.Optional[str] = None,
        start_date: str,
        end_date: typing.Optional[str] = None,
    ) -> typing.List[ClientFacingCholesterolTimeseries]:
        """
        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.vitals.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(
        self,
        user_id: str,
        *,
        provider: typing.Optional[str] = None,
        start_date: str,
        end_date: typing.Optional[str] = None,
    ) -> typing.List[ClientFacingCholesterolTimeseries]:
        """
        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.vitals.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 body_weight(
        self,
        user_id: str,
        *,
        provider: typing.Optional[str] = None,
        start_date: str,
        end_date: typing.Optional[str] = None,
    ) -> typing.List[ClientFacingBodyWeightTimeseries]:
        """
        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.vitals.body_weight(
            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}/body_weight"),
            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[ClientFacingBodyWeightTimeseries], _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 body_fat(
        self,
        user_id: str,
        *,
        provider: typing.Optional[str] = None,
        start_date: str,
        end_date: typing.Optional[str] = None,
    ) -> typing.List[ClientFacingBodyFatTimeseries]:
        """
        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.vitals.body_fat(
            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}/body_fat"),
            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[ClientFacingBodyFatTimeseries], _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]:
        """
        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.vitals.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 electrocardiogram_voltage(
        self,
        user_id: str,
        *,
        provider: typing.Optional[str] = None,
        start_date: str,
        end_date: typing.Optional[str] = None,
    ) -> typing.List[ClientFacingElectrocardiogramVoltageTimeseries]:
        """
        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.vitals.electrocardiogram_voltage(
            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}/electrocardiogram_voltage"
            ),
            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[ClientFacingElectrocardiogramVoltageTimeseries], _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]:
        """
        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.vitals.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 vo_2_max_grouped(
        self,
        user_id: str,
        *,
        cursor: typing.Optional[str] = None,
        provider: typing.Optional[str] = None,
        start_date: str,
        end_date: typing.Optional[str] = None,
    ) -> GroupedVo2MaxResponse:
        """
        Parameters:
            - user_id: str.

            - cursor: typing.Optional[str]. The cursor for fetching the next page, or `null` to fetch the first page.

            - 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.vitals.vo_2_max_grouped(
            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}/vo2_max/grouped"),
            params=remove_none_from_dict(
                {"cursor": cursor, "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(GroupedVo2MaxResponse, _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 stress_level_grouped(
        self,
        user_id: str,
        *,
        cursor: typing.Optional[str] = None,
        provider: typing.Optional[str] = None,
        start_date: str,
        end_date: typing.Optional[str] = None,
    ) -> GroupedStressLevelResponse:
        """
        Parameters:
            - user_id: str.

            - cursor: typing.Optional[str]. The cursor for fetching the next page, or `null` to fetch the first page.

            - 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.vitals.stress_level_grouped(
            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}/stress_level/grouped"
            ),
            params=remove_none_from_dict(
                {"cursor": cursor, "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(GroupedStressLevelResponse, _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 mindfulness_minutes_grouped(
        self,
        user_id: str,
        *,
        cursor: typing.Optional[str] = None,
        provider: typing.Optional[str] = None,
        start_date: str,
        end_date: typing.Optional[str] = None,
    ) -> GroupedMindfulnessMinutesResponse:
        """
        Parameters:
            - user_id: str.

            - cursor: typing.Optional[str]. The cursor for fetching the next page, or `null` to fetch the first page.

            - 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.vitals.mindfulness_minutes_grouped(
            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/grouped"
            ),
            params=remove_none_from_dict(
                {"cursor": cursor, "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(GroupedMindfulnessMinutesResponse, _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_grouped(
        self,
        user_id: str,
        *,
        cursor: typing.Optional[str] = None,
        provider: typing.Optional[str] = None,
        start_date: str,
        end_date: typing.Optional[str] = None,
    ) -> GroupedCaffeineResponse:
        """
        Parameters:
            - user_id: str.

            - cursor: typing.Optional[str]. The cursor for fetching the next page, or `null` to fetch the first page.

            - 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.vitals.caffeine_grouped(
            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/grouped"
            ),
            params=remove_none_from_dict(
                {"cursor": cursor, "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(GroupedCaffeineResponse, _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_grouped(
        self,
        user_id: str,
        *,
        cursor: typing.Optional[str] = None,
        provider: typing.Optional[str] = None,
        start_date: str,
        end_date: typing.Optional[str] = None,
    ) -> GroupedWaterResponse:
        """
        Parameters:
            - user_id: str.

            - cursor: typing.Optional[str]. The cursor for fetching the next page, or `null` to fetch the first page.

            - 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.vitals.water_grouped(
            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/grouped"),
            params=remove_none_from_dict(
                {"cursor": cursor, "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(GroupedWaterResponse, _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_grouped(
        self,
        user_id: str,
        *,
        cursor: typing.Optional[str] = None,
        provider: typing.Optional[str] = None,
        start_date: str,
        end_date: typing.Optional[str] = None,
    ) -> GroupedStepsResponse:
        """
        Parameters:
            - user_id: str.

            - cursor: typing.Optional[str]. The cursor for fetching the next page, or `null` to fetch the first page.

            - 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.vitals.steps_grouped(
            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/grouped"),
            params=remove_none_from_dict(
                {"cursor": cursor, "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(GroupedStepsResponse, _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_grouped(
        self,
        user_id: str,
        *,
        cursor: typing.Optional[str] = None,
        provider: typing.Optional[str] = None,
        start_date: str,
        end_date: typing.Optional[str] = None,
    ) -> GroupedFloorsClimbedResponse:
        """
        Parameters:
            - user_id: str.

            - cursor: typing.Optional[str]. The cursor for fetching the next page, or `null` to fetch the first page.

            - 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.vitals.floors_climbed_grouped(
            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/grouped"
            ),
            params=remove_none_from_dict(
                {"cursor": cursor, "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(GroupedFloorsClimbedResponse, _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_grouped(
        self,
        user_id: str,
        *,
        cursor: typing.Optional[str] = None,
        provider: typing.Optional[str] = None,
        start_date: str,
        end_date: typing.Optional[str] = None,
    ) -> GroupedDistanceResponse:
        """
        Parameters:
            - user_id: str.

            - cursor: typing.Optional[str]. The cursor for fetching the next page, or `null` to fetch the first page.

            - 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.vitals.distance_grouped(
            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/grouped"
            ),
            params=remove_none_from_dict(
                {"cursor": cursor, "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(GroupedDistanceResponse, _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_grouped(
        self,
        user_id: str,
        *,
        cursor: typing.Optional[str] = None,
        provider: typing.Optional[str] = None,
        start_date: str,
        end_date: typing.Optional[str] = None,
    ) -> GroupedCaloriesBasalResponse:
        """
        Parameters:
            - user_id: str.

            - cursor: typing.Optional[str]. The cursor for fetching the next page, or `null` to fetch the first page.

            - 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.vitals.calories_basal_grouped(
            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/grouped"
            ),
            params=remove_none_from_dict(
                {"cursor": cursor, "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(GroupedCaloriesBasalResponse, _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_grouped(
        self,
        user_id: str,
        *,
        cursor: typing.Optional[str] = None,
        provider: typing.Optional[str] = None,
        start_date: str,
        end_date: typing.Optional[str] = None,
    ) -> GroupedCaloriesActiveResponse:
        """
        Parameters:
            - user_id: str.

            - cursor: typing.Optional[str]. The cursor for fetching the next page, or `null` to fetch the first page.

            - 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.vitals.calories_active_grouped(
            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/grouped"
            ),
            params=remove_none_from_dict(
                {"cursor": cursor, "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(GroupedCaloriesActiveResponse, _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_grouped(
        self,
        user_id: str,
        *,
        cursor: typing.Optional[str] = None,
        provider: typing.Optional[str] = None,
        start_date: str,
        end_date: typing.Optional[str] = None,
    ) -> GroupedRespiratoryRateResponse:
        """
        Parameters:
            - user_id: str.

            - cursor: typing.Optional[str]. The cursor for fetching the next page, or `null` to fetch the first page.

            - 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.vitals.respiratory_rate_grouped(
            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/grouped"
            ),
            params=remove_none_from_dict(
                {"cursor": cursor, "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(GroupedRespiratoryRateResponse, _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_grouped(
        self,
        user_id: str,
        *,
        cursor: typing.Optional[str] = None,
        provider: typing.Optional[str] = None,
        start_date: str,
        end_date: typing.Optional[str] = None,
    ) -> GroupedIgeResponse:
        """
        Parameters:
            - user_id: str.

            - cursor: typing.Optional[str]. The cursor for fetching the next page, or `null` to fetch the first page.

            - 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.vitals.ige_grouped(
            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/grouped"),
            params=remove_none_from_dict(
                {"cursor": cursor, "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(GroupedIgeResponse, _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_grouped(
        self,
        user_id: str,
        *,
        cursor: typing.Optional[str] = None,
        provider: typing.Optional[str] = None,
        start_date: str,
        end_date: typing.Optional[str] = None,
    ) -> GroupedIggResponse:
        """
        Parameters:
            - user_id: str.

            - cursor: typing.Optional[str]. The cursor for fetching the next page, or `null` to fetch the first page.

            - 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.vitals.igg_grouped(
            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/grouped"),
            params=remove_none_from_dict(
                {"cursor": cursor, "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(GroupedIggResponse, _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_grouped(
        self,
        user_id: str,
        *,
        cursor: typing.Optional[str] = None,
        provider: typing.Optional[str] = None,
        start_date: str,
        end_date: typing.Optional[str] = None,
    ) -> GroupedHypnogramResponse:
        """
        Parameters:
            - user_id: str.

            - cursor: typing.Optional[str]. The cursor for fetching the next page, or `null` to fetch the first page.

            - 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.vitals.hypnogram_grouped(
            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/grouped"
            ),
            params=remove_none_from_dict(
                {"cursor": cursor, "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(GroupedHypnogramResponse, _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_grouped(
        self,
        user_id: str,
        *,
        cursor: typing.Optional[str] = None,
        provider: typing.Optional[str] = None,
        start_date: str,
        end_date: typing.Optional[str] = None,
    ) -> GroupedHrvResponse:
        """
        Parameters:
            - user_id: str.

            - cursor: typing.Optional[str]. The cursor for fetching the next page, or `null` to fetch the first page.

            - 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.vitals.hrv_grouped(
            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/grouped"),
            params=remove_none_from_dict(
                {"cursor": cursor, "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(GroupedHrvResponse, _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_grouped(
        self,
        user_id: str,
        *,
        cursor: typing.Optional[str] = None,
        provider: typing.Optional[str] = None,
        start_date: str,
        end_date: typing.Optional[str] = None,
    ) -> GroupedHeartRateResponse:
        """
        Parameters:
            - user_id: str.

            - cursor: typing.Optional[str]. The cursor for fetching the next page, or `null` to fetch the first page.

            - 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.vitals.heartrate_grouped(
            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/grouped"
            ),
            params=remove_none_from_dict(
                {"cursor": cursor, "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(GroupedHeartRateResponse, _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_grouped(
        self,
        user_id: str,
        *,
        cursor: typing.Optional[str] = None,
        provider: typing.Optional[str] = None,
        start_date: str,
        end_date: typing.Optional[str] = None,
    ) -> GroupedGlucoseResponse:
        """
        Parameters:
            - user_id: str.

            - cursor: typing.Optional[str]. The cursor for fetching the next page, or `null` to fetch the first page.

            - 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.vitals.glucose_grouped(
            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/grouped"),
            params=remove_none_from_dict(
                {"cursor": cursor, "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(GroupedGlucoseResponse, _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_grouped(
        self,
        user_id: str,
        *,
        cursor: typing.Optional[str] = None,
        provider: typing.Optional[str] = None,
        start_date: str,
        end_date: typing.Optional[str] = None,
    ) -> GroupedCholesterolResponse:
        """
        Parameters:
            - user_id: str.

            - cursor: typing.Optional[str]. The cursor for fetching the next page, or `null` to fetch the first page.

            - 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.vitals.cholesterol_grouped(
            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/grouped"
            ),
            params=remove_none_from_dict(
                {"cursor": cursor, "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(GroupedCholesterolResponse, _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 body_weight_grouped(
        self,
        user_id: str,
        *,
        cursor: typing.Optional[str] = None,
        provider: typing.Optional[str] = None,
        start_date: str,
        end_date: typing.Optional[str] = None,
    ) -> GroupedBodyWeightResponse:
        """
        Parameters:
            - user_id: str.

            - cursor: typing.Optional[str]. The cursor for fetching the next page, or `null` to fetch the first page.

            - 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.vitals.body_weight_grouped(
            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}/body_weight/grouped"
            ),
            params=remove_none_from_dict(
                {"cursor": cursor, "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(GroupedBodyWeightResponse, _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 body_fat_grouped(
        self,
        user_id: str,
        *,
        cursor: typing.Optional[str] = None,
        provider: typing.Optional[str] = None,
        start_date: str,
        end_date: typing.Optional[str] = None,
    ) -> GroupedBodyFatResponse:
        """
        Parameters:
            - user_id: str.

            - cursor: typing.Optional[str]. The cursor for fetching the next page, or `null` to fetch the first page.

            - 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.vitals.body_fat_grouped(
            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}/body_fat/grouped"
            ),
            params=remove_none_from_dict(
                {"cursor": cursor, "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(GroupedBodyFatResponse, _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_grouped(
        self,
        user_id: str,
        *,
        cursor: typing.Optional[str] = None,
        provider: typing.Optional[str] = None,
        start_date: str,
        end_date: typing.Optional[str] = None,
    ) -> GroupedBloodOxygenResponse:
        """
        Parameters:
            - user_id: str.

            - cursor: typing.Optional[str]. The cursor for fetching the next page, or `null` to fetch the first page.

            - 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.vitals.blood_oxygen_grouped(
            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/grouped"
            ),
            params=remove_none_from_dict(
                {"cursor": cursor, "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(GroupedBloodOxygenResponse, _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 electrocardiogram_voltage_grouped(
        self,
        user_id: str,
        *,
        cursor: typing.Optional[str] = None,
        provider: typing.Optional[str] = None,
        start_date: str,
        end_date: typing.Optional[str] = None,
    ) -> GroupedElectrocardiogramVoltageResponse:
        """
        Parameters:
            - user_id: str.

            - cursor: typing.Optional[str]. The cursor for fetching the next page, or `null` to fetch the first page.

            - 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.vitals.electrocardiogram_voltage_grouped(
            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}/electrocardiogram_voltage/grouped"
            ),
            params=remove_none_from_dict(
                {"cursor": cursor, "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(GroupedElectrocardiogramVoltageResponse, _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_grouped(
        self,
        user_id: str,
        *,
        cursor: typing.Optional[str] = None,
        provider: typing.Optional[str] = None,
        start_date: str,
        end_date: typing.Optional[str] = None,
    ) -> GroupedBloodPressureResponse:
        """
        Parameters:
            - user_id: str.

            - cursor: typing.Optional[str]. The cursor for fetching the next page, or `null` to fetch the first page.

            - 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.vitals.blood_pressure_grouped(
            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/grouped"
            ),
            params=remove_none_from_dict(
                {"cursor": cursor, "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(GroupedBloodPressureResponse, _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 vo_2_max(
        self,
        user_id: str,
        *,
        provider: typing.Optional[str] = None,
        start_date: str,
        end_date: typing.Optional[str] = None,
    ) -> typing.List[ClientFacingVo2MaxTimeseries]:
        """
        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.vitals.vo_2_max(
            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}/vo2_max"),
            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[ClientFacingVo2MaxTimeseries], _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 stress_level(
        self,
        user_id: str,
        *,
        provider: typing.Optional[str] = None,
        start_date: str,
        end_date: typing.Optional[str] = None,
    ) -> typing.List[ClientFacingStressLevelTimeseries]:
        """
        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.vitals.stress_level(
            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}/stress_level"),
            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[ClientFacingStressLevelTimeseries], _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 mindfulness_minutes(
        self,
        user_id: str,
        *,
        provider: typing.Optional[str] = None,
        start_date: str,
        end_date: typing.Optional[str] = None,
    ) -> typing.List[ClientFacingMindfulnessMinutesTimeseries]:
        """
        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.vitals.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]:
        """
        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.vitals.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]:
        """
        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.vitals.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]:
        """
        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.vitals.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]:
        """
        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.vitals.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]:
        """
        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.vitals.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]:
        """
        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.vitals.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]:
        """
        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.vitals.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]:
        """
        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.vitals.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]:
        """
        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.vitals.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]:
        """
        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.vitals.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]:
        """
        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.vitals.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]:
        """
        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.vitals.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]:
        """
        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.vitals.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]:
        """
        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.vitals.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 cholesterol_triglycerides(
        self,
        user_id: str,
        *,
        provider: typing.Optional[str] = None,
        start_date: str,
        end_date: typing.Optional[str] = None,
    ) -> typing.List[ClientFacingCholesterolTimeseries]:
        """
        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.vitals.cholesterol_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]:
        """
        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.vitals.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_ldl(
        self,
        user_id: str,
        *,
        provider: typing.Optional[str] = None,
        start_date: str,
        end_date: typing.Optional[str] = None,
    ) -> typing.List[ClientFacingCholesterolTimeseries]:
        """
        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.vitals.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_hdl(
        self,
        user_id: str,
        *,
        provider: typing.Optional[str] = None,
        start_date: str,
        end_date: typing.Optional[str] = None,
    ) -> typing.List[ClientFacingCholesterolTimeseries]:
        """
        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.vitals.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(
        self,
        user_id: str,
        *,
        provider: typing.Optional[str] = None,
        start_date: str,
        end_date: typing.Optional[str] = None,
    ) -> typing.List[ClientFacingCholesterolTimeseries]:
        """
        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.vitals.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 body_weight(
        self,
        user_id: str,
        *,
        provider: typing.Optional[str] = None,
        start_date: str,
        end_date: typing.Optional[str] = None,
    ) -> typing.List[ClientFacingBodyWeightTimeseries]:
        """
        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.vitals.body_weight(
            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}/body_weight"),
            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[ClientFacingBodyWeightTimeseries], _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 body_fat(
        self,
        user_id: str,
        *,
        provider: typing.Optional[str] = None,
        start_date: str,
        end_date: typing.Optional[str] = None,
    ) -> typing.List[ClientFacingBodyFatTimeseries]:
        """
        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.vitals.body_fat(
            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}/body_fat"),
            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[ClientFacingBodyFatTimeseries], _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]:
        """
        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.vitals.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 electrocardiogram_voltage(
        self,
        user_id: str,
        *,
        provider: typing.Optional[str] = None,
        start_date: str,
        end_date: typing.Optional[str] = None,
    ) -> typing.List[ClientFacingElectrocardiogramVoltageTimeseries]:
        """
        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.vitals.electrocardiogram_voltage(
            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}/electrocardiogram_voltage"
            ),
            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[ClientFacingElectrocardiogramVoltageTimeseries], _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]:
        """
        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.vitals.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)
