MoveGraph Documentation
Target version: v1.0.0
MoveGraph is a set of JSON Schemas that define structures, constraints, and data types which can be used to describe any type of fitness activity, whether it is cardio, interval, or strength training. MoveGraph’s aim is to provide a universal structure that can be used by athletes and coaches in different kinds of sports to describe their workouts, sessions, and all other fitness data in a measurable and comparable manner.
MoveGraph’s JSON Schema collection can be utilized by any application; therefore, it is not an application or a framework that can be used for fitness management. Instead, it serves merely as a blueprint for structuring workouts, sessions, and all other fitness data.
Format and validation
MoveGraph uses JSON Schema, a declarative language for defining the structure and constraints of JSON data. This means that any data that utilizes the the MoveGraph structure can be easily validated against the schema file using any standard JSON Schema validator. More information about JSON Schema and the available validators can be found on the JSON Schema website.
Available schemas
Athletes and coaches in various sports use different types of structures to describe their workouts. MoveGraph aims to fill this gap by offering a structure that can be used for any type of physical activity in a structured and extensible way. At this stage, the following schemas are available:
-
Workout: This schema describes a reusable plan for a physical activity, detailing what exercises the athlete should complete and how. The exercises can be grouped into sets or rounds in any hierarchical structure, and each exercise can be precisely described by defining its repetitions, equipment, resistance, and intensity.
-
Session: This schema describes a completed or proposed physical activity, including all the essential information about it. Additionally, a session can include one or more workouts and the results achieved for the goals within those workouts.
-
Exercise: This schema includes all the essential information about a specific movement performed to develop or maintain fitness or a skill.
-
Equipment: This schema includes all the essential information about a device used during an exercise to enhance its strength or conditioning effects.
-
Athlete: This schema includes all the essential information about a person who completes the physical activities.
-
Activity type: This schema describes a type of physical activity that athletes engage in to improve their fitness, health, or performance.
-
Relative units: These three schemas represent custom-made units for repeat, intensity, and resistance. A relative unit contains an absolute unit and a value, which together define one quantity of that unit. Due to the absolute representation, values in relative units can always be converted to absolute ones. Within the sessions, the default values can be overridden with customized ones, making it easy to create tailored workouts for every athlete by simply setting a single value.
-
Program: This schema defines a schedule for a list of routines, where each routine outlines the workouts the athlete should complete during a session and the break period that should be maintained afterward. A training program corresponds to a microcycle or a mesocycle in an athlete’s preparation.
Workout schema
The workout schema describes a reusable plan for a physical activity. It includes one Workout
object at the root, which defines the essential information about the workout and describes the exercises in a structured manner using blocks. Therefore, all other objects exist under this object, and only one Workout
object must be present at the top level of the JSON.
A workout can include any number of blocks, which describe what the athlete should complete and how. A block can be either a BlockExercise
or a BlockGroup
.
The BlockExercise
specifies what exercise should be completed within the block and how it should be performed. A BlockGroup
can include other exercise and group blocks as children, making it ideal for organizing them into sets or rounds and for structuring the order of completion in a tree hierarchy. The aim of this structure is to make the majority of workouts describable in a consistent manner.
Both group and exercise blocks can include Repeat
, which defines how many times or how long an exercise, or the exercises and subgroups within the group, must be repeated. A repeat can be expressed in terms of amount, length, power, time, or in a relative unit that can be converted into an absolute one.
The relative repeat unit can be useful when you want to use a custom unit for an exercise block in a convertible manner. For example, you can define that 1 lap in an Olympic-size swimming pool is 50 meters. You can then use the lap as a unit when describing the block; however, due to the definition, the number of laps can always be converted into meters, which can be useful for analysis, comparison, and more. The relative repeat unit can also be used to define units where the corresponding absolute value can be customized for the athlete within the session, allowing workouts to scale to the athlete’s skills (e.g., 60% of the maximum repetitions for an exercise can be converted by setting the absolute value for the athlete).
It is possible to define Intensity
for an exercise block, which indicates how hard the athlete should complete it. Intensity can be expressed in terms of exertion, heart rate, pace, or in a relative unit that can be converted to an absolute one.
Using relative intensity units is an especially useful way to create personalized workouts. For example, you can define the maximum heart rate (MHR) as a unit; then, you can use it to describe at what percentage of MHR an exercise should be completed. This way, you can easily personalize a workout by customizing the MHR for the athlete within the session while maintaining comparability through the ability to convert values.
You can also define Load
s for an exercise block, specifying which piece of Equipment
is needed and, optionally, the designated Resistance
at which it should be set. The resistance can be expressed in terms of angle, length, mass, range, volume, or as a relative unit that can be converted to an absolute one.
Similar to relative intensity and repeat, relative resistance can also be used to define units that can be customized for the athlete within the session. For example, the 1RM for the shoulder press is a form of relative resistance because it defines the maximum weight the athlete can lift only once. Using relative resistance units makes it easy to define customizable resistances that scale to the athlete’s skills (e.g., 60% of 1RM).
Timing an exercise or a group of exercises can be done in two ways. To define how long a group or an exercise block should be repeated, the repeat can be used with a time unit (e.g., seconds, minutes). Sometimes, it is necessary to specify that an exercise with a specified number of repeats must be completed within a certain time. For this, a Timer
can be used, which defines the time within which the exercise or group of exercises must be completed. A timer is ideal for EMOM-type workouts (which stands for ‘every minute on the minute’) or for fitness tests.
MoveGraph includes many other useful structures to make a workout even more precisely defined. For example, a Coordinate
can be added to a workout or an exercise block to specify the location of completion. It is also possible to define a route for an exercise block, outlining the path the athlete should follow during the completion of the exercise (e.g., for running or rowing). Additionally, you can set a Recovery
for both exercise and group blocks, which defines the recovery exercise that should be completed after the block is finished.
Almost every object can be extended with custom metadata, which can be useful for applications to store additional information. In future versions, even more features may be added. But now, it is time to do some push-ups before diving into the various types of objects and their properties.
Example workouts
-
Baekdu: A high-intensity interval workout in which the athlete performs five rounds of 20 pull-ups, 30 push-ups, 40 sit-ups, and 50 squats for time, with three minutes of rest between each round. All exercises are defined within the workout.
-
Chechia: A high-intensity interval workout in which the athlete performs 5 pull-ups, 10 push-ups, and 15 squats every minute on the minute (EMOM) for a total of 30 minutes. All exercises are URI references to objects.
-
Cooper test: A physical fitness test that measures an athlete’s aerobic endurance by assessing the distance covered in 12 minutes of running. The exercise is defined within the workout.
-
Formosa: A run around a city park in which the athlete must maintain a specified heart rate. The exercise is defined within the workout, while the relative units are URI references to objects.
-
Intan: A hypertrophy-focused strength workout including four exercises and specified rest periods between sets. All exercises are URI references to objects, and the relative resistance units are also URI references.
Workout reference
Workout
object type
This object type represents all the information about the workout, including which exercises should be completed and how. It serves as the root object in the JSON structure. Any custom data intended to extend the workout must be placed under the meta
property. Additional properties are not allowed.
Properties
Name | Type | Required | Description |
---|---|---|---|
is-preset | boolean |
Indicates whether the workout is a preset. Preset workouts are a great way to use the same workout in multiple sessions and by multiple athletes. This makes sessions and athletes comparable because the target workout is the same. | |
name | string |
Yes* | The name of the workout. It is required only if the workout is a preset. |
description | string |
A short description for the workout. | |
created | string |
The date when the workout was created, in date-time format. |
|
modified | string |
The date when the workout was last modified, in date-time format. |
|
location | Coordinate |
The location for completing the workout. | |
definitions | DefinitionGroups |
The definitions that can be referenced within the workout, such as the relative units of repeat, intensity, and resistance. | |
authors | array<Author> |
A list of authors who participated in the process of creating the workout. | |
goals | Goals |
Goals that are intended to be achieved when completing the workout. | |
tips | array<string> |
A list of tips to consider when completing the workout. | |
blocks | array<BlockExercise\|BlockGroup> |
A list of exercise and group blocks to be completed within the workout. | |
meta | object |
Custom metadata related to the workout. |
Examples
{
"name": "Baekdu",
"description": "A high-intensity interval workout in which the athlete performs five rounds of 20 pull-ups, 30 push-ups, 40 sit-ups, and 50 squats for time, with three minutes of rest between each round.",
"created": "2048-02-02T08:00:00Z",
"modified": "2048-04-04T10:00:00Z",
"location": {...},
"definitions": {...},
"authors": [...],
"goals": {...},
"tips": [...],
"blocks": [...],
"meta": {...}
}
BlockExercise
object type
This object type specifies what exercise should be completed within the block and how it should be performed. Any custom data intended to extend the exercise block must be placed under the meta
property. Additional properties are not allowed.
Properties
Name | Type | Required | Description |
---|---|---|---|
kind | const |
Yes | The type of the block, which is exercise in the case of an exercise block. |
exercise | Exercise |string |
Yes | The exercise that should be completed within the block, or a URI reference to the object. In the case of a URI reference, the format must be in uri-reference . |
notes | string |
Notes for the exercise block that cannot be described in any other way. | |
tempo | string |
The time spent on each of the four phases of an exercise repeat. The format must be valid against the ^@[0-9]{2}[0-9X][0-9]$ pattern (e.g., @2010 or @30X0). |
|
repeat | Repeat |
Yes | The unit and the number of times the exercise must be repeated. |
timer | Timer |
Timer for the maximum time allowed to complete the exercise block. | |
recovery | Recovery |
The exercise that should be completed as a recovery after the main exercise is finished. | |
intensity | Intesnity |
The intensity to be maintained throughout the exercise. | |
loads | array<Load> |
A list of equipment required for the exercise and, optionally, their resistances. | |
location | Coordinate |
The location for completing the exercise block. | |
route | array<Coordinate> |
The route along which the exercise block should be completed. | |
meta | object |
Custom metadata related to the exercise block. |
Examples
{
"kind": "exercise",
"exercise": {...},
"notes": "Keep your body in a straight line.",
"tempo": "@30X0",
"repeat": {...},
"timer": {...},
"recovery": {...},
"intensity": {...},
"loads": [...],
"location": {...},
"route": [...],
"meta": {...}
}
BlockGroup
object type
This object type can include a list of exercise and group blocks as children, making it ideal for organizing exercises into sets or rounds, and for structuring the order of completion in a tree hierarchy. Any custom data intended to extend the group block must be placed under the meta
property. Additional properties are not allowed.
Properties
Name | Type | Required | Description |
---|---|---|---|
kind | const |
Yes | The type of the block, which is group in the case of a group block. |
notes | string |
Notes for the group block that cannot be described in any other way. | |
repeat | Repeat |
Yes | The unit and the number of times the child blocks must be repeated. |
timer | Timer |
Timer for the maximum time allowed to complete the child blocks. | |
recovery | Recovery |
The exercise that should be completed as a recovery after the child blocks are finished. | |
blocks | array<BlockExercise\|BlockGroup> |
A list of child exercises and subgroups to be completed. | |
meta | object |
Custom metadata related to the group block. |
Repeat
object type
This object type defines how many times or how long an exercise, or the exercises and subgroups within a group, must be repeated. A repeat can be expressed in terms of amount, length, power, time, or in a relative unit that can be converted into an absolute one. Additional properties are not allowed.
Properties
Name | Type | Required | Description |
---|---|---|---|
unit | UnitAmount |UnitLength |UnitPower |UnitTime |string |
Yes | The unit of the repeat, which can be an absolute value expressed in terms of amount, length, power, time, or a reference to a relative repeat unit definition. In the case of reference, the unique identifier of the definition must be prefixed with a # sign. |
values | array<number\|RelativeValue> |
Yes | The number of times the exercise, or the exercises and subgroups within the group, must be repeated. Non-negative numbers can be used for absolute values, while min or max for relative values. In the case of multiple values, each one represents the next number of repetitions until the parent repetitions are completed. If the number of parent repetitions is greater, the values start over from the beginning. |
Examples
{
"unit": "repetition",
"values": [5, 10, 15, 20]
}
{
"unit": "kilometer",
"values": ["max"]
}
{
"unit": "#swimming-pool-lap",
"values": [2]
}
Intensity
object type
This object type defines how hard the athlete should complete an exercise. Intensity can be expressed in terms of exertion, heart rate, pace, or in a relative unit that can be converted to an absolute one. Additional properties are not allowed.
Properties
Name | Type | Required | Description |
---|---|---|---|
unit | UnitExertion |UnitHeartRate |UnitPace |string |
Yes | The unit of the intensity, which can be an absolute value expressed in terms of exertion, heart rate, pace, or a reference to a relative intensity unit definition. In the case of reference, the unique identifier of the definition must be prefixed with a # sign. |
values | array<number\|RelativeValue> |
Yes | The values that belong to the specified unit, where non-negative numbers can be used for absolute values, while min or max for relative values. In the case of multiple values, each one represents the next intensity value until the parent repetitions are completed. If the number of parent repetitions is greater, the values start over from the beginning. |
Examples
{
"unit": "rpe",
"values": [6, 7, 8]
}
{
"unit": "bpm",
"values": ["max"]
}
{
"unit": "#max-heart-rate",
"values": [0.7]
}
Load
object type
This object type defines the equipment and, optionally, its resistance required for an exercise. Any custom data intended to extend the load must be placed under the meta
property. Additional properties are not allowed.
Properties
Name | Type | Required | Description |
---|---|---|---|
equipment | Equipment |string |
Yes | The equipment that is required for exercise, or a URI reference to the object. In the case of a URI reference, the format must be in uri-reference . |
resistance | Resistance |
The designated resistance at which the equipment should be used while completing the exercise. | |
meta | object |
Custom metadata related to the load. |
Examples
{
"equipment": {...},
"resistance": {...},
"meta": {...}
}
Resistance
object type
This object type defines the designated resistance at which the equipment should be used while completing the exercise. The resistance can be expressed in terms of angle, length, mass, range, volume, or in a relative unit that can be converted to an absolute one. Additional properties are not allowed.
Properties
Name | Type | Required | Description |
---|---|---|---|
unit | UnitAngle |UnitLength |UnitMass |UnitRange |UnitVolume |string |
Yes | The unit of the resistance, which can be an absolute value expressed in terms of angle, length, mass, range, volume, or a reference to a relative resistance unit definition. In the case of reference, the unique identifier of the definition must be prefixed with a # sign. |
values | array<number\|RelativeValue> |
Yes | The values that belong to the specified unit, where non-negative numbers can be used for absolute values, while min or max for relative values. In the case of multiple values, each one represents the next resistance value until the parent repetitions are completed. If the number of parent repetitions is greater, the values start over from the beginning. |
Examples
{
"unit": "kilogram",
"values": [60, 70]
}
{
"unit": "#back-squat-1rm",
"values": [0.65]
}
RelativeValue
enumeration type
This enumeration type defines the available choices for a relative value. The value must be one of the following options:
min
: The value should be as low as possible.max
: The value should be as great as possible.
UnitAmount
enumeration type
This enumeration type defines the available choices for a unit expressed in terms of amount. The value must be one of the following options:
repetition
: The value is expressed in the number of repetitions.
UnitAngle
enumeration type
This enumeration type defines the available choices for a unit expressed in terms of angle. The value must be one of the following options:
radian
: The value is expressed in radians.degree
: The value is expressed in degrees.
UnitExertion
enumeration type
This enumeration type defines the available choices for a unit expressed in terms of exertion. The value must be one of the following options:
rpe
: The value is expressed in the rate of perceived exertion (RPE).
UnitHeartRate
enumeration type
This enumeration type defines the available choices for a unit expressed in terms of heart rate. The value must be one of the following options:
bpm
: The value is expressed in beats per minute (bpm), which indicates how many times your heart beats in one minute.
UnitLength
enumeration type
This enumeration type defines the available choices for a unit expressed in terms of length. The value must be one of the following options:
centimeter
: The value is expressed in centimeters.meter
: The value is expressed in meters.kilometer
: The value is expressed in kilometers.inch
: The value is expressed in inches.foot
: The value is expressed in feet.yard
: The value is expressed in yards.mile
: The value is expressed in miles.
UnitMass
enumeration type
This enumeration type defines the available choices for a unit expressed in terms of mass. The value must be one of the following options:
kilogram
: The value is expressed in kilograms.pound
: The value is expressed in pounds.
UnitPace
enumeration type
This enumeration type defines the available choices for a unit expressed in terms of pace. The value must be one of the following options:
min/km
: The value is expressed in minute per kilometer.min/mile
: The value is expressed in minute per mile.
UnitPower
enumeration type
This enumeration type defines the available choices for a unit expressed in terms of power. The value must be one of the following options:
watt
: The value is expressed in watts.
UnitRange
enumeration type
This enumeration type defines the available choices for a unit expressed in terms of range. The value must be one of the following options:
level
: The value is expressed in levels.percent
: The value is expressed in percents.
UnitTime
enumeration type
This enumeration type defines the available choices for a unit expressed in terms of time. The value must be one of the following options:
second
: The value is expressed in seconds.minute
: The value is expressed in minutes.hour
: The value is expressed in hours.
UnitVolume
enumeration type
This enumeration type defines the available choices for a unit expressed in terms of volume. The value must be one of the following options:
cubic meter
: The value is expressed in cubic meters.liter
: The value is expressed in liters.
Timer
object type
This object type defines the time within which the exercise or group block must be completed. The timer is ideal for EMOM-type workouts (which stands for ‘every minute on the minute’) or for fitness tests. Any custom data intended to extend the timer must be placed under the meta
property. Additional properties are not allowed.
Properties
Name | Type | Required | Description |
---|---|---|---|
unit | UnitTime |
Yes | The unit of the timer, expressed in terms of time. |
values | array<number> |
Yes | The values as non-negative numbers from which the timer counts down in the specified unit. In the case of multiple values, each one represents the next time value until the parent repetitions are completed. If the number of parent repetitions is greater, the values start over from the beginning. |
remainder | RemainderRecovery |
The exercise that should be completed as a recovery in the remainign time. This is similar to Recovery , except that the repeat cannot be defined here. |
|
meta | object |
Custom metadata related to the timer. |
Examples
{
"unit": "minute",
"values": [1],
"remainder": {...},
"meta": {...}
}
Recovery
object type
This object type defines an exercise that should be completed as a recovery. Any custom data intended to extend the recovery must be placed under the meta
property. Additional properties are not allowed.
Properties
Name | Type | Required | Description |
---|---|---|---|
exercise | Exercise |string |
Yes | The exercise that should be completed as a recovery, or a URI reference to the object. In the case of a URI reference, the format must be in uri-reference . |
notes | string |
Notes for the recovery that cannot be described in any other way. | |
tempo | string |
The time spent on each of the four phases of an exercise repeat. The format must be valid against the ^@[0-9]{2}[0-9X][0-9]$ pattern (e.g., @2010 or @30X0). |
|
repeat | Repeat |
Yes | The unit and the number of times the exercise must be repeated. |
intensity | Intesnity |
The intensity to be maintained throughout the exercise. | |
loads | array<Load> |
A list of equipment required for the exercise and, optionally, their resistances. | |
location | Coordinate |
The location for completing the recovery. | |
route | array<Coordinate> |
The route along which the recovery should be completed. | |
meta | object |
Custom metadata related to the recovery. |
Examples
{
"exercise": {...},
"notes": "Try not to sit down.",
"tempo": "",
"repeat": {...},
"intensity": {...},
"loads": [...],
"location": {...},
"route": [...],
"meta": {...}
}
RemainderRecovery
object type
This object type defines what recovery exercise should be completed in the remaining time of a timer. Any custom data intended to extend the remainder recovery must be placed under the meta
property. Additional properties are not allowed.
Properties
Name | Type | Required | Description |
---|---|---|---|
exercise | Exercise |string |
Yes | The exercise that should be completed as a remainder recovery, or a URI reference to the object. In the case of a URI reference, the format must be in uri-reference . |
notes | string |
Notes for the remainder recovery that cannot be described in any other way. | |
tempo | string |
The time spent on each of the four phases of an exercise repeat. The format must be valid against the ^@[0-9]{2}[0-9X][0-9]$ pattern (e.g., @2010 or @30X0). |
|
intensity | Intesnity |
The intensity to be maintained throughout the exercise. | |
loads | array<Load> |
A list of equipment required for the exercise and, optionally, their resistances. | |
location | Coordinate |
The location for completing the remainding recovery. | |
route | array<Coordinate> |
The route along which the remainding recovery should be completed. | |
meta | object |
Custom metadata related to the remainder recovery. |
Examples
{
"exercise": {...},
"notes": "Try not to sit down.",
"tempo": "...",
"intensity": {...},
"loads": [...],
"location": {...},
"route": [...],
"meta": {...}
}
Coordinate
object type
This object type represents a latitude and a longitude of a location. Any custom data intended to extend the coordinate must be placed under the meta
property. Additional properties are not allowed.
Properties
Name | Type | Required | Description |
---|---|---|---|
lat | number |
Yes | The latitude of the coordinate in degrees. The value must be greater than or equal to -90 and less than or equal to 90. |
long | number |
Yes | The longitude of the coordinate in degrees. The value must be greater than or equal to -180 and less than or equal to 180. |
meta | object |
Custom metadata related to the coordinate. |
Examples
{
"lat": 47.46756404949221,
"long": 19.063900634781618,
"meta": {...}
}
Author
object type
This object type represents a person who participated in the process of creating the workout. Any custom data intended to extend the author must be placed under the meta
property. Additional properties are not allowed.
Properties
Name | Type | Required | Description |
---|---|---|---|
name | string |
Yes | The name of the author. |
uris | array<URI> |
A list of URIs for the author. | |
meta | object |
Custom metadata related to the author. |
Examples
{
"name": "John Doe",
"uris": [...],
"meta": {...}
}
URI
object type
This object type represents a uniform resource identifier (URI), such as a webpage, email address, or phone number. Any custom data intended to extend the URI must be placed under the meta
property. Additional properties are not allowed.
Properties
Name | Type | Required | Description |
---|---|---|---|
name | string |
Yes | The name of the URI. |
uri | string |
A valid URI, in uri format. |
|
meta | object |
Custom metadata related to the URI. |
Examples
{
"name": "Email",
"uri": "mailto:john.doe@example.test",
"meta": {...}
}
{
"name": "Website",
"uri": "https://www.example.test"
}
Goals
object type
This object type represents a set of ambitions for what the athlete should strive to achieve. The names of the properties are the unique identifiers of the goals, which applications can use to connect the achieved results to those goals. The values of the properties are Goal
objects. Only lowercase characters, numbers, and hyphens (-) are allowed in the names.
Examples
{
"completed-rounds": {...}
}
Goal
object type
This object type represents an ambition for what the athlete should strive to achieve. Any custom data intended to extend the goal must be placed under the meta
property. Additional properties are not allowed.
Properties
Name | Type | Required | Description |
---|---|---|---|
name | string |
Yes | The name of the goal. |
notes | string |
Notes for the goal that cannot be described in any other way. | |
unit | UnitAmount |UnitAngle |UnitExertion |UnitHeartRate |UnitLength |UnitMass |UnitPace |UnitPower |UnitTime |UnitVolume |
Yes | The unit of the goal, which can be an absolute value expressed in terms of amount, angle, exertion, heart rate, length, mass, pace, power, time, or volume. |
value | RelativeValue |
Yes | The relative value associated with the specified unit that the athlete should strive to achieve, which can be min or max . |
aggregate | Aggregate |
Yes | The aggregate function performed to calculate the result when multiple values are available within the session. |
meta | object |
Custom metadata related to the goal. |
Examples
{
"name": "The number of completed rounds",
"unit": "repetition",
"value": "max",
"aggregate": "sum",
"meta": {...}
}
Aggregate
enumeration type
This enumeration type defines the available choices for an aggregate function that performs a calculation on a set of values and returns a single value. The value must be one of the following options:
avg
: Returns the average value of the set.count
: Returns the number of values in the set.max
: Returns the greatest value within the set.min
: Returns the lowest value within the set.sum
: Returns the total sum of the set.
DefinitionGroups
object type
This object type represents the definition groups (such as repeat, intensity, and resistance) that can be referenced within the workout. Additional properties are not allowed.
Properties
Name | Type | Required | Description |
---|---|---|---|
relative-repeat-units | RelativeRepeatUnitDefinitions |
The definitions of relative repeat units that can be referenced within the workout. | |
relative-intensity-units | RelativeIntensityUnitDefinitions |
The definitions of relative intensity units that can be referenced within the workout. | |
relative-resistance-units | RelativeResistanceUnitDefinitions |
The definitions of relative resistance units that can be referenced within the workout. |
Examples
{
"relative-repeat-units": {...},
"relative-intensity-units": {...},
"relative-resistance-units": {...}
}
RelativeRepeatUnitDefinitions
object type
This object type includes the definitions of relative repeat units that can be referenced within the workout. The names of the properties are the unique identifiers of the relative repeat units, which can contain only lowercase characters, numbers, and hyphens (e.g., swimming-pool-lap). The values of the properties are RelativeRepeatUnit
objects, or URI references to the objects. In the case of a URI reference, the format must be in uri-reference
. After a definition is created, references can point to it using the ID of the definition, prefixed with a # sign (e.g., #swimming-pool-lap).
Examples
{
"swimming-pool-lap": {...}
}
RelativeIntensityUnitDefinitions
object type
This object type includes the definitions of relative intensity units that can be referenced within the workout. The names of the properties are the unique identifiers of the relative intensity units, which can contain only lowercase characters, numbers, and hyphens (e.g., max-heart-rate). The values of the properties are RelativeIntensityUnit
objects, or URI references to the objects. In the case of a URI reference, the format must be in uri-reference
. After a definition is created, references can point to it using the ID of the definition, prefixed with a # sign (e.g., #max-heart-rate).
Examples
{
"max-heart-rate": {...}
}
RelativeResistanceUnitDefinitions
object type
This object type includes the definitions of relative resistance units that can be referenced within the workout. The names of the properties are the unique identifiers of the relative resistance units, which can contain only lowercase characters, numbers, and hyphens (e.g., back-squat-1rm). The values of the properties are RelativeResistanceUnit
objects, or URI references to the objects. In the case of a URI reference, the format must be in uri-reference
. After a definition is created, references can point to it using the ID of the definition, prefixed with a # sign (e.g., #back-squat-1rm).
Examples
{
"back-squat-1rm": {...}
}
Session schema
The session schema describes a completed, proposed or rejected physical activity. It includes one Session
object at the root, which defines the essential information about the session. Therefore, all other objects exist under this object, and only one Session
object must be present at the top level of the JSON.
A session can include one or more tasks, with each Task
defining the workout that the athlete has completed or should complete. In the case of a completed session, a Task
object can also include the results achieved for the goals defined in the workout. A session can also be rejected if it was not completed before.
It is also possible to set CustomizationGroups
for the session, which specify customized absolute values for the relative units in the associated workouts. When an absolute value is found for a relative unit, the default value is replaced by the specified one, making tailored workouts significantly easier to create.
Example sessions
- 0001: A proposed session that has not yet been completed, in which the athlete must complete a Baekdu workout.
- 0002: A performed session in which the athlete completed a Cooper test, covering a distance of 2,800 meters. has run 2,800 meters in a Cooper test.
- 0003: A rejected session where the athlete was supposed to complete an Intan workout at their customized 1RMs, but they could not do so because they had to study.
- 0004: A performed session in which the athlete completed a custom high-intensity interval workout.
Session reference
Session
object type
This object type represents all the information about the session, including which workouts have been or should be completed, and optionally their results as well. It serves as the root object in the JSON structure. Any custom data intended to extend the session must be placed under the meta
property. Additional properties are not allowed.
Properties
Name | Type | Required | Description |
---|---|---|---|
activity-type | ActivityType |string |
Yes | The activity type to which the session belongs, or a URI reference to the object. In the case of a URI reference, the format must be in uri-reference . |
athlete | Athlete |string |
Yes | The athlete who completed or should complete the session, or a URI reference to the object. In the case of a URI reference, the format must be in uri-reference . |
description | string |
A short description for the session. | |
notes | string |
Notes for the session after completion. | |
created | string |
The date when the session was created, in date-time format. |
|
modified | string |
The date when the session was last modified, in date-time format. |
|
proposed | string |
Yes | The date when the session was proposed for completion, in date-time format. |
performed | string |
The date when the session was ultimately performed, in date-time format. |
|
rejected | string |
The date when the session was rejected, in date-time format. A session that has been performed cannot be rejected; only an unperformed session is allowed to be rejected. |
|
duration | string |
The duration of the session, indicating how long it took to complete, in duration format. |
|
customizations | CustomizationGroups |
The relative unit groups (such as repeat, intensity, and resistance) within which the customized absolute values for the units are stored. If a unit is presented within the workout of a task, its default absolute value is replaced by the customized one. | |
tasks | array<Task> |
Yes | A list of tasks that defines the workouts the athlete has completed or should complete, the customized absolute values for the relative units within the workouts, and, optionally, the results for the goals defined in the workouts. At least one task is required. |
location | Coordinate |
The location where the session was completed or should be completed. | |
meta | object |
Custom metadata related to the session. |
Examples
{
"activity-type": {...},
"athlete": {...},
"description": "High-intensity interval training to prepare for the games in the upcoming week.",
"notes": "I could not do my best because I felt sick.",
"created": "2048-02-02T08:00:00Z",
"modified": "2048-04-04T10:00:00Z",
"proposed": "2048-04-04T08:00:00Z",
"performed": "2048-04-04T09:00:00Z",
"duration": "PT60M",
"customizations": {...},
"tasks": [...],
"location": {...},
"meta": {...}
}
task
object type
This object type defines a workout that the athlete has completed or should complete, and it may optionally include the results for the goals defined in the workout.
Properties
Name | Type | Required | Description |
---|---|---|---|
workout | Workout |string |
Yes | The workout that has been completed or should be completed, or a URI reference to the object. In the case of a URI reference, the format must be in uri-reference . |
results | Results |
The results for the goals that are defined in the workout. | |
meta | object |
Custom metadata related to the task. |
Examples
{
"workout": {...},
"results": {...},
"meta": {...}
}
CustomizationGroups
object type
This object type represents the relative unit groups (such as repeat, intensity, and resistance) within which the customized absolute values for the units are stored. Additional properties are not allowed.
Properties
Name | Type | Required | Description |
---|---|---|---|
relative-repeat-units | Customizations |
The customized absolute values for the relative repeat units. | |
relative-intensity-units | Customizations |
The customized absolute values for the relative intensity units. | |
relative-resistance-units | Customizations |
The customized absolute values for the relative resistance units. |
Examples
{
"relative-repeat-units": {...},
"relative-intensity-units": {...},
"relative-resistance-units": {...}
}
Customizations
object type
This object type represents the customized absolute values for the relative units within a group (such as repeat, intensity, and resistance). The names of the properties are the unique identifiers for the relative units, which can contain only lowercase characters, numbers, and hyphens (-). The values of the properties are numbers that represent the absolute values used instead of the default values within the unit.
Examples
{
"back-squat-1rm": 70
}
Results
object type
This object type represents the results for the goals defined within the workout. The names of the properties are the unique identifiers of the Goal
objects in the workout, which can contain only lowercase characters, numbers, and hyphens (-). The values of the properties are lists of numbers representing the achieved results. In the case of multiple values, the aggregate function within the goal defines how the final results should be calculated.
Examples
{
"completed-distance": [2800]
}
Exercise schema
The exercise schema describes a specific movement performed to develop or maintain fitness or a skill. It includes one Exercise
object at the root, which defines the essential information about the exercise. Therefore, all other objects exist under this object, and only one Exercise
object must be present at the top level of the JSON.
Example exercises
- Back squat: A strength training exercise in which the athlete squats with a barbell positioned across the upper back.
- Bench press: A strength training exercise where the athlete lies on a bench and presses two dumbbells or a barbell upward from chest level until their arms are fully extended.
- Burpee: A full-body exercise that combines a squat, push-up, and jump.
- Pull-up: A bodyweight exercise where the athlete hangs from a bar and pulls their body upward until their chin is above the bar.
- Push-up: A bodyweight exercise where the athlete lowers and raises their body using their arms while in a prone position.
- Romanian deadlift: A strength training exercise where the athlete lifts a barbell or dumbbells from a standing position to hip level while maintaining a slight bend in the knees and hinging at the hips.
- Seated row: A strength training exercise in which the athlete pulls a weighted cable or bar towards their torso while seated.
- Squat: A fundamental exercise where the athlete lowers their body by bending the knees and hips while keeping the back straight, then returns to a standing position.
Exercise reference
Exercise
object type
This object type represents all the information about the exercise. It serves as the root object in the JSON structure. Any custom data intended to extend the exercise must be placed under the meta
property. Additional properties are not allowed.
Properties
Name | Type | Required | Description |
---|---|---|---|
name | string |
Yes | The name of the exercise. |
description | string |
A short description for the exercise. | |
created | string |
The date when the exercise was created, in date-time format. |
|
modified | string |
The date when the exercise was last modified, in date-time format. |
|
steps | array<string> |
A list of steps that describe how to properly execute the exercise. | |
tips | array<string> |
A list of tips to consider when completing the exercise. | |
muscle-groups | array<MuscleGroup> |
The muscle groups targeted by the exercise. | |
meta | object |
Custom metadata related to the exercise. |
Examples
{
"name": "Burpee",
"description": "A full-body exercise that combines a squat, push-up, and jump.",
"created": "2048-02-02T08:00:00Z",
"modified": "2048-04-04T10:00:00Z",
"steps": [...],
"tips": [...],
"muscle-groups": [...],
"meta": {...}
}
MuscleGroup
enumeration type
This enumeration type defines the available choices for muscle groups. The value must be one of the following options:
pecs
: The pecs are used for the exercise.shoulders
: The shoulders are used for the exercise.biceps
: The biceps are used for the exercise.triceps
: The triceps are used for the exercise.forearms
: The forearms are used for the exercise.abdominals
: The abdominals are used for the exercise.obliques
: The obliques are used for the exercise.traps
: The traps are used for the exercise.lats
: The lats are used for the exercise.lower back
: The lower back muscles are used for the exercise.glutes
: The glutes are used for the exercise.quads
: The quads are used for the exercise.hamstrings
: The hamstrings are used for the exercise.calves
: The calves are used for the exercise.
Equipment schema
The equipment schema describes a device used during an exercise to enhance its strength or conditioning effects. It includes one Equipment
object at the root, which defines the essential information about the equipment. Therefore, all other objects exist under this object, and only one Exercise
object must be present at the top level of the JSON.
Example equipment
- Barbell: A long bar, typically made of steel, with weights attached at each end.
- Pull-up bar: A horizontal bar fixed at a height that allows the athlete to perform pull-ups and chin-ups.
- Seated row machine: A seat, a backrest, and a set of handles or a bar that the athlete pulls towards their body while seated.
Equipment reference
Equipment
object type
This object type represents all the information about the equipment. It serves as the root object in the JSON structure. Any custom data intended to extend the equipment must be placed under the meta
property. Additional properties are not allowed.
Properties
Name | Type | Required | Description |
---|---|---|---|
name | string |
Yes | The name of the equipment. |
description | string |
A short description for the equipment. | |
created | string |
The date when the equipment was created, in date-time format. |
|
modified | string |
The date when the equipment was last modified, in date-time format. |
|
is-portable | boolean |
Indicates whether the equipment is portable or not. | |
meta | object |
Custom metadata related to the equipment. |
Examples
{
"name": "Barbell",
"description": "A long bar, typically made of steel, with weights attached at each end.",
"created": "2048-02-02T08:00:00Z",
"modified": "2048-04-04T10:00:00Z",
"is-portable": false,
"meta": {...}
}
Athlete schema
The athlete schema describes a person who completes the physical activities. It includes one Athlete
object at the root, which defines the essential information about the athlete. Therefore, all other objects exist under this object, and only one Athlete
object must be present at the top level of the JSON.
Example athletes
- John Doe: A male athlete who was born in 2028 and prefers the metric unit system.
Athlete reference
Athlete
object type
This object type represents all the information about the athlete. It serves as the root object in the JSON structure. Any custom data intended to extend the athlete must be placed under the meta
property. Additional properties are not allowed.
Properties
Name | Type | Required | Description |
---|---|---|---|
name | string |
Yes | The name of the athlete. |
created | string |
The date when the athlete was created, in date-time format. |
|
modified | string |
The date when the athlete was last modified, in date-time format. |
|
birthdate | string |
The date when the athlete was born, in date format. |
|
gender | Gender |
The gender of the athlete. | |
unit-system | UnitSystem |
The unit system preferred by the athlete. | |
uris | array<URI> |
A list of URIs for the athlete. | |
meta | object |
Custom metadata related to the athlete. |
Examples
{
"name": "John Doe",
"created": "2048-02-02T08:00:00Z",
"modified": "2048-04-04T10:00:00Z",
"birthdate": "1995-01-01",
"gender": "male",
"unit-system": "metric",
"meta": {...}
}
Gender
enumeration type
This enumeration type defines the available choices for the gender assigned to the person at birth. The value must be one of the following options:
male
: The person was born as male.female
: The person was born as female.
UnitSystem
enumeration type
This enumeration type defines the available choices for a unit system. The value must be one of the following options:
metric
: The unit system is metric.imperial
: The unit system is imperial.
Activity type schema
The activity type schema describes a type of physical activity that athletes engage in to improve their fitness, health, or performance. It includes one ActivityType
object at the root, which defines the essential information about the activity type. Therefore, all other objects exist under this object, and only one ActivityType
object must be present at the top level of the JSON.
Example activity types
- Interval training: An activity type that represents interval training.
- Run: An activity type that represents run.
- Weight training: An activity type that represents weight training.
Activity type reference
ActivityType
object type
This object type represents all the information about the activity type. It serves as the root object in the JSON structure. Any custom data intended to extend the activity type must be placed under the meta
property. Additional properties are not allowed.
Properties
Name | Type | Required | Description |
---|---|---|---|
name | string |
Yes | The name of the activity type. |
created | string |
The date when the activity type was created, in date-time format. |
|
modified | string |
The date when the activity type was last modified, in date-time format. |
|
meta | object |
Custom metadata related to the activity type. |
Examples
{
"name": "Weight training",
"created": "2048-02-02T08:00:00Z",
"modified": "2048-04-04T10:00:00Z",
"meta": {...}
}
Relative repeat unit schema
The relative repeat unit schema represents a custom-made repeat unit that contains an absolute repeat unit and a value, which together define one quantity of that unit. It includes one RelativeRepeatUnit
object at the root, which defines the essential information about the relative unit. Therefore, all other objects exist under this object, and only one RelativeRepeatUnit
object must be present at the top level of the JSON.
Example relative repeat units
- City park distance: A relative repeat unit that defines the distance of a lap around a city park.
- Burpee maximum repetitions: A relative repeat unit that defines the maximum number of burpees the athlete can perform at once.
Relative repeat unit reference
RelativeRepeatUnit
object type
This object type represents a relative repeat unit that can be referenced within the workout. Any custom data intended to extend the unit must be placed under the meta
property. Additional properties are not allowed.
Properties
Name | Type | Required | Description |
---|---|---|---|
name | string |
Yes | The name of the relative repeat unit. |
unit | UnitAmount |UnitLength |UnitPower |UnitTime |
Yes | The absolute unit that corresponds to the relative repeat unit. |
default-value | number |
Yes | The default absolute value that corresponds to one relative repeat unit when the customized one is not available within the session. It must be a number greater than or equal to zero. |
is-fixed | boolean |
Yes | Indicates whether the default absolute value is customizable or fixed. |
meta | object |
Custom metadata related to the relative repeat unit. |
Examples
{
"name": "Swimming pool lap",
"unit": "meter",
"default-value": 50,
"is-fixed": true,
"meta": {...}
}
{
"name": "Maximum number of pull-ups",
"unit": "repetition",
"default-value": 30,
"is-fixed": false,
"meta": {...}
}
Relative intensity unit schema
The relative intensity unit schema represents a custom-made intensity unit that contains an absolute intensity unit and a value, which together define one quantity of that unit. It includes one RelativeIntensityUnit
object at the root, which defines the essential information about the relative unit. Therefore, all other objects exist under this object, and only one RelativeIntensityUnit
object must be present at the top level of the JSON.
Example relative intensity units
- Maximum heart rate: A relative intensity unit that represents the maximum heart rate.
Relative intensity unit reference
RelativeIntensityUnit
object type
This object type represents a relative intensity unit that can be referenced within the workout. Any custom data intended to extend the unit must be placed under the meta
property. Additional properties are not allowed.
Properties
Name | Type | Required | Description |
---|---|---|---|
name | string |
Yes | The name of the relative intensity unit. |
unit | UnitExertion |UnitHeartRate |UnitPace |
Yes | The absolute unit that corresponds to the relative intensity unit. |
default-value | number |
Yes | The default absolute value that corresponds to one relative intensity unit when the customized one is not available within the session. It must be a number greater than or equal to zero. |
meta | object |
Custom metadata related to the relative intensity unit. |
Examples
{
"name": "Maximum heart rate",
"unit": "bpm",
"default-value": 190,
"meta": {...}
}
Relative resistance unit schema
The relative resistance unit schema represents a custom-made resistance unit that contains an absolute resistance unit and a value, which together define one quantity of that unit. It includes one RelativeResistanceUnit
object at the root, which defines the essential information about the relative unit. Therefore, all other objects exist under this object, and only one RelativeResistanceUnit
object must be present at the top level of the JSON.
Example relative resistance units
- Back squat 1RM: A relative resistance unit that represents the 1RM for the back squat.
- Bench press 1RM: A relative resistance unit that represents the 1RM for the bench press.
- Romanian deadlift 1RM: A relative resistance unit that represents the 1RM for the romanian deadlift.
- Seated row 1RM: A relative resistance unit that represents the 1RM for the seated row.
Relative resistance unit reference
RelativeResistanceUnit
object type
This object type represents a relative resistance unit that can be referenced within the workout. Any custom data intended to extend the unit must be placed under the meta
property. Additional properties are not allowed.
Properties
Name | Type | Required | Description |
---|---|---|---|
name | string |
Yes | The name of the relative resistance unit. |
unit | UnitAngle |UnitLength |UnitMass |UnitRange |UnitVolume |
Yes | The absolute unit that corresponds to the relative resistance unit. |
default-value | number |
Yes | The default absolute value that corresponds to one relative resistance unit when the customized one is not available within the session. It must be a number greater than or equal to zero. |
meta | object |
Custom metadata related to the relative resistance unit. |
Examples
{
"name": "Back squat 1RM",
"unit": "kilogram",
"default-value": 80,
"meta": {...}
}
Program schema
The program schema defines the schedule of a list of routines, where each Routine
outlines the workouts the athlete should complete during a session and the break period that should be maintained afterward. The schema includes one Program
object at the root, which defines the essential information about the program. Therefore, all other objects exist under this object, and only one Program
object must be present at the top level of the JSON. A training program corresponds to a microcycle or a mesocycle in an athlete’s preparation.
Example programs
- Pavo: A high-intensity interval program for athletes who embody both strength and agility.
Program reference
Program
object type
This object type represents all the information about the program. It serves as the root object in the JSON structure. Any custom data intended to extend the program must be placed under the meta
property. Additional properties are not allowed.
Properties
Name | Type | Required | Description |
---|---|---|---|
name | string |
Yes | The name of the program. |
description | string |
A short description for the program. | |
created | string |
The date when the program was created, in date-time format. |
|
modified | string |
The date when the program was last modified, in date-time format. |
|
authors | array<Author> |
A list of authors who participated in the process of creating the program. | |
tips | array<string> |
A list of tips to consider when completing the program. | |
schedule | array<Routine> |
A list of routines, where each routine outlines the workouts the athlete should complete during a session and the break period that should be maintained afterward. | |
meta | object |
Custom metadata related to the program. |
Examples
{
"name": "Pavo",
"description": "A high-intensity interval program for athletes who embody both strength and agility.",
"created": "2048-02-02T08:00:00Z",
"modified": "2048-04-04T10:00:00Z",
"authors": [...],
"tips": [...],
"schedule": [...],
"meta": {...}
}
Routine
object type
This object type defines the workouts the athlete should complete during a session and the break period that should be maintained afterward. The routine is a blueprint for a session, meaning that the routine completed by an athlete constitutes a session.
It is also possible to set CustomizationGroups
for the routine, which specify customized absolute values for the relative units in the associated workouts. When an absolute value is found for a relative unit, the default value is replaced by the specified one.
Properties
Name | Type | Required | Description |
---|---|---|---|
activity-type | ActivityType |string |
Yes | The activity type to which the routine belongs, or a URI reference to the object. In the case of a URI reference, the format must be in uri-reference . |
workouts | array<Workout\|string> |
Yes | A list of workouts (or URI references to the objects) that the athlete should complete within the routine. In the case of a URI reference, the format must be in uri-reference . At least one workout is required. |
break-period | string |
The break period that should be maintained after the routine is completed, in duration format. |
|
customizations | CustomizationGroups |
The relative unit groups (such as repeat, intensity, and resistance) within which the customized absolute values for the units are stored. If a unit is presented within a workout of the routine, its default absolute value is replaced by the customized one. | |
meta | object |
Custom metadata related to the routine. |
Examples
{
"activity-type": {...},
"workouts": [...],
"break-period": "P1D",
"customizations": {...},
"meta": {...}
}
Feature roadmap
- Multiplayer mode: With multiplayer mode, you will be able to define team or group workouts, specifying which players should execute which exercises and how. The division between the players can also be defined. In the session, you can specify which athletes correspond to which players.
License
MoveGraph was originally created for Movelapse by Abel Brencsan. Unless indicated otherwise, the MoveGraph documentation and the accompanying JSON schemas are licensed under the Creative Commons Attribution 4.0 International License (CC BY 4.0). You are free to share, adapt, and build upon the material, provided that appropriate credit is given, a link to the license is included, and any changes made are indicated.
However, please note that all trademarks, logos, and service marks associated with MoveGraph are the property of their respective owners. The use of any trademarks, logos, or service marks is strictly prohibited without prior written permission from the respective owners.