Reference

Link

client.link.listBulkOps({ ...params }) -> Vital.BulkOpsResponse

🔌 Usage

await client.link.listBulkOps();

⚙️ Parameters

request: Vital.LinkListBulkOpsRequest

requestOptions: Link.RequestOptions

client.link.bulkImport({ ...params }) -> Vital.BulkImportConnectionsResponse

🔌 Usage

await client.link.bulkImport({
    provider: "oura",
    connections: [
        {
            userId: "user_id",
            accessToken: "access_token",
            refreshToken: "refresh_token",
            providerId: "provider_id",
            expiresAt: 1,
        },
    ],
});

⚙️ Parameters

request: Vital.BulkImportConnectionsBody

requestOptions: Link.RequestOptions

client.link.bulkTriggerHistoricalPull({ ...params }) -> unknown

🔌 Usage

await client.link.bulkTriggerHistoricalPull({
    userIds: ["user_ids"],
    provider: "oura",
});

⚙️ Parameters

request: Vital.BulkTriggerHistoricalPullBody

requestOptions: Link.RequestOptions

client.link.bulkExport({ ...params }) -> Vital.BulkExportConnectionsResponse

🔌 Usage

await client.link.bulkExport({
    provider: "oura",
});

⚙️ Parameters

request: Vital.BulkExportConnectionsBody

requestOptions: Link.RequestOptions

client.link.bulkPause({ ...params }) -> unknown

🔌 Usage

await client.link.bulkPause({
    userIds: ["user_ids"],
    provider: "oura",
});

⚙️ Parameters

request: Vital.BulkPauseConnectionsBody

requestOptions: Link.RequestOptions

client.link.token({ ...params }) -> Vital.LinkTokenExchangeResponse

📝 Description

Endpoint to generate a user link token, to be used throughout the vital link process. The vital link token is a one time use token, that expires after 10 minutes. If you would like vital-link widget to launch with a specific provider, pass in a provider in the body. If you would like to redirect to a custom url after successful or error connection, pass in your own custom redirect_url parameter.

🔌 Usage

await client.link.token({
    userId: "user_id",
});

⚙️ Parameters

request: Vital.LinkTokenExchange

requestOptions: Link.RequestOptions

client.link.isTokenValid({ ...params }) -> Record

🔌 Usage

await client.link.isTokenValid({
    token: "token",
});

⚙️ Parameters

request: Vital.LinkTokenValidationRequest

requestOptions: Link.RequestOptions

client.link.codeCreate({ ...params }) -> Vital.VitalTokenCreatedResponse

📝 Description

Generate a token to invite a user of Vital mobile app to your team

🔌 Usage

await client.link.codeCreate({
    userId: "user_id",
});

⚙️ Parameters

request: Vital.LinkCodeCreateRequest

requestOptions: Link.RequestOptions

client.link.startConnect({ ...params }) -> Record

📝 Description

REQUEST_SOURCE: VITAL-LINK Start link token process

🔌 Usage

await client.link.startConnect({
    linkToken: "link_token",
    provider: "oura",
});

⚙️ Parameters

request: Vital.BeginLinkTokenRequest

requestOptions: Link.RequestOptions

client.link.tokenState({ ...params }) -> Record

📝 Description

REQUEST_SOURCE: VITAL-LINK Check link token state - can be hit continuously used as heartbeat

🔌 Usage

await client.link.tokenState();

⚙️ Parameters

request: Vital.LinkTokenStateRequest

requestOptions: Link.RequestOptions

client.link.emailAuth({ ...params }) -> unknown

📝 Description

Deprecated. Use POST /v2/link/provider/email/{provider} instead.

🔌 Usage

await client.link.emailAuth({
    email: "email",
    provider: "oura",
    authType: "password",
});

⚙️ Parameters

request: Vital.EmailAuthLink

requestOptions: Link.RequestOptions

client.link.passwordAuth({ ...params }) -> unknown

📝 Description

Deprecated. Use POST /v2/link/provider/password/{provider} instead.

🔌 Usage

await client.link.passwordAuth({
    username: "username",
    password: "password",
    provider: "oura",
    authType: "password",
});

⚙️ Parameters

request: Vital.PasswordAuthLink

requestOptions: Link.RequestOptions

client.link.generateOauthLink(oauthProvider, { ...params }) -> Vital.Source

📝 Description

This endpoint generates an OAuth link for oauth provider

🔌 Usage

await client.link.generateOauthLink("oura");

⚙️ Parameters

oauthProvider: Vital.OAuthProviders

request: Vital.LinkGenerateOauthLinkRequest

requestOptions: Link.RequestOptions

client.link.connectPasswordProvider(provider, { ...params }) -> Vital.ProviderLinkResponse

📝 Description

This connects auth providers that are password based.

🔌 Usage

await client.link.connectPasswordProvider("whoop", {
    username: "username",
    password: "password",
});

⚙️ Parameters

provider: Vital.PasswordProviders

request: Vital.IndividualProviderData

requestOptions: Link.RequestOptions

client.link.completePasswordProviderMfa(provider, { ...params }) -> Vital.ProviderLinkResponse

📝 Description

This connects auth providers that are password based.

🔌 Usage

await client.link.completePasswordProviderMfa("whoop", {
    mfaCode: "mfa_code",
});

⚙️ Parameters

provider: Vital.PasswordProviders

request: Vital.CompletePasswordProviderMfaBody

requestOptions: Link.RequestOptions

client.link.connectEmailAuthProvider(provider, { ...params }) -> unknown

📝 Description

This connects auth providers that are email based.

🔌 Usage

await client.link.connectEmailAuthProvider("freestyle_libre", {
    email: "email",
});

⚙️ Parameters

provider: Vital.EmailProviders

request: Vital.EmailProviderAuthLink

requestOptions: Link.RequestOptions

client.link.getAllProviders({ ...params }) -> Vital.SourceLink[]

📝 Description

GET List of all available providers given the generated link token.

🔌 Usage

await client.link.getAllProviders();

⚙️ Parameters

request: Vital.LinkGetAllProvidersRequest

requestOptions: Link.RequestOptions

client.link.connectManualProvider(provider, { ...params }) -> Record

🔌 Usage

await client.link.connectManualProvider("beurer_ble", {
    userId: "user_id",
});

⚙️ Parameters

provider: Vital.ManualProviders

request: Vital.ManualConnectionData

requestOptions: Link.RequestOptions

client.link.connectDemoProvider({ ...params }) -> Vital.DemoConnectionStatus

📝 Description

POST Connect the given Vital user to a demo provider.

🔌 Usage

await client.link.connectDemoProvider({
    userId: "user_id",
    provider: "apple_health_kit",
});

⚙️ Parameters

request: Vital.DemoConnectionCreationPayload

requestOptions: Link.RequestOptions

Electrocardiogram

client.electrocardiogram.get(userId, { ...params }) -> Vital.ClientFacingElectrocardiogramResponse

📝 Description

Get electrocardiogram summary for user_id

🔌 Usage

await client.electrocardiogram.get("user_id", {
    startDate: "start_date",
});

⚙️ Parameters

userId: string

request: Vital.ElectrocardiogramGetRequest

requestOptions: Electrocardiogram.RequestOptions

SleepCycle

client.sleepCycle.get(userId, { ...params }) -> Vital.ClientSleepCycleResponse

📝 Description

Get sleep cycle for user_id

🔌 Usage

await client.sleepCycle.get("user_id", {
    startDate: "start_date",
});

⚙️ Parameters

userId: string

request: Vital.SleepCycleGetRequest

requestOptions: SleepCycle.RequestOptions

Profile

client.profile.get(userId, { ...params }) -> Vital.ClientFacingProfile

📝 Description

Get profile for user_id

🔌 Usage

await client.profile.get("user_id");

⚙️ Parameters

userId: string

request: Vital.ProfileGetRequest

requestOptions: Profile.RequestOptions

client.profile.getRaw(userId, { ...params }) -> Vital.RawProfile

📝 Description

Get raw profile for user_id

🔌 Usage

await client.profile.getRaw("user_id");

⚙️ Parameters

userId: string

request: Vital.ProfileGetRawRequest

requestOptions: Profile.RequestOptions

Devices

client.devices.getRaw(userId, { ...params }) -> Vital.RawDevices

📝 Description

Get Devices for user_id

🔌 Usage

await client.devices.getRaw("user_id");

⚙️ Parameters

userId: string

request: Vital.DevicesGetRawRequest

requestOptions: Devices.RequestOptions

Activity

client.activity.get(userId, { ...params }) -> Vital.ClientActivityResponse

📝 Description

Get activity summary for user_id

🔌 Usage

await client.activity.get("user_id", {
    startDate: "start_date",
});

⚙️ Parameters

userId: string

request: Vital.ActivityGetRequest

requestOptions: Activity.RequestOptions

client.activity.getRaw(userId, { ...params }) -> Vital.RawActivity

📝 Description

Get raw activity summary for user_id

🔌 Usage

await client.activity.getRaw("user_id", {
    startDate: "start_date",
});

⚙️ Parameters

userId: string

request: Vital.ActivityGetRawRequest

requestOptions: Activity.RequestOptions

Workouts

client.workouts.get(userId, { ...params }) -> Vital.ClientWorkoutResponse

📝 Description

Get workout summary for user_id

🔌 Usage

await client.workouts.get("user_id", {
    startDate: "start_date",
});

⚙️ Parameters

userId: string

request: Vital.WorkoutsGetRequest

requestOptions: Workouts.RequestOptions

client.workouts.getRaw(userId, { ...params }) -> Vital.RawWorkout

📝 Description

Get raw workout summary for user_id

🔌 Usage

await client.workouts.getRaw("user_id", {
    startDate: "start_date",
});

⚙️ Parameters

userId: string

request: Vital.WorkoutsGetRawRequest

requestOptions: Workouts.RequestOptions

client.workouts.getByWorkoutId(workoutId) -> Vital.ClientFacingStream

🔌 Usage

await client.workouts.getByWorkoutId("workout_id");

⚙️ Parameters

workoutId: string — The Vital ID for the workout

requestOptions: Workouts.RequestOptions

Sleep

client.sleep.get(userId, { ...params }) -> Vital.ClientSleepResponse

📝 Description

Get sleep summary for user_id

🔌 Usage

await client.sleep.get("user_id", {
    startDate: "start_date",
});

⚙️ Parameters

userId: string

request: Vital.SleepGetRequest

requestOptions: Sleep.RequestOptions

client.sleep.getStream(userId, { ...params }) -> Vital.ClientSleepResponse

📝 Description

Get sleep stream for user_id

🔌 Usage

await client.sleep.getStream("user_id", {
    startDate: "start_date",
});

⚙️ Parameters

userId: string

request: Vital.SleepGetStreamRequest

requestOptions: Sleep.RequestOptions

client.sleep.getRaw(userId, { ...params }) -> Vital.RawSleep

📝 Description

Get raw sleep summary for user_id

🔌 Usage

await client.sleep.getRaw("user_id", {
    startDate: "start_date",
});

⚙️ Parameters

userId: string

request: Vital.SleepGetRawRequest

requestOptions: Sleep.RequestOptions

client.sleep.getStreamBySleepId(sleepId) -> Vital.ClientFacingSleepStream

📝 Description

Get Sleep stream for a user_id

🔌 Usage

await client.sleep.getStreamBySleepId("sleep_id");

⚙️ Parameters

sleepId: string — The Vital Sleep ID

requestOptions: Sleep.RequestOptions

Body

client.body.get(userId, { ...params }) -> Vital.ClientBodyResponse

📝 Description

Get Body summary for user_id

🔌 Usage

await client.body.get("user_id", {
    startDate: "start_date",
});

⚙️ Parameters

userId: string

request: Vital.BodyGetRequest

requestOptions: Body.RequestOptions

client.body.getRaw(userId, { ...params }) -> Vital.RawBody

📝 Description

Get raw Body summary for user_id

🔌 Usage

await client.body.getRaw("user_id", {
    startDate: "start_date",
});

⚙️ Parameters

userId: string

request: Vital.BodyGetRawRequest

requestOptions: Body.RequestOptions

Meal

client.meal.get(userId, { ...params }) -> Vital.ClientFacingMealResponse

📝 Description

Get user's meals

🔌 Usage

await client.meal.get("user_id", {
    startDate: "start_date",
});

⚙️ Parameters

userId: string

request: Vital.MealGetRequest

requestOptions: Meal.RequestOptions

MenstrualCycle

client.menstrualCycle.get(userId, { ...params }) -> Vital.MenstrualCycleResponse

🔌 Usage

await client.menstrualCycle.get("user_id", {
    startDate: "start_date",
});

⚙️ Parameters

userId: string

request: Vital.MenstrualCycleGetRequest

requestOptions: MenstrualCycle.RequestOptions

Vitals

client.vitals.workoutSwimmingStrokeGrouped(userId, { ...params }) -> Vital.GroupedWorkoutSwimmingStrokeResponse

🔌 Usage

await client.vitals.workoutSwimmingStrokeGrouped("user_id", {
    startDate: "start_date",
});

⚙️ Parameters

userId: string

request: Vital.VitalsWorkoutSwimmingStrokeGroupedRequest

requestOptions: Vitals.RequestOptions

client.vitals.workoutDistanceGrouped(userId, { ...params }) -> Vital.GroupedWorkoutDistanceResponse

🔌 Usage

await client.vitals.workoutDistanceGrouped("user_id", {
    startDate: "start_date",
});

⚙️ Parameters

userId: string

request: Vital.VitalsWorkoutDistanceGroupedRequest

requestOptions: Vitals.RequestOptions

client.vitals.heartRateRecoveryOneMinuteGrouped(userId, { ...params }) -> Vital.GroupedHeartRateRecoveryOneMinuteResponse

🔌 Usage

await client.vitals.heartRateRecoveryOneMinuteGrouped("user_id", {
    startDate: "start_date",
});

⚙️ Parameters

userId: string

request: Vital.VitalsHeartRateRecoveryOneMinuteGroupedRequest

requestOptions: Vitals.RequestOptions

client.vitals.waistCircumferenceGrouped(userId, { ...params }) -> Vital.GroupedWaistCircumferenceResponse

🔌 Usage

await client.vitals.waistCircumferenceGrouped("user_id", {
    startDate: "start_date",
});

⚙️ Parameters

userId: string

request: Vital.VitalsWaistCircumferenceGroupedRequest

requestOptions: Vitals.RequestOptions

client.vitals.leanBodyMassGrouped(userId, { ...params }) -> Vital.GroupedLeanBodyMassResponse

🔌 Usage

await client.vitals.leanBodyMassGrouped("user_id", {
    startDate: "start_date",
});

⚙️ Parameters

userId: string

request: Vital.VitalsLeanBodyMassGroupedRequest

requestOptions: Vitals.RequestOptions

client.vitals.bodyMassIndexGrouped(userId, { ...params }) -> Vital.GroupedBodyMassIndexResponse

🔌 Usage

await client.vitals.bodyMassIndexGrouped("user_id", {
    startDate: "start_date",
});

⚙️ Parameters

userId: string

request: Vital.VitalsBodyMassIndexGroupedRequest

requestOptions: Vitals.RequestOptions

client.vitals.basalBodyTemperatureGrouped(userId, { ...params }) -> Vital.GroupedBasalBodyTemperatureResponse

🔌 Usage

await client.vitals.basalBodyTemperatureGrouped("user_id", {
    startDate: "start_date",
});

⚙️ Parameters

userId: string

request: Vital.VitalsBasalBodyTemperatureGroupedRequest

requestOptions: Vitals.RequestOptions

client.vitals.handwashingGrouped(userId, { ...params }) -> Vital.GroupedHandwashingResponse

🔌 Usage

await client.vitals.handwashingGrouped("user_id", {
    startDate: "start_date",
});

⚙️ Parameters

userId: string

request: Vital.VitalsHandwashingGroupedRequest

requestOptions: Vitals.RequestOptions

client.vitals.daylightExposureGrouped(userId, { ...params }) -> Vital.GroupedDaylightExposureResponse

🔌 Usage

await client.vitals.daylightExposureGrouped("user_id", {
    startDate: "start_date",
});

⚙️ Parameters

userId: string

request: Vital.VitalsDaylightExposureGroupedRequest

requestOptions: Vitals.RequestOptions

client.vitals.uvExposureGrouped(userId, { ...params }) -> Vital.GroupedUvExposureResponse

🔌 Usage

await client.vitals.uvExposureGrouped("user_id", {
    startDate: "start_date",
});

⚙️ Parameters

userId: string

request: Vital.VitalsUvExposureGroupedRequest

requestOptions: Vitals.RequestOptions

client.vitals.fallGrouped(userId, { ...params }) -> Vital.GroupedFallResponse

🔌 Usage

await client.vitals.fallGrouped("user_id", {
    startDate: "start_date",
});

⚙️ Parameters

userId: string

request: Vital.VitalsFallGroupedRequest

requestOptions: Vitals.RequestOptions

client.vitals.inhalerUsageGrouped(userId, { ...params }) -> Vital.GroupedInhalerUsageResponse

🔌 Usage

await client.vitals.inhalerUsageGrouped("user_id", {
    startDate: "start_date",
});

⚙️ Parameters

userId: string

request: Vital.VitalsInhalerUsageGroupedRequest

requestOptions: Vitals.RequestOptions

client.vitals.peakExpiratoryFlowRateGrouped(userId, { ...params }) -> Vital.GroupedPeakExpiratoryFlowRateResponse

🔌 Usage

await client.vitals.peakExpiratoryFlowRateGrouped("user_id", {
    startDate: "start_date",
});

⚙️ Parameters

userId: string

request: Vital.VitalsPeakExpiratoryFlowRateGroupedRequest

requestOptions: Vitals.RequestOptions

client.vitals.forcedVitalCapacityGrouped(userId, { ...params }) -> Vital.GroupedForcedVitalCapacityResponse

🔌 Usage

await client.vitals.forcedVitalCapacityGrouped("user_id", {
    startDate: "start_date",
});

⚙️ Parameters

userId: string

request: Vital.VitalsForcedVitalCapacityGroupedRequest

requestOptions: Vitals.RequestOptions

client.vitals.forcedExpiratoryVolume1Grouped(userId, { ...params }) -> Vital.GroupedForcedExpiratoryVolume1Response

🔌 Usage

await client.vitals.forcedExpiratoryVolume1Grouped("user_id", {
    startDate: "start_date",
});

⚙️ Parameters

userId: string

request: Vital.VitalsForcedExpiratoryVolume1GroupedRequest

requestOptions: Vitals.RequestOptions

client.vitals.wheelchairPushGrouped(userId, { ...params }) -> Vital.GroupedWheelchairPushResponse

🔌 Usage

await client.vitals.wheelchairPushGrouped("user_id", {
    startDate: "start_date",
});

⚙️ Parameters

userId: string

request: Vital.VitalsWheelchairPushGroupedRequest

requestOptions: Vitals.RequestOptions

client.vitals.sleepBreathingDisturbanceGrouped(userId, { ...params }) -> Vital.GroupedSleepBreathingDisturbanceResponse

🔌 Usage

await client.vitals.sleepBreathingDisturbanceGrouped("user_id", {
    startDate: "start_date",
});

⚙️ Parameters

userId: string

request: Vital.VitalsSleepBreathingDisturbanceGroupedRequest

requestOptions: Vitals.RequestOptions

client.vitals.sleepApneaAlertGrouped(userId, { ...params }) -> Vital.GroupedSleepApneaAlertResponse

🔌 Usage

await client.vitals.sleepApneaAlertGrouped("user_id", {
    startDate: "start_date",
});

⚙️ Parameters

userId: string

request: Vital.VitalsSleepApneaAlertGroupedRequest

requestOptions: Vitals.RequestOptions

client.vitals.standDurationGrouped(userId, { ...params }) -> Vital.GroupedStandDurationResponse

🔌 Usage

await client.vitals.standDurationGrouped("user_id", {
    startDate: "start_date",
});

⚙️ Parameters

userId: string

request: Vital.VitalsStandDurationGroupedRequest

requestOptions: Vitals.RequestOptions

client.vitals.standHourGrouped(userId, { ...params }) -> Vital.GroupedStandHourResponse

🔌 Usage

await client.vitals.standHourGrouped("user_id", {
    startDate: "start_date",
});

⚙️ Parameters

userId: string

request: Vital.VitalsStandHourGroupedRequest

requestOptions: Vitals.RequestOptions

client.vitals.heartRateAlertGrouped(userId, { ...params }) -> Vital.GroupedHeartRateAlertResponse

🔌 Usage

await client.vitals.heartRateAlertGrouped("user_id", {
    startDate: "start_date",
});

⚙️ Parameters

userId: string

request: Vital.VitalsHeartRateAlertGroupedRequest

requestOptions: Vitals.RequestOptions

client.vitals.afibBurdenGrouped(userId, { ...params }) -> Vital.GroupedAFibBurdenResponse

🔌 Usage

await client.vitals.afibBurdenGrouped("user_id", {
    startDate: "start_date",
});

⚙️ Parameters

userId: string

request: Vital.VitalsAfibBurdenGroupedRequest

requestOptions: Vitals.RequestOptions

client.vitals.workoutDurationGrouped(userId, { ...params }) -> Vital.GroupedWorkoutDurationResponse

🔌 Usage

await client.vitals.workoutDurationGrouped("user_id", {
    startDate: "start_date",
});

⚙️ Parameters

userId: string

request: Vital.VitalsWorkoutDurationGroupedRequest

requestOptions: Vitals.RequestOptions

client.vitals.vo2MaxGrouped(userId, { ...params }) -> Vital.GroupedVo2MaxResponse

🔌 Usage

await client.vitals.vo2MaxGrouped("user_id", {
    startDate: "start_date",
});

⚙️ Parameters

userId: string

request: Vital.VitalsVo2MaxGroupedRequest

requestOptions: Vitals.RequestOptions

client.vitals.stressLevelGrouped(userId, { ...params }) -> Vital.GroupedStressLevelResponse

🔌 Usage

await client.vitals.stressLevelGrouped("user_id", {
    startDate: "start_date",
});

⚙️ Parameters

userId: string

request: Vital.VitalsStressLevelGroupedRequest

requestOptions: Vitals.RequestOptions

client.vitals.mindfulnessMinutesGrouped(userId, { ...params }) -> Vital.GroupedMindfulnessMinutesResponse

🔌 Usage

await client.vitals.mindfulnessMinutesGrouped("user_id", {
    startDate: "start_date",
});

⚙️ Parameters

userId: string

request: Vital.VitalsMindfulnessMinutesGroupedRequest

requestOptions: Vitals.RequestOptions

client.vitals.caffeineGrouped(userId, { ...params }) -> Vital.GroupedCaffeineResponse

🔌 Usage

await client.vitals.caffeineGrouped("user_id", {
    startDate: "start_date",
});

⚙️ Parameters

userId: string

request: Vital.VitalsCaffeineGroupedRequest

requestOptions: Vitals.RequestOptions

client.vitals.waterGrouped(userId, { ...params }) -> Vital.GroupedWaterResponse

🔌 Usage

await client.vitals.waterGrouped("user_id", {
    startDate: "start_date",
});

⚙️ Parameters

userId: string

request: Vital.VitalsWaterGroupedRequest

requestOptions: Vitals.RequestOptions

client.vitals.stepsGrouped(userId, { ...params }) -> Vital.GroupedStepsResponse

🔌 Usage

await client.vitals.stepsGrouped("user_id", {
    startDate: "start_date",
});

⚙️ Parameters

userId: string

request: Vital.VitalsStepsGroupedRequest

requestOptions: Vitals.RequestOptions

client.vitals.floorsClimbedGrouped(userId, { ...params }) -> Vital.GroupedFloorsClimbedResponse

🔌 Usage

await client.vitals.floorsClimbedGrouped("user_id", {
    startDate: "start_date",
});

⚙️ Parameters

userId: string

request: Vital.VitalsFloorsClimbedGroupedRequest

requestOptions: Vitals.RequestOptions

client.vitals.distanceGrouped(userId, { ...params }) -> Vital.GroupedDistanceResponse

🔌 Usage

await client.vitals.distanceGrouped("user_id", {
    startDate: "start_date",
});

⚙️ Parameters

userId: string

request: Vital.VitalsDistanceGroupedRequest

requestOptions: Vitals.RequestOptions

client.vitals.caloriesBasalGrouped(userId, { ...params }) -> Vital.GroupedCaloriesBasalResponse

🔌 Usage

await client.vitals.caloriesBasalGrouped("user_id", {
    startDate: "start_date",
});

⚙️ Parameters

userId: string

request: Vital.VitalsCaloriesBasalGroupedRequest

requestOptions: Vitals.RequestOptions

client.vitals.caloriesActiveGrouped(userId, { ...params }) -> Vital.GroupedCaloriesActiveResponse

🔌 Usage

await client.vitals.caloriesActiveGrouped("user_id", {
    startDate: "start_date",
});

⚙️ Parameters

userId: string

request: Vital.VitalsCaloriesActiveGroupedRequest

requestOptions: Vitals.RequestOptions

client.vitals.respiratoryRateGrouped(userId, { ...params }) -> Vital.GroupedRespiratoryRateResponse

🔌 Usage

await client.vitals.respiratoryRateGrouped("user_id", {
    startDate: "start_date",
});

⚙️ Parameters

userId: string

request: Vital.VitalsRespiratoryRateGroupedRequest

requestOptions: Vitals.RequestOptions

client.vitals.noteGrouped(userId, { ...params }) -> Vital.GroupedNoteResponse

🔌 Usage

await client.vitals.noteGrouped("user_id", {
    startDate: "start_date",
});

⚙️ Parameters

userId: string

request: Vital.VitalsNoteGroupedRequest

requestOptions: Vitals.RequestOptions

client.vitals.insulinInjectionGrouped(userId, { ...params }) -> Vital.GroupedInsulinInjectionResponse

🔌 Usage

await client.vitals.insulinInjectionGrouped("user_id", {
    startDate: "start_date",
});

⚙️ Parameters

userId: string

request: Vital.VitalsInsulinInjectionGroupedRequest

requestOptions: Vitals.RequestOptions

client.vitals.igeGrouped(userId, { ...params }) -> Vital.GroupedIgeResponse

🔌 Usage

await client.vitals.igeGrouped("user_id", {
    startDate: "start_date",
});

⚙️ Parameters

userId: string

request: Vital.VitalsIgeGroupedRequest

requestOptions: Vitals.RequestOptions

client.vitals.iggGrouped(userId, { ...params }) -> Vital.GroupedIggResponse

🔌 Usage

await client.vitals.iggGrouped("user_id", {
    startDate: "start_date",
});

⚙️ Parameters

userId: string

request: Vital.VitalsIggGroupedRequest

requestOptions: Vitals.RequestOptions

client.vitals.hypnogramGrouped(userId, { ...params }) -> Vital.GroupedHypnogramResponse

🔌 Usage

await client.vitals.hypnogramGrouped("user_id", {
    startDate: "start_date",
});

⚙️ Parameters

userId: string

request: Vital.VitalsHypnogramGroupedRequest

requestOptions: Vitals.RequestOptions

client.vitals.hrvGrouped(userId, { ...params }) -> Vital.GroupedHrvResponse

🔌 Usage

await client.vitals.hrvGrouped("user_id", {
    startDate: "start_date",
});

⚙️ Parameters

userId: string

request: Vital.VitalsHrvGroupedRequest

requestOptions: Vitals.RequestOptions

client.vitals.heartrateGrouped(userId, { ...params }) -> Vital.GroupedHeartRateResponse

🔌 Usage

await client.vitals.heartrateGrouped("user_id", {
    startDate: "start_date",
});

⚙️ Parameters

userId: string

request: Vital.VitalsHeartrateGroupedRequest

requestOptions: Vitals.RequestOptions

client.vitals.glucoseGrouped(userId, { ...params }) -> Vital.GroupedGlucoseResponse

🔌 Usage

await client.vitals.glucoseGrouped("user_id", {
    startDate: "start_date",
});

⚙️ Parameters

userId: string

request: Vital.VitalsGlucoseGroupedRequest

requestOptions: Vitals.RequestOptions

client.vitals.cholesterolGrouped(userId, { ...params }) -> Vital.GroupedCholesterolResponse

🔌 Usage

await client.vitals.cholesterolGrouped("user_id", {
    startDate: "start_date",
});

⚙️ Parameters

userId: string

request: Vital.VitalsCholesterolGroupedRequest

requestOptions: Vitals.RequestOptions

client.vitals.carbohydratesGrouped(userId, { ...params }) -> Vital.GroupedCarbohydratesResponse

🔌 Usage

await client.vitals.carbohydratesGrouped("user_id", {
    startDate: "start_date",
});

⚙️ Parameters

userId: string

request: Vital.VitalsCarbohydratesGroupedRequest

requestOptions: Vitals.RequestOptions

client.vitals.bodyTemperatureDeltaGrouped(userId, { ...params }) -> Vital.GroupedBodyTemperatureDeltaResponse

🔌 Usage

await client.vitals.bodyTemperatureDeltaGrouped("user_id", {
    startDate: "start_date",
});

⚙️ Parameters

userId: string

request: Vital.VitalsBodyTemperatureDeltaGroupedRequest

requestOptions: Vitals.RequestOptions

client.vitals.bodyTemperatureGrouped(userId, { ...params }) -> Vital.GroupedBodyTemperatureResponse

🔌 Usage

await client.vitals.bodyTemperatureGrouped("user_id", {
    startDate: "start_date",
});

⚙️ Parameters

userId: string

request: Vital.VitalsBodyTemperatureGroupedRequest

requestOptions: Vitals.RequestOptions

client.vitals.bodyWeightGrouped(userId, { ...params }) -> Vital.GroupedBodyWeightResponse

🔌 Usage

await client.vitals.bodyWeightGrouped("user_id", {
    startDate: "start_date",
});

⚙️ Parameters

userId: string

request: Vital.VitalsBodyWeightGroupedRequest

requestOptions: Vitals.RequestOptions

client.vitals.bodyFatGrouped(userId, { ...params }) -> Vital.GroupedBodyFatResponse

🔌 Usage

await client.vitals.bodyFatGrouped("user_id", {
    startDate: "start_date",
});

⚙️ Parameters

userId: string

request: Vital.VitalsBodyFatGroupedRequest

requestOptions: Vitals.RequestOptions

client.vitals.bloodOxygenGrouped(userId, { ...params }) -> Vital.GroupedBloodOxygenResponse

🔌 Usage

await client.vitals.bloodOxygenGrouped("user_id", {
    startDate: "start_date",
});

⚙️ Parameters

userId: string

request: Vital.VitalsBloodOxygenGroupedRequest

requestOptions: Vitals.RequestOptions

client.vitals.electrocardiogramVoltageGrouped(userId, { ...params }) -> Vital.GroupedElectrocardiogramVoltageResponse

🔌 Usage

await client.vitals.electrocardiogramVoltageGrouped("user_id", {
    startDate: "start_date",
});

⚙️ Parameters

userId: string

request: Vital.VitalsElectrocardiogramVoltageGroupedRequest

requestOptions: Vitals.RequestOptions

client.vitals.bloodPressureGrouped(userId, { ...params }) -> Vital.GroupedBloodPressureResponse

🔌 Usage

await client.vitals.bloodPressureGrouped("user_id", {
    startDate: "start_date",
});

⚙️ Parameters

userId: string

request: Vital.VitalsBloodPressureGroupedRequest

requestOptions: Vitals.RequestOptions

client.vitals.vo2Max(userId, { ...params }) -> Vital.ClientFacingVo2MaxTimeseries[]

🔌 Usage

await client.vitals.vo2Max("user_id", {
    startDate: "start_date",
});

⚙️ Parameters

userId: string

request: Vital.VitalsVo2MaxRequest

requestOptions: Vitals.RequestOptions

client.vitals.stressLevel(userId, { ...params }) -> Vital.ClientFacingStressLevelTimeseries[]

🔌 Usage

await client.vitals.stressLevel("user_id", {
    startDate: "start_date",
});

⚙️ Parameters

userId: string

request: Vital.VitalsStressLevelRequest

requestOptions: Vitals.RequestOptions

client.vitals.mindfulnessMinutes(userId, { ...params }) -> Vital.ClientFacingMindfulnessMinutesTimeseries[]

🔌 Usage

await client.vitals.mindfulnessMinutes("user_id", {
    startDate: "start_date",
});

⚙️ Parameters

userId: string

request: Vital.VitalsMindfulnessMinutesRequest

requestOptions: Vitals.RequestOptions

client.vitals.caffeine(userId, { ...params }) -> Vital.ClientFacingCaffeineTimeseries[]

🔌 Usage

await client.vitals.caffeine("user_id", {
    startDate: "start_date",
});

⚙️ Parameters

userId: string

request: Vital.VitalsCaffeineRequest

requestOptions: Vitals.RequestOptions

client.vitals.water(userId, { ...params }) -> Vital.ClientFacingWaterTimeseries[]

🔌 Usage

await client.vitals.water("user_id", {
    startDate: "start_date",
});

⚙️ Parameters

userId: string

request: Vital.VitalsWaterRequest

requestOptions: Vitals.RequestOptions

client.vitals.steps(userId, { ...params }) -> Vital.ClientFacingStepsTimeseries[]

🔌 Usage

await client.vitals.steps("user_id", {
    startDate: "start_date",
});

⚙️ Parameters

userId: string

request: Vital.VitalsStepsRequest

requestOptions: Vitals.RequestOptions

client.vitals.floorsClimbed(userId, { ...params }) -> Vital.ClientFacingFloorsClimbedTimeseries[]

🔌 Usage

await client.vitals.floorsClimbed("user_id", {
    startDate: "start_date",
});

⚙️ Parameters

userId: string

request: Vital.VitalsFloorsClimbedRequest

requestOptions: Vitals.RequestOptions

client.vitals.distance(userId, { ...params }) -> Vital.ClientFacingDistanceTimeseries[]

🔌 Usage

await client.vitals.distance("user_id", {
    startDate: "start_date",
});

⚙️ Parameters

userId: string

request: Vital.VitalsDistanceRequest

requestOptions: Vitals.RequestOptions

client.vitals.caloriesBasal(userId, { ...params }) -> Vital.ClientFacingCaloriesBasalTimeseries[]

🔌 Usage

await client.vitals.caloriesBasal("user_id", {
    startDate: "start_date",
});

⚙️ Parameters

userId: string

request: Vital.VitalsCaloriesBasalRequest

requestOptions: Vitals.RequestOptions

client.vitals.caloriesActive(userId, { ...params }) -> Vital.ClientFacingCaloriesActiveTimeseries[]

🔌 Usage

await client.vitals.caloriesActive("user_id", {
    startDate: "start_date",
});

⚙️ Parameters

userId: string

request: Vital.VitalsCaloriesActiveRequest

requestOptions: Vitals.RequestOptions

client.vitals.respiratoryRate(userId, { ...params }) -> Vital.ClientFacingRespiratoryRateTimeseries[]

🔌 Usage

await client.vitals.respiratoryRate("user_id", {
    startDate: "start_date",
});

⚙️ Parameters

userId: string

request: Vital.VitalsRespiratoryRateRequest

requestOptions: Vitals.RequestOptions

client.vitals.ige(userId, { ...params }) -> Vital.ClientFacingIgeTimeseries[]

🔌 Usage

await client.vitals.ige("user_id", {
    startDate: "start_date",
});

⚙️ Parameters

userId: string

request: Vital.VitalsIgeRequest

requestOptions: Vitals.RequestOptions

client.vitals.igg(userId, { ...params }) -> Vital.ClientFacingIggTimeseries[]

🔌 Usage

await client.vitals.igg("user_id", {
    startDate: "start_date",
});

⚙️ Parameters

userId: string

request: Vital.VitalsIggRequest

requestOptions: Vitals.RequestOptions

client.vitals.hypnogram(userId, { ...params }) -> Vital.ClientFacingHypnogramTimeseries[]

🔌 Usage

await client.vitals.hypnogram("user_id", {
    startDate: "start_date",
});

⚙️ Parameters

userId: string

request: Vital.VitalsHypnogramRequest

requestOptions: Vitals.RequestOptions

client.vitals.hrv(userId, { ...params }) -> Vital.ClientFacingHrvTimeseries[]

🔌 Usage

await client.vitals.hrv("user_id", {
    startDate: "start_date",
});

⚙️ Parameters

userId: string

request: Vital.VitalsHrvRequest

requestOptions: Vitals.RequestOptions

client.vitals.heartrate(userId, { ...params }) -> Vital.ClientFacingHeartRateTimeseries[]

🔌 Usage

await client.vitals.heartrate("user_id", {
    startDate: "start_date",
});

⚙️ Parameters

userId: string

request: Vital.VitalsHeartrateRequest

requestOptions: Vitals.RequestOptions

client.vitals.glucose(userId, { ...params }) -> Vital.ClientFacingGlucoseTimeseries[]

🔌 Usage

await client.vitals.glucose("user_id", {
    startDate: "start_date",
});

⚙️ Parameters

userId: string

request: Vital.VitalsGlucoseRequest

requestOptions: Vitals.RequestOptions

client.vitals.cholesterolTriglycerides(userId, { ...params }) -> Vital.ClientFacingCholesterolTimeseries[]

🔌 Usage

await client.vitals.cholesterolTriglycerides("user_id", {
    startDate: "start_date",
});

⚙️ Parameters

userId: string

request: Vital.VitalsCholesterolTriglyceridesRequest

requestOptions: Vitals.RequestOptions

client.vitals.cholesterolTotal(userId, { ...params }) -> Vital.ClientFacingCholesterolTimeseries[]

🔌 Usage

await client.vitals.cholesterolTotal("user_id", {
    startDate: "start_date",
});

⚙️ Parameters

userId: string

request: Vital.VitalsCholesterolTotalRequest

requestOptions: Vitals.RequestOptions

client.vitals.cholesterolLdl(userId, { ...params }) -> Vital.ClientFacingCholesterolTimeseries[]

🔌 Usage

await client.vitals.cholesterolLdl("user_id", {
    startDate: "start_date",
});

⚙️ Parameters

userId: string

request: Vital.VitalsCholesterolLdlRequest

requestOptions: Vitals.RequestOptions

client.vitals.cholesterolHdl(userId, { ...params }) -> Vital.ClientFacingCholesterolTimeseries[]

🔌 Usage

await client.vitals.cholesterolHdl("user_id", {
    startDate: "start_date",
});

⚙️ Parameters

userId: string

request: Vital.VitalsCholesterolHdlRequest

requestOptions: Vitals.RequestOptions

client.vitals.cholesterol(userId, { ...params }) -> Vital.ClientFacingCholesterolTimeseries[]

🔌 Usage

await client.vitals.cholesterol("user_id", {
    startDate: "start_date",
});

⚙️ Parameters

userId: string

request: Vital.VitalsCholesterolRequest

requestOptions: Vitals.RequestOptions

client.vitals.bodyWeight(userId, { ...params }) -> Vital.ClientFacingBodyWeightTimeseries[]

🔌 Usage

await client.vitals.bodyWeight("user_id", {
    startDate: "start_date",
});

⚙️ Parameters

userId: string

request: Vital.VitalsBodyWeightRequest

requestOptions: Vitals.RequestOptions

client.vitals.bodyFat(userId, { ...params }) -> Vital.ClientFacingBodyFatTimeseries[]

🔌 Usage

await client.vitals.bodyFat("user_id", {
    startDate: "start_date",
});

⚙️ Parameters

userId: string

request: Vital.VitalsBodyFatRequest

requestOptions: Vitals.RequestOptions

client.vitals.bloodOxygen(userId, { ...params }) -> Vital.ClientFacingBloodOxygenTimeseries[]

🔌 Usage

await client.vitals.bloodOxygen("user_id", {
    startDate: "start_date",
});

⚙️ Parameters

userId: string

request: Vital.VitalsBloodOxygenRequest

requestOptions: Vitals.RequestOptions

client.vitals.electrocardiogramVoltage(userId, { ...params }) -> Vital.ClientFacingElectrocardiogramVoltageTimeseries[]

🔌 Usage

await client.vitals.electrocardiogramVoltage("user_id", {
    startDate: "start_date",
});

⚙️ Parameters

userId: string

request: Vital.VitalsElectrocardiogramVoltageRequest

requestOptions: Vitals.RequestOptions

client.vitals.bloodPressure(userId, { ...params }) -> Vital.ClientFacingBloodPressureTimeseries[]

🔌 Usage

await client.vitals.bloodPressure("user_id", {
    startDate: "start_date",
});

⚙️ Parameters

userId: string

request: Vital.VitalsBloodPressureRequest

requestOptions: Vitals.RequestOptions

User

client.user.getAll({ ...params }) -> Vital.PaginatedUsersResponse

📝 Description

GET All users for team.

🔌 Usage

await client.user.getAll();

⚙️ Parameters

request: Vital.UserGetAllRequest

requestOptions: User.RequestOptions

client.user.create({ ...params }) -> Vital.ClientFacingUserKey

📝 Description

POST Create a Vital user given a client_user_id and returns the user_id.

🔌 Usage

await client.user.create({
    clientUserId: "client_user_id",
});

⚙️ Parameters

request: Vital.UserCreateBody

requestOptions: User.RequestOptions

client.user.getTeamMetrics() -> Vital.MetricsResult

📝 Description

GET metrics for team.

🔌 Usage

await client.user.getTeamMetrics();

⚙️ Parameters

requestOptions: User.RequestOptions

client.user.getUserSignInToken(userId) -> Vital.UserSignInTokenResponse

🔌 Usage

await client.user.getUserSignInToken("user_id");

⚙️ Parameters

userId: string

requestOptions: User.RequestOptions

client.user.getConnectedProviders(userId) -> Record

📝 Description

GET Users connected providers

🔌 Usage

await client.user.getConnectedProviders("user_id");

⚙️ Parameters

userId: string

requestOptions: User.RequestOptions

client.user.get(userId) -> Vital.ClientFacingUser

📝 Description

GET User details given the user_id.

🔌 Usage

await client.user.get("user_id");

⚙️ Parameters

userId: string

requestOptions: User.RequestOptions

client.user.delete(userId) -> Vital.UserSuccessResponse

🔌 Usage

await client.user.delete("user_id");

⚙️ Parameters

userId: string

requestOptions: User.RequestOptions

client.user.patch(userId, { ...params }) -> void

🔌 Usage

await client.user.patch("user_id");

⚙️ Parameters

userId: string

request: Vital.UserPatchBody

requestOptions: User.RequestOptions

client.user.getLatestUserInfo(userId) -> Vital.UserInfo

🔌 Usage

await client.user.getLatestUserInfo("user_id");

⚙️ Parameters

userId: string

requestOptions: User.RequestOptions

client.user.createInsurance(userId, { ...params }) -> Vital.ClientFacingInsurance

🔌 Usage

await client.user.createInsurance("user_id", {
    payorCode: "payor_code",
    memberId: "member_id",
    relationship: "Self",
    insured: {
        firstName: "first_name",
        lastName: "last_name",
        gender: "female",
        address: {
            firstLine: "first_line",
            country: "country",
            zip: "zip",
            city: "city",
            state: "state",
        },
        dob: "dob",
        email: "email",
        phoneNumber: "phone_number",
    },
});

⚙️ Parameters

userId: string

request: Vital.CreateInsuranceRequest

requestOptions: User.RequestOptions

client.user.getLatestInsurance(userId) -> Vital.ClientFacingInsurance

🔌 Usage

await client.user.getLatestInsurance("user_id");

⚙️ Parameters

userId: string

requestOptions: User.RequestOptions

client.user.upsertUserInfo(userId, { ...params }) -> Vital.UserInfo

🔌 Usage

await client.user.upsertUserInfo("user_id", {
    firstName: "first_name",
    lastName: "last_name",
    email: "email",
    phoneNumber: "phone_number",
    gender: "gender",
    dob: "dob",
    address: {
        firstLine: "first_line",
        country: "country",
        zip: "zip",
        city: "city",
        state: "state",
    },
});

⚙️ Parameters

userId: string

request: Vital.UserInfoCreateRequest

requestOptions: User.RequestOptions

client.user.getByClientUserId(clientUserId) -> Vital.ClientFacingUser

📝 Description

GET user_id from client_user_id.

🔌 Usage

await client.user.getByClientUserId("client_user_id");

⚙️ Parameters

clientUserId: string — A unique ID representing the end user. Typically this will be a user ID number from your application. Personally identifiable information, such as an email address or phone number, should not be used in the client_user_id.

requestOptions: User.RequestOptions

client.user.deregisterProvider(userId, provider) -> Vital.UserSuccessResponse

🔌 Usage

await client.user.deregisterProvider("user_id", "oura");

⚙️ Parameters

userId: string

provider: Vital.Providers — Provider slug. e.g., oura, fitbit, garmin.

requestOptions: User.RequestOptions

client.user.undoDelete({ ...params }) -> Vital.UserSuccessResponse

🔌 Usage

await client.user.undoDelete();

⚙️ Parameters

request: Vital.UserUndoDeleteRequest

requestOptions: User.RequestOptions

client.user.refresh(userId, { ...params }) -> Vital.UserRefreshSuccessResponse

📝 Description

Trigger a manual refresh for a specific user

🔌 Usage

await client.user.refresh("user_id");

⚙️ Parameters

userId: string

request: Vital.UserRefreshRequest

requestOptions: User.RequestOptions

Team

client.team.getLinkConfig({ ...params }) -> Record

📝 Description

Post teams.

🔌 Usage

await client.team.getLinkConfig();

⚙️ Parameters

request: Vital.TeamGetLinkConfigRequest

requestOptions: Team.RequestOptions

client.team.get(teamId) -> Vital.ClientFacingTeam

📝 Description

Get team.

🔌 Usage

await client.team.get("team_id");

⚙️ Parameters

teamId: string

requestOptions: Team.RequestOptions

client.team.getUserById({ ...params }) -> Vital.ClientFacingUser[]

📝 Description

Search team users by user_id

🔌 Usage

await client.team.getUserById();

⚙️ Parameters

request: Vital.TeamGetUserByIdRequest

requestOptions: Team.RequestOptions

client.team.getSvixUrl() -> Record

🔌 Usage

await client.team.getSvixUrl();

⚙️ Parameters

requestOptions: Team.RequestOptions

client.team.getSourcePriorities({ ...params }) -> Record[]

📝 Description

GET source priorities.

🔌 Usage

await client.team.getSourcePriorities();

⚙️ Parameters

request: Vital.TeamGetSourcePrioritiesRequest

requestOptions: Team.RequestOptions

client.team.updateSourcePriorities() -> Record[]

📝 Description

Patch source priorities.

🔌 Usage

await client.team.updateSourcePriorities();

⚙️ Parameters

requestOptions: Team.RequestOptions

client.team.getPhysicians(teamId) -> Vital.ClientFacingPhysician[]

🔌 Usage

await client.team.getPhysicians("team_id");

⚙️ Parameters

teamId: string

requestOptions: Team.RequestOptions

Providers

client.providers.getAll({ ...params }) -> Vital.ClientFacingProviderDetailed[]

📝 Description

Get Provider list

🔌 Usage

await client.providers.getAll();

⚙️ Parameters

request: Vital.ProvidersGetAllRequest

requestOptions: Providers.RequestOptions

Introspect

client.introspect.getUserResources({ ...params }) -> Vital.UserResourcesResponse

🔌 Usage

await client.introspect.getUserResources();

⚙️ Parameters

request: Vital.IntrospectGetUserResourcesRequest

requestOptions: Introspect.RequestOptions

client.introspect.getUserHistoricalPulls({ ...params }) -> Vital.UserHistoricalPullsResponse

🔌 Usage

await client.introspect.getUserHistoricalPulls();

⚙️ Parameters

request: Vital.IntrospectGetUserHistoricalPullsRequest

requestOptions: Introspect.RequestOptions

LabTests

client.labTests.get({ ...params }) -> Vital.ClientFacingLabTest[]

📝 Description

GET all the lab tests the team has access to.

🔌 Usage

await client.labTests.get();

⚙️ Parameters

request: Vital.LabTestsGetRequest

requestOptions: LabTests.RequestOptions

client.labTests.create({ ...params }) -> Vital.ClientFacingLabTest

🔌 Usage

await client.labTests.create({
    name: "name",
    method: "testkit",
    description: "description",
});

⚙️ Parameters

request: Vital.CreateLabTestRequest

requestOptions: LabTests.RequestOptions

client.labTests.getById(labTestId) -> Vital.ClientFacingLabTest

📝 Description

GET all the lab tests the team has access to.

🔌 Usage

await client.labTests.getById("lab_test_id");

⚙️ Parameters

labTestId: string

requestOptions: LabTests.RequestOptions

client.labTests.updateLabTest(labTestId, { ...params }) -> Vital.ClientFacingLabTest

🔌 Usage

await client.labTests.updateLabTest("lab_test_id");

⚙️ Parameters

labTestId: string

request: Vital.UpdateLabTestRequest

requestOptions: LabTests.RequestOptions

client.labTests.getMarkers({ ...params }) -> Vital.GetMarkersResponse

📝 Description

GET all the markers for the given lab.

🔌 Usage

await client.labTests.getMarkers();

⚙️ Parameters

request: Vital.LabTestsGetMarkersRequest

requestOptions: LabTests.RequestOptions

client.labTests.getMarkersForOrderSet({ ...params }) -> Vital.GetMarkersResponse

🔌 Usage

await client.labTests.getMarkersForOrderSet({
    body: {},
});

⚙️ Parameters

request: Vital.LabTestsGetMarkersForOrderSetRequest

requestOptions: LabTests.RequestOptions

client.labTests.getMarkersForLabTest(labTestId, { ...params }) -> Vital.GetMarkersResponse

🔌 Usage

await client.labTests.getMarkersForLabTest("lab_test_id");

⚙️ Parameters

labTestId: string

request: Vital.LabTestsGetMarkersForLabTestRequest

requestOptions: LabTests.RequestOptions

client.labTests.getMarkersByLabAndProviderId(providerId, labId) -> Vital.ClientFacingMarker

📝 Description

GET a specific marker for the given lab and provider_id

🔌 Usage

await client.labTests.getMarkersByLabAndProviderId("provider_id", 1);

⚙️ Parameters

providerId: string

labId: number

requestOptions: LabTests.RequestOptions

client.labTests.getLabs() -> Vital.ClientFacingLab[]

📝 Description

GET all the labs.

🔌 Usage

await client.labTests.getLabs();

⚙️ Parameters

requestOptions: LabTests.RequestOptions

client.labTests.getPaginated({ ...params }) -> Vital.LabTestResourcesResponse

📝 Description

GET lab tests the team has access to as a paginated list.

🔌 Usage

await client.labTests.getPaginated();

⚙️ Parameters

request: Vital.LabTestsGetPaginatedRequest

requestOptions: LabTests.RequestOptions

client.labTests.getPhlebotomyAppointmentAvailability({ ...params }) -> Vital.AppointmentAvailabilitySlots

📝 Description

Return the available time slots to book an appointment with a phlebotomist for the given address and order.

🔌 Usage

await client.labTests.getPhlebotomyAppointmentAvailability({
    body: {
        firstLine: "first_line",
        city: "city",
        state: "state",
        zipCode: "zip_code",
    },
});

⚙️ Parameters

request: Vital.LabTestsGetPhlebotomyAppointmentAvailabilityRequest

requestOptions: LabTests.RequestOptions

client.labTests.bookPhlebotomyAppointment(orderId, { ...params }) -> Vital.ClientFacingAppointment

📝 Description

Book an at-home phlebotomy appointment.

🔌 Usage

await client.labTests.bookPhlebotomyAppointment("order_id", {
    bookingKey: "booking_key",
});

⚙️ Parameters

orderId: string — Your Order ID.

request: Vital.AppointmentBookingRequest

requestOptions: LabTests.RequestOptions

client.labTests.requestPhlebotomyAppointment(orderId, { ...params }) -> Vital.ClientFacingAppointment

📝 Description

Request an at-home phlebotomy appointment.

🔌 Usage

await client.labTests.requestPhlebotomyAppointment("order_id", {
    address: {
        firstLine: "first_line",
        city: "city",
        state: "state",
        zipCode: "zip_code",
    },
    provider: "getlabs",
});

⚙️ Parameters

orderId: string — Your Order ID.

request: Vital.RequestAppointmentRequest

requestOptions: LabTests.RequestOptions

client.labTests.reschedulePhlebotomyAppointment(orderId, { ...params }) -> Vital.ClientFacingAppointment

📝 Description

Reschedule a previously booked at-home phlebotomy appointment.

🔌 Usage

await client.labTests.reschedulePhlebotomyAppointment("order_id", {
    bookingKey: "booking_key",
});

⚙️ Parameters

orderId: string — Your Order ID.

request: Vital.AppointmentRescheduleRequest

requestOptions: LabTests.RequestOptions

client.labTests.cancelPhlebotomyAppointment(orderId, { ...params }) -> Vital.ClientFacingAppointment

📝 Description

Cancel a previously booked at-home phlebotomy appointment.

🔌 Usage

await client.labTests.cancelPhlebotomyAppointment("order_id", {
    cancellationReasonId: "cancellation_reason_id",
});

⚙️ Parameters

orderId: string — Your Order ID.

request: Vital.ApiApiV1EndpointsVitalApiLabTestingOrdersHelpersAppointmentCancelRequest

requestOptions: LabTests.RequestOptions

client.labTests.getPhlebotomyAppointmentCancellationReason() -> Vital.ClientFacingAppointmentCancellationReason[]

📝 Description

Get the list of reasons for cancelling an at-home phlebotomy appointment.

🔌 Usage

await client.labTests.getPhlebotomyAppointmentCancellationReason();

⚙️ Parameters

requestOptions: LabTests.RequestOptions

client.labTests.getPhlebotomyAppointment(orderId) -> Vital.ClientFacingAppointment

📝 Description

Get the appointment associated with an order.

🔌 Usage

await client.labTests.getPhlebotomyAppointment("order_id");

⚙️ Parameters

orderId: string — Your Order ID.

requestOptions: LabTests.RequestOptions

client.labTests.getAreaInfo({ ...params }) -> Vital.AreaInfo

📝 Description

GET information about an area with respect to lab-testing.

Information returned:

Whether a given zip code is served by our Phlebotomy network.
List of Lab locations in the area.

🔌 Usage

await client.labTests.getAreaInfo({
    zipCode: "zip_code",
});

⚙️ Parameters

request: Vital.LabTestsGetAreaInfoRequest

requestOptions: LabTests.RequestOptions

client.labTests.getPscInfo({ ...params }) -> Vital.PscInfo

🔌 Usage

await client.labTests.getPscInfo({
    zipCode: "zip_code",
    labId: 1,
});

⚙️ Parameters

request: Vital.LabTestsGetPscInfoRequest

requestOptions: LabTests.RequestOptions

client.labTests.getOrderPscInfo(orderId, { ...params }) -> Vital.PscInfo

🔌 Usage

await client.labTests.getOrderPscInfo("order_id");

⚙️ Parameters

orderId: string — Your Order ID.

request: Vital.LabTestsGetOrderPscInfoRequest

requestOptions: LabTests.RequestOptions

client.labTests.getResultMetadata(orderId) -> Vital.LabResultsMetadata

📝 Description

Return metadata related to order results, such as lab metadata, provider and sample dates.

🔌 Usage

await client.labTests.getResultMetadata("order_id");

⚙️ Parameters

orderId: string

requestOptions: LabTests.RequestOptions

client.labTests.getResultRaw(orderId) -> Vital.LabResultsRaw

📝 Description

Return both metadata and raw json test data

🔌 Usage

await client.labTests.getResultRaw("order_id");

⚙️ Parameters

orderId: string

requestOptions: LabTests.RequestOptions

client.labTests.getPscAppointmentAvailability({ ...params }) -> Vital.AppointmentAvailabilitySlots

🔌 Usage

await client.labTests.getPscAppointmentAvailability({
    lab: "quest",
});

⚙️ Parameters

request: Vital.LabTestsGetPscAppointmentAvailabilityRequest

requestOptions: LabTests.RequestOptions

client.labTests.bookPscAppointment(orderId, { ...params }) -> Vital.ClientFacingAppointment

🔌 Usage

await client.labTests.bookPscAppointment("order_id", {
    bookingKey: "booking_key",
});

⚙️ Parameters

orderId: string — Your Order ID.

request: Vital.AppointmentBookingRequest

requestOptions: LabTests.RequestOptions

client.labTests.reschedulePscAppointment(orderId, { ...params }) -> Vital.ClientFacingAppointment

🔌 Usage

await client.labTests.reschedulePscAppointment("order_id", {
    bookingKey: "booking_key",
});

⚙️ Parameters

orderId: string — Your Order ID.

request: Vital.AppointmentRescheduleRequest

requestOptions: LabTests.RequestOptions

client.labTests.cancelPscAppointment(orderId, { ...params }) -> Vital.ClientFacingAppointment

🔌 Usage

await client.labTests.cancelPscAppointment("order_id", {
    cancellationReasonId: "cancellationReasonId",
});

⚙️ Parameters

orderId: string — Your Order ID.

request: Vital.VitalCoreClientsLabTestGetlabsSchemaAppointmentCancelRequest

requestOptions: LabTests.RequestOptions

client.labTests.getPscAppointmentCancellationReason() -> Vital.ClientFacingAppointmentCancellationReason[]

🔌 Usage

await client.labTests.getPscAppointmentCancellationReason();

⚙️ Parameters

requestOptions: LabTests.RequestOptions

client.labTests.getPscAppointment(orderId) -> Vital.ClientFacingAppointment

📝 Description

Get the appointment associated with an order.

🔌 Usage

await client.labTests.getPscAppointment("order_id");

⚙️ Parameters

orderId: string — Your Order ID.

requestOptions: LabTests.RequestOptions

client.labTests.getOrder(orderId) -> Vital.ClientFacingOrder

📝 Description

GET individual order by ID.

🔌 Usage

await client.labTests.getOrder("order_id");

⚙️ Parameters

orderId: string — Your Order ID.

requestOptions: LabTests.RequestOptions

client.labTests.createOrder({ ...params }) -> Vital.PostOrderResponse

📝 Description

POST create new order

🔌 Usage

await client.labTests.createOrder({
    userId: "user_id",
    patientDetails: {
        firstName: "first_name",
        lastName: "last_name",
        dob: "dob",
        gender: "female",
        phoneNumber: "phone_number",
        email: "email",
    },
    patientAddress: {
        firstLine: "first_line",
        city: "city",
        state: "state",
        zip: "zip",
        country: "country",
    },
});

⚙️ Parameters

request: Vital.CreateOrderRequestCompatible

requestOptions: LabTests.RequestOptions

client.labTests.importOrder({ ...params }) -> Vital.PostOrderResponse

🔌 Usage

await client.labTests.importOrder({
    userId: "user_id",
    billingType: "client_bill",
    orderSet: {},
    collectionMethod: "testkit",
    patientDetails: {
        firstName: "first_name",
        lastName: "last_name",
        dob: "dob",
        gender: "female",
        phoneNumber: "phone_number",
        email: "email",
    },
    patientAddress: {
        receiverName: "receiver_name",
        firstLine: "first_line",
        city: "city",
        state: "state",
        zip: "zip",
        country: "country",
    },
    sampleId: "sample_id",
});

⚙️ Parameters

request: Vital.ImportOrderBody

requestOptions: LabTests.RequestOptions

client.labTests.cancelOrder(orderId) -> Vital.PostOrderResponse

📝 Description

POST cancel order

🔌 Usage

await client.labTests.cancelOrder("order_id");

⚙️ Parameters

orderId: string — Your Order ID.

requestOptions: LabTests.RequestOptions

client.labTests.simulateOrderProcess(orderId, { ...params }) -> unknown

📝 Description

Get available test kits.

🔌 Usage

await client.labTests.simulateOrderProcess("order_id");

⚙️ Parameters

orderId: string

request: Vital.LabTestsSimulateOrderProcessRequest

requestOptions: LabTests.RequestOptions

client.labTests.getOrders({ ...params }) -> Vital.GetOrdersResponse

📝 Description

GET many orders with filters.

🔌 Usage

await client.labTests.getOrders();

⚙️ Parameters

request: Vital.LabTestsGetOrdersRequest

requestOptions: LabTests.RequestOptions

Testkit

client.testkit.register({ ...params }) -> Vital.PostOrderResponse

🔌 Usage

await client.testkit.register({
    sampleId: "sample_id",
    patientDetails: {
        firstName: "first_name",
        lastName: "last_name",
        dob: "dob",
        gender: "female",
        phoneNumber: "phone_number",
        email: "email",
    },
    patientAddress: {
        firstLine: "first_line",
        city: "city",
        state: "state",
        zip: "zip",
        country: "country",
    },
});

⚙️ Parameters

request: Vital.RegisterTestkitRequest

requestOptions: Testkit.RequestOptions

client.testkit.createOrder({ ...params }) -> Vital.PostOrderResponse

📝 Description

Creates an order for an unregistered testkit

🔌 Usage

await client.testkit.createOrder({
    userId: "user_id",
    labTestId: "lab_test_id",
    shippingDetails: {
        receiverName: "receiver_name",
        firstLine: "first_line",
        city: "city",
        state: "state",
        zip: "zip",
        country: "country",
        phoneNumber: "phone_number",
    },
});

⚙️ Parameters

request: Vital.CreateRegistrableTestkitOrderRequest

requestOptions: Testkit.RequestOptions

Order

client.order.resendEvents({ ...params }) -> Vital.ResendWebhookResponse

📝 Description

Replay a webhook for a given set of orders

🔌 Usage

await client.order.resendEvents();

⚙️ Parameters

request: Vital.ResendWebhookBody

requestOptions: Order.RequestOptions

Insurance

client.insurance.searchGetPayorInfo({ ...params }) -> Vital.ClientFacingPayorSearchResponse[]

🔌 Usage

await client.insurance.searchGetPayorInfo();

⚙️ Parameters

request: Vital.InsuranceSearchGetPayorInfoRequest

requestOptions: Insurance.RequestOptions

client.insurance.searchPayorInfo({ ...params }) -> Vital.ClientFacingPayorSearchResponseDeprecated[]

🔌 Usage

await client.insurance.searchPayorInfo();

⚙️ Parameters

request: Vital.PayorSearchRequest

requestOptions: Insurance.RequestOptions

client.insurance.searchDiagnosis({ ...params }) -> Vital.ClientFacingDiagnosisInformation[]

🔌 Usage

await client.insurance.searchDiagnosis({
    diagnosisQuery: "diagnosis_query",
});

⚙️ Parameters

request: Vital.InsuranceSearchDiagnosisRequest

requestOptions: Insurance.RequestOptions

Aggregate

client.aggregate.queryOne(userId, { ...params }) -> Vital.AggregationResponse

🔌 Usage

await client.aggregate.queryOne("user_id", {
    timeframe: {
        type: "relative",
        anchor: "anchor",
        past: {
            unit: "minute",
        },
    },
    queries: [
        {
            select: [
                {
                    arg: {
                        sleep: "session_start",
                    },
                    func: "mean",
                },
            ],
        },
    ],
});

⚙️ Parameters

userId: string

request: Vital.QueryBatch

requestOptions: Aggregate.RequestOptions

client.aggregate.getResultTableForContinuousQuery(userId, queryIdOrSlug) -> Vital.AggregationResult

🔌 Usage

await client.aggregate.getResultTableForContinuousQuery("user_id", "query_id_or_slug");

⚙️ Parameters

userId: string

queryIdOrSlug: string

requestOptions: Aggregate.RequestOptions

Files

reference.md

Latest commit

History

reference.md

File metadata and controls

Reference

Link

🔌 Usage

⚙️ Parameters

🔌 Usage

⚙️ Parameters

🔌 Usage

⚙️ Parameters

🔌 Usage

⚙️ Parameters

🔌 Usage

⚙️ Parameters

📝 Description

🔌 Usage

⚙️ Parameters

🔌 Usage

⚙️ Parameters

📝 Description

🔌 Usage

⚙️ Parameters

📝 Description

🔌 Usage

⚙️ Parameters

📝 Description

🔌 Usage

⚙️ Parameters

📝 Description

🔌 Usage

⚙️ Parameters

📝 Description

🔌 Usage

⚙️ Parameters

📝 Description

🔌 Usage

⚙️ Parameters

📝 Description

🔌 Usage

⚙️ Parameters

📝 Description

🔌 Usage

⚙️ Parameters

📝 Description

🔌 Usage

⚙️ Parameters

📝 Description

🔌 Usage

⚙️ Parameters

🔌 Usage

⚙️ Parameters

📝 Description

🔌 Usage

⚙️ Parameters

Electrocardiogram

📝 Description

🔌 Usage

⚙️ Parameters

SleepCycle

📝 Description

🔌 Usage

⚙️ Parameters

Profile

📝 Description

🔌 Usage

⚙️ Parameters

📝 Description

🔌 Usage

⚙️ Parameters

Devices

📝 Description

🔌 Usage

⚙️ Parameters

Activity

📝 Description

🔌 Usage