MoveGraph logo

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 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 Loads 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

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:

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:

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:

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:

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:

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:

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:

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:

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:

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:

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:

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:

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:

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

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

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:

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

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

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:

UnitSystem enumeration type

This enumeration type defines the available choices for a unit system. The value must be one of the following options:

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

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

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

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

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

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

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.