Skip to content
Docs menu

Method reference

212 methods · garminconnect-js 0.12.0

212 of 212 shown

MethodDescriptionTags
addBodyCompositionRecords a weight (kg) with optional body-composition fields such as body fat and muscle mass, uploaded as a `.fit` weight-scale file built in memory. Builds a `.fit` binary in memory and uploads it via `client.upload` to `/upload-service/upload`; `weight` validated positive/finite, throws `GarminError` otherwise.write
addGearToActivityLinks a piece of gear to an activity. On 404 re-raises as `GarminConnectionError` ("gear not found (likely retired/removed)").write
addHydrationDataLogs water intake in milliliters (negative values subtract). There is no delete endpoint. Raw milliliters, magnitude capped at 10000, negative values allowed; no delete endpoint exists, so **not safely round-trippable**.write
addWeighInRecords a weigh-in in `"kg"` (the default) or `"lbs"`. `when` defaults to now. Defaults `unitKey="kg"`, `when=new Date()`.write
addWeighInWithTimestamps`addWeighIn` with explicit local and GMT timestamps. Same raw-value, no-conversion rule as `addWeighIn`; the two timestamps are COUPLED: the local instant resolves from `dateTimestamp` if given (naive strings read as LOCAL time) else from `when` (defaults `new Date()`), and `gmtTimestamp`, when omitted, is derived from THAT resolved instant, never independently from `when`. Both supplied strings are re-formatted rather than forwarded verbatim (a naive `gmtTimestamp` is read as UTC).write
confirmMenstrualPeriodStartConfirms that a period started on a date, with its period and cycle lengths. There is no undo. Needs cycle tracking set up in Garmin Connect first. POSTs `/periodichealth-service/menstrualcycle/{periodStartDate}` directly, NOT the `dayview`/`calendar`/`lastconfirmed`/`summary` sub-paths.write
countActivitiesThe total number of activities on the account. Returns the envelope's `totalCount`, not the whole response; throws `GarminError` if Garmin returns nothing or a non-numeric `totalCount`.read
createCalendarEventAdds a race or other event to the calendar. Always stored PRIVATE. POSTs `/calendar-service/event`. `CalendarEventInput` = `{name, date, startTime?: "HH:MM", timeZoneId?, eventType?, race?, primary?, distance?: {value, unit: meter|kilometer|yard|mile}, goalTimeSeconds?, location?, url?, note?}`; only `name`/`date` are required by Garmin (`'addEvent.arg3.eventName' must not be blank` otherwise). Garmin forces every user-created event **PRIVATE and unshareable** whatever is sent, sets `isTrainingEvent` whenever `isPrimaryEvent` is, and answers an unknown `eventType` with a 500. It also rewrote …write
createCourseSaves a course from a name and at least two geo points. Garmin computes the distance. POSTs `/course-service/course` with the template Garmin's web client sends. `CourseInput` = `{ name, geoPoints, coursePoints?, activityTypeId? = 1 (running), privacy? = "private" }`; privacy maps to `rulePK` public 1 / private 2. Garmin computes `distanceMeter` and elevation. Throws `GarminError` before any request on an empty name or fewer than two geoPoints.write
createCourseFromGpx`importCourseGpx` then `createCourse`, in one call. Name defaults to the GPX `<name>`, then the filename without `.gpx`.write
createCustomFoodCreates a custom food (per serving). Needs Connect+. **A PUT**, not a POST, to `/nutrition-service/customFood`; `CustomFoodInput` = `{name, calories, servingUnit? = "G", servingSize? = 100, brand?, carbs?, protein?, fat?, fiber?, sugar?, saturatedFat?, transFat?, sodium?, cholesterol?, potassium?, calcium?, iron?, vitaminD?}` per ONE serving, absolute amounts (not %DV); numbers are sent as strings, as Garmin's own client does. Returns the stored food with the `foodId`/`servingId` `logFood` takes.writeConnect+
createGearCreates a piece of gear (shoes, bike and so on). Usage limits are given in km and minutes. POSTs `/gear-service/gear/v2`; defaults `usageType="DISTANCE", notes=""`; `gearType`/`usageType` upper-cased via `validateSportKey`; **converts** `maxUsageDistanceKm` -> `maxUsageDistanceMeters` (`round(km*1000)`, floor 1) and `maxUsageDurationMin` -> `maxUsageDurationSeconds` (`round(min*60)`, floor 1), the opposite direction from `addWeighIn`'s "send raw" rule; returns the response unchecked.write
createManualActivityCreates a manual activity from a distance in km and a duration in minutes. `startDatetime` is a local timestamp with milliseconds, e.g. `"2026-09-22T10:00:00.000"`. **converts units**: `distanceKm * 1000` → meters, `durationMin * 60` → seconds, before building the request body; `startDatetime` is NOT routed through `formatDate` (it's a full local timestamp, not a bare calendar date) and **must include milliseconds**, e.g. `"2026-09-22T10:00:00.000"`; omitting them produced a live HTTP 500 `ValueInstantiationException` from Garmin during verification.write
createManualActivityFromJsonCreates a manual activity from a payload sent to Garmin verbatim. Sends `payload` to Garmin verbatim, no shape validation.write
deleteActivityDeletes an activity. IRREVERSIBLE. Resolves to `null` on success.destructive
deleteBloodPressureDeletes one blood-pressure reading by its `version`, taken from `getBloodPressure`. Deletes one reading by its `version`, taken from `getBloodPressure`.destructive
deleteCalendarEventIRREVERSIBLE. `DELETE /calendar-service/event/{id}`, resolves `null` (204).destructive
deleteCourseIRREVERSIBLE. A course created seconds ago may 429 "not yet ready"; retry shortly. `DELETE /course-service/course/{courseId}`, resolves `null` (204). May 429 "not yet ready" for a few seconds after creation.destructive
deleteCustomFoodIRREVERSIBLE. Needs Connect+. `DELETE /nutrition-service/customFood/{foodId}`, resolves `null`.destructiveConnect+
deleteFoodLogsDeletes log entries from one day, any number at once. IRREVERSIBLE. `DELETE /nutrition-service/food/logs/{date}` with `{logIds}` as the body: any number in ONE call, regular and quick-add alike. `logId`s are on the entries of `getNutritionDailyFoodLog`. Needs Connect+.destructiveConnect+
deleteGearDeletes a piece of gear and its activity history. IRREVERSIBLE. `DELETE /gear-service/gear/v2/{gearUUID}`, resolves `null` on success (204). **The UUID must be HYPHENATED**: `getGear` returns them WITHOUT hyphens and that form 404s, so this method re-inserts them for you when handed the bare 32-char form; only hand-rolled URLs hit the 404.destructive
deleteHeartRateZonesRemoves a sport's own zone profile; it falls back to DEFAULT. PUTs the stored profile back with `changeState: "DELETED"`, which removes it so the sport falls back to DEFAULT. Refuses DEFAULT; throws for a sport with no profile instead of doing nothing.destructive
deleteTrainingPlanQuits an enrolled plan ("Quit Plan"); its workouts leave the calendar. IRREVERSIBLE. `DELETE /trainingplan-service/trainingplan/trainingplan/{planId}` (the `trainingplan` segment really is doubled): the request Garmin Connect's "Quit Plan" sends, observed in the web client on 2026-10-06. Resolves `null` (204); the plan's scheduled workouts leave the calendar, completed activities stay. A second call is a 404 `"Training plan not found with ID: …"`.destructive
deleteWeighInDeletes one weigh-in, by date and its `weightPk`.destructive
deleteWeighInsDeletes the weigh-ins recorded on one date and returns how many went. IRREVERSIBLE. No HTTP path of its own: calls `getDailyWeighIns`, then loops `deleteWeighIn` per entry; returns `null` (deletes nothing) if there are zero entries, or more than one entry and `deleteAll` is not `true`; otherwise deletes every entry that day and returns the count.destructive
deleteWorkoutDeletes a workout from the library. IRREVERSIBLE.destructive
displayNameThe account's display name, which date-scoped endpoints put in their URLs. Cached.read
downloadActivityDownloads an activity file: `"ORIGINAL"` (the default), TCX, GPX, KML or CSV. `ActivityDownloadFormat` is `"ORIGINAL" | "TCX" | "GPX" | "KML" | "CSV"`, default `"ORIGINAL"`.read
downloadCourseGpxDownloads a saved course as GPX bytes. GETs `/course-service/course/gpx/{courseId}` through `client.download`.read
downloadHealthSnapshotDownloads the Health Snapshot recorded on a date, as raw bytes.read
downloadWorkoutDownloads a workout as FIT-file bytes.read
fullNameThe account holder's full name, from the cached user profile.read
getActivitiesA page of activities, newest first (`start` defaults to 0, `limit` to 20). Defaults `start=0, limit=20`.read
getActivitiesByDateEvery activity between two dates, optionally filtered by activity type. Pages through the results internally. Paginates internally: fetches fixed pages of 20, incrementing `start` by 20, until an empty page (normal end) or 2000 pages without one (throws `GarminError`).read
getActivitiesForDateThe activities recorded on one date. Despite the name, the path is `/mobile-gateway/heartRate/...`, not an activities-service path.read
getActivityOne activity by id; measurements are under `summaryDTO`. Throws `GarminError` if Garmin returns nothing. `ActivitySummary` extends `PersonalApi.ActivitySummaryDTO`, typed from Garmin's Personal API spec (AGENTS.md section 3).read
getActivityDetailsAn activity's time series and GPS track, capped at `maxchart`/`maxpoly` points. Defaults `maxchart=2000, maxpoly=4000`, sent as `maxChartSize`/`maxPolylineSize`.read
getActivityEventTypesThe event types `setActivityEventType` accepts. GETs `/activity-service/activity/eventTypes`: nine `{typeId, typeKey, sortOrder}` entries (`race`, `recreation`, `specialEvent`, `training`, `transportation`, `touring`, `geocaching`, `fitness`, `uncategorized`).read
getActivityExerciseSetsA strength activity's exercise sets.read
getActivityGearThe gear linked to an activity. Returns an ARRAY, verified live.read
getActivityHrInTimezonesTime spent in each heart-rate zone during an activity.read
getActivityPowerInTimezonesTime spent in each power zone during an activity.read
getActivitySplitsAn activity's laps.read
getActivitySplitSummariesSummaries of an activity's splits.read
getActivityTypedSplitsAn activity's typed splits, richer than `getActivitySplits` for some sports. Richer detail than `getActivitySplits` for some activity types (e.g. Bouldering).read
getActivityTypesEvery activity type Garmin knows: `{ typeId, typeKey, parentTypeId, ... }`.read
getActivityWeatherThe weather recorded for an activity.read
getActivityWorkoutsThe workouts done during an activity, with the steps the device ran. GETs `/activity-service/activity/{id}/workouts`: the workouts done during the activity, `{index, workoutName, timeCreated, sport, manufacturer, multisportSet, steps, workoutPhrase}` with the steps the device ran (`PersonalApi.ActivityWorkoutDTO`, matched key for key, steps included). `[]` for an activity done without one.read
getAdaptiveTrainingPlanByIdOne adaptive (Garmin Coach) training plan by id. GETs `/trainingplan-service/trainingplan/fbt-adaptive/{planId}`, a distinct sub-path from `getTrainingPlanById`'s `phased` path.read
getAdaptiveWorkoutA Garmin Coach workout by its workoutUuid (getWorkoutById cannot). GETs `/workout-service/fbt-adaptive/{uuid}`: a Garmin Coach workout with segments, steps and `estimatedTrainingEffect`. Coach workouts have no `workoutId`, and `getWorkoutById` cannot fetch them: `/workout-service/workout/{uuid}` is a 404. Take the uuid from `getTrainingPlanWorkouts` or `getScheduledWorkoutSummaries`.read
getAdhocChallengesAd-hoc challenges the account took part in. GETs `/adhocchallenge-service/adHocChallenge/historical`; `start` validated non-negative, `limit` validated positive (throws `GarminError` otherwise); returns an ARRAY, verified live.read
getAllDayEventsDaily events for one date (Garmin's `dailyEvents` feed).read
getAllDayStressAll-day stress levels for one date.read
getAvailableBadgeChallengesBadge challenges the account can join. Garmin rejects `start=0`; start at 1. GETs `/badgechallenge-service/badgeChallenge/available`; same `start`/`limit` validation; same array-not-dict correction and same live `start=0` -> 400 discovery as `getBadgeChallenges`.read
getAvailableBadgesBadges the account can still earn, each with `badgeImageUrls` added. GETs `/badge-service/badge/available?showExclusiveBadge=true`; same `badgeImageUrls` as `getEarnedBadges`; stays nullable.read
getBadgeChallengesCompleted badge challenges. Garmin rejects `start=0`; start at 1. GETs `/badgechallenge-service/badgeChallenge/completed`; same `start`/`limit` validation as `getAdhocChallenges`; returns an ARRAY, verified live. **Live discovery**: Garmin's server rejects `start=0` with a 400 (`"start should > 0."`) on this endpoint even though the client-side check allows it (non-negative); the 400 is Garmin's server, not a wrong URL; call with `start>=1` in practice.read
getBadgeDetailOne badge with its related series and what earned it. Works for unearned badges. GETs `/badge-service/badge/detail/v3/{badgeId}`, the request Garmin Connect's web app makes when a badge is opened; `badgeId` validated as a positive integer. Returns an OBJECT: the `getEarnedBadges` fields plus `relatedBadges` (the rest of the series, each with `earnedByMe`), `badgeAssocType`/`badgeAssocDataId`/`badgeAssocDataName` (for `"activityId"`, the activity that earned it) and `followings`. An unknown id is a **400** `GarminHttpError`, not a 404. The badge and each `relatedBadges` entry gain `badgeImageU…read
getBloodPressureBlood-pressure readings for a date or a date range (`enddate` defaults to `startdate`).read
getBodyBatteryDaily Body Battery reports for a date or a date range (`enddate` defaults to `startdate`).read
getBodyBatteryEventsBody Battery events for one date.read
getBodyCompositionBody-composition data for a date or a date range (`enddate` defaults to `startdate`). GETs `/weight-service/weight/dateRange`; throws `GarminError` if `startdate > enddate` `getStatsAndBody` (wellness service) now delegates to this instead of inlining its own copy of the same call.read
getCalendarEventOne calendar event by id. GETs `/calendar-service/event/{id}`; a missing id is a 404 `GarminHttpError`.read
getCaloriesDailyActive, resting and total calories per day over a date range. Merges active (metricId 22) and resting/BMR (metricId 23) series into `[{calendarDate, active, resting, total}]`.read
getCourseOne saved course by id. GETs `/course-service/course/{courseId}`; a missing id is a 404 `GarminHttpError` ("Course not found : {id}").read
getCurrentMaxDiveNumberCurrent maximum Dive number; reading does not reserve the next number. Reads, does not reserve the next number.read
getCustomFoodsYour custom foods, optionally filtered by name (limit <= 20). Needs Connect+. GETs `/nutrition-service/customFood` with `includeContent=true`: `{customFoods, moreDataAvailable}`. **`limit` is capped at 20** (Garmin 400s above it). There is NO get-by-id: `GET /customFood/{id}` is a 405, so search by name to read one back.readConnect+
getCustomFoodServingUnitsServing units a custom food can use. Needs Connect+. GETs `/nutrition-service/metadata/customFoodServingUnits` (13 units).readConnect+
getCyclingFtpThe latest cycling functional threshold power (FTP). Latest value only; use `getFunctionalThresholdPowerRange` for history.read
getDailyHydrationDaily hydration in milliliters, with the goal, over a date range; ranges over 31 days are chunked. GETs `/usersummary-service/stats/hydration/daily/{start}/{end}`: `{calendarDate, valueInML, goalInML}` per day that has an entry (the spec's `sweatLossInML`/`activityIntakeInML` were not seen). Garmin 400s `end - start > 30` ("cannot be more than 31 days"), so longer ranges go in 31-day windows.read
getDailyStatsPer-day calorie or step totals; ranges over 28 days are chunked. GETs `/usersummary-service/stats/daily/{start}/{end}?statsType=CALORIES|STEPS`; `statsType` is exactly `"CALORIES"` or `"STEPS"` (any other value, lower-case included, is a Garmin 404). Garmin 400s when `end - start > 27`, so longer ranges are fetched in 28-day windows and the rows concatenated; Garmin's per-request `aggregations` (averages) are DROPPED rather than returned wrong for a chunked range. A range with no data returns `[]` (Garmin answers `null`). Overlaps `getDailySteps`/`getCaloriesDaily`; this one returns total/act…read
getDailyStepsDaily step totals over a date range; ranges over 28 days are fetched in chunks. Auto-chunks ranges over Garmin's 28-day-per-request limit into ≤28-day windows and concatenates; a single request within the limit.read
getDailyStressDaily stress level and time at each stress level over a date range; ranges over 28 days are chunked. GETs `/usersummary-service/stats/stress/daily/{start}/{end}`: `{calendarDate, values: {overallStressLevel, restStressDuration, lowStressDuration, mediumStressDuration, highStressDuration}}` per day, durations in seconds. Garmin 400s `end - start > 27` ("cannot be more than 28 days"), so longer ranges go in 28-day windows; a reversed range throws `GarminError` before any request.read
getDailySummariesOne whole-day summary per day: steps, calories, heart rate, stress, Body Battery, SpO2 and more. Ranges over a year are chunked. GETs `/usersummary-service/v2/dailysummaries?startDate&endDate` and unwraps `data`: one object per day grouped by topic (`movement`, `calories`, `heartRate`, `intensityMinutes`, `stress`, `bodyBattery`, `hydration`, `respiration`, `pulseOx`, `jetLag`), typed from `PersonalApi.UserDailySummaryV2DTO`. Garmin caps one request at a year ("must be P1Y or less": a 365-day span passes, 366 is a 400), so longer ranges go in 365-day windows. Days with no data are ABSENT, not…read
getDailyWeighInsEvery weigh-in recorded on one date. GETs `/weight-service/weight/dayview/{cdate}?includeAll=true`.read
getDeviceAlarmsEvery alarm configured on every registered device. No HTTP path of its own: calls `getDevices()` once, then `getDeviceSettings(device.deviceId)` once per device (N+1 fan-out, sequential by design; do not parallelize), concatenating each device's `alarms`; a device with no alarms contributes nothing, never throws for that case.read
getDeviceLastUsedThe device used most recently. Also used internally by `pushWorkoutToDevice` to resolve a missing `deviceId`.read
getDevicesEvery device registered to the account. Undocumented per-device shape, `deviceId` is the field the other device methods key off of.read
getDeviceSettingsOne device's settings, by the `deviceId` from `getDevices`. `deviceId` coerced to an int, validated positive, re-stringified before being placed in the path Two-call sequence: get a `deviceId` from a `getDevices()` entry first, then pass it here.read
getDeviceSolarDataA solar device's charging input for a date or a date range (`enddate` defaults to `startdate`). The only raising method in this group: throws `GarminConnectionError` if the response is falsy or missing the `deviceSolarInput` key; returns `resp.deviceSolarInput`, NOT the envelope. `enddate` defaults to `startdate`, and `singleDayView` is sent `"true"` exactly when `enddate` was omitted.read
getDiveGearNumeric Dive gear ID and explicit local YYYY-MM-DD calendar date. Explicit local YYYY-MM-DD date.read
getDiveGearSummariesDive equipment summaries, distinct from Connect shoes/bicycles. Numeric Dive gear, unrelated to Connect gear UUIDs.read
getDiveLogFull Dive detail by Dive ID, not Connect activity ID. Full detail by Dive ID; depth and bottom-time measurements are under `profile`.read
getDiveLogByConnectActivityIdFull Dive detail using the explicit Connect activity ID bridge. Explicit ID bridge.read
getDiveLogsOne page of Dive summaries; no assumed paging defaults or automatic traversal. One page: `{totalCount, diveActivities?}`, with optional `pageSize`/`pageNumber`; an empty account returns only `{totalCount: 0}`, with or without paging params. Use `page?.diveActivities?.[0]`; no library-selected paging defaults.read
getDiverCertificationNumeric Dive gear ID and explicit local YYYY-MM-DD calendar date. Checks CERTIFICATION type; explicit local YYYY-MM-DD date.read
getDiverCertificationsCertification cards are Dive gear wrappers, not Connect gear UUID records. Gear wrappers, not bare cards.read
getDiverPrivacyDiver profile/statistics and default activity visibility settings. Profile and default activity settings.read
getDiveTagsAvailable Dive tag keys mapped to their numeric values. Tag key to number map.read
getEarnedBadgesBadges the account has earned, each with `badgeImageUrls` added. GETs `/badge-service/badge/earned`; each badge gains `badgeImageUrls: { small, large }`, added by this library (Garmin sends no image URL): `https://connect.garmin.com/images/badges/xxhdpi/badge_<badgeUuid ?? badgeId>_sml.png` (`_lrg.png` for `large`), the URL Garmin Connect's web app builds; public, no session. Every other field passes through unchanged; stays nullable (does NOT coalesce to `[]`).read
getEnduranceScoreEndurance score for a date, or weekly aggregates over a date range. TWO branches by presence of `enddate`: no `enddate` hits the single-day endpoint; with `enddate` hits `.../stats` with hard-coded `aggregation="weekly"`.read
getFitnessAgeDataFitness age for one date.read
getFloorsFloors climbed and descended for one date. Throws `GarminError` if Garmin returns nothing.read
getFunctionalThresholdPowerRangeFunctional threshold power (FTP) history for a sport over a date range. Defaults `sport="RUNNING"`, `aggregation="daily"`; `sport` upper-cased and validated (`^[A-Z_]+$`); `aggregation` restricted to `{daily,weekly,monthly,yearly}`.read
getGearEvery piece of gear on the account. `userProfileNumber` is the profile's numeric id. Hits `/gear-service/gear/filterGear?userProfilePk=...`; returns an ARRAY of gear entries, verified live. This is the dedicated gear-CRUD service, distinct from `getActivityGear` (activities service, reuses the same base URL with `activityId` instead).read
getGearActivitiesActivities that used a piece of gear (`limit` capped at 1000); `[]` if it is unknown. `limit` clamped to 1000; returns `[]` on a 404 instead of throwing.read
getGearDefaultsWhich gear is the default for which activity types. GETs `/gear-service/gear/user/{userProfileNumber}/activityTypes`; returns an ARRAY of `{uuid, activityTypePk, defaultGear}` entries, verified live.read
getGearStatsUsage totals for one piece of gear; `{}` if it is unknown. GETs `/gear-service/gear/stats/{gearUUID}`; `gearUUID` validated via `validateUuid` (hex, hyphens optional); returns `{}` on a 404 instead of throwing; other errors re-raised.read
getGoalsThe account's goals with a given status (active, future or past), every page fetched. Sends the `Sec-Fetch-Site: same-origin` header Garmin needs to return newer goal types. Defaults `status="active", **start=1**, limit=30`. `start` defaults to 1, NOT 0, because goal-service is 1-INDEXED and `start=0` silently returns `[]`; throws `GarminError` before any request for an invalid `status`. **Paginated, multi-call**: starting at `start`, fetches successive pages of `limit` entries (incrementing `start` by `limit` each call) until a page comes back empty/falsy, same fixed-page-size pattern as `ge…read
getGolfClubStatsPer-club golf stats. Defaults `limit=1000`; validated positive; GETs `/gcs-golfcommunity/api/v2/club/player`; hyphenated query params `per-page` and `include-stats` (literal `"true"`). **An ARRAY, verified live**: the test account returned a JSON ARRAY of 17 club entries (`{id, clubTypeId, shaftLength, flexTypeId, averageDistance, adviceDistance, retired, deleted, lastModifiedTime}`), not a single object.read
getGolfScorecardOne golf scorecard in full. GETs `/gcs-golfcommunity/api/v2/scorecard/detail`; hyphenated query params `scorecard-ids` and `include-longest-shot-distance` (sent as the literal string `"true"`).read
getGolfShotDataShot data for a scorecard, optionally for some holes only (e.g. `"1,2,3"`). GETs `/gcs-golfcommunity/api/v2/shot/scorecard/{scorecardId}/hole`; `holeNumbers` accepts commas or hyphens as separators (spaces stripped), re-joined with `-` before sending as the hyphenated `hole-numbers` param; **if any requested hole number is >9, the filter is silently dropped and all 18 holes are requested instead** (Garmin's endpoint drops double-digit hole numbers from a filtered query); omitting `holeNumbers` also fetches all 18.read
getGolfSummaryA page of golf scorecard summaries. Defaults `start=0, limit=100`; `start` validated non-negative, `limit` validated positive (throws `GarminError` otherwise); query params are literally hyphenated (`per-page`, `start`), matching Garmin's own naming. **An OBJECT, not an array, verified live**: the test account (0 rounds recorded) returned a single pagination-envelope OBJECT `{pageNumber, rowsPerPage, totalRows}`, not an array.read
getGolfUserStatsGolf handicap and strokes-gained overview. GETs `/gcs-golfcommunity/api/v2/player/stats`; handicap and strokes-gained overview, no params.read
getHeartRatesHeart-rate samples plus resting, min and max heart rate for one date.read
getHeartRateZonesHeart-rate zone profiles: DEFAULT plus any per-sport ones.read
getHillScoreHill score for a date, or daily values over a date range. TWO branches by presence of `enddate`, same shape as `getEnduranceScore` but the range branch hard-codes `aggregation="daily"` (NOT `"weekly"`; do not conflate the two).read
getHrvDataHeart-rate variability (HRV) readings and status for one date.read
getHrvDataRangeDaily HRV summaries over a date range.read
getHydrationDataThe hydration log for one date.read
getInProgressBadgesBadges with progress towards them, from the earned and available lists. No HTTP path of its own: calls `getEarnedBadges()` and `getAvailableBadges()`, filters each with an in-progress predicate (progress truthy; if `progress === target`, only "in progress" when `badgeLimitCount` is set and `badgeEarnedNumber < badgeLimitCount`), then merges both filtered lists into a `Map` keyed by `badgeId` (available overwrites earned on collision, keeping the earned entry's position); never raises: a `null` from either call is treated as `[]`. Badges carry `badgeImageUrls` (inherited from the two calls).read
getInprogressVirtualChallengesVirtual challenges in progress. `start` must be at least 1. GETs `/badgechallenge-service/virtualChallenge/inProgress`; **asymmetric validation**: `start` validated POSITIVE here (rejects `start=0`), unlike the non-negative `start` on the four challenge methods above; `limit` validated positive; same array-not-dict correction.read
getIntensityMinutesDataModerate and vigorous intensity minutes for one date.read
getLactateThresholdLactate threshold: the latest values (default), or history over a date range when `latest` is `false`. Defaults `latest=true`, `aggregation="daily"`. TWO DIFFERENT branches: `latest=true` returns `{speed_and_heart_rate, power}` from two GETs; `latest=false` (requires `startDate`, throws otherwise) returns `{speed, heart_rate, power}` from three GETs.read
getLastActivityThe most recent activity, or `null` if there are none. Delegates to `getActivities(0, 1)`, returns the last element or `null`.read
getLifestyleLoggingDataLifestyle logging entries for one date. GETs `/lifestylelogging-service/dailyLog/{cdate}` Grouped under `misc` per the plan's explicit instruction, even though it superficially resembles a wellness-daily endpoint.read
getMaxMetricsMax metrics (VO2 max and related values) for one date. The date is repeated twice in the path (start=end=cdate).read
getMaxMetricsRangeMax metrics (VO2 max and related values) over a date range. Throws `GarminError` if `start > end`.read
getMenstrualCalendarDataMenstrual-cycle calendar data between two dates (Garmin allows up to 91 days). Garmin rejects windows of 92+ inclusive days; not enforced here (caller's responsibility).read
getMenstrualCycleSummaryA summary of the menstrual cycle containing a date.read
getMenstrualDataForDateThe menstrual-cycle day view for one date.read
getMenstrualLastConfirmedThe last confirmed period as of a date.read
getMenstrualReportsMenstrual-cycle reports over the last 1, 6 (the default) or 12 cycles. Defaults `numberOfCycles=6, nextReport=false, reportType="CYCLE"`, `todayCalendarDate` defaults to today; `numberOfCycles` restricted to `{1,6,12}` or throws `GarminError`.read
getMorningTrainingReadinessThe training readiness score computed after waking up on a date. Delegates to `getTrainingReadiness`, no HTTP call of its own; filters for `inputContext === "AFTER_WAKEUP_RESET"`, falls back to the first entry; `null` for a falsy or empty result.read
getNextScheduledWorkoutThe next scheduled workout from this month or next, or `{}` if there is none. Computed from two `getScheduledWorkouts` calls (this month + next, handling Dec->Jan rollover); returns `{}` if nothing matches, never throws.read
getNonCompletedBadgeChallengesBadge challenges joined but not completed. Garmin rejects `start=0`. GETs `/badgechallenge-service/badgeChallenge/non-completed`; same `start`/`limit` validation; same array-not-dict correction and same live `start=0` -> 400 discovery as `getBadgeChallenges`.read
getNutritionDailyFoodLogThe food log for one date. GETs `/nutrition-service/food/logs/{cdate}`.read
getNutritionDailyMealsMeals logged on one date. GETs `/nutrition-service/meals/{cdate}`.read
getNutritionDailySettingsNutrition settings and goals in effect on one date. GETs `/nutrition-service/settings/{cdate}`.read
getNutritionFoodLogRangeDaily food logs over a range; works without Connect+. GETs `/nutrition-service/food/logs/range?startDate&endDate`: `{dailyNutritionSummaries}`, one day-log per day that has anything logged.read
getPersonalRecordThe account's personal records, one row per record type. GETs `/personalrecord-service/personalrecord/prs/{displayName}`; no args `PersonalRecords` is `PersonalRecord[]`, **an ARRAY, verified live** (the test account returned `array[0]`). Note the plural type name: the method name is singular but the payload is a list.read
getPowerZonesPower zone profiles.read
getPowerZonesForSportPower zones for one sport, e.g. `"CYCLING"`. `sport` upper-cased and validated the same way as `getFunctionalThresholdPowerRange`.read
getPregnancySummaryThe pregnancy-tracking summary.read
getPrimaryTrainingDeviceThe account's primary training device.read
getProgressSummaryBetweenDatesTotals of one metric (default `distance`) between two dates, grouped by activity type by default. Defaults `metric="distance", groupbyactivities=true`.read
getRacePredictionsPredicted race times: the latest, or daily/monthly history when all three args are given. TWO branches, all-or-nothing params (throws on a partial combination): no params hits `.../latest/{displayName}`; all three hit `.../{type}/{displayName}`, capped at a 366-day span.read
getRespirationDataBreathing-rate data for one date.read
getRhrDailyResting heart rate per day over a date range, as `{ calendarDate, value }` rows. Reshapes `allMetrics.metricsMap` into `[{calendarDate, value}]`, dropping null values.read
getRhrDayResting heart rate for one date.read
getRunningToleranceRunning tolerance over a date range, aggregated weekly (the default) or daily. Defaults `aggregation="weekly"`; restricted to `{daily,weekly}` (narrower than the FTP/lactate methods).read
getScheduledWorkoutByIdOne scheduled workout by its scheduled-workout id. Uses a DIFFERENT base (`/workout-service/schedule`) than `getScheduledWorkouts` (`/calendar-service`).read
getScheduledWorkoutsThe calendar for one month (`month` is 1-12): scheduled workouts, events and more. `month` is 1-12 on the way in, converted to 0-indexed on the wire; validates `year>=2000`, `month` 1-12.read
getScheduledWorkoutSummariesEvery scheduled workout between two dates, as compact summaries. POSTs the fixed GraphQL query `workoutScheduleSummariesScalar(startDate, endDate)`: every scheduled workout in the range, plan or self-scheduled (`tpType: null`), as compact rows whose `scheduledWorkoutId` is what `unscheduleWorkout` takes, or `null` for a Garmin Coach workout, which also has `tpType: null` like a self-scheduled one (tell them apart by `fbtAdaptivePlanId`). Dates are validated before they are spliced into the query. A GraphQL error arrives as HTTP 200 with `errors`, turned into a `GarminError`. **It LAGS writes*…read
getSharedCalendarEventA race from Garmin's events catalogue by its shareableEventUuid; no subscription needed. GETs `/calendar-service/event/{uuid}/shareable`: an event from Garmin's public events catalogue (Races & Events -> Find an Event), with `locationStartPoint`, `subscribersCount`, `provider` and `subscribed`. Works WITHOUT subscribing (`subscribed: false`). The plain `/event/{uuid}` is a 404. Events you create never get a shareable uuid (Garmin forces them private).read
getSleepDailyPer-night sleep stats over a date range; ranges over 28 days are fetched in chunks. Garmin's endpoint has a documented **28-day-per-request limit**; ranges beyond that are auto-chunked, de-duplicated by `calendarDate`, and sorted.read
getSleepDataSleep data for one date: the night's summary and its sleep levels.read
getSpo2AcclimationOne day's SpO2 readings with altitude acclimation. GETs `/wellness-service/wellness/daily/spo2acclimation/{cdate}` (Garmin's Personal API spec): the day's SpO2 averages, sleep and hourly series and the monitoring environment, typed from `PersonalApi.DailySpO2AndAcclimationDTO`. Distinct from `getSpo2Data`'s path. A day with no data (even 2030-01-01) still returns the object, fields `null`.read
getSpo2DataPulse-oximeter (SpO2) readings for one date. Coerces a string `lastSevenDaysAvgSpO2` to a number.read
getStatsAlias of getUserSummary. Alias of `getUserSummary`.read
getStatsAndBody`getUserSummary` merged with the day's body-composition averages. Merges `getUserSummary` with the body-composition `totalAverage` block, delegating to `getBodyComposition` (bodyComposition service) for the latter.read
getStepsDataStep counts for one date, as a series of time intervals; `[]` if there are none.read
getStressDataAlias of `getAllDayStress`. Identical URL to `getAllDayStress`; an alias.read
getTrainingPlanByIdOne phased training plan by id. GETs `/trainingplan-service/trainingplan/phased/{planId}`.read
getTrainingPlansThe account's training plans. GETs `/trainingplan-service/trainingplan/plans`; no params.read
getTrainingPlanWorkoutsEnrolled training plans' workouts around a date, grouped by plan. POSTs GraphQL `trainingPlanScalar(calendarDate, lang, firstDayOfWeek)` (all three arguments are REQUIRED by Garmin) and unwraps `trainingPlanWorkoutScheduleDTOS`: one entry per enrolled plan, `{trainingPlanId, planName, trainingPlanClassification, trainingPlanDetailsDTO, workoutScheduleSummaries}`. Garmin picks the window (18 workouts across several weeks for an ITP plan); `[]` with no plan.read
getTrainingReadinessTraining readiness entries for one date.read
getTrainingStatusTraining status for one date.read
getUserProfileCached per instance; every date-scoped endpoint needs the display name.read
getUserprofileSettingsThe account's profile settings record, from `/userprofile-service/userprofile/settings`. Distinct from `getUserSettings()` ("user-settings"): the two paths are one character apart. GETs `/userprofile-service/userprofile/settings` (SINGULAR "settings", distinct from `getUserSettings`'s "user-settings"; the two paths are one character apart and easy to transpose) Three profile endpoints, three methods: `getUserProfile()` reads `/userprofile-service/socialProfile` (and backs `displayName`/`fullName`/`userName`), `getUserSettings()` reads `/userprofile-service/userprofile/user-settings` (and back…read
getUserSettingsCached per instance, same eviction-on-failure pattern as `getUserProfile()`.read
getUserSummaryThe daily summary for one date: steps, distance, calories and the rest of the day's totals.read
getWeeklyIntensityMinutesWeekly intensity-minute totals between two dates.read
getWeeklyStepsWeekly step totals for the `weeks` weeks (default 52) ending on `end`. `weeks` defaults to 52, must be a positive integer.read
getWeeklyStressWeekly stress averages for the `weeks` weeks (default 52) ending on `end`. Same `weeks` default/validation as `getWeeklySteps`.read
getWeighInsWeigh-ins between two dates.read
getWeightGoalsThe weight goals in effect between two dates, in grams. GETs `/goal-service/goal/user/effective/weightgoal/{start}/{end}`: `{userGoals, userGoalRanges}`, weights in GRAMS (`PersonalApi.UserGoalsRangeDTO`). No range limit found (1000 days answered); a reversed range throws before any request although Garmin itself accepts one.read
getWorkoutByIdOne workout from the library by id.read
getWorkoutsA page of the workout library (`start` defaults to 0, `limit` to 100). Defaults `start=0, limit=100`, stays nullable (does NOT coalesce to `[]`).read
hasConnectPlusWhether the account has a Garmin Connect+ subscription, from the cached user profile. The methods in `CONNECT_PLUS_METHODS` need it and throw `GarminConnectPlusRequiredError` without. Whether the account has a Garmin Connect+ subscription, read from the cached user profile (`/userprofile-service/socialProfile`, so usually no extra request): `true` when `hasPremiumSocialIcon` is `true` or `userRoles` holds any `ROLE_SP_FEATURE_n` entry. The methods in `CONNECT_PLUS_METHODS` (`searchFoods`, `getCustomFoods`, `getCustomFoodServingUnits`, `createCustomFood`, `updateCustomFood`, `deleteCustomFood`…read
importActivityImports a `.fit`, `.gpx` or `.tcx` file as an activity. A duplicate raises `GarminConnectionError`. Multipart upload to `/upload-service/upload/{ext}` (extension from `filename`, must be `fit`/`gpx`/`tcx`) with the load-bearing `NK`/`origin`/custom `User-Agent` headers that make Garmin treat it as an import rather than a device sync; a 409 is re-raised as `GarminConnectionError` ("Activity already exists (duplicate):...").write
importCourseGpxParses a GPX file into a course WITHOUT saving it (`courseId: null`). Multipart POST (field `file`) to `/course-service/course/import`. **Parses only, saves NOTHING**: the result has `courseId: null` and a RESAMPLED track (13 GPX points came back as 37) with null elevations/timestamps; `courseName` is the GPX `<name>`. Only `.gpx` accepted (only `.gpx` verified); throws `GarminError` on an empty response.write
initMenstrualCycleSetupSets up cycle tracking from a first period start date and average period and cycle lengths. Account-level and not undoable; not meant for an account that is already set up. Does NOT also update tracking-preference settings (call `updateMenstrualSettings` separately for that); not intended for an already-configured account.write
listCalendarEventsEvery event between two dates, inclusive, or every event on the account with no dates. Events also appear in `getScheduledWorkouts`' month feed as `itemType` `event`; this GETs `/calendar-service/events`, with `startDate`/`endDate` when both dates are given (inclusive) or no params for every event on the account; one date alone throws.read
listCoursesEvery saved course, as `{ coursesForUser: CourseSummary[] }`. GETs `/web-gateway/course/owner/` (trailing slash included); returns an ENVELOPE `{ coursesForUser: CourseSummary[] }`, not a bare array.read
logFoodLogs a catalogue or custom food into a meal. Needs Connect+. PUTs `/nutrition-service/food/logs` with one `REGULAR_LOG` item and returns the whole day's log. `FoodLogInput` = `{date, foodId, servingId, servings? = 1, time?, meal?, source? = "GARMIN", regionCode?, languageCode?}`. Pass the catalogue food's `source`/`regionCode`/`languageCode` for a search result. **Needs a `mealId`**, which only exists after Garmin's nutrition setup in the app (400 `mealId must not be null` otherwise; this method throws a clearer error first). The meal is the named one, else the one whose window holds `time`, …writeConnect+
logoutClears the configured `TokenStore`. Makes no request: the token is not revoked server-side. Makes **no HTTP call** (the token is never revoked server-side). Does NOT clear the in-memory tokens already held by the calling `GarminClient` instance: there is no public API to do that, and this method's host is deliberately scoped to `{ client }` only. **NEVER call this against a `FileTokenStore` pointed at `./tokens`**: that is the test harness's live session.destructive
pushWorkoutToDeviceSends a workout to a device. Defaults to the newest workout and the most recently used device. Multi-call: resolves a missing `deviceId` via `/device-service/deviceservice/mylastused`'s `userDeviceId`, a missing `workoutId` via `getWorkouts(0,1)`'s first result (throws if none), then reads `getWorkoutById(workoutId).workoutName` for the push message on the final POST.write
queryGarminGraphqlSends a GraphQL request body to Garmin's GraphQL gateway verbatim. POSTs the caller's GraphQL body verbatim to `/graphql-gateway/graphql`. **The leading slash is load-bearing**: `connectapi` composes the request URL by plain string concatenation (`` `https://connectapi.${domain}${path}` ``), not `URL`-relative joining, so omitting the leading slash here would silently glue onto the hostname (`connectapi.garmin.comgraphql-gateway/graphql`) rather than 404; the usual "a 404 means the URL is wrong" heuristic would not even catch it. The leading slash is therefore hardcoded and deliberate; `tests…destructive
quickAddFoodLogs an entry by name and macros ("Quick Add"). Needs Connect+. PUTs `/nutrition-service/food/logs/quickAdd`: an entry by `name` + `calories`/`carbs`/`protein`/`fat` with no food behind it (`QUICK_ADD`). Same meal rules as `logFood`.writeConnect+
removeGearFromActivityUnlinks a piece of gear from an activity. **PUT**, not DELETE; same 404-handling pattern as `addGearToActivity`.write
requestReloadAsks Garmin to reload a day's wellness data that it has offloaded. POSTs `/wellness-service/wellness/epoch/request/{cdate}` with no JSON body; asks Garmin to reload/recompute a day's data (Garmin offloads older data, so this forces it back).write
scheduleWorkoutSchedules a library workout on a date.write
searchActivitiesOne page of activities filtered by text, type, dates, distance, duration, power, location and more. One page from `/activitylist-service/activities/search/activities` (the `getActivities` endpoint) with the filters Garmin's Personal API spec documents: `search`, `activityType` (a PARENT key, includes its subtypes; a subtype there is a 400), `activitySubType`, `excludedActivitySubTypes`, `eventType`, `startDate`/`endDate`, min/max distance (m), duration and elapsed duration (s), elevation gain (m), `minAvgPower` (W), `favorite`, `excludeChildren`, `sortBy`/`sortOrder`, `requiredFields`, `bound…read
searchFoodsFood catalogue search. Needs Garmin Connect+. GETs `/nutrition-service/food/search?searchExpression&start&limit` (defaults 0/20): `{results: Food[], moreDataAvailable}`; catalogue foods carry `source: "FATSECRET"` and several servings each.readConnect+
setActivityDescriptionSets an activity's description. Resolves to `null` on success.write
setActivityDistanceSets an activity's total distance in meters; Garmin recomputes the average speeds. Partial PUT of `summaryDTO.distance` in METERS (no conversion; `createManualActivity` is the one that takes km), the edit Garmin Connect offers for treadmill runs. Garmin recomputes `averageSpeed`/`averageMovingSpeed` from it; duration, calories and laps stay as recorded, so the laps no longer sum to the total. `getActivities` lags the change by a few seconds while `getActivity` shows it at once. Throws `GarminError` before any request for a non-positive or non-finite value.write
setActivityEventTypeFiles an activity under an event type, e.g. "race" or "training". Partial `PUT /activity-service/activity/{id}` with `{activityId, eventTypeDTO: {typeKey}}`. The `typeKey` alone is enough; Garmin fills in `typeId`/`sortOrder`. Throws `GarminError` before any request for a key outside the nine.write
setActivityExerciseSetsReplaces ALL of a strength activity's exercise sets with `payload`. **replace-all semantics**, `payload` sent verbatim.destructive
setActivityFeel"How did you feel?": 0, 25, 50, 75 or 100, or `null` to clear it. Partial PUT of `summaryDTO.directWorkoutFeel`, one of 0/25/50/75/100 ("How did you feel?", very weak to very strong); `null` clears it. Garmin stores any number (30 read back as 30) that its apps cannot display, so the method refuses anything else.write
setActivityNameRenames an activity. Resolves to `null` on success.write
setActivityPerceivedEffortPerceived effort (RPE) 1-10, or `null` to clear it. Partial PUT of `summaryDTO.directWorkoutRpe`, which Garmin stores **TIMES TEN**: pass RPE 1-10 (integer), it sends 10-100; `null` clears it. Garmin itself rejects 150 with a 400 `MEASUREMENT_NOT_VALID`. Never read-modify-write the whole `summaryDTO` instead: PUTting its stored start-coordinate pair back is a 400.write
setActivityTypeChanges an activity's type. Resolves to `null` on success.write
setBloodPressureRecords a blood-pressure reading (systolic 70-260, diastolic 40-150, pulse 20-250). `when` defaults to now. Validates systolic 70-260, diastolic 40-150, pulse (if given) 20-250, all integers; `when` defaults to `new Date()`.write
setGearActivityDefaultsSets which activity types default to this gear. Uses the v2 full-record PUT Garmin's own web client uses (the older dedicated default-gear endpoint is dead). The working way to set gear defaults (the old dedicated default-gear endpoint is dead; there is no `setGearDefault`). Read-modify-writes the v2 record: GETs `/gear-service/gear/v2/{uuid}`, replaces `associatedActivityTypes` with `[{activityTypeKey, defaultGear: true, preferredGear: false}]` per key, PUTs the whole record back. Keys are **lowercase** (`"running"`), matching `createGear`, NOT `setGearDefault`'s upper-cased form. `[]` clear…destructive
setHeartRateZonesChanges one heart-rate zone profile and returns it as stored. READ-MODIFY-WRITE of one profile: GETs `/biometric-service/heartRateZones`, overlays `{sport? = "DEFAULT", trainingMethod?, maxHeartRate?, restingHeartRate?, lactateThresholdHeartRate?, zoneFloors?: [5 bpm]}` with `changeState: "CHANGED"`, PUTs `[profile]` (204), then returns the profile READ BACK. A sport with no profile starts from DEFAULT's. Setting `restingHeartRate` also turns off `restingHrAutoUpdateUsed`. **Garmin does NOT recompute floors** when the method or a heart rate changes. Send `zoneFloors` too. Floors must be stric…write
setSleepWindowSets one night's bedtime and wake time, moving it or creating it; filed under the wake-up date. Sets one night's bedtime and wake time, as Garmin Connect's edit-sleep-times dialog does. `cdate` is the date Garmin files the night under, the WAKE-UP day. Reads the night through `getSleepData` first. A RECORDED night's `id` is its current `sleepStartTimestampGMT` in epoch ms and CHANGES after every edit, so it is read fresh, then PUT to `/sleep-service/sleep/dailySleep/{id}` with `{calendarDate, sleepStartTimestampGMT, sleepEndTimestampGMT, sleepTimeSeconds, napTimeSeconds, sleepWindowConfirmed:…write
unitSystem`measurementSystem` lives on `/userprofile-service/userprofile/user-settings` (under `userData`), not on the social profile. A convenience accessor, not a data endpoint: returns `undefined` rather than throwing if the payload shape is missing.read
unscheduleWorkoutRemoves a workout from the calendar; the workout stays in the library. Removes the calendar entry without deleting the workout template; irreversible.destructive
updateCalendarEventRead-modify-write of the stored event; resolves to `null`. READ-MODIFY-WRITE: GETs the event, overlays `{name?, date?, location?, url?, note?, race?, goalTimeSeconds?}` (`null` clears an optional one), PUTs the whole record back to `/calendar-service/event/{id}`; Concurrent callers can clobber each other.write
updateCourseRename and/or change privacy. Read-modify-write of the whole record. READ-MODIFY-WRITE: GETs the record, overlays the changes, PUTs the whole record back to `/course-service/course/{courseId}`, the same request Garmin's own web editor sends on Save (observed 2026-09-24). Concurrent callers can clobber each other. Throws before any request if neither field is given or the name is blank. A just-created course may 429 "not yet ready".write
updateCustomFoodFULL REPLACE of a custom food's definition. Needs Connect+. The same PUT carrying both ids. **FULL REPLACE**: a nutrient or brand left out is removed (verified: the brand was dropped).writeConnect+
updateMenstrualCalendarRewrites the period days in a date range. Replaces what the range holds; there is no undo. Needs cycle tracking set up in Garmin Connect first. **full replace, not a merge**; each `cycleDatesLists` group must be non-empty, consecutive calendar dates, and fall within `[startdate, enddate]`, else throws `GarminError`.destructive
updateMenstrualDailyLogLogs a day's cycle-tracking entry (symptoms, moods, flow, notes). Replaces whatever that day already holds; there is no undo. Needs cycle tracking set up in Garmin Connect first. **full-day replace, not a merge**; at least one optional field required or throws `GarminError`; `notes: undefined` preserves the existing note, `notes: ""` clears it (distinct, load-bearing); `discharge` rejects combining `"NO_DISCHARGE"` with any other value.destructive
updateMenstrualSettingsChanges cycle-tracking preferences (merged into the current ones). Has no effect until cycle tracking is set up in Garmin Connect. `settings` must be non-empty or throws `GarminError`; multi-step: GETs `/userprofile-service/userprofile/user-settings`, overlays `settings` onto the current `userMenstrualCycleSettings`, then PUTs the same endpoint, including `id` if resolvable.write
updateWorkoutReplaces a stored workout with new JSON (a full replace, not a merge). Full-replace PUT; forces `workoutId` into the body to match the path id; unlike `uploadWorkout`, a string must resolve to an object, not an array.write
uploadActivityUploads an activity file through Garmin's plain device-sync upload path. Multipart upload to the PLAIN `/upload-service/upload` path, no extension suffix and none of `importActivity`'s load-bearing import headers (ordinary device-sync-shaped upload, distinct from `importActivity`'s spoofed-client import).write
uploadCyclingWorkout`uploadWorkout` with the cycling sport type filled in if missing. Same pattern, default `sportType` `{sportTypeId:2, sportTypeKey:"cycling", displayOrder:2}`.write
uploadRunningWorkout`uploadWorkout` with the running sport type filled in if missing. Fills the default `running` `sportType` (`{sportTypeId:1, sportTypeKey:"running", displayOrder:1}`) if the caller didn't supply one, then delegates to `uploadWorkout`.write
uploadStrengthWorkout`uploadWorkout` with the strength-training sport type filled in if missing. Same pattern, default `sportType` `{sportTypeId:5, sportTypeKey:"strength_training", displayOrder:5}`.write
uploadSwimmingWorkout`uploadWorkout` with the swimming sport type filled in if missing. Same pattern, default `sportType` `{sportTypeId:4, sportTypeKey:"swimming", displayOrder:3}`.write
uploadWorkoutCreates a workout from JSON (an object, an array or a JSON string). `buildWorkout` builds the JSON for you. A string is JSON-parsed (throws `GarminError` on invalid JSON or a non-object/array result).write
userNameThe account's user name, from the cached user profile.read