rustyfit 0.10.0

// Code generated by fitgen/main.go. DO NOT EDIT.

// Copyright 2025 The RustyFIT Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

#![allow(clippy::manual_range_patterns)]

use crate::profile::typedef::{self, FitBaseType};
use crate::proto::*;
use crate::semconv;
use alloc::borrow::ToOwned;
use alloc::string::String;
use alloc::vec::Vec;
#[cfg(feature = "serde")]
use serde::{Deserialize, Serialize, Serializer, ser::SerializeStruct};

fn is_expanded(state: &[u8], num: u8) -> bool {
    match num {
        124 | 125 | 126 | 127 | 128 | 169 | 170 | 180 => {
            (state[num as usize >> 3] >> (num & 7)) & 1 == 1
        }
        _ => false,
    }
}

/// Session message.
#[cfg_attr(feature = "serde", derive(Deserialize), serde(from = "De"))]
#[derive(Debug, Clone)]
pub struct Session {
    /// Selected bit is set for the current session.
    pub message_index: typedef::MessageIndex,
    /// Units: s
    pub timestamp: typedef::DateTime,
    /// session
    pub event: typedef::Event,
    /// stop
    pub event_type: typedef::EventType,
    pub start_time: typedef::DateTime,
    /// Units: semicircles
    pub start_position_lat: i32,
    /// Units: semicircles
    pub start_position_long: i32,
    pub sport: typedef::Sport,
    pub sub_sport: typedef::SubSport,
    /// Scale: 1000; Units: s; Time (includes pauses)
    pub total_elapsed_time: u32,
    /// Scale: 1000; Units: s; Timer Time (excludes pauses)
    pub total_timer_time: u32,
    /// Scale: 100; Units: m
    pub total_distance: u32,
    /// Units: cycles
    pub total_cycles: u32,
    /// Units: kcal
    pub total_calories: u16,
    /// Units: kcal
    pub total_fat_calories: u16,
    /// Scale: 1000; Units: m/s; total_distance / total_timer_time
    pub avg_speed: u16,
    /// Scale: 1000; Units: m/s
    pub max_speed: u16,
    /// Units: bpm; average heart rate (excludes pause time)
    pub avg_heart_rate: u8,
    /// Units: bpm
    pub max_heart_rate: u8,
    /// Units: rpm; total_cycles / total_timer_time if non_zero_avg_cadence otherwise total_cycles / total_elapsed_time
    pub avg_cadence: u8,
    /// Units: rpm
    pub max_cadence: u8,
    /// Units: watts; total_power / total_timer_time if non_zero_avg_power otherwise total_power / total_elapsed_time
    pub avg_power: u16,
    /// Units: watts
    pub max_power: u16,
    /// Units: m
    pub total_ascent: u16,
    /// Units: m
    pub total_descent: u16,
    /// Scale: 10
    pub total_training_effect: u8,
    pub first_lap_index: u16,
    pub num_laps: u16,
    pub event_group: u8,
    pub trigger: typedef::SessionTrigger,
    /// Units: semicircles; North east corner latitude
    pub nec_lat: i32,
    /// Units: semicircles; North east corner longitude
    pub nec_long: i32,
    /// Units: semicircles; South west corner latitude
    pub swc_lat: i32,
    /// Units: semicircles; South west corner longitude
    pub swc_long: i32,
    /// Units: lengths; # of lengths of swim pool
    pub num_lengths: u16,
    /// Units: watts
    pub normalized_power: u16,
    /// Scale: 10; Units: tss
    pub training_stress_score: u16,
    /// Scale: 1000; Units: if
    pub intensity_factor: u16,
    pub left_right_balance: typedef::LeftRightBalance100,
    /// Units: semicircles
    pub end_position_lat: i32,
    /// Units: semicircles
    pub end_position_long: i32,
    /// Scale: 10; Units: strokes/lap
    pub avg_stroke_count: u32,
    /// Scale: 100; Units: m
    pub avg_stroke_distance: u16,
    /// Units: swim_stroke
    pub swim_stroke: typedef::SwimStroke,
    /// Scale: 100; Units: m
    pub pool_length: u16,
    /// Units: watts
    pub threshold_power: u16,
    pub pool_length_unit: typedef::DisplayMeasure,
    /// Units: lengths; # of active lengths of swim pool
    pub num_active_lengths: u16,
    /// Units: J
    pub total_work: u32,
    /// Scale: 5; Offset: 500; Units: m
    pub avg_altitude: u16,
    /// Scale: 5; Offset: 500; Units: m
    pub max_altitude: u16,
    /// Units: m
    pub gps_accuracy: u8,
    /// Scale: 100; Units: %
    pub avg_grade: i16,
    /// Scale: 100; Units: %
    pub avg_pos_grade: i16,
    /// Scale: 100; Units: %
    pub avg_neg_grade: i16,
    /// Scale: 100; Units: %
    pub max_pos_grade: i16,
    /// Scale: 100; Units: %
    pub max_neg_grade: i16,
    /// Units: C
    pub avg_temperature: i8,
    /// Units: C
    pub max_temperature: i8,
    /// Scale: 1000; Units: s
    pub total_moving_time: u32,
    /// Scale: 1000; Units: m/s
    pub avg_pos_vertical_speed: i16,
    /// Scale: 1000; Units: m/s
    pub avg_neg_vertical_speed: i16,
    /// Scale: 1000; Units: m/s
    pub max_pos_vertical_speed: i16,
    /// Scale: 1000; Units: m/s
    pub max_neg_vertical_speed: i16,
    /// Units: bpm
    pub min_heart_rate: u8,
    /// Scale: 1000; Units: s
    pub time_in_hr_zone: Vec<u32>,
    /// Scale: 1000; Units: s
    pub time_in_speed_zone: Vec<u32>,
    /// Scale: 1000; Units: s
    pub time_in_cadence_zone: Vec<u32>,
    /// Scale: 1000; Units: s
    pub time_in_power_zone: Vec<u32>,
    /// Scale: 1000; Units: s
    pub avg_lap_time: u32,
    pub best_lap_index: u16,
    /// Scale: 5; Offset: 500; Units: m
    pub min_altitude: u16,
    /// Scale: 1000; Units: s
    pub active_time: u32,
    pub player_score: u16,
    pub opponent_score: u16,
    pub opponent_name: String,
    /// Units: counts; stroke_type enum used as the index
    pub stroke_count: Vec<u16>,
    /// Units: counts; zone number used as the index
    pub zone_count: Vec<u16>,
    /// Scale: 100; Units: m/s
    pub max_ball_speed: u16,
    /// Scale: 100; Units: m/s
    pub avg_ball_speed: u16,
    /// Scale: 10; Units: mm
    pub avg_vertical_oscillation: u16,
    /// Scale: 100; Units: percent
    pub avg_stance_time_percent: u16,
    /// Scale: 10; Units: ms
    pub avg_stance_time: u16,
    /// Scale: 128; Units: rpm; fractional part of the avg_cadence
    pub avg_fractional_cadence: u8,
    /// Scale: 128; Units: rpm; fractional part of the max_cadence
    pub max_fractional_cadence: u8,
    /// Scale: 128; Units: cycles; fractional part of the total_cycles
    pub total_fractional_cycles: u8,
    /// Scale: 100; Units: g/dL; Avg saturated and unsaturated hemoglobin
    pub avg_total_hemoglobin_conc: Vec<u16>,
    /// Scale: 100; Units: g/dL; Min saturated and unsaturated hemoglobin
    pub min_total_hemoglobin_conc: Vec<u16>,
    /// Scale: 100; Units: g/dL; Max saturated and unsaturated hemoglobin
    pub max_total_hemoglobin_conc: Vec<u16>,
    /// Scale: 10; Units: %; Avg percentage of hemoglobin saturated with oxygen
    pub avg_saturated_hemoglobin_percent: Vec<u16>,
    /// Scale: 10; Units: %; Min percentage of hemoglobin saturated with oxygen
    pub min_saturated_hemoglobin_percent: Vec<u16>,
    /// Scale: 10; Units: %; Max percentage of hemoglobin saturated with oxygen
    pub max_saturated_hemoglobin_percent: Vec<u16>,
    /// Scale: 2; Units: percent
    pub avg_left_torque_effectiveness: u8,
    /// Scale: 2; Units: percent
    pub avg_right_torque_effectiveness: u8,
    /// Scale: 2; Units: percent
    pub avg_left_pedal_smoothness: u8,
    /// Scale: 2; Units: percent
    pub avg_right_pedal_smoothness: u8,
    /// Scale: 2; Units: percent
    pub avg_combined_pedal_smoothness: u8,
    /// Sport name from associated sport mesg
    pub sport_profile_name: String,
    pub sport_index: u8,
    /// Scale: 1000; Units: s; Total time spend in the standing position
    pub time_standing: u32,
    /// Number of transitions to the standing state
    pub stand_count: u16,
    /// Units: mm; Average platform center offset Left
    pub avg_left_pco: i8,
    /// Units: mm; Average platform center offset Right
    pub avg_right_pco: i8,
    /// Scale: 0.7111111; Units: degrees; Average left power phase angles. Indexes defined by power_phase_type.
    pub avg_left_power_phase: Vec<u8>,
    /// Scale: 0.7111111; Units: degrees; Average left power phase peak angles. Data value indexes defined by power_phase_type.
    pub avg_left_power_phase_peak: Vec<u8>,
    /// Scale: 0.7111111; Units: degrees; Average right power phase angles. Data value indexes defined by power_phase_type.
    pub avg_right_power_phase: Vec<u8>,
    /// Scale: 0.7111111; Units: degrees; Average right power phase peak angles data value indexes defined by power_phase_type.
    pub avg_right_power_phase_peak: Vec<u8>,
    /// Units: watts; Average power by position. Data value indexes defined by rider_position_type.
    pub avg_power_position: Vec<u16>,
    /// Units: watts; Maximum power by position. Data value indexes defined by rider_position_type.
    pub max_power_position: Vec<u16>,
    /// Units: rpm; Average cadence by position. Data value indexes defined by rider_position_type.
    pub avg_cadence_position: Vec<u8>,
    /// Units: rpm; Maximum cadence by position. Data value indexes defined by rider_position_type.
    pub max_cadence_position: Vec<u8>,
    /// Scale: 1000; Units: m/s; total_distance / total_timer_time
    pub enhanced_avg_speed: u32,
    /// Scale: 1000; Units: m/s
    pub enhanced_max_speed: u32,
    /// Scale: 5; Offset: 500; Units: m
    pub enhanced_avg_altitude: u32,
    /// Scale: 5; Offset: 500; Units: m
    pub enhanced_min_altitude: u32,
    /// Scale: 5; Offset: 500; Units: m
    pub enhanced_max_altitude: u32,
    /// Units: watts; lev average motor power during session
    pub avg_lev_motor_power: u16,
    /// Units: watts; lev maximum motor power during session
    pub max_lev_motor_power: u16,
    /// Scale: 2; Units: percent; lev battery consumption during session
    pub lev_battery_consumption: u8,
    /// Scale: 100; Units: percent
    pub avg_vertical_ratio: u16,
    /// Scale: 100; Units: percent
    pub avg_stance_time_balance: u16,
    /// Scale: 10; Units: mm
    pub avg_step_length: u16,
    /// Scale: 10
    pub total_anaerobic_training_effect: u8,
    /// Scale: 1000; Units: m/s
    pub avg_vam: u16,
    /// Scale: 1000; Units: m; 0 if above water
    pub avg_depth: u32,
    /// Scale: 1000; Units: m; 0 if above water
    pub max_depth: u32,
    /// Units: s; Time since end of last dive
    pub surface_interval: u32,
    /// Units: percent
    pub start_cns: u8,
    /// Units: percent
    pub end_cns: u8,
    /// Units: percent
    pub start_n2: u16,
    /// Units: percent
    pub end_n2: u16,
    pub avg_respiration_rate: u8,
    pub max_respiration_rate: u8,
    pub min_respiration_rate: u8,
    /// Units: C
    pub min_temperature: i8,
    /// Units: OTUs
    pub o2_toxicity: u16,
    pub dive_number: u32,
    /// Scale: 65536
    pub training_load_peak: i32,
    /// Scale: 100; Units: Breaths/min
    pub enhanced_avg_respiration_rate: u16,
    /// Scale: 100; Units: Breaths/min
    pub enhanced_max_respiration_rate: u16,
    /// Scale: 100
    pub enhanced_min_respiration_rate: u16,
    /// Units: kGrit; The grit score estimates how challenging a route could be for a cyclist in terms of time spent going over sharp turns or large grade slopes.
    pub total_grit: f32,
    /// Units: Flow; The flow score estimates how long distance wise a cyclist deaccelerates over intervals where deacceleration is unnecessary such as smooth turns or small grade angle intervals.
    pub total_flow: f32,
    pub jump_count: u16,
    /// Units: kGrit; The grit score estimates how challenging a route could be for a cyclist in terms of time spent going over sharp turns or large grade slopes.
    pub avg_grit: f32,
    /// Units: Flow; The flow score estimates how long distance wise a cyclist deaccelerates over intervals where deacceleration is unnecessary such as smooth turns or small grade angle intervals.
    pub avg_flow: f32,
    /// A 0-100 scale representing how a user felt while performing a workout. Low values are considered feeling bad, while high values are good.
    pub workout_feel: u8,
    /// Common Borg CR10 / 0-10 RPE scale, multiplied 10x.. Aggregate score for all workouts in a single session.
    pub workout_rpe: u8,
    /// Units: percent; Average SPO2 for the monitoring session
    pub avg_spo2: u8,
    /// Units: percent; Average stress for the monitoring session
    pub avg_stress: u8,
    /// Units: kcal
    pub metabolic_calories: u16,
    /// Units: mS; Standard deviation of R-R interval (SDRR) - Heart rate variability measure most useful for wellness users.
    pub sdrr_hrv: u8,
    /// Units: mS; Root mean square successive difference (RMSSD) - Heart rate variability measure most useful for athletes
    pub rmssd_hrv: u8,
    /// Scale: 100; Units: m; fractional part of total_ascent
    pub total_fractional_ascent: u8,
    /// Scale: 100; Units: m; fractional part of total_descent
    pub total_fractional_descent: u8,
    /// Scale: 100; Units: C
    pub avg_core_temperature: u16,
    /// Scale: 100; Units: C
    pub min_core_temperature: u16,
    /// Scale: 100; Units: C
    pub max_core_temperature: u16,
    state: [u8; 23], // Used for tracking expanded fields.
    /// unknown_fields are fields that are exist but they are not defined in Profile.xlsx
    pub unknown_fields: Vec<Field>,
    /// developer_fields are custom data fields (Added since protocol version 2.0)
    pub developer_fields: Vec<DeveloperField>,
}

impl Session {
    /// Value's type: `u16`; FitBaseType::UINT16; ProfileType::MessageIndex
    pub const MESSAGE_INDEX: u8 = 254;
    /// Value's type: `u32`; FitBaseType::UINT32; ProfileType::DateTime; Units: `s`
    pub const TIMESTAMP: u8 = 253;
    /// Value's type: `u8`; FitBaseType::ENUM; ProfileType::Event
    pub const EVENT: u8 = 0;
    /// Value's type: `u8`; FitBaseType::ENUM; ProfileType::EventType
    pub const EVENT_TYPE: u8 = 1;
    /// Value's type: `u32`; FitBaseType::UINT32; ProfileType::DateTime
    pub const START_TIME: u8 = 2;
    /// Value's type: `i32`; FitBaseType::SINT32; ProfileType::Sint32; Units: `semicircles`
    pub const START_POSITION_LAT: u8 = 3;
    /// Value's type: `i32`; FitBaseType::SINT32; ProfileType::Sint32; Units: `semicircles`
    pub const START_POSITION_LONG: u8 = 4;
    /// Value's type: `u8`; FitBaseType::ENUM; ProfileType::Sport
    pub const SPORT: u8 = 5;
    /// Value's type: `u8`; FitBaseType::ENUM; ProfileType::SubSport
    pub const SUB_SPORT: u8 = 6;
    /// Value's type: `u32`; FitBaseType::UINT32; ProfileType::Uint32; Scale: `1000`; Units: `s`
    pub const TOTAL_ELAPSED_TIME: u8 = 7;
    /// Value's type: `u32`; FitBaseType::UINT32; ProfileType::Uint32; Scale: `1000`; Units: `s`
    pub const TOTAL_TIMER_TIME: u8 = 8;
    /// Value's type: `u32`; FitBaseType::UINT32; ProfileType::Uint32; Scale: `100`; Units: `m`
    pub const TOTAL_DISTANCE: u8 = 9;
    /// Value's type: `u32`; FitBaseType::UINT32; ProfileType::Uint32; Units: `cycles`
    pub const TOTAL_CYCLES: u8 = 10;
    /// Value's type: `u16`; FitBaseType::UINT16; ProfileType::Uint16; Units: `kcal`
    pub const TOTAL_CALORIES: u8 = 11;
    /// Value's type: `u16`; FitBaseType::UINT16; ProfileType::Uint16; Units: `kcal`
    pub const TOTAL_FAT_CALORIES: u8 = 13;
    /// Value's type: `u16`; FitBaseType::UINT16; ProfileType::Uint16; Scale: `1000`; Units: `m/s`
    pub const AVG_SPEED: u8 = 14;
    /// Value's type: `u16`; FitBaseType::UINT16; ProfileType::Uint16; Scale: `1000`; Units: `m/s`
    pub const MAX_SPEED: u8 = 15;
    /// Value's type: `u8`; FitBaseType::UINT8; ProfileType::Uint8; Units: `bpm`
    pub const AVG_HEART_RATE: u8 = 16;
    /// Value's type: `u8`; FitBaseType::UINT8; ProfileType::Uint8; Units: `bpm`
    pub const MAX_HEART_RATE: u8 = 17;
    /// Value's type: `u8`; FitBaseType::UINT8; ProfileType::Uint8; Units: `rpm`
    pub const AVG_CADENCE: u8 = 18;
    /// Value's type: `u8`; FitBaseType::UINT8; ProfileType::Uint8; Units: `rpm`
    pub const MAX_CADENCE: u8 = 19;
    /// Value's type: `u16`; FitBaseType::UINT16; ProfileType::Uint16; Units: `watts`
    pub const AVG_POWER: u8 = 20;
    /// Value's type: `u16`; FitBaseType::UINT16; ProfileType::Uint16; Units: `watts`
    pub const MAX_POWER: u8 = 21;
    /// Value's type: `u16`; FitBaseType::UINT16; ProfileType::Uint16; Units: `m`
    pub const TOTAL_ASCENT: u8 = 22;
    /// Value's type: `u16`; FitBaseType::UINT16; ProfileType::Uint16; Units: `m`
    pub const TOTAL_DESCENT: u8 = 23;
    /// Value's type: `u8`; FitBaseType::UINT8; ProfileType::Uint8; Scale: `10`
    pub const TOTAL_TRAINING_EFFECT: u8 = 24;
    /// Value's type: `u16`; FitBaseType::UINT16; ProfileType::Uint16
    pub const FIRST_LAP_INDEX: u8 = 25;
    /// Value's type: `u16`; FitBaseType::UINT16; ProfileType::Uint16
    pub const NUM_LAPS: u8 = 26;
    /// Value's type: `u8`; FitBaseType::UINT8; ProfileType::Uint8
    pub const EVENT_GROUP: u8 = 27;
    /// Value's type: `u8`; FitBaseType::ENUM; ProfileType::SessionTrigger
    pub const TRIGGER: u8 = 28;
    /// Value's type: `i32`; FitBaseType::SINT32; ProfileType::Sint32; Units: `semicircles`
    pub const NEC_LAT: u8 = 29;
    /// Value's type: `i32`; FitBaseType::SINT32; ProfileType::Sint32; Units: `semicircles`
    pub const NEC_LONG: u8 = 30;
    /// Value's type: `i32`; FitBaseType::SINT32; ProfileType::Sint32; Units: `semicircles`
    pub const SWC_LAT: u8 = 31;
    /// Value's type: `i32`; FitBaseType::SINT32; ProfileType::Sint32; Units: `semicircles`
    pub const SWC_LONG: u8 = 32;
    /// Value's type: `u16`; FitBaseType::UINT16; ProfileType::Uint16; Units: `lengths`
    pub const NUM_LENGTHS: u8 = 33;
    /// Value's type: `u16`; FitBaseType::UINT16; ProfileType::Uint16; Units: `watts`
    pub const NORMALIZED_POWER: u8 = 34;
    /// Value's type: `u16`; FitBaseType::UINT16; ProfileType::Uint16; Scale: `10`; Units: `tss`
    pub const TRAINING_STRESS_SCORE: u8 = 35;
    /// Value's type: `u16`; FitBaseType::UINT16; ProfileType::Uint16; Scale: `1000`; Units: `if`
    pub const INTENSITY_FACTOR: u8 = 36;
    /// Value's type: `u16`; FitBaseType::UINT16; ProfileType::LeftRightBalance100
    pub const LEFT_RIGHT_BALANCE: u8 = 37;
    /// Value's type: `i32`; FitBaseType::SINT32; ProfileType::Sint32; Units: `semicircles`
    pub const END_POSITION_LAT: u8 = 38;
    /// Value's type: `i32`; FitBaseType::SINT32; ProfileType::Sint32; Units: `semicircles`
    pub const END_POSITION_LONG: u8 = 39;
    /// Value's type: `u32`; FitBaseType::UINT32; ProfileType::Uint32; Scale: `10`; Units: `strokes/lap`
    pub const AVG_STROKE_COUNT: u8 = 41;
    /// Value's type: `u16`; FitBaseType::UINT16; ProfileType::Uint16; Scale: `100`; Units: `m`
    pub const AVG_STROKE_DISTANCE: u8 = 42;
    /// Value's type: `u8`; FitBaseType::ENUM; ProfileType::SwimStroke; Units: `swim_stroke`
    pub const SWIM_STROKE: u8 = 43;
    /// Value's type: `u16`; FitBaseType::UINT16; ProfileType::Uint16; Scale: `100`; Units: `m`
    pub const POOL_LENGTH: u8 = 44;
    /// Value's type: `u16`; FitBaseType::UINT16; ProfileType::Uint16; Units: `watts`
    pub const THRESHOLD_POWER: u8 = 45;
    /// Value's type: `u8`; FitBaseType::ENUM; ProfileType::DisplayMeasure
    pub const POOL_LENGTH_UNIT: u8 = 46;
    /// Value's type: `u16`; FitBaseType::UINT16; ProfileType::Uint16; Units: `lengths`
    pub const NUM_ACTIVE_LENGTHS: u8 = 47;
    /// Value's type: `u32`; FitBaseType::UINT32; ProfileType::Uint32; Units: `J`
    pub const TOTAL_WORK: u8 = 48;
    /// Value's type: `u16`; FitBaseType::UINT16; ProfileType::Uint16; Scale: `5`; Offset: `500`; Units: `m`
    pub const AVG_ALTITUDE: u8 = 49;
    /// Value's type: `u16`; FitBaseType::UINT16; ProfileType::Uint16; Scale: `5`; Offset: `500`; Units: `m`
    pub const MAX_ALTITUDE: u8 = 50;
    /// Value's type: `u8`; FitBaseType::UINT8; ProfileType::Uint8; Units: `m`
    pub const GPS_ACCURACY: u8 = 51;
    /// Value's type: `i16`; FitBaseType::SINT16; ProfileType::Sint16; Scale: `100`; Units: `%`
    pub const AVG_GRADE: u8 = 52;
    /// Value's type: `i16`; FitBaseType::SINT16; ProfileType::Sint16; Scale: `100`; Units: `%`
    pub const AVG_POS_GRADE: u8 = 53;
    /// Value's type: `i16`; FitBaseType::SINT16; ProfileType::Sint16; Scale: `100`; Units: `%`
    pub const AVG_NEG_GRADE: u8 = 54;
    /// Value's type: `i16`; FitBaseType::SINT16; ProfileType::Sint16; Scale: `100`; Units: `%`
    pub const MAX_POS_GRADE: u8 = 55;
    /// Value's type: `i16`; FitBaseType::SINT16; ProfileType::Sint16; Scale: `100`; Units: `%`
    pub const MAX_NEG_GRADE: u8 = 56;
    /// Value's type: `i8`; FitBaseType::SINT8; ProfileType::Sint8; Units: `C`
    pub const AVG_TEMPERATURE: u8 = 57;
    /// Value's type: `i8`; FitBaseType::SINT8; ProfileType::Sint8; Units: `C`
    pub const MAX_TEMPERATURE: u8 = 58;
    /// Value's type: `u32`; FitBaseType::UINT32; ProfileType::Uint32; Scale: `1000`; Units: `s`
    pub const TOTAL_MOVING_TIME: u8 = 59;
    /// Value's type: `i16`; FitBaseType::SINT16; ProfileType::Sint16; Scale: `1000`; Units: `m/s`
    pub const AVG_POS_VERTICAL_SPEED: u8 = 60;
    /// Value's type: `i16`; FitBaseType::SINT16; ProfileType::Sint16; Scale: `1000`; Units: `m/s`
    pub const AVG_NEG_VERTICAL_SPEED: u8 = 61;
    /// Value's type: `i16`; FitBaseType::SINT16; ProfileType::Sint16; Scale: `1000`; Units: `m/s`
    pub const MAX_POS_VERTICAL_SPEED: u8 = 62;
    /// Value's type: `i16`; FitBaseType::SINT16; ProfileType::Sint16; Scale: `1000`; Units: `m/s`
    pub const MAX_NEG_VERTICAL_SPEED: u8 = 63;
    /// Value's type: `u8`; FitBaseType::UINT8; ProfileType::Uint8; Units: `bpm`
    pub const MIN_HEART_RATE: u8 = 64;
    /// Value's type: `Vec<u32>`; FitBaseType::UINT32; ProfileType::Uint32; Scale: `1000`; Units: `s`
    pub const TIME_IN_HR_ZONE: u8 = 65;
    /// Value's type: `Vec<u32>`; FitBaseType::UINT32; ProfileType::Uint32; Scale: `1000`; Units: `s`
    pub const TIME_IN_SPEED_ZONE: u8 = 66;
    /// Value's type: `Vec<u32>`; FitBaseType::UINT32; ProfileType::Uint32; Scale: `1000`; Units: `s`
    pub const TIME_IN_CADENCE_ZONE: u8 = 67;
    /// Value's type: `Vec<u32>`; FitBaseType::UINT32; ProfileType::Uint32; Scale: `1000`; Units: `s`
    pub const TIME_IN_POWER_ZONE: u8 = 68;
    /// Value's type: `u32`; FitBaseType::UINT32; ProfileType::Uint32; Scale: `1000`; Units: `s`
    pub const AVG_LAP_TIME: u8 = 69;
    /// Value's type: `u16`; FitBaseType::UINT16; ProfileType::Uint16
    pub const BEST_LAP_INDEX: u8 = 70;
    /// Value's type: `u16`; FitBaseType::UINT16; ProfileType::Uint16; Scale: `5`; Offset: `500`; Units: `m`
    pub const MIN_ALTITUDE: u8 = 71;
    /// Value's type: `u32`; FitBaseType::UINT32; ProfileType::Uint32; Scale: `1000`; Units: `s`
    pub const ACTIVE_TIME: u8 = 78;
    /// Value's type: `u16`; FitBaseType::UINT16; ProfileType::Uint16
    pub const PLAYER_SCORE: u8 = 82;
    /// Value's type: `u16`; FitBaseType::UINT16; ProfileType::Uint16
    pub const OPPONENT_SCORE: u8 = 83;
    /// Value's type: `String`; FitBaseType::STRING; ProfileType::String
    pub const OPPONENT_NAME: u8 = 84;
    /// Value's type: `Vec<u16>`; FitBaseType::UINT16; ProfileType::Uint16; Units: `counts`
    pub const STROKE_COUNT: u8 = 85;
    /// Value's type: `Vec<u16>`; FitBaseType::UINT16; ProfileType::Uint16; Units: `counts`
    pub const ZONE_COUNT: u8 = 86;
    /// Value's type: `u16`; FitBaseType::UINT16; ProfileType::Uint16; Scale: `100`; Units: `m/s`
    pub const MAX_BALL_SPEED: u8 = 87;
    /// Value's type: `u16`; FitBaseType::UINT16; ProfileType::Uint16; Scale: `100`; Units: `m/s`
    pub const AVG_BALL_SPEED: u8 = 88;
    /// Value's type: `u16`; FitBaseType::UINT16; ProfileType::Uint16; Scale: `10`; Units: `mm`
    pub const AVG_VERTICAL_OSCILLATION: u8 = 89;
    /// Value's type: `u16`; FitBaseType::UINT16; ProfileType::Uint16; Scale: `100`; Units: `percent`
    pub const AVG_STANCE_TIME_PERCENT: u8 = 90;
    /// Value's type: `u16`; FitBaseType::UINT16; ProfileType::Uint16; Scale: `10`; Units: `ms`
    pub const AVG_STANCE_TIME: u8 = 91;
    /// Value's type: `u8`; FitBaseType::UINT8; ProfileType::Uint8; Scale: `128`; Units: `rpm`
    pub const AVG_FRACTIONAL_CADENCE: u8 = 92;
    /// Value's type: `u8`; FitBaseType::UINT8; ProfileType::Uint8; Scale: `128`; Units: `rpm`
    pub const MAX_FRACTIONAL_CADENCE: u8 = 93;
    /// Value's type: `u8`; FitBaseType::UINT8; ProfileType::Uint8; Scale: `128`; Units: `cycles`
    pub const TOTAL_FRACTIONAL_CYCLES: u8 = 94;
    /// Value's type: `Vec<u16>`; FitBaseType::UINT16; ProfileType::Uint16; Scale: `100`; Units: `g/dL`
    pub const AVG_TOTAL_HEMOGLOBIN_CONC: u8 = 95;
    /// Value's type: `Vec<u16>`; FitBaseType::UINT16; ProfileType::Uint16; Scale: `100`; Units: `g/dL`
    pub const MIN_TOTAL_HEMOGLOBIN_CONC: u8 = 96;
    /// Value's type: `Vec<u16>`; FitBaseType::UINT16; ProfileType::Uint16; Scale: `100`; Units: `g/dL`
    pub const MAX_TOTAL_HEMOGLOBIN_CONC: u8 = 97;
    /// Value's type: `Vec<u16>`; FitBaseType::UINT16; ProfileType::Uint16; Scale: `10`; Units: `%`
    pub const AVG_SATURATED_HEMOGLOBIN_PERCENT: u8 = 98;
    /// Value's type: `Vec<u16>`; FitBaseType::UINT16; ProfileType::Uint16; Scale: `10`; Units: `%`
    pub const MIN_SATURATED_HEMOGLOBIN_PERCENT: u8 = 99;
    /// Value's type: `Vec<u16>`; FitBaseType::UINT16; ProfileType::Uint16; Scale: `10`; Units: `%`
    pub const MAX_SATURATED_HEMOGLOBIN_PERCENT: u8 = 100;
    /// Value's type: `u8`; FitBaseType::UINT8; ProfileType::Uint8; Scale: `2`; Units: `percent`
    pub const AVG_LEFT_TORQUE_EFFECTIVENESS: u8 = 101;
    /// Value's type: `u8`; FitBaseType::UINT8; ProfileType::Uint8; Scale: `2`; Units: `percent`
    pub const AVG_RIGHT_TORQUE_EFFECTIVENESS: u8 = 102;
    /// Value's type: `u8`; FitBaseType::UINT8; ProfileType::Uint8; Scale: `2`; Units: `percent`
    pub const AVG_LEFT_PEDAL_SMOOTHNESS: u8 = 103;
    /// Value's type: `u8`; FitBaseType::UINT8; ProfileType::Uint8; Scale: `2`; Units: `percent`
    pub const AVG_RIGHT_PEDAL_SMOOTHNESS: u8 = 104;
    /// Value's type: `u8`; FitBaseType::UINT8; ProfileType::Uint8; Scale: `2`; Units: `percent`
    pub const AVG_COMBINED_PEDAL_SMOOTHNESS: u8 = 105;
    /// Value's type: `String`; FitBaseType::STRING; ProfileType::String
    pub const SPORT_PROFILE_NAME: u8 = 110;
    /// Value's type: `u8`; FitBaseType::UINT8; ProfileType::Uint8
    pub const SPORT_INDEX: u8 = 111;
    /// Value's type: `u32`; FitBaseType::UINT32; ProfileType::Uint32; Scale: `1000`; Units: `s`
    pub const TIME_STANDING: u8 = 112;
    /// Value's type: `u16`; FitBaseType::UINT16; ProfileType::Uint16
    pub const STAND_COUNT: u8 = 113;
    /// Value's type: `i8`; FitBaseType::SINT8; ProfileType::Sint8; Units: `mm`
    pub const AVG_LEFT_PCO: u8 = 114;
    /// Value's type: `i8`; FitBaseType::SINT8; ProfileType::Sint8; Units: `mm`
    pub const AVG_RIGHT_PCO: u8 = 115;
    /// Value's type: `Vec<u8>`; FitBaseType::UINT8; ProfileType::Uint8; Scale: `0.7111111`; Units: `degrees`
    pub const AVG_LEFT_POWER_PHASE: u8 = 116;
    /// Value's type: `Vec<u8>`; FitBaseType::UINT8; ProfileType::Uint8; Scale: `0.7111111`; Units: `degrees`
    pub const AVG_LEFT_POWER_PHASE_PEAK: u8 = 117;
    /// Value's type: `Vec<u8>`; FitBaseType::UINT8; ProfileType::Uint8; Scale: `0.7111111`; Units: `degrees`
    pub const AVG_RIGHT_POWER_PHASE: u8 = 118;
    /// Value's type: `Vec<u8>`; FitBaseType::UINT8; ProfileType::Uint8; Scale: `0.7111111`; Units: `degrees`
    pub const AVG_RIGHT_POWER_PHASE_PEAK: u8 = 119;
    /// Value's type: `Vec<u16>`; FitBaseType::UINT16; ProfileType::Uint16; Units: `watts`
    pub const AVG_POWER_POSITION: u8 = 120;
    /// Value's type: `Vec<u16>`; FitBaseType::UINT16; ProfileType::Uint16; Units: `watts`
    pub const MAX_POWER_POSITION: u8 = 121;
    /// Value's type: `Vec<u8>`; FitBaseType::UINT8; ProfileType::Uint8; Units: `rpm`
    pub const AVG_CADENCE_POSITION: u8 = 122;
    /// Value's type: `Vec<u8>`; FitBaseType::UINT8; ProfileType::Uint8; Units: `rpm`
    pub const MAX_CADENCE_POSITION: u8 = 123;
    /// Value's type: `u32`; FitBaseType::UINT32; ProfileType::Uint32; Scale: `1000`; Units: `m/s`
    pub const ENHANCED_AVG_SPEED: u8 = 124;
    /// Value's type: `u32`; FitBaseType::UINT32; ProfileType::Uint32; Scale: `1000`; Units: `m/s`
    pub const ENHANCED_MAX_SPEED: u8 = 125;
    /// Value's type: `u32`; FitBaseType::UINT32; ProfileType::Uint32; Scale: `5`; Offset: `500`; Units: `m`
    pub const ENHANCED_AVG_ALTITUDE: u8 = 126;
    /// Value's type: `u32`; FitBaseType::UINT32; ProfileType::Uint32; Scale: `5`; Offset: `500`; Units: `m`
    pub const ENHANCED_MIN_ALTITUDE: u8 = 127;
    /// Value's type: `u32`; FitBaseType::UINT32; ProfileType::Uint32; Scale: `5`; Offset: `500`; Units: `m`
    pub const ENHANCED_MAX_ALTITUDE: u8 = 128;
    /// Value's type: `u16`; FitBaseType::UINT16; ProfileType::Uint16; Units: `watts`
    pub const AVG_LEV_MOTOR_POWER: u8 = 129;
    /// Value's type: `u16`; FitBaseType::UINT16; ProfileType::Uint16; Units: `watts`
    pub const MAX_LEV_MOTOR_POWER: u8 = 130;
    /// Value's type: `u8`; FitBaseType::UINT8; ProfileType::Uint8; Scale: `2`; Units: `percent`
    pub const LEV_BATTERY_CONSUMPTION: u8 = 131;
    /// Value's type: `u16`; FitBaseType::UINT16; ProfileType::Uint16; Scale: `100`; Units: `percent`
    pub const AVG_VERTICAL_RATIO: u8 = 132;
    /// Value's type: `u16`; FitBaseType::UINT16; ProfileType::Uint16; Scale: `100`; Units: `percent`
    pub const AVG_STANCE_TIME_BALANCE: u8 = 133;
    /// Value's type: `u16`; FitBaseType::UINT16; ProfileType::Uint16; Scale: `10`; Units: `mm`
    pub const AVG_STEP_LENGTH: u8 = 134;
    /// Value's type: `u8`; FitBaseType::UINT8; ProfileType::Uint8; Scale: `10`
    pub const TOTAL_ANAEROBIC_TRAINING_EFFECT: u8 = 137;
    /// Value's type: `u16`; FitBaseType::UINT16; ProfileType::Uint16; Scale: `1000`; Units: `m/s`
    pub const AVG_VAM: u8 = 139;
    /// Value's type: `u32`; FitBaseType::UINT32; ProfileType::Uint32; Scale: `1000`; Units: `m`
    pub const AVG_DEPTH: u8 = 140;
    /// Value's type: `u32`; FitBaseType::UINT32; ProfileType::Uint32; Scale: `1000`; Units: `m`
    pub const MAX_DEPTH: u8 = 141;
    /// Value's type: `u32`; FitBaseType::UINT32; ProfileType::Uint32; Units: `s`
    pub const SURFACE_INTERVAL: u8 = 142;
    /// Value's type: `u8`; FitBaseType::UINT8; ProfileType::Uint8; Units: `percent`
    pub const START_CNS: u8 = 143;
    /// Value's type: `u8`; FitBaseType::UINT8; ProfileType::Uint8; Units: `percent`
    pub const END_CNS: u8 = 144;
    /// Value's type: `u16`; FitBaseType::UINT16; ProfileType::Uint16; Units: `percent`
    pub const START_N2: u8 = 145;
    /// Value's type: `u16`; FitBaseType::UINT16; ProfileType::Uint16; Units: `percent`
    pub const END_N2: u8 = 146;
    /// Value's type: `u8`; FitBaseType::UINT8; ProfileType::Uint8
    pub const AVG_RESPIRATION_RATE: u8 = 147;
    /// Value's type: `u8`; FitBaseType::UINT8; ProfileType::Uint8
    pub const MAX_RESPIRATION_RATE: u8 = 148;
    /// Value's type: `u8`; FitBaseType::UINT8; ProfileType::Uint8
    pub const MIN_RESPIRATION_RATE: u8 = 149;
    /// Value's type: `i8`; FitBaseType::SINT8; ProfileType::Sint8; Units: `C`
    pub const MIN_TEMPERATURE: u8 = 150;
    /// Value's type: `u16`; FitBaseType::UINT16; ProfileType::Uint16; Units: `OTUs`
    pub const O2_TOXICITY: u8 = 155;
    /// Value's type: `u32`; FitBaseType::UINT32; ProfileType::Uint32
    pub const DIVE_NUMBER: u8 = 156;
    /// Value's type: `i32`; FitBaseType::SINT32; ProfileType::Sint32; Scale: `65536`
    pub const TRAINING_LOAD_PEAK: u8 = 168;
    /// Value's type: `u16`; FitBaseType::UINT16; ProfileType::Uint16; Scale: `100`; Units: `Breaths/min`
    pub const ENHANCED_AVG_RESPIRATION_RATE: u8 = 169;
    /// Value's type: `u16`; FitBaseType::UINT16; ProfileType::Uint16; Scale: `100`; Units: `Breaths/min`
    pub const ENHANCED_MAX_RESPIRATION_RATE: u8 = 170;
    /// Value's type: `u16`; FitBaseType::UINT16; ProfileType::Uint16; Scale: `100`
    pub const ENHANCED_MIN_RESPIRATION_RATE: u8 = 180;
    /// Value's type: `f32`; FitBaseType::FLOAT32; ProfileType::Float32; Units: `kGrit`
    pub const TOTAL_GRIT: u8 = 181;
    /// Value's type: `f32`; FitBaseType::FLOAT32; ProfileType::Float32; Units: `Flow`
    pub const TOTAL_FLOW: u8 = 182;
    /// Value's type: `u16`; FitBaseType::UINT16; ProfileType::Uint16
    pub const JUMP_COUNT: u8 = 183;
    /// Value's type: `f32`; FitBaseType::FLOAT32; ProfileType::Float32; Units: `kGrit`
    pub const AVG_GRIT: u8 = 186;
    /// Value's type: `f32`; FitBaseType::FLOAT32; ProfileType::Float32; Units: `Flow`
    pub const AVG_FLOW: u8 = 187;
    /// Value's type: `u8`; FitBaseType::UINT8; ProfileType::Uint8
    pub const WORKOUT_FEEL: u8 = 192;
    /// Value's type: `u8`; FitBaseType::UINT8; ProfileType::Uint8
    pub const WORKOUT_RPE: u8 = 193;
    /// Value's type: `u8`; FitBaseType::UINT8; ProfileType::Uint8; Units: `percent`
    pub const AVG_SPO2: u8 = 194;
    /// Value's type: `u8`; FitBaseType::UINT8; ProfileType::Uint8; Units: `percent`
    pub const AVG_STRESS: u8 = 195;
    /// Value's type: `u16`; FitBaseType::UINT16; ProfileType::Uint16; Units: `kcal`
    pub const METABOLIC_CALORIES: u8 = 196;
    /// Value's type: `u8`; FitBaseType::UINT8; ProfileType::Uint8; Units: `mS`
    pub const SDRR_HRV: u8 = 197;
    /// Value's type: `u8`; FitBaseType::UINT8; ProfileType::Uint8; Units: `mS`
    pub const RMSSD_HRV: u8 = 198;
    /// Value's type: `u8`; FitBaseType::UINT8; ProfileType::Uint8; Scale: `100`; Units: `m`
    pub const TOTAL_FRACTIONAL_ASCENT: u8 = 199;
    /// Value's type: `u8`; FitBaseType::UINT8; ProfileType::Uint8; Scale: `100`; Units: `m`
    pub const TOTAL_FRACTIONAL_DESCENT: u8 = 200;
    /// Value's type: `u16`; FitBaseType::UINT16; ProfileType::Uint16; Scale: `100`; Units: `C`
    pub const AVG_CORE_TEMPERATURE: u8 = 208;
    /// Value's type: `u16`; FitBaseType::UINT16; ProfileType::Uint16; Scale: `100`; Units: `C`
    pub const MIN_CORE_TEMPERATURE: u8 = 209;
    /// Value's type: `u16`; FitBaseType::UINT16; ProfileType::Uint16; Scale: `100`; Units: `C`
    pub const MAX_CORE_TEMPERATURE: u8 = 210;

    /// Create new Session with all fields being set to its corresponding invalid value.
    pub const fn new() -> Self {
        Self {
            message_index: typedef::MessageIndex(u16::MAX),
            timestamp: typedef::DateTime(u32::MAX),
            event: typedef::Event(u8::MAX),
            event_type: typedef::EventType(u8::MAX),
            start_time: typedef::DateTime(u32::MAX),
            start_position_lat: i32::MAX,
            start_position_long: i32::MAX,
            sport: typedef::Sport(u8::MAX),
            sub_sport: typedef::SubSport(u8::MAX),
            total_elapsed_time: u32::MAX,
            total_timer_time: u32::MAX,
            total_distance: u32::MAX,
            total_cycles: u32::MAX,
            total_calories: u16::MAX,
            total_fat_calories: u16::MAX,
            avg_speed: u16::MAX,
            max_speed: u16::MAX,
            avg_heart_rate: u8::MAX,
            max_heart_rate: u8::MAX,
            avg_cadence: u8::MAX,
            max_cadence: u8::MAX,
            avg_power: u16::MAX,
            max_power: u16::MAX,
            total_ascent: u16::MAX,
            total_descent: u16::MAX,
            total_training_effect: u8::MAX,
            first_lap_index: u16::MAX,
            num_laps: u16::MAX,
            event_group: u8::MAX,
            trigger: typedef::SessionTrigger(u8::MAX),
            nec_lat: i32::MAX,
            nec_long: i32::MAX,
            swc_lat: i32::MAX,
            swc_long: i32::MAX,
            num_lengths: u16::MAX,
            normalized_power: u16::MAX,
            training_stress_score: u16::MAX,
            intensity_factor: u16::MAX,
            left_right_balance: typedef::LeftRightBalance100(u16::MAX),
            end_position_lat: i32::MAX,
            end_position_long: i32::MAX,
            avg_stroke_count: u32::MAX,
            avg_stroke_distance: u16::MAX,
            swim_stroke: typedef::SwimStroke(u8::MAX),
            pool_length: u16::MAX,
            threshold_power: u16::MAX,
            pool_length_unit: typedef::DisplayMeasure(u8::MAX),
            num_active_lengths: u16::MAX,
            total_work: u32::MAX,
            avg_altitude: u16::MAX,
            max_altitude: u16::MAX,
            gps_accuracy: u8::MAX,
            avg_grade: i16::MAX,
            avg_pos_grade: i16::MAX,
            avg_neg_grade: i16::MAX,
            max_pos_grade: i16::MAX,
            max_neg_grade: i16::MAX,
            avg_temperature: i8::MAX,
            max_temperature: i8::MAX,
            total_moving_time: u32::MAX,
            avg_pos_vertical_speed: i16::MAX,
            avg_neg_vertical_speed: i16::MAX,
            max_pos_vertical_speed: i16::MAX,
            max_neg_vertical_speed: i16::MAX,
            min_heart_rate: u8::MAX,
            time_in_hr_zone: Vec::new(),
            time_in_speed_zone: Vec::new(),
            time_in_cadence_zone: Vec::new(),
            time_in_power_zone: Vec::new(),
            avg_lap_time: u32::MAX,
            best_lap_index: u16::MAX,
            min_altitude: u16::MAX,
            active_time: u32::MAX,
            player_score: u16::MAX,
            opponent_score: u16::MAX,
            opponent_name: String::new(),
            stroke_count: Vec::new(),
            zone_count: Vec::new(),
            max_ball_speed: u16::MAX,
            avg_ball_speed: u16::MAX,
            avg_vertical_oscillation: u16::MAX,
            avg_stance_time_percent: u16::MAX,
            avg_stance_time: u16::MAX,
            avg_fractional_cadence: u8::MAX,
            max_fractional_cadence: u8::MAX,
            total_fractional_cycles: u8::MAX,
            avg_total_hemoglobin_conc: Vec::new(),
            min_total_hemoglobin_conc: Vec::new(),
            max_total_hemoglobin_conc: Vec::new(),
            avg_saturated_hemoglobin_percent: Vec::new(),
            min_saturated_hemoglobin_percent: Vec::new(),
            max_saturated_hemoglobin_percent: Vec::new(),
            avg_left_torque_effectiveness: u8::MAX,
            avg_right_torque_effectiveness: u8::MAX,
            avg_left_pedal_smoothness: u8::MAX,
            avg_right_pedal_smoothness: u8::MAX,
            avg_combined_pedal_smoothness: u8::MAX,
            sport_profile_name: String::new(),
            sport_index: u8::MAX,
            time_standing: u32::MAX,
            stand_count: u16::MAX,
            avg_left_pco: i8::MAX,
            avg_right_pco: i8::MAX,
            avg_left_power_phase: Vec::new(),
            avg_left_power_phase_peak: Vec::new(),
            avg_right_power_phase: Vec::new(),
            avg_right_power_phase_peak: Vec::new(),
            avg_power_position: Vec::new(),
            max_power_position: Vec::new(),
            avg_cadence_position: Vec::new(),
            max_cadence_position: Vec::new(),
            enhanced_avg_speed: u32::MAX,
            enhanced_max_speed: u32::MAX,
            enhanced_avg_altitude: u32::MAX,
            enhanced_min_altitude: u32::MAX,
            enhanced_max_altitude: u32::MAX,
            avg_lev_motor_power: u16::MAX,
            max_lev_motor_power: u16::MAX,
            lev_battery_consumption: u8::MAX,
            avg_vertical_ratio: u16::MAX,
            avg_stance_time_balance: u16::MAX,
            avg_step_length: u16::MAX,
            total_anaerobic_training_effect: u8::MAX,
            avg_vam: u16::MAX,
            avg_depth: u32::MAX,
            max_depth: u32::MAX,
            surface_interval: u32::MAX,
            start_cns: u8::MAX,
            end_cns: u8::MAX,
            start_n2: u16::MAX,
            end_n2: u16::MAX,
            avg_respiration_rate: u8::MAX,
            max_respiration_rate: u8::MAX,
            min_respiration_rate: u8::MAX,
            min_temperature: i8::MAX,
            o2_toxicity: u16::MAX,
            dive_number: u32::MAX,
            training_load_peak: i32::MAX,
            enhanced_avg_respiration_rate: u16::MAX,
            enhanced_max_respiration_rate: u16::MAX,
            enhanced_min_respiration_rate: u16::MAX,
            total_grit: f32::from_bits(u32::MAX),
            total_flow: f32::from_bits(u32::MAX),
            jump_count: u16::MAX,
            avg_grit: f32::from_bits(u32::MAX),
            avg_flow: f32::from_bits(u32::MAX),
            workout_feel: u8::MAX,
            workout_rpe: u8::MAX,
            avg_spo2: u8::MAX,
            avg_stress: u8::MAX,
            metabolic_calories: u16::MAX,
            sdrr_hrv: u8::MAX,
            rmssd_hrv: u8::MAX,
            total_fractional_ascent: u8::MAX,
            total_fractional_descent: u8::MAX,
            avg_core_temperature: u16::MAX,
            min_core_temperature: u16::MAX,
            max_core_temperature: u16::MAX,
            state: [0u8; 23],
            unknown_fields: Vec::new(),
            developer_fields: Vec::new(),
        }
    }

    /// Returns `start_position_lat` in degrees instead of semicircles. It returns `None` when value is invalid.
    pub fn start_position_lat_degrees(&self) -> Option<f64> {
        semconv::to_degrees(self.start_position_lat)
    }

    /// Set `start_position_lat` with a value in degrees instead of semicircles, the value will be converted to semicircles.
    pub fn set_start_position_lat_degrees(&mut self, v: f64) -> &mut Self {
        self.start_position_lat = semconv::to_semicircles(v).unwrap_or(i32::MAX);
        self
    }

    /// Returns `start_position_long` in degrees instead of semicircles. It returns `None` when value is invalid.
    pub fn start_position_long_degrees(&self) -> Option<f64> {
        semconv::to_degrees(self.start_position_long)
    }

    /// Set `start_position_long` with a value in degrees instead of semicircles, the value will be converted to semicircles.
    pub fn set_start_position_long_degrees(&mut self, v: f64) -> &mut Self {
        self.start_position_long = semconv::to_semicircles(v).unwrap_or(i32::MAX);
        self
    }

    /// Returns `nec_lat` in degrees instead of semicircles. It returns `None` when value is invalid.
    pub fn nec_lat_degrees(&self) -> Option<f64> {
        semconv::to_degrees(self.nec_lat)
    }

    /// Set `nec_lat` with a value in degrees instead of semicircles, the value will be converted to semicircles.
    pub fn set_nec_lat_degrees(&mut self, v: f64) -> &mut Self {
        self.nec_lat = semconv::to_semicircles(v).unwrap_or(i32::MAX);
        self
    }

    /// Returns `nec_long` in degrees instead of semicircles. It returns `None` when value is invalid.
    pub fn nec_long_degrees(&self) -> Option<f64> {
        semconv::to_degrees(self.nec_long)
    }

    /// Set `nec_long` with a value in degrees instead of semicircles, the value will be converted to semicircles.
    pub fn set_nec_long_degrees(&mut self, v: f64) -> &mut Self {
        self.nec_long = semconv::to_semicircles(v).unwrap_or(i32::MAX);
        self
    }

    /// Returns `swc_lat` in degrees instead of semicircles. It returns `None` when value is invalid.
    pub fn swc_lat_degrees(&self) -> Option<f64> {
        semconv::to_degrees(self.swc_lat)
    }

    /// Set `swc_lat` with a value in degrees instead of semicircles, the value will be converted to semicircles.
    pub fn set_swc_lat_degrees(&mut self, v: f64) -> &mut Self {
        self.swc_lat = semconv::to_semicircles(v).unwrap_or(i32::MAX);
        self
    }

    /// Returns `swc_long` in degrees instead of semicircles. It returns `None` when value is invalid.
    pub fn swc_long_degrees(&self) -> Option<f64> {
        semconv::to_degrees(self.swc_long)
    }

    /// Set `swc_long` with a value in degrees instead of semicircles, the value will be converted to semicircles.
    pub fn set_swc_long_degrees(&mut self, v: f64) -> &mut Self {
        self.swc_long = semconv::to_semicircles(v).unwrap_or(i32::MAX);
        self
    }

    /// Returns `end_position_lat` in degrees instead of semicircles. It returns `None` when value is invalid.
    pub fn end_position_lat_degrees(&self) -> Option<f64> {
        semconv::to_degrees(self.end_position_lat)
    }

    /// Set `end_position_lat` with a value in degrees instead of semicircles, the value will be converted to semicircles.
    pub fn set_end_position_lat_degrees(&mut self, v: f64) -> &mut Self {
        self.end_position_lat = semconv::to_semicircles(v).unwrap_or(i32::MAX);
        self
    }

    /// Returns `end_position_long` in degrees instead of semicircles. It returns `None` when value is invalid.
    pub fn end_position_long_degrees(&self) -> Option<f64> {
        semconv::to_degrees(self.end_position_long)
    }

    /// Set `end_position_long` with a value in degrees instead of semicircles, the value will be converted to semicircles.
    pub fn set_end_position_long_degrees(&mut self, v: f64) -> &mut Self {
        self.end_position_long = semconv::to_semicircles(v).unwrap_or(i32::MAX);
        self
    }

    /// Returns `total_elapsed_time` in its scaled value. It returns `None` when value is invalid.
    ///
    /// Units: s
    pub fn total_elapsed_time_scaled(&self) -> Option<f64> {
        if self.total_elapsed_time == u32::MAX {
            return None;
        }
        Some(self.total_elapsed_time as f64 / 1000.0 - 0.0)
    }

    /// Set `total_elapsed_time` with scaled value, it will automatically be converted to its corresponding integer value.
    pub fn set_total_elapsed_time_scaled(&mut self, v: f64) -> &mut Self {
        let unscaled = (v + 0.0) * 1000.0;
        if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u32::MAX as f64 {
            self.total_elapsed_time = u32::MAX;
            return self;
        }
        self.total_elapsed_time = unscaled as u32;
        self
    }

    /// Returns `total_timer_time` in its scaled value. It returns `None` when value is invalid.
    ///
    /// Units: s
    pub fn total_timer_time_scaled(&self) -> Option<f64> {
        if self.total_timer_time == u32::MAX {
            return None;
        }
        Some(self.total_timer_time as f64 / 1000.0 - 0.0)
    }

    /// Set `total_timer_time` with scaled value, it will automatically be converted to its corresponding integer value.
    pub fn set_total_timer_time_scaled(&mut self, v: f64) -> &mut Self {
        let unscaled = (v + 0.0) * 1000.0;
        if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u32::MAX as f64 {
            self.total_timer_time = u32::MAX;
            return self;
        }
        self.total_timer_time = unscaled as u32;
        self
    }

    /// Returns `total_distance` in its scaled value. It returns `None` when value is invalid.
    ///
    /// Units: m
    pub fn total_distance_scaled(&self) -> Option<f64> {
        if self.total_distance == u32::MAX {
            return None;
        }
        Some(self.total_distance as f64 / 100.0 - 0.0)
    }

    /// Set `total_distance` with scaled value, it will automatically be converted to its corresponding integer value.
    pub fn set_total_distance_scaled(&mut self, v: f64) -> &mut Self {
        let unscaled = (v + 0.0) * 100.0;
        if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u32::MAX as f64 {
            self.total_distance = u32::MAX;
            return self;
        }
        self.total_distance = unscaled as u32;
        self
    }

    /// Returns `avg_speed` in its scaled value. It returns `None` when value is invalid.
    ///
    /// Units: m/s
    pub fn avg_speed_scaled(&self) -> Option<f64> {
        if self.avg_speed == u16::MAX {
            return None;
        }
        Some(self.avg_speed as f64 / 1000.0 - 0.0)
    }

    /// Set `avg_speed` with scaled value, it will automatically be converted to its corresponding integer value.
    pub fn set_avg_speed_scaled(&mut self, v: f64) -> &mut Self {
        let unscaled = (v + 0.0) * 1000.0;
        if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u16::MAX as f64 {
            self.avg_speed = u16::MAX;
            return self;
        }
        self.avg_speed = unscaled as u16;
        self
    }

    /// Returns `max_speed` in its scaled value. It returns `None` when value is invalid.
    ///
    /// Units: m/s
    pub fn max_speed_scaled(&self) -> Option<f64> {
        if self.max_speed == u16::MAX {
            return None;
        }
        Some(self.max_speed as f64 / 1000.0 - 0.0)
    }

    /// Set `max_speed` with scaled value, it will automatically be converted to its corresponding integer value.
    pub fn set_max_speed_scaled(&mut self, v: f64) -> &mut Self {
        let unscaled = (v + 0.0) * 1000.0;
        if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u16::MAX as f64 {
            self.max_speed = u16::MAX;
            return self;
        }
        self.max_speed = unscaled as u16;
        self
    }

    /// Returns `total_training_effect` in its scaled value. It returns `None` when value is invalid.
    pub fn total_training_effect_scaled(&self) -> Option<f64> {
        if self.total_training_effect == u8::MAX {
            return None;
        }
        Some(self.total_training_effect as f64 / 10.0 - 0.0)
    }

    /// Set `total_training_effect` with scaled value, it will automatically be converted to its corresponding integer value.
    pub fn set_total_training_effect_scaled(&mut self, v: f64) -> &mut Self {
        let unscaled = (v + 0.0) * 10.0;
        if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u8::MAX as f64 {
            self.total_training_effect = u8::MAX;
            return self;
        }
        self.total_training_effect = unscaled as u8;
        self
    }

    /// Returns `training_stress_score` in its scaled value. It returns `None` when value is invalid.
    ///
    /// Units: tss
    pub fn training_stress_score_scaled(&self) -> Option<f64> {
        if self.training_stress_score == u16::MAX {
            return None;
        }
        Some(self.training_stress_score as f64 / 10.0 - 0.0)
    }

    /// Set `training_stress_score` with scaled value, it will automatically be converted to its corresponding integer value.
    pub fn set_training_stress_score_scaled(&mut self, v: f64) -> &mut Self {
        let unscaled = (v + 0.0) * 10.0;
        if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u16::MAX as f64 {
            self.training_stress_score = u16::MAX;
            return self;
        }
        self.training_stress_score = unscaled as u16;
        self
    }

    /// Returns `intensity_factor` in its scaled value. It returns `None` when value is invalid.
    ///
    /// Units: if
    pub fn intensity_factor_scaled(&self) -> Option<f64> {
        if self.intensity_factor == u16::MAX {
            return None;
        }
        Some(self.intensity_factor as f64 / 1000.0 - 0.0)
    }

    /// Set `intensity_factor` with scaled value, it will automatically be converted to its corresponding integer value.
    pub fn set_intensity_factor_scaled(&mut self, v: f64) -> &mut Self {
        let unscaled = (v + 0.0) * 1000.0;
        if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u16::MAX as f64 {
            self.intensity_factor = u16::MAX;
            return self;
        }
        self.intensity_factor = unscaled as u16;
        self
    }

    /// Returns `avg_stroke_count` in its scaled value. It returns `None` when value is invalid.
    ///
    /// Units: strokes/lap
    pub fn avg_stroke_count_scaled(&self) -> Option<f64> {
        if self.avg_stroke_count == u32::MAX {
            return None;
        }
        Some(self.avg_stroke_count as f64 / 10.0 - 0.0)
    }

    /// Set `avg_stroke_count` with scaled value, it will automatically be converted to its corresponding integer value.
    pub fn set_avg_stroke_count_scaled(&mut self, v: f64) -> &mut Self {
        let unscaled = (v + 0.0) * 10.0;
        if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u32::MAX as f64 {
            self.avg_stroke_count = u32::MAX;
            return self;
        }
        self.avg_stroke_count = unscaled as u32;
        self
    }

    /// Returns `avg_stroke_distance` in its scaled value. It returns `None` when value is invalid.
    ///
    /// Units: m
    pub fn avg_stroke_distance_scaled(&self) -> Option<f64> {
        if self.avg_stroke_distance == u16::MAX {
            return None;
        }
        Some(self.avg_stroke_distance as f64 / 100.0 - 0.0)
    }

    /// Set `avg_stroke_distance` with scaled value, it will automatically be converted to its corresponding integer value.
    pub fn set_avg_stroke_distance_scaled(&mut self, v: f64) -> &mut Self {
        let unscaled = (v + 0.0) * 100.0;
        if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u16::MAX as f64 {
            self.avg_stroke_distance = u16::MAX;
            return self;
        }
        self.avg_stroke_distance = unscaled as u16;
        self
    }

    /// Returns `pool_length` in its scaled value. It returns `None` when value is invalid.
    ///
    /// Units: m
    pub fn pool_length_scaled(&self) -> Option<f64> {
        if self.pool_length == u16::MAX {
            return None;
        }
        Some(self.pool_length as f64 / 100.0 - 0.0)
    }

    /// Set `pool_length` with scaled value, it will automatically be converted to its corresponding integer value.
    pub fn set_pool_length_scaled(&mut self, v: f64) -> &mut Self {
        let unscaled = (v + 0.0) * 100.0;
        if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u16::MAX as f64 {
            self.pool_length = u16::MAX;
            return self;
        }
        self.pool_length = unscaled as u16;
        self
    }

    /// Returns `avg_altitude` in its scaled value. It returns `None` when value is invalid.
    ///
    /// Units: m
    pub fn avg_altitude_scaled(&self) -> Option<f64> {
        if self.avg_altitude == u16::MAX {
            return None;
        }
        Some(self.avg_altitude as f64 / 5.0 - 500.0)
    }

    /// Set `avg_altitude` with scaled value, it will automatically be converted to its corresponding integer value.
    pub fn set_avg_altitude_scaled(&mut self, v: f64) -> &mut Self {
        let unscaled = (v + 500.0) * 5.0;
        if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u16::MAX as f64 {
            self.avg_altitude = u16::MAX;
            return self;
        }
        self.avg_altitude = unscaled as u16;
        self
    }

    /// Returns `max_altitude` in its scaled value. It returns `None` when value is invalid.
    ///
    /// Units: m
    pub fn max_altitude_scaled(&self) -> Option<f64> {
        if self.max_altitude == u16::MAX {
            return None;
        }
        Some(self.max_altitude as f64 / 5.0 - 500.0)
    }

    /// Set `max_altitude` with scaled value, it will automatically be converted to its corresponding integer value.
    pub fn set_max_altitude_scaled(&mut self, v: f64) -> &mut Self {
        let unscaled = (v + 500.0) * 5.0;
        if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u16::MAX as f64 {
            self.max_altitude = u16::MAX;
            return self;
        }
        self.max_altitude = unscaled as u16;
        self
    }

    /// Returns `avg_grade` in its scaled value. It returns `None` when value is invalid.
    ///
    /// Units: %
    pub fn avg_grade_scaled(&self) -> Option<f64> {
        if self.avg_grade == i16::MAX {
            return None;
        }
        Some(self.avg_grade as f64 / 100.0 - 0.0)
    }

    /// Set `avg_grade` with scaled value, it will automatically be converted to its corresponding integer value.
    pub fn set_avg_grade_scaled(&mut self, v: f64) -> &mut Self {
        let unscaled = (v + 0.0) * 100.0;
        if unscaled.is_nan() || unscaled.is_infinite() || unscaled > i16::MAX as f64 {
            self.avg_grade = i16::MAX;
            return self;
        }
        self.avg_grade = unscaled as i16;
        self
    }

    /// Returns `avg_pos_grade` in its scaled value. It returns `None` when value is invalid.
    ///
    /// Units: %
    pub fn avg_pos_grade_scaled(&self) -> Option<f64> {
        if self.avg_pos_grade == i16::MAX {
            return None;
        }
        Some(self.avg_pos_grade as f64 / 100.0 - 0.0)
    }

    /// Set `avg_pos_grade` with scaled value, it will automatically be converted to its corresponding integer value.
    pub fn set_avg_pos_grade_scaled(&mut self, v: f64) -> &mut Self {
        let unscaled = (v + 0.0) * 100.0;
        if unscaled.is_nan() || unscaled.is_infinite() || unscaled > i16::MAX as f64 {
            self.avg_pos_grade = i16::MAX;
            return self;
        }
        self.avg_pos_grade = unscaled as i16;
        self
    }

    /// Returns `avg_neg_grade` in its scaled value. It returns `None` when value is invalid.
    ///
    /// Units: %
    pub fn avg_neg_grade_scaled(&self) -> Option<f64> {
        if self.avg_neg_grade == i16::MAX {
            return None;
        }
        Some(self.avg_neg_grade as f64 / 100.0 - 0.0)
    }

    /// Set `avg_neg_grade` with scaled value, it will automatically be converted to its corresponding integer value.
    pub fn set_avg_neg_grade_scaled(&mut self, v: f64) -> &mut Self {
        let unscaled = (v + 0.0) * 100.0;
        if unscaled.is_nan() || unscaled.is_infinite() || unscaled > i16::MAX as f64 {
            self.avg_neg_grade = i16::MAX;
            return self;
        }
        self.avg_neg_grade = unscaled as i16;
        self
    }

    /// Returns `max_pos_grade` in its scaled value. It returns `None` when value is invalid.
    ///
    /// Units: %
    pub fn max_pos_grade_scaled(&self) -> Option<f64> {
        if self.max_pos_grade == i16::MAX {
            return None;
        }
        Some(self.max_pos_grade as f64 / 100.0 - 0.0)
    }

    /// Set `max_pos_grade` with scaled value, it will automatically be converted to its corresponding integer value.
    pub fn set_max_pos_grade_scaled(&mut self, v: f64) -> &mut Self {
        let unscaled = (v + 0.0) * 100.0;
        if unscaled.is_nan() || unscaled.is_infinite() || unscaled > i16::MAX as f64 {
            self.max_pos_grade = i16::MAX;
            return self;
        }
        self.max_pos_grade = unscaled as i16;
        self
    }

    /// Returns `max_neg_grade` in its scaled value. It returns `None` when value is invalid.
    ///
    /// Units: %
    pub fn max_neg_grade_scaled(&self) -> Option<f64> {
        if self.max_neg_grade == i16::MAX {
            return None;
        }
        Some(self.max_neg_grade as f64 / 100.0 - 0.0)
    }

    /// Set `max_neg_grade` with scaled value, it will automatically be converted to its corresponding integer value.
    pub fn set_max_neg_grade_scaled(&mut self, v: f64) -> &mut Self {
        let unscaled = (v + 0.0) * 100.0;
        if unscaled.is_nan() || unscaled.is_infinite() || unscaled > i16::MAX as f64 {
            self.max_neg_grade = i16::MAX;
            return self;
        }
        self.max_neg_grade = unscaled as i16;
        self
    }

    /// Returns `total_moving_time` in its scaled value. It returns `None` when value is invalid.
    ///
    /// Units: s
    pub fn total_moving_time_scaled(&self) -> Option<f64> {
        if self.total_moving_time == u32::MAX {
            return None;
        }
        Some(self.total_moving_time as f64 / 1000.0 - 0.0)
    }

    /// Set `total_moving_time` with scaled value, it will automatically be converted to its corresponding integer value.
    pub fn set_total_moving_time_scaled(&mut self, v: f64) -> &mut Self {
        let unscaled = (v + 0.0) * 1000.0;
        if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u32::MAX as f64 {
            self.total_moving_time = u32::MAX;
            return self;
        }
        self.total_moving_time = unscaled as u32;
        self
    }

    /// Returns `avg_pos_vertical_speed` in its scaled value. It returns `None` when value is invalid.
    ///
    /// Units: m/s
    pub fn avg_pos_vertical_speed_scaled(&self) -> Option<f64> {
        if self.avg_pos_vertical_speed == i16::MAX {
            return None;
        }
        Some(self.avg_pos_vertical_speed as f64 / 1000.0 - 0.0)
    }

    /// Set `avg_pos_vertical_speed` with scaled value, it will automatically be converted to its corresponding integer value.
    pub fn set_avg_pos_vertical_speed_scaled(&mut self, v: f64) -> &mut Self {
        let unscaled = (v + 0.0) * 1000.0;
        if unscaled.is_nan() || unscaled.is_infinite() || unscaled > i16::MAX as f64 {
            self.avg_pos_vertical_speed = i16::MAX;
            return self;
        }
        self.avg_pos_vertical_speed = unscaled as i16;
        self
    }

    /// Returns `avg_neg_vertical_speed` in its scaled value. It returns `None` when value is invalid.
    ///
    /// Units: m/s
    pub fn avg_neg_vertical_speed_scaled(&self) -> Option<f64> {
        if self.avg_neg_vertical_speed == i16::MAX {
            return None;
        }
        Some(self.avg_neg_vertical_speed as f64 / 1000.0 - 0.0)
    }

    /// Set `avg_neg_vertical_speed` with scaled value, it will automatically be converted to its corresponding integer value.
    pub fn set_avg_neg_vertical_speed_scaled(&mut self, v: f64) -> &mut Self {
        let unscaled = (v + 0.0) * 1000.0;
        if unscaled.is_nan() || unscaled.is_infinite() || unscaled > i16::MAX as f64 {
            self.avg_neg_vertical_speed = i16::MAX;
            return self;
        }
        self.avg_neg_vertical_speed = unscaled as i16;
        self
    }

    /// Returns `max_pos_vertical_speed` in its scaled value. It returns `None` when value is invalid.
    ///
    /// Units: m/s
    pub fn max_pos_vertical_speed_scaled(&self) -> Option<f64> {
        if self.max_pos_vertical_speed == i16::MAX {
            return None;
        }
        Some(self.max_pos_vertical_speed as f64 / 1000.0 - 0.0)
    }

    /// Set `max_pos_vertical_speed` with scaled value, it will automatically be converted to its corresponding integer value.
    pub fn set_max_pos_vertical_speed_scaled(&mut self, v: f64) -> &mut Self {
        let unscaled = (v + 0.0) * 1000.0;
        if unscaled.is_nan() || unscaled.is_infinite() || unscaled > i16::MAX as f64 {
            self.max_pos_vertical_speed = i16::MAX;
            return self;
        }
        self.max_pos_vertical_speed = unscaled as i16;
        self
    }

    /// Returns `max_neg_vertical_speed` in its scaled value. It returns `None` when value is invalid.
    ///
    /// Units: m/s
    pub fn max_neg_vertical_speed_scaled(&self) -> Option<f64> {
        if self.max_neg_vertical_speed == i16::MAX {
            return None;
        }
        Some(self.max_neg_vertical_speed as f64 / 1000.0 - 0.0)
    }

    /// Set `max_neg_vertical_speed` with scaled value, it will automatically be converted to its corresponding integer value.
    pub fn set_max_neg_vertical_speed_scaled(&mut self, v: f64) -> &mut Self {
        let unscaled = (v + 0.0) * 1000.0;
        if unscaled.is_nan() || unscaled.is_infinite() || unscaled > i16::MAX as f64 {
            self.max_neg_vertical_speed = i16::MAX;
            return self;
        }
        self.max_neg_vertical_speed = unscaled as i16;
        self
    }

    /// Returns `time_in_hr_zone` in its scaled value. It returns `None` when value is invalid.
    ///
    /// Units: s
    pub fn time_in_hr_zone_scaled(&self) -> Option<Vec<f64>> {
        if self.time_in_hr_zone.is_empty() {
            return None;
        }
        let mut v = Vec::with_capacity(self.time_in_hr_zone.len());
        for &x in &self.time_in_hr_zone {
            v.push(x as f64 / 1000.0 - 0.0)
        }
        Some(v)
    }

    /// Set `time_in_hr_zone` with scaled value, it will automatically be converted to its corresponding integer value.
    pub fn set_time_in_hr_zone_scaled(&mut self, v: &[f64]) -> &mut Self {
        self.time_in_hr_zone = Vec::with_capacity(v.len());
        if v.is_empty() {
            return self;
        }
        for &x in v {
            let unscaled = (x + 0.0) * 1000.0;
            if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u32::MAX as f64 {
                self.time_in_hr_zone.push(u32::MAX);
                continue;
            }
            self.time_in_hr_zone.push(unscaled as u32);
        }
        self
    }

    /// Returns `time_in_speed_zone` in its scaled value. It returns `None` when value is invalid.
    ///
    /// Units: s
    pub fn time_in_speed_zone_scaled(&self) -> Option<Vec<f64>> {
        if self.time_in_speed_zone.is_empty() {
            return None;
        }
        let mut v = Vec::with_capacity(self.time_in_speed_zone.len());
        for &x in &self.time_in_speed_zone {
            v.push(x as f64 / 1000.0 - 0.0)
        }
        Some(v)
    }

    /// Set `time_in_speed_zone` with scaled value, it will automatically be converted to its corresponding integer value.
    pub fn set_time_in_speed_zone_scaled(&mut self, v: &[f64]) -> &mut Self {
        self.time_in_speed_zone = Vec::with_capacity(v.len());
        if v.is_empty() {
            return self;
        }
        for &x in v {
            let unscaled = (x + 0.0) * 1000.0;
            if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u32::MAX as f64 {
                self.time_in_speed_zone.push(u32::MAX);
                continue;
            }
            self.time_in_speed_zone.push(unscaled as u32);
        }
        self
    }

    /// Returns `time_in_cadence_zone` in its scaled value. It returns `None` when value is invalid.
    ///
    /// Units: s
    pub fn time_in_cadence_zone_scaled(&self) -> Option<Vec<f64>> {
        if self.time_in_cadence_zone.is_empty() {
            return None;
        }
        let mut v = Vec::with_capacity(self.time_in_cadence_zone.len());
        for &x in &self.time_in_cadence_zone {
            v.push(x as f64 / 1000.0 - 0.0)
        }
        Some(v)
    }

    /// Set `time_in_cadence_zone` with scaled value, it will automatically be converted to its corresponding integer value.
    pub fn set_time_in_cadence_zone_scaled(&mut self, v: &[f64]) -> &mut Self {
        self.time_in_cadence_zone = Vec::with_capacity(v.len());
        if v.is_empty() {
            return self;
        }
        for &x in v {
            let unscaled = (x + 0.0) * 1000.0;
            if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u32::MAX as f64 {
                self.time_in_cadence_zone.push(u32::MAX);
                continue;
            }
            self.time_in_cadence_zone.push(unscaled as u32);
        }
        self
    }

    /// Returns `time_in_power_zone` in its scaled value. It returns `None` when value is invalid.
    ///
    /// Units: s
    pub fn time_in_power_zone_scaled(&self) -> Option<Vec<f64>> {
        if self.time_in_power_zone.is_empty() {
            return None;
        }
        let mut v = Vec::with_capacity(self.time_in_power_zone.len());
        for &x in &self.time_in_power_zone {
            v.push(x as f64 / 1000.0 - 0.0)
        }
        Some(v)
    }

    /// Set `time_in_power_zone` with scaled value, it will automatically be converted to its corresponding integer value.
    pub fn set_time_in_power_zone_scaled(&mut self, v: &[f64]) -> &mut Self {
        self.time_in_power_zone = Vec::with_capacity(v.len());
        if v.is_empty() {
            return self;
        }
        for &x in v {
            let unscaled = (x + 0.0) * 1000.0;
            if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u32::MAX as f64 {
                self.time_in_power_zone.push(u32::MAX);
                continue;
            }
            self.time_in_power_zone.push(unscaled as u32);
        }
        self
    }

    /// Returns `avg_lap_time` in its scaled value. It returns `None` when value is invalid.
    ///
    /// Units: s
    pub fn avg_lap_time_scaled(&self) -> Option<f64> {
        if self.avg_lap_time == u32::MAX {
            return None;
        }
        Some(self.avg_lap_time as f64 / 1000.0 - 0.0)
    }

    /// Set `avg_lap_time` with scaled value, it will automatically be converted to its corresponding integer value.
    pub fn set_avg_lap_time_scaled(&mut self, v: f64) -> &mut Self {
        let unscaled = (v + 0.0) * 1000.0;
        if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u32::MAX as f64 {
            self.avg_lap_time = u32::MAX;
            return self;
        }
        self.avg_lap_time = unscaled as u32;
        self
    }

    /// Returns `min_altitude` in its scaled value. It returns `None` when value is invalid.
    ///
    /// Units: m
    pub fn min_altitude_scaled(&self) -> Option<f64> {
        if self.min_altitude == u16::MAX {
            return None;
        }
        Some(self.min_altitude as f64 / 5.0 - 500.0)
    }

    /// Set `min_altitude` with scaled value, it will automatically be converted to its corresponding integer value.
    pub fn set_min_altitude_scaled(&mut self, v: f64) -> &mut Self {
        let unscaled = (v + 500.0) * 5.0;
        if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u16::MAX as f64 {
            self.min_altitude = u16::MAX;
            return self;
        }
        self.min_altitude = unscaled as u16;
        self
    }

    /// Returns `active_time` in its scaled value. It returns `None` when value is invalid.
    ///
    /// Units: s
    pub fn active_time_scaled(&self) -> Option<f64> {
        if self.active_time == u32::MAX {
            return None;
        }
        Some(self.active_time as f64 / 1000.0 - 0.0)
    }

    /// Set `active_time` with scaled value, it will automatically be converted to its corresponding integer value.
    pub fn set_active_time_scaled(&mut self, v: f64) -> &mut Self {
        let unscaled = (v + 0.0) * 1000.0;
        if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u32::MAX as f64 {
            self.active_time = u32::MAX;
            return self;
        }
        self.active_time = unscaled as u32;
        self
    }

    /// Returns `max_ball_speed` in its scaled value. It returns `None` when value is invalid.
    ///
    /// Units: m/s
    pub fn max_ball_speed_scaled(&self) -> Option<f64> {
        if self.max_ball_speed == u16::MAX {
            return None;
        }
        Some(self.max_ball_speed as f64 / 100.0 - 0.0)
    }

    /// Set `max_ball_speed` with scaled value, it will automatically be converted to its corresponding integer value.
    pub fn set_max_ball_speed_scaled(&mut self, v: f64) -> &mut Self {
        let unscaled = (v + 0.0) * 100.0;
        if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u16::MAX as f64 {
            self.max_ball_speed = u16::MAX;
            return self;
        }
        self.max_ball_speed = unscaled as u16;
        self
    }

    /// Returns `avg_ball_speed` in its scaled value. It returns `None` when value is invalid.
    ///
    /// Units: m/s
    pub fn avg_ball_speed_scaled(&self) -> Option<f64> {
        if self.avg_ball_speed == u16::MAX {
            return None;
        }
        Some(self.avg_ball_speed as f64 / 100.0 - 0.0)
    }

    /// Set `avg_ball_speed` with scaled value, it will automatically be converted to its corresponding integer value.
    pub fn set_avg_ball_speed_scaled(&mut self, v: f64) -> &mut Self {
        let unscaled = (v + 0.0) * 100.0;
        if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u16::MAX as f64 {
            self.avg_ball_speed = u16::MAX;
            return self;
        }
        self.avg_ball_speed = unscaled as u16;
        self
    }

    /// Returns `avg_vertical_oscillation` in its scaled value. It returns `None` when value is invalid.
    ///
    /// Units: mm
    pub fn avg_vertical_oscillation_scaled(&self) -> Option<f64> {
        if self.avg_vertical_oscillation == u16::MAX {
            return None;
        }
        Some(self.avg_vertical_oscillation as f64 / 10.0 - 0.0)
    }

    /// Set `avg_vertical_oscillation` with scaled value, it will automatically be converted to its corresponding integer value.
    pub fn set_avg_vertical_oscillation_scaled(&mut self, v: f64) -> &mut Self {
        let unscaled = (v + 0.0) * 10.0;
        if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u16::MAX as f64 {
            self.avg_vertical_oscillation = u16::MAX;
            return self;
        }
        self.avg_vertical_oscillation = unscaled as u16;
        self
    }

    /// Returns `avg_stance_time_percent` in its scaled value. It returns `None` when value is invalid.
    ///
    /// Units: percent
    pub fn avg_stance_time_percent_scaled(&self) -> Option<f64> {
        if self.avg_stance_time_percent == u16::MAX {
            return None;
        }
        Some(self.avg_stance_time_percent as f64 / 100.0 - 0.0)
    }

    /// Set `avg_stance_time_percent` with scaled value, it will automatically be converted to its corresponding integer value.
    pub fn set_avg_stance_time_percent_scaled(&mut self, v: f64) -> &mut Self {
        let unscaled = (v + 0.0) * 100.0;
        if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u16::MAX as f64 {
            self.avg_stance_time_percent = u16::MAX;
            return self;
        }
        self.avg_stance_time_percent = unscaled as u16;
        self
    }

    /// Returns `avg_stance_time` in its scaled value. It returns `None` when value is invalid.
    ///
    /// Units: ms
    pub fn avg_stance_time_scaled(&self) -> Option<f64> {
        if self.avg_stance_time == u16::MAX {
            return None;
        }
        Some(self.avg_stance_time as f64 / 10.0 - 0.0)
    }

    /// Set `avg_stance_time` with scaled value, it will automatically be converted to its corresponding integer value.
    pub fn set_avg_stance_time_scaled(&mut self, v: f64) -> &mut Self {
        let unscaled = (v + 0.0) * 10.0;
        if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u16::MAX as f64 {
            self.avg_stance_time = u16::MAX;
            return self;
        }
        self.avg_stance_time = unscaled as u16;
        self
    }

    /// Returns `avg_fractional_cadence` in its scaled value. It returns `None` when value is invalid.
    ///
    /// Units: rpm
    pub fn avg_fractional_cadence_scaled(&self) -> Option<f64> {
        if self.avg_fractional_cadence == u8::MAX {
            return None;
        }
        Some(self.avg_fractional_cadence as f64 / 128.0 - 0.0)
    }

    /// Set `avg_fractional_cadence` with scaled value, it will automatically be converted to its corresponding integer value.
    pub fn set_avg_fractional_cadence_scaled(&mut self, v: f64) -> &mut Self {
        let unscaled = (v + 0.0) * 128.0;
        if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u8::MAX as f64 {
            self.avg_fractional_cadence = u8::MAX;
            return self;
        }
        self.avg_fractional_cadence = unscaled as u8;
        self
    }

    /// Returns `max_fractional_cadence` in its scaled value. It returns `None` when value is invalid.
    ///
    /// Units: rpm
    pub fn max_fractional_cadence_scaled(&self) -> Option<f64> {
        if self.max_fractional_cadence == u8::MAX {
            return None;
        }
        Some(self.max_fractional_cadence as f64 / 128.0 - 0.0)
    }

    /// Set `max_fractional_cadence` with scaled value, it will automatically be converted to its corresponding integer value.
    pub fn set_max_fractional_cadence_scaled(&mut self, v: f64) -> &mut Self {
        let unscaled = (v + 0.0) * 128.0;
        if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u8::MAX as f64 {
            self.max_fractional_cadence = u8::MAX;
            return self;
        }
        self.max_fractional_cadence = unscaled as u8;
        self
    }

    /// Returns `total_fractional_cycles` in its scaled value. It returns `None` when value is invalid.
    ///
    /// Units: cycles
    pub fn total_fractional_cycles_scaled(&self) -> Option<f64> {
        if self.total_fractional_cycles == u8::MAX {
            return None;
        }
        Some(self.total_fractional_cycles as f64 / 128.0 - 0.0)
    }

    /// Set `total_fractional_cycles` with scaled value, it will automatically be converted to its corresponding integer value.
    pub fn set_total_fractional_cycles_scaled(&mut self, v: f64) -> &mut Self {
        let unscaled = (v + 0.0) * 128.0;
        if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u8::MAX as f64 {
            self.total_fractional_cycles = u8::MAX;
            return self;
        }
        self.total_fractional_cycles = unscaled as u8;
        self
    }

    /// Returns `avg_total_hemoglobin_conc` in its scaled value. It returns `None` when value is invalid.
    ///
    /// Units: g/dL
    pub fn avg_total_hemoglobin_conc_scaled(&self) -> Option<Vec<f64>> {
        if self.avg_total_hemoglobin_conc.is_empty() {
            return None;
        }
        let mut v = Vec::with_capacity(self.avg_total_hemoglobin_conc.len());
        for &x in &self.avg_total_hemoglobin_conc {
            v.push(x as f64 / 100.0 - 0.0)
        }
        Some(v)
    }

    /// Set `avg_total_hemoglobin_conc` with scaled value, it will automatically be converted to its corresponding integer value.
    pub fn set_avg_total_hemoglobin_conc_scaled(&mut self, v: &[f64]) -> &mut Self {
        self.avg_total_hemoglobin_conc = Vec::with_capacity(v.len());
        if v.is_empty() {
            return self;
        }
        for &x in v {
            let unscaled = (x + 0.0) * 100.0;
            if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u16::MAX as f64 {
                self.avg_total_hemoglobin_conc.push(u16::MAX);
                continue;
            }
            self.avg_total_hemoglobin_conc.push(unscaled as u16);
        }
        self
    }

    /// Returns `min_total_hemoglobin_conc` in its scaled value. It returns `None` when value is invalid.
    ///
    /// Units: g/dL
    pub fn min_total_hemoglobin_conc_scaled(&self) -> Option<Vec<f64>> {
        if self.min_total_hemoglobin_conc.is_empty() {
            return None;
        }
        let mut v = Vec::with_capacity(self.min_total_hemoglobin_conc.len());
        for &x in &self.min_total_hemoglobin_conc {
            v.push(x as f64 / 100.0 - 0.0)
        }
        Some(v)
    }

    /// Set `min_total_hemoglobin_conc` with scaled value, it will automatically be converted to its corresponding integer value.
    pub fn set_min_total_hemoglobin_conc_scaled(&mut self, v: &[f64]) -> &mut Self {
        self.min_total_hemoglobin_conc = Vec::with_capacity(v.len());
        if v.is_empty() {
            return self;
        }
        for &x in v {
            let unscaled = (x + 0.0) * 100.0;
            if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u16::MAX as f64 {
                self.min_total_hemoglobin_conc.push(u16::MAX);
                continue;
            }
            self.min_total_hemoglobin_conc.push(unscaled as u16);
        }
        self
    }

    /// Returns `max_total_hemoglobin_conc` in its scaled value. It returns `None` when value is invalid.
    ///
    /// Units: g/dL
    pub fn max_total_hemoglobin_conc_scaled(&self) -> Option<Vec<f64>> {
        if self.max_total_hemoglobin_conc.is_empty() {
            return None;
        }
        let mut v = Vec::with_capacity(self.max_total_hemoglobin_conc.len());
        for &x in &self.max_total_hemoglobin_conc {
            v.push(x as f64 / 100.0 - 0.0)
        }
        Some(v)
    }

    /// Set `max_total_hemoglobin_conc` with scaled value, it will automatically be converted to its corresponding integer value.
    pub fn set_max_total_hemoglobin_conc_scaled(&mut self, v: &[f64]) -> &mut Self {
        self.max_total_hemoglobin_conc = Vec::with_capacity(v.len());
        if v.is_empty() {
            return self;
        }
        for &x in v {
            let unscaled = (x + 0.0) * 100.0;
            if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u16::MAX as f64 {
                self.max_total_hemoglobin_conc.push(u16::MAX);
                continue;
            }
            self.max_total_hemoglobin_conc.push(unscaled as u16);
        }
        self
    }

    /// Returns `avg_saturated_hemoglobin_percent` in its scaled value. It returns `None` when value is invalid.
    ///
    /// Units: %
    pub fn avg_saturated_hemoglobin_percent_scaled(&self) -> Option<Vec<f64>> {
        if self.avg_saturated_hemoglobin_percent.is_empty() {
            return None;
        }
        let mut v = Vec::with_capacity(self.avg_saturated_hemoglobin_percent.len());
        for &x in &self.avg_saturated_hemoglobin_percent {
            v.push(x as f64 / 10.0 - 0.0)
        }
        Some(v)
    }

    /// Set `avg_saturated_hemoglobin_percent` with scaled value, it will automatically be converted to its corresponding integer value.
    pub fn set_avg_saturated_hemoglobin_percent_scaled(&mut self, v: &[f64]) -> &mut Self {
        self.avg_saturated_hemoglobin_percent = Vec::with_capacity(v.len());
        if v.is_empty() {
            return self;
        }
        for &x in v {
            let unscaled = (x + 0.0) * 10.0;
            if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u16::MAX as f64 {
                self.avg_saturated_hemoglobin_percent.push(u16::MAX);
                continue;
            }
            self.avg_saturated_hemoglobin_percent.push(unscaled as u16);
        }
        self
    }

    /// Returns `min_saturated_hemoglobin_percent` in its scaled value. It returns `None` when value is invalid.
    ///
    /// Units: %
    pub fn min_saturated_hemoglobin_percent_scaled(&self) -> Option<Vec<f64>> {
        if self.min_saturated_hemoglobin_percent.is_empty() {
            return None;
        }
        let mut v = Vec::with_capacity(self.min_saturated_hemoglobin_percent.len());
        for &x in &self.min_saturated_hemoglobin_percent {
            v.push(x as f64 / 10.0 - 0.0)
        }
        Some(v)
    }

    /// Set `min_saturated_hemoglobin_percent` with scaled value, it will automatically be converted to its corresponding integer value.
    pub fn set_min_saturated_hemoglobin_percent_scaled(&mut self, v: &[f64]) -> &mut Self {
        self.min_saturated_hemoglobin_percent = Vec::with_capacity(v.len());
        if v.is_empty() {
            return self;
        }
        for &x in v {
            let unscaled = (x + 0.0) * 10.0;
            if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u16::MAX as f64 {
                self.min_saturated_hemoglobin_percent.push(u16::MAX);
                continue;
            }
            self.min_saturated_hemoglobin_percent.push(unscaled as u16);
        }
        self
    }

    /// Returns `max_saturated_hemoglobin_percent` in its scaled value. It returns `None` when value is invalid.
    ///
    /// Units: %
    pub fn max_saturated_hemoglobin_percent_scaled(&self) -> Option<Vec<f64>> {
        if self.max_saturated_hemoglobin_percent.is_empty() {
            return None;
        }
        let mut v = Vec::with_capacity(self.max_saturated_hemoglobin_percent.len());
        for &x in &self.max_saturated_hemoglobin_percent {
            v.push(x as f64 / 10.0 - 0.0)
        }
        Some(v)
    }

    /// Set `max_saturated_hemoglobin_percent` with scaled value, it will automatically be converted to its corresponding integer value.
    pub fn set_max_saturated_hemoglobin_percent_scaled(&mut self, v: &[f64]) -> &mut Self {
        self.max_saturated_hemoglobin_percent = Vec::with_capacity(v.len());
        if v.is_empty() {
            return self;
        }
        for &x in v {
            let unscaled = (x + 0.0) * 10.0;
            if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u16::MAX as f64 {
                self.max_saturated_hemoglobin_percent.push(u16::MAX);
                continue;
            }
            self.max_saturated_hemoglobin_percent.push(unscaled as u16);
        }
        self
    }

    /// Returns `avg_left_torque_effectiveness` in its scaled value. It returns `None` when value is invalid.
    ///
    /// Units: percent
    pub fn avg_left_torque_effectiveness_scaled(&self) -> Option<f64> {
        if self.avg_left_torque_effectiveness == u8::MAX {
            return None;
        }
        Some(self.avg_left_torque_effectiveness as f64 / 2.0 - 0.0)
    }

    /// Set `avg_left_torque_effectiveness` with scaled value, it will automatically be converted to its corresponding integer value.
    pub fn set_avg_left_torque_effectiveness_scaled(&mut self, v: f64) -> &mut Self {
        let unscaled = (v + 0.0) * 2.0;
        if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u8::MAX as f64 {
            self.avg_left_torque_effectiveness = u8::MAX;
            return self;
        }
        self.avg_left_torque_effectiveness = unscaled as u8;
        self
    }

    /// Returns `avg_right_torque_effectiveness` in its scaled value. It returns `None` when value is invalid.
    ///
    /// Units: percent
    pub fn avg_right_torque_effectiveness_scaled(&self) -> Option<f64> {
        if self.avg_right_torque_effectiveness == u8::MAX {
            return None;
        }
        Some(self.avg_right_torque_effectiveness as f64 / 2.0 - 0.0)
    }

    /// Set `avg_right_torque_effectiveness` with scaled value, it will automatically be converted to its corresponding integer value.
    pub fn set_avg_right_torque_effectiveness_scaled(&mut self, v: f64) -> &mut Self {
        let unscaled = (v + 0.0) * 2.0;
        if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u8::MAX as f64 {
            self.avg_right_torque_effectiveness = u8::MAX;
            return self;
        }
        self.avg_right_torque_effectiveness = unscaled as u8;
        self
    }

    /// Returns `avg_left_pedal_smoothness` in its scaled value. It returns `None` when value is invalid.
    ///
    /// Units: percent
    pub fn avg_left_pedal_smoothness_scaled(&self) -> Option<f64> {
        if self.avg_left_pedal_smoothness == u8::MAX {
            return None;
        }
        Some(self.avg_left_pedal_smoothness as f64 / 2.0 - 0.0)
    }

    /// Set `avg_left_pedal_smoothness` with scaled value, it will automatically be converted to its corresponding integer value.
    pub fn set_avg_left_pedal_smoothness_scaled(&mut self, v: f64) -> &mut Self {
        let unscaled = (v + 0.0) * 2.0;
        if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u8::MAX as f64 {
            self.avg_left_pedal_smoothness = u8::MAX;
            return self;
        }
        self.avg_left_pedal_smoothness = unscaled as u8;
        self
    }

    /// Returns `avg_right_pedal_smoothness` in its scaled value. It returns `None` when value is invalid.
    ///
    /// Units: percent
    pub fn avg_right_pedal_smoothness_scaled(&self) -> Option<f64> {
        if self.avg_right_pedal_smoothness == u8::MAX {
            return None;
        }
        Some(self.avg_right_pedal_smoothness as f64 / 2.0 - 0.0)
    }

    /// Set `avg_right_pedal_smoothness` with scaled value, it will automatically be converted to its corresponding integer value.
    pub fn set_avg_right_pedal_smoothness_scaled(&mut self, v: f64) -> &mut Self {
        let unscaled = (v + 0.0) * 2.0;
        if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u8::MAX as f64 {
            self.avg_right_pedal_smoothness = u8::MAX;
            return self;
        }
        self.avg_right_pedal_smoothness = unscaled as u8;
        self
    }

    /// Returns `avg_combined_pedal_smoothness` in its scaled value. It returns `None` when value is invalid.
    ///
    /// Units: percent
    pub fn avg_combined_pedal_smoothness_scaled(&self) -> Option<f64> {
        if self.avg_combined_pedal_smoothness == u8::MAX {
            return None;
        }
        Some(self.avg_combined_pedal_smoothness as f64 / 2.0 - 0.0)
    }

    /// Set `avg_combined_pedal_smoothness` with scaled value, it will automatically be converted to its corresponding integer value.
    pub fn set_avg_combined_pedal_smoothness_scaled(&mut self, v: f64) -> &mut Self {
        let unscaled = (v + 0.0) * 2.0;
        if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u8::MAX as f64 {
            self.avg_combined_pedal_smoothness = u8::MAX;
            return self;
        }
        self.avg_combined_pedal_smoothness = unscaled as u8;
        self
    }

    /// Returns `time_standing` in its scaled value. It returns `None` when value is invalid.
    ///
    /// Units: s
    pub fn time_standing_scaled(&self) -> Option<f64> {
        if self.time_standing == u32::MAX {
            return None;
        }
        Some(self.time_standing as f64 / 1000.0 - 0.0)
    }

    /// Set `time_standing` with scaled value, it will automatically be converted to its corresponding integer value.
    pub fn set_time_standing_scaled(&mut self, v: f64) -> &mut Self {
        let unscaled = (v + 0.0) * 1000.0;
        if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u32::MAX as f64 {
            self.time_standing = u32::MAX;
            return self;
        }
        self.time_standing = unscaled as u32;
        self
    }

    /// Returns `avg_left_power_phase` in its scaled value. It returns `None` when value is invalid.
    ///
    /// Units: degrees
    pub fn avg_left_power_phase_scaled(&self) -> Option<Vec<f64>> {
        if self.avg_left_power_phase.is_empty() {
            return None;
        }
        let mut v = Vec::with_capacity(self.avg_left_power_phase.len());
        for &x in &self.avg_left_power_phase {
            v.push(x as f64 / 0.7111111 - 0.0)
        }
        Some(v)
    }

    /// Set `avg_left_power_phase` with scaled value, it will automatically be converted to its corresponding integer value.
    pub fn set_avg_left_power_phase_scaled(&mut self, v: &[f64]) -> &mut Self {
        self.avg_left_power_phase = Vec::with_capacity(v.len());
        if v.is_empty() {
            return self;
        }
        for &x in v {
            let unscaled = (x + 0.0) * 0.7111111;
            if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u8::MAX as f64 {
                self.avg_left_power_phase.push(u8::MAX);
                continue;
            }
            self.avg_left_power_phase.push(unscaled as u8);
        }
        self
    }

    /// Returns `avg_left_power_phase_peak` in its scaled value. It returns `None` when value is invalid.
    ///
    /// Units: degrees
    pub fn avg_left_power_phase_peak_scaled(&self) -> Option<Vec<f64>> {
        if self.avg_left_power_phase_peak.is_empty() {
            return None;
        }
        let mut v = Vec::with_capacity(self.avg_left_power_phase_peak.len());
        for &x in &self.avg_left_power_phase_peak {
            v.push(x as f64 / 0.7111111 - 0.0)
        }
        Some(v)
    }

    /// Set `avg_left_power_phase_peak` with scaled value, it will automatically be converted to its corresponding integer value.
    pub fn set_avg_left_power_phase_peak_scaled(&mut self, v: &[f64]) -> &mut Self {
        self.avg_left_power_phase_peak = Vec::with_capacity(v.len());
        if v.is_empty() {
            return self;
        }
        for &x in v {
            let unscaled = (x + 0.0) * 0.7111111;
            if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u8::MAX as f64 {
                self.avg_left_power_phase_peak.push(u8::MAX);
                continue;
            }
            self.avg_left_power_phase_peak.push(unscaled as u8);
        }
        self
    }

    /// Returns `avg_right_power_phase` in its scaled value. It returns `None` when value is invalid.
    ///
    /// Units: degrees
    pub fn avg_right_power_phase_scaled(&self) -> Option<Vec<f64>> {
        if self.avg_right_power_phase.is_empty() {
            return None;
        }
        let mut v = Vec::with_capacity(self.avg_right_power_phase.len());
        for &x in &self.avg_right_power_phase {
            v.push(x as f64 / 0.7111111 - 0.0)
        }
        Some(v)
    }

    /// Set `avg_right_power_phase` with scaled value, it will automatically be converted to its corresponding integer value.
    pub fn set_avg_right_power_phase_scaled(&mut self, v: &[f64]) -> &mut Self {
        self.avg_right_power_phase = Vec::with_capacity(v.len());
        if v.is_empty() {
            return self;
        }
        for &x in v {
            let unscaled = (x + 0.0) * 0.7111111;
            if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u8::MAX as f64 {
                self.avg_right_power_phase.push(u8::MAX);
                continue;
            }
            self.avg_right_power_phase.push(unscaled as u8);
        }
        self
    }

    /// Returns `avg_right_power_phase_peak` in its scaled value. It returns `None` when value is invalid.
    ///
    /// Units: degrees
    pub fn avg_right_power_phase_peak_scaled(&self) -> Option<Vec<f64>> {
        if self.avg_right_power_phase_peak.is_empty() {
            return None;
        }
        let mut v = Vec::with_capacity(self.avg_right_power_phase_peak.len());
        for &x in &self.avg_right_power_phase_peak {
            v.push(x as f64 / 0.7111111 - 0.0)
        }
        Some(v)
    }

    /// Set `avg_right_power_phase_peak` with scaled value, it will automatically be converted to its corresponding integer value.
    pub fn set_avg_right_power_phase_peak_scaled(&mut self, v: &[f64]) -> &mut Self {
        self.avg_right_power_phase_peak = Vec::with_capacity(v.len());
        if v.is_empty() {
            return self;
        }
        for &x in v {
            let unscaled = (x + 0.0) * 0.7111111;
            if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u8::MAX as f64 {
                self.avg_right_power_phase_peak.push(u8::MAX);
                continue;
            }
            self.avg_right_power_phase_peak.push(unscaled as u8);
        }
        self
    }

    /// Returns `enhanced_avg_speed` in its scaled value. It returns `None` when value is invalid.
    ///
    /// Units: m/s
    pub fn enhanced_avg_speed_scaled(&self) -> Option<f64> {
        if self.enhanced_avg_speed == u32::MAX {
            return None;
        }
        Some(self.enhanced_avg_speed as f64 / 1000.0 - 0.0)
    }

    /// Set `enhanced_avg_speed` with scaled value, it will automatically be converted to its corresponding integer value.
    pub fn set_enhanced_avg_speed_scaled(&mut self, v: f64) -> &mut Self {
        let unscaled = (v + 0.0) * 1000.0;
        if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u32::MAX as f64 {
            self.enhanced_avg_speed = u32::MAX;
            return self;
        }
        self.enhanced_avg_speed = unscaled as u32;
        self
    }

    /// Returns `enhanced_max_speed` in its scaled value. It returns `None` when value is invalid.
    ///
    /// Units: m/s
    pub fn enhanced_max_speed_scaled(&self) -> Option<f64> {
        if self.enhanced_max_speed == u32::MAX {
            return None;
        }
        Some(self.enhanced_max_speed as f64 / 1000.0 - 0.0)
    }

    /// Set `enhanced_max_speed` with scaled value, it will automatically be converted to its corresponding integer value.
    pub fn set_enhanced_max_speed_scaled(&mut self, v: f64) -> &mut Self {
        let unscaled = (v + 0.0) * 1000.0;
        if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u32::MAX as f64 {
            self.enhanced_max_speed = u32::MAX;
            return self;
        }
        self.enhanced_max_speed = unscaled as u32;
        self
    }

    /// Returns `enhanced_avg_altitude` in its scaled value. It returns `None` when value is invalid.
    ///
    /// Units: m
    pub fn enhanced_avg_altitude_scaled(&self) -> Option<f64> {
        if self.enhanced_avg_altitude == u32::MAX {
            return None;
        }
        Some(self.enhanced_avg_altitude as f64 / 5.0 - 500.0)
    }

    /// Set `enhanced_avg_altitude` with scaled value, it will automatically be converted to its corresponding integer value.
    pub fn set_enhanced_avg_altitude_scaled(&mut self, v: f64) -> &mut Self {
        let unscaled = (v + 500.0) * 5.0;
        if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u32::MAX as f64 {
            self.enhanced_avg_altitude = u32::MAX;
            return self;
        }
        self.enhanced_avg_altitude = unscaled as u32;
        self
    }

    /// Returns `enhanced_min_altitude` in its scaled value. It returns `None` when value is invalid.
    ///
    /// Units: m
    pub fn enhanced_min_altitude_scaled(&self) -> Option<f64> {
        if self.enhanced_min_altitude == u32::MAX {
            return None;
        }
        Some(self.enhanced_min_altitude as f64 / 5.0 - 500.0)
    }

    /// Set `enhanced_min_altitude` with scaled value, it will automatically be converted to its corresponding integer value.
    pub fn set_enhanced_min_altitude_scaled(&mut self, v: f64) -> &mut Self {
        let unscaled = (v + 500.0) * 5.0;
        if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u32::MAX as f64 {
            self.enhanced_min_altitude = u32::MAX;
            return self;
        }
        self.enhanced_min_altitude = unscaled as u32;
        self
    }

    /// Returns `enhanced_max_altitude` in its scaled value. It returns `None` when value is invalid.
    ///
    /// Units: m
    pub fn enhanced_max_altitude_scaled(&self) -> Option<f64> {
        if self.enhanced_max_altitude == u32::MAX {
            return None;
        }
        Some(self.enhanced_max_altitude as f64 / 5.0 - 500.0)
    }

    /// Set `enhanced_max_altitude` with scaled value, it will automatically be converted to its corresponding integer value.
    pub fn set_enhanced_max_altitude_scaled(&mut self, v: f64) -> &mut Self {
        let unscaled = (v + 500.0) * 5.0;
        if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u32::MAX as f64 {
            self.enhanced_max_altitude = u32::MAX;
            return self;
        }
        self.enhanced_max_altitude = unscaled as u32;
        self
    }

    /// Returns `lev_battery_consumption` in its scaled value. It returns `None` when value is invalid.
    ///
    /// Units: percent
    pub fn lev_battery_consumption_scaled(&self) -> Option<f64> {
        if self.lev_battery_consumption == u8::MAX {
            return None;
        }
        Some(self.lev_battery_consumption as f64 / 2.0 - 0.0)
    }

    /// Set `lev_battery_consumption` with scaled value, it will automatically be converted to its corresponding integer value.
    pub fn set_lev_battery_consumption_scaled(&mut self, v: f64) -> &mut Self {
        let unscaled = (v + 0.0) * 2.0;
        if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u8::MAX as f64 {
            self.lev_battery_consumption = u8::MAX;
            return self;
        }
        self.lev_battery_consumption = unscaled as u8;
        self
    }

    /// Returns `avg_vertical_ratio` in its scaled value. It returns `None` when value is invalid.
    ///
    /// Units: percent
    pub fn avg_vertical_ratio_scaled(&self) -> Option<f64> {
        if self.avg_vertical_ratio == u16::MAX {
            return None;
        }
        Some(self.avg_vertical_ratio as f64 / 100.0 - 0.0)
    }

    /// Set `avg_vertical_ratio` with scaled value, it will automatically be converted to its corresponding integer value.
    pub fn set_avg_vertical_ratio_scaled(&mut self, v: f64) -> &mut Self {
        let unscaled = (v + 0.0) * 100.0;
        if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u16::MAX as f64 {
            self.avg_vertical_ratio = u16::MAX;
            return self;
        }
        self.avg_vertical_ratio = unscaled as u16;
        self
    }

    /// Returns `avg_stance_time_balance` in its scaled value. It returns `None` when value is invalid.
    ///
    /// Units: percent
    pub fn avg_stance_time_balance_scaled(&self) -> Option<f64> {
        if self.avg_stance_time_balance == u16::MAX {
            return None;
        }
        Some(self.avg_stance_time_balance as f64 / 100.0 - 0.0)
    }

    /// Set `avg_stance_time_balance` with scaled value, it will automatically be converted to its corresponding integer value.
    pub fn set_avg_stance_time_balance_scaled(&mut self, v: f64) -> &mut Self {
        let unscaled = (v + 0.0) * 100.0;
        if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u16::MAX as f64 {
            self.avg_stance_time_balance = u16::MAX;
            return self;
        }
        self.avg_stance_time_balance = unscaled as u16;
        self
    }

    /// Returns `avg_step_length` in its scaled value. It returns `None` when value is invalid.
    ///
    /// Units: mm
    pub fn avg_step_length_scaled(&self) -> Option<f64> {
        if self.avg_step_length == u16::MAX {
            return None;
        }
        Some(self.avg_step_length as f64 / 10.0 - 0.0)
    }

    /// Set `avg_step_length` with scaled value, it will automatically be converted to its corresponding integer value.
    pub fn set_avg_step_length_scaled(&mut self, v: f64) -> &mut Self {
        let unscaled = (v + 0.0) * 10.0;
        if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u16::MAX as f64 {
            self.avg_step_length = u16::MAX;
            return self;
        }
        self.avg_step_length = unscaled as u16;
        self
    }

    /// Returns `total_anaerobic_training_effect` in its scaled value. It returns `None` when value is invalid.
    pub fn total_anaerobic_training_effect_scaled(&self) -> Option<f64> {
        if self.total_anaerobic_training_effect == u8::MAX {
            return None;
        }
        Some(self.total_anaerobic_training_effect as f64 / 10.0 - 0.0)
    }

    /// Set `total_anaerobic_training_effect` with scaled value, it will automatically be converted to its corresponding integer value.
    pub fn set_total_anaerobic_training_effect_scaled(&mut self, v: f64) -> &mut Self {
        let unscaled = (v + 0.0) * 10.0;
        if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u8::MAX as f64 {
            self.total_anaerobic_training_effect = u8::MAX;
            return self;
        }
        self.total_anaerobic_training_effect = unscaled as u8;
        self
    }

    /// Returns `avg_vam` in its scaled value. It returns `None` when value is invalid.
    ///
    /// Units: m/s
    pub fn avg_vam_scaled(&self) -> Option<f64> {
        if self.avg_vam == u16::MAX {
            return None;
        }
        Some(self.avg_vam as f64 / 1000.0 - 0.0)
    }

    /// Set `avg_vam` with scaled value, it will automatically be converted to its corresponding integer value.
    pub fn set_avg_vam_scaled(&mut self, v: f64) -> &mut Self {
        let unscaled = (v + 0.0) * 1000.0;
        if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u16::MAX as f64 {
            self.avg_vam = u16::MAX;
            return self;
        }
        self.avg_vam = unscaled as u16;
        self
    }

    /// Returns `avg_depth` in its scaled value. It returns `None` when value is invalid.
    ///
    /// Units: m
    pub fn avg_depth_scaled(&self) -> Option<f64> {
        if self.avg_depth == u32::MAX {
            return None;
        }
        Some(self.avg_depth as f64 / 1000.0 - 0.0)
    }

    /// Set `avg_depth` with scaled value, it will automatically be converted to its corresponding integer value.
    pub fn set_avg_depth_scaled(&mut self, v: f64) -> &mut Self {
        let unscaled = (v + 0.0) * 1000.0;
        if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u32::MAX as f64 {
            self.avg_depth = u32::MAX;
            return self;
        }
        self.avg_depth = unscaled as u32;
        self
    }

    /// Returns `max_depth` in its scaled value. It returns `None` when value is invalid.
    ///
    /// Units: m
    pub fn max_depth_scaled(&self) -> Option<f64> {
        if self.max_depth == u32::MAX {
            return None;
        }
        Some(self.max_depth as f64 / 1000.0 - 0.0)
    }

    /// Set `max_depth` with scaled value, it will automatically be converted to its corresponding integer value.
    pub fn set_max_depth_scaled(&mut self, v: f64) -> &mut Self {
        let unscaled = (v + 0.0) * 1000.0;
        if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u32::MAX as f64 {
            self.max_depth = u32::MAX;
            return self;
        }
        self.max_depth = unscaled as u32;
        self
    }

    /// Returns `training_load_peak` in its scaled value. It returns `None` when value is invalid.
    pub fn training_load_peak_scaled(&self) -> Option<f64> {
        if self.training_load_peak == i32::MAX {
            return None;
        }
        Some(self.training_load_peak as f64 / 65536.0 - 0.0)
    }

    /// Set `training_load_peak` with scaled value, it will automatically be converted to its corresponding integer value.
    pub fn set_training_load_peak_scaled(&mut self, v: f64) -> &mut Self {
        let unscaled = (v + 0.0) * 65536.0;
        if unscaled.is_nan() || unscaled.is_infinite() || unscaled > i32::MAX as f64 {
            self.training_load_peak = i32::MAX;
            return self;
        }
        self.training_load_peak = unscaled as i32;
        self
    }

    /// Returns `enhanced_avg_respiration_rate` in its scaled value. It returns `None` when value is invalid.
    ///
    /// Units: Breaths/min
    pub fn enhanced_avg_respiration_rate_scaled(&self) -> Option<f64> {
        if self.enhanced_avg_respiration_rate == u16::MAX {
            return None;
        }
        Some(self.enhanced_avg_respiration_rate as f64 / 100.0 - 0.0)
    }

    /// Set `enhanced_avg_respiration_rate` with scaled value, it will automatically be converted to its corresponding integer value.
    pub fn set_enhanced_avg_respiration_rate_scaled(&mut self, v: f64) -> &mut Self {
        let unscaled = (v + 0.0) * 100.0;
        if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u16::MAX as f64 {
            self.enhanced_avg_respiration_rate = u16::MAX;
            return self;
        }
        self.enhanced_avg_respiration_rate = unscaled as u16;
        self
    }

    /// Returns `enhanced_max_respiration_rate` in its scaled value. It returns `None` when value is invalid.
    ///
    /// Units: Breaths/min
    pub fn enhanced_max_respiration_rate_scaled(&self) -> Option<f64> {
        if self.enhanced_max_respiration_rate == u16::MAX {
            return None;
        }
        Some(self.enhanced_max_respiration_rate as f64 / 100.0 - 0.0)
    }

    /// Set `enhanced_max_respiration_rate` with scaled value, it will automatically be converted to its corresponding integer value.
    pub fn set_enhanced_max_respiration_rate_scaled(&mut self, v: f64) -> &mut Self {
        let unscaled = (v + 0.0) * 100.0;
        if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u16::MAX as f64 {
            self.enhanced_max_respiration_rate = u16::MAX;
            return self;
        }
        self.enhanced_max_respiration_rate = unscaled as u16;
        self
    }

    /// Returns `enhanced_min_respiration_rate` in its scaled value. It returns `None` when value is invalid.
    pub fn enhanced_min_respiration_rate_scaled(&self) -> Option<f64> {
        if self.enhanced_min_respiration_rate == u16::MAX {
            return None;
        }
        Some(self.enhanced_min_respiration_rate as f64 / 100.0 - 0.0)
    }

    /// Set `enhanced_min_respiration_rate` with scaled value, it will automatically be converted to its corresponding integer value.
    pub fn set_enhanced_min_respiration_rate_scaled(&mut self, v: f64) -> &mut Self {
        let unscaled = (v + 0.0) * 100.0;
        if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u16::MAX as f64 {
            self.enhanced_min_respiration_rate = u16::MAX;
            return self;
        }
        self.enhanced_min_respiration_rate = unscaled as u16;
        self
    }

    /// Returns `total_fractional_ascent` in its scaled value. It returns `None` when value is invalid.
    ///
    /// Units: m
    pub fn total_fractional_ascent_scaled(&self) -> Option<f64> {
        if self.total_fractional_ascent == u8::MAX {
            return None;
        }
        Some(self.total_fractional_ascent as f64 / 100.0 - 0.0)
    }

    /// Set `total_fractional_ascent` with scaled value, it will automatically be converted to its corresponding integer value.
    pub fn set_total_fractional_ascent_scaled(&mut self, v: f64) -> &mut Self {
        let unscaled = (v + 0.0) * 100.0;
        if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u8::MAX as f64 {
            self.total_fractional_ascent = u8::MAX;
            return self;
        }
        self.total_fractional_ascent = unscaled as u8;
        self
    }

    /// Returns `total_fractional_descent` in its scaled value. It returns `None` when value is invalid.
    ///
    /// Units: m
    pub fn total_fractional_descent_scaled(&self) -> Option<f64> {
        if self.total_fractional_descent == u8::MAX {
            return None;
        }
        Some(self.total_fractional_descent as f64 / 100.0 - 0.0)
    }

    /// Set `total_fractional_descent` with scaled value, it will automatically be converted to its corresponding integer value.
    pub fn set_total_fractional_descent_scaled(&mut self, v: f64) -> &mut Self {
        let unscaled = (v + 0.0) * 100.0;
        if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u8::MAX as f64 {
            self.total_fractional_descent = u8::MAX;
            return self;
        }
        self.total_fractional_descent = unscaled as u8;
        self
    }

    /// Returns `avg_core_temperature` in its scaled value. It returns `None` when value is invalid.
    ///
    /// Units: C
    pub fn avg_core_temperature_scaled(&self) -> Option<f64> {
        if self.avg_core_temperature == u16::MAX {
            return None;
        }
        Some(self.avg_core_temperature as f64 / 100.0 - 0.0)
    }

    /// Set `avg_core_temperature` with scaled value, it will automatically be converted to its corresponding integer value.
    pub fn set_avg_core_temperature_scaled(&mut self, v: f64) -> &mut Self {
        let unscaled = (v + 0.0) * 100.0;
        if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u16::MAX as f64 {
            self.avg_core_temperature = u16::MAX;
            return self;
        }
        self.avg_core_temperature = unscaled as u16;
        self
    }

    /// Returns `min_core_temperature` in its scaled value. It returns `None` when value is invalid.
    ///
    /// Units: C
    pub fn min_core_temperature_scaled(&self) -> Option<f64> {
        if self.min_core_temperature == u16::MAX {
            return None;
        }
        Some(self.min_core_temperature as f64 / 100.0 - 0.0)
    }

    /// Set `min_core_temperature` with scaled value, it will automatically be converted to its corresponding integer value.
    pub fn set_min_core_temperature_scaled(&mut self, v: f64) -> &mut Self {
        let unscaled = (v + 0.0) * 100.0;
        if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u16::MAX as f64 {
            self.min_core_temperature = u16::MAX;
            return self;
        }
        self.min_core_temperature = unscaled as u16;
        self
    }

    /// Returns `max_core_temperature` in its scaled value. It returns `None` when value is invalid.
    ///
    /// Units: C
    pub fn max_core_temperature_scaled(&self) -> Option<f64> {
        if self.max_core_temperature == u16::MAX {
            return None;
        }
        Some(self.max_core_temperature as f64 / 100.0 - 0.0)
    }

    /// Set `max_core_temperature` with scaled value, it will automatically be converted to its corresponding integer value.
    pub fn set_max_core_temperature_scaled(&mut self, v: f64) -> &mut Self {
        let unscaled = (v + 0.0) * 100.0;
        if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u16::MAX as f64 {
            self.max_core_temperature = u16::MAX;
            return self;
        }
        self.max_core_temperature = unscaled as u16;
        self
    }

    /// Marks whether given field's num is an expanded field (field that being generated through a component expansion).
    pub fn mark_as_expanded(&mut self, num: u8, flag: bool) -> bool {
        match num {
            124 | 125 | 126 | 127 | 128 | 169 | 170 | 180 => {
                if flag {
                    self.state[num as usize >> 3] |= 1 << (num & 7)
                } else {
                    self.state[num as usize >> 3] &= !(1 << (num & 7))
                }
                true
            }
            _ => false,
        }
    }

    /// checks whether given field's num is a field generated through a component expansion.
    pub fn is_expanded(&self, num: u8) -> bool {
        is_expanded(&self.state, num)
    }

    fn count_valid_fields(&self) -> usize {
        (self.message_index.0 != u16::MAX) as usize
            + (self.timestamp.0 != u32::MAX) as usize
            + (self.event.0 != u8::MAX) as usize
            + (self.event_type.0 != u8::MAX) as usize
            + (self.start_time.0 != u32::MAX) as usize
            + (self.start_position_lat != i32::MAX) as usize
            + (self.start_position_long != i32::MAX) as usize
            + (self.sport.0 != u8::MAX) as usize
            + (self.sub_sport.0 != u8::MAX) as usize
            + (self.total_elapsed_time != u32::MAX) as usize
            + (self.total_timer_time != u32::MAX) as usize
            + (self.total_distance != u32::MAX) as usize
            + (self.total_cycles != u32::MAX) as usize
            + (self.total_calories != u16::MAX) as usize
            + (self.total_fat_calories != u16::MAX) as usize
            + (self.avg_speed != u16::MAX) as usize
            + (self.max_speed != u16::MAX) as usize
            + (self.avg_heart_rate != u8::MAX) as usize
            + (self.max_heart_rate != u8::MAX) as usize
            + (self.avg_cadence != u8::MAX) as usize
            + (self.max_cadence != u8::MAX) as usize
            + (self.avg_power != u16::MAX) as usize
            + (self.max_power != u16::MAX) as usize
            + (self.total_ascent != u16::MAX) as usize
            + (self.total_descent != u16::MAX) as usize
            + (self.total_training_effect != u8::MAX) as usize
            + (self.first_lap_index != u16::MAX) as usize
            + (self.num_laps != u16::MAX) as usize
            + (self.event_group != u8::MAX) as usize
            + (self.trigger.0 != u8::MAX) as usize
            + (self.nec_lat != i32::MAX) as usize
            + (self.nec_long != i32::MAX) as usize
            + (self.swc_lat != i32::MAX) as usize
            + (self.swc_long != i32::MAX) as usize
            + (self.num_lengths != u16::MAX) as usize
            + (self.normalized_power != u16::MAX) as usize
            + (self.training_stress_score != u16::MAX) as usize
            + (self.intensity_factor != u16::MAX) as usize
            + (self.left_right_balance.0 != u16::MAX) as usize
            + (self.end_position_lat != i32::MAX) as usize
            + (self.end_position_long != i32::MAX) as usize
            + (self.avg_stroke_count != u32::MAX) as usize
            + (self.avg_stroke_distance != u16::MAX) as usize
            + (self.swim_stroke.0 != u8::MAX) as usize
            + (self.pool_length != u16::MAX) as usize
            + (self.threshold_power != u16::MAX) as usize
            + (self.pool_length_unit.0 != u8::MAX) as usize
            + (self.num_active_lengths != u16::MAX) as usize
            + (self.total_work != u32::MAX) as usize
            + (self.avg_altitude != u16::MAX) as usize
            + (self.max_altitude != u16::MAX) as usize
            + (self.gps_accuracy != u8::MAX) as usize
            + (self.avg_grade != i16::MAX) as usize
            + (self.avg_pos_grade != i16::MAX) as usize
            + (self.avg_neg_grade != i16::MAX) as usize
            + (self.max_pos_grade != i16::MAX) as usize
            + (self.max_neg_grade != i16::MAX) as usize
            + (self.avg_temperature != i8::MAX) as usize
            + (self.max_temperature != i8::MAX) as usize
            + (self.total_moving_time != u32::MAX) as usize
            + (self.avg_pos_vertical_speed != i16::MAX) as usize
            + (self.avg_neg_vertical_speed != i16::MAX) as usize
            + (self.max_pos_vertical_speed != i16::MAX) as usize
            + (self.max_neg_vertical_speed != i16::MAX) as usize
            + (self.min_heart_rate != u8::MAX) as usize
            + (!self.time_in_hr_zone.is_empty()) as usize
            + (!self.time_in_speed_zone.is_empty()) as usize
            + (!self.time_in_cadence_zone.is_empty()) as usize
            + (!self.time_in_power_zone.is_empty()) as usize
            + (self.avg_lap_time != u32::MAX) as usize
            + (self.best_lap_index != u16::MAX) as usize
            + (self.min_altitude != u16::MAX) as usize
            + (self.active_time != u32::MAX) as usize
            + (self.player_score != u16::MAX) as usize
            + (self.opponent_score != u16::MAX) as usize
            + (!self.opponent_name.is_empty()) as usize
            + (!self.stroke_count.is_empty()) as usize
            + (!self.zone_count.is_empty()) as usize
            + (self.max_ball_speed != u16::MAX) as usize
            + (self.avg_ball_speed != u16::MAX) as usize
            + (self.avg_vertical_oscillation != u16::MAX) as usize
            + (self.avg_stance_time_percent != u16::MAX) as usize
            + (self.avg_stance_time != u16::MAX) as usize
            + (self.avg_fractional_cadence != u8::MAX) as usize
            + (self.max_fractional_cadence != u8::MAX) as usize
            + (self.total_fractional_cycles != u8::MAX) as usize
            + (!self.avg_total_hemoglobin_conc.is_empty()) as usize
            + (!self.min_total_hemoglobin_conc.is_empty()) as usize
            + (!self.max_total_hemoglobin_conc.is_empty()) as usize
            + (!self.avg_saturated_hemoglobin_percent.is_empty()) as usize
            + (!self.min_saturated_hemoglobin_percent.is_empty()) as usize
            + (!self.max_saturated_hemoglobin_percent.is_empty()) as usize
            + (self.avg_left_torque_effectiveness != u8::MAX) as usize
            + (self.avg_right_torque_effectiveness != u8::MAX) as usize
            + (self.avg_left_pedal_smoothness != u8::MAX) as usize
            + (self.avg_right_pedal_smoothness != u8::MAX) as usize
            + (self.avg_combined_pedal_smoothness != u8::MAX) as usize
            + (!self.sport_profile_name.is_empty()) as usize
            + (self.sport_index != u8::MAX) as usize
            + (self.time_standing != u32::MAX) as usize
            + (self.stand_count != u16::MAX) as usize
            + (self.avg_left_pco != i8::MAX) as usize
            + (self.avg_right_pco != i8::MAX) as usize
            + (!self.avg_left_power_phase.is_empty()) as usize
            + (!self.avg_left_power_phase_peak.is_empty()) as usize
            + (!self.avg_right_power_phase.is_empty()) as usize
            + (!self.avg_right_power_phase_peak.is_empty()) as usize
            + (!self.avg_power_position.is_empty()) as usize
            + (!self.max_power_position.is_empty()) as usize
            + (!self.avg_cadence_position.is_empty()) as usize
            + (!self.max_cadence_position.is_empty()) as usize
            + (self.enhanced_avg_speed != u32::MAX) as usize
            + (self.enhanced_max_speed != u32::MAX) as usize
            + (self.enhanced_avg_altitude != u32::MAX) as usize
            + (self.enhanced_min_altitude != u32::MAX) as usize
            + (self.enhanced_max_altitude != u32::MAX) as usize
            + (self.avg_lev_motor_power != u16::MAX) as usize
            + (self.max_lev_motor_power != u16::MAX) as usize
            + (self.lev_battery_consumption != u8::MAX) as usize
            + (self.avg_vertical_ratio != u16::MAX) as usize
            + (self.avg_stance_time_balance != u16::MAX) as usize
            + (self.avg_step_length != u16::MAX) as usize
            + (self.total_anaerobic_training_effect != u8::MAX) as usize
            + (self.avg_vam != u16::MAX) as usize
            + (self.avg_depth != u32::MAX) as usize
            + (self.max_depth != u32::MAX) as usize
            + (self.surface_interval != u32::MAX) as usize
            + (self.start_cns != u8::MAX) as usize
            + (self.end_cns != u8::MAX) as usize
            + (self.start_n2 != u16::MAX) as usize
            + (self.end_n2 != u16::MAX) as usize
            + (self.avg_respiration_rate != u8::MAX) as usize
            + (self.max_respiration_rate != u8::MAX) as usize
            + (self.min_respiration_rate != u8::MAX) as usize
            + (self.min_temperature != i8::MAX) as usize
            + (self.o2_toxicity != u16::MAX) as usize
            + (self.dive_number != u32::MAX) as usize
            + (self.training_load_peak != i32::MAX) as usize
            + (self.enhanced_avg_respiration_rate != u16::MAX) as usize
            + (self.enhanced_max_respiration_rate != u16::MAX) as usize
            + (self.enhanced_min_respiration_rate != u16::MAX) as usize
            + (self.total_grit.to_bits() != u32::MAX) as usize
            + (self.total_flow.to_bits() != u32::MAX) as usize
            + (self.jump_count != u16::MAX) as usize
            + (self.avg_grit.to_bits() != u32::MAX) as usize
            + (self.avg_flow.to_bits() != u32::MAX) as usize
            + (self.workout_feel != u8::MAX) as usize
            + (self.workout_rpe != u8::MAX) as usize
            + (self.avg_spo2 != u8::MAX) as usize
            + (self.avg_stress != u8::MAX) as usize
            + (self.metabolic_calories != u16::MAX) as usize
            + (self.sdrr_hrv != u8::MAX) as usize
            + (self.rmssd_hrv != u8::MAX) as usize
            + (self.total_fractional_ascent != u8::MAX) as usize
            + (self.total_fractional_descent != u8::MAX) as usize
            + (self.avg_core_temperature != u16::MAX) as usize
            + (self.min_core_temperature != u16::MAX) as usize
            + (self.max_core_temperature != u16::MAX) as usize
    }
}

impl Default for Session {
    fn default() -> Self {
        Self::new()
    }
}

impl From<&Message> for Session {
    /// from creates new Session struct based on given mesg.
    fn from(mesg: &Message) -> Self {
        const KNOWN_NUMS: [u64; 4] = [
            18446742974197919743,
            18446678103011639551,
            932252819858127487,
            6917529027641541119,
        ];
        let mut n = 0u64;
        for field in &mesg.fields {
            n += (KNOWN_NUMS[field.num as usize >> 6] >> (field.num & 63)) & 1 ^ 1
        }

        let mut v = Self::new();
        v.unknown_fields = Vec::<Field>::with_capacity(n as usize);
        v.developer_fields = mesg.developer_fields.clone();

        for field in &mesg.fields {
            match field.num {
                254 => v.message_index = typedef::MessageIndex(field.value.as_u16()),
                253 => v.timestamp = typedef::DateTime(field.value.as_u32()),
                0 => v.event = typedef::Event(field.value.as_u8()),
                1 => v.event_type = typedef::EventType(field.value.as_u8()),
                2 => v.start_time = typedef::DateTime(field.value.as_u32()),
                3 => v.start_position_lat = field.value.as_i32(),
                4 => v.start_position_long = field.value.as_i32(),
                5 => v.sport = typedef::Sport(field.value.as_u8()),
                6 => v.sub_sport = typedef::SubSport(field.value.as_u8()),
                7 => v.total_elapsed_time = field.value.as_u32(),
                8 => v.total_timer_time = field.value.as_u32(),
                9 => v.total_distance = field.value.as_u32(),
                10 => v.total_cycles = field.value.as_u32(),
                11 => v.total_calories = field.value.as_u16(),
                13 => v.total_fat_calories = field.value.as_u16(),
                14 => v.avg_speed = field.value.as_u16(),
                15 => v.max_speed = field.value.as_u16(),
                16 => v.avg_heart_rate = field.value.as_u8(),
                17 => v.max_heart_rate = field.value.as_u8(),
                18 => v.avg_cadence = field.value.as_u8(),
                19 => v.max_cadence = field.value.as_u8(),
                20 => v.avg_power = field.value.as_u16(),
                21 => v.max_power = field.value.as_u16(),
                22 => v.total_ascent = field.value.as_u16(),
                23 => v.total_descent = field.value.as_u16(),
                24 => v.total_training_effect = field.value.as_u8(),
                25 => v.first_lap_index = field.value.as_u16(),
                26 => v.num_laps = field.value.as_u16(),
                27 => v.event_group = field.value.as_u8(),
                28 => v.trigger = typedef::SessionTrigger(field.value.as_u8()),
                29 => v.nec_lat = field.value.as_i32(),
                30 => v.nec_long = field.value.as_i32(),
                31 => v.swc_lat = field.value.as_i32(),
                32 => v.swc_long = field.value.as_i32(),
                33 => v.num_lengths = field.value.as_u16(),
                34 => v.normalized_power = field.value.as_u16(),
                35 => v.training_stress_score = field.value.as_u16(),
                36 => v.intensity_factor = field.value.as_u16(),
                37 => v.left_right_balance = typedef::LeftRightBalance100(field.value.as_u16()),
                38 => v.end_position_lat = field.value.as_i32(),
                39 => v.end_position_long = field.value.as_i32(),
                41 => v.avg_stroke_count = field.value.as_u32(),
                42 => v.avg_stroke_distance = field.value.as_u16(),
                43 => v.swim_stroke = typedef::SwimStroke(field.value.as_u8()),
                44 => v.pool_length = field.value.as_u16(),
                45 => v.threshold_power = field.value.as_u16(),
                46 => v.pool_length_unit = typedef::DisplayMeasure(field.value.as_u8()),
                47 => v.num_active_lengths = field.value.as_u16(),
                48 => v.total_work = field.value.as_u32(),
                49 => v.avg_altitude = field.value.as_u16(),
                50 => v.max_altitude = field.value.as_u16(),
                51 => v.gps_accuracy = field.value.as_u8(),
                52 => v.avg_grade = field.value.as_i16(),
                53 => v.avg_pos_grade = field.value.as_i16(),
                54 => v.avg_neg_grade = field.value.as_i16(),
                55 => v.max_pos_grade = field.value.as_i16(),
                56 => v.max_neg_grade = field.value.as_i16(),
                57 => v.avg_temperature = field.value.as_i8(),
                58 => v.max_temperature = field.value.as_i8(),
                59 => v.total_moving_time = field.value.as_u32(),
                60 => v.avg_pos_vertical_speed = field.value.as_i16(),
                61 => v.avg_neg_vertical_speed = field.value.as_i16(),
                62 => v.max_pos_vertical_speed = field.value.as_i16(),
                63 => v.max_neg_vertical_speed = field.value.as_i16(),
                64 => v.min_heart_rate = field.value.as_u8(),
                65 => v.time_in_hr_zone = field.value.to_vec_u32(),
                66 => v.time_in_speed_zone = field.value.to_vec_u32(),
                67 => v.time_in_cadence_zone = field.value.to_vec_u32(),
                68 => v.time_in_power_zone = field.value.to_vec_u32(),
                69 => v.avg_lap_time = field.value.as_u32(),
                70 => v.best_lap_index = field.value.as_u16(),
                71 => v.min_altitude = field.value.as_u16(),
                78 => v.active_time = field.value.as_u32(),
                82 => v.player_score = field.value.as_u16(),
                83 => v.opponent_score = field.value.as_u16(),
                84 => v.opponent_name = field.value.as_str().to_owned(),
                85 => v.stroke_count = field.value.to_vec_u16(),
                86 => v.zone_count = field.value.to_vec_u16(),
                87 => v.max_ball_speed = field.value.as_u16(),
                88 => v.avg_ball_speed = field.value.as_u16(),
                89 => v.avg_vertical_oscillation = field.value.as_u16(),
                90 => v.avg_stance_time_percent = field.value.as_u16(),
                91 => v.avg_stance_time = field.value.as_u16(),
                92 => v.avg_fractional_cadence = field.value.as_u8(),
                93 => v.max_fractional_cadence = field.value.as_u8(),
                94 => v.total_fractional_cycles = field.value.as_u8(),
                95 => v.avg_total_hemoglobin_conc = field.value.to_vec_u16(),
                96 => v.min_total_hemoglobin_conc = field.value.to_vec_u16(),
                97 => v.max_total_hemoglobin_conc = field.value.to_vec_u16(),
                98 => v.avg_saturated_hemoglobin_percent = field.value.to_vec_u16(),
                99 => v.min_saturated_hemoglobin_percent = field.value.to_vec_u16(),
                100 => v.max_saturated_hemoglobin_percent = field.value.to_vec_u16(),
                101 => v.avg_left_torque_effectiveness = field.value.as_u8(),
                102 => v.avg_right_torque_effectiveness = field.value.as_u8(),
                103 => v.avg_left_pedal_smoothness = field.value.as_u8(),
                104 => v.avg_right_pedal_smoothness = field.value.as_u8(),
                105 => v.avg_combined_pedal_smoothness = field.value.as_u8(),
                110 => v.sport_profile_name = field.value.as_str().to_owned(),
                111 => v.sport_index = field.value.as_u8(),
                112 => v.time_standing = field.value.as_u32(),
                113 => v.stand_count = field.value.as_u16(),
                114 => v.avg_left_pco = field.value.as_i8(),
                115 => v.avg_right_pco = field.value.as_i8(),
                116 => v.avg_left_power_phase = field.value.to_vec_u8(),
                117 => v.avg_left_power_phase_peak = field.value.to_vec_u8(),
                118 => v.avg_right_power_phase = field.value.to_vec_u8(),
                119 => v.avg_right_power_phase_peak = field.value.to_vec_u8(),
                120 => v.avg_power_position = field.value.to_vec_u16(),
                121 => v.max_power_position = field.value.to_vec_u16(),
                122 => v.avg_cadence_position = field.value.to_vec_u8(),
                123 => v.max_cadence_position = field.value.to_vec_u8(),
                124 => v.enhanced_avg_speed = field.value.as_u32(),
                125 => v.enhanced_max_speed = field.value.as_u32(),
                126 => v.enhanced_avg_altitude = field.value.as_u32(),
                127 => v.enhanced_min_altitude = field.value.as_u32(),
                128 => v.enhanced_max_altitude = field.value.as_u32(),
                129 => v.avg_lev_motor_power = field.value.as_u16(),
                130 => v.max_lev_motor_power = field.value.as_u16(),
                131 => v.lev_battery_consumption = field.value.as_u8(),
                132 => v.avg_vertical_ratio = field.value.as_u16(),
                133 => v.avg_stance_time_balance = field.value.as_u16(),
                134 => v.avg_step_length = field.value.as_u16(),
                137 => v.total_anaerobic_training_effect = field.value.as_u8(),
                139 => v.avg_vam = field.value.as_u16(),
                140 => v.avg_depth = field.value.as_u32(),
                141 => v.max_depth = field.value.as_u32(),
                142 => v.surface_interval = field.value.as_u32(),
                143 => v.start_cns = field.value.as_u8(),
                144 => v.end_cns = field.value.as_u8(),
                145 => v.start_n2 = field.value.as_u16(),
                146 => v.end_n2 = field.value.as_u16(),
                147 => v.avg_respiration_rate = field.value.as_u8(),
                148 => v.max_respiration_rate = field.value.as_u8(),
                149 => v.min_respiration_rate = field.value.as_u8(),
                150 => v.min_temperature = field.value.as_i8(),
                155 => v.o2_toxicity = field.value.as_u16(),
                156 => v.dive_number = field.value.as_u32(),
                168 => v.training_load_peak = field.value.as_i32(),
                169 => v.enhanced_avg_respiration_rate = field.value.as_u16(),
                170 => v.enhanced_max_respiration_rate = field.value.as_u16(),
                180 => v.enhanced_min_respiration_rate = field.value.as_u16(),
                181 => v.total_grit = field.value.as_f32(),
                182 => v.total_flow = field.value.as_f32(),
                183 => v.jump_count = field.value.as_u16(),
                186 => v.avg_grit = field.value.as_f32(),
                187 => v.avg_flow = field.value.as_f32(),
                192 => v.workout_feel = field.value.as_u8(),
                193 => v.workout_rpe = field.value.as_u8(),
                194 => v.avg_spo2 = field.value.as_u8(),
                195 => v.avg_stress = field.value.as_u8(),
                196 => v.metabolic_calories = field.value.as_u16(),
                197 => v.sdrr_hrv = field.value.as_u8(),
                198 => v.rmssd_hrv = field.value.as_u8(),
                199 => v.total_fractional_ascent = field.value.as_u8(),
                200 => v.total_fractional_descent = field.value.as_u8(),
                208 => v.avg_core_temperature = field.value.as_u16(),
                209 => v.min_core_temperature = field.value.as_u16(),
                210 => v.max_core_temperature = field.value.as_u16(),
                _ => {
                    v.unknown_fields.push(field.clone());
                    continue;
                }
            };
            if field.is_expanded && field.num < 181 {
                v.state[field.num as usize >> 3] |= 1 << (field.num & 7)
            }
        }

        v
    }
}

impl From<Session> for Message {
    fn from(m: Session) -> Self {
        let mut fields =
            Vec::<Field>::with_capacity(m.count_valid_fields() + m.unknown_fields.len());

        if m.message_index.0 != u16::MAX {
            fields.push(Field {
                num: 254,
                base_type: FitBaseType::UINT16,
                value: Value::Uint16(m.message_index.0),
                is_expanded: false,
            });
        };
        if m.timestamp.0 != u32::MAX {
            fields.push(Field {
                num: 253,
                base_type: FitBaseType::UINT32,
                value: Value::Uint32(m.timestamp.0),
                is_expanded: false,
            });
        };
        if m.event.0 != u8::MAX {
            fields.push(Field {
                num: 0,
                base_type: FitBaseType::ENUM,
                value: Value::Uint8(m.event.0),
                is_expanded: false,
            });
        };
        if m.event_type.0 != u8::MAX {
            fields.push(Field {
                num: 1,
                base_type: FitBaseType::ENUM,
                value: Value::Uint8(m.event_type.0),
                is_expanded: false,
            });
        };
        if m.start_time.0 != u32::MAX {
            fields.push(Field {
                num: 2,
                base_type: FitBaseType::UINT32,
                value: Value::Uint32(m.start_time.0),
                is_expanded: false,
            });
        };
        if m.start_position_lat != i32::MAX {
            fields.push(Field {
                num: 3,
                base_type: FitBaseType::SINT32,
                value: Value::Int32(m.start_position_lat),
                is_expanded: false,
            });
        };
        if m.start_position_long != i32::MAX {
            fields.push(Field {
                num: 4,
                base_type: FitBaseType::SINT32,
                value: Value::Int32(m.start_position_long),
                is_expanded: false,
            });
        };
        if m.sport.0 != u8::MAX {
            fields.push(Field {
                num: 5,
                base_type: FitBaseType::ENUM,
                value: Value::Uint8(m.sport.0),
                is_expanded: false,
            });
        };
        if m.sub_sport.0 != u8::MAX {
            fields.push(Field {
                num: 6,
                base_type: FitBaseType::ENUM,
                value: Value::Uint8(m.sub_sport.0),
                is_expanded: false,
            });
        };
        if m.total_elapsed_time != u32::MAX {
            fields.push(Field {
                num: 7,
                base_type: FitBaseType::UINT32,
                value: Value::Uint32(m.total_elapsed_time),
                is_expanded: false,
            });
        };
        if m.total_timer_time != u32::MAX {
            fields.push(Field {
                num: 8,
                base_type: FitBaseType::UINT32,
                value: Value::Uint32(m.total_timer_time),
                is_expanded: false,
            });
        };
        if m.total_distance != u32::MAX {
            fields.push(Field {
                num: 9,
                base_type: FitBaseType::UINT32,
                value: Value::Uint32(m.total_distance),
                is_expanded: false,
            });
        };
        if m.total_cycles != u32::MAX {
            fields.push(Field {
                num: 10,
                base_type: FitBaseType::UINT32,
                value: Value::Uint32(m.total_cycles),
                is_expanded: false,
            });
        };
        if m.total_calories != u16::MAX {
            fields.push(Field {
                num: 11,
                base_type: FitBaseType::UINT16,
                value: Value::Uint16(m.total_calories),
                is_expanded: false,
            });
        };
        if m.total_fat_calories != u16::MAX {
            fields.push(Field {
                num: 13,
                base_type: FitBaseType::UINT16,
                value: Value::Uint16(m.total_fat_calories),
                is_expanded: false,
            });
        };
        if m.avg_speed != u16::MAX {
            fields.push(Field {
                num: 14,
                base_type: FitBaseType::UINT16,
                value: Value::Uint16(m.avg_speed),
                is_expanded: false,
            });
        };
        if m.max_speed != u16::MAX {
            fields.push(Field {
                num: 15,
                base_type: FitBaseType::UINT16,
                value: Value::Uint16(m.max_speed),
                is_expanded: false,
            });
        };
        if m.avg_heart_rate != u8::MAX {
            fields.push(Field {
                num: 16,
                base_type: FitBaseType::UINT8,
                value: Value::Uint8(m.avg_heart_rate),
                is_expanded: false,
            });
        };
        if m.max_heart_rate != u8::MAX {
            fields.push(Field {
                num: 17,
                base_type: FitBaseType::UINT8,
                value: Value::Uint8(m.max_heart_rate),
                is_expanded: false,
            });
        };
        if m.avg_cadence != u8::MAX {
            fields.push(Field {
                num: 18,
                base_type: FitBaseType::UINT8,
                value: Value::Uint8(m.avg_cadence),
                is_expanded: false,
            });
        };
        if m.max_cadence != u8::MAX {
            fields.push(Field {
                num: 19,
                base_type: FitBaseType::UINT8,
                value: Value::Uint8(m.max_cadence),
                is_expanded: false,
            });
        };
        if m.avg_power != u16::MAX {
            fields.push(Field {
                num: 20,
                base_type: FitBaseType::UINT16,
                value: Value::Uint16(m.avg_power),
                is_expanded: false,
            });
        };
        if m.max_power != u16::MAX {
            fields.push(Field {
                num: 21,
                base_type: FitBaseType::UINT16,
                value: Value::Uint16(m.max_power),
                is_expanded: false,
            });
        };
        if m.total_ascent != u16::MAX {
            fields.push(Field {
                num: 22,
                base_type: FitBaseType::UINT16,
                value: Value::Uint16(m.total_ascent),
                is_expanded: false,
            });
        };
        if m.total_descent != u16::MAX {
            fields.push(Field {
                num: 23,
                base_type: FitBaseType::UINT16,
                value: Value::Uint16(m.total_descent),
                is_expanded: false,
            });
        };
        if m.total_training_effect != u8::MAX {
            fields.push(Field {
                num: 24,
                base_type: FitBaseType::UINT8,
                value: Value::Uint8(m.total_training_effect),
                is_expanded: false,
            });
        };
        if m.first_lap_index != u16::MAX {
            fields.push(Field {
                num: 25,
                base_type: FitBaseType::UINT16,
                value: Value::Uint16(m.first_lap_index),
                is_expanded: false,
            });
        };
        if m.num_laps != u16::MAX {
            fields.push(Field {
                num: 26,
                base_type: FitBaseType::UINT16,
                value: Value::Uint16(m.num_laps),
                is_expanded: false,
            });
        };
        if m.event_group != u8::MAX {
            fields.push(Field {
                num: 27,
                base_type: FitBaseType::UINT8,
                value: Value::Uint8(m.event_group),
                is_expanded: false,
            });
        };
        if m.trigger.0 != u8::MAX {
            fields.push(Field {
                num: 28,
                base_type: FitBaseType::ENUM,
                value: Value::Uint8(m.trigger.0),
                is_expanded: false,
            });
        };
        if m.nec_lat != i32::MAX {
            fields.push(Field {
                num: 29,
                base_type: FitBaseType::SINT32,
                value: Value::Int32(m.nec_lat),
                is_expanded: false,
            });
        };
        if m.nec_long != i32::MAX {
            fields.push(Field {
                num: 30,
                base_type: FitBaseType::SINT32,
                value: Value::Int32(m.nec_long),
                is_expanded: false,
            });
        };
        if m.swc_lat != i32::MAX {
            fields.push(Field {
                num: 31,
                base_type: FitBaseType::SINT32,
                value: Value::Int32(m.swc_lat),
                is_expanded: false,
            });
        };
        if m.swc_long != i32::MAX {
            fields.push(Field {
                num: 32,
                base_type: FitBaseType::SINT32,
                value: Value::Int32(m.swc_long),
                is_expanded: false,
            });
        };
        if m.num_lengths != u16::MAX {
            fields.push(Field {
                num: 33,
                base_type: FitBaseType::UINT16,
                value: Value::Uint16(m.num_lengths),
                is_expanded: false,
            });
        };
        if m.normalized_power != u16::MAX {
            fields.push(Field {
                num: 34,
                base_type: FitBaseType::UINT16,
                value: Value::Uint16(m.normalized_power),
                is_expanded: false,
            });
        };
        if m.training_stress_score != u16::MAX {
            fields.push(Field {
                num: 35,
                base_type: FitBaseType::UINT16,
                value: Value::Uint16(m.training_stress_score),
                is_expanded: false,
            });
        };
        if m.intensity_factor != u16::MAX {
            fields.push(Field {
                num: 36,
                base_type: FitBaseType::UINT16,
                value: Value::Uint16(m.intensity_factor),
                is_expanded: false,
            });
        };
        if m.left_right_balance.0 != u16::MAX {
            fields.push(Field {
                num: 37,
                base_type: FitBaseType::UINT16,
                value: Value::Uint16(m.left_right_balance.0),
                is_expanded: false,
            });
        };
        if m.end_position_lat != i32::MAX {
            fields.push(Field {
                num: 38,
                base_type: FitBaseType::SINT32,
                value: Value::Int32(m.end_position_lat),
                is_expanded: false,
            });
        };
        if m.end_position_long != i32::MAX {
            fields.push(Field {
                num: 39,
                base_type: FitBaseType::SINT32,
                value: Value::Int32(m.end_position_long),
                is_expanded: false,
            });
        };
        if m.avg_stroke_count != u32::MAX {
            fields.push(Field {
                num: 41,
                base_type: FitBaseType::UINT32,
                value: Value::Uint32(m.avg_stroke_count),
                is_expanded: false,
            });
        };
        if m.avg_stroke_distance != u16::MAX {
            fields.push(Field {
                num: 42,
                base_type: FitBaseType::UINT16,
                value: Value::Uint16(m.avg_stroke_distance),
                is_expanded: false,
            });
        };
        if m.swim_stroke.0 != u8::MAX {
            fields.push(Field {
                num: 43,
                base_type: FitBaseType::ENUM,
                value: Value::Uint8(m.swim_stroke.0),
                is_expanded: false,
            });
        };
        if m.pool_length != u16::MAX {
            fields.push(Field {
                num: 44,
                base_type: FitBaseType::UINT16,
                value: Value::Uint16(m.pool_length),
                is_expanded: false,
            });
        };
        if m.threshold_power != u16::MAX {
            fields.push(Field {
                num: 45,
                base_type: FitBaseType::UINT16,
                value: Value::Uint16(m.threshold_power),
                is_expanded: false,
            });
        };
        if m.pool_length_unit.0 != u8::MAX {
            fields.push(Field {
                num: 46,
                base_type: FitBaseType::ENUM,
                value: Value::Uint8(m.pool_length_unit.0),
                is_expanded: false,
            });
        };
        if m.num_active_lengths != u16::MAX {
            fields.push(Field {
                num: 47,
                base_type: FitBaseType::UINT16,
                value: Value::Uint16(m.num_active_lengths),
                is_expanded: false,
            });
        };
        if m.total_work != u32::MAX {
            fields.push(Field {
                num: 48,
                base_type: FitBaseType::UINT32,
                value: Value::Uint32(m.total_work),
                is_expanded: false,
            });
        };
        if m.avg_altitude != u16::MAX {
            fields.push(Field {
                num: 49,
                base_type: FitBaseType::UINT16,
                value: Value::Uint16(m.avg_altitude),
                is_expanded: false,
            });
        };
        if m.max_altitude != u16::MAX {
            fields.push(Field {
                num: 50,
                base_type: FitBaseType::UINT16,
                value: Value::Uint16(m.max_altitude),
                is_expanded: false,
            });
        };
        if m.gps_accuracy != u8::MAX {
            fields.push(Field {
                num: 51,
                base_type: FitBaseType::UINT8,
                value: Value::Uint8(m.gps_accuracy),
                is_expanded: false,
            });
        };
        if m.avg_grade != i16::MAX {
            fields.push(Field {
                num: 52,
                base_type: FitBaseType::SINT16,
                value: Value::Int16(m.avg_grade),
                is_expanded: false,
            });
        };
        if m.avg_pos_grade != i16::MAX {
            fields.push(Field {
                num: 53,
                base_type: FitBaseType::SINT16,
                value: Value::Int16(m.avg_pos_grade),
                is_expanded: false,
            });
        };
        if m.avg_neg_grade != i16::MAX {
            fields.push(Field {
                num: 54,
                base_type: FitBaseType::SINT16,
                value: Value::Int16(m.avg_neg_grade),
                is_expanded: false,
            });
        };
        if m.max_pos_grade != i16::MAX {
            fields.push(Field {
                num: 55,
                base_type: FitBaseType::SINT16,
                value: Value::Int16(m.max_pos_grade),
                is_expanded: false,
            });
        };
        if m.max_neg_grade != i16::MAX {
            fields.push(Field {
                num: 56,
                base_type: FitBaseType::SINT16,
                value: Value::Int16(m.max_neg_grade),
                is_expanded: false,
            });
        };
        if m.avg_temperature != i8::MAX {
            fields.push(Field {
                num: 57,
                base_type: FitBaseType::SINT8,
                value: Value::Int8(m.avg_temperature),
                is_expanded: false,
            });
        };
        if m.max_temperature != i8::MAX {
            fields.push(Field {
                num: 58,
                base_type: FitBaseType::SINT8,
                value: Value::Int8(m.max_temperature),
                is_expanded: false,
            });
        };
        if m.total_moving_time != u32::MAX {
            fields.push(Field {
                num: 59,
                base_type: FitBaseType::UINT32,
                value: Value::Uint32(m.total_moving_time),
                is_expanded: false,
            });
        };
        if m.avg_pos_vertical_speed != i16::MAX {
            fields.push(Field {
                num: 60,
                base_type: FitBaseType::SINT16,
                value: Value::Int16(m.avg_pos_vertical_speed),
                is_expanded: false,
            });
        };
        if m.avg_neg_vertical_speed != i16::MAX {
            fields.push(Field {
                num: 61,
                base_type: FitBaseType::SINT16,
                value: Value::Int16(m.avg_neg_vertical_speed),
                is_expanded: false,
            });
        };
        if m.max_pos_vertical_speed != i16::MAX {
            fields.push(Field {
                num: 62,
                base_type: FitBaseType::SINT16,
                value: Value::Int16(m.max_pos_vertical_speed),
                is_expanded: false,
            });
        };
        if m.max_neg_vertical_speed != i16::MAX {
            fields.push(Field {
                num: 63,
                base_type: FitBaseType::SINT16,
                value: Value::Int16(m.max_neg_vertical_speed),
                is_expanded: false,
            });
        };
        if m.min_heart_rate != u8::MAX {
            fields.push(Field {
                num: 64,
                base_type: FitBaseType::UINT8,
                value: Value::Uint8(m.min_heart_rate),
                is_expanded: false,
            });
        };
        if !m.time_in_hr_zone.is_empty() {
            fields.push(Field {
                num: 65,
                base_type: FitBaseType::UINT32,
                value: Value::VecUint32(m.time_in_hr_zone),
                is_expanded: false,
            });
        };
        if !m.time_in_speed_zone.is_empty() {
            fields.push(Field {
                num: 66,
                base_type: FitBaseType::UINT32,
                value: Value::VecUint32(m.time_in_speed_zone),
                is_expanded: false,
            });
        };
        if !m.time_in_cadence_zone.is_empty() {
            fields.push(Field {
                num: 67,
                base_type: FitBaseType::UINT32,
                value: Value::VecUint32(m.time_in_cadence_zone),
                is_expanded: false,
            });
        };
        if !m.time_in_power_zone.is_empty() {
            fields.push(Field {
                num: 68,
                base_type: FitBaseType::UINT32,
                value: Value::VecUint32(m.time_in_power_zone),
                is_expanded: false,
            });
        };
        if m.avg_lap_time != u32::MAX {
            fields.push(Field {
                num: 69,
                base_type: FitBaseType::UINT32,
                value: Value::Uint32(m.avg_lap_time),
                is_expanded: false,
            });
        };
        if m.best_lap_index != u16::MAX {
            fields.push(Field {
                num: 70,
                base_type: FitBaseType::UINT16,
                value: Value::Uint16(m.best_lap_index),
                is_expanded: false,
            });
        };
        if m.min_altitude != u16::MAX {
            fields.push(Field {
                num: 71,
                base_type: FitBaseType::UINT16,
                value: Value::Uint16(m.min_altitude),
                is_expanded: false,
            });
        };
        if m.active_time != u32::MAX {
            fields.push(Field {
                num: 78,
                base_type: FitBaseType::UINT32,
                value: Value::Uint32(m.active_time),
                is_expanded: false,
            });
        };
        if m.player_score != u16::MAX {
            fields.push(Field {
                num: 82,
                base_type: FitBaseType::UINT16,
                value: Value::Uint16(m.player_score),
                is_expanded: false,
            });
        };
        if m.opponent_score != u16::MAX {
            fields.push(Field {
                num: 83,
                base_type: FitBaseType::UINT16,
                value: Value::Uint16(m.opponent_score),
                is_expanded: false,
            });
        };
        if !m.opponent_name.is_empty() {
            fields.push(Field {
                num: 84,
                base_type: FitBaseType::STRING,
                value: Value::String(m.opponent_name),
                is_expanded: false,
            });
        };
        if !m.stroke_count.is_empty() {
            fields.push(Field {
                num: 85,
                base_type: FitBaseType::UINT16,
                value: Value::VecUint16(m.stroke_count),
                is_expanded: false,
            });
        };
        if !m.zone_count.is_empty() {
            fields.push(Field {
                num: 86,
                base_type: FitBaseType::UINT16,
                value: Value::VecUint16(m.zone_count),
                is_expanded: false,
            });
        };
        if m.max_ball_speed != u16::MAX {
            fields.push(Field {
                num: 87,
                base_type: FitBaseType::UINT16,
                value: Value::Uint16(m.max_ball_speed),
                is_expanded: false,
            });
        };
        if m.avg_ball_speed != u16::MAX {
            fields.push(Field {
                num: 88,
                base_type: FitBaseType::UINT16,
                value: Value::Uint16(m.avg_ball_speed),
                is_expanded: false,
            });
        };
        if m.avg_vertical_oscillation != u16::MAX {
            fields.push(Field {
                num: 89,
                base_type: FitBaseType::UINT16,
                value: Value::Uint16(m.avg_vertical_oscillation),
                is_expanded: false,
            });
        };
        if m.avg_stance_time_percent != u16::MAX {
            fields.push(Field {
                num: 90,
                base_type: FitBaseType::UINT16,
                value: Value::Uint16(m.avg_stance_time_percent),
                is_expanded: false,
            });
        };
        if m.avg_stance_time != u16::MAX {
            fields.push(Field {
                num: 91,
                base_type: FitBaseType::UINT16,
                value: Value::Uint16(m.avg_stance_time),
                is_expanded: false,
            });
        };
        if m.avg_fractional_cadence != u8::MAX {
            fields.push(Field {
                num: 92,
                base_type: FitBaseType::UINT8,
                value: Value::Uint8(m.avg_fractional_cadence),
                is_expanded: false,
            });
        };
        if m.max_fractional_cadence != u8::MAX {
            fields.push(Field {
                num: 93,
                base_type: FitBaseType::UINT8,
                value: Value::Uint8(m.max_fractional_cadence),
                is_expanded: false,
            });
        };
        if m.total_fractional_cycles != u8::MAX {
            fields.push(Field {
                num: 94,
                base_type: FitBaseType::UINT8,
                value: Value::Uint8(m.total_fractional_cycles),
                is_expanded: false,
            });
        };
        if !m.avg_total_hemoglobin_conc.is_empty() {
            fields.push(Field {
                num: 95,
                base_type: FitBaseType::UINT16,
                value: Value::VecUint16(m.avg_total_hemoglobin_conc),
                is_expanded: false,
            });
        };
        if !m.min_total_hemoglobin_conc.is_empty() {
            fields.push(Field {
                num: 96,
                base_type: FitBaseType::UINT16,
                value: Value::VecUint16(m.min_total_hemoglobin_conc),
                is_expanded: false,
            });
        };
        if !m.max_total_hemoglobin_conc.is_empty() {
            fields.push(Field {
                num: 97,
                base_type: FitBaseType::UINT16,
                value: Value::VecUint16(m.max_total_hemoglobin_conc),
                is_expanded: false,
            });
        };
        if !m.avg_saturated_hemoglobin_percent.is_empty() {
            fields.push(Field {
                num: 98,
                base_type: FitBaseType::UINT16,
                value: Value::VecUint16(m.avg_saturated_hemoglobin_percent),
                is_expanded: false,
            });
        };
        if !m.min_saturated_hemoglobin_percent.is_empty() {
            fields.push(Field {
                num: 99,
                base_type: FitBaseType::UINT16,
                value: Value::VecUint16(m.min_saturated_hemoglobin_percent),
                is_expanded: false,
            });
        };
        if !m.max_saturated_hemoglobin_percent.is_empty() {
            fields.push(Field {
                num: 100,
                base_type: FitBaseType::UINT16,
                value: Value::VecUint16(m.max_saturated_hemoglobin_percent),
                is_expanded: false,
            });
        };
        if m.avg_left_torque_effectiveness != u8::MAX {
            fields.push(Field {
                num: 101,
                base_type: FitBaseType::UINT8,
                value: Value::Uint8(m.avg_left_torque_effectiveness),
                is_expanded: false,
            });
        };
        if m.avg_right_torque_effectiveness != u8::MAX {
            fields.push(Field {
                num: 102,
                base_type: FitBaseType::UINT8,
                value: Value::Uint8(m.avg_right_torque_effectiveness),
                is_expanded: false,
            });
        };
        if m.avg_left_pedal_smoothness != u8::MAX {
            fields.push(Field {
                num: 103,
                base_type: FitBaseType::UINT8,
                value: Value::Uint8(m.avg_left_pedal_smoothness),
                is_expanded: false,
            });
        };
        if m.avg_right_pedal_smoothness != u8::MAX {
            fields.push(Field {
                num: 104,
                base_type: FitBaseType::UINT8,
                value: Value::Uint8(m.avg_right_pedal_smoothness),
                is_expanded: false,
            });
        };
        if m.avg_combined_pedal_smoothness != u8::MAX {
            fields.push(Field {
                num: 105,
                base_type: FitBaseType::UINT8,
                value: Value::Uint8(m.avg_combined_pedal_smoothness),
                is_expanded: false,
            });
        };
        if !m.sport_profile_name.is_empty() {
            fields.push(Field {
                num: 110,
                base_type: FitBaseType::STRING,
                value: Value::String(m.sport_profile_name),
                is_expanded: false,
            });
        };
        if m.sport_index != u8::MAX {
            fields.push(Field {
                num: 111,
                base_type: FitBaseType::UINT8,
                value: Value::Uint8(m.sport_index),
                is_expanded: false,
            });
        };
        if m.time_standing != u32::MAX {
            fields.push(Field {
                num: 112,
                base_type: FitBaseType::UINT32,
                value: Value::Uint32(m.time_standing),
                is_expanded: false,
            });
        };
        if m.stand_count != u16::MAX {
            fields.push(Field {
                num: 113,
                base_type: FitBaseType::UINT16,
                value: Value::Uint16(m.stand_count),
                is_expanded: false,
            });
        };
        if m.avg_left_pco != i8::MAX {
            fields.push(Field {
                num: 114,
                base_type: FitBaseType::SINT8,
                value: Value::Int8(m.avg_left_pco),
                is_expanded: false,
            });
        };
        if m.avg_right_pco != i8::MAX {
            fields.push(Field {
                num: 115,
                base_type: FitBaseType::SINT8,
                value: Value::Int8(m.avg_right_pco),
                is_expanded: false,
            });
        };
        if !m.avg_left_power_phase.is_empty() {
            fields.push(Field {
                num: 116,
                base_type: FitBaseType::UINT8,
                value: Value::VecUint8(m.avg_left_power_phase),
                is_expanded: false,
            });
        };
        if !m.avg_left_power_phase_peak.is_empty() {
            fields.push(Field {
                num: 117,
                base_type: FitBaseType::UINT8,
                value: Value::VecUint8(m.avg_left_power_phase_peak),
                is_expanded: false,
            });
        };
        if !m.avg_right_power_phase.is_empty() {
            fields.push(Field {
                num: 118,
                base_type: FitBaseType::UINT8,
                value: Value::VecUint8(m.avg_right_power_phase),
                is_expanded: false,
            });
        };
        if !m.avg_right_power_phase_peak.is_empty() {
            fields.push(Field {
                num: 119,
                base_type: FitBaseType::UINT8,
                value: Value::VecUint8(m.avg_right_power_phase_peak),
                is_expanded: false,
            });
        };
        if !m.avg_power_position.is_empty() {
            fields.push(Field {
                num: 120,
                base_type: FitBaseType::UINT16,
                value: Value::VecUint16(m.avg_power_position),
                is_expanded: false,
            });
        };
        if !m.max_power_position.is_empty() {
            fields.push(Field {
                num: 121,
                base_type: FitBaseType::UINT16,
                value: Value::VecUint16(m.max_power_position),
                is_expanded: false,
            });
        };
        if !m.avg_cadence_position.is_empty() {
            fields.push(Field {
                num: 122,
                base_type: FitBaseType::UINT8,
                value: Value::VecUint8(m.avg_cadence_position),
                is_expanded: false,
            });
        };
        if !m.max_cadence_position.is_empty() {
            fields.push(Field {
                num: 123,
                base_type: FitBaseType::UINT8,
                value: Value::VecUint8(m.max_cadence_position),
                is_expanded: false,
            });
        };
        if m.enhanced_avg_speed != u32::MAX {
            fields.push(Field {
                num: 124,
                base_type: FitBaseType::UINT32,
                value: Value::Uint32(m.enhanced_avg_speed),
                is_expanded: is_expanded(&m.state, 124),
            });
        };
        if m.enhanced_max_speed != u32::MAX {
            fields.push(Field {
                num: 125,
                base_type: FitBaseType::UINT32,
                value: Value::Uint32(m.enhanced_max_speed),
                is_expanded: is_expanded(&m.state, 125),
            });
        };
        if m.enhanced_avg_altitude != u32::MAX {
            fields.push(Field {
                num: 126,
                base_type: FitBaseType::UINT32,
                value: Value::Uint32(m.enhanced_avg_altitude),
                is_expanded: is_expanded(&m.state, 126),
            });
        };
        if m.enhanced_min_altitude != u32::MAX {
            fields.push(Field {
                num: 127,
                base_type: FitBaseType::UINT32,
                value: Value::Uint32(m.enhanced_min_altitude),
                is_expanded: is_expanded(&m.state, 127),
            });
        };
        if m.enhanced_max_altitude != u32::MAX {
            fields.push(Field {
                num: 128,
                base_type: FitBaseType::UINT32,
                value: Value::Uint32(m.enhanced_max_altitude),
                is_expanded: is_expanded(&m.state, 128),
            });
        };
        if m.avg_lev_motor_power != u16::MAX {
            fields.push(Field {
                num: 129,
                base_type: FitBaseType::UINT16,
                value: Value::Uint16(m.avg_lev_motor_power),
                is_expanded: false,
            });
        };
        if m.max_lev_motor_power != u16::MAX {
            fields.push(Field {
                num: 130,
                base_type: FitBaseType::UINT16,
                value: Value::Uint16(m.max_lev_motor_power),
                is_expanded: false,
            });
        };
        if m.lev_battery_consumption != u8::MAX {
            fields.push(Field {
                num: 131,
                base_type: FitBaseType::UINT8,
                value: Value::Uint8(m.lev_battery_consumption),
                is_expanded: false,
            });
        };
        if m.avg_vertical_ratio != u16::MAX {
            fields.push(Field {
                num: 132,
                base_type: FitBaseType::UINT16,
                value: Value::Uint16(m.avg_vertical_ratio),
                is_expanded: false,
            });
        };
        if m.avg_stance_time_balance != u16::MAX {
            fields.push(Field {
                num: 133,
                base_type: FitBaseType::UINT16,
                value: Value::Uint16(m.avg_stance_time_balance),
                is_expanded: false,
            });
        };
        if m.avg_step_length != u16::MAX {
            fields.push(Field {
                num: 134,
                base_type: FitBaseType::UINT16,
                value: Value::Uint16(m.avg_step_length),
                is_expanded: false,
            });
        };
        if m.total_anaerobic_training_effect != u8::MAX {
            fields.push(Field {
                num: 137,
                base_type: FitBaseType::UINT8,
                value: Value::Uint8(m.total_anaerobic_training_effect),
                is_expanded: false,
            });
        };
        if m.avg_vam != u16::MAX {
            fields.push(Field {
                num: 139,
                base_type: FitBaseType::UINT16,
                value: Value::Uint16(m.avg_vam),
                is_expanded: false,
            });
        };
        if m.avg_depth != u32::MAX {
            fields.push(Field {
                num: 140,
                base_type: FitBaseType::UINT32,
                value: Value::Uint32(m.avg_depth),
                is_expanded: false,
            });
        };
        if m.max_depth != u32::MAX {
            fields.push(Field {
                num: 141,
                base_type: FitBaseType::UINT32,
                value: Value::Uint32(m.max_depth),
                is_expanded: false,
            });
        };
        if m.surface_interval != u32::MAX {
            fields.push(Field {
                num: 142,
                base_type: FitBaseType::UINT32,
                value: Value::Uint32(m.surface_interval),
                is_expanded: false,
            });
        };
        if m.start_cns != u8::MAX {
            fields.push(Field {
                num: 143,
                base_type: FitBaseType::UINT8,
                value: Value::Uint8(m.start_cns),
                is_expanded: false,
            });
        };
        if m.end_cns != u8::MAX {
            fields.push(Field {
                num: 144,
                base_type: FitBaseType::UINT8,
                value: Value::Uint8(m.end_cns),
                is_expanded: false,
            });
        };
        if m.start_n2 != u16::MAX {
            fields.push(Field {
                num: 145,
                base_type: FitBaseType::UINT16,
                value: Value::Uint16(m.start_n2),
                is_expanded: false,
            });
        };
        if m.end_n2 != u16::MAX {
            fields.push(Field {
                num: 146,
                base_type: FitBaseType::UINT16,
                value: Value::Uint16(m.end_n2),
                is_expanded: false,
            });
        };
        if m.avg_respiration_rate != u8::MAX {
            fields.push(Field {
                num: 147,
                base_type: FitBaseType::UINT8,
                value: Value::Uint8(m.avg_respiration_rate),
                is_expanded: false,
            });
        };
        if m.max_respiration_rate != u8::MAX {
            fields.push(Field {
                num: 148,
                base_type: FitBaseType::UINT8,
                value: Value::Uint8(m.max_respiration_rate),
                is_expanded: false,
            });
        };
        if m.min_respiration_rate != u8::MAX {
            fields.push(Field {
                num: 149,
                base_type: FitBaseType::UINT8,
                value: Value::Uint8(m.min_respiration_rate),
                is_expanded: false,
            });
        };
        if m.min_temperature != i8::MAX {
            fields.push(Field {
                num: 150,
                base_type: FitBaseType::SINT8,
                value: Value::Int8(m.min_temperature),
                is_expanded: false,
            });
        };
        if m.o2_toxicity != u16::MAX {
            fields.push(Field {
                num: 155,
                base_type: FitBaseType::UINT16,
                value: Value::Uint16(m.o2_toxicity),
                is_expanded: false,
            });
        };
        if m.dive_number != u32::MAX {
            fields.push(Field {
                num: 156,
                base_type: FitBaseType::UINT32,
                value: Value::Uint32(m.dive_number),
                is_expanded: false,
            });
        };
        if m.training_load_peak != i32::MAX {
            fields.push(Field {
                num: 168,
                base_type: FitBaseType::SINT32,
                value: Value::Int32(m.training_load_peak),
                is_expanded: false,
            });
        };
        if m.enhanced_avg_respiration_rate != u16::MAX {
            fields.push(Field {
                num: 169,
                base_type: FitBaseType::UINT16,
                value: Value::Uint16(m.enhanced_avg_respiration_rate),
                is_expanded: is_expanded(&m.state, 169),
            });
        };
        if m.enhanced_max_respiration_rate != u16::MAX {
            fields.push(Field {
                num: 170,
                base_type: FitBaseType::UINT16,
                value: Value::Uint16(m.enhanced_max_respiration_rate),
                is_expanded: is_expanded(&m.state, 170),
            });
        };
        if m.enhanced_min_respiration_rate != u16::MAX {
            fields.push(Field {
                num: 180,
                base_type: FitBaseType::UINT16,
                value: Value::Uint16(m.enhanced_min_respiration_rate),
                is_expanded: is_expanded(&m.state, 180),
            });
        };
        if m.total_grit.to_bits() != u32::MAX {
            fields.push(Field {
                num: 181,
                base_type: FitBaseType::FLOAT32,
                value: Value::Float32(m.total_grit),
                is_expanded: false,
            });
        };
        if m.total_flow.to_bits() != u32::MAX {
            fields.push(Field {
                num: 182,
                base_type: FitBaseType::FLOAT32,
                value: Value::Float32(m.total_flow),
                is_expanded: false,
            });
        };
        if m.jump_count != u16::MAX {
            fields.push(Field {
                num: 183,
                base_type: FitBaseType::UINT16,
                value: Value::Uint16(m.jump_count),
                is_expanded: false,
            });
        };
        if m.avg_grit.to_bits() != u32::MAX {
            fields.push(Field {
                num: 186,
                base_type: FitBaseType::FLOAT32,
                value: Value::Float32(m.avg_grit),
                is_expanded: false,
            });
        };
        if m.avg_flow.to_bits() != u32::MAX {
            fields.push(Field {
                num: 187,
                base_type: FitBaseType::FLOAT32,
                value: Value::Float32(m.avg_flow),
                is_expanded: false,
            });
        };
        if m.workout_feel != u8::MAX {
            fields.push(Field {
                num: 192,
                base_type: FitBaseType::UINT8,
                value: Value::Uint8(m.workout_feel),
                is_expanded: false,
            });
        };
        if m.workout_rpe != u8::MAX {
            fields.push(Field {
                num: 193,
                base_type: FitBaseType::UINT8,
                value: Value::Uint8(m.workout_rpe),
                is_expanded: false,
            });
        };
        if m.avg_spo2 != u8::MAX {
            fields.push(Field {
                num: 194,
                base_type: FitBaseType::UINT8,
                value: Value::Uint8(m.avg_spo2),
                is_expanded: false,
            });
        };
        if m.avg_stress != u8::MAX {
            fields.push(Field {
                num: 195,
                base_type: FitBaseType::UINT8,
                value: Value::Uint8(m.avg_stress),
                is_expanded: false,
            });
        };
        if m.metabolic_calories != u16::MAX {
            fields.push(Field {
                num: 196,
                base_type: FitBaseType::UINT16,
                value: Value::Uint16(m.metabolic_calories),
                is_expanded: false,
            });
        };
        if m.sdrr_hrv != u8::MAX {
            fields.push(Field {
                num: 197,
                base_type: FitBaseType::UINT8,
                value: Value::Uint8(m.sdrr_hrv),
                is_expanded: false,
            });
        };
        if m.rmssd_hrv != u8::MAX {
            fields.push(Field {
                num: 198,
                base_type: FitBaseType::UINT8,
                value: Value::Uint8(m.rmssd_hrv),
                is_expanded: false,
            });
        };
        if m.total_fractional_ascent != u8::MAX {
            fields.push(Field {
                num: 199,
                base_type: FitBaseType::UINT8,
                value: Value::Uint8(m.total_fractional_ascent),
                is_expanded: false,
            });
        };
        if m.total_fractional_descent != u8::MAX {
            fields.push(Field {
                num: 200,
                base_type: FitBaseType::UINT8,
                value: Value::Uint8(m.total_fractional_descent),
                is_expanded: false,
            });
        };
        if m.avg_core_temperature != u16::MAX {
            fields.push(Field {
                num: 208,
                base_type: FitBaseType::UINT16,
                value: Value::Uint16(m.avg_core_temperature),
                is_expanded: false,
            });
        };
        if m.min_core_temperature != u16::MAX {
            fields.push(Field {
                num: 209,
                base_type: FitBaseType::UINT16,
                value: Value::Uint16(m.min_core_temperature),
                is_expanded: false,
            });
        };
        if m.max_core_temperature != u16::MAX {
            fields.push(Field {
                num: 210,
                base_type: FitBaseType::UINT16,
                value: Value::Uint16(m.max_core_temperature),
                is_expanded: false,
            });
        };

        fields.extend_from_slice(&m.unknown_fields);

        Self {
            header: 0,
            num: typedef::MesgNum::SESSION,
            fields,
            developer_fields: m.developer_fields,
        }
    }
}

#[cfg(feature = "serde")]
impl Serialize for Session {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
        let n = self.count_valid_fields() + 2;
        let mut state = serializer.serialize_struct("Session", n)?;
        if self.message_index.0 != u16::MAX {
            state.serialize_field("message_index", &self.message_index)?;
        }
        if let Some(v) = self.timestamp.unix_timestamp() {
            state.serialize_field("timestamp", &v)?;
        }
        if self.event.0 != u8::MAX {
            state.serialize_field("event", &self.event)?;
        }
        if self.event_type.0 != u8::MAX {
            state.serialize_field("event_type", &self.event_type)?;
        }
        if let Some(v) = self.start_time.unix_timestamp() {
            state.serialize_field("start_time", &v)?;
        }
        if let Some(v) = self.start_position_lat_degrees() {
            state.serialize_field("start_position_lat", &v)?;
        }
        if let Some(v) = self.start_position_long_degrees() {
            state.serialize_field("start_position_long", &v)?;
        }
        if self.sport.0 != u8::MAX {
            state.serialize_field("sport", &self.sport)?;
        }
        if self.sub_sport.0 != u8::MAX {
            state.serialize_field("sub_sport", &self.sub_sport)?;
        }
        if let Some(v) = self.total_elapsed_time_scaled() {
            state.serialize_field("total_elapsed_time", &v)?;
        }
        if let Some(v) = self.total_timer_time_scaled() {
            state.serialize_field("total_timer_time", &v)?;
        }
        if let Some(v) = self.total_distance_scaled() {
            state.serialize_field("total_distance", &v)?;
        }
        if self.total_cycles != u32::MAX {
            state.serialize_field("total_cycles", &self.total_cycles)?;
        }
        if self.total_calories != u16::MAX {
            state.serialize_field("total_calories", &self.total_calories)?;
        }
        if self.total_fat_calories != u16::MAX {
            state.serialize_field("total_fat_calories", &self.total_fat_calories)?;
        }
        if let Some(v) = self.avg_speed_scaled() {
            state.serialize_field("avg_speed", &v)?;
        }
        if let Some(v) = self.max_speed_scaled() {
            state.serialize_field("max_speed", &v)?;
        }
        if self.avg_heart_rate != u8::MAX {
            state.serialize_field("avg_heart_rate", &self.avg_heart_rate)?;
        }
        if self.max_heart_rate != u8::MAX {
            state.serialize_field("max_heart_rate", &self.max_heart_rate)?;
        }
        if self.avg_cadence != u8::MAX {
            state.serialize_field("avg_cadence", &self.avg_cadence)?;
        }
        if self.max_cadence != u8::MAX {
            state.serialize_field("max_cadence", &self.max_cadence)?;
        }
        if self.avg_power != u16::MAX {
            state.serialize_field("avg_power", &self.avg_power)?;
        }
        if self.max_power != u16::MAX {
            state.serialize_field("max_power", &self.max_power)?;
        }
        if self.total_ascent != u16::MAX {
            state.serialize_field("total_ascent", &self.total_ascent)?;
        }
        if self.total_descent != u16::MAX {
            state.serialize_field("total_descent", &self.total_descent)?;
        }
        if let Some(v) = self.total_training_effect_scaled() {
            state.serialize_field("total_training_effect", &v)?;
        }
        if self.first_lap_index != u16::MAX {
            state.serialize_field("first_lap_index", &self.first_lap_index)?;
        }
        if self.num_laps != u16::MAX {
            state.serialize_field("num_laps", &self.num_laps)?;
        }
        if self.event_group != u8::MAX {
            state.serialize_field("event_group", &self.event_group)?;
        }
        if self.trigger.0 != u8::MAX {
            state.serialize_field("trigger", &self.trigger)?;
        }
        if let Some(v) = self.nec_lat_degrees() {
            state.serialize_field("nec_lat", &v)?;
        }
        if let Some(v) = self.nec_long_degrees() {
            state.serialize_field("nec_long", &v)?;
        }
        if let Some(v) = self.swc_lat_degrees() {
            state.serialize_field("swc_lat", &v)?;
        }
        if let Some(v) = self.swc_long_degrees() {
            state.serialize_field("swc_long", &v)?;
        }
        if self.num_lengths != u16::MAX {
            state.serialize_field("num_lengths", &self.num_lengths)?;
        }
        if self.normalized_power != u16::MAX {
            state.serialize_field("normalized_power", &self.normalized_power)?;
        }
        if let Some(v) = self.training_stress_score_scaled() {
            state.serialize_field("training_stress_score", &v)?;
        }
        if let Some(v) = self.intensity_factor_scaled() {
            state.serialize_field("intensity_factor", &v)?;
        }
        if self.left_right_balance.0 != u16::MAX {
            state.serialize_field("left_right_balance", &self.left_right_balance)?;
        }
        if let Some(v) = self.end_position_lat_degrees() {
            state.serialize_field("end_position_lat", &v)?;
        }
        if let Some(v) = self.end_position_long_degrees() {
            state.serialize_field("end_position_long", &v)?;
        }
        if let Some(v) = self.avg_stroke_count_scaled() {
            state.serialize_field("avg_stroke_count", &v)?;
        }
        if let Some(v) = self.avg_stroke_distance_scaled() {
            state.serialize_field("avg_stroke_distance", &v)?;
        }
        if self.swim_stroke.0 != u8::MAX {
            state.serialize_field("swim_stroke", &self.swim_stroke)?;
        }
        if let Some(v) = self.pool_length_scaled() {
            state.serialize_field("pool_length", &v)?;
        }
        if self.threshold_power != u16::MAX {
            state.serialize_field("threshold_power", &self.threshold_power)?;
        }
        if self.pool_length_unit.0 != u8::MAX {
            state.serialize_field("pool_length_unit", &self.pool_length_unit)?;
        }
        if self.num_active_lengths != u16::MAX {
            state.serialize_field("num_active_lengths", &self.num_active_lengths)?;
        }
        if self.total_work != u32::MAX {
            state.serialize_field("total_work", &self.total_work)?;
        }
        if let Some(v) = self.avg_altitude_scaled() {
            state.serialize_field("avg_altitude", &v)?;
        }
        if let Some(v) = self.max_altitude_scaled() {
            state.serialize_field("max_altitude", &v)?;
        }
        if self.gps_accuracy != u8::MAX {
            state.serialize_field("gps_accuracy", &self.gps_accuracy)?;
        }
        if let Some(v) = self.avg_grade_scaled() {
            state.serialize_field("avg_grade", &v)?;
        }
        if let Some(v) = self.avg_pos_grade_scaled() {
            state.serialize_field("avg_pos_grade", &v)?;
        }
        if let Some(v) = self.avg_neg_grade_scaled() {
            state.serialize_field("avg_neg_grade", &v)?;
        }
        if let Some(v) = self.max_pos_grade_scaled() {
            state.serialize_field("max_pos_grade", &v)?;
        }
        if let Some(v) = self.max_neg_grade_scaled() {
            state.serialize_field("max_neg_grade", &v)?;
        }
        if self.avg_temperature != i8::MAX {
            state.serialize_field("avg_temperature", &self.avg_temperature)?;
        }
        if self.max_temperature != i8::MAX {
            state.serialize_field("max_temperature", &self.max_temperature)?;
        }
        if let Some(v) = self.total_moving_time_scaled() {
            state.serialize_field("total_moving_time", &v)?;
        }
        if let Some(v) = self.avg_pos_vertical_speed_scaled() {
            state.serialize_field("avg_pos_vertical_speed", &v)?;
        }
        if let Some(v) = self.avg_neg_vertical_speed_scaled() {
            state.serialize_field("avg_neg_vertical_speed", &v)?;
        }
        if let Some(v) = self.max_pos_vertical_speed_scaled() {
            state.serialize_field("max_pos_vertical_speed", &v)?;
        }
        if let Some(v) = self.max_neg_vertical_speed_scaled() {
            state.serialize_field("max_neg_vertical_speed", &v)?;
        }
        if self.min_heart_rate != u8::MAX {
            state.serialize_field("min_heart_rate", &self.min_heart_rate)?;
        }
        if let Some(v) = self.time_in_hr_zone_scaled() {
            state.serialize_field("time_in_hr_zone", &v)?;
        }
        if let Some(v) = self.time_in_speed_zone_scaled() {
            state.serialize_field("time_in_speed_zone", &v)?;
        }
        if let Some(v) = self.time_in_cadence_zone_scaled() {
            state.serialize_field("time_in_cadence_zone", &v)?;
        }
        if let Some(v) = self.time_in_power_zone_scaled() {
            state.serialize_field("time_in_power_zone", &v)?;
        }
        if let Some(v) = self.avg_lap_time_scaled() {
            state.serialize_field("avg_lap_time", &v)?;
        }
        if self.best_lap_index != u16::MAX {
            state.serialize_field("best_lap_index", &self.best_lap_index)?;
        }
        if let Some(v) = self.min_altitude_scaled() {
            state.serialize_field("min_altitude", &v)?;
        }
        if let Some(v) = self.active_time_scaled() {
            state.serialize_field("active_time", &v)?;
        }
        if self.player_score != u16::MAX {
            state.serialize_field("player_score", &self.player_score)?;
        }
        if self.opponent_score != u16::MAX {
            state.serialize_field("opponent_score", &self.opponent_score)?;
        }
        if !self.opponent_name.is_empty() {
            state.serialize_field("opponent_name", &self.opponent_name)?;
        }
        if !self.stroke_count.is_empty() {
            state.serialize_field("stroke_count", &self.stroke_count)?;
        }
        if !self.zone_count.is_empty() {
            state.serialize_field("zone_count", &self.zone_count)?;
        }
        if let Some(v) = self.max_ball_speed_scaled() {
            state.serialize_field("max_ball_speed", &v)?;
        }
        if let Some(v) = self.avg_ball_speed_scaled() {
            state.serialize_field("avg_ball_speed", &v)?;
        }
        if let Some(v) = self.avg_vertical_oscillation_scaled() {
            state.serialize_field("avg_vertical_oscillation", &v)?;
        }
        if let Some(v) = self.avg_stance_time_percent_scaled() {
            state.serialize_field("avg_stance_time_percent", &v)?;
        }
        if let Some(v) = self.avg_stance_time_scaled() {
            state.serialize_field("avg_stance_time", &v)?;
        }
        if let Some(v) = self.avg_fractional_cadence_scaled() {
            state.serialize_field("avg_fractional_cadence", &v)?;
        }
        if let Some(v) = self.max_fractional_cadence_scaled() {
            state.serialize_field("max_fractional_cadence", &v)?;
        }
        if let Some(v) = self.total_fractional_cycles_scaled() {
            state.serialize_field("total_fractional_cycles", &v)?;
        }
        if let Some(v) = self.avg_total_hemoglobin_conc_scaled() {
            state.serialize_field("avg_total_hemoglobin_conc", &v)?;
        }
        if let Some(v) = self.min_total_hemoglobin_conc_scaled() {
            state.serialize_field("min_total_hemoglobin_conc", &v)?;
        }
        if let Some(v) = self.max_total_hemoglobin_conc_scaled() {
            state.serialize_field("max_total_hemoglobin_conc", &v)?;
        }
        if let Some(v) = self.avg_saturated_hemoglobin_percent_scaled() {
            state.serialize_field("avg_saturated_hemoglobin_percent", &v)?;
        }
        if let Some(v) = self.min_saturated_hemoglobin_percent_scaled() {
            state.serialize_field("min_saturated_hemoglobin_percent", &v)?;
        }
        if let Some(v) = self.max_saturated_hemoglobin_percent_scaled() {
            state.serialize_field("max_saturated_hemoglobin_percent", &v)?;
        }
        if let Some(v) = self.avg_left_torque_effectiveness_scaled() {
            state.serialize_field("avg_left_torque_effectiveness", &v)?;
        }
        if let Some(v) = self.avg_right_torque_effectiveness_scaled() {
            state.serialize_field("avg_right_torque_effectiveness", &v)?;
        }
        if let Some(v) = self.avg_left_pedal_smoothness_scaled() {
            state.serialize_field("avg_left_pedal_smoothness", &v)?;
        }
        if let Some(v) = self.avg_right_pedal_smoothness_scaled() {
            state.serialize_field("avg_right_pedal_smoothness", &v)?;
        }
        if let Some(v) = self.avg_combined_pedal_smoothness_scaled() {
            state.serialize_field("avg_combined_pedal_smoothness", &v)?;
        }
        if !self.sport_profile_name.is_empty() {
            state.serialize_field("sport_profile_name", &self.sport_profile_name)?;
        }
        if self.sport_index != u8::MAX {
            state.serialize_field("sport_index", &self.sport_index)?;
        }
        if let Some(v) = self.time_standing_scaled() {
            state.serialize_field("time_standing", &v)?;
        }
        if self.stand_count != u16::MAX {
            state.serialize_field("stand_count", &self.stand_count)?;
        }
        if self.avg_left_pco != i8::MAX {
            state.serialize_field("avg_left_pco", &self.avg_left_pco)?;
        }
        if self.avg_right_pco != i8::MAX {
            state.serialize_field("avg_right_pco", &self.avg_right_pco)?;
        }
        if let Some(v) = self.avg_left_power_phase_scaled() {
            state.serialize_field("avg_left_power_phase", &v)?;
        }
        if let Some(v) = self.avg_left_power_phase_peak_scaled() {
            state.serialize_field("avg_left_power_phase_peak", &v)?;
        }
        if let Some(v) = self.avg_right_power_phase_scaled() {
            state.serialize_field("avg_right_power_phase", &v)?;
        }
        if let Some(v) = self.avg_right_power_phase_peak_scaled() {
            state.serialize_field("avg_right_power_phase_peak", &v)?;
        }
        if !self.avg_power_position.is_empty() {
            state.serialize_field("avg_power_position", &self.avg_power_position)?;
        }
        if !self.max_power_position.is_empty() {
            state.serialize_field("max_power_position", &self.max_power_position)?;
        }
        if !self.avg_cadence_position.is_empty() {
            state.serialize_field("avg_cadence_position", &self.avg_cadence_position)?;
        }
        if !self.max_cadence_position.is_empty() {
            state.serialize_field("max_cadence_position", &self.max_cadence_position)?;
        }
        if let Some(v) = self.enhanced_avg_speed_scaled() {
            state.serialize_field("enhanced_avg_speed", &v)?;
        }
        if let Some(v) = self.enhanced_max_speed_scaled() {
            state.serialize_field("enhanced_max_speed", &v)?;
        }
        if let Some(v) = self.enhanced_avg_altitude_scaled() {
            state.serialize_field("enhanced_avg_altitude", &v)?;
        }
        if let Some(v) = self.enhanced_min_altitude_scaled() {
            state.serialize_field("enhanced_min_altitude", &v)?;
        }
        if let Some(v) = self.enhanced_max_altitude_scaled() {
            state.serialize_field("enhanced_max_altitude", &v)?;
        }
        if self.avg_lev_motor_power != u16::MAX {
            state.serialize_field("avg_lev_motor_power", &self.avg_lev_motor_power)?;
        }
        if self.max_lev_motor_power != u16::MAX {
            state.serialize_field("max_lev_motor_power", &self.max_lev_motor_power)?;
        }
        if let Some(v) = self.lev_battery_consumption_scaled() {
            state.serialize_field("lev_battery_consumption", &v)?;
        }
        if let Some(v) = self.avg_vertical_ratio_scaled() {
            state.serialize_field("avg_vertical_ratio", &v)?;
        }
        if let Some(v) = self.avg_stance_time_balance_scaled() {
            state.serialize_field("avg_stance_time_balance", &v)?;
        }
        if let Some(v) = self.avg_step_length_scaled() {
            state.serialize_field("avg_step_length", &v)?;
        }
        if let Some(v) = self.total_anaerobic_training_effect_scaled() {
            state.serialize_field("total_anaerobic_training_effect", &v)?;
        }
        if let Some(v) = self.avg_vam_scaled() {
            state.serialize_field("avg_vam", &v)?;
        }
        if let Some(v) = self.avg_depth_scaled() {
            state.serialize_field("avg_depth", &v)?;
        }
        if let Some(v) = self.max_depth_scaled() {
            state.serialize_field("max_depth", &v)?;
        }
        if self.surface_interval != u32::MAX {
            state.serialize_field("surface_interval", &self.surface_interval)?;
        }
        if self.start_cns != u8::MAX {
            state.serialize_field("start_cns", &self.start_cns)?;
        }
        if self.end_cns != u8::MAX {
            state.serialize_field("end_cns", &self.end_cns)?;
        }
        if self.start_n2 != u16::MAX {
            state.serialize_field("start_n2", &self.start_n2)?;
        }
        if self.end_n2 != u16::MAX {
            state.serialize_field("end_n2", &self.end_n2)?;
        }
        if self.avg_respiration_rate != u8::MAX {
            state.serialize_field("avg_respiration_rate", &self.avg_respiration_rate)?;
        }
        if self.max_respiration_rate != u8::MAX {
            state.serialize_field("max_respiration_rate", &self.max_respiration_rate)?;
        }
        if self.min_respiration_rate != u8::MAX {
            state.serialize_field("min_respiration_rate", &self.min_respiration_rate)?;
        }
        if self.min_temperature != i8::MAX {
            state.serialize_field("min_temperature", &self.min_temperature)?;
        }
        if self.o2_toxicity != u16::MAX {
            state.serialize_field("o2_toxicity", &self.o2_toxicity)?;
        }
        if self.dive_number != u32::MAX {
            state.serialize_field("dive_number", &self.dive_number)?;
        }
        if let Some(v) = self.training_load_peak_scaled() {
            state.serialize_field("training_load_peak", &v)?;
        }
        if let Some(v) = self.enhanced_avg_respiration_rate_scaled() {
            state.serialize_field("enhanced_avg_respiration_rate", &v)?;
        }
        if let Some(v) = self.enhanced_max_respiration_rate_scaled() {
            state.serialize_field("enhanced_max_respiration_rate", &v)?;
        }
        if let Some(v) = self.enhanced_min_respiration_rate_scaled() {
            state.serialize_field("enhanced_min_respiration_rate", &v)?;
        }
        if self.total_grit.to_bits() != u32::MAX {
            state.serialize_field("total_grit", &self.total_grit)?;
        }
        if self.total_flow.to_bits() != u32::MAX {
            state.serialize_field("total_flow", &self.total_flow)?;
        }
        if self.jump_count != u16::MAX {
            state.serialize_field("jump_count", &self.jump_count)?;
        }
        if self.avg_grit.to_bits() != u32::MAX {
            state.serialize_field("avg_grit", &self.avg_grit)?;
        }
        if self.avg_flow.to_bits() != u32::MAX {
            state.serialize_field("avg_flow", &self.avg_flow)?;
        }
        if self.workout_feel != u8::MAX {
            state.serialize_field("workout_feel", &self.workout_feel)?;
        }
        if self.workout_rpe != u8::MAX {
            state.serialize_field("workout_rpe", &self.workout_rpe)?;
        }
        if self.avg_spo2 != u8::MAX {
            state.serialize_field("avg_spo2", &self.avg_spo2)?;
        }
        if self.avg_stress != u8::MAX {
            state.serialize_field("avg_stress", &self.avg_stress)?;
        }
        if self.metabolic_calories != u16::MAX {
            state.serialize_field("metabolic_calories", &self.metabolic_calories)?;
        }
        if self.sdrr_hrv != u8::MAX {
            state.serialize_field("sdrr_hrv", &self.sdrr_hrv)?;
        }
        if self.rmssd_hrv != u8::MAX {
            state.serialize_field("rmssd_hrv", &self.rmssd_hrv)?;
        }
        if let Some(v) = self.total_fractional_ascent_scaled() {
            state.serialize_field("total_fractional_ascent", &v)?;
        }
        if let Some(v) = self.total_fractional_descent_scaled() {
            state.serialize_field("total_fractional_descent", &v)?;
        }
        if let Some(v) = self.avg_core_temperature_scaled() {
            state.serialize_field("avg_core_temperature", &v)?;
        }
        if let Some(v) = self.min_core_temperature_scaled() {
            state.serialize_field("min_core_temperature", &v)?;
        }
        if let Some(v) = self.max_core_temperature_scaled() {
            state.serialize_field("max_core_temperature", &v)?;
        }
        if !self.unknown_fields.is_empty() {
            state.serialize_field("unknown_fields", &self.unknown_fields)?;
        }
        if !self.developer_fields.is_empty() {
            state.serialize_field("developer_fields", &self.developer_fields)?;
        }
        state.end()
    }
}

#[cfg(feature = "serde")]
#[cfg_attr(feature = "serde", derive(Deserialize), serde(default))]
struct De {
    message_index: typedef::MessageIndex,
    timestamp: Option<i64>,
    event: typedef::Event,
    event_type: typedef::EventType,
    start_time: Option<i64>,
    /// Degrees.
    start_position_lat: f64,
    /// Degrees.
    start_position_long: f64,
    sport: typedef::Sport,
    sub_sport: typedef::SubSport,
    total_elapsed_time: f64,
    total_timer_time: f64,
    total_distance: f64,
    total_cycles: u32,
    total_calories: u16,
    total_fat_calories: u16,
    avg_speed: f64,
    max_speed: f64,
    avg_heart_rate: u8,
    max_heart_rate: u8,
    avg_cadence: u8,
    max_cadence: u8,
    avg_power: u16,
    max_power: u16,
    total_ascent: u16,
    total_descent: u16,
    total_training_effect: f64,
    first_lap_index: u16,
    num_laps: u16,
    event_group: u8,
    trigger: typedef::SessionTrigger,
    /// Degrees.
    nec_lat: f64,
    /// Degrees.
    nec_long: f64,
    /// Degrees.
    swc_lat: f64,
    /// Degrees.
    swc_long: f64,
    num_lengths: u16,
    normalized_power: u16,
    training_stress_score: f64,
    intensity_factor: f64,
    left_right_balance: typedef::LeftRightBalance100,
    /// Degrees.
    end_position_lat: f64,
    /// Degrees.
    end_position_long: f64,
    avg_stroke_count: f64,
    avg_stroke_distance: f64,
    swim_stroke: typedef::SwimStroke,
    pool_length: f64,
    threshold_power: u16,
    pool_length_unit: typedef::DisplayMeasure,
    num_active_lengths: u16,
    total_work: u32,
    avg_altitude: f64,
    max_altitude: f64,
    gps_accuracy: u8,
    avg_grade: f64,
    avg_pos_grade: f64,
    avg_neg_grade: f64,
    max_pos_grade: f64,
    max_neg_grade: f64,
    avg_temperature: i8,
    max_temperature: i8,
    total_moving_time: f64,
    avg_pos_vertical_speed: f64,
    avg_neg_vertical_speed: f64,
    max_pos_vertical_speed: f64,
    max_neg_vertical_speed: f64,
    min_heart_rate: u8,
    time_in_hr_zone: Vec<f64>,
    time_in_speed_zone: Vec<f64>,
    time_in_cadence_zone: Vec<f64>,
    time_in_power_zone: Vec<f64>,
    avg_lap_time: f64,
    best_lap_index: u16,
    min_altitude: f64,
    active_time: f64,
    player_score: u16,
    opponent_score: u16,
    opponent_name: String,
    stroke_count: Vec<u16>,
    zone_count: Vec<u16>,
    max_ball_speed: f64,
    avg_ball_speed: f64,
    avg_vertical_oscillation: f64,
    avg_stance_time_percent: f64,
    avg_stance_time: f64,
    avg_fractional_cadence: f64,
    max_fractional_cadence: f64,
    total_fractional_cycles: f64,
    avg_total_hemoglobin_conc: Vec<f64>,
    min_total_hemoglobin_conc: Vec<f64>,
    max_total_hemoglobin_conc: Vec<f64>,
    avg_saturated_hemoglobin_percent: Vec<f64>,
    min_saturated_hemoglobin_percent: Vec<f64>,
    max_saturated_hemoglobin_percent: Vec<f64>,
    avg_left_torque_effectiveness: f64,
    avg_right_torque_effectiveness: f64,
    avg_left_pedal_smoothness: f64,
    avg_right_pedal_smoothness: f64,
    avg_combined_pedal_smoothness: f64,
    sport_profile_name: String,
    sport_index: u8,
    time_standing: f64,
    stand_count: u16,
    avg_left_pco: i8,
    avg_right_pco: i8,
    avg_left_power_phase: Vec<f64>,
    avg_left_power_phase_peak: Vec<f64>,
    avg_right_power_phase: Vec<f64>,
    avg_right_power_phase_peak: Vec<f64>,
    avg_power_position: Vec<u16>,
    max_power_position: Vec<u16>,
    avg_cadence_position: Vec<u8>,
    max_cadence_position: Vec<u8>,
    enhanced_avg_speed: f64,
    enhanced_max_speed: f64,
    enhanced_avg_altitude: f64,
    enhanced_min_altitude: f64,
    enhanced_max_altitude: f64,
    avg_lev_motor_power: u16,
    max_lev_motor_power: u16,
    lev_battery_consumption: f64,
    avg_vertical_ratio: f64,
    avg_stance_time_balance: f64,
    avg_step_length: f64,
    total_anaerobic_training_effect: f64,
    avg_vam: f64,
    avg_depth: f64,
    max_depth: f64,
    surface_interval: u32,
    start_cns: u8,
    end_cns: u8,
    start_n2: u16,
    end_n2: u16,
    avg_respiration_rate: u8,
    max_respiration_rate: u8,
    min_respiration_rate: u8,
    min_temperature: i8,
    o2_toxicity: u16,
    dive_number: u32,
    training_load_peak: f64,
    enhanced_avg_respiration_rate: f64,
    enhanced_max_respiration_rate: f64,
    enhanced_min_respiration_rate: f64,
    total_grit: f32,
    total_flow: f32,
    jump_count: u16,
    avg_grit: f32,
    avg_flow: f32,
    workout_feel: u8,
    workout_rpe: u8,
    avg_spo2: u8,
    avg_stress: u8,
    metabolic_calories: u16,
    sdrr_hrv: u8,
    rmssd_hrv: u8,
    total_fractional_ascent: f64,
    total_fractional_descent: f64,
    avg_core_temperature: f64,
    min_core_temperature: f64,
    max_core_temperature: f64,
    unknown_fields: Vec<Field>,
    developer_fields: Vec<DeveloperField>,
}

#[cfg(feature = "serde")]
impl From<De> for Session {
    fn from(m: De) -> Self {
        Self {
            message_index: m.message_index,
            timestamp: m.timestamp.map_or_else(
                || typedef::DateTime(u32::MAX),
                typedef::DateTime::from_unix_timestamp,
            ),
            event: m.event,
            event_type: m.event_type,
            start_time: m.start_time.map_or_else(
                || typedef::DateTime(u32::MAX),
                typedef::DateTime::from_unix_timestamp,
            ),
            start_position_lat: semconv::to_semicircles(m.start_position_lat).unwrap_or(i32::MAX),
            start_position_long: semconv::to_semicircles(m.start_position_long).unwrap_or(i32::MAX),
            sport: m.sport,
            sub_sport: m.sub_sport,
            total_elapsed_time: {
                let unscaled = (m.total_elapsed_time + 0.0) * 1000.0;
                if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u32::MAX as f64 {
                    u32::MAX
                } else {
                    unscaled as u32
                }
            },
            total_timer_time: {
                let unscaled = (m.total_timer_time + 0.0) * 1000.0;
                if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u32::MAX as f64 {
                    u32::MAX
                } else {
                    unscaled as u32
                }
            },
            total_distance: {
                let unscaled = (m.total_distance + 0.0) * 100.0;
                if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u32::MAX as f64 {
                    u32::MAX
                } else {
                    unscaled as u32
                }
            },
            total_cycles: m.total_cycles,
            total_calories: m.total_calories,
            total_fat_calories: m.total_fat_calories,
            avg_speed: {
                let unscaled = (m.avg_speed + 0.0) * 1000.0;
                if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u16::MAX as f64 {
                    u16::MAX
                } else {
                    unscaled as u16
                }
            },
            max_speed: {
                let unscaled = (m.max_speed + 0.0) * 1000.0;
                if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u16::MAX as f64 {
                    u16::MAX
                } else {
                    unscaled as u16
                }
            },
            avg_heart_rate: m.avg_heart_rate,
            max_heart_rate: m.max_heart_rate,
            avg_cadence: m.avg_cadence,
            max_cadence: m.max_cadence,
            avg_power: m.avg_power,
            max_power: m.max_power,
            total_ascent: m.total_ascent,
            total_descent: m.total_descent,
            total_training_effect: {
                let unscaled = (m.total_training_effect + 0.0) * 10.0;
                if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u8::MAX as f64 {
                    u8::MAX
                } else {
                    unscaled as u8
                }
            },
            first_lap_index: m.first_lap_index,
            num_laps: m.num_laps,
            event_group: m.event_group,
            trigger: m.trigger,
            nec_lat: semconv::to_semicircles(m.nec_lat).unwrap_or(i32::MAX),
            nec_long: semconv::to_semicircles(m.nec_long).unwrap_or(i32::MAX),
            swc_lat: semconv::to_semicircles(m.swc_lat).unwrap_or(i32::MAX),
            swc_long: semconv::to_semicircles(m.swc_long).unwrap_or(i32::MAX),
            num_lengths: m.num_lengths,
            normalized_power: m.normalized_power,
            training_stress_score: {
                let unscaled = (m.training_stress_score + 0.0) * 10.0;
                if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u16::MAX as f64 {
                    u16::MAX
                } else {
                    unscaled as u16
                }
            },
            intensity_factor: {
                let unscaled = (m.intensity_factor + 0.0) * 1000.0;
                if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u16::MAX as f64 {
                    u16::MAX
                } else {
                    unscaled as u16
                }
            },
            left_right_balance: m.left_right_balance,
            end_position_lat: semconv::to_semicircles(m.end_position_lat).unwrap_or(i32::MAX),
            end_position_long: semconv::to_semicircles(m.end_position_long).unwrap_or(i32::MAX),
            avg_stroke_count: {
                let unscaled = (m.avg_stroke_count + 0.0) * 10.0;
                if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u32::MAX as f64 {
                    u32::MAX
                } else {
                    unscaled as u32
                }
            },
            avg_stroke_distance: {
                let unscaled = (m.avg_stroke_distance + 0.0) * 100.0;
                if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u16::MAX as f64 {
                    u16::MAX
                } else {
                    unscaled as u16
                }
            },
            swim_stroke: m.swim_stroke,
            pool_length: {
                let unscaled = (m.pool_length + 0.0) * 100.0;
                if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u16::MAX as f64 {
                    u16::MAX
                } else {
                    unscaled as u16
                }
            },
            threshold_power: m.threshold_power,
            pool_length_unit: m.pool_length_unit,
            num_active_lengths: m.num_active_lengths,
            total_work: m.total_work,
            avg_altitude: {
                let unscaled = (m.avg_altitude + 500.0) * 5.0;
                if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u16::MAX as f64 {
                    u16::MAX
                } else {
                    unscaled as u16
                }
            },
            max_altitude: {
                let unscaled = (m.max_altitude + 500.0) * 5.0;
                if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u16::MAX as f64 {
                    u16::MAX
                } else {
                    unscaled as u16
                }
            },
            gps_accuracy: m.gps_accuracy,
            avg_grade: {
                let unscaled = (m.avg_grade + 0.0) * 100.0;
                if unscaled.is_nan() || unscaled.is_infinite() || unscaled > i16::MAX as f64 {
                    i16::MAX
                } else {
                    unscaled as i16
                }
            },
            avg_pos_grade: {
                let unscaled = (m.avg_pos_grade + 0.0) * 100.0;
                if unscaled.is_nan() || unscaled.is_infinite() || unscaled > i16::MAX as f64 {
                    i16::MAX
                } else {
                    unscaled as i16
                }
            },
            avg_neg_grade: {
                let unscaled = (m.avg_neg_grade + 0.0) * 100.0;
                if unscaled.is_nan() || unscaled.is_infinite() || unscaled > i16::MAX as f64 {
                    i16::MAX
                } else {
                    unscaled as i16
                }
            },
            max_pos_grade: {
                let unscaled = (m.max_pos_grade + 0.0) * 100.0;
                if unscaled.is_nan() || unscaled.is_infinite() || unscaled > i16::MAX as f64 {
                    i16::MAX
                } else {
                    unscaled as i16
                }
            },
            max_neg_grade: {
                let unscaled = (m.max_neg_grade + 0.0) * 100.0;
                if unscaled.is_nan() || unscaled.is_infinite() || unscaled > i16::MAX as f64 {
                    i16::MAX
                } else {
                    unscaled as i16
                }
            },
            avg_temperature: m.avg_temperature,
            max_temperature: m.max_temperature,
            total_moving_time: {
                let unscaled = (m.total_moving_time + 0.0) * 1000.0;
                if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u32::MAX as f64 {
                    u32::MAX
                } else {
                    unscaled as u32
                }
            },
            avg_pos_vertical_speed: {
                let unscaled = (m.avg_pos_vertical_speed + 0.0) * 1000.0;
                if unscaled.is_nan() || unscaled.is_infinite() || unscaled > i16::MAX as f64 {
                    i16::MAX
                } else {
                    unscaled as i16
                }
            },
            avg_neg_vertical_speed: {
                let unscaled = (m.avg_neg_vertical_speed + 0.0) * 1000.0;
                if unscaled.is_nan() || unscaled.is_infinite() || unscaled > i16::MAX as f64 {
                    i16::MAX
                } else {
                    unscaled as i16
                }
            },
            max_pos_vertical_speed: {
                let unscaled = (m.max_pos_vertical_speed + 0.0) * 1000.0;
                if unscaled.is_nan() || unscaled.is_infinite() || unscaled > i16::MAX as f64 {
                    i16::MAX
                } else {
                    unscaled as i16
                }
            },
            max_neg_vertical_speed: {
                let unscaled = (m.max_neg_vertical_speed + 0.0) * 1000.0;
                if unscaled.is_nan() || unscaled.is_infinite() || unscaled > i16::MAX as f64 {
                    i16::MAX
                } else {
                    unscaled as i16
                }
            },
            min_heart_rate: m.min_heart_rate,
            time_in_hr_zone: {
                if m.time_in_hr_zone.is_empty() {
                    Vec::new()
                } else {
                    let mut vals = Vec::with_capacity(m.time_in_hr_zone.len());
                    for &x in m.time_in_hr_zone.iter() {
                        let unscaled = (x + 0.0) * 1000.0;
                        if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u32::MAX as f64
                        {
                            vals.push(u32::MAX);
                            continue;
                        }
                        vals.push(unscaled as u32);
                    }
                    vals
                }
            },
            time_in_speed_zone: {
                if m.time_in_speed_zone.is_empty() {
                    Vec::new()
                } else {
                    let mut vals = Vec::with_capacity(m.time_in_speed_zone.len());
                    for &x in m.time_in_speed_zone.iter() {
                        let unscaled = (x + 0.0) * 1000.0;
                        if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u32::MAX as f64
                        {
                            vals.push(u32::MAX);
                            continue;
                        }
                        vals.push(unscaled as u32);
                    }
                    vals
                }
            },
            time_in_cadence_zone: {
                if m.time_in_cadence_zone.is_empty() {
                    Vec::new()
                } else {
                    let mut vals = Vec::with_capacity(m.time_in_cadence_zone.len());
                    for &x in m.time_in_cadence_zone.iter() {
                        let unscaled = (x + 0.0) * 1000.0;
                        if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u32::MAX as f64
                        {
                            vals.push(u32::MAX);
                            continue;
                        }
                        vals.push(unscaled as u32);
                    }
                    vals
                }
            },
            time_in_power_zone: {
                if m.time_in_power_zone.is_empty() {
                    Vec::new()
                } else {
                    let mut vals = Vec::with_capacity(m.time_in_power_zone.len());
                    for &x in m.time_in_power_zone.iter() {
                        let unscaled = (x + 0.0) * 1000.0;
                        if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u32::MAX as f64
                        {
                            vals.push(u32::MAX);
                            continue;
                        }
                        vals.push(unscaled as u32);
                    }
                    vals
                }
            },
            avg_lap_time: {
                let unscaled = (m.avg_lap_time + 0.0) * 1000.0;
                if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u32::MAX as f64 {
                    u32::MAX
                } else {
                    unscaled as u32
                }
            },
            best_lap_index: m.best_lap_index,
            min_altitude: {
                let unscaled = (m.min_altitude + 500.0) * 5.0;
                if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u16::MAX as f64 {
                    u16::MAX
                } else {
                    unscaled as u16
                }
            },
            active_time: {
                let unscaled = (m.active_time + 0.0) * 1000.0;
                if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u32::MAX as f64 {
                    u32::MAX
                } else {
                    unscaled as u32
                }
            },
            player_score: m.player_score,
            opponent_score: m.opponent_score,
            opponent_name: m.opponent_name,
            stroke_count: m.stroke_count,
            zone_count: m.zone_count,
            max_ball_speed: {
                let unscaled = (m.max_ball_speed + 0.0) * 100.0;
                if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u16::MAX as f64 {
                    u16::MAX
                } else {
                    unscaled as u16
                }
            },
            avg_ball_speed: {
                let unscaled = (m.avg_ball_speed + 0.0) * 100.0;
                if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u16::MAX as f64 {
                    u16::MAX
                } else {
                    unscaled as u16
                }
            },
            avg_vertical_oscillation: {
                let unscaled = (m.avg_vertical_oscillation + 0.0) * 10.0;
                if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u16::MAX as f64 {
                    u16::MAX
                } else {
                    unscaled as u16
                }
            },
            avg_stance_time_percent: {
                let unscaled = (m.avg_stance_time_percent + 0.0) * 100.0;
                if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u16::MAX as f64 {
                    u16::MAX
                } else {
                    unscaled as u16
                }
            },
            avg_stance_time: {
                let unscaled = (m.avg_stance_time + 0.0) * 10.0;
                if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u16::MAX as f64 {
                    u16::MAX
                } else {
                    unscaled as u16
                }
            },
            avg_fractional_cadence: {
                let unscaled = (m.avg_fractional_cadence + 0.0) * 128.0;
                if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u8::MAX as f64 {
                    u8::MAX
                } else {
                    unscaled as u8
                }
            },
            max_fractional_cadence: {
                let unscaled = (m.max_fractional_cadence + 0.0) * 128.0;
                if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u8::MAX as f64 {
                    u8::MAX
                } else {
                    unscaled as u8
                }
            },
            total_fractional_cycles: {
                let unscaled = (m.total_fractional_cycles + 0.0) * 128.0;
                if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u8::MAX as f64 {
                    u8::MAX
                } else {
                    unscaled as u8
                }
            },
            avg_total_hemoglobin_conc: {
                if m.avg_total_hemoglobin_conc.is_empty() {
                    Vec::new()
                } else {
                    let mut vals = Vec::with_capacity(m.avg_total_hemoglobin_conc.len());
                    for &x in m.avg_total_hemoglobin_conc.iter() {
                        let unscaled = (x + 0.0) * 100.0;
                        if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u16::MAX as f64
                        {
                            vals.push(u16::MAX);
                            continue;
                        }
                        vals.push(unscaled as u16);
                    }
                    vals
                }
            },
            min_total_hemoglobin_conc: {
                if m.min_total_hemoglobin_conc.is_empty() {
                    Vec::new()
                } else {
                    let mut vals = Vec::with_capacity(m.min_total_hemoglobin_conc.len());
                    for &x in m.min_total_hemoglobin_conc.iter() {
                        let unscaled = (x + 0.0) * 100.0;
                        if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u16::MAX as f64
                        {
                            vals.push(u16::MAX);
                            continue;
                        }
                        vals.push(unscaled as u16);
                    }
                    vals
                }
            },
            max_total_hemoglobin_conc: {
                if m.max_total_hemoglobin_conc.is_empty() {
                    Vec::new()
                } else {
                    let mut vals = Vec::with_capacity(m.max_total_hemoglobin_conc.len());
                    for &x in m.max_total_hemoglobin_conc.iter() {
                        let unscaled = (x + 0.0) * 100.0;
                        if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u16::MAX as f64
                        {
                            vals.push(u16::MAX);
                            continue;
                        }
                        vals.push(unscaled as u16);
                    }
                    vals
                }
            },
            avg_saturated_hemoglobin_percent: {
                if m.avg_saturated_hemoglobin_percent.is_empty() {
                    Vec::new()
                } else {
                    let mut vals = Vec::with_capacity(m.avg_saturated_hemoglobin_percent.len());
                    for &x in m.avg_saturated_hemoglobin_percent.iter() {
                        let unscaled = (x + 0.0) * 10.0;
                        if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u16::MAX as f64
                        {
                            vals.push(u16::MAX);
                            continue;
                        }
                        vals.push(unscaled as u16);
                    }
                    vals
                }
            },
            min_saturated_hemoglobin_percent: {
                if m.min_saturated_hemoglobin_percent.is_empty() {
                    Vec::new()
                } else {
                    let mut vals = Vec::with_capacity(m.min_saturated_hemoglobin_percent.len());
                    for &x in m.min_saturated_hemoglobin_percent.iter() {
                        let unscaled = (x + 0.0) * 10.0;
                        if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u16::MAX as f64
                        {
                            vals.push(u16::MAX);
                            continue;
                        }
                        vals.push(unscaled as u16);
                    }
                    vals
                }
            },
            max_saturated_hemoglobin_percent: {
                if m.max_saturated_hemoglobin_percent.is_empty() {
                    Vec::new()
                } else {
                    let mut vals = Vec::with_capacity(m.max_saturated_hemoglobin_percent.len());
                    for &x in m.max_saturated_hemoglobin_percent.iter() {
                        let unscaled = (x + 0.0) * 10.0;
                        if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u16::MAX as f64
                        {
                            vals.push(u16::MAX);
                            continue;
                        }
                        vals.push(unscaled as u16);
                    }
                    vals
                }
            },
            avg_left_torque_effectiveness: {
                let unscaled = (m.avg_left_torque_effectiveness + 0.0) * 2.0;
                if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u8::MAX as f64 {
                    u8::MAX
                } else {
                    unscaled as u8
                }
            },
            avg_right_torque_effectiveness: {
                let unscaled = (m.avg_right_torque_effectiveness + 0.0) * 2.0;
                if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u8::MAX as f64 {
                    u8::MAX
                } else {
                    unscaled as u8
                }
            },
            avg_left_pedal_smoothness: {
                let unscaled = (m.avg_left_pedal_smoothness + 0.0) * 2.0;
                if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u8::MAX as f64 {
                    u8::MAX
                } else {
                    unscaled as u8
                }
            },
            avg_right_pedal_smoothness: {
                let unscaled = (m.avg_right_pedal_smoothness + 0.0) * 2.0;
                if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u8::MAX as f64 {
                    u8::MAX
                } else {
                    unscaled as u8
                }
            },
            avg_combined_pedal_smoothness: {
                let unscaled = (m.avg_combined_pedal_smoothness + 0.0) * 2.0;
                if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u8::MAX as f64 {
                    u8::MAX
                } else {
                    unscaled as u8
                }
            },
            sport_profile_name: m.sport_profile_name,
            sport_index: m.sport_index,
            time_standing: {
                let unscaled = (m.time_standing + 0.0) * 1000.0;
                if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u32::MAX as f64 {
                    u32::MAX
                } else {
                    unscaled as u32
                }
            },
            stand_count: m.stand_count,
            avg_left_pco: m.avg_left_pco,
            avg_right_pco: m.avg_right_pco,
            avg_left_power_phase: {
                if m.avg_left_power_phase.is_empty() {
                    Vec::new()
                } else {
                    let mut vals = Vec::with_capacity(m.avg_left_power_phase.len());
                    for &x in m.avg_left_power_phase.iter() {
                        let unscaled = (x + 0.0) * 0.7111111;
                        if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u8::MAX as f64
                        {
                            vals.push(u8::MAX);
                            continue;
                        }
                        vals.push(unscaled as u8);
                    }
                    vals
                }
            },
            avg_left_power_phase_peak: {
                if m.avg_left_power_phase_peak.is_empty() {
                    Vec::new()
                } else {
                    let mut vals = Vec::with_capacity(m.avg_left_power_phase_peak.len());
                    for &x in m.avg_left_power_phase_peak.iter() {
                        let unscaled = (x + 0.0) * 0.7111111;
                        if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u8::MAX as f64
                        {
                            vals.push(u8::MAX);
                            continue;
                        }
                        vals.push(unscaled as u8);
                    }
                    vals
                }
            },
            avg_right_power_phase: {
                if m.avg_right_power_phase.is_empty() {
                    Vec::new()
                } else {
                    let mut vals = Vec::with_capacity(m.avg_right_power_phase.len());
                    for &x in m.avg_right_power_phase.iter() {
                        let unscaled = (x + 0.0) * 0.7111111;
                        if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u8::MAX as f64
                        {
                            vals.push(u8::MAX);
                            continue;
                        }
                        vals.push(unscaled as u8);
                    }
                    vals
                }
            },
            avg_right_power_phase_peak: {
                if m.avg_right_power_phase_peak.is_empty() {
                    Vec::new()
                } else {
                    let mut vals = Vec::with_capacity(m.avg_right_power_phase_peak.len());
                    for &x in m.avg_right_power_phase_peak.iter() {
                        let unscaled = (x + 0.0) * 0.7111111;
                        if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u8::MAX as f64
                        {
                            vals.push(u8::MAX);
                            continue;
                        }
                        vals.push(unscaled as u8);
                    }
                    vals
                }
            },
            avg_power_position: m.avg_power_position,
            max_power_position: m.max_power_position,
            avg_cadence_position: m.avg_cadence_position,
            max_cadence_position: m.max_cadence_position,
            enhanced_avg_speed: {
                let unscaled = (m.enhanced_avg_speed + 0.0) * 1000.0;
                if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u32::MAX as f64 {
                    u32::MAX
                } else {
                    unscaled as u32
                }
            },
            enhanced_max_speed: {
                let unscaled = (m.enhanced_max_speed + 0.0) * 1000.0;
                if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u32::MAX as f64 {
                    u32::MAX
                } else {
                    unscaled as u32
                }
            },
            enhanced_avg_altitude: {
                let unscaled = (m.enhanced_avg_altitude + 500.0) * 5.0;
                if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u32::MAX as f64 {
                    u32::MAX
                } else {
                    unscaled as u32
                }
            },
            enhanced_min_altitude: {
                let unscaled = (m.enhanced_min_altitude + 500.0) * 5.0;
                if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u32::MAX as f64 {
                    u32::MAX
                } else {
                    unscaled as u32
                }
            },
            enhanced_max_altitude: {
                let unscaled = (m.enhanced_max_altitude + 500.0) * 5.0;
                if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u32::MAX as f64 {
                    u32::MAX
                } else {
                    unscaled as u32
                }
            },
            avg_lev_motor_power: m.avg_lev_motor_power,
            max_lev_motor_power: m.max_lev_motor_power,
            lev_battery_consumption: {
                let unscaled = (m.lev_battery_consumption + 0.0) * 2.0;
                if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u8::MAX as f64 {
                    u8::MAX
                } else {
                    unscaled as u8
                }
            },
            avg_vertical_ratio: {
                let unscaled = (m.avg_vertical_ratio + 0.0) * 100.0;
                if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u16::MAX as f64 {
                    u16::MAX
                } else {
                    unscaled as u16
                }
            },
            avg_stance_time_balance: {
                let unscaled = (m.avg_stance_time_balance + 0.0) * 100.0;
                if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u16::MAX as f64 {
                    u16::MAX
                } else {
                    unscaled as u16
                }
            },
            avg_step_length: {
                let unscaled = (m.avg_step_length + 0.0) * 10.0;
                if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u16::MAX as f64 {
                    u16::MAX
                } else {
                    unscaled as u16
                }
            },
            total_anaerobic_training_effect: {
                let unscaled = (m.total_anaerobic_training_effect + 0.0) * 10.0;
                if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u8::MAX as f64 {
                    u8::MAX
                } else {
                    unscaled as u8
                }
            },
            avg_vam: {
                let unscaled = (m.avg_vam + 0.0) * 1000.0;
                if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u16::MAX as f64 {
                    u16::MAX
                } else {
                    unscaled as u16
                }
            },
            avg_depth: {
                let unscaled = (m.avg_depth + 0.0) * 1000.0;
                if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u32::MAX as f64 {
                    u32::MAX
                } else {
                    unscaled as u32
                }
            },
            max_depth: {
                let unscaled = (m.max_depth + 0.0) * 1000.0;
                if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u32::MAX as f64 {
                    u32::MAX
                } else {
                    unscaled as u32
                }
            },
            surface_interval: m.surface_interval,
            start_cns: m.start_cns,
            end_cns: m.end_cns,
            start_n2: m.start_n2,
            end_n2: m.end_n2,
            avg_respiration_rate: m.avg_respiration_rate,
            max_respiration_rate: m.max_respiration_rate,
            min_respiration_rate: m.min_respiration_rate,
            min_temperature: m.min_temperature,
            o2_toxicity: m.o2_toxicity,
            dive_number: m.dive_number,
            training_load_peak: {
                let unscaled = (m.training_load_peak + 0.0) * 65536.0;
                if unscaled.is_nan() || unscaled.is_infinite() || unscaled > i32::MAX as f64 {
                    i32::MAX
                } else {
                    unscaled as i32
                }
            },
            enhanced_avg_respiration_rate: {
                let unscaled = (m.enhanced_avg_respiration_rate + 0.0) * 100.0;
                if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u16::MAX as f64 {
                    u16::MAX
                } else {
                    unscaled as u16
                }
            },
            enhanced_max_respiration_rate: {
                let unscaled = (m.enhanced_max_respiration_rate + 0.0) * 100.0;
                if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u16::MAX as f64 {
                    u16::MAX
                } else {
                    unscaled as u16
                }
            },
            enhanced_min_respiration_rate: {
                let unscaled = (m.enhanced_min_respiration_rate + 0.0) * 100.0;
                if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u16::MAX as f64 {
                    u16::MAX
                } else {
                    unscaled as u16
                }
            },
            total_grit: m.total_grit,
            total_flow: m.total_flow,
            jump_count: m.jump_count,
            avg_grit: m.avg_grit,
            avg_flow: m.avg_flow,
            workout_feel: m.workout_feel,
            workout_rpe: m.workout_rpe,
            avg_spo2: m.avg_spo2,
            avg_stress: m.avg_stress,
            metabolic_calories: m.metabolic_calories,
            sdrr_hrv: m.sdrr_hrv,
            rmssd_hrv: m.rmssd_hrv,
            total_fractional_ascent: {
                let unscaled = (m.total_fractional_ascent + 0.0) * 100.0;
                if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u8::MAX as f64 {
                    u8::MAX
                } else {
                    unscaled as u8
                }
            },
            total_fractional_descent: {
                let unscaled = (m.total_fractional_descent + 0.0) * 100.0;
                if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u8::MAX as f64 {
                    u8::MAX
                } else {
                    unscaled as u8
                }
            },
            avg_core_temperature: {
                let unscaled = (m.avg_core_temperature + 0.0) * 100.0;
                if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u16::MAX as f64 {
                    u16::MAX
                } else {
                    unscaled as u16
                }
            },
            min_core_temperature: {
                let unscaled = (m.min_core_temperature + 0.0) * 100.0;
                if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u16::MAX as f64 {
                    u16::MAX
                } else {
                    unscaled as u16
                }
            },
            max_core_temperature: {
                let unscaled = (m.max_core_temperature + 0.0) * 100.0;
                if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u16::MAX as f64 {
                    u16::MAX
                } else {
                    unscaled as u16
                }
            },
            state: [0u8; 23],
            unknown_fields: m.unknown_fields,
            developer_fields: m.developer_fields,
        }
    }
}

#[cfg(feature = "serde")]
impl Default for De {
    fn default() -> Self {
        Self {
            message_index: typedef::MessageIndex(u16::MAX),
            timestamp: None,
            event: typedef::Event(u8::MAX),
            event_type: typedef::EventType(u8::MAX),
            start_time: None,
            start_position_lat: f64::from_bits(u64::MAX),
            start_position_long: f64::from_bits(u64::MAX),
            sport: typedef::Sport(u8::MAX),
            sub_sport: typedef::SubSport(u8::MAX),
            total_elapsed_time: f64::from_bits(u64::MAX),
            total_timer_time: f64::from_bits(u64::MAX),
            total_distance: f64::from_bits(u64::MAX),
            total_cycles: u32::MAX,
            total_calories: u16::MAX,
            total_fat_calories: u16::MAX,
            avg_speed: f64::from_bits(u64::MAX),
            max_speed: f64::from_bits(u64::MAX),
            avg_heart_rate: u8::MAX,
            max_heart_rate: u8::MAX,
            avg_cadence: u8::MAX,
            max_cadence: u8::MAX,
            avg_power: u16::MAX,
            max_power: u16::MAX,
            total_ascent: u16::MAX,
            total_descent: u16::MAX,
            total_training_effect: f64::from_bits(u64::MAX),
            first_lap_index: u16::MAX,
            num_laps: u16::MAX,
            event_group: u8::MAX,
            trigger: typedef::SessionTrigger(u8::MAX),
            nec_lat: f64::from_bits(u64::MAX),
            nec_long: f64::from_bits(u64::MAX),
            swc_lat: f64::from_bits(u64::MAX),
            swc_long: f64::from_bits(u64::MAX),
            num_lengths: u16::MAX,
            normalized_power: u16::MAX,
            training_stress_score: f64::from_bits(u64::MAX),
            intensity_factor: f64::from_bits(u64::MAX),
            left_right_balance: typedef::LeftRightBalance100(u16::MAX),
            end_position_lat: f64::from_bits(u64::MAX),
            end_position_long: f64::from_bits(u64::MAX),
            avg_stroke_count: f64::from_bits(u64::MAX),
            avg_stroke_distance: f64::from_bits(u64::MAX),
            swim_stroke: typedef::SwimStroke(u8::MAX),
            pool_length: f64::from_bits(u64::MAX),
            threshold_power: u16::MAX,
            pool_length_unit: typedef::DisplayMeasure(u8::MAX),
            num_active_lengths: u16::MAX,
            total_work: u32::MAX,
            avg_altitude: f64::from_bits(u64::MAX),
            max_altitude: f64::from_bits(u64::MAX),
            gps_accuracy: u8::MAX,
            avg_grade: f64::from_bits(u64::MAX),
            avg_pos_grade: f64::from_bits(u64::MAX),
            avg_neg_grade: f64::from_bits(u64::MAX),
            max_pos_grade: f64::from_bits(u64::MAX),
            max_neg_grade: f64::from_bits(u64::MAX),
            avg_temperature: i8::MAX,
            max_temperature: i8::MAX,
            total_moving_time: f64::from_bits(u64::MAX),
            avg_pos_vertical_speed: f64::from_bits(u64::MAX),
            avg_neg_vertical_speed: f64::from_bits(u64::MAX),
            max_pos_vertical_speed: f64::from_bits(u64::MAX),
            max_neg_vertical_speed: f64::from_bits(u64::MAX),
            min_heart_rate: u8::MAX,
            time_in_hr_zone: Vec::new(),
            time_in_speed_zone: Vec::new(),
            time_in_cadence_zone: Vec::new(),
            time_in_power_zone: Vec::new(),
            avg_lap_time: f64::from_bits(u64::MAX),
            best_lap_index: u16::MAX,
            min_altitude: f64::from_bits(u64::MAX),
            active_time: f64::from_bits(u64::MAX),
            player_score: u16::MAX,
            opponent_score: u16::MAX,
            opponent_name: String::new(),
            stroke_count: Vec::new(),
            zone_count: Vec::new(),
            max_ball_speed: f64::from_bits(u64::MAX),
            avg_ball_speed: f64::from_bits(u64::MAX),
            avg_vertical_oscillation: f64::from_bits(u64::MAX),
            avg_stance_time_percent: f64::from_bits(u64::MAX),
            avg_stance_time: f64::from_bits(u64::MAX),
            avg_fractional_cadence: f64::from_bits(u64::MAX),
            max_fractional_cadence: f64::from_bits(u64::MAX),
            total_fractional_cycles: f64::from_bits(u64::MAX),
            avg_total_hemoglobin_conc: Vec::new(),
            min_total_hemoglobin_conc: Vec::new(),
            max_total_hemoglobin_conc: Vec::new(),
            avg_saturated_hemoglobin_percent: Vec::new(),
            min_saturated_hemoglobin_percent: Vec::new(),
            max_saturated_hemoglobin_percent: Vec::new(),
            avg_left_torque_effectiveness: f64::from_bits(u64::MAX),
            avg_right_torque_effectiveness: f64::from_bits(u64::MAX),
            avg_left_pedal_smoothness: f64::from_bits(u64::MAX),
            avg_right_pedal_smoothness: f64::from_bits(u64::MAX),
            avg_combined_pedal_smoothness: f64::from_bits(u64::MAX),
            sport_profile_name: String::new(),
            sport_index: u8::MAX,
            time_standing: f64::from_bits(u64::MAX),
            stand_count: u16::MAX,
            avg_left_pco: i8::MAX,
            avg_right_pco: i8::MAX,
            avg_left_power_phase: Vec::new(),
            avg_left_power_phase_peak: Vec::new(),
            avg_right_power_phase: Vec::new(),
            avg_right_power_phase_peak: Vec::new(),
            avg_power_position: Vec::new(),
            max_power_position: Vec::new(),
            avg_cadence_position: Vec::new(),
            max_cadence_position: Vec::new(),
            enhanced_avg_speed: f64::from_bits(u64::MAX),
            enhanced_max_speed: f64::from_bits(u64::MAX),
            enhanced_avg_altitude: f64::from_bits(u64::MAX),
            enhanced_min_altitude: f64::from_bits(u64::MAX),
            enhanced_max_altitude: f64::from_bits(u64::MAX),
            avg_lev_motor_power: u16::MAX,
            max_lev_motor_power: u16::MAX,
            lev_battery_consumption: f64::from_bits(u64::MAX),
            avg_vertical_ratio: f64::from_bits(u64::MAX),
            avg_stance_time_balance: f64::from_bits(u64::MAX),
            avg_step_length: f64::from_bits(u64::MAX),
            total_anaerobic_training_effect: f64::from_bits(u64::MAX),
            avg_vam: f64::from_bits(u64::MAX),
            avg_depth: f64::from_bits(u64::MAX),
            max_depth: f64::from_bits(u64::MAX),
            surface_interval: u32::MAX,
            start_cns: u8::MAX,
            end_cns: u8::MAX,
            start_n2: u16::MAX,
            end_n2: u16::MAX,
            avg_respiration_rate: u8::MAX,
            max_respiration_rate: u8::MAX,
            min_respiration_rate: u8::MAX,
            min_temperature: i8::MAX,
            o2_toxicity: u16::MAX,
            dive_number: u32::MAX,
            training_load_peak: f64::from_bits(u64::MAX),
            enhanced_avg_respiration_rate: f64::from_bits(u64::MAX),
            enhanced_max_respiration_rate: f64::from_bits(u64::MAX),
            enhanced_min_respiration_rate: f64::from_bits(u64::MAX),
            total_grit: f32::from_bits(u32::MAX),
            total_flow: f32::from_bits(u32::MAX),
            jump_count: u16::MAX,
            avg_grit: f32::from_bits(u32::MAX),
            avg_flow: f32::from_bits(u32::MAX),
            workout_feel: u8::MAX,
            workout_rpe: u8::MAX,
            avg_spo2: u8::MAX,
            avg_stress: u8::MAX,
            metabolic_calories: u16::MAX,
            sdrr_hrv: u8::MAX,
            rmssd_hrv: u8::MAX,
            total_fractional_ascent: f64::from_bits(u64::MAX),
            total_fractional_descent: f64::from_bits(u64::MAX),
            avg_core_temperature: f64::from_bits(u64::MAX),
            min_core_temperature: f64::from_bits(u64::MAX),
            max_core_temperature: f64::from_bits(u64::MAX),
            unknown_fields: Vec::new(),
            developer_fields: Vec::new(),
        }
    }
}