SDK operations

Each named operation below becomes a typed method on the client: sdk.<operationName>(variables). Native clients (Swift, Kotlin) generate from the same documents and schema.graphql.

admin

AdminDashboard

sdk.adminDashboard() — query

query AdminDashboard {
  admin {
    inviteOnly
    users {
      id
      name
      email
      isAdmin
      disabled
      isGuest
      createdAt
      workouts
      lastActive
    }
    trainingNow {
      userId
      name
      workoutName
      exerciseId
      setsDone
      setsTotal
      updatedAt
    }
    invites {
      code
      createdAt
      usedBy
      usedAt
      revokedAt
    }
  }
}

AdminUser

sdk.adminUser(variables) — query

query AdminUser($id: ID!) {
  admin {
    user(id: $id) {
      id
      workouts {
        ...WorkoutFields
      }
      bodyweight {
        date
        weight
      }
    }
  }
}

AdminCreateInvite

sdk.adminCreateInvite() — mutation

mutation AdminCreateInvite {
  adminCreateInvite {
    code
    createdAt
  }
}

AdminRevokeInvite

sdk.adminRevokeInvite(variables) — mutation

mutation AdminRevokeInvite($code: String!) {
  adminRevokeInvite(code: $code)
}

AdminSetUserDisabled

sdk.adminSetUserDisabled(variables) — mutation

mutation AdminSetUserDisabled($userId: ID!, $disabled: Boolean!, $reason: String) {
  adminSetUserDisabled(userId: $userId, disabled: $disabled, reason: $reason)
}

AdminSignIns

sdk.adminSignIns(variables) — query

query AdminSignIns($limit: Int) {
  admin {
    signIns(limit: $limit) {
      userId
      name
      email
      isGuest
      at
      method
      country
      device
    }
  }
}

body

Bodyweight

sdk.bodyweight(variables) — query

query Bodyweight($from: Date, $to: Date) {
  viewer {
    id
    bodyweight(from: $from, to: $to) {
      date
      weight
    }
    settings {
      targetWeight
      unit
    }
  }
}

LogBodyweight

sdk.logBodyweight(variables) — mutation

mutation LogBodyweight($input: BodyweightInput!) {
  logBodyweight(input: $input) {
    date
    weight
  }
}

DeleteBodyweight

sdk.deleteBodyweight(variables) — mutation

mutation DeleteBodyweight($date: Date!) {
  deleteBodyweight(date: $date)
}

data

Backup

sdk.backup() — query

query Backup {
  viewer {
    id
    backup
  }
}

RestoreBackup

sdk.restoreBackup(variables) — mutation

mutation RestoreBackup($backup: JSON!) {
  restoreBackup(backup: $backup)
}

ResetData

sdk.resetData() — mutation

mutation ResetData {
  resetData
}

ImportHistory

sdk.importHistory(variables) — mutation

mutation ImportHistory($input: ImportHistoryInput!) {
  importHistory(input: $input) {
    workouts
    sets
    customExercises
    bodyweight
    skippedDays
  }
}

exercises

Exercises

sdk.exercises(variables) — query

query Exercises($includeDeleted: Boolean) {
  viewer {
    id
    customExercises(includeDeleted: $includeDeleted) {
      ...CustomExerciseFields
    }
    exerciseSettings {
      ...ExerciseSettingFields
    }
  }
}

SaveCustomExercise

sdk.saveCustomExercise(variables) — mutation

mutation SaveCustomExercise($input: CustomExerciseInput!) {
  saveCustomExercise(input: $input) {
    ...CustomExerciseFields
  }
}

DeleteCustomExercise

sdk.deleteCustomExercise(variables) — mutation

mutation DeleteCustomExercise($id: ID!) {
  deleteCustomExercise(id: $id)
}

SetFavourite

sdk.setFavourite(variables) — mutation

mutation SetFavourite($exerciseId: ID!, $favourite: Boolean!) {
  setFavourite(exerciseId: $exerciseId, favourite: $favourite)
}

SetExerciseSetting

sdk.setExerciseSetting(variables) — mutation

mutation SetExerciseSetting($input: ExerciseSettingInput!) {
  setExerciseSetting(input: $input) {
    ...ExerciseSettingFields
  }
}

ExerciseStats

sdk.exerciseStats(variables) — query

query ExerciseStats($exerciseId: ID!) {
  viewer {
    id
    exerciseStats(exerciseId: $exerciseId) {
      exerciseId
      best
      bestOneRm {
        value
        weight
        reps
        date
      }
      points {
        date
        top
        topReps
        oneRm
        effortRir
        volume
      }
    }
  }
}

SetCustomExercisePhoto

sdk.setCustomExercisePhoto(variables) — mutation

mutation SetCustomExercisePhoto($exerciseId: ID!, $image: String!) {
  setCustomExercisePhoto(exerciseId: $exerciseId, image: $image) {
    ...CustomExerciseFields
  }
}

RemoveCustomExercisePhoto

sdk.removeCustomExercisePhoto(variables) — mutation

mutation RemoveCustomExercisePhoto($exerciseId: ID!) {
  removeCustomExercisePhoto(exerciseId: $exerciseId) {
    ...CustomExerciseFields
  }
}

plan

Plan

sdk.plan() — query

query Plan {
  viewer {
    id
    routines {
      ...RoutineFields
    }
    week {
      weekday
      routineId
    }
  }
}

Day

sdk.day(variables) — query

query Day($date: Date) {
  viewer {
    id
    day(date: $date) {
      date
      routineId
      isOverride
      routine {
        ...RoutineFields
      }
      workouts {
        id
        name
        finishedAt
      }
    }
  }
}

Overrides

sdk.overrides(variables) — query

query Overrides($from: Date, $to: Date) {
  viewer {
    id
    overrides(from: $from, to: $to) {
      date
      routineId
    }
  }
}

SaveRoutine

sdk.saveRoutine(variables) — mutation

mutation SaveRoutine($input: RoutineInput!, $position: Int) {
  saveRoutine(input: $input, position: $position) {
    ...RoutineFields
  }
}

DeleteRoutine

sdk.deleteRoutine(variables) — mutation

mutation DeleteRoutine($id: ID!) {
  deleteRoutine(id: $id)
}

ReorderRoutines

sdk.reorderRoutines(variables) — mutation

mutation ReorderRoutines($ids: [ID!]!) {
  reorderRoutines(ids: $ids)
}

SetWeekday

sdk.setWeekday(variables) — mutation

mutation SetWeekday($weekday: Int!, $routineId: ID) {
  setWeekday(weekday: $weekday, routineId: $routineId) {
    weekday
    routineId
  }
}

SetDayOverride

sdk.setDayOverride(variables) — mutation

mutation SetDayOverride($date: Date!, $routineId: ID) {
  setDayOverride(date: $date, routineId: $routineId) {
    date
    routineId
  }
}

ClearDayOverride

sdk.clearDayOverride(variables) — mutation

mutation ClearDayOverride($date: Date!) {
  clearDayOverride(date: $date)
}

RescheduleDay

sdk.rescheduleDay(variables) — mutation

mutation RescheduleDay($from: Date!, $to: Date!) {
  rescheduleDay(from: $from, to: $to) {
    date
    routineId
  }
}

LoadStarterPlan

sdk.loadStarterPlan(variables) — mutation

mutation LoadStarterPlan($kind: StarterKind!) {
  loadStarterPlan(kind: $kind) {
    ...RoutineFields
  }
}

PlanFile

sdk.planFile() — query

query PlanFile {
  viewer {
    id
    planFile
  }
}

ImportPlan

sdk.importPlan(variables) — mutation

mutation ImportPlan($plan: JSON!, $takeWeek: Boolean) {
  importPlan(plan: $plan, takeWeek: $takeWeek) {
    routines
    customExercises
    dropped
    weekReplaced
  }
}

CreatePlanShare

sdk.createPlanShare() — mutation

mutation CreatePlanShare {
  createPlanShare {
    token
    expiresAt
  }
}

SharedPlan

sdk.sharedPlan(variables) — query

query SharedPlan($token: String!) {
  sharedPlan(token: $token) {
    ownerName
    plan
    expiresAt
  }
}

ImportSharedPlan

sdk.importSharedPlan(variables) — mutation

mutation ImportSharedPlan($token: String!, $takeWeek: Boolean) {
  importSharedPlan(token: $token, takeWeek: $takeWeek)
}

push

SubscribePush

sdk.subscribePush(variables) — mutation

mutation SubscribePush($input: PushSubscriptionInput!) {
  subscribePush(input: $input)
}

UnsubscribePush

sdk.unsubscribePush(variables) — mutation

mutation UnsubscribePush($endpoint: String!) {
  unsubscribePush(endpoint: $endpoint)
}

SendTestPush

sdk.sendTestPush() — mutation

mutation SendTestPush {
  sendTestPush
}

ScheduleRestPush

sdk.scheduleRestPush(variables) — mutation

mutation ScheduleRestPush($seconds: Int!, $title: String!, $body: String!) {
  scheduleRestPush(seconds: $seconds, title: $title, body: $body)
}

CancelRestPush

sdk.cancelRestPush() — mutation

mutation CancelRestPush {
  cancelRestPush
}

stats

Activity

sdk.activity(variables) — query

query Activity($from: Date, $to: Date) {
  viewer {
    id
    streak
    activity(from: $from, to: $to) {
      date
      minutes
      volume
    }
  }
}

MuscleBalance

sdk.muscleBalance(variables) — query

query MuscleBalance($from: Date, $to: Date, $hardOnly: Boolean) {
  viewer {
    id
    muscleBalance(from: $from, to: $to, hardOnly: $hardOnly) {
      muscles {
        muscle
        sets
      }
      untrained
    }
  }
}

Effort

sdk.effort(variables) — query

query Effort($from: Date, $to: Date) {
  viewer {
    id
    effort(from: $from, to: $to) {
      totalSets
      ratedSets
      averageRir
      nearFailureShare
      distribution
      weeks {
        weekStart
        averageRir
        ratedSets
        totalSets
      }
    }
  }
}

MuscleRecovery

sdk.muscleRecovery() — query

query MuscleRecovery {
  viewer {
    id
    muscleRecovery {
      muscle
      fatigue
      strength
      lastTrained
      daysSince
    }
  }
}

LiftBalance

sdk.liftBalance() — query

query LiftBalance {
  viewer {
    id
    liftBalance {
      lifts {
        exerciseId
        oneRm
        ratio
        share
      }
      weakest
    }
  }
}

viewer

Me

sdk.me() — query

query Me {
  viewer {
    id
    name
    email
    image
    isAnonymous
    isAdmin
    settings {
      ...SettingsFields
    }
  }
  config {
    ...ConfigFields
  }
}

Config

sdk.config() — query

query Config {
  config {
    ...ConfigFields
  }
}

UpdateSettings

sdk.updateSettings(variables) — mutation

mutation UpdateSettings($input: SettingsInput!) {
  updateSettings(input: $input) {
    ...SettingsFields
  }
}

ConnectedApps

sdk.connectedApps() — query

query ConnectedApps {
  viewer {
    id
    connectedApps {
      clientId
      name
      uri
      icon
      connectedAt
    }
  }
}

DisconnectApp

sdk.disconnectApp(variables) — mutation

mutation DisconnectApp($clientId: ID!) {
  disconnectApp(clientId: $clientId)
}

ApiKeys

sdk.apiKeys() — query

query ApiKeys {
  viewer {
    id
    apiKeys {
      ...ApiKeyFields
    }
  }
}

CreateApiKey

sdk.createApiKey(variables) — mutation

mutation CreateApiKey($input: CreateApiKeyInput!) {
  createApiKey(input: $input) {
    key
    apiKey {
      ...ApiKeyFields
    }
  }
}

RevokeApiKey

sdk.revokeApiKey(variables) — mutation

mutation RevokeApiKey($id: ID!) {
  revokeApiKey(id: $id)
}

SetPassword

sdk.setPassword(variables) — mutation

mutation SetPassword($password: String!) {
  setPassword(password: $password)
}

SignedInSessions

sdk.signedInSessions() — query

query SignedInSessions {
  viewer {
    id
    sessions {
      ...SignedInSessionFields
    }
  }
}

RevokeSession

sdk.revokeSession(variables) — mutation

mutation RevokeSession($id: ID!) {
  revokeSession(id: $id)
}

HevyWorkouts

sdk.hevyWorkouts(variables) — query

query HevyWorkouts($apiKey: String!, $page: Int!) {
  viewer {
    id
    hevyWorkouts(apiKey: $apiKey, page: $page) {
      page
      pageCount
      workouts
    }
  }
}

workouts

NextTargets

sdk.nextTargets(variables) — query

query NextTargets($routineId: ID!) {
  viewer {
    id
    nextTargets(routineId: $routineId) {
      itemId
      exerciseId
      mode
      supersetGroup
      restSec
      rule
      perSide
      bodyweight
      reason {
        code
        params
      }
      sets {
        kind
        weight
        reps
        durationSec
        speed
        amrap
      }
    }
  }
}

ActiveWorkout

sdk.activeWorkout() — query

query ActiveWorkout {
  viewer {
    id
    activeWorkout {
      ...WorkoutFields
    }
  }
}

Workouts

sdk.workouts(variables) — query

query Workouts($from: Date, $to: Date, $limit: Int, $offset: Int) {
  viewer {
    id
    workouts(from: $from, to: $to, limit: $limit, offset: $offset) {
      ...WorkoutFields
    }
  }
}

Workout

sdk.workout(variables) — query

query Workout($id: ID!) {
  viewer {
    id
    workout(id: $id) {
      ...WorkoutFields
    }
  }
}

SaveWorkout

sdk.saveWorkout(variables) — mutation

mutation SaveWorkout($input: WorkoutInput!) {
  saveWorkout(input: $input) {
    id
  }
}

FinishWorkout

sdk.finishWorkout(variables) — mutation

mutation FinishWorkout($input: WorkoutInput!) {
  finishWorkout(input: $input) {
    workout {
      ...WorkoutFields
    }
    records {
      exerciseId
      kind
      value
      previous
    }
    muscles {
      muscle
      sets
    }
  }
}

DeleteWorkout

sdk.deleteWorkout(variables) — mutation

mutation DeleteWorkout($id: ID!) {
  deleteWorkout(id: $id)
}

Heartbeat

sdk.heartbeat(variables) — mutation

mutation Heartbeat($input: HeartbeatInput!) {
  heartbeat(input: $input)
}

PinnedNotes

sdk.pinnedNotes() — query

query PinnedNotes {
  viewer {
    id
    pinnedNotes {
      exerciseId
      note
      date
    }
  }
}