1use chrono::{DateTime, Utc};
2use serde::{Deserialize, Serialize};
3
4#[derive(Debug, Clone, Serialize, Deserialize)]
5pub struct ActivityTotal {
6 pub count: Option<i32>,
7 pub distance: Option<f64>,
8 pub moving_time: Option<f64>,
9 pub elapsed_time: Option<f64>,
10 pub elevation_gain: Option<f64>,
11 pub achievement_count: Option<i32>,
12}
13
14#[derive(Debug, Clone, Serialize, Deserialize)]
15pub struct ActivityStats {
16 pub biggest_ride_distance: Option<f64>,
17 pub biggest_climb_elevation_gain: Option<f64>,
18 pub recent_ride_totals: Option<ActivityTotal>,
19 pub recent_run_totals: Option<ActivityTotal>,
20 pub recent_swim_totals: Option<ActivityTotal>,
21 pub ytd_ride_totals: Option<ActivityTotal>,
22 pub ytd_run_totals: Option<ActivityTotal>,
23 pub ytd_swim_totals: Option<ActivityTotal>,
24 pub all_ride_totals: Option<ActivityTotal>,
25 pub all_run_totals: Option<ActivityTotal>,
26 pub all_swim_totals: Option<ActivityTotal>,
27}
28
29#[derive(Debug, Clone, Serialize, Deserialize)]
30#[serde(rename_all = "PascalCase")]
31pub enum ActivityType {
32 AlpineSki,
33 BackcountrySki,
34 Canoeing,
35 Crossfit,
36 EBikeRide,
37 Elliptical,
38 Golf,
39 Handcycle,
40 Hike,
41 IceSkate,
42 InlineSkate,
43 Kayaking,
44 Kitesurf,
45 NordicSki,
46 Ride,
47 RockClimbing,
48 RollerSki,
49 Rowing,
50 Run,
51 Sail,
52 Skateboard,
53 Snowboard,
54 Snowshoe,
55 Soccer,
56 StairStepper,
57 StandUpPaddling,
58 Surfing,
59 Swim,
60 Velomobile,
61 VirtualRide,
62 VirtualRun,
63 Walk,
64 WeightTraining,
65 Wheelchair,
66 Windsurf,
67 Workout,
68 Yoga,
69 #[serde(other)]
70 Unknown,
71}
72
73#[derive(Debug, Clone, Serialize, Deserialize)]
74pub struct ActivityZone {
75 pub score: Option<i32>,
76 pub distribution_buckets: Option<Vec<TimedZoneDistribution>>,
77 #[serde(rename = "type")]
78 pub zone_type: Option<String>,
79 pub sensor_based: Option<bool>,
80 pub points: Option<i32>,
81 pub custom_zones: Option<bool>,
82 pub max: Option<i32>,
83}
84
85#[derive(Debug, Clone, Serialize, Deserialize)]
86pub struct BaseStream {
87 pub original_size: Option<i32>,
88 pub resolution: Option<String>,
89 pub series_type: Option<String>,
90}
91
92#[derive(Debug, Clone, Serialize, Deserialize)]
93pub struct ClubActivity {
94 pub athlete: Option<MetaAthlete>,
95 pub name: Option<String>,
96 pub distance: Option<f32>,
97 pub moving_time: Option<i32>,
98 pub elapsed_time: Option<i32>,
99 pub total_elevation_gain: Option<f32>,
100 #[deprecated(note = "Use `sport_type` instead")]
101 #[serde(default)]
102 pub r#type: Option<ActivityType>,
103 pub sport_type: Option<SportType>,
104 pub workout_type: Option<i32>,
105}
106
107#[derive(Debug, Clone, Serialize, Deserialize)]
108pub struct ClubAthlete {
109 pub resource_state: Option<i32>,
110 pub firstname: Option<String>,
111 pub lastname: Option<String>,
112 pub member: Option<String>,
113 pub admin: Option<bool>,
114 pub owner: Option<bool>,
115}
116
117#[derive(Debug, Clone, Serialize, Deserialize)]
118pub struct SimpleComment {
119 pub id: Option<i64>,
120 pub activity_id: Option<i64>,
121 pub text: Option<String>,
122 pub athlete: Option<SummaryAthlete>,
123 pub created_at: Option<DateTime<Utc>>,
124}
125
126#[derive(Debug, Clone, Serialize, Deserialize)]
127pub struct Error {
128 pub code: Option<String>,
129 pub field: Option<String>,
130 pub resource: Option<String>,
131}
132
133#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
134pub struct Activity {
135 pub id: i64,
136 pub resource_state: u8,
137 pub external_id: Option<String>,
138 pub upload_id: Option<i64>,
139 pub athlete: SimpleAthlete,
140 pub name: String,
141 pub distance: f64,
142 pub moving_time: i32,
143 pub elapsed_time: i32,
144 pub total_elevation_gain: f64,
145 #[serde(rename = "type")]
146 pub activity_type: String,
147 pub sport_type: String,
148 pub start_date: String,
149 pub start_date_local: String,
150 pub timezone: String,
151 pub utc_offset: f64,
152 pub achievement_count: i32,
153 pub kudos_count: i32,
154 pub comment_count: i32,
155 pub athlete_count: i32,
156 pub photo_count: i32,
157 pub map: Map,
158 pub trainer: bool,
159 pub commute: bool,
160 pub manual: bool,
161 pub private: bool,
162 pub flagged: bool,
163 pub gear_id: Option<String>,
164 pub from_accepted_tag: Option<bool>,
165 pub average_speed: f64,
166 pub max_speed: f64,
167 pub device_watts: Option<bool>,
168 pub has_heartrate: bool,
169 pub pr_count: i32,
170 pub total_photo_count: i32,
171 pub has_kudoed: bool,
172 pub workout_type: Option<i32>,
173 pub description: Option<String>,
174 pub calories: Option<f64>,
175 pub segment_efforts: Option<Vec<SegmentEffort>>,
176}
177
178#[derive(Serialize, Debug)]
179pub struct CreateActivity {
180 pub name: String,
181 #[serde(skip_serializing_if = "Option::is_none")]
182 pub activity_type: Option<String>,
183 pub sport_type: String,
184 pub start_date_local: String,
185 pub elapsed_time: i32,
186 #[serde(skip_serializing_if = "Option::is_none")]
187 pub description: Option<String>,
188 #[serde(skip_serializing_if = "Option::is_none")]
189 pub distance: Option<f64>,
190 #[serde(skip_serializing_if = "Option::is_none")]
191 pub trainer: Option<i32>,
192 #[serde(skip_serializing_if = "Option::is_none")]
193 pub commute: Option<i32>,
194}
195
196#[derive(Debug, Deserialize)]
197struct SimpleActivity {
198 id: i64,
199 resource_state: i32,
200}
201
202#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
203pub struct SimpleAthlete {
204 pub id: i64,
205 pub resource_state: u8,
206}
207
208#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
209pub struct Map {
210 pub id: String,
211 pub polyline: Option<String>,
212 pub resource_state: u8,
213}
214
215#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
216pub struct SegmentEffort {}
217
218#[derive(Debug, Deserialize, PartialEq)]
219pub struct Comment {
220 id: i64,
221 activity_id: i64,
222 post_id: Option<i64>,
223 resource_state: i32,
224 text: String,
225 mentions_metadata: Option<String>,
226 created_at: String,
227 athlete: User,
228 cursor: Option<String>,
229 reaction_count: i32,
230 has_reacted: bool,
231}
232
233#[derive(Debug, Deserialize, PartialEq)]
234pub struct User {
235 firstname: String,
236 lastname: String,
237 resource_state: Option<i32>,
238}
239
240#[derive(Debug, Clone, Serialize, Deserialize)]
241pub struct ExplorerResponse {
242 pub segments: Option<Vec<ExplorerSegment>>,
243}
244
245#[derive(Debug, Clone, Serialize, Deserialize)]
246pub struct ExplorerSegment {
247 pub id: Option<i64>,
248 pub name: Option<String>,
249 pub climb_category: Option<i32>,
250 pub climb_category_desc: Option<String>,
251 pub avg_grade: Option<f32>,
252 pub start_latlng: Option<LatLng>,
253 pub end_latlng: Option<LatLng>,
254 pub elev_difference: Option<f32>,
255 pub distance: Option<f32>,
256 pub points: Option<String>,
257}
258
259#[derive(Debug, Clone, Serialize, Deserialize)]
260pub struct Fault {
261 pub errors: Option<Vec<Error>>,
262 pub message: Option<String>,
263}
264
265#[derive(Debug, Clone, Serialize, Deserialize)]
266pub struct HeartRateZoneRanges {
267 pub custom_zones: Option<bool>,
268 pub zones: Option<ZoneRanges>,
269}
270
271#[derive(Debug, Clone, Serialize, Deserialize)]
272pub struct Lap {
273 pub id: Option<i64>,
274 pub activity: Option<MetaActivity>,
275 pub athlete: Option<MetaAthlete>,
276 pub average_cadence: Option<f32>,
277 pub average_speed: Option<f32>,
278 pub distance: Option<f32>,
279 pub elapsed_time: Option<i32>,
280 pub start_index: Option<i32>,
281 pub end_index: Option<i32>,
282 pub lap_index: Option<i32>,
283 pub max_speed: Option<f32>,
284 pub moving_time: Option<i32>,
285 pub name: Option<String>,
286 pub pace_zone: Option<i32>,
287 pub split: Option<i32>,
288 pub start_date: Option<DateTime<Utc>>,
289 pub start_date_local: Option<DateTime<Utc>>,
290 pub total_elevation_gain: Option<f32>,
291}
292
293#[derive(Debug, Clone, Serialize, Deserialize)]
294pub struct LatLng(pub f64, pub f64);
295
296#[derive(Debug, Clone, Serialize, Deserialize)]
297pub struct MetaActivity {
298 pub id: Option<i64>,
299}
300
301#[derive(Debug, Clone, Serialize, Deserialize)]
302pub struct MetaAthlete {
303 pub id: Option<i64>,
304}
305
306#[derive(Debug, Clone, Serialize, Deserialize)]
307pub struct MetaClub {
308 pub id: Option<i64>,
309 pub resource_state: Option<i32>,
310 pub name: Option<String>,
311}
312
313#[derive(Debug, Clone, Serialize, Deserialize)]
314pub struct PhotosSummary {
315 pub count: Option<i32>,
316 pub primary: Option<PhotosSummaryPrimary>,
317}
318
319#[derive(Debug, Clone, Serialize, Deserialize)]
320pub struct PhotosSummaryPrimary {
321 pub id: Option<i64>,
322 pub source: Option<i32>,
323 pub unique_id: Option<String>,
324 pub urls: Option<String>,
325}
326
327#[derive(Debug, Clone, Serialize, Deserialize)]
328pub struct PolylineMap {
329 pub id: Option<String>,
330 pub polyline: Option<String>,
331 pub summary_polyline: Option<String>,
332}
333
334#[derive(Debug, Clone, Serialize, Deserialize)]
335pub struct PowerZoneRanges {
336 pub zones: Option<ZoneRanges>,
337}
338
339#[derive(Debug, Clone, Serialize, Deserialize)]
340pub struct Route {
341 pub athlete: Option<SummaryAthlete>,
342 pub description: Option<String>,
343 pub distance: Option<f32>,
344 pub elevation_gain: Option<f32>,
345 pub id: Option<i64>,
346 pub id_str: Option<String>,
347 pub map: Option<PolylineMap>,
348 pub name: Option<String>,
349 pub private: Option<bool>,
350 pub starred: Option<bool>,
351 pub timestamp: Option<i64>,
352 pub r#type: Option<i32>,
353 pub sub_type: Option<i32>,
354 pub created_at: Option<DateTime<Utc>>,
355 pub updated_at: Option<DateTime<Utc>>,
356 pub estimated_moving_time: Option<i32>,
357 pub segments: Option<Vec<SummarySegment>>,
358 pub waypoints: Option<Vec<Waypoint>>,
359}
360
361#[derive(Debug, Clone, Serialize, Deserialize)]
362pub struct Split {
363 pub average_speed: Option<f32>,
364 pub distance: Option<f32>,
365 pub elapsed_time: Option<i32>,
366 pub elevation_difference: Option<f32>,
367 pub pace_zone: Option<i32>,
368 pub moving_time: Option<i32>,
369 pub split: Option<i32>,
370}
371
372#[derive(Debug, Clone, Serialize, Deserialize)]
373#[serde(rename_all = "PascalCase")]
374pub enum SportType {
375 AlpineSki,
376 BackcountrySki,
377 Badminton,
378 Canoeing,
379 Crossfit,
380 EBikeRide,
381 Elliptical,
382 EMountainBikeRide,
383 Golf,
384 GravelRide,
385 Handcycle,
386 HighIntensityIntervalTraining,
387 Hike,
388 IceSkate,
389 InlineSkate,
390 Kayaking,
391 Kitesurf,
392 MountainBikeRide,
393 NordicSki,
394 Pickleball,
395 Pilates,
396 Racquetball,
397 Ride,
398 RockClimbing,
399 RollerSki,
400 Rowing,
401 Run,
402 Sail,
403 Skateboard,
404 Snowboard,
405 Snowshoe,
406 Soccer,
407 Squash,
408 StairStepper,
409 StandUpPaddling,
410 Surfing,
411 Swim,
412 TableTennis,
413 Tennis,
414 TrailRun,
415 Velomobile,
416 VirtualRide,
417 VirtualRow,
418 VirtualRun,
419 Walk,
420 WeightTraining,
421 Wheelchair,
422 Windsurf,
423 Workout,
424 Yoga,
425 #[serde(other)]
426 Unknown,
427}
428
429#[derive(Debug, Clone, Serialize, Deserialize)]
430pub struct StreamSet {
431 pub time: Option<TimeStream>,
432 pub distance: Option<DistanceStream>,
433 pub latlng: Option<LatLngStream>,
434 pub altitude: Option<AltitudeStream>,
435 pub velocity_smooth: Option<SmoothVelocityStream>,
436 pub heartrate: Option<HeartrateStream>,
437 pub cadence: Option<CadenceStream>,
438 pub watts: Option<PowerStream>,
439 pub temp: Option<TemperatureStream>,
440 pub moving: Option<MovingStream>,
441 pub grade_smooth: Option<SmoothGradeStream>,
442}
443
444#[derive(Debug, Clone, Serialize, Deserialize)]
445pub struct SummaryGear {
446 pub id: Option<String>,
447 pub resource_state: Option<i32>,
448 pub primary: Option<bool>,
449 pub name: Option<String>,
450 pub distance: Option<f32>,
451}
452
453#[derive(Debug, Clone, Serialize, Deserialize)]
454pub struct SummaryPRSegmentEffort {
455 pub pr_activity_id: Option<i64>,
456 pub pr_elapsed_time: Option<i32>,
457 pub pr_date: Option<DateTime<Utc>>,
458 pub effort_count: Option<i32>,
459}
460
461#[derive(Debug, Clone, Serialize, Deserialize)]
462pub struct SummarySegment {
463 pub id: Option<i64>,
464 pub name: Option<String>,
465 pub activity_type: Option<String>,
466 pub distance: Option<f32>,
467 pub average_grade: Option<f32>,
468 pub maximum_grade: Option<f32>,
469 pub elevation_high: Option<f32>,
470 pub elevation_low: Option<f32>,
471 pub start_latlng: Option<LatLng>,
472 pub end_latlng: Option<LatLng>,
473 pub climb_category: Option<i32>,
474 pub city: Option<String>,
475 pub state: Option<String>,
476 pub country: Option<String>,
477 pub private: Option<bool>,
478 pub athlete_pr_effort: Option<SummaryPRSegmentEffort>,
479 pub athlete_segment_stats: Option<SummarySegmentEffort>,
480}
481
482#[derive(Debug, Clone, Serialize, Deserialize)]
483pub struct SummarySegmentEffort {
484 pub id: Option<i64>,
485 pub activity_id: Option<i64>,
486 pub elapsed_time: Option<i32>,
487 pub start_date: Option<DateTime<Utc>>,
488 pub start_date_local: Option<DateTime<Utc>>,
489 pub distance: Option<f32>,
490 pub is_kom: Option<bool>,
491}
492
493#[derive(Debug, Clone, Serialize, Deserialize)]
494pub struct TimedZoneDistribution {
495 pub ranges: Option<Vec<TimedZoneRange>>,
496}
497
498#[derive(Debug, Clone, Serialize, Deserialize)]
499pub struct UpdatableActivity {
500 pub commute: Option<bool>,
501 pub trainer: Option<bool>,
502 pub hide_from_home: Option<bool>,
503 pub description: Option<String>,
504 pub name: Option<String>,
505 #[deprecated(note = "Use sport_type instead")]
506 #[serde(default)]
507 pub r#type: Option<ActivityType>,
508 pub sport_type: Option<SportType>,
509 pub gear_id: Option<String>,
510}
511
512#[derive(Debug, Clone, Serialize, Deserialize)]
513pub struct Upload {
514 pub id: Option<i64>,
515 pub id_str: Option<String>,
516 pub external_id: Option<String>,
517 pub error: Option<String>,
518 pub status: Option<String>,
519 pub activity_id: Option<i64>,
520}
521
522#[derive(Debug, Clone, Serialize, Deserialize)]
523pub struct Waypoint {
524 pub latlng: Option<LatLng>,
525 pub target_latlng: Option<LatLng>,
526 pub categories: Option<String>,
527 pub title: Option<String>,
528 pub description: Option<String>,
529 pub distance_into_route: Option<i32>,
530}
531
532#[derive(Debug, Clone, Serialize, Deserialize)]
533pub struct ZoneRange {
534 pub min: Option<i32>,
535 pub max: Option<i32>,
536}
537
538#[derive(Debug, Clone, Serialize, Deserialize)]
539pub struct ZoneRanges {
540 pub zones: Option<Vec<ZoneRange>>,
541}
542
543#[derive(Debug, Clone, Serialize, Deserialize)]
544pub struct Zones {
545 pub heart_rate: Option<HeartRateZoneRanges>,
546 pub power: Option<PowerZoneRanges>,
547}
548
549#[derive(Debug, Clone, Serialize, Deserialize)]
550pub struct AltitudeStream {
551 pub original_size: Option<i32>,
552 pub resolution: Option<String>,
553 pub series_type: Option<String>,
554 pub data: Option<Vec<f32>>,
555}
556
557#[derive(Debug, Clone, Serialize, Deserialize)]
558pub struct CadenceStream {
559 pub original_size: Option<i32>,
560 pub resolution: Option<String>,
561 pub series_type: Option<String>,
562 pub data: Option<Vec<i32>>,
563}
564
565#[derive(Debug, Clone, Serialize, Deserialize)]
566pub struct DetailedGear {
567 pub id: Option<String>,
568 pub resource_state: Option<i32>,
569 pub primary: Option<bool>,
570 pub name: Option<String>,
571 pub distance: Option<f32>,
572 pub brand_name: Option<String>,
573 pub model_name: Option<String>,
574 pub frame_type: Option<i32>,
575 pub description: Option<String>,
576}
577
578#[derive(Debug, Clone, Serialize, Deserialize)]
579pub struct DetailedSegment {
580 pub id: Option<i64>,
581 pub name: Option<String>,
582 pub activity_type: Option<String>,
583 pub distance: Option<f32>,
584 pub average_grade: Option<f32>,
585 pub maximum_grade: Option<f32>,
586 pub elevation_high: Option<f32>,
587 pub elevation_low: Option<f32>,
588 pub start_latlng: Option<LatLng>,
589 pub end_latlng: Option<LatLng>,
590 pub climb_category: Option<i32>,
591 pub city: Option<String>,
592 pub state: Option<String>,
593 pub country: Option<String>,
594 pub private: Option<bool>,
595 pub athlete_pr_effort: Option<SummaryPRSegmentEffort>,
596 pub athlete_segment_stats: Option<SummarySegmentEffort>,
597 pub created_at: Option<String>,
598 pub updated_at: Option<String>,
599 pub total_elevation_gain: Option<f32>,
600 pub map: Option<PolylineMap>,
601 pub effort_count: Option<i32>,
602 pub athlete_count: Option<i32>,
603 pub hazardous: Option<bool>,
604 pub star_count: Option<i32>,
605}
606
607#[derive(Debug, Clone, Serialize, Deserialize)]
608pub struct DetailedSegmentEffort {
609 pub id: Option<i64>,
610 pub activity_id: Option<i64>,
611 pub elapsed_time: Option<i32>,
612 pub start_date: Option<DateTime<Utc>>,
613 pub start_date_local: Option<DateTime<Utc>>,
614 pub distance: Option<f32>,
615 pub is_kom: Option<bool>,
616 pub name: Option<String>,
617 pub activity: Option<MetaActivity>,
618 pub athlete: Option<MetaAthlete>,
619 pub moving_time: Option<i32>,
620 pub start_index: Option<i32>,
621 pub end_index: Option<i32>,
622 pub average_cadence: Option<f32>,
623 pub average_watts: Option<f32>,
624 pub device_watts: Option<bool>,
625 pub average_heartrate: Option<f32>,
626 pub max_heartrate: Option<f32>,
627 pub segment: Option<SummarySegment>,
628 pub kom_rank: Option<i32>,
629 pub pr_rank: Option<i32>,
630 pub hidden: Option<bool>,
631}
632
633#[derive(Debug, Clone, Serialize, Deserialize)]
634pub struct DistanceStream {
635 pub original_size: Option<i32>,
636 pub resolution: Option<String>,
637 pub series_type: Option<String>,
638 pub data: Option<Vec<f32>>,
639}
640
641#[derive(Debug, Clone, Serialize, Deserialize)]
642pub struct HeartrateStream {
643 pub original_size: Option<i32>,
644 pub resolution: Option<String>,
645 pub series_type: Option<String>,
646 pub data: Option<Vec<i32>>,
647}
648
649#[derive(Debug, Clone, Serialize, Deserialize)]
650pub struct LatLngStream {
651 pub original_size: Option<i32>,
652 pub resolution: Option<String>,
653 pub series_type: Option<String>,
654 pub data: Option<Vec<LatLng>>,
655}
656
657#[derive(Debug, Clone, Serialize, Deserialize)]
658pub struct MovingStream {
659 pub original_size: Option<i32>,
660 pub resolution: Option<String>,
661 pub series_type: Option<String>,
662 pub data: Option<Vec<bool>>,
663}
664
665#[derive(Debug, Clone, Serialize, Deserialize)]
666pub struct PowerStream {
667 pub original_size: Option<i32>,
668 pub resolution: Option<String>,
669 pub series_type: Option<String>,
670 pub data: Option<Vec<i32>>,
671}
672
673#[derive(Debug, Clone, Serialize, Deserialize)]
674pub struct SmoothGradeStream {
675 pub original_size: Option<i32>,
676 pub resolution: Option<String>,
677 pub series_type: Option<String>,
678 pub data: Option<Vec<f32>>,
679}
680
681#[derive(Debug, Clone, Serialize, Deserialize)]
682pub struct SmoothVelocityStream {
683 pub original_size: Option<i32>,
684 pub resolution: Option<String>,
685 pub series_type: Option<String>,
686 pub data: Option<Vec<f32>>,
687}
688
689#[derive(Debug, Clone, Serialize, Deserialize)]
690pub struct SummaryActivity {
691 pub id: Option<i64>,
692 pub external_id: Option<String>,
693 pub upload_id: Option<i64>,
694 pub athlete: Option<MetaAthlete>,
695 pub name: Option<String>,
696 pub distance: Option<f32>,
697 pub moving_time: Option<i32>,
698 pub elapsed_time: Option<i32>,
699 pub total_elevation_gain: Option<f32>,
700 pub elev_high: Option<f32>,
701 pub elev_low: Option<f32>,
702 #[deprecated(note = "Use sport_type instead")]
703 #[serde(default)]
704 pub r#type: Option<ActivityType>,
705 pub sport_type: Option<SportType>,
706 pub start_date: Option<DateTime<Utc>>,
707 pub start_date_local: Option<DateTime<Utc>>,
708 pub timezone: Option<String>,
709 pub start_latlng: Option<LatLng>,
710 pub end_latlng: Option<LatLng>,
711 pub achievement_count: Option<i32>,
712 pub kudos_count: Option<i32>,
713 pub comment_count: Option<i32>,
714 pub athlete_count: Option<i32>,
715 pub photo_count: Option<i32>,
716 pub total_photo_count: Option<i32>,
717 pub map: Option<PolylineMap>,
718 pub trainer: Option<bool>,
719 pub commute: Option<bool>,
720 pub manual: Option<bool>,
721 pub private: Option<bool>,
722 pub flagged: Option<bool>,
723 pub workout_type: Option<i32>,
724 pub upload_id_str: Option<String>,
725 pub average_speed: Option<f32>,
726 pub max_speed: Option<f32>,
727 pub has_kudoed: Option<bool>,
728 pub hide_from_home: Option<bool>,
729 pub gear_id: Option<String>,
730 pub kilojoules: Option<f32>,
731 pub average_watts: Option<f32>,
732 pub device_watts: Option<bool>,
733 pub max_watts: Option<i32>,
734 pub weighted_average_watts: Option<i32>,
735}
736
737#[derive(Debug, Clone, Serialize, Deserialize)]
738pub struct SummaryAthlete {
739 pub id: Option<i64>,
740 pub resource_state: Option<i32>,
741 pub firstname: Option<String>,
742 pub lastname: Option<String>,
743 pub profile_medium: Option<String>,
744 pub profile: Option<String>,
745 pub city: Option<String>,
746 pub state: Option<String>,
747 pub country: Option<String>,
748 pub sex: Option<String>,
749 #[deprecated(note = "Use summit instead")]
750 pub premium: Option<bool>,
751 pub summit: Option<bool>,
752 pub created_at: Option<DateTime<Utc>>,
753 pub updated_at: Option<DateTime<Utc>>,
754}
755
756#[derive(Debug, Clone, Serialize, Deserialize)]
757pub struct SummaryClub {
758 pub id: Option<i64>,
759 pub resource_state: Option<i32>,
760 pub name: Option<String>,
761 pub profile_medium: Option<String>,
762 pub cover_photo: Option<String>,
763 pub cover_photo_small: Option<String>,
764 #[deprecated(note = "Use activity_types instead")]
765 pub sport_type: Option<String>,
766 pub activity_types: Option<Vec<ActivityType>>,
767 pub city: Option<String>,
768 pub state: Option<String>,
769 pub country: Option<String>,
770 pub private: Option<bool>,
771 pub member_count: Option<i32>,
772 pub featured: Option<bool>,
773 pub verified: Option<bool>,
774 pub url: Option<String>,
775}
776
777#[derive(Debug, Clone, Serialize, Deserialize)]
778pub struct TemperatureStream {
779 pub original_size: Option<i32>,
780 pub resolution: Option<String>,
781 pub series_type: Option<String>,
782 pub data: Option<Vec<i32>>,
783}
784
785#[derive(Debug, Clone, Serialize, Deserialize)]
786pub struct TimeStream {
787 pub original_size: Option<i32>,
788 pub resolution: Option<String>,
789 pub series_type: Option<String>,
790 pub data: Option<Vec<i32>>,
791}
792
793#[derive(Debug, Clone, Serialize, Deserialize)]
794pub struct TimedZoneRange {
795 pub min: Option<i32>,
796 pub max: Option<i32>,
797 pub time: Option<i32>,
798}
799
800#[derive(Debug, Clone, Serialize, Deserialize)]
801pub struct DetailedActivity {
802 pub id: Option<i64>,
803 pub external_id: Option<String>,
804 pub upload_id: Option<i64>,
805 pub athlete: Option<MetaAthlete>,
806 pub name: Option<String>,
807 pub distance: Option<f32>,
808 pub moving_time: Option<i32>,
809 pub elapsed_time: Option<i32>,
810 pub total_elevation_gain: Option<f32>,
811 pub elev_high: Option<f32>,
812 pub elev_low: Option<f32>,
813 #[deprecated(note = "Use sport_type instead")]
814 #[serde(default)]
815 pub r#type: Option<ActivityType>,
816 pub sport_type: Option<SportType>,
817 pub start_date: Option<DateTime<Utc>>,
818 pub start_date_local: Option<DateTime<Utc>>,
819 pub timezone: Option<String>,
820 pub start_latlng: Option<LatLng>,
821 pub end_latlng: Option<LatLng>,
822 pub achievement_count: Option<i32>,
823 pub kudos_count: Option<i32>,
824 pub comment_count: Option<i32>,
825 pub athlete_count: Option<i32>,
826 pub photo_count: Option<i32>,
827 pub total_photo_count: Option<i32>,
828 pub map: Option<PolylineMap>,
829 pub trainer: Option<bool>,
830 pub commute: Option<bool>,
831 pub manual: Option<bool>,
832 pub private: Option<bool>,
833 pub flagged: Option<bool>,
834 pub workout_type: Option<i32>,
835 pub upload_id_str: Option<String>,
836 pub average_speed: Option<f32>,
837 pub max_speed: Option<f32>,
838 pub has_kudoed: Option<bool>,
839 pub hide_from_home: Option<bool>,
840 pub gear_id: Option<String>,
841 pub kilojoules: Option<f32>,
842 pub average_watts: Option<f32>,
843 pub device_watts: Option<bool>,
844 pub max_watts: Option<i32>,
845 pub weighted_average_watts: Option<i32>,
846 pub description: Option<String>,
847 pub photos: Option<PhotosSummary>,
848 pub gear: Option<SummaryGear>,
849 pub calories: Option<f32>,
850 pub segment_efforts: Option<Vec<DetailedSegmentEffort>>,
851 pub device_name: Option<String>,
852 pub embed_token: Option<String>,
853 pub splits_metric: Option<Vec<Split>>,
854 pub splits_standard: Option<Vec<Split>>,
855 pub laps: Option<Vec<Lap>>,
856 pub best_efforts: Option<Vec<DetailedSegmentEffort>>,
857}
858
859#[derive(Debug, Clone, Serialize, Deserialize)]
860pub struct DetailedAthlete {
861 pub id: Option<i64>,
862 pub resource_state: Option<i32>,
863 pub firstname: Option<String>,
864 pub lastname: Option<String>,
865 pub profile_medium: Option<String>,
866 pub profile: Option<String>,
867 pub city: Option<String>,
868 pub state: Option<String>,
869 pub country: Option<String>,
870 pub sex: Option<String>,
871 #[deprecated(note = "Use summit instead")]
872 pub premium: Option<bool>,
873 pub summit: Option<bool>,
874 pub created_at: Option<DateTime<Utc>>,
875 pub updated_at: Option<DateTime<Utc>>,
876 pub follower_count: Option<i32>,
877 pub friend_count: Option<i32>,
878 pub measurement_preference: Option<String>,
879 pub ftp: Option<i32>,
880 pub weight: Option<f32>,
881 pub clubs: Option<Vec<SummaryClub>>,
882 pub bikes: Option<Vec<SummaryGear>>,
883 pub shoes: Option<Vec<SummaryGear>>,
884}
885
886#[derive(Debug, Clone, Serialize, Deserialize)]
887pub struct DetailedClub {
888 pub id: Option<i64>,
889 pub resource_state: Option<i32>,
890 pub name: Option<String>,
891 pub profile_medium: Option<String>,
892 pub cover_photo: Option<String>,
893 pub cover_photo_small: Option<String>,
894 #[deprecated(note = "Use activity_types instead")]
895 pub sport_type: Option<String>,
896 pub activity_types: Option<Vec<ActivityType>>,
897 pub city: Option<String>,
898 pub state: Option<String>,
899 pub country: Option<String>,
900 pub private: Option<bool>,
901 pub member_count: Option<i32>,
902 pub featured: Option<bool>,
903 pub verified: Option<bool>,
904 pub url: Option<String>,
905 pub membership: Option<String>,
906 pub admin: Option<bool>,
907 pub owner: Option<bool>,
908 pub following_count: Option<i32>,
909}