@sports-alliance/sports-lib 6.0.4 → 6.1.0

package/lib/esm/data/data.store.js

@@ -0,0 +1,1209 @@
+import { DataVerticalSpeed, DataVerticalSpeedFeetPerHour, DataVerticalSpeedFeetPerMinute, DataVerticalSpeedFeetPerSecond, DataVerticalSpeedKilometerPerHour, DataVerticalSpeedMetersPerHour, DataVerticalSpeedMetersPerMinute, DataVerticalSpeedMilesPerHour } from './data.vertical-speed';
+import { DataTemperature } from './data.temperature';
+import { DataSpeed, DataSpeedFeetPerMinute, DataSpeedFeetPerSecond, DataSpeedKilometersPerHour, DataSpeedKnots, DataSpeedMetersPerMinute, DataSpeedMilesPerHour } from './data.speed';
+import { DataSeaLevelPressure } from './data.sea-level-pressure';
+import { DataSatellite5BestSNR } from './data.satellite-5-best-snr';
+import { DataAbsolutePressure } from './data.absolute-pressure';
+import { DataAltitude } from './data.altitude';
+import { DataCadence } from './data.cadence';
+import { DataDistance, DataDistanceMiles } from './data.distance';
+import { DataDuration } from './data.duration';
+import { DataEHPE } from './data.ehpe';
+import { DataEVPE } from './data.evpe';
+import { DataHeartRate } from './data.heart-rate';
+import { DataLatitudeDegrees } from './data.latitude-degrees';
+import { DataLongitudeDegrees } from './data.longitude-degrees';
+import { DataNumberOfSatellites } from './data.number-of-satellites';
+import { DataPower } from './data.power';
+import { DataGPSAltitude } from './data.altitude-gps';
+import { DataAltitudeMin } from './data.altitude-min';
+import { DataAltitudeMax } from './data.altitude-max';
+import { DataVO2Max } from './data.vo2-max';
+import { DataVerticalSpeedMin, DataVerticalSpeedMinFeetPerHour, DataVerticalSpeedMinFeetPerMinute, DataVerticalSpeedMinFeetPerSecond, DataVerticalSpeedMinKilometerPerHour, DataVerticalSpeedMinMetersPerHour, DataVerticalSpeedMinMetersPerMinute, DataVerticalSpeedMinMilesPerHour } from './data.vertical-speed-min';
+import { DataVerticalSpeedMax, DataVerticalSpeedMaxFeetPerHour, DataVerticalSpeedMaxFeetPerMinute, DataVerticalSpeedMaxFeetPerSecond, DataVerticalSpeedMaxKilometerPerHour, DataVerticalSpeedMaxMetersPerHour, DataVerticalSpeedMaxMetersPerMinute, DataVerticalSpeedMaxMilesPerHour } from './data.vertical-speed-max';
+import { DataVerticalSpeedAvg, DataVerticalSpeedAvgFeetPerHour, DataVerticalSpeedAvgFeetPerMinute, DataVerticalSpeedAvgFeetPerSecond, DataVerticalSpeedAvgKilometerPerHour, DataVerticalSpeedAvgMetersPerHour, DataVerticalSpeedAvgMetersPerMinute, DataVerticalSpeedAvgMilesPerHour } from './data.vertical-speed-avg';
+import { DataTemperatureMin } from './data.temperature-min';
+import { DataTemperatureMax } from './data.temperature-max';
+import { DataTemperatureAvg } from './data.temperature-avg';
+import { DataSpeedMin, DataSpeedMinFeetPerMinute, DataSpeedMinFeetPerSecond, DataSpeedMinKilometersPerHour, DataSpeedMinKnots, DataSpeedMinMetersPerMinute, DataSpeedMinMilesPerHour } from './data.speed-min';
+import { DataSpeedMax, DataSpeedMaxFeetPerMinute, DataSpeedMaxFeetPerSecond, DataSpeedMaxKilometersPerHour, DataSpeedMaxKnots, DataSpeedMaxMetersPerMinute, DataSpeedMaxMilesPerHour } from './data.speed-max';
+import { DataSpeedAvg, DataSpeedAvgFeetPerMinute, DataSpeedAvgFeetPerSecond, DataSpeedAvgKilometersPerHour, DataSpeedAvgKnots, DataSpeedAvgMetersPerMinute, DataSpeedAvgMilesPerHour } from './data.speed-avg';
+import { DataRecoveryTime } from './data.recovery-time';
+import { DataPowerMin } from './data.power-min';
+import { DataPowerMax } from './data.power-max';
+import { DataPowerAvg } from './data.power-avg';
+import { DataPeakTrainingEffect } from './data.peak-training-effect';
+import { DataPause } from './data.pause';
+import { DataHeartRateMin } from './data.heart-rate-min';
+import { DataHeartRateMax } from './data.heart-rate-max';
+import { DataHeartRateAvg } from './data.heart-rate-avg';
+import { DataFeeling } from './data.feeling';
+import { DataEPOC } from './data.epoc';
+import { DataEnergy } from './data.energy';
+import { DataDescentTime } from './data.descent-time';
+import { DataDescent } from './data.descent';
+import { DataCadenceMin } from './data.cadence-min';
+import { DataCadenceMax } from './data.cadence-max';
+import { DataCadenceAvg } from './data.cadence-avg';
+import { DataAscentTime } from './data.ascent-time';
+import { DataAscent } from './data.ascent';
+import { DataAltitudeAvg } from './data.altitude-avg';
+import { DataFusedLocation } from './data.fused-location';
+import { DataPaceMin, DataPaceMinMinutesPerMile } from './data.pace-min';
+import { DataPaceMax, DataPaceMaxMinutesPerMile } from './data.pace-max';
+import { DataPaceAvg, DataPaceAvgMinutesPerMile } from './data.pace-avg';
+import { DataPace, DataPaceMinutesPerMile } from './data.pace';
+import { DataFusedAltitude } from './data.fused-altitude';
+import { DataBatteryCharge } from './data.battery-charge';
+import { DataBatteryCurrent } from './data.battery-current';
+import { DataBatteryVoltage } from './data.battery-voltage';
+import { DataBatteryConsumption } from './data.battery-consumption';
+import { DataBatteryLifeEstimation } from './data.battery-life-estimation';
+import { DataFormPower } from './data.form-power';
+import { DataLegStiffness, DataLegSpringStiffness } from './data.leg-stiffness';
+import { DataVerticalOscillation } from './data.vertical-oscillation';
+import { DataAerobicTrainingEffect } from './data-aerobic-training-effect';
+import { DataNumberOfSamples } from './data.number-of.samples';
+import { DataFootPodUsed } from './data.foot-pod-used';
+import { DataAutoPauseUsed } from './data.auto-pause-used';
+import { DataAutoLapDuration } from './data.auto-lap-duration';
+import { DataAutoLapDistance } from './data.auto-lap-distance';
+import { DataAutoLapUsed } from './data.auto-lap-used';
+import { DataBikePodUsed } from './data.bike-pod-used';
+import { DataEnabledNavigationSystems } from './data.enabled-navigation-systems';
+import { DataHeartRateUsed } from './data.heart-rate-used';
+import { DataPowerPodUsed } from './data.power-pod-used';
+import { DataAltiBaroProfile } from './data.alti-baro-profile';
+import { DataIBI } from './data.ibi';
+import { DataSteps } from './data.steps';
+import { DataPoolLength } from './data.pool-length';
+import { DataDeviceLocation } from './data.device-location';
+import { DataPeakEPOC } from './data.peak-epoc';
+import { DataDeviceNames } from './data.device-names';
+import { DataActivityTypes } from './data.activity-types';
+import { DataStartAltitude } from './data.start-altitude';
+import { DataEndAltitude } from './data.end-altitude';
+import { DataSwimPace, DataSwimPaceMinutesPer100Yard } from './data.swim-pace';
+import { DataSwimPaceAvg, DataSwimPaceAvgMinutesPer100Yard } from './data.swim-pace-avg';
+import { DataSwimPaceMax, DataSwimPaceMaxMinutesPer100Yard } from './data.swim-pace-max';
+import { DataSwimPaceMin, DataSwimPaceMinMinutesPer100Yard } from './data.swim-pace-min';
+import { DataSWOLF25m } from './data.swolf-25m';
+import { DataAccumulatedPower } from './data.accumulated-power';
+import { DataStrydDistance } from './data.stryd-distance';
+import { DataStrydSpeed } from './data.stryd-speed';
+import { DataStrydAltitude } from './data.stryd-altitude';
+import { DataLeftBalance } from './data.left-balance';
+import { DataRightBalance } from './data.right-balance';
+import { DataRPE } from './data.rpe';
+import { DataPowerRight } from './data.power-right';
+import { DataPowerLeft } from './data.power-left';
+import { DataStanceTime } from './data.stance-time';
+import { DataStanceTimeBalanceLeft } from './data-stance-time-balance-left';
+import { DataStepLength } from './data.step-length';
+import { DataVerticalRatio } from './data.vertical-ratio';
+import { DataDescription } from './data.description';
+import { DataAirPower } from './data.air-power';
+import { DataGroundTime } from './data.ground-time';
+import { DataAirPowerMax } from './data.air-power-max';
+import { DataAirPowerMin } from './data.air-power-min';
+import { DataAirPowerAvg } from './data.air-power-avg';
+import { DataGNSSDistance } from './data.gnss-distance';
+import { DataHeartRateZoneOneDuration } from './data.heart-rate-zone-one-duration';
+import { DataHeartRateZoneTwoDuration } from './data.heart-rate-zone-two-duration';
+import { DataHeartRateZoneThreeDuration } from './data.heart-rate-zone-three-duration';
+import { DataHeartRateZoneFourDuration } from './data.heart-rate-zone-four-duration';
+import { DataHeartRateZoneFiveDuration } from './data.heart-rate-zone-five-duration';
+import { DataSpeedZoneOneDuration } from './data.speed-zone-one-duration';
+import { DataSpeedZoneTwoDuration } from './data.speed-zone-two-duration';
+import { DataSpeedZoneThreeDuration } from './data.speed-zone-three-duration';
+import { DataSpeedZoneFourDuration } from './data.speed-zone-four-duration';
+import { DataSpeedZoneFiveDuration } from './data.speed-zone-five-duration';
+import { DataPowerZoneOneDuration } from './data.power-zone-one-duration';
+import { DataPowerZoneTwoDuration } from './data.power-zone-two-duration';
+import { DataPowerZoneThreeDuration } from './data.power-zone-three-duration';
+import { DataPowerZoneFiveDuration } from './data.power-zone-five-duration';
+import { DataPowerZoneFourDuration } from './data.power-zone-four-duration';
+import { DataPosition } from './data.position';
+import { DataStartPosition } from './data.start-position';
+import { DataEndPosition } from './data.end-position';
+import { DataGrade } from './data.grade';
+import { DataGradeAdjustedSpeed, DataGradeAdjustedSpeedFeetPerMinute, DataGradeAdjustedSpeedFeetPerSecond, DataGradeAdjustedSpeedKilometersPerHour, DataGradeAdjustedSpeedKnots, DataGradeAdjustedSpeedMetersPerMinute, DataGradeAdjustedSpeedMilesPerHour } from './data.grade-adjusted-speed';
+import { DataGradeAdjustedPace, DataGradeAdjustedPaceMinutesPerMile } from './data.grade-adjusted-pace';
+import { DataGradeAdjustedSpeedMax, DataGradeAdjustedSpeedMaxFeetPerMinute, DataGradeAdjustedSpeedMaxFeetPerSecond, DataGradeAdjustedSpeedMaxKilometersPerHour, DataGradeAdjustedSpeedMaxKnots, DataGradeAdjustedSpeedMaxMetersPerMinute, DataGradeAdjustedSpeedMaxMilesPerHour } from './data.grade-adjusted-speed-max';
+import { DataGradeAdjustedSpeedMin, DataGradeAdjustedSpeedMinFeetPerMinute, DataGradeAdjustedSpeedMinFeetPerSecond, DataGradeAdjustedSpeedMinKilometersPerHour, DataGradeAdjustedSpeedMinKnots, DataGradeAdjustedSpeedMinMetersPerMinute, DataGradeAdjustedSpeedMinMilesPerHour } from './data.grade-adjusted-speed-min';
+import { DataGradeAdjustedSpeedAvg, DataGradeAdjustedSpeedAvgFeetPerMinute, DataGradeAdjustedSpeedAvgFeetPerSecond, DataGradeAdjustedSpeedAvgKilometersPerHour, DataGradeAdjustedSpeedAvgKnots, DataGradeAdjustedSpeedAvgMetersPerMinute, DataGradeAdjustedSpeedAvgMilesPerHour } from './data.grade-adjusted-speed-avg';
+import { DataGradeAdjustedPaceAvg, DataGradeAdjustedPaceAvgMinutesPerMile } from './data.grade-adjusted-pace-avg';
+import { DataGradeAdjustedPaceMax, DataGradeAdjustedPaceMaxMinutesPerMile } from './data.grade-adjusted-pace-max';
+import { DataGradeAdjustedPaceMin, DataGradeAdjustedPaceMinMinutesPerMile } from './data.grade-adjusted-pace-min';
+import { DataStepsOld } from './data.steps-old';
+import { DataStopEvent } from './data.stop-event';
+import { DataStartEvent } from './data.start-event';
+import { DataStopAllEvent } from './data.stop-all-event';
+import { DataTime } from './data.time';
+import { convertMetersToMiles, convertPaceToPaceInMinutesPerMile, convertSpeedToSpeedInFeetPerHour, convertSpeedToSpeedInFeetPerMinute, convertSpeedToSpeedInFeetPerSecond, convertSpeedToSpeedInKilometersPerHour, convertSpeedToSpeedInKnots, convertSpeedToSpeedInMetersPerHour, convertSpeedToSpeedInMetersPerMinute, convertSpeedToSpeedInMilesPerHour, convertSwimPaceToSwimPacePer100Yard } from '../events/utilities/helpers';
+import { DataMovingTime } from './data.moving-time';
+import { DataSWOLF50m } from './data.swolf-50m';
+import { DataTimerTime } from './data.timer-time';
+import { DataActiveLap } from './data-active-lap';
+import { DataActiveLengths } from './data-active-lengths';
+import { DataAnaerobicTrainingEffect } from './data-anaerobic-training-effect';
+import { DataTotalCycles } from './data-total-cycles';
+import { DataPowerIntensityFactor } from './data.power-intensity-factor';
+import { DataPowerNormalized } from './data.power-normalized';
+import { DataPowerPedalSmoothnessLeft } from './data.power-pedal-smoothness-left';
+import { DataPowerPedalSmoothnessRight } from './data.power-pedal-smoothness-right';
+import { DataPowerTorqueEffectivenessLeft } from './data.power-torque-effectiveness-left';
+import { DataPowerTorqueEffectivenessRight } from './data.power-torque-effectiveness-right';
+import { DataPowerTrainingStressScore } from './data.power-training-stress-score';
+import { DataPowerWork } from './data.power-work';
+import { DataPowerDown } from './data.power-down';
+import { DataPowerUp } from './data.power-up';
+import { DataTargetPowerZone } from './data.target-power-zone';
+import { DataTargetHeartRateZone } from './data.target-heart-rate-zone';
+import { DataTargetSpeedZone } from './data.target-speed-zone';
+import { DataTargetDistance } from './data.target-distance';
+import { DataTargetTime } from './data.target-time';
+import { DataStanceTimeBalanceRight } from './data-stance-time-balance-right';
+import { DataRiderPositionChangeEvent } from './data.rider-position-change-event';
+import { DataSportProfileName } from './data.sport-profile-name';
+import { DataBalance } from './data.balance';
+import { DataAltitudeSmooth } from './data.altitude-smooth';
+import { DataAvgStrideLength } from './data.avg-stride-length';
+import { DataCyclingSeatedTime } from './data.cycling-seated-time';
+import { DataCyclingStandingTime } from './data.cycling-standing-time';
+import { DataGradeSmooth } from './data.grade-smooth';
+// "Total Training effect" was renamed to "Aerobic Training Effect" in sports-lib 6.0
+export class DataTotalTrainingEffectLegacy extends DataAerobicTrainingEffect {
+}
+DataTotalTrainingEffectLegacy.type = 'Total Training effect';
+/**
+ * Only concrete classes no abstracts
+ */
+export const DataStore = {
+    DataVerticalSpeed,
+    DataTemperature,
+    DataSpeed,
+    DataGradeAdjustedSpeed,
+    DataSeaLevelPressure,
+    DataSatellite5BestSNR,
+    DataPower,
+    DataNumberOfSatellites,
+    DataLongitudeDegrees,
+    DataLatitudeDegrees,
+    DataHeartRate,
+    DataEVPE,
+    DataEHPE,
+    DataDuration,
+    DataDistance,
+    DataCadence,
+    DataGPSAltitude,
+    DataAltitude,
+    DataAbsolutePressure,
+    DataVO2Max,
+    DataVerticalSpeedMin,
+    DataVerticalSpeedMax,
+    DataVerticalSpeedAvg,
+    DataTemperatureMin,
+    DataTemperatureMax,
+    DataTemperatureAvg,
+    DataSpeedMin,
+    DataSpeedMax,
+    DataSpeedAvg,
+    DataGradeAdjustedSpeedMin,
+    DataGradeAdjustedSpeedMax,
+    DataGradeAdjustedSpeedAvg,
+    DataRecoveryTime,
+    DataPowerMin,
+    DataPowerMax,
+    DataPowerAvg,
+    DataPeakTrainingEffect,
+    DataPause,
+    DataHeartRateMin,
+    DataHeartRateMax,
+    DataHeartRateAvg,
+    DataFeeling,
+    DataEPOC,
+    DataEnergy,
+    DataDescentTime,
+    DataDescent,
+    DataCadenceMin,
+    DataCadenceMax,
+    DataCadenceAvg,
+    DataAscentTime,
+    DataAscent,
+    DataAltitudeMin,
+    DataAltitudeMax,
+    DataAltitudeAvg,
+    DataFusedLocation,
+    DataFusedAltitude,
+    DataPace,
+    DataPaceMin,
+    DataPaceMax,
+    DataPaceAvg,
+    DataGradeAdjustedPace,
+    DataGradeAdjustedPaceMin,
+    DataGradeAdjustedPaceMax,
+    DataGradeAdjustedPaceAvg,
+    DataSwimPace,
+    DataSwimPaceMin,
+    DataSwimPaceMax,
+    DataSwimPaceAvg,
+    DataNumberOfSamples,
+    DataBatteryCharge,
+    DataBatteryCurrent,
+    DataBatteryVoltage,
+    DataBatteryConsumption,
+    DataBatteryLifeEstimation,
+    DataFormPower,
+    DataLegStiffness,
+    DataLegSpringStiffness,
+    DataVerticalOscillation,
+    DataAerobicTrainingEffect,
+    DataFootPodUsed,
+    DataAltiBaroProfile,
+    DataAutoPauseUsed,
+    DataAutoLapDuration,
+    DataAutoLapDistance,
+    DataAutoLapUsed,
+    DataBikePodUsed,
+    DataEnabledNavigationSystems,
+    DataHeartRateUsed,
+    DataPowerPodUsed,
+    DataSpeedKilometersPerHour,
+    DataSpeedMilesPerHour,
+    DataSpeedFeetPerSecond,
+    DataSpeedMetersPerMinute,
+    DataSpeedFeetPerMinute,
+    DataSpeedAvgKilometersPerHour,
+    DataSpeedAvgMilesPerHour,
+    DataSpeedAvgFeetPerSecond,
+    DataSpeedAvgMetersPerMinute,
+    DataSpeedAvgFeetPerMinute,
+    DataSpeedMinKilometersPerHour,
+    DataSpeedMinMilesPerHour,
+    DataSpeedMinFeetPerSecond,
+    DataSpeedMinMetersPerMinute,
+    DataSpeedMinFeetPerMinute,
+    DataSpeedMaxKilometersPerHour,
+    DataSpeedMaxMilesPerHour,
+    DataSpeedMaxFeetPerSecond,
+    DataSpeedMaxMetersPerMinute,
+    DataSpeedMaxFeetPerMinute,
+    DataSpeedKnots,
+    DataSpeedAvgKnots,
+    DataSpeedMinKnots,
+    DataSpeedMaxKnots,
+    DataGradeAdjustedSpeedKilometersPerHour,
+    DataGradeAdjustedSpeedMilesPerHour,
+    DataGradeAdjustedSpeedFeetPerSecond,
+    DataGradeAdjustedSpeedMetersPerMinute,
+    DataGradeAdjustedSpeedFeetPerMinute,
+    DataGradeAdjustedSpeedAvgKilometersPerHour,
+    DataGradeAdjustedSpeedAvgMilesPerHour,
+    DataGradeAdjustedSpeedAvgFeetPerSecond,
+    DataGradeAdjustedSpeedAvgMetersPerMinute,
+    DataGradeAdjustedSpeedAvgFeetPerMinute,
+    DataGradeAdjustedSpeedMinKilometersPerHour,
+    DataGradeAdjustedSpeedMinMilesPerHour,
+    DataGradeAdjustedSpeedMinFeetPerSecond,
+    DataGradeAdjustedSpeedMinMetersPerMinute,
+    DataGradeAdjustedSpeedMinFeetPerMinute,
+    DataGradeAdjustedSpeedMaxKilometersPerHour,
+    DataGradeAdjustedSpeedMaxMilesPerHour,
+    DataGradeAdjustedSpeedMaxFeetPerSecond,
+    DataGradeAdjustedSpeedMaxMetersPerMinute,
+    DataGradeAdjustedSpeedMaxFeetPerMinute,
+    DataGradeAdjustedSpeedKnots,
+    DataGradeAdjustedSpeedAvgKnots,
+    DataGradeAdjustedSpeedMinKnots,
+    DataGradeAdjustedSpeedMaxKnots,
+    DataPaceMinutesPerMile,
+    DataPaceAvgMinutesPerMile,
+    DataPaceMinMinutesPerMile,
+    DataPaceMaxMinutesPerMile,
+    DataGradeAdjustedPaceMinutesPerMile,
+    DataGradeAdjustedPaceAvgMinutesPerMile,
+    DataGradeAdjustedPaceMinMinutesPerMile,
+    DataGradeAdjustedPaceMaxMinutesPerMile,
+    DataSwimPaceMinutesPer100Yard,
+    DataSwimPaceAvgMinutesPer100Yard,
+    DataSwimPaceMinMinutesPer100Yard,
+    DataSwimPaceMaxMinutesPer100Yard,
+    DataVerticalSpeedFeetPerSecond,
+    DataVerticalSpeedMetersPerMinute,
+    DataVerticalSpeedFeetPerMinute,
+    DataVerticalSpeedMetersPerHour,
+    DataVerticalSpeedFeetPerHour,
+    DataVerticalSpeedKilometerPerHour,
+    DataVerticalSpeedMilesPerHour,
+    DataVerticalSpeedAvgFeetPerSecond,
+    DataVerticalSpeedAvgMetersPerMinute,
+    DataVerticalSpeedAvgFeetPerMinute,
+    DataVerticalSpeedAvgMetersPerHour,
+    DataVerticalSpeedAvgFeetPerHour,
+    DataVerticalSpeedAvgKilometerPerHour,
+    DataVerticalSpeedAvgMilesPerHour,
+    DataVerticalSpeedMaxFeetPerSecond,
+    DataVerticalSpeedMaxMetersPerMinute,
+    DataVerticalSpeedMaxFeetPerMinute,
+    DataVerticalSpeedMaxMetersPerHour,
+    DataVerticalSpeedMaxFeetPerHour,
+    DataVerticalSpeedMaxKilometerPerHour,
+    DataVerticalSpeedMaxMilesPerHour,
+    DataVerticalSpeedMinFeetPerSecond,
+    DataVerticalSpeedMinMetersPerMinute,
+    DataVerticalSpeedMinFeetPerMinute,
+    DataVerticalSpeedMinMetersPerHour,
+    DataVerticalSpeedMinFeetPerHour,
+    DataVerticalSpeedMinKilometerPerHour,
+    DataVerticalSpeedMinMilesPerHour,
+    DataIBI,
+    DataSteps,
+    DataStepsOld,
+    DataStrydAltitude,
+    DataStrydSpeed,
+    DataStrydDistance,
+    DataPoolLength,
+    DataDeviceLocation,
+    DataPeakEPOC,
+    DataActivityTypes,
+    DataDeviceNames,
+    DataStartAltitude,
+    DataEndAltitude,
+    DataSWOLF25m,
+    DataSWOLF50m,
+    DataAccumulatedPower,
+    DataLeftBalance,
+    DataRightBalance,
+    DataPowerLeft,
+    DataPowerRight,
+    DataRPE,
+    DataStanceTime,
+    DataStanceTimeBalanceRight,
+    DataStanceTimeBalanceLeft,
+    DataStepLength,
+    DataVerticalRatio,
+    DataDescription,
+    DataGroundTime,
+    DataAirPower,
+    DataAirPowerAvg,
+    DataAirPowerMax,
+    DataAirPowerMin,
+    DataGNSSDistance,
+    DataHeartRateZoneOneDuration,
+    DataHeartRateZoneTwoDuration,
+    DataHeartRateZoneThreeDuration,
+    DataHeartRateZoneFourDuration,
+    DataHeartRateZoneFiveDuration,
+    DataPowerZoneOneDuration,
+    DataPowerZoneTwoDuration,
+    DataPowerZoneThreeDuration,
+    DataPowerZoneFourDuration,
+    DataPowerZoneFiveDuration,
+    DataSpeedZoneOneDuration,
+    DataSpeedZoneTwoDuration,
+    DataSpeedZoneThreeDuration,
+    DataSpeedZoneFourDuration,
+    DataSpeedZoneFiveDuration,
+    DataPosition,
+    DataStartPosition,
+    DataEndPosition,
+    DataGrade,
+    DataStartEvent,
+    DataStopEvent,
+    DataStopAllEvent,
+    DataTime,
+    DataDistanceMiles,
+    DataMovingTime,
+    DataTimerTime,
+    DataActiveLap,
+    DataActiveLengths,
+    DataAnaerobicTrainingEffect,
+    DataTotalCycles,
+    DataPowerIntensityFactor,
+    DataPowerNormalized,
+    DataPowerPedalSmoothnessLeft,
+    DataPowerPedalSmoothnessRight,
+    DataPowerTorqueEffectivenessLeft,
+    DataPowerTorqueEffectivenessRight,
+    DataPowerTrainingStressScore,
+    DataPowerWork,
+    DataRiderPositionChangeEvent,
+    DataSportProfileName,
+    DataBalance,
+    DataAltitudeSmooth,
+    DataAvgStrideLength,
+    DataCyclingSeatedTime,
+    DataCyclingStandingTime,
+    DataGradeSmooth,
+    DataPowerDown,
+    DataPowerUp,
+    DataTargetPowerZone,
+    DataTargetHeartRateZone,
+    DataTargetSpeedZone,
+    DataTargetDistance,
+    DataTargetTime,
+    DataTotalTrainingEffectLegacy
+};
+export class DynamicDataLoader {
+    static getDataInstanceFromDataType(dataType, opts) {
+        const className = Object.keys(DataStore).find(dataClass => {
+            return DataStore[dataClass] && DataStore[dataClass].type && DataStore[dataClass].type === dataType;
+        });
+        if (!className || !DataStore[className]) {
+            throw new Error(`Class type of '${dataType}' is not in the store`);
+        }
+        return new DataStore[className](opts);
+    }
+    static getDataClassFromDataType(dataType) {
+        const className = Object.keys(DataStore).find(dataClass => {
+            return DataStore[dataClass] && DataStore[dataClass].type && DataStore[dataClass].type === dataType;
+        });
+        if (!className || !DataStore[className]) {
+            throw new Error(`Class type of '${dataType}' is not in the store`);
+        }
+        return DataStore[className];
+    }
+    static isUnitDerivedDataType(dataType) {
+        return this.allUnitDerivedDataTypes.indexOf(dataType) !== -1;
+    }
+    static isSpeedDerivedDataType(dataType) {
+        return this.speedDerivedDataTypes.indexOf(dataType) !== -1;
+    }
+    static isBlackListedStream(dataType) {
+        return [DataGNSSDistance.type, DataTime.type].indexOf(dataType) !== -1;
+    }
+    /**
+     * This get's the basic data types for the charts depending or not on the user datatype settings
+     * There are no unit specific datatypes here so if the user has selected pace it implies metric
+     */
+    static getNonUnitBasedDataTypes(showAllData, dataTypesToUse) {
+        // let dataTypes = DynamicDataLoader.basicDataTypes;
+        // Set the datatypes to show if all is selected
+        if (showAllData) {
+            return [...DynamicDataLoader.basicDataTypes, ...DynamicDataLoader.advancedDataTypes];
+        }
+        if (!dataTypesToUse) {
+            return DynamicDataLoader.basicDataTypes;
+        }
+        return dataTypesToUse;
+    }
+    /**
+     * This gets the base and extended unit datatypes from a datatype array depending on the user settings
+     * @param dataTypes
+     * @param userUnitSettings
+     */
+    static getUnitBasedDataTypesFromDataTypes(dataTypes, userUnitSettings) {
+        let unitBasedDataTypes = [];
+        if (!userUnitSettings) {
+            return unitBasedDataTypes;
+        }
+        if (dataTypes.indexOf(DataSpeed.type) !== -1) {
+            unitBasedDataTypes = unitBasedDataTypes.concat(userUnitSettings.speedUnits);
+            unitBasedDataTypes = unitBasedDataTypes.concat(userUnitSettings.swimPaceUnits);
+            unitBasedDataTypes = unitBasedDataTypes.concat(userUnitSettings.paceUnits);
+        }
+        if (dataTypes.indexOf(DataGradeAdjustedSpeed.type) !== -1) {
+            unitBasedDataTypes = unitBasedDataTypes.concat(userUnitSettings.gradeAdjustedSpeedUnits);
+            unitBasedDataTypes = unitBasedDataTypes.concat(userUnitSettings.gradeAdjustedPaceUnits);
+        }
+        if (dataTypes.indexOf(DataVerticalSpeed.type) !== -1) {
+            unitBasedDataTypes = unitBasedDataTypes.concat(userUnitSettings.verticalSpeedUnits);
+        }
+        return unitBasedDataTypes;
+    }
+    /**
+     * Gets the unitbased types
+     * @param dataType
+     * @param userUnitSettings
+     */
+    static getUnitBasedDataTypesFromDataType(dataType, userUnitSettings) {
+        if (!userUnitSettings) {
+            return [dataType];
+        }
+        if (dataType === DataSpeed.type) {
+            return userUnitSettings.speedUnits;
+        }
+        if (dataType === DataGradeAdjustedSpeed.type) {
+            return userUnitSettings.gradeAdjustedSpeedUnits;
+        }
+        if (dataType === DataPace.type) {
+            return userUnitSettings.paceUnits;
+        }
+        if (dataType === DataGradeAdjustedPace.type) {
+            return userUnitSettings.gradeAdjustedPaceUnits;
+        }
+        if (dataType === DataSwimPace.type) {
+            return userUnitSettings.swimPaceUnits;
+        }
+        if (dataType === DataVerticalSpeed.type) {
+            return userUnitSettings.verticalSpeedUnits;
+        }
+        return [dataType];
+    }
+    /**
+     * Gets back an array of the unit based data for the data that was asked
+     * For example if the user has for speed selected m/s+km/h doing:
+     * getUnitBasedDataFromData(speedData) will return an array of [DataSpeed, DataSpeedInKilometersPerHour] instances
+     * @param data
+     * @param userUnitSettings
+     * @todo move to solo unit settings eg speed settings
+     */
+    static getUnitBasedDataFromDataInstance(data, userUnitSettings) {
+        if (!userUnitSettings) {
+            return [data];
+        }
+        switch (data.getType()) {
+            // Speed
+            case DataSpeed.type:
+                return userUnitSettings.speedUnits.reduce((accu, unit) => {
+                    return [...accu, this.getDataInstanceFromDataType(unit, data.getValue(unit))];
+                }, []);
+            case DataSpeedAvg.type:
+                return userUnitSettings.speedUnits.reduce((accu, unit) => {
+                    switch (unit) {
+                        case DataSpeed.type:
+                            return [...accu, this.getDataInstanceFromDataType(DataSpeedAvg.type, data.getValue(unit))];
+                        case DataSpeedKilometersPerHour.type:
+                            return [
+                                ...accu,
+                                this.getDataInstanceFromDataType(DataSpeedAvgKilometersPerHour.type, data.getValue(unit))
+                            ];
+                        case DataSpeedMilesPerHour.type:
+                            return [...accu, this.getDataInstanceFromDataType(DataSpeedAvgMilesPerHour.type, data.getValue(unit))];
+                        case DataSpeedFeetPerSecond.type:
+                            return [...accu, this.getDataInstanceFromDataType(DataSpeedAvgFeetPerSecond.type, data.getValue(unit))];
+                        case DataSpeedMetersPerMinute.type:
+                            return [...accu, this.getDataInstanceFromDataType(DataSpeedAvgMetersPerMinute.type, data.getValue(unit))];
+                        case DataSpeedFeetPerMinute.type:
+                            return [...accu, this.getDataInstanceFromDataType(DataSpeedAvgFeetPerMinute.type, data.getValue(unit))];
+                        case DataSpeedKnots.type:
+                            return [...accu, this.getDataInstanceFromDataType(DataSpeedAvgKnots.type, data.getValue(unit))];
+                    }
+                    return accu;
+                }, []);
+            case DataSpeedMax.type:
+                return userUnitSettings.speedUnits.reduce((accu, unit) => {
+                    switch (unit) {
+                        case DataSpeed.type:
+                            return [...accu, this.getDataInstanceFromDataType(DataSpeedMax.type, data.getValue(unit))];
+                        case DataSpeedKilometersPerHour.type:
+                            return [
+                                ...accu,
+                                this.getDataInstanceFromDataType(DataSpeedMaxKilometersPerHour.type, data.getValue(unit))
+                            ];
+                        case DataSpeedMilesPerHour.type:
+                            return [...accu, this.getDataInstanceFromDataType(DataSpeedMaxMilesPerHour.type, data.getValue(unit))];
+                        case DataSpeedFeetPerSecond.type:
+                            return [...accu, this.getDataInstanceFromDataType(DataSpeedMaxFeetPerSecond.type, data.getValue(unit))];
+                        case DataSpeedMetersPerMinute.type:
+                            return [...accu, this.getDataInstanceFromDataType(DataSpeedMaxMetersPerMinute.type, data.getValue(unit))];
+                        case DataSpeedFeetPerMinute.type:
+                            return [...accu, this.getDataInstanceFromDataType(DataSpeedMaxFeetPerMinute.type, data.getValue(unit))];
+                        case DataSpeedKnots.type:
+                            return [...accu, this.getDataInstanceFromDataType(DataSpeedMaxKnots.type, data.getValue(unit))];
+                    }
+                    return accu;
+                }, []);
+            case DataSpeedMin.type:
+                return userUnitSettings.speedUnits.reduce((accu, unit) => {
+                    switch (unit) {
+                        case DataSpeed.type:
+                            return [...accu, this.getDataInstanceFromDataType(DataSpeedMin.type, data.getValue(unit))];
+                        case DataSpeedKilometersPerHour.type:
+                            return [
+                                ...accu,
+                                this.getDataInstanceFromDataType(DataSpeedMinKilometersPerHour.type, data.getValue(unit))
+                            ];
+                        case DataSpeedMilesPerHour.type:
+                            return [...accu, this.getDataInstanceFromDataType(DataSpeedMinMilesPerHour.type, data.getValue(unit))];
+                        case DataSpeedFeetPerSecond.type:
+                            return [...accu, this.getDataInstanceFromDataType(DataSpeedMinFeetPerSecond.type, data.getValue(unit))];
+                        case DataSpeedMetersPerMinute.type:
+                            return [...accu, this.getDataInstanceFromDataType(DataSpeedMinMetersPerMinute.type, data.getValue(unit))];
+                        case DataSpeedFeetPerMinute.type:
+                            return [...accu, this.getDataInstanceFromDataType(DataSpeedMinFeetPerMinute.type, data.getValue(unit))];
+                        case DataSpeedKnots.type:
+                            return [...accu, this.getDataInstanceFromDataType(DataSpeedMinKnots.type, data.getValue(unit))];
+                    }
+                    return accu;
+                }, []);
+            // GradeAdjusted Speed
+            case DataGradeAdjustedSpeed.type:
+                return userUnitSettings.gradeAdjustedSpeedUnits.reduce((accu, unit) => {
+                    return [...accu, this.getDataInstanceFromDataType(unit, data.getValue(unit))];
+                }, []);
+            case DataGradeAdjustedSpeedAvg.type:
+                return userUnitSettings.gradeAdjustedSpeedUnits.reduce((accu, unit) => {
+                    switch (unit) {
+                        case DataGradeAdjustedSpeed.type:
+                            return [...accu, this.getDataInstanceFromDataType(DataGradeAdjustedSpeedAvg.type, data.getValue(unit))];
+                        case DataGradeAdjustedSpeedKilometersPerHour.type:
+                            return [
+                                ...accu,
+                                this.getDataInstanceFromDataType(DataGradeAdjustedSpeedAvgKilometersPerHour.type, data.getValue(unit))
+                            ];
+                        case DataGradeAdjustedSpeedMilesPerHour.type:
+                            return [
+                                ...accu,
+                                this.getDataInstanceFromDataType(DataGradeAdjustedSpeedAvgMilesPerHour.type, data.getValue(unit))
+                            ];
+                        case DataGradeAdjustedSpeedFeetPerSecond.type:
+                            return [
+                                ...accu,
+                                this.getDataInstanceFromDataType(DataGradeAdjustedSpeedAvgFeetPerSecond.type, data.getValue(unit))
+                            ];
+                        case DataGradeAdjustedSpeedMetersPerMinute.type:
+                            return [
+                                ...accu,
+                                this.getDataInstanceFromDataType(DataGradeAdjustedSpeedAvgMetersPerMinute.type, data.getValue(unit))
+                            ];
+                        case DataGradeAdjustedSpeedFeetPerMinute.type:
+                            return [
+                                ...accu,
+                                this.getDataInstanceFromDataType(DataGradeAdjustedSpeedAvgFeetPerMinute.type, data.getValue(unit))
+                            ];
+                        case DataGradeAdjustedSpeedKnots.type:
+                            return [
+                                ...accu,
+                                this.getDataInstanceFromDataType(DataGradeAdjustedSpeedAvgKnots.type, data.getValue(unit))
+                            ];
+                    }
+                    return accu;
+                }, []);
+            case DataGradeAdjustedSpeedMax.type:
+                return userUnitSettings.gradeAdjustedSpeedUnits.reduce((accu, unit) => {
+                    switch (unit) {
+                        case DataGradeAdjustedSpeed.type:
+                            return [...accu, this.getDataInstanceFromDataType(DataGradeAdjustedSpeedMax.type, data.getValue(unit))];
+                        case DataGradeAdjustedSpeedKilometersPerHour.type:
+                            return [
+                                ...accu,
+                                this.getDataInstanceFromDataType(DataGradeAdjustedSpeedMaxKilometersPerHour.type, data.getValue(unit))
+                            ];
+                        case DataGradeAdjustedSpeedMilesPerHour.type:
+                            return [
+                                ...accu,
+                                this.getDataInstanceFromDataType(DataGradeAdjustedSpeedMaxMilesPerHour.type, data.getValue(unit))
+                            ];
+                        case DataGradeAdjustedSpeedFeetPerSecond.type:
+                            return [
+                                ...accu,
+                                this.getDataInstanceFromDataType(DataGradeAdjustedSpeedMaxFeetPerSecond.type, data.getValue(unit))
+                            ];
+                        case DataGradeAdjustedSpeedMetersPerMinute.type:
+                            return [
+                                ...accu,
+                                this.getDataInstanceFromDataType(DataGradeAdjustedSpeedMaxMetersPerMinute.type, data.getValue(unit))
+                            ];
+                        case DataGradeAdjustedSpeedFeetPerMinute.type:
+                            return [
+                                ...accu,
+                                this.getDataInstanceFromDataType(DataGradeAdjustedSpeedMaxFeetPerMinute.type, data.getValue(unit))
+                            ];
+                        case DataGradeAdjustedSpeedKnots.type:
+                            return [
+                                ...accu,
+                                this.getDataInstanceFromDataType(DataGradeAdjustedSpeedMaxKnots.type, data.getValue(unit))
+                            ];
+                    }
+                    return accu;
+                }, []);
+            case DataGradeAdjustedSpeedMin.type:
+                return userUnitSettings.gradeAdjustedSpeedUnits.reduce((accu, unit) => {
+                    switch (unit) {
+                        case DataGradeAdjustedSpeed.type:
+                            return [...accu, this.getDataInstanceFromDataType(DataGradeAdjustedSpeedMin.type, data.getValue(unit))];
+                        case DataGradeAdjustedSpeedKilometersPerHour.type:
+                            return [
+                                ...accu,
+                                this.getDataInstanceFromDataType(DataGradeAdjustedSpeedMinKilometersPerHour.type, data.getValue(unit))
+                            ];
+                        case DataGradeAdjustedSpeedMilesPerHour.type:
+                            return [
+                                ...accu,
+                                this.getDataInstanceFromDataType(DataGradeAdjustedSpeedMinMilesPerHour.type, data.getValue(unit))
+                            ];
+                        case DataGradeAdjustedSpeedFeetPerSecond.type:
+                            return [
+                                ...accu,
+                                this.getDataInstanceFromDataType(DataGradeAdjustedSpeedMinFeetPerSecond.type, data.getValue(unit))
+                            ];
+                        case DataGradeAdjustedSpeedMetersPerMinute.type:
+                            return [
+                                ...accu,
+                                this.getDataInstanceFromDataType(DataGradeAdjustedSpeedMinMetersPerMinute.type, data.getValue(unit))
+                            ];
+                        case DataGradeAdjustedSpeedFeetPerMinute.type:
+                            return [
+                                ...accu,
+                                this.getDataInstanceFromDataType(DataGradeAdjustedSpeedMinFeetPerMinute.type, data.getValue(unit))
+                            ];
+                        case DataGradeAdjustedSpeedKnots.type:
+                            return [
+                                ...accu,
+                                this.getDataInstanceFromDataType(DataGradeAdjustedSpeedMinKnots.type, data.getValue(unit))
+                            ];
+                    }
+                    return accu;
+                }, []);
+            // Pace
+            case DataPace.type:
+                return userUnitSettings.paceUnits.reduce((accu, unit) => {
+                    return [...accu, this.getDataInstanceFromDataType(unit, data.getValue(unit))];
+                }, []);
+            case DataPaceAvg.type:
+                return userUnitSettings.paceUnits.reduce((accu, unit) => {
+                    switch (unit) {
+                        case DataPace.type:
+                            return [...accu, this.getDataInstanceFromDataType(DataPaceAvg.type, data.getValue(unit))];
+                        case DataPaceMinutesPerMile.type:
+                            return [...accu, this.getDataInstanceFromDataType(DataPaceAvgMinutesPerMile.type, data.getValue(unit))];
+                    }
+                    return accu;
+                }, []);
+            case DataPaceMax.type:
+                return userUnitSettings.paceUnits.reduce((accu, unit) => {
+                    switch (unit) {
+                        case DataPace.type:
+                            return [...accu, this.getDataInstanceFromDataType(DataPaceMax.type, data.getValue(unit))];
+                        case DataPaceMinutesPerMile.type:
+                            return [...accu, this.getDataInstanceFromDataType(DataPaceMaxMinutesPerMile.type, data.getValue(unit))];
+                    }
+                    return accu;
+                }, []);
+            case DataPaceMin.type:
+                return userUnitSettings.paceUnits.reduce((accu, unit) => {
+                    switch (unit) {
+                        case DataPace.type:
+                            return [...accu, this.getDataInstanceFromDataType(DataPaceMin.type, data.getValue(unit))];
+                        case DataPaceMinutesPerMile.type:
+                            return [...accu, this.getDataInstanceFromDataType(DataPaceMinMinutesPerMile.type, data.getValue(unit))];
+                    }
+                    return accu;
+                }, []);
+            // GAP Pace
+            case DataGradeAdjustedPace.type:
+                return userUnitSettings.gradeAdjustedPaceUnits.reduce((accu, unit) => {
+                    return [...accu, this.getDataInstanceFromDataType(unit, data.getValue(unit))];
+                }, []);
+            case DataGradeAdjustedPaceAvg.type:
+                return userUnitSettings.gradeAdjustedPaceUnits.reduce((accu, unit) => {
+                    switch (unit) {
+                        case DataGradeAdjustedPace.type:
+                            return [...accu, this.getDataInstanceFromDataType(DataGradeAdjustedPaceAvg.type, data.getValue(unit))];
+                        case DataGradeAdjustedPaceMinutesPerMile.type:
+                            return [
+                                ...accu,
+                                this.getDataInstanceFromDataType(DataGradeAdjustedPaceAvgMinutesPerMile.type, data.getValue(unit))
+                            ];
+                    }
+                    return accu;
+                }, []);
+            case DataGradeAdjustedPaceMax.type:
+                return userUnitSettings.gradeAdjustedPaceUnits.reduce((accu, unit) => {
+                    switch (unit) {
+                        case DataGradeAdjustedPace.type:
+                            return [...accu, this.getDataInstanceFromDataType(DataGradeAdjustedPaceMax.type, data.getValue(unit))];
+                        case DataGradeAdjustedPaceMinutesPerMile.type:
+                            return [
+                                ...accu,
+                                this.getDataInstanceFromDataType(DataGradeAdjustedPaceMaxMinutesPerMile.type, data.getValue(unit))
+                            ];
+                    }
+                    return accu;
+                }, []);
+            case DataGradeAdjustedPaceMin.type:
+                return userUnitSettings.gradeAdjustedPaceUnits.reduce((accu, unit) => {
+                    switch (unit) {
+                        case DataGradeAdjustedPace.type:
+                            return [...accu, this.getDataInstanceFromDataType(DataGradeAdjustedPaceMin.type, data.getValue(unit))];
+                        case DataGradeAdjustedPaceMinutesPerMile.type:
+                            return [
+                                ...accu,
+                                this.getDataInstanceFromDataType(DataGradeAdjustedPaceMinMinutesPerMile.type, data.getValue(unit))
+                            ];
+                    }
+                    return accu;
+                }, []);
+            // Swim
+            case DataSwimPace.type:
+                return userUnitSettings.swimPaceUnits.reduce((accu, unit) => {
+                    return [...accu, this.getDataInstanceFromDataType(unit, data.getValue(unit))];
+                }, []);
+            case DataSwimPaceAvg.type:
+                return userUnitSettings.swimPaceUnits.reduce((accu, unit) => {
+                    switch (unit) {
+                        case DataSwimPace.type:
+                            return [...accu, this.getDataInstanceFromDataType(DataSwimPaceAvg.type, data.getValue(unit))];
+                        case DataSwimPaceMinutesPer100Yard.type:
+                            return [
+                                ...accu,
+                                this.getDataInstanceFromDataType(DataSwimPaceAvgMinutesPer100Yard.type, data.getValue(unit))
+                            ];
+                    }
+                    return accu;
+                }, []);
+            case DataSwimPaceMax.type:
+                return userUnitSettings.swimPaceUnits.reduce((accu, unit) => {
+                    switch (unit) {
+                        case DataSwimPace.type:
+                            return [...accu, this.getDataInstanceFromDataType(DataSwimPaceMax.type, data.getValue(unit))];
+                        case DataSwimPaceMinutesPer100Yard.type:
+                            return [
+                                ...accu,
+                                this.getDataInstanceFromDataType(DataSwimPaceMaxMinutesPer100Yard.type, data.getValue(unit))
+                            ];
+                    }
+                    return accu;
+                }, []);
+            case DataSwimPaceMin.type:
+                return userUnitSettings.swimPaceUnits.reduce((accu, unit) => {
+                    switch (unit) {
+                        case DataSwimPace.type:
+                            return [...accu, this.getDataInstanceFromDataType(DataSwimPaceMin.type, data.getValue(unit))];
+                        case DataSwimPaceMinutesPer100Yard.type:
+                            return [
+                                ...accu,
+                                this.getDataInstanceFromDataType(DataSwimPaceMinMinutesPer100Yard.type, data.getValue(unit))
+                            ];
+                    }
+                    return accu;
+                }, []);
+            // Vertical speed
+            case DataVerticalSpeed.type:
+                return userUnitSettings.verticalSpeedUnits.reduce((accu, unit) => {
+                    return [...accu, this.getDataInstanceFromDataType(unit, data.getValue(unit))];
+                }, []);
+            case DataVerticalSpeedAvg.type:
+                return userUnitSettings.verticalSpeedUnits.reduce((accu, unit) => {
+                    switch (unit) {
+                        case DataVerticalSpeed.type:
+                            return [...accu, this.getDataInstanceFromDataType(DataVerticalSpeedAvg.type, data.getValue(unit))];
+                        case DataVerticalSpeedFeetPerHour.type:
+                            return [
+                                ...accu,
+                                this.getDataInstanceFromDataType(DataVerticalSpeedAvgFeetPerHour.type, data.getValue(unit))
+                            ];
+                        case DataVerticalSpeedFeetPerMinute.type:
+                            return [
+                                ...accu,
+                                this.getDataInstanceFromDataType(DataVerticalSpeedAvgFeetPerMinute.type, data.getValue(unit))
+                            ];
+                        case DataVerticalSpeedFeetPerSecond.type:
+                            return [
+                                ...accu,
+                                this.getDataInstanceFromDataType(DataVerticalSpeedAvgFeetPerSecond.type, data.getValue(unit))
+                            ];
+                        case DataVerticalSpeedKilometerPerHour.type:
+                            return [
+                                ...accu,
+                                this.getDataInstanceFromDataType(DataVerticalSpeedAvgKilometerPerHour.type, data.getValue(unit))
+                            ];
+                        case DataVerticalSpeedMilesPerHour.type:
+                            return [
+                                ...accu,
+                                this.getDataInstanceFromDataType(DataVerticalSpeedAvgMilesPerHour.type, data.getValue(unit))
+                            ];
+                        case DataVerticalSpeedMetersPerHour.type:
+                            return [
+                                ...accu,
+                                this.getDataInstanceFromDataType(DataVerticalSpeedAvgMetersPerHour.type, data.getValue(unit))
+                            ];
+                        case DataVerticalSpeedMetersPerMinute.type:
+                            return [
+                                ...accu,
+                                this.getDataInstanceFromDataType(DataVerticalSpeedAvgMetersPerMinute.type, data.getValue(unit))
+                            ];
+                    }
+                    return accu;
+                }, []);
+            case DataVerticalSpeedMax.type:
+                return userUnitSettings.verticalSpeedUnits.reduce((accu, unit) => {
+                    switch (unit) {
+                        case DataVerticalSpeed.type:
+                            return [...accu, this.getDataInstanceFromDataType(DataVerticalSpeedMax.type, data.getValue(unit))];
+                        case DataVerticalSpeedFeetPerHour.type:
+                            return [
+                                ...accu,
+                                this.getDataInstanceFromDataType(DataVerticalSpeedMaxFeetPerHour.type, data.getValue(unit))
+                            ];
+                        case DataVerticalSpeedFeetPerMinute.type:
+                            return [
+                                ...accu,
+                                this.getDataInstanceFromDataType(DataVerticalSpeedMaxFeetPerMinute.type, data.getValue(unit))
+                            ];
+                        case DataVerticalSpeedFeetPerSecond.type:
+                            return [
+                                ...accu,
+                                this.getDataInstanceFromDataType(DataVerticalSpeedMaxFeetPerSecond.type, data.getValue(unit))
+                            ];
+                        case DataVerticalSpeedKilometerPerHour.type:
+                            return [
+                                ...accu,
+                                this.getDataInstanceFromDataType(DataVerticalSpeedMaxKilometerPerHour.type, data.getValue(unit))
+                            ];
+                        case DataVerticalSpeedMilesPerHour.type:
+                            return [
+                                ...accu,
+                                this.getDataInstanceFromDataType(DataVerticalSpeedMaxMilesPerHour.type, data.getValue(unit))
+                            ];
+                        case DataVerticalSpeedMetersPerHour.type:
+                            return [
+                                ...accu,
+                                this.getDataInstanceFromDataType(DataVerticalSpeedMaxMetersPerHour.type, data.getValue(unit))
+                            ];
+                        case DataVerticalSpeedMetersPerMinute.type:
+                            return [
+                                ...accu,
+                                this.getDataInstanceFromDataType(DataVerticalSpeedMaxMetersPerMinute.type, data.getValue(unit))
+                            ];
+                    }
+                    return accu;
+                }, []);
+            case DataVerticalSpeedMin.type:
+                return userUnitSettings.verticalSpeedUnits.reduce((accu, unit) => {
+                    switch (unit) {
+                        case DataVerticalSpeed.type:
+                            return [...accu, this.getDataInstanceFromDataType(DataVerticalSpeedMin.type, data.getValue(unit))];
+                        case DataVerticalSpeedFeetPerHour.type:
+                            return [
+                                ...accu,
+                                this.getDataInstanceFromDataType(DataVerticalSpeedMinFeetPerHour.type, data.getValue(unit))
+                            ];
+                        case DataVerticalSpeedFeetPerMinute.type:
+                            return [
+                                ...accu,
+                                this.getDataInstanceFromDataType(DataVerticalSpeedMinFeetPerMinute.type, data.getValue(unit))
+                            ];
+                        case DataVerticalSpeedFeetPerSecond.type:
+                            return [
+                                ...accu,
+                                this.getDataInstanceFromDataType(DataVerticalSpeedMinFeetPerSecond.type, data.getValue(unit))
+                            ];
+                        case DataVerticalSpeedKilometerPerHour.type:
+                            return [
+                                ...accu,
+                                this.getDataInstanceFromDataType(DataVerticalSpeedMinKilometerPerHour.type, data.getValue(unit))
+                            ];
+                        case DataVerticalSpeedMilesPerHour.type:
+                            return [
+                                ...accu,
+                                this.getDataInstanceFromDataType(DataVerticalSpeedMinMilesPerHour.type, data.getValue(unit))
+                            ];
+                        case DataVerticalSpeedMetersPerHour.type:
+                            return [
+                                ...accu,
+                                this.getDataInstanceFromDataType(DataVerticalSpeedMinMetersPerHour.type, data.getValue(unit))
+                            ];
+                        case DataVerticalSpeedMetersPerMinute.type:
+                            return [
+                                ...accu,
+                                this.getDataInstanceFromDataType(DataVerticalSpeedMinMetersPerMinute.type, data.getValue(unit))
+                            ];
+                    }
+                    return accu;
+                }, []);
+            default:
+                return [data];
+        }
+    }
+}
+// @todo Convert to enums please and use them on Stream types
+DynamicDataLoader.positionalDataTypes = [DataLatitudeDegrees.type, DataLongitudeDegrees.type];
+DynamicDataLoader.baseDataTypes = [DataSpeed.type, DataDistance.type];
+DynamicDataLoader.basicDataTypes = [
+    DataHeartRate.type,
+    DataAltitude.type,
+    DataCadence.type,
+    DataPower.type,
+    DataPace.type,
+    DataGradeAdjustedSpeed.type,
+    DataGradeAdjustedPace.type,
+    DataSpeed.type
+];
+DynamicDataLoader.advancedDataTypes = [
+    DataGrade.type,
+    DataVerticalSpeed.type,
+    DataTemperature.type,
+    DataSeaLevelPressure.type,
+    DataSatellite5BestSNR.type,
+    DataNumberOfSatellites.type,
+    DataEVPE.type,
+    DataEHPE.type,
+    DataGPSAltitude.type,
+    DataAbsolutePressure.type,
+    DataPeakTrainingEffect.type,
+    DataEPOC.type,
+    DataEnergy.type,
+    DataBatteryCharge.type,
+    DataBatteryCurrent.type,
+    DataBatteryVoltage.type,
+    DataBatteryConsumption.type,
+    DataFormPower.type,
+    DataLegStiffness.type,
+    DataVerticalOscillation.type,
+    DataAerobicTrainingEffect.type,
+    DataIBI.type,
+    DataStrydAltitude.type,
+    DataAccumulatedPower.type,
+    DataStrydAltitude.type,
+    DataStrydDistance.type,
+    DataStrydSpeed.type,
+    DataLeftBalance.type,
+    DataRightBalance.type,
+    DataPowerLeft.type,
+    DataPowerRight.type,
+    DataStanceTime.type,
+    DataStanceTimeBalanceLeft.type,
+    DataStepLength.type,
+    DataVerticalRatio.type,
+    DataGroundTime.type,
+    DataAirPower.type,
+    DataGNSSDistance.type,
+    DataDistance.type
+];
+// @todo perhaps this can be simplified with using getValue if it becomes static of the data it self
+DynamicDataLoader.dataTypeUnitGroups = {
+    [DataSpeed.type]: {
+        [DataSpeedKilometersPerHour.type]: convertSpeedToSpeedInKilometersPerHour,
+        [DataSpeedMilesPerHour.type]: convertSpeedToSpeedInMilesPerHour,
+        [DataSpeedFeetPerSecond.type]: convertSpeedToSpeedInFeetPerSecond,
+        [DataSpeedMetersPerMinute.type]: convertSpeedToSpeedInMetersPerMinute,
+        [DataSpeedFeetPerMinute.type]: convertSpeedToSpeedInFeetPerMinute,
+        [DataSpeedKnots.type]: convertSpeedToSpeedInKnots
+    },
+    [DataGradeAdjustedSpeed.type]: {
+        [DataGradeAdjustedSpeedKilometersPerHour.type]: convertSpeedToSpeedInKilometersPerHour,
+        [DataGradeAdjustedSpeedMilesPerHour.type]: convertSpeedToSpeedInMilesPerHour,
+        [DataGradeAdjustedSpeedFeetPerSecond.type]: convertSpeedToSpeedInFeetPerSecond,
+        [DataGradeAdjustedSpeedMetersPerMinute.type]: convertSpeedToSpeedInMetersPerMinute,
+        [DataGradeAdjustedSpeedFeetPerMinute.type]: convertSpeedToSpeedInFeetPerMinute,
+        [DataGradeAdjustedSpeedKnots.type]: convertSpeedToSpeedInKnots
+    },
+    [DataPace.type]: {
+        [DataPaceMinutesPerMile.type]: convertPaceToPaceInMinutesPerMile
+    },
+    [DataGradeAdjustedPace.type]: {
+        [DataGradeAdjustedPaceMinutesPerMile.type]: convertPaceToPaceInMinutesPerMile
+    },
+    [DataSwimPace.type]: {
+        [DataSwimPaceMinutesPer100Yard.type]: convertSwimPaceToSwimPacePer100Yard
+    },
+    [DataVerticalSpeed.type]: {
+        [DataVerticalSpeedFeetPerSecond.type]: convertSpeedToSpeedInFeetPerSecond,
+        [DataVerticalSpeedMetersPerMinute.type]: convertSpeedToSpeedInMetersPerMinute,
+        [DataVerticalSpeedFeetPerMinute.type]: convertSpeedToSpeedInFeetPerMinute,
+        [DataVerticalSpeedMetersPerHour.type]: convertSpeedToSpeedInMetersPerHour,
+        [DataVerticalSpeedFeetPerHour.type]: convertSpeedToSpeedInFeetPerHour,
+        [DataVerticalSpeedKilometerPerHour.type]: convertSpeedToSpeedInKilometersPerHour,
+        [DataVerticalSpeedMilesPerHour.type]: convertSpeedToSpeedInMilesPerHour
+    },
+    [DataDistance.type]: {
+        [DataDistanceMiles.type]: convertMetersToMiles
+    }
+};
+// @todo perhaps GAS?
+DynamicDataLoader.speedDerivedDataTypes = [DataPace.type, DataGradeAdjustedPace.type, DataSwimPace.type];
+DynamicDataLoader.dataTypeMinDataType = {
+    [DataAltitude.type]: DataAltitudeMin.type,
+    [DataHeartRate.type]: DataHeartRateMin.type,
+    [DataSpeed.type]: DataSpeedMin.type,
+    [DataSpeedKilometersPerHour.type]: DataSpeedMinKilometersPerHour.type,
+    [DataSpeedMilesPerHour.type]: DataSpeedMinMilesPerHour.type,
+    [DataSpeedFeetPerSecond.type]: DataSpeedMinFeetPerSecond.type,
+    [DataSpeedMetersPerMinute.type]: DataSpeedMinMetersPerMinute.type,
+    [DataSpeedKnots.type]: DataSpeedMinKnots.type,
+    [DataGradeAdjustedSpeed.type]: DataGradeAdjustedSpeedMin.type,
+    [DataGradeAdjustedSpeedKilometersPerHour.type]: DataGradeAdjustedSpeedMinKilometersPerHour.type,
+    [DataGradeAdjustedSpeedMilesPerHour.type]: DataGradeAdjustedSpeedMinMilesPerHour.type,
+    [DataGradeAdjustedSpeedFeetPerSecond.type]: DataGradeAdjustedSpeedMinFeetPerSecond.type,
+    [DataGradeAdjustedSpeedMetersPerMinute.type]: DataGradeAdjustedSpeedMinMetersPerMinute.type,
+    [DataGradeAdjustedSpeedKnots.type]: DataGradeAdjustedSpeedMinKnots.type,
+    [DataPace.type]: DataPaceMin.type,
+    [DataPaceMinutesPerMile.type]: DataPaceMinMinutesPerMile.type,
+    [DataGradeAdjustedPace.type]: DataGradeAdjustedPaceMin.type,
+    [DataGradeAdjustedPaceMinutesPerMile.type]: DataGradeAdjustedPaceMinMinutesPerMile.type,
+    [DataPower.type]: DataPowerMin.type,
+    [DataCadence.type]: DataCadenceMin.type,
+    [DataTemperature.type]: DataTemperatureMin.type
+};
+DynamicDataLoader.dataTypeMaxDataType = {
+    [DataAltitude.type]: DataAltitudeMax.type,
+    [DataHeartRate.type]: DataHeartRateMax.type,
+    [DataSpeed.type]: DataSpeedMax.type,
+    [DataSpeedKilometersPerHour.type]: DataSpeedMaxKilometersPerHour.type,
+    [DataSpeedMilesPerHour.type]: DataSpeedMaxMilesPerHour.type,
+    [DataSpeedFeetPerSecond.type]: DataSpeedMaxFeetPerSecond.type,
+    [DataSpeedMetersPerMinute.type]: DataSpeedMaxMetersPerMinute.type,
+    [DataSpeedKnots.type]: DataSpeedMaxKnots.type,
+    [DataGradeAdjustedSpeed.type]: DataGradeAdjustedSpeedMax.type,
+    [DataGradeAdjustedSpeedKilometersPerHour.type]: DataGradeAdjustedSpeedMaxKilometersPerHour.type,
+    [DataGradeAdjustedSpeedMilesPerHour.type]: DataGradeAdjustedSpeedMaxMilesPerHour.type,
+    [DataGradeAdjustedSpeedFeetPerSecond.type]: DataGradeAdjustedSpeedMaxFeetPerSecond.type,
+    [DataGradeAdjustedSpeedMetersPerMinute.type]: DataGradeAdjustedSpeedMaxMetersPerMinute.type,
+    [DataGradeAdjustedSpeedKnots.type]: DataGradeAdjustedSpeedMaxKnots.type,
+    [DataPace.type]: DataPaceMax.type,
+    [DataPaceMinutesPerMile.type]: DataPaceMaxMinutesPerMile.type,
+    [DataGradeAdjustedPace.type]: DataGradeAdjustedPaceMax.type,
+    [DataGradeAdjustedPaceMinutesPerMile.type]: DataGradeAdjustedPaceMaxMinutesPerMile.type,
+    [DataPower.type]: DataPowerMax.type,
+    [DataCadence.type]: DataCadenceMax.type,
+    [DataTemperature.type]: DataTemperatureMax.type
+};
+DynamicDataLoader.dataTypeAvgDataType = {
+    [DataAltitude.type]: DataAltitudeAvg.type,
+    [DataHeartRate.type]: DataHeartRateAvg.type,
+    [DataSpeed.type]: DataSpeedAvg.type,
+    [DataSpeedKilometersPerHour.type]: DataSpeedAvgKilometersPerHour.type,
+    [DataSpeedMilesPerHour.type]: DataSpeedAvgMilesPerHour.type,
+    [DataSpeedFeetPerSecond.type]: DataSpeedAvgFeetPerSecond.type,
+    [DataSpeedMetersPerMinute.type]: DataSpeedAvgMetersPerMinute.type,
+    [DataSpeedKnots.type]: DataSpeedAvgKnots.type,
+    [DataGradeAdjustedSpeed.type]: DataGradeAdjustedSpeedAvg.type,
+    [DataGradeAdjustedSpeedKilometersPerHour.type]: DataGradeAdjustedSpeedAvgKilometersPerHour.type,
+    [DataGradeAdjustedSpeedMilesPerHour.type]: DataGradeAdjustedSpeedAvgMilesPerHour.type,
+    [DataGradeAdjustedSpeedFeetPerSecond.type]: DataGradeAdjustedSpeedAvgFeetPerSecond.type,
+    [DataGradeAdjustedSpeedMetersPerMinute.type]: DataGradeAdjustedSpeedAvgMetersPerMinute.type,
+    [DataGradeAdjustedSpeedKnots.type]: DataGradeAdjustedSpeedAvgKnots.type,
+    [DataPace.type]: DataPaceAvg.type,
+    [DataPaceMinutesPerMile.type]: DataPaceAvgMinutesPerMile.type,
+    [DataGradeAdjustedPace.type]: DataGradeAdjustedPaceAvg.type,
+    [DataGradeAdjustedPaceMinutesPerMile.type]: DataGradeAdjustedPaceAvgMinutesPerMile.type,
+    [DataPower.type]: DataPowerAvg.type,
+    [DataCadence.type]: DataCadenceAvg.type,
+    [DataTemperature.type]: DataTemperatureAvg.type
+};
+DynamicDataLoader.allUnitDerivedDataTypes = Object.keys(DynamicDataLoader.dataTypeUnitGroups).reduce((accu, key) => accu.concat(Object.keys(DynamicDataLoader.dataTypeUnitGroups[key])), []);
+DynamicDataLoader.zoneStatsTypeMap = [
+    {
+        type: DataHeartRate.type,
+        stats: [
+            DataHeartRateZoneOneDuration.type,
+            DataHeartRateZoneTwoDuration.type,
+            DataHeartRateZoneThreeDuration.type,
+            DataHeartRateZoneFourDuration.type,
+            DataHeartRateZoneFiveDuration.type
+        ]
+    },
+    {
+        type: DataSpeed.type,
+        stats: [
+            DataSpeedZoneOneDuration.type,
+            DataSpeedZoneTwoDuration.type,
+            DataSpeedZoneThreeDuration.type,
+            DataSpeedZoneFourDuration.type,
+            DataSpeedZoneFiveDuration.type
+        ]
+    },
+    {
+        type: DataPower.type,
+        stats: [
+            DataPowerZoneOneDuration.type,
+            DataPowerZoneTwoDuration.type,
+            DataPowerZoneThreeDuration.type,
+            DataPowerZoneFourDuration.type,
+            DataPowerZoneFiveDuration.type
+        ]
+    }
+];