hevy 0.1.0

An async Rust client library for the Hevy public API (https://api.hevyapp.com/docs/)
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277

use serde::{Deserialize, Serialize};

use super::common::SetType;

/// A single logged set, as returned by the API within a [`Workout`] or [`crate::Routine`].
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct Set {
    /// Index indicating the order of the set within the exercise.
    #[serde(default)]
    pub index: u32,
    /// The type of set: one of `normal`, `warmup`, `dropset`, `failure`.
    #[serde(rename = "type", default)]
    pub r#type: String,
    /// Weight lifted, in kilograms.
    #[serde(default)]
    pub weight_kg: Option<f64>,
    /// Number of reps logged for the set.
    #[serde(default)]
    pub reps: Option<f64>,
    /// Number of meters logged for the set.
    #[serde(default)]
    pub distance_meters: Option<f64>,
    /// Number of seconds logged for the set.
    #[serde(default)]
    pub duration_seconds: Option<f64>,
    /// Rating of Perceived Exertion logged for the set.
    #[serde(default)]
    pub rpe: Option<f64>,
    /// Custom metric logged for the set (used for e.g. floors/steps on stair machines).
    #[serde(default)]
    pub custom_metric: Option<f64>,
}

/// An exercise entry within a [`Workout`], including all logged sets.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct Exercise {
    /// Index indicating the order of the exercise within the workout.
    #[serde(default)]
    pub index: u32,
    /// Title of the exercise.
    #[serde(default)]
    pub title: String,
    /// Notes on the exercise.
    #[serde(default)]
    pub notes: Option<String>,
    /// The id of the exercise template. Can be used to fetch the full template.
    #[serde(default)]
    pub exercise_template_id: String,
    /// The id of the superset this exercise belongs to, if any.
    #[serde(default)]
    pub supersets_id: Option<u32>,
    /// The sets logged for this exercise.
    #[serde(default)]
    pub sets: Vec<Set>,
}

/// A completed workout.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct Workout {
    /// The workout ID.
    pub id: String,
    /// The workout title.
    #[serde(default)]
    pub title: String,
    /// The ID of the routine this workout was created from, if any.
    #[serde(default)]
    pub routine_id: Option<String>,
    /// The workout description.
    #[serde(default)]
    pub description: Option<String>,
    /// ISO 8601 timestamp of when the workout was recorded to have started.
    #[serde(default)]
    pub start_time: String,
    /// ISO 8601 timestamp of when the workout was recorded to have ended.
    #[serde(default)]
    pub end_time: String,
    /// ISO 8601 timestamp of when the workout was last updated.
    #[serde(default)]
    pub updated_at: String,
    /// ISO 8601 timestamp of when the workout was created.
    #[serde(default)]
    pub created_at: String,
    /// The exercises logged in this workout.
    #[serde(default)]
    pub exercises: Vec<Exercise>,
}

/// A page of [`Workout`]s, as returned by [`crate::HevyClient::list_workouts`].
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct WorkoutsPage {
    /// The current page number.
    pub page: u32,
    /// The total number of pages available.
    pub page_count: u32,
    /// The workouts on this page.
    #[serde(default)]
    pub workouts: Vec<Workout>,
}

/// The total number of workouts on the account.
#[derive(Debug, Clone, Copy, Default, PartialEq, Serialize, Deserialize)]
pub struct WorkoutCount {
    /// The total number of workouts.
    pub workout_count: u64,
}

/// A set to include when creating or updating a workout.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct WorkoutSetInput {
    /// The type of the set.
    #[serde(rename = "type", skip_serializing_if = "Option::is_none")]
    pub r#type: Option<SetType>,
    /// The weight in kilograms.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub weight_kg: Option<f64>,
    /// The number of repetitions.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub reps: Option<i64>,
    /// The distance in meters.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub distance_meters: Option<i64>,
    /// The duration in seconds.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub duration_seconds: Option<i64>,
    /// A custom metric for the set. Currently used for steps and floors.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub custom_metric: Option<f64>,
    /// The Rating of Perceived Exertion (one of 6, 7, 7.5, 8, 8.5, 9, 9.5, 10).
    #[serde(skip_serializing_if = "Option::is_none")]
    pub rpe: Option<f64>,
}

impl WorkoutSetInput {
    /// Creates a normal set with the given weight and reps.
    pub fn normal(weight_kg: f64, reps: i64) -> Self {
        Self {
            r#type: Some(SetType::Normal),
            weight_kg: Some(weight_kg),
            reps: Some(reps),
            ..Default::default()
        }
    }

    /// Creates a warmup set with the given weight and reps.
    pub fn warmup(weight_kg: f64, reps: i64) -> Self {
        Self {
            r#type: Some(SetType::Warmup),
            weight_kg: Some(weight_kg),
            reps: Some(reps),
            ..Default::default()
        }
    }
}

/// An exercise to include when creating or updating a workout.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct WorkoutExerciseInput {
    /// The ID of the exercise template.
    pub exercise_template_id: String,
    /// The ID of the superset this exercise belongs to, if any.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub superset_id: Option<i64>,
    /// Additional notes for the exercise.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub notes: Option<String>,
    /// The sets performed for this exercise.
    pub sets: Vec<WorkoutSetInput>,
}

impl WorkoutExerciseInput {
    /// Creates a new exercise input for the given exercise template id.
    pub fn new(exercise_template_id: impl Into<String>) -> Self {
        Self {
            exercise_template_id: exercise_template_id.into(),
            superset_id: None,
            notes: None,
            sets: Vec::new(),
        }
    }

    /// Appends a set to this exercise.
    pub fn with_set(mut self, set: WorkoutSetInput) -> Self {
        self.sets.push(set);
        self
    }
}

/// The workout fields accepted by the create/update workout endpoints.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct NewWorkout {
    /// The title of the workout.
    pub title: String,
    /// A description for the workout.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,
    /// ISO 8601 timestamp of when the workout started.
    pub start_time: String,
    /// ISO 8601 timestamp of when the workout ended.
    pub end_time: String,
    /// Whether the workout is private.
    #[serde(default)]
    pub is_private: bool,
    /// The exercises performed in this workout.
    pub exercises: Vec<WorkoutExerciseInput>,
}

impl NewWorkout {
    /// Creates a new workout with the given title and start/end times.
    ///
    /// Timestamps should be ISO 8601 strings, e.g. `"2024-08-14T12:00:00Z"`.
    pub fn new(
        title: impl Into<String>,
        start_time: impl Into<String>,
        end_time: impl Into<String>,
    ) -> Self {
        Self {
            title: title.into(),
            description: None,
            start_time: start_time.into(),
            end_time: end_time.into(),
            is_private: false,
            exercises: Vec::new(),
        }
    }

    /// Appends an exercise to this workout.
    pub fn with_exercise(mut self, exercise: WorkoutExerciseInput) -> Self {
        self.exercises.push(exercise);
        self
    }
}

/// The request body used to create or update a workout.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct CreateWorkoutRequest {
    /// The workout to create or the new state of the workout to update.
    pub workout: NewWorkout,
}

impl CreateWorkoutRequest {
    /// Wraps a [`NewWorkout`] in the request body envelope expected by the API.
    pub fn new(workout: NewWorkout) -> Self {
        Self { workout }
    }
}

/// A workout event indicating either an update or a deletion, as returned by
/// [`crate::HevyClient::workout_events`].
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(tag = "type", rename_all = "snake_case")]
pub enum WorkoutEvent {
    /// A workout was created or updated.
    Updated {
        /// The full, up-to-date workout.
        workout: Workout,
    },
    /// A workout was deleted.
    Deleted {
        /// The id of the deleted workout.
        id: String,
        /// When the workout was deleted, if known.
        #[serde(default, skip_serializing_if = "Option::is_none")]
        deleted_at: Option<String>,
    },
}

/// A paginated list of [`WorkoutEvent`]s, as returned by [`crate::HevyClient::workout_events`].
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct PaginatedWorkoutEvents {
    /// The current page number.
    pub page: u32,
    /// The total number of pages available.
    pub page_count: u32,
    /// The events on this page, ordered from newest to oldest.
    #[serde(default)]
    pub events: Vec<WorkoutEvent>,
}