@tryvital/vital-node 3.1.500 → 3.1.501

package/dist/api/resources/vitals/client/Client.d.ts

@@ -23,1018 +23,1276 @@ export declare class Vitals {
     constructor(_options?: Vitals.Options);
     /**
      * @param {string} userId
-     * @param {Vital.WorkoutSwimmingStrokeGroupedVitalsRequest} request
+     * @param {Vital.VitalsWorkoutSwimmingStrokeGroupedRequest} request
      * @param {Vitals.RequestOptions} requestOptions - Request-specific configuration.
      *
      * @throws {@link Vital.UnprocessableEntityError}
      *
      * @example
      *     await client.vitals.workoutSwimmingStrokeGrouped("user_id", {
-     *         startDate: "start_date"
+     *         cursor: "cursor",
+     *         nextCursor: "next_cursor",
+     *         provider: "provider",
+     *         startDate: "start_date",
+     *         endDate: "end_date"
      *     })
      */
-    workoutSwimmingStrokeGrouped(userId: string, request: Vital.WorkoutSwimmingStrokeGroupedVitalsRequest, requestOptions?: Vitals.RequestOptions): Promise<Vital.GroupedWorkoutSwimmingStrokeResponse>;
+    workoutSwimmingStrokeGrouped(userId: string, request: Vital.VitalsWorkoutSwimmingStrokeGroupedRequest, requestOptions?: Vitals.RequestOptions): Promise<Vital.GroupedWorkoutSwimmingStrokeResponse>;
     /**
      * @param {string} userId
-     * @param {Vital.WorkoutDistanceGroupedVitalsRequest} request
+     * @param {Vital.VitalsWorkoutDistanceGroupedRequest} request
      * @param {Vitals.RequestOptions} requestOptions - Request-specific configuration.
      *
      * @throws {@link Vital.UnprocessableEntityError}
      *
      * @example
      *     await client.vitals.workoutDistanceGrouped("user_id", {
-     *         startDate: "start_date"
+     *         cursor: "cursor",
+     *         nextCursor: "next_cursor",
+     *         provider: "provider",
+     *         startDate: "start_date",
+     *         endDate: "end_date"
      *     })
      */
-    workoutDistanceGrouped(userId: string, request: Vital.WorkoutDistanceGroupedVitalsRequest, requestOptions?: Vitals.RequestOptions): Promise<Vital.GroupedWorkoutDistanceResponse>;
+    workoutDistanceGrouped(userId: string, request: Vital.VitalsWorkoutDistanceGroupedRequest, requestOptions?: Vitals.RequestOptions): Promise<Vital.GroupedWorkoutDistanceResponse>;
     /**
      * @param {string} userId
-     * @param {Vital.HeartRateRecoveryOneMinuteGroupedVitalsRequest} request
+     * @param {Vital.VitalsHeartRateRecoveryOneMinuteGroupedRequest} request
      * @param {Vitals.RequestOptions} requestOptions - Request-specific configuration.
      *
      * @throws {@link Vital.UnprocessableEntityError}
      *
      * @example
      *     await client.vitals.heartRateRecoveryOneMinuteGrouped("user_id", {
-     *         startDate: "start_date"
+     *         cursor: "cursor",
+     *         nextCursor: "next_cursor",
+     *         provider: "provider",
+     *         startDate: "start_date",
+     *         endDate: "end_date"
      *     })
      */
-    heartRateRecoveryOneMinuteGrouped(userId: string, request: Vital.HeartRateRecoveryOneMinuteGroupedVitalsRequest, requestOptions?: Vitals.RequestOptions): Promise<Vital.GroupedHeartRateRecoveryOneMinuteResponse>;
+    heartRateRecoveryOneMinuteGrouped(userId: string, request: Vital.VitalsHeartRateRecoveryOneMinuteGroupedRequest, requestOptions?: Vitals.RequestOptions): Promise<Vital.GroupedHeartRateRecoveryOneMinuteResponse>;
     /**
      * @param {string} userId
-     * @param {Vital.WaistCircumferenceGroupedVitalsRequest} request
+     * @param {Vital.VitalsWaistCircumferenceGroupedRequest} request
      * @param {Vitals.RequestOptions} requestOptions - Request-specific configuration.
      *
      * @throws {@link Vital.UnprocessableEntityError}
      *
      * @example
      *     await client.vitals.waistCircumferenceGrouped("user_id", {
-     *         startDate: "start_date"
+     *         cursor: "cursor",
+     *         nextCursor: "next_cursor",
+     *         provider: "provider",
+     *         startDate: "start_date",
+     *         endDate: "end_date"
      *     })
      */
-    waistCircumferenceGrouped(userId: string, request: Vital.WaistCircumferenceGroupedVitalsRequest, requestOptions?: Vitals.RequestOptions): Promise<Vital.GroupedWaistCircumferenceResponse>;
+    waistCircumferenceGrouped(userId: string, request: Vital.VitalsWaistCircumferenceGroupedRequest, requestOptions?: Vitals.RequestOptions): Promise<Vital.GroupedWaistCircumferenceResponse>;
     /**
      * @param {string} userId
-     * @param {Vital.LeanBodyMassGroupedVitalsRequest} request
+     * @param {Vital.VitalsLeanBodyMassGroupedRequest} request
      * @param {Vitals.RequestOptions} requestOptions - Request-specific configuration.
      *
      * @throws {@link Vital.UnprocessableEntityError}
      *
      * @example
      *     await client.vitals.leanBodyMassGrouped("user_id", {
-     *         startDate: "start_date"
+     *         cursor: "cursor",
+     *         nextCursor: "next_cursor",
+     *         provider: "provider",
+     *         startDate: "start_date",
+     *         endDate: "end_date"
      *     })
      */
-    leanBodyMassGrouped(userId: string, request: Vital.LeanBodyMassGroupedVitalsRequest, requestOptions?: Vitals.RequestOptions): Promise<Vital.GroupedLeanBodyMassResponse>;
+    leanBodyMassGrouped(userId: string, request: Vital.VitalsLeanBodyMassGroupedRequest, requestOptions?: Vitals.RequestOptions): Promise<Vital.GroupedLeanBodyMassResponse>;
     /**
      * @param {string} userId
-     * @param {Vital.BodyMassIndexGroupedVitalsRequest} request
+     * @param {Vital.VitalsBodyMassIndexGroupedRequest} request
      * @param {Vitals.RequestOptions} requestOptions - Request-specific configuration.
      *
      * @throws {@link Vital.UnprocessableEntityError}
      *
      * @example
      *     await client.vitals.bodyMassIndexGrouped("user_id", {
-     *         startDate: "start_date"
+     *         cursor: "cursor",
+     *         nextCursor: "next_cursor",
+     *         provider: "provider",
+     *         startDate: "start_date",
+     *         endDate: "end_date"
      *     })
      */
-    bodyMassIndexGrouped(userId: string, request: Vital.BodyMassIndexGroupedVitalsRequest, requestOptions?: Vitals.RequestOptions): Promise<Vital.GroupedBodyMassIndexResponse>;
+    bodyMassIndexGrouped(userId: string, request: Vital.VitalsBodyMassIndexGroupedRequest, requestOptions?: Vitals.RequestOptions): Promise<Vital.GroupedBodyMassIndexResponse>;
     /**
      * @param {string} userId
-     * @param {Vital.BasalBodyTemperatureGroupedVitalsRequest} request
+     * @param {Vital.VitalsBasalBodyTemperatureGroupedRequest} request
      * @param {Vitals.RequestOptions} requestOptions - Request-specific configuration.
      *
      * @throws {@link Vital.UnprocessableEntityError}
      *
      * @example
      *     await client.vitals.basalBodyTemperatureGrouped("user_id", {
-     *         startDate: "start_date"
+     *         cursor: "cursor",
+     *         nextCursor: "next_cursor",
+     *         provider: "provider",
+     *         startDate: "start_date",
+     *         endDate: "end_date"
      *     })
      */
-    basalBodyTemperatureGrouped(userId: string, request: Vital.BasalBodyTemperatureGroupedVitalsRequest, requestOptions?: Vitals.RequestOptions): Promise<Vital.GroupedBasalBodyTemperatureResponse>;
+    basalBodyTemperatureGrouped(userId: string, request: Vital.VitalsBasalBodyTemperatureGroupedRequest, requestOptions?: Vitals.RequestOptions): Promise<Vital.GroupedBasalBodyTemperatureResponse>;
     /**
      * @param {string} userId
-     * @param {Vital.HandwashingGroupedVitalsRequest} request
+     * @param {Vital.VitalsHandwashingGroupedRequest} request
      * @param {Vitals.RequestOptions} requestOptions - Request-specific configuration.
      *
      * @throws {@link Vital.UnprocessableEntityError}
      *
      * @example
      *     await client.vitals.handwashingGrouped("user_id", {
-     *         startDate: "start_date"
+     *         cursor: "cursor",
+     *         nextCursor: "next_cursor",
+     *         provider: "provider",
+     *         startDate: "start_date",
+     *         endDate: "end_date"
      *     })
      */
-    handwashingGrouped(userId: string, request: Vital.HandwashingGroupedVitalsRequest, requestOptions?: Vitals.RequestOptions): Promise<Vital.GroupedHandwashingResponse>;
+    handwashingGrouped(userId: string, request: Vital.VitalsHandwashingGroupedRequest, requestOptions?: Vitals.RequestOptions): Promise<Vital.GroupedHandwashingResponse>;
     /**
      * @param {string} userId
-     * @param {Vital.DaylightExposureGroupedVitalsRequest} request
+     * @param {Vital.VitalsDaylightExposureGroupedRequest} request
      * @param {Vitals.RequestOptions} requestOptions - Request-specific configuration.
      *
      * @throws {@link Vital.UnprocessableEntityError}
      *
      * @example
      *     await client.vitals.daylightExposureGrouped("user_id", {
-     *         startDate: "start_date"
+     *         cursor: "cursor",
+     *         nextCursor: "next_cursor",
+     *         provider: "provider",
+     *         startDate: "start_date",
+     *         endDate: "end_date"
      *     })
      */
-    daylightExposureGrouped(userId: string, request: Vital.DaylightExposureGroupedVitalsRequest, requestOptions?: Vitals.RequestOptions): Promise<Vital.GroupedDaylightExposureResponse>;
+    daylightExposureGrouped(userId: string, request: Vital.VitalsDaylightExposureGroupedRequest, requestOptions?: Vitals.RequestOptions): Promise<Vital.GroupedDaylightExposureResponse>;
     /**
      * @param {string} userId
-     * @param {Vital.UvExposureGroupedVitalsRequest} request
+     * @param {Vital.VitalsUvExposureGroupedRequest} request
      * @param {Vitals.RequestOptions} requestOptions - Request-specific configuration.
      *
      * @throws {@link Vital.UnprocessableEntityError}
      *
      * @example
      *     await client.vitals.uvExposureGrouped("user_id", {
-     *         startDate: "start_date"
+     *         cursor: "cursor",
+     *         nextCursor: "next_cursor",
+     *         provider: "provider",
+     *         startDate: "start_date",
+     *         endDate: "end_date"
      *     })
      */
-    uvExposureGrouped(userId: string, request: Vital.UvExposureGroupedVitalsRequest, requestOptions?: Vitals.RequestOptions): Promise<Vital.GroupedUvExposureResponse>;
+    uvExposureGrouped(userId: string, request: Vital.VitalsUvExposureGroupedRequest, requestOptions?: Vitals.RequestOptions): Promise<Vital.GroupedUvExposureResponse>;
     /**
      * @param {string} userId
-     * @param {Vital.FallGroupedVitalsRequest} request
+     * @param {Vital.VitalsFallGroupedRequest} request
      * @param {Vitals.RequestOptions} requestOptions - Request-specific configuration.
      *
      * @throws {@link Vital.UnprocessableEntityError}
      *
      * @example
      *     await client.vitals.fallGrouped("user_id", {
-     *         startDate: "start_date"
+     *         cursor: "cursor",
+     *         nextCursor: "next_cursor",
+     *         provider: "provider",
+     *         startDate: "start_date",
+     *         endDate: "end_date"
      *     })
      */
-    fallGrouped(userId: string, request: Vital.FallGroupedVitalsRequest, requestOptions?: Vitals.RequestOptions): Promise<Vital.GroupedFallResponse>;
+    fallGrouped(userId: string, request: Vital.VitalsFallGroupedRequest, requestOptions?: Vitals.RequestOptions): Promise<Vital.GroupedFallResponse>;
     /**
      * @param {string} userId
-     * @param {Vital.InhalerUsageGroupedVitalsRequest} request
+     * @param {Vital.VitalsInhalerUsageGroupedRequest} request
      * @param {Vitals.RequestOptions} requestOptions - Request-specific configuration.
      *
      * @throws {@link Vital.UnprocessableEntityError}
      *
      * @example
      *     await client.vitals.inhalerUsageGrouped("user_id", {
-     *         startDate: "start_date"
+     *         cursor: "cursor",
+     *         nextCursor: "next_cursor",
+     *         provider: "provider",
+     *         startDate: "start_date",
+     *         endDate: "end_date"
      *     })
      */
-    inhalerUsageGrouped(userId: string, request: Vital.InhalerUsageGroupedVitalsRequest, requestOptions?: Vitals.RequestOptions): Promise<Vital.GroupedInhalerUsageResponse>;
+    inhalerUsageGrouped(userId: string, request: Vital.VitalsInhalerUsageGroupedRequest, requestOptions?: Vitals.RequestOptions): Promise<Vital.GroupedInhalerUsageResponse>;
     /**
      * @param {string} userId
-     * @param {Vital.PeakExpiratoryFlowRateGroupedVitalsRequest} request
+     * @param {Vital.VitalsPeakExpiratoryFlowRateGroupedRequest} request
      * @param {Vitals.RequestOptions} requestOptions - Request-specific configuration.
      *
      * @throws {@link Vital.UnprocessableEntityError}
      *
      * @example
      *     await client.vitals.peakExpiratoryFlowRateGrouped("user_id", {
-     *         startDate: "start_date"
+     *         cursor: "cursor",
+     *         nextCursor: "next_cursor",
+     *         provider: "provider",
+     *         startDate: "start_date",
+     *         endDate: "end_date"
      *     })
      */
-    peakExpiratoryFlowRateGrouped(userId: string, request: Vital.PeakExpiratoryFlowRateGroupedVitalsRequest, requestOptions?: Vitals.RequestOptions): Promise<Vital.GroupedPeakExpiratoryFlowRateResponse>;
+    peakExpiratoryFlowRateGrouped(userId: string, request: Vital.VitalsPeakExpiratoryFlowRateGroupedRequest, requestOptions?: Vitals.RequestOptions): Promise<Vital.GroupedPeakExpiratoryFlowRateResponse>;
     /**
      * @param {string} userId
-     * @param {Vital.ForcedVitalCapacityGroupedVitalsRequest} request
+     * @param {Vital.VitalsForcedVitalCapacityGroupedRequest} request
      * @param {Vitals.RequestOptions} requestOptions - Request-specific configuration.
      *
      * @throws {@link Vital.UnprocessableEntityError}
      *
      * @example
      *     await client.vitals.forcedVitalCapacityGrouped("user_id", {
-     *         startDate: "start_date"
+     *         cursor: "cursor",
+     *         nextCursor: "next_cursor",
+     *         provider: "provider",
+     *         startDate: "start_date",
+     *         endDate: "end_date"
      *     })
      */
-    forcedVitalCapacityGrouped(userId: string, request: Vital.ForcedVitalCapacityGroupedVitalsRequest, requestOptions?: Vitals.RequestOptions): Promise<Vital.GroupedForcedVitalCapacityResponse>;
+    forcedVitalCapacityGrouped(userId: string, request: Vital.VitalsForcedVitalCapacityGroupedRequest, requestOptions?: Vitals.RequestOptions): Promise<Vital.GroupedForcedVitalCapacityResponse>;
     /**
      * @param {string} userId
-     * @param {Vital.ForcedExpiratoryVolume1GroupedVitalsRequest} request
+     * @param {Vital.VitalsForcedExpiratoryVolume1GroupedRequest} request
      * @param {Vitals.RequestOptions} requestOptions - Request-specific configuration.
      *
      * @throws {@link Vital.UnprocessableEntityError}
      *
      * @example
      *     await client.vitals.forcedExpiratoryVolume1Grouped("user_id", {
-     *         startDate: "start_date"
+     *         cursor: "cursor",
+     *         nextCursor: "next_cursor",
+     *         provider: "provider",
+     *         startDate: "start_date",
+     *         endDate: "end_date"
      *     })
      */
-    forcedExpiratoryVolume1Grouped(userId: string, request: Vital.ForcedExpiratoryVolume1GroupedVitalsRequest, requestOptions?: Vitals.RequestOptions): Promise<Vital.GroupedForcedExpiratoryVolume1Response>;
+    forcedExpiratoryVolume1Grouped(userId: string, request: Vital.VitalsForcedExpiratoryVolume1GroupedRequest, requestOptions?: Vitals.RequestOptions): Promise<Vital.GroupedForcedExpiratoryVolume1Response>;
     /**
      * @param {string} userId
-     * @param {Vital.WheelchairPushGroupedVitalsRequest} request
+     * @param {Vital.VitalsWheelchairPushGroupedRequest} request
      * @param {Vitals.RequestOptions} requestOptions - Request-specific configuration.
      *
      * @throws {@link Vital.UnprocessableEntityError}
      *
      * @example
      *     await client.vitals.wheelchairPushGrouped("user_id", {
-     *         startDate: "start_date"
+     *         cursor: "cursor",
+     *         nextCursor: "next_cursor",
+     *         provider: "provider",
+     *         startDate: "start_date",
+     *         endDate: "end_date"
      *     })
      */
-    wheelchairPushGrouped(userId: string, request: Vital.WheelchairPushGroupedVitalsRequest, requestOptions?: Vitals.RequestOptions): Promise<Vital.GroupedWheelchairPushResponse>;
+    wheelchairPushGrouped(userId: string, request: Vital.VitalsWheelchairPushGroupedRequest, requestOptions?: Vitals.RequestOptions): Promise<Vital.GroupedWheelchairPushResponse>;
     /**
      * @param {string} userId
-     * @param {Vital.SleepBreathingDisturbanceGroupedVitalsRequest} request
+     * @param {Vital.VitalsSleepBreathingDisturbanceGroupedRequest} request
      * @param {Vitals.RequestOptions} requestOptions - Request-specific configuration.
      *
      * @throws {@link Vital.UnprocessableEntityError}
      *
      * @example
      *     await client.vitals.sleepBreathingDisturbanceGrouped("user_id", {
-     *         startDate: "start_date"
+     *         cursor: "cursor",
+     *         nextCursor: "next_cursor",
+     *         provider: "provider",
+     *         startDate: "start_date",
+     *         endDate: "end_date"
      *     })
      */
-    sleepBreathingDisturbanceGrouped(userId: string, request: Vital.SleepBreathingDisturbanceGroupedVitalsRequest, requestOptions?: Vitals.RequestOptions): Promise<Vital.GroupedSleepBreathingDisturbanceResponse>;
+    sleepBreathingDisturbanceGrouped(userId: string, request: Vital.VitalsSleepBreathingDisturbanceGroupedRequest, requestOptions?: Vitals.RequestOptions): Promise<Vital.GroupedSleepBreathingDisturbanceResponse>;
     /**
      * @param {string} userId
-     * @param {Vital.SleepApneaAlertGroupedVitalsRequest} request
+     * @param {Vital.VitalsSleepApneaAlertGroupedRequest} request
      * @param {Vitals.RequestOptions} requestOptions - Request-specific configuration.
      *
      * @throws {@link Vital.UnprocessableEntityError}
      *
      * @example
      *     await client.vitals.sleepApneaAlertGrouped("user_id", {
-     *         startDate: "start_date"
+     *         cursor: "cursor",
+     *         nextCursor: "next_cursor",
+     *         provider: "provider",
+     *         startDate: "start_date",
+     *         endDate: "end_date"
      *     })
      */
-    sleepApneaAlertGrouped(userId: string, request: Vital.SleepApneaAlertGroupedVitalsRequest, requestOptions?: Vitals.RequestOptions): Promise<Vital.GroupedSleepApneaAlertResponse>;
+    sleepApneaAlertGrouped(userId: string, request: Vital.VitalsSleepApneaAlertGroupedRequest, requestOptions?: Vitals.RequestOptions): Promise<Vital.GroupedSleepApneaAlertResponse>;
     /**
      * @param {string} userId
-     * @param {Vital.StandDurationGroupedVitalsRequest} request
+     * @param {Vital.VitalsStandDurationGroupedRequest} request
      * @param {Vitals.RequestOptions} requestOptions - Request-specific configuration.
      *
      * @throws {@link Vital.UnprocessableEntityError}
      *
      * @example
      *     await client.vitals.standDurationGrouped("user_id", {
-     *         startDate: "start_date"
+     *         cursor: "cursor",
+     *         nextCursor: "next_cursor",
+     *         provider: "provider",
+     *         startDate: "start_date",
+     *         endDate: "end_date"
      *     })
      */
-    standDurationGrouped(userId: string, request: Vital.StandDurationGroupedVitalsRequest, requestOptions?: Vitals.RequestOptions): Promise<Vital.GroupedStandDurationResponse>;
+    standDurationGrouped(userId: string, request: Vital.VitalsStandDurationGroupedRequest, requestOptions?: Vitals.RequestOptions): Promise<Vital.GroupedStandDurationResponse>;
     /**
      * @param {string} userId
-     * @param {Vital.StandHourGroupedVitalsRequest} request
+     * @param {Vital.VitalsStandHourGroupedRequest} request
      * @param {Vitals.RequestOptions} requestOptions - Request-specific configuration.
      *
      * @throws {@link Vital.UnprocessableEntityError}
      *
      * @example
      *     await client.vitals.standHourGrouped("user_id", {
-     *         startDate: "start_date"
+     *         cursor: "cursor",
+     *         nextCursor: "next_cursor",
+     *         provider: "provider",
+     *         startDate: "start_date",
+     *         endDate: "end_date"
      *     })
      */
-    standHourGrouped(userId: string, request: Vital.StandHourGroupedVitalsRequest, requestOptions?: Vitals.RequestOptions): Promise<Vital.GroupedStandHourResponse>;
+    standHourGrouped(userId: string, request: Vital.VitalsStandHourGroupedRequest, requestOptions?: Vitals.RequestOptions): Promise<Vital.GroupedStandHourResponse>;
     /**
      * @param {string} userId
-     * @param {Vital.HeartRateAlertGroupedVitalsRequest} request
+     * @param {Vital.VitalsHeartRateAlertGroupedRequest} request
      * @param {Vitals.RequestOptions} requestOptions - Request-specific configuration.
      *
      * @throws {@link Vital.UnprocessableEntityError}
      *
      * @example
      *     await client.vitals.heartRateAlertGrouped("user_id", {
-     *         startDate: "start_date"
+     *         cursor: "cursor",
+     *         nextCursor: "next_cursor",
+     *         provider: "provider",
+     *         startDate: "start_date",
+     *         endDate: "end_date"
      *     })
      */
-    heartRateAlertGrouped(userId: string, request: Vital.HeartRateAlertGroupedVitalsRequest, requestOptions?: Vitals.RequestOptions): Promise<Vital.GroupedHeartRateAlertResponse>;
+    heartRateAlertGrouped(userId: string, request: Vital.VitalsHeartRateAlertGroupedRequest, requestOptions?: Vitals.RequestOptions): Promise<Vital.GroupedHeartRateAlertResponse>;
     /**
      * @param {string} userId
-     * @param {Vital.AfibBurdenGroupedVitalsRequest} request
+     * @param {Vital.VitalsAfibBurdenGroupedRequest} request
      * @param {Vitals.RequestOptions} requestOptions - Request-specific configuration.
      *
      * @throws {@link Vital.UnprocessableEntityError}
      *
      * @example
      *     await client.vitals.afibBurdenGrouped("user_id", {
-     *         startDate: "start_date"
+     *         cursor: "cursor",
+     *         nextCursor: "next_cursor",
+     *         provider: "provider",
+     *         startDate: "start_date",
+     *         endDate: "end_date"
      *     })
      */
-    afibBurdenGrouped(userId: string, request: Vital.AfibBurdenGroupedVitalsRequest, requestOptions?: Vitals.RequestOptions): Promise<Vital.GroupedAFibBurdenResponse>;
+    afibBurdenGrouped(userId: string, request: Vital.VitalsAfibBurdenGroupedRequest, requestOptions?: Vitals.RequestOptions): Promise<Vital.GroupedAFibBurdenResponse>;
     /**
      * @param {string} userId
-     * @param {Vital.WorkoutDurationGroupedVitalsRequest} request
+     * @param {Vital.VitalsWorkoutDurationGroupedRequest} request
      * @param {Vitals.RequestOptions} requestOptions - Request-specific configuration.
      *
      * @throws {@link Vital.UnprocessableEntityError}
      *
      * @example
      *     await client.vitals.workoutDurationGrouped("user_id", {
-     *         startDate: "start_date"
+     *         cursor: "cursor",
+     *         nextCursor: "next_cursor",
+     *         provider: "provider",
+     *         startDate: "start_date",
+     *         endDate: "end_date"
      *     })
      */
-    workoutDurationGrouped(userId: string, request: Vital.WorkoutDurationGroupedVitalsRequest, requestOptions?: Vitals.RequestOptions): Promise<Vital.GroupedWorkoutDurationResponse>;
+    workoutDurationGrouped(userId: string, request: Vital.VitalsWorkoutDurationGroupedRequest, requestOptions?: Vitals.RequestOptions): Promise<Vital.GroupedWorkoutDurationResponse>;
     /**
      * @param {string} userId
-     * @param {Vital.Vo2MaxGroupedVitalsRequest} request
+     * @param {Vital.VitalsVo2MaxGroupedRequest} request
      * @param {Vitals.RequestOptions} requestOptions - Request-specific configuration.
      *
      * @throws {@link Vital.UnprocessableEntityError}
      *
      * @example
      *     await client.vitals.vo2MaxGrouped("user_id", {
-     *         startDate: "start_date"
+     *         cursor: "cursor",
+     *         nextCursor: "next_cursor",
+     *         provider: "provider",
+     *         startDate: "start_date",
+     *         endDate: "end_date"
      *     })
      */
-    vo2MaxGrouped(userId: string, request: Vital.Vo2MaxGroupedVitalsRequest, requestOptions?: Vitals.RequestOptions): Promise<Vital.GroupedVo2MaxResponse>;
+    vo2MaxGrouped(userId: string, request: Vital.VitalsVo2MaxGroupedRequest, requestOptions?: Vitals.RequestOptions): Promise<Vital.GroupedVo2MaxResponse>;
     /**
      * @param {string} userId
-     * @param {Vital.StressLevelGroupedVitalsRequest} request
+     * @param {Vital.VitalsStressLevelGroupedRequest} request
      * @param {Vitals.RequestOptions} requestOptions - Request-specific configuration.
      *
      * @throws {@link Vital.UnprocessableEntityError}
      *
      * @example
      *     await client.vitals.stressLevelGrouped("user_id", {
-     *         startDate: "start_date"
+     *         cursor: "cursor",
+     *         nextCursor: "next_cursor",
+     *         provider: "provider",
+     *         startDate: "start_date",
+     *         endDate: "end_date"
      *     })
      */
-    stressLevelGrouped(userId: string, request: Vital.StressLevelGroupedVitalsRequest, requestOptions?: Vitals.RequestOptions): Promise<Vital.GroupedStressLevelResponse>;
+    stressLevelGrouped(userId: string, request: Vital.VitalsStressLevelGroupedRequest, requestOptions?: Vitals.RequestOptions): Promise<Vital.GroupedStressLevelResponse>;
     /**
      * @param {string} userId
-     * @param {Vital.MindfulnessMinutesGroupedVitalsRequest} request
+     * @param {Vital.VitalsMindfulnessMinutesGroupedRequest} request
      * @param {Vitals.RequestOptions} requestOptions - Request-specific configuration.
      *
      * @throws {@link Vital.UnprocessableEntityError}
      *
      * @example
      *     await client.vitals.mindfulnessMinutesGrouped("user_id", {
-     *         startDate: "start_date"
+     *         cursor: "cursor",
+     *         nextCursor: "next_cursor",
+     *         provider: "provider",
+     *         startDate: "start_date",
+     *         endDate: "end_date"
      *     })
      */
-    mindfulnessMinutesGrouped(userId: string, request: Vital.MindfulnessMinutesGroupedVitalsRequest, requestOptions?: Vitals.RequestOptions): Promise<Vital.GroupedMindfulnessMinutesResponse>;
+    mindfulnessMinutesGrouped(userId: string, request: Vital.VitalsMindfulnessMinutesGroupedRequest, requestOptions?: Vitals.RequestOptions): Promise<Vital.GroupedMindfulnessMinutesResponse>;
     /**
      * @param {string} userId
-     * @param {Vital.CaffeineGroupedVitalsRequest} request
+     * @param {Vital.VitalsCaffeineGroupedRequest} request
      * @param {Vitals.RequestOptions} requestOptions - Request-specific configuration.
      *
      * @throws {@link Vital.UnprocessableEntityError}
      *
      * @example
      *     await client.vitals.caffeineGrouped("user_id", {
-     *         startDate: "start_date"
+     *         cursor: "cursor",
+     *         nextCursor: "next_cursor",
+     *         provider: "provider",
+     *         startDate: "start_date",
+     *         endDate: "end_date"
      *     })
      */
-    caffeineGrouped(userId: string, request: Vital.CaffeineGroupedVitalsRequest, requestOptions?: Vitals.RequestOptions): Promise<Vital.GroupedCaffeineResponse>;
+    caffeineGrouped(userId: string, request: Vital.VitalsCaffeineGroupedRequest, requestOptions?: Vitals.RequestOptions): Promise<Vital.GroupedCaffeineResponse>;
     /**
      * @param {string} userId
-     * @param {Vital.WaterGroupedVitalsRequest} request
+     * @param {Vital.VitalsWaterGroupedRequest} request
      * @param {Vitals.RequestOptions} requestOptions - Request-specific configuration.
      *
      * @throws {@link Vital.UnprocessableEntityError}
      *
      * @example
      *     await client.vitals.waterGrouped("user_id", {
-     *         startDate: "start_date"
+     *         cursor: "cursor",
+     *         nextCursor: "next_cursor",
+     *         provider: "provider",
+     *         startDate: "start_date",
+     *         endDate: "end_date"
      *     })
      */
-    waterGrouped(userId: string, request: Vital.WaterGroupedVitalsRequest, requestOptions?: Vitals.RequestOptions): Promise<Vital.GroupedWaterResponse>;
+    waterGrouped(userId: string, request: Vital.VitalsWaterGroupedRequest, requestOptions?: Vitals.RequestOptions): Promise<Vital.GroupedWaterResponse>;
     /**
      * @param {string} userId
-     * @param {Vital.StepsGroupedVitalsRequest} request
+     * @param {Vital.VitalsStepsGroupedRequest} request
      * @param {Vitals.RequestOptions} requestOptions - Request-specific configuration.
      *
      * @throws {@link Vital.UnprocessableEntityError}
      *
      * @example
      *     await client.vitals.stepsGrouped("user_id", {
-     *         startDate: "start_date"
+     *         cursor: "cursor",
+     *         nextCursor: "next_cursor",
+     *         provider: "provider",
+     *         startDate: "start_date",
+     *         endDate: "end_date"
      *     })
      */
-    stepsGrouped(userId: string, request: Vital.StepsGroupedVitalsRequest, requestOptions?: Vitals.RequestOptions): Promise<Vital.GroupedStepsResponse>;
+    stepsGrouped(userId: string, request: Vital.VitalsStepsGroupedRequest, requestOptions?: Vitals.RequestOptions): Promise<Vital.GroupedStepsResponse>;
     /**
      * @param {string} userId
-     * @param {Vital.FloorsClimbedGroupedVitalsRequest} request
+     * @param {Vital.VitalsFloorsClimbedGroupedRequest} request
      * @param {Vitals.RequestOptions} requestOptions - Request-specific configuration.
      *
      * @throws {@link Vital.UnprocessableEntityError}
      *
      * @example
      *     await client.vitals.floorsClimbedGrouped("user_id", {
-     *         startDate: "start_date"
+     *         cursor: "cursor",
+     *         nextCursor: "next_cursor",
+     *         provider: "provider",
+     *         startDate: "start_date",
+     *         endDate: "end_date"
      *     })
      */
-    floorsClimbedGrouped(userId: string, request: Vital.FloorsClimbedGroupedVitalsRequest, requestOptions?: Vitals.RequestOptions): Promise<Vital.GroupedFloorsClimbedResponse>;
+    floorsClimbedGrouped(userId: string, request: Vital.VitalsFloorsClimbedGroupedRequest, requestOptions?: Vitals.RequestOptions): Promise<Vital.GroupedFloorsClimbedResponse>;
     /**
      * @param {string} userId
-     * @param {Vital.DistanceGroupedVitalsRequest} request
+     * @param {Vital.VitalsDistanceGroupedRequest} request
      * @param {Vitals.RequestOptions} requestOptions - Request-specific configuration.
      *
      * @throws {@link Vital.UnprocessableEntityError}
      *
      * @example
      *     await client.vitals.distanceGrouped("user_id", {
-     *         startDate: "start_date"
+     *         cursor: "cursor",
+     *         nextCursor: "next_cursor",
+     *         provider: "provider",
+     *         startDate: "start_date",
+     *         endDate: "end_date"
      *     })
      */
-    distanceGrouped(userId: string, request: Vital.DistanceGroupedVitalsRequest, requestOptions?: Vitals.RequestOptions): Promise<Vital.GroupedDistanceResponse>;
+    distanceGrouped(userId: string, request: Vital.VitalsDistanceGroupedRequest, requestOptions?: Vitals.RequestOptions): Promise<Vital.GroupedDistanceResponse>;
     /**
      * @param {string} userId
-     * @param {Vital.CaloriesBasalGroupedVitalsRequest} request
+     * @param {Vital.VitalsCaloriesBasalGroupedRequest} request
      * @param {Vitals.RequestOptions} requestOptions - Request-specific configuration.
      *
      * @throws {@link Vital.UnprocessableEntityError}
      *
      * @example
      *     await client.vitals.caloriesBasalGrouped("user_id", {
-     *         startDate: "start_date"
+     *         cursor: "cursor",
+     *         nextCursor: "next_cursor",
+     *         provider: "provider",
+     *         startDate: "start_date",
+     *         endDate: "end_date"
      *     })
      */
-    caloriesBasalGrouped(userId: string, request: Vital.CaloriesBasalGroupedVitalsRequest, requestOptions?: Vitals.RequestOptions): Promise<Vital.GroupedCaloriesBasalResponse>;
+    caloriesBasalGrouped(userId: string, request: Vital.VitalsCaloriesBasalGroupedRequest, requestOptions?: Vitals.RequestOptions): Promise<Vital.GroupedCaloriesBasalResponse>;
     /**
      * @param {string} userId
-     * @param {Vital.CaloriesActiveGroupedVitalsRequest} request
+     * @param {Vital.VitalsCaloriesActiveGroupedRequest} request
      * @param {Vitals.RequestOptions} requestOptions - Request-specific configuration.
      *
      * @throws {@link Vital.UnprocessableEntityError}
      *
      * @example
      *     await client.vitals.caloriesActiveGrouped("user_id", {
-     *         startDate: "start_date"
+     *         cursor: "cursor",
+     *         nextCursor: "next_cursor",
+     *         provider: "provider",
+     *         startDate: "start_date",
+     *         endDate: "end_date"
      *     })
      */
-    caloriesActiveGrouped(userId: string, request: Vital.CaloriesActiveGroupedVitalsRequest, requestOptions?: Vitals.RequestOptions): Promise<Vital.GroupedCaloriesActiveResponse>;
+    caloriesActiveGrouped(userId: string, request: Vital.VitalsCaloriesActiveGroupedRequest, requestOptions?: Vitals.RequestOptions): Promise<Vital.GroupedCaloriesActiveResponse>;
     /**
      * @param {string} userId
-     * @param {Vital.RespiratoryRateGroupedVitalsRequest} request
+     * @param {Vital.VitalsRespiratoryRateGroupedRequest} request
      * @param {Vitals.RequestOptions} requestOptions - Request-specific configuration.
      *
      * @throws {@link Vital.UnprocessableEntityError}
      *
      * @example
      *     await client.vitals.respiratoryRateGrouped("user_id", {
-     *         startDate: "start_date"
+     *         cursor: "cursor",
+     *         nextCursor: "next_cursor",
+     *         provider: "provider",
+     *         startDate: "start_date",
+     *         endDate: "end_date"
      *     })
      */
-    respiratoryRateGrouped(userId: string, request: Vital.RespiratoryRateGroupedVitalsRequest, requestOptions?: Vitals.RequestOptions): Promise<Vital.GroupedRespiratoryRateResponse>;
+    respiratoryRateGrouped(userId: string, request: Vital.VitalsRespiratoryRateGroupedRequest, requestOptions?: Vitals.RequestOptions): Promise<Vital.GroupedRespiratoryRateResponse>;
     /**
      * @param {string} userId
-     * @param {Vital.NoteGroupedVitalsRequest} request
+     * @param {Vital.VitalsNoteGroupedRequest} request
      * @param {Vitals.RequestOptions} requestOptions - Request-specific configuration.
      *
      * @throws {@link Vital.UnprocessableEntityError}
      *
      * @example
      *     await client.vitals.noteGrouped("user_id", {
-     *         startDate: "start_date"
+     *         cursor: "cursor",
+     *         nextCursor: "next_cursor",
+     *         provider: "provider",
+     *         startDate: "start_date",
+     *         endDate: "end_date"
      *     })
      */
-    noteGrouped(userId: string, request: Vital.NoteGroupedVitalsRequest, requestOptions?: Vitals.RequestOptions): Promise<Vital.GroupedNoteResponse>;
+    noteGrouped(userId: string, request: Vital.VitalsNoteGroupedRequest, requestOptions?: Vitals.RequestOptions): Promise<Vital.GroupedNoteResponse>;
     /**
      * @param {string} userId
-     * @param {Vital.InsulinInjectionGroupedVitalsRequest} request
+     * @param {Vital.VitalsInsulinInjectionGroupedRequest} request
      * @param {Vitals.RequestOptions} requestOptions - Request-specific configuration.
      *
      * @throws {@link Vital.UnprocessableEntityError}
      *
      * @example
      *     await client.vitals.insulinInjectionGrouped("user_id", {
-     *         startDate: "start_date"
+     *         cursor: "cursor",
+     *         nextCursor: "next_cursor",
+     *         provider: "provider",
+     *         startDate: "start_date",
+     *         endDate: "end_date"
      *     })
      */
-    insulinInjectionGrouped(userId: string, request: Vital.InsulinInjectionGroupedVitalsRequest, requestOptions?: Vitals.RequestOptions): Promise<Vital.GroupedInsulinInjectionResponse>;
+    insulinInjectionGrouped(userId: string, request: Vital.VitalsInsulinInjectionGroupedRequest, requestOptions?: Vitals.RequestOptions): Promise<Vital.GroupedInsulinInjectionResponse>;
     /**
      * @param {string} userId
-     * @param {Vital.IgeGroupedVitalsRequest} request
+     * @param {Vital.VitalsIgeGroupedRequest} request
      * @param {Vitals.RequestOptions} requestOptions - Request-specific configuration.
      *
      * @throws {@link Vital.UnprocessableEntityError}
      *
      * @example
      *     await client.vitals.igeGrouped("user_id", {
-     *         startDate: "start_date"
+     *         cursor: "cursor",
+     *         nextCursor: "next_cursor",
+     *         provider: "provider",
+     *         startDate: "start_date",
+     *         endDate: "end_date"
      *     })
      */
-    igeGrouped(userId: string, request: Vital.IgeGroupedVitalsRequest, requestOptions?: Vitals.RequestOptions): Promise<Vital.GroupedIgeResponse>;
+    igeGrouped(userId: string, request: Vital.VitalsIgeGroupedRequest, requestOptions?: Vitals.RequestOptions): Promise<Vital.GroupedIgeResponse>;
     /**
      * @param {string} userId
-     * @param {Vital.IggGroupedVitalsRequest} request
+     * @param {Vital.VitalsIggGroupedRequest} request
      * @param {Vitals.RequestOptions} requestOptions - Request-specific configuration.
      *
      * @throws {@link Vital.UnprocessableEntityError}
      *
      * @example
      *     await client.vitals.iggGrouped("user_id", {
-     *         startDate: "start_date"
+     *         cursor: "cursor",
+     *         nextCursor: "next_cursor",
+     *         provider: "provider",
+     *         startDate: "start_date",
+     *         endDate: "end_date"
      *     })
      */
-    iggGrouped(userId: string, request: Vital.IggGroupedVitalsRequest, requestOptions?: Vitals.RequestOptions): Promise<Vital.GroupedIggResponse>;
+    iggGrouped(userId: string, request: Vital.VitalsIggGroupedRequest, requestOptions?: Vitals.RequestOptions): Promise<Vital.GroupedIggResponse>;
     /**
      * @param {string} userId
-     * @param {Vital.HypnogramGroupedVitalsRequest} request
+     * @param {Vital.VitalsHypnogramGroupedRequest} request
      * @param {Vitals.RequestOptions} requestOptions - Request-specific configuration.
      *
      * @throws {@link Vital.UnprocessableEntityError}
      *
      * @example
      *     await client.vitals.hypnogramGrouped("user_id", {
-     *         startDate: "start_date"
+     *         cursor: "cursor",
+     *         nextCursor: "next_cursor",
+     *         provider: "provider",
+     *         startDate: "start_date",
+     *         endDate: "end_date"
      *     })
      */
-    hypnogramGrouped(userId: string, request: Vital.HypnogramGroupedVitalsRequest, requestOptions?: Vitals.RequestOptions): Promise<Vital.GroupedHypnogramResponse>;
+    hypnogramGrouped(userId: string, request: Vital.VitalsHypnogramGroupedRequest, requestOptions?: Vitals.RequestOptions): Promise<Vital.GroupedHypnogramResponse>;
     /**
      * @param {string} userId
-     * @param {Vital.HrvGroupedVitalsRequest} request
+     * @param {Vital.VitalsHrvGroupedRequest} request
      * @param {Vitals.RequestOptions} requestOptions - Request-specific configuration.
      *
      * @throws {@link Vital.UnprocessableEntityError}
      *
      * @example
      *     await client.vitals.hrvGrouped("user_id", {
-     *         startDate: "start_date"
+     *         cursor: "cursor",
+     *         nextCursor: "next_cursor",
+     *         provider: "provider",
+     *         startDate: "start_date",
+     *         endDate: "end_date"
      *     })
      */
-    hrvGrouped(userId: string, request: Vital.HrvGroupedVitalsRequest, requestOptions?: Vitals.RequestOptions): Promise<Vital.GroupedHrvResponse>;
+    hrvGrouped(userId: string, request: Vital.VitalsHrvGroupedRequest, requestOptions?: Vitals.RequestOptions): Promise<Vital.GroupedHrvResponse>;
     /**
      * @param {string} userId
-     * @param {Vital.HeartrateGroupedVitalsRequest} request
+     * @param {Vital.VitalsHeartrateGroupedRequest} request
      * @param {Vitals.RequestOptions} requestOptions - Request-specific configuration.
      *
      * @throws {@link Vital.UnprocessableEntityError}
      *
      * @example
      *     await client.vitals.heartrateGrouped("user_id", {
-     *         startDate: "start_date"
+     *         cursor: "cursor",
+     *         nextCursor: "next_cursor",
+     *         provider: "provider",
+     *         startDate: "start_date",
+     *         endDate: "end_date"
      *     })
      */
-    heartrateGrouped(userId: string, request: Vital.HeartrateGroupedVitalsRequest, requestOptions?: Vitals.RequestOptions): Promise<Vital.GroupedHeartRateResponse>;
+    heartrateGrouped(userId: string, request: Vital.VitalsHeartrateGroupedRequest, requestOptions?: Vitals.RequestOptions): Promise<Vital.GroupedHeartRateResponse>;
     /**
      * @param {string} userId
-     * @param {Vital.GlucoseGroupedVitalsRequest} request
+     * @param {Vital.VitalsGlucoseGroupedRequest} request
      * @param {Vitals.RequestOptions} requestOptions - Request-specific configuration.
      *
      * @throws {@link Vital.UnprocessableEntityError}
      *
      * @example
      *     await client.vitals.glucoseGrouped("user_id", {
-     *         startDate: "start_date"
+     *         cursor: "cursor",
+     *         nextCursor: "next_cursor",
+     *         provider: "provider",
+     *         startDate: "start_date",
+     *         endDate: "end_date"
      *     })
      */
-    glucoseGrouped(userId: string, request: Vital.GlucoseGroupedVitalsRequest, requestOptions?: Vitals.RequestOptions): Promise<Vital.GroupedGlucoseResponse>;
+    glucoseGrouped(userId: string, request: Vital.VitalsGlucoseGroupedRequest, requestOptions?: Vitals.RequestOptions): Promise<Vital.GroupedGlucoseResponse>;
     /**
      * @param {string} userId
-     * @param {Vital.CholesterolGroupedVitalsRequest} request
+     * @param {Vital.VitalsCholesterolGroupedRequest} request
      * @param {Vitals.RequestOptions} requestOptions - Request-specific configuration.
      *
      * @throws {@link Vital.UnprocessableEntityError}
      *
      * @example
      *     await client.vitals.cholesterolGrouped("user_id", {
-     *         startDate: "start_date"
+     *         cursor: "cursor",
+     *         nextCursor: "next_cursor",
+     *         provider: "provider",
+     *         startDate: "start_date",
+     *         endDate: "end_date"
      *     })
      */
-    cholesterolGrouped(userId: string, request: Vital.CholesterolGroupedVitalsRequest, requestOptions?: Vitals.RequestOptions): Promise<Vital.GroupedCholesterolResponse>;
+    cholesterolGrouped(userId: string, request: Vital.VitalsCholesterolGroupedRequest, requestOptions?: Vitals.RequestOptions): Promise<Vital.GroupedCholesterolResponse>;
     /**
      * @param {string} userId
-     * @param {Vital.CarbohydratesGroupedVitalsRequest} request
+     * @param {Vital.VitalsCarbohydratesGroupedRequest} request
      * @param {Vitals.RequestOptions} requestOptions - Request-specific configuration.
      *
      * @throws {@link Vital.UnprocessableEntityError}
      *
      * @example
      *     await client.vitals.carbohydratesGrouped("user_id", {
-     *         startDate: "start_date"
+     *         cursor: "cursor",
+     *         nextCursor: "next_cursor",
+     *         provider: "provider",
+     *         startDate: "start_date",
+     *         endDate: "end_date"
      *     })
      */
-    carbohydratesGrouped(userId: string, request: Vital.CarbohydratesGroupedVitalsRequest, requestOptions?: Vitals.RequestOptions): Promise<Vital.GroupedCarbohydratesResponse>;
+    carbohydratesGrouped(userId: string, request: Vital.VitalsCarbohydratesGroupedRequest, requestOptions?: Vitals.RequestOptions): Promise<Vital.GroupedCarbohydratesResponse>;
     /**
      * @param {string} userId
-     * @param {Vital.BodyTemperatureDeltaGroupedVitalsRequest} request
+     * @param {Vital.VitalsBodyTemperatureDeltaGroupedRequest} request
      * @param {Vitals.RequestOptions} requestOptions - Request-specific configuration.
      *
      * @throws {@link Vital.UnprocessableEntityError}
      *
      * @example
      *     await client.vitals.bodyTemperatureDeltaGrouped("user_id", {
-     *         startDate: "start_date"
+     *         cursor: "cursor",
+     *         nextCursor: "next_cursor",
+     *         provider: "provider",
+     *         startDate: "start_date",
+     *         endDate: "end_date"
      *     })
      */
-    bodyTemperatureDeltaGrouped(userId: string, request: Vital.BodyTemperatureDeltaGroupedVitalsRequest, requestOptions?: Vitals.RequestOptions): Promise<Vital.GroupedBodyTemperatureDeltaResponse>;
+    bodyTemperatureDeltaGrouped(userId: string, request: Vital.VitalsBodyTemperatureDeltaGroupedRequest, requestOptions?: Vitals.RequestOptions): Promise<Vital.GroupedBodyTemperatureDeltaResponse>;
     /**
      * @param {string} userId
-     * @param {Vital.BodyTemperatureGroupedVitalsRequest} request
+     * @param {Vital.VitalsBodyTemperatureGroupedRequest} request
      * @param {Vitals.RequestOptions} requestOptions - Request-specific configuration.
      *
      * @throws {@link Vital.UnprocessableEntityError}
      *
      * @example
      *     await client.vitals.bodyTemperatureGrouped("user_id", {
-     *         startDate: "start_date"
+     *         cursor: "cursor",
+     *         nextCursor: "next_cursor",
+     *         provider: "provider",
+     *         startDate: "start_date",
+     *         endDate: "end_date"
      *     })
      */
-    bodyTemperatureGrouped(userId: string, request: Vital.BodyTemperatureGroupedVitalsRequest, requestOptions?: Vitals.RequestOptions): Promise<Vital.GroupedBodyTemperatureResponse>;
+    bodyTemperatureGrouped(userId: string, request: Vital.VitalsBodyTemperatureGroupedRequest, requestOptions?: Vitals.RequestOptions): Promise<Vital.GroupedBodyTemperatureResponse>;
     /**
      * @param {string} userId
-     * @param {Vital.BodyWeightGroupedVitalsRequest} request
+     * @param {Vital.VitalsBodyWeightGroupedRequest} request
      * @param {Vitals.RequestOptions} requestOptions - Request-specific configuration.
      *
      * @throws {@link Vital.UnprocessableEntityError}
      *
      * @example
      *     await client.vitals.bodyWeightGrouped("user_id", {
-     *         startDate: "start_date"
+     *         cursor: "cursor",
+     *         nextCursor: "next_cursor",
+     *         provider: "provider",
+     *         startDate: "start_date",
+     *         endDate: "end_date"
      *     })
      */
-    bodyWeightGrouped(userId: string, request: Vital.BodyWeightGroupedVitalsRequest, requestOptions?: Vitals.RequestOptions): Promise<Vital.GroupedBodyWeightResponse>;
+    bodyWeightGrouped(userId: string, request: Vital.VitalsBodyWeightGroupedRequest, requestOptions?: Vitals.RequestOptions): Promise<Vital.GroupedBodyWeightResponse>;
     /**
      * @param {string} userId
-     * @param {Vital.BodyFatGroupedVitalsRequest} request
+     * @param {Vital.VitalsBodyFatGroupedRequest} request
      * @param {Vitals.RequestOptions} requestOptions - Request-specific configuration.
      *
      * @throws {@link Vital.UnprocessableEntityError}
      *
      * @example
      *     await client.vitals.bodyFatGrouped("user_id", {
-     *         startDate: "start_date"
+     *         cursor: "cursor",
+     *         nextCursor: "next_cursor",
+     *         provider: "provider",
+     *         startDate: "start_date",
+     *         endDate: "end_date"
      *     })
      */
-    bodyFatGrouped(userId: string, request: Vital.BodyFatGroupedVitalsRequest, requestOptions?: Vitals.RequestOptions): Promise<Vital.GroupedBodyFatResponse>;
+    bodyFatGrouped(userId: string, request: Vital.VitalsBodyFatGroupedRequest, requestOptions?: Vitals.RequestOptions): Promise<Vital.GroupedBodyFatResponse>;
     /**
      * @param {string} userId
-     * @param {Vital.BloodOxygenGroupedVitalsRequest} request
+     * @param {Vital.VitalsBloodOxygenGroupedRequest} request
      * @param {Vitals.RequestOptions} requestOptions - Request-specific configuration.
      *
      * @throws {@link Vital.UnprocessableEntityError}
      *
      * @example
      *     await client.vitals.bloodOxygenGrouped("user_id", {
-     *         startDate: "start_date"
+     *         cursor: "cursor",
+     *         nextCursor: "next_cursor",
+     *         provider: "provider",
+     *         startDate: "start_date",
+     *         endDate: "end_date"
      *     })
      */
-    bloodOxygenGrouped(userId: string, request: Vital.BloodOxygenGroupedVitalsRequest, requestOptions?: Vitals.RequestOptions): Promise<Vital.GroupedBloodOxygenResponse>;
+    bloodOxygenGrouped(userId: string, request: Vital.VitalsBloodOxygenGroupedRequest, requestOptions?: Vitals.RequestOptions): Promise<Vital.GroupedBloodOxygenResponse>;
     /**
      * @param {string} userId
-     * @param {Vital.ElectrocardiogramVoltageGroupedVitalsRequest} request
+     * @param {Vital.VitalsElectrocardiogramVoltageGroupedRequest} request
      * @param {Vitals.RequestOptions} requestOptions - Request-specific configuration.
      *
      * @throws {@link Vital.UnprocessableEntityError}
      *
      * @example
      *     await client.vitals.electrocardiogramVoltageGrouped("user_id", {
-     *         startDate: "start_date"
+     *         cursor: "cursor",
+     *         nextCursor: "next_cursor",
+     *         provider: "provider",
+     *         startDate: "start_date",
+     *         endDate: "end_date"
      *     })
      */
-    electrocardiogramVoltageGrouped(userId: string, request: Vital.ElectrocardiogramVoltageGroupedVitalsRequest, requestOptions?: Vitals.RequestOptions): Promise<Vital.GroupedElectrocardiogramVoltageResponse>;
+    electrocardiogramVoltageGrouped(userId: string, request: Vital.VitalsElectrocardiogramVoltageGroupedRequest, requestOptions?: Vitals.RequestOptions): Promise<Vital.GroupedElectrocardiogramVoltageResponse>;
     /**
      * @param {string} userId
-     * @param {Vital.BloodPressureGroupedVitalsRequest} request
+     * @param {Vital.VitalsBloodPressureGroupedRequest} request
      * @param {Vitals.RequestOptions} requestOptions - Request-specific configuration.
      *
      * @throws {@link Vital.UnprocessableEntityError}
      *
      * @example
      *     await client.vitals.bloodPressureGrouped("user_id", {
-     *         startDate: "start_date"
+     *         cursor: "cursor",
+     *         nextCursor: "next_cursor",
+     *         provider: "provider",
+     *         startDate: "start_date",
+     *         endDate: "end_date"
      *     })
      */
-    bloodPressureGrouped(userId: string, request: Vital.BloodPressureGroupedVitalsRequest, requestOptions?: Vitals.RequestOptions): Promise<Vital.GroupedBloodPressureResponse>;
+    bloodPressureGrouped(userId: string, request: Vital.VitalsBloodPressureGroupedRequest, requestOptions?: Vitals.RequestOptions): Promise<Vital.GroupedBloodPressureResponse>;
     /**
      * @param {string} userId
-     * @param {Vital.Vo2MaxVitalsRequest} request
+     * @param {Vital.VitalsVo2MaxRequest} request
      * @param {Vitals.RequestOptions} requestOptions - Request-specific configuration.
      *
      * @throws {@link Vital.UnprocessableEntityError}
      *
      * @example
      *     await client.vitals.vo2Max("user_id", {
-     *         startDate: "start_date"
+     *         provider: "provider",
+     *         startDate: "start_date",
+     *         endDate: "end_date"
      *     })
      */
-    vo2Max(userId: string, request: Vital.Vo2MaxVitalsRequest, requestOptions?: Vitals.RequestOptions): Promise<Vital.ClientFacingVo2MaxTimeseries[]>;
+    vo2Max(userId: string, request: Vital.VitalsVo2MaxRequest, requestOptions?: Vitals.RequestOptions): Promise<Vital.ClientFacingVo2MaxTimeseries[]>;
     /**
      * @param {string} userId
-     * @param {Vital.StressLevelVitalsRequest} request
+     * @param {Vital.VitalsStressLevelRequest} request
      * @param {Vitals.RequestOptions} requestOptions - Request-specific configuration.
      *
      * @throws {@link Vital.UnprocessableEntityError}
      *
      * @example
      *     await client.vitals.stressLevel("user_id", {
-     *         startDate: "start_date"
+     *         provider: "provider",
+     *         startDate: "start_date",
+     *         endDate: "end_date"
      *     })
      */
-    stressLevel(userId: string, request: Vital.StressLevelVitalsRequest, requestOptions?: Vitals.RequestOptions): Promise<Vital.ClientFacingStressLevelTimeseries[]>;
+    stressLevel(userId: string, request: Vital.VitalsStressLevelRequest, requestOptions?: Vitals.RequestOptions): Promise<Vital.ClientFacingStressLevelTimeseries[]>;
     /**
      * @param {string} userId
-     * @param {Vital.MindfulnessMinutesVitalsRequest} request
+     * @param {Vital.VitalsMindfulnessMinutesRequest} request
      * @param {Vitals.RequestOptions} requestOptions - Request-specific configuration.
      *
      * @throws {@link Vital.UnprocessableEntityError}
      *
      * @example
      *     await client.vitals.mindfulnessMinutes("user_id", {
-     *         startDate: "start_date"
+     *         provider: "provider",
+     *         startDate: "start_date",
+     *         endDate: "end_date"
      *     })
      */
-    mindfulnessMinutes(userId: string, request: Vital.MindfulnessMinutesVitalsRequest, requestOptions?: Vitals.RequestOptions): Promise<Vital.ClientFacingMindfulnessMinutesTimeseries[]>;
+    mindfulnessMinutes(userId: string, request: Vital.VitalsMindfulnessMinutesRequest, requestOptions?: Vitals.RequestOptions): Promise<Vital.ClientFacingMindfulnessMinutesTimeseries[]>;
     /**
      * @param {string} userId
-     * @param {Vital.CaffeineVitalsRequest} request
+     * @param {Vital.VitalsCaffeineRequest} request
      * @param {Vitals.RequestOptions} requestOptions - Request-specific configuration.
      *
      * @throws {@link Vital.UnprocessableEntityError}
      *
      * @example
      *     await client.vitals.caffeine("user_id", {
-     *         startDate: "start_date"
+     *         provider: "provider",
+     *         startDate: "start_date",
+     *         endDate: "end_date"
      *     })
      */
-    caffeine(userId: string, request: Vital.CaffeineVitalsRequest, requestOptions?: Vitals.RequestOptions): Promise<Vital.ClientFacingCaffeineTimeseries[]>;
+    caffeine(userId: string, request: Vital.VitalsCaffeineRequest, requestOptions?: Vitals.RequestOptions): Promise<Vital.ClientFacingCaffeineTimeseries[]>;
     /**
      * @param {string} userId
-     * @param {Vital.WaterVitalsRequest} request
+     * @param {Vital.VitalsWaterRequest} request
      * @param {Vitals.RequestOptions} requestOptions - Request-specific configuration.
      *
      * @throws {@link Vital.UnprocessableEntityError}
      *
      * @example
      *     await client.vitals.water("user_id", {
-     *         startDate: "start_date"
+     *         provider: "provider",
+     *         startDate: "start_date",
+     *         endDate: "end_date"
      *     })
      */
-    water(userId: string, request: Vital.WaterVitalsRequest, requestOptions?: Vitals.RequestOptions): Promise<Vital.ClientFacingWaterTimeseries[]>;
+    water(userId: string, request: Vital.VitalsWaterRequest, requestOptions?: Vitals.RequestOptions): Promise<Vital.ClientFacingWaterTimeseries[]>;
     /**
      * @param {string} userId
-     * @param {Vital.StepsVitalsRequest} request
+     * @param {Vital.VitalsStepsRequest} request
      * @param {Vitals.RequestOptions} requestOptions - Request-specific configuration.
      *
      * @throws {@link Vital.UnprocessableEntityError}
      *
      * @example
      *     await client.vitals.steps("user_id", {
-     *         startDate: "start_date"
+     *         provider: "provider",
+     *         startDate: "start_date",
+     *         endDate: "end_date"
      *     })
      */
-    steps(userId: string, request: Vital.StepsVitalsRequest, requestOptions?: Vitals.RequestOptions): Promise<Vital.ClientFacingStepsTimeseries[]>;
+    steps(userId: string, request: Vital.VitalsStepsRequest, requestOptions?: Vitals.RequestOptions): Promise<Vital.ClientFacingStepsTimeseries[]>;
     /**
      * @param {string} userId
-     * @param {Vital.FloorsClimbedVitalsRequest} request
+     * @param {Vital.VitalsFloorsClimbedRequest} request
      * @param {Vitals.RequestOptions} requestOptions - Request-specific configuration.
      *
      * @throws {@link Vital.UnprocessableEntityError}
      *
      * @example
      *     await client.vitals.floorsClimbed("user_id", {
-     *         startDate: "start_date"
+     *         provider: "provider",
+     *         startDate: "start_date",
+     *         endDate: "end_date"
      *     })
      */
-    floorsClimbed(userId: string, request: Vital.FloorsClimbedVitalsRequest, requestOptions?: Vitals.RequestOptions): Promise<Vital.ClientFacingFloorsClimbedTimeseries[]>;
+    floorsClimbed(userId: string, request: Vital.VitalsFloorsClimbedRequest, requestOptions?: Vitals.RequestOptions): Promise<Vital.ClientFacingFloorsClimbedTimeseries[]>;
     /**
      * @param {string} userId
-     * @param {Vital.DistanceVitalsRequest} request
+     * @param {Vital.VitalsDistanceRequest} request
      * @param {Vitals.RequestOptions} requestOptions - Request-specific configuration.
      *
      * @throws {@link Vital.UnprocessableEntityError}
      *
      * @example
      *     await client.vitals.distance("user_id", {
-     *         startDate: "start_date"
+     *         provider: "provider",
+     *         startDate: "start_date",
+     *         endDate: "end_date"
      *     })
      */
-    distance(userId: string, request: Vital.DistanceVitalsRequest, requestOptions?: Vitals.RequestOptions): Promise<Vital.ClientFacingDistanceTimeseries[]>;
+    distance(userId: string, request: Vital.VitalsDistanceRequest, requestOptions?: Vitals.RequestOptions): Promise<Vital.ClientFacingDistanceTimeseries[]>;
     /**
      * @param {string} userId
-     * @param {Vital.CaloriesBasalVitalsRequest} request
+     * @param {Vital.VitalsCaloriesBasalRequest} request
      * @param {Vitals.RequestOptions} requestOptions - Request-specific configuration.
      *
      * @throws {@link Vital.UnprocessableEntityError}
      *
      * @example
      *     await client.vitals.caloriesBasal("user_id", {
-     *         startDate: "start_date"
+     *         provider: "provider",
+     *         startDate: "start_date",
+     *         endDate: "end_date"
      *     })
      */
-    caloriesBasal(userId: string, request: Vital.CaloriesBasalVitalsRequest, requestOptions?: Vitals.RequestOptions): Promise<Vital.ClientFacingCaloriesBasalTimeseries[]>;
+    caloriesBasal(userId: string, request: Vital.VitalsCaloriesBasalRequest, requestOptions?: Vitals.RequestOptions): Promise<Vital.ClientFacingCaloriesBasalTimeseries[]>;
     /**
      * @param {string} userId
-     * @param {Vital.CaloriesActiveVitalsRequest} request
+     * @param {Vital.VitalsCaloriesActiveRequest} request
      * @param {Vitals.RequestOptions} requestOptions - Request-specific configuration.
      *
      * @throws {@link Vital.UnprocessableEntityError}
      *
      * @example
      *     await client.vitals.caloriesActive("user_id", {
-     *         startDate: "start_date"
+     *         provider: "provider",
+     *         startDate: "start_date",
+     *         endDate: "end_date"
      *     })
      */
-    caloriesActive(userId: string, request: Vital.CaloriesActiveVitalsRequest, requestOptions?: Vitals.RequestOptions): Promise<Vital.ClientFacingCaloriesActiveTimeseries[]>;
+    caloriesActive(userId: string, request: Vital.VitalsCaloriesActiveRequest, requestOptions?: Vitals.RequestOptions): Promise<Vital.ClientFacingCaloriesActiveTimeseries[]>;
     /**
      * @param {string} userId
-     * @param {Vital.RespiratoryRateVitalsRequest} request
+     * @param {Vital.VitalsRespiratoryRateRequest} request
      * @param {Vitals.RequestOptions} requestOptions - Request-specific configuration.
      *
      * @throws {@link Vital.UnprocessableEntityError}
      *
      * @example
      *     await client.vitals.respiratoryRate("user_id", {
-     *         startDate: "start_date"
+     *         provider: "provider",
+     *         startDate: "start_date",
+     *         endDate: "end_date"
      *     })
      */
-    respiratoryRate(userId: string, request: Vital.RespiratoryRateVitalsRequest, requestOptions?: Vitals.RequestOptions): Promise<Vital.ClientFacingRespiratoryRateTimeseries[]>;
+    respiratoryRate(userId: string, request: Vital.VitalsRespiratoryRateRequest, requestOptions?: Vitals.RequestOptions): Promise<Vital.ClientFacingRespiratoryRateTimeseries[]>;
     /**
      * @param {string} userId
-     * @param {Vital.IgeVitalsRequest} request
+     * @param {Vital.VitalsIgeRequest} request
      * @param {Vitals.RequestOptions} requestOptions - Request-specific configuration.
      *
      * @throws {@link Vital.UnprocessableEntityError}
      *
      * @example
      *     await client.vitals.ige("user_id", {
-     *         startDate: "start_date"
+     *         provider: "provider",
+     *         startDate: "start_date",
+     *         endDate: "end_date"
      *     })
      */
-    ige(userId: string, request: Vital.IgeVitalsRequest, requestOptions?: Vitals.RequestOptions): Promise<Vital.ClientFacingIgeTimeseries[]>;
+    ige(userId: string, request: Vital.VitalsIgeRequest, requestOptions?: Vitals.RequestOptions): Promise<Vital.ClientFacingIgeTimeseries[]>;
     /**
      * @param {string} userId
-     * @param {Vital.IggVitalsRequest} request
+     * @param {Vital.VitalsIggRequest} request
      * @param {Vitals.RequestOptions} requestOptions - Request-specific configuration.
      *
      * @throws {@link Vital.UnprocessableEntityError}
      *
      * @example
      *     await client.vitals.igg("user_id", {
-     *         startDate: "start_date"
+     *         provider: "provider",
+     *         startDate: "start_date",
+     *         endDate: "end_date"
      *     })
      */
-    igg(userId: string, request: Vital.IggVitalsRequest, requestOptions?: Vitals.RequestOptions): Promise<Vital.ClientFacingIggTimeseries[]>;
+    igg(userId: string, request: Vital.VitalsIggRequest, requestOptions?: Vitals.RequestOptions): Promise<Vital.ClientFacingIggTimeseries[]>;
     /**
      * @param {string} userId
-     * @param {Vital.HypnogramVitalsRequest} request
+     * @param {Vital.VitalsHypnogramRequest} request
      * @param {Vitals.RequestOptions} requestOptions - Request-specific configuration.
      *
      * @throws {@link Vital.UnprocessableEntityError}
      *
      * @example
      *     await client.vitals.hypnogram("user_id", {
-     *         startDate: "start_date"
+     *         provider: "provider",
+     *         startDate: "start_date",
+     *         endDate: "end_date"
      *     })
      */
-    hypnogram(userId: string, request: Vital.HypnogramVitalsRequest, requestOptions?: Vitals.RequestOptions): Promise<Vital.ClientFacingHypnogramTimeseries[]>;
+    hypnogram(userId: string, request: Vital.VitalsHypnogramRequest, requestOptions?: Vitals.RequestOptions): Promise<Vital.ClientFacingHypnogramTimeseries[]>;
     /**
      * @param {string} userId
-     * @param {Vital.HrvVitalsRequest} request
+     * @param {Vital.VitalsHrvRequest} request
      * @param {Vitals.RequestOptions} requestOptions - Request-specific configuration.
      *
      * @throws {@link Vital.UnprocessableEntityError}
      *
      * @example
      *     await client.vitals.hrv("user_id", {
-     *         startDate: "start_date"
+     *         provider: "provider",
+     *         startDate: "start_date",
+     *         endDate: "end_date"
      *     })
      */
-    hrv(userId: string, request: Vital.HrvVitalsRequest, requestOptions?: Vitals.RequestOptions): Promise<Vital.ClientFacingHrvTimeseries[]>;
+    hrv(userId: string, request: Vital.VitalsHrvRequest, requestOptions?: Vitals.RequestOptions): Promise<Vital.ClientFacingHrvTimeseries[]>;
     /**
      * @param {string} userId
-     * @param {Vital.HeartrateVitalsRequest} request
+     * @param {Vital.VitalsHeartrateRequest} request
      * @param {Vitals.RequestOptions} requestOptions - Request-specific configuration.
      *
      * @throws {@link Vital.UnprocessableEntityError}
      *
      * @example
      *     await client.vitals.heartrate("user_id", {
-     *         startDate: "start_date"
+     *         provider: "provider",
+     *         startDate: "start_date",
+     *         endDate: "end_date"
      *     })
      */
-    heartrate(userId: string, request: Vital.HeartrateVitalsRequest, requestOptions?: Vitals.RequestOptions): Promise<Vital.ClientFacingHeartRateTimeseries[]>;
+    heartrate(userId: string, request: Vital.VitalsHeartrateRequest, requestOptions?: Vitals.RequestOptions): Promise<Vital.ClientFacingHeartRateTimeseries[]>;
     /**
      * @param {string} userId
-     * @param {Vital.GlucoseVitalsRequest} request
+     * @param {Vital.VitalsGlucoseRequest} request
      * @param {Vitals.RequestOptions} requestOptions - Request-specific configuration.
      *
      * @throws {@link Vital.UnprocessableEntityError}
      *
      * @example
      *     await client.vitals.glucose("user_id", {
-     *         startDate: "start_date"
+     *         provider: "provider",
+     *         startDate: "start_date",
+     *         endDate: "end_date"
      *     })
      */
-    glucose(userId: string, request: Vital.GlucoseVitalsRequest, requestOptions?: Vitals.RequestOptions): Promise<Vital.ClientFacingGlucoseTimeseries[]>;
+    glucose(userId: string, request: Vital.VitalsGlucoseRequest, requestOptions?: Vitals.RequestOptions): Promise<Vital.ClientFacingGlucoseTimeseries[]>;
     /**
      * @param {string} userId
-     * @param {Vital.CholesterolTriglyceridesVitalsRequest} request
+     * @param {Vital.VitalsCholesterolTriglyceridesRequest} request
      * @param {Vitals.RequestOptions} requestOptions - Request-specific configuration.
      *
      * @throws {@link Vital.UnprocessableEntityError}
      *
      * @example
      *     await client.vitals.cholesterolTriglycerides("user_id", {
-     *         startDate: "start_date"
+     *         provider: "provider",
+     *         startDate: "start_date",
+     *         endDate: "end_date"
      *     })
      */
-    cholesterolTriglycerides(userId: string, request: Vital.CholesterolTriglyceridesVitalsRequest, requestOptions?: Vitals.RequestOptions): Promise<Vital.ClientFacingCholesterolTimeseries[]>;
+    cholesterolTriglycerides(userId: string, request: Vital.VitalsCholesterolTriglyceridesRequest, requestOptions?: Vitals.RequestOptions): Promise<Vital.ClientFacingCholesterolTimeseries[]>;
     /**
      * @param {string} userId
-     * @param {Vital.CholesterolTotalVitalsRequest} request
+     * @param {Vital.VitalsCholesterolTotalRequest} request
      * @param {Vitals.RequestOptions} requestOptions - Request-specific configuration.
      *
      * @throws {@link Vital.UnprocessableEntityError}
      *
      * @example
      *     await client.vitals.cholesterolTotal("user_id", {
-     *         startDate: "start_date"
+     *         provider: "provider",
+     *         startDate: "start_date",
+     *         endDate: "end_date"
      *     })
      */
-    cholesterolTotal(userId: string, request: Vital.CholesterolTotalVitalsRequest, requestOptions?: Vitals.RequestOptions): Promise<Vital.ClientFacingCholesterolTimeseries[]>;
+    cholesterolTotal(userId: string, request: Vital.VitalsCholesterolTotalRequest, requestOptions?: Vitals.RequestOptions): Promise<Vital.ClientFacingCholesterolTimeseries[]>;
     /**
      * @param {string} userId
-     * @param {Vital.CholesterolLdlVitalsRequest} request
+     * @param {Vital.VitalsCholesterolLdlRequest} request
      * @param {Vitals.RequestOptions} requestOptions - Request-specific configuration.
      *
      * @throws {@link Vital.UnprocessableEntityError}
      *
      * @example
      *     await client.vitals.cholesterolLdl("user_id", {
-     *         startDate: "start_date"
+     *         provider: "provider",
+     *         startDate: "start_date",
+     *         endDate: "end_date"
      *     })
      */
-    cholesterolLdl(userId: string, request: Vital.CholesterolLdlVitalsRequest, requestOptions?: Vitals.RequestOptions): Promise<Vital.ClientFacingCholesterolTimeseries[]>;
+    cholesterolLdl(userId: string, request: Vital.VitalsCholesterolLdlRequest, requestOptions?: Vitals.RequestOptions): Promise<Vital.ClientFacingCholesterolTimeseries[]>;
     /**
      * @param {string} userId
-     * @param {Vital.CholesterolHdlVitalsRequest} request
+     * @param {Vital.VitalsCholesterolHdlRequest} request
      * @param {Vitals.RequestOptions} requestOptions - Request-specific configuration.
      *
      * @throws {@link Vital.UnprocessableEntityError}
      *
      * @example
      *     await client.vitals.cholesterolHdl("user_id", {
-     *         startDate: "start_date"
+     *         provider: "provider",
+     *         startDate: "start_date",
+     *         endDate: "end_date"
      *     })
      */
-    cholesterolHdl(userId: string, request: Vital.CholesterolHdlVitalsRequest, requestOptions?: Vitals.RequestOptions): Promise<Vital.ClientFacingCholesterolTimeseries[]>;
+    cholesterolHdl(userId: string, request: Vital.VitalsCholesterolHdlRequest, requestOptions?: Vitals.RequestOptions): Promise<Vital.ClientFacingCholesterolTimeseries[]>;
     /**
      * @param {string} userId
-     * @param {Vital.CholesterolVitalsRequest} request
+     * @param {Vital.VitalsCholesterolRequest} request
      * @param {Vitals.RequestOptions} requestOptions - Request-specific configuration.
      *
      * @throws {@link Vital.UnprocessableEntityError}
      *
      * @example
      *     await client.vitals.cholesterol("user_id", {
-     *         startDate: "start_date"
+     *         provider: "provider",
+     *         startDate: "start_date",
+     *         endDate: "end_date"
      *     })
      */
-    cholesterol(userId: string, request: Vital.CholesterolVitalsRequest, requestOptions?: Vitals.RequestOptions): Promise<Vital.ClientFacingCholesterolTimeseries[]>;
+    cholesterol(userId: string, request: Vital.VitalsCholesterolRequest, requestOptions?: Vitals.RequestOptions): Promise<Vital.ClientFacingCholesterolTimeseries[]>;
     /**
      * @param {string} userId
-     * @param {Vital.BodyWeightVitalsRequest} request
+     * @param {Vital.VitalsBodyWeightRequest} request
      * @param {Vitals.RequestOptions} requestOptions - Request-specific configuration.
      *
      * @throws {@link Vital.UnprocessableEntityError}
      *
      * @example
      *     await client.vitals.bodyWeight("user_id", {
-     *         startDate: "start_date"
+     *         provider: "provider",
+     *         startDate: "start_date",
+     *         endDate: "end_date"
      *     })
      */
-    bodyWeight(userId: string, request: Vital.BodyWeightVitalsRequest, requestOptions?: Vitals.RequestOptions): Promise<Vital.ClientFacingBodyWeightTimeseries[]>;
+    bodyWeight(userId: string, request: Vital.VitalsBodyWeightRequest, requestOptions?: Vitals.RequestOptions): Promise<Vital.ClientFacingBodyWeightTimeseries[]>;
     /**
      * @param {string} userId
-     * @param {Vital.BodyFatVitalsRequest} request
+     * @param {Vital.VitalsBodyFatRequest} request
      * @param {Vitals.RequestOptions} requestOptions - Request-specific configuration.
      *
      * @throws {@link Vital.UnprocessableEntityError}
      *
      * @example
      *     await client.vitals.bodyFat("user_id", {
-     *         startDate: "start_date"
+     *         provider: "provider",
+     *         startDate: "start_date",
+     *         endDate: "end_date"
      *     })
      */
-    bodyFat(userId: string, request: Vital.BodyFatVitalsRequest, requestOptions?: Vitals.RequestOptions): Promise<Vital.ClientFacingBodyFatTimeseries[]>;
+    bodyFat(userId: string, request: Vital.VitalsBodyFatRequest, requestOptions?: Vitals.RequestOptions): Promise<Vital.ClientFacingBodyFatTimeseries[]>;
     /**
      * @param {string} userId
-     * @param {Vital.BloodOxygenVitalsRequest} request
+     * @param {Vital.VitalsBloodOxygenRequest} request
      * @param {Vitals.RequestOptions} requestOptions - Request-specific configuration.
      *
      * @throws {@link Vital.UnprocessableEntityError}
      *
      * @example
      *     await client.vitals.bloodOxygen("user_id", {
-     *         startDate: "start_date"
+     *         provider: "provider",
+     *         startDate: "start_date",
+     *         endDate: "end_date"
      *     })
      */
-    bloodOxygen(userId: string, request: Vital.BloodOxygenVitalsRequest, requestOptions?: Vitals.RequestOptions): Promise<Vital.ClientFacingBloodOxygenTimeseries[]>;
+    bloodOxygen(userId: string, request: Vital.VitalsBloodOxygenRequest, requestOptions?: Vitals.RequestOptions): Promise<Vital.ClientFacingBloodOxygenTimeseries[]>;
     /**
      * @param {string} userId
-     * @param {Vital.ElectrocardiogramVoltageVitalsRequest} request
+     * @param {Vital.VitalsElectrocardiogramVoltageRequest} request
      * @param {Vitals.RequestOptions} requestOptions - Request-specific configuration.
      *
      * @throws {@link Vital.UnprocessableEntityError}
      *
      * @example
      *     await client.vitals.electrocardiogramVoltage("user_id", {
-     *         startDate: "start_date"
+     *         provider: "provider",
+     *         startDate: "start_date",
+     *         endDate: "end_date"
      *     })
      */
-    electrocardiogramVoltage(userId: string, request: Vital.ElectrocardiogramVoltageVitalsRequest, requestOptions?: Vitals.RequestOptions): Promise<Vital.ClientFacingElectrocardiogramVoltageTimeseries[]>;
+    electrocardiogramVoltage(userId: string, request: Vital.VitalsElectrocardiogramVoltageRequest, requestOptions?: Vitals.RequestOptions): Promise<Vital.ClientFacingElectrocardiogramVoltageTimeseries[]>;
     /**
      * @param {string} userId
-     * @param {Vital.BloodPressureVitalsRequest} request
+     * @param {Vital.VitalsBloodPressureRequest} request
      * @param {Vitals.RequestOptions} requestOptions - Request-specific configuration.
      *
      * @throws {@link Vital.UnprocessableEntityError}
      *
      * @example
      *     await client.vitals.bloodPressure("user_id", {
-     *         startDate: "start_date"
+     *         provider: "provider",
+     *         startDate: "start_date",
+     *         endDate: "end_date"
      *     })
      */
-    bloodPressure(userId: string, request: Vital.BloodPressureVitalsRequest, requestOptions?: Vitals.RequestOptions): Promise<Vital.ClientFacingBloodPressureTimeseries[]>;
+    bloodPressure(userId: string, request: Vital.VitalsBloodPressureRequest, requestOptions?: Vitals.RequestOptions): Promise<Vital.ClientFacingBloodPressureTimeseries[]>;
     protected _getCustomAuthorizationHeaders(): Promise<{
         "x-vital-api-key": string | undefined;
     }>;