@stuartshay/otel-graphql-types 1.0.94 → 1.0.445

package/index.d.ts

@@ -1,19 +1,14 @@
 export type Maybe<T> = T | null;
 export type InputMaybe<T> = Maybe<T>;
-export type Exact<T extends { [key: string]: unknown }> = { [K in keyof T]: T[K] };
-export type MakeOptional<T, K extends keyof T> = Omit<T, K> & { [SubKey in K]?: Maybe<T[SubKey]> };
-export type MakeMaybe<T, K extends keyof T> = Omit<T, K> & { [SubKey in K]: Maybe<T[SubKey]> };
-export type MakeEmpty<T extends { [key: string]: unknown }, K extends keyof T> = { [_ in K]?: never };
-export type Incremental<T> = T | { [P in keyof T]?: P extends ' $fragmentName' | '__typename' ? T[P] : never };
 /** All built-in and custom scalars, mapped to their actual values */
 export interface Scalars {
-  ID: { input: string; output: string; }
-  String: { input: string; output: string; }
-  Boolean: { input: boolean; output: boolean; }
-  Int: { input: number; output: number; }
-  Float: { input: number; output: number; }
-  DateTime: { input: string; output: string; }
-  JSON: { input: Record<string, unknown>; output: Record<string, unknown>; }
+  ID: { input: string; output: string };
+  String: { input: string; output: string };
+  Boolean: { input: boolean; output: boolean };
+  Int: { input: number; output: number };
+  Float: { input: number; output: number };
+  DateTime: { input: string; output: string };
+  JSON: { input: Record<string, unknown>; output: Record<string, unknown> };
 }
 
 /** Per-day aggregate combining OwnTracks location stats and Garmin activity metrics. */
@@ -45,6 +40,28 @@ export interface DailyActivitySummary {
   total_duration_seconds?: Maybe<Scalars['Float']['output']>;
 }
 
+/** Paginated list of daily activity summaries. */
+export interface DailySummaryConnection {
+  __typename?: 'DailySummaryConnection';
+  /** List of daily activity summary items in the current page */
+  items: Array<DailyActivitySummary>;
+  /** Maximum number of items per page */
+  limit: Scalars['Int']['output'];
+  /** Number of items skipped from the start */
+  offset: Scalars['Int']['output'];
+  /** Total number of items matching the query */
+  total: Scalars['Int']['output'];
+}
+
+/** Earliest and latest activity dates available in the daily activity summary view. */
+export interface DailySummaryDateRange {
+  __typename?: 'DailySummaryDateRange';
+  /** Latest activity date with daily summary data (YYYY-MM-DD) */
+  max_date: Scalars['String']['output'];
+  /** Earliest activity date with daily summary data (YYYY-MM-DD) */
+  min_date: Scalars['String']['output'];
+}
+
 /** Distinct OwnTracks device identifier. */
 export interface DeviceInfo {
   __typename?: 'DeviceInfo';
@@ -72,12 +89,18 @@ export interface GarminActivity {
   __typename?: 'GarminActivity';
   /** Garmin Connect activity identifier */
   activity_id: Scalars['String']['output'];
+  /** Aerobic training effect score */
+  aerobic_training_effect?: Maybe<Scalars['Float']['output']>;
+  /** Anaerobic training effect score */
+  anaerobic_training_effect?: Maybe<Scalars['Float']['output']>;
   /** Average cadence in RPM */
   avg_cadence?: Maybe<Scalars['Int']['output']>;
   /** Average heart rate in beats per minute */
   avg_heart_rate?: Maybe<Scalars['Int']['output']>;
   /** Average pace in minutes per kilometre */
   avg_pace?: Maybe<Scalars['Float']['output']>;
+  /** Average respiration rate in breaths per minute */
+  avg_respiration_rate?: Maybe<Scalars['Int']['output']>;
   /** Average speed in km/h */
   avg_speed_kmh?: Maybe<Scalars['Float']['output']>;
   /** Average ambient temperature in degrees C */
@@ -86,6 +109,8 @@ export interface GarminActivity {
   calories?: Maybe<Scalars['Int']['output']>;
   /** UTC timestamp when the record was inserted */
   created_at?: Maybe<Scalars['String']['output']>;
+  /** Recording device metadata (manufacturer, model, firmware) */
+  device?: Maybe<GarminDevice>;
   /** Device manufacturer (e.g. garmin) */
   device_manufacturer?: Maybe<Scalars['String']['output']>;
   /** Total distance in kilometres */
@@ -94,22 +119,38 @@ export interface GarminActivity {
   duration_seconds?: Maybe<Scalars['Float']['output']>;
   /** Activity end time in UTC */
   end_time?: Maybe<Scalars['String']['output']>;
+  /** Exercise load score */
+  exercise_load?: Maybe<Scalars['Int']['output']>;
+  /** Whether this activity has usable heart-rate data in summary or track points */
+  hr_available: Scalars['Boolean']['output'];
   /** Maximum cadence in RPM */
   max_cadence?: Maybe<Scalars['Int']['output']>;
   /** Maximum heart rate in beats per minute */
   max_heart_rate?: Maybe<Scalars['Int']['output']>;
+  /** Maximum respiration rate in breaths per minute */
+  max_respiration_rate?: Maybe<Scalars['Int']['output']>;
   /** Maximum speed in km/h */
   max_speed_kmh?: Maybe<Scalars['Float']['output']>;
   /** Maximum ambient temperature in degrees C */
   max_temperature_c?: Maybe<Scalars['Int']['output']>;
+  /** Minimum heart rate in beats per minute */
+  min_heart_rate?: Maybe<Scalars['Int']['output']>;
+  /** Minimum respiration rate in breaths per minute */
+  min_respiration_rate?: Maybe<Scalars['Int']['output']>;
   /** Minimum ambient temperature in degrees C */
   min_temperature_c?: Maybe<Scalars['Int']['output']>;
+  /** Moderate intensity minutes */
+  moderate_intensity_minutes?: Maybe<Scalars['Int']['output']>;
+  /** Distance over paved surfaces in kilometres */
+  paved_distance_km?: Maybe<Scalars['Float']['output']>;
   /** Primary sport type (e.g. cycling, running) */
   sport: Scalars['String']['output'];
   /** Activity start time in UTC */
   start_time?: Maybe<Scalars['String']['output']>;
   /** Sub-sport classification (e.g. road, trail) */
   sub_sport?: Maybe<Scalars['String']['output']>;
+  /** Estimated sweat loss in millilitres */
+  sweat_loss_ml?: Maybe<Scalars['Int']['output']>;
   /** Total elevation gain in meters */
   total_ascent_m?: Maybe<Scalars['Float']['output']>;
   /** Total elevation loss in meters */
@@ -118,12 +159,134 @@ export interface GarminActivity {
   total_distance?: Maybe<Scalars['Float']['output']>;
   /** Total elapsed time in seconds (includes pauses) */
   total_elapsed_time?: Maybe<Scalars['Float']['output']>;
+  /** Total intensity minutes */
+  total_intensity_minutes?: Maybe<Scalars['Int']['output']>;
+  /** Total activity strokes */
+  total_strokes?: Maybe<Scalars['Int']['output']>;
   /** Total timer time in seconds (active recording) */
   total_timer_time?: Maybe<Scalars['Float']['output']>;
   /** Number of GPS track points in this activity */
   track_point_count?: Maybe<Scalars['Int']['output']>;
+  /** Distance over unpaved surfaces in kilometres */
+  unpaved_distance_km?: Maybe<Scalars['Float']['output']>;
   /** UTC timestamp when the FIT file was uploaded */
   uploaded_at?: Maybe<Scalars['String']['output']>;
+  /** Vigorous intensity minutes */
+  vigorous_intensity_minutes?: Maybe<Scalars['Int']['output']>;
+}
+
+/** Full reverse-geocoded address attached to a Garmin activity waypoint. */
+export interface GarminActivityAddress {
+  __typename?: 'GarminActivityAddress';
+  /** Parent Garmin activity identifier */
+  activity_id: Scalars['String']['output'];
+  /** Pelias confidence score (0-1) */
+  confidence?: Maybe<Scalars['Float']['output']>;
+  /** Country name */
+  country?: Maybe<Scalars['String']['output']>;
+  /** Full formatted address label from Pelias */
+  display_address?: Maybe<Scalars['String']['output']>;
+  /** UTC timestamp when geocoding was performed */
+  geocoded_at?: Maybe<Scalars['String']['output']>;
+  /** House or building number */
+  housenumber?: Maybe<Scalars['String']['output']>;
+  /** GPS latitude in decimal degrees (WGS 84) */
+  latitude: Scalars['Float']['output'];
+  /** City or town */
+  locality?: Maybe<Scalars['String']['output']>;
+  /** GPS longitude in decimal degrees (WGS 84) */
+  longitude: Scalars['Float']['output'];
+  /** Neighbourhood name */
+  neighbourhood?: Maybe<Scalars['String']['output']>;
+  /** Postal or ZIP code */
+  postalcode?: Maybe<Scalars['String']['output']>;
+  /** State or province */
+  region?: Maybe<Scalars['String']['output']>;
+  /** Geocoding status: success, no_coverage, error, pending */
+  status: Scalars['String']['output'];
+  /** Street name */
+  street?: Maybe<Scalars['String']['output']>;
+  /** UTC timestamp of the track point this address was derived from */
+  timestamp: Scalars['DateTime']['output'];
+  /** garmin_track_points.id this address was geocoded from */
+  track_point_id: Scalars['Int']['output'];
+  /** Role of this waypoint within the activity: start, end, or waypoint */
+  waypoint_kind: Scalars['String']['output'];
+}
+
+/** Garmin-native ClimbPro typed split for an activity. */
+export interface GarminActivityClimb {
+  __typename?: 'GarminActivityClimb';
+  /** Parent Garmin activity identifier */
+  activity_id: Scalars['String']['output'];
+  /** Average elapsed vertical speed in meters per second */
+  average_elapsed_vertical_speed_mps?: Maybe<Scalars['Float']['output']>;
+  /** Average climb grade percent */
+  average_grade_percent?: Maybe<Scalars['Float']['output']>;
+  /** Average moving speed in meters per second */
+  average_moving_speed_mps?: Maybe<Scalars['Float']['output']>;
+  /** Average speed in meters per second */
+  average_speed_mps?: Maybe<Scalars['Float']['output']>;
+  /** Average temperature in degrees C */
+  average_temperature_c?: Maybe<Scalars['Float']['output']>;
+  /** Average vertical speed in meters per second */
+  average_vertical_speed_mps?: Maybe<Scalars['Float']['output']>;
+  /** BMR calories recorded for this climb */
+  bmr_calories?: Maybe<Scalars['Float']['output']>;
+  /** Calories recorded for this climb */
+  calories?: Maybe<Scalars['Float']['output']>;
+  /** Garmin ClimbPro difficulty */
+  climb_pro_difficulty?: Maybe<Scalars['String']['output']>;
+  /** Garmin ClimbPro typed split type */
+  climb_type?: Maybe<Scalars['String']['output']>;
+  /** UTC timestamp when the row was inserted */
+  created_at?: Maybe<Scalars['String']['output']>;
+  /** Climb distance in meters */
+  distance_meters?: Maybe<Scalars['Float']['output']>;
+  /** Climb duration in seconds */
+  duration_seconds?: Maybe<Scalars['Float']['output']>;
+  /** Elapsed climb duration in seconds */
+  elapsed_duration_seconds?: Maybe<Scalars['Float']['output']>;
+  /** Climb elevation gain in meters */
+  elevation_gain_meters?: Maybe<Scalars['Float']['output']>;
+  /** Climb elevation loss in meters */
+  elevation_loss_meters?: Maybe<Scalars['Float']['output']>;
+  /** Climb end latitude */
+  end_latitude?: Maybe<Scalars['Float']['output']>;
+  /** Climb end longitude */
+  end_longitude?: Maybe<Scalars['Float']['output']>;
+  /** UTC climb end time */
+  end_time?: Maybe<Scalars['String']['output']>;
+  /** Unique climb row identifier */
+  id: Scalars['Float']['output'];
+  /** Maximum climb grade percent */
+  max_grade_percent?: Maybe<Scalars['Float']['output']>;
+  /** Maximum speed in meters per second */
+  max_speed_mps?: Maybe<Scalars['Float']['output']>;
+  /** Maximum temperature in degrees C */
+  max_temperature_c?: Maybe<Scalars['Float']['output']>;
+  /** Garmin message index */
+  message_index?: Maybe<Scalars['Int']['output']>;
+  /** Minimum temperature in degrees C */
+  min_temperature_c?: Maybe<Scalars['Float']['output']>;
+  /** Moving climb duration in seconds */
+  moving_duration_seconds?: Maybe<Scalars['Float']['output']>;
+  /** Zero-based Garmin typed split order */
+  source_split_index: Scalars['Int']['output'];
+  /** Garmin split type label when provided */
+  split_type?: Maybe<Scalars['String']['output']>;
+  /** Climb start elevation in meters */
+  start_elevation_meters?: Maybe<Scalars['Float']['output']>;
+  /** Climb start latitude */
+  start_latitude?: Maybe<Scalars['Float']['output']>;
+  /** Climb start longitude */
+  start_longitude?: Maybe<Scalars['Float']['output']>;
+  /** UTC climb start time */
+  start_time?: Maybe<Scalars['String']['output']>;
+  /** Local climb start time from Garmin */
+  start_time_local?: Maybe<Scalars['String']['output']>;
+  /** UTC timestamp when the row was last updated */
+  updated_at?: Maybe<Scalars['String']['output']>;
 }
 
 /** Paginated list of Garmin activities. */
@@ -139,6 +302,66 @@ export interface GarminActivityConnection {
   total: Scalars['Int']['output'];
 }
 
+/** Garmin-native or derived activity lap row. */
+export interface GarminActivityLap {
+  __typename?: 'GarminActivityLap';
+  /** Parent Garmin activity identifier */
+  activity_id: Scalars['String']['output'];
+  /** Average lap heart rate in bpm */
+  avg_heart_rate?: Maybe<Scalars['Int']['output']>;
+  /** Average lap speed in meters per second */
+  avg_speed_mps?: Maybe<Scalars['Float']['output']>;
+  /** Calories recorded for this lap */
+  calories?: Maybe<Scalars['Float']['output']>;
+  /** UTC timestamp when the row was inserted */
+  created_at?: Maybe<Scalars['String']['output']>;
+  /** Lap distance in meters */
+  distance_meters?: Maybe<Scalars['Float']['output']>;
+  /** Lap timer duration in seconds */
+  duration_seconds?: Maybe<Scalars['Float']['output']>;
+  /** Lap elapsed duration in seconds */
+  elapsed_duration_seconds?: Maybe<Scalars['Float']['output']>;
+  /** UTC lap end time */
+  end_time?: Maybe<Scalars['String']['output']>;
+  /** Unique lap row identifier */
+  id: Scalars['Float']['output'];
+  /** One-based lap order within the activity */
+  lap_index: Scalars['Int']['output'];
+  /** Maximum lap heart rate in bpm */
+  max_heart_rate?: Maybe<Scalars['Int']['output']>;
+  /** Lap moving duration in seconds */
+  moving_duration_seconds?: Maybe<Scalars['Float']['output']>;
+  /** Lap paved distance in meters */
+  paved_distance_meters?: Maybe<Scalars['Float']['output']>;
+  /** UTC lap start time */
+  start_time?: Maybe<Scalars['String']['output']>;
+  /** Lap elevation gain in meters */
+  total_ascent_meters?: Maybe<Scalars['Float']['output']>;
+  /** Lap elevation loss in meters */
+  total_descent_meters?: Maybe<Scalars['Float']['output']>;
+  /** Lap unpaved distance in meters */
+  unpaved_distance_meters?: Maybe<Scalars['Float']['output']>;
+  /** UTC timestamp when the row was last updated */
+  updated_at?: Maybe<Scalars['String']['output']>;
+}
+
+/** Aggregated Garmin activity totals for a single time bucket (week, month, or year). */
+export interface GarminActivityTotal {
+  __typename?: 'GarminActivityTotal';
+  /** Number of activities in the period */
+  activity_count: Scalars['Int']['output'];
+  /** Start date of the period bucket (DATE_TRUNC of week/month/year) */
+  period_start: Scalars['String']['output'];
+  /** Sum of elevation gain in meters */
+  total_ascent_m?: Maybe<Scalars['Int']['output']>;
+  /** Sum of calories burned */
+  total_calories?: Maybe<Scalars['Int']['output']>;
+  /** Sum of distance in kilometres */
+  total_distance_km?: Maybe<Scalars['Float']['output']>;
+  /** Sum of active duration in seconds (excludes pauses) */
+  total_duration_seconds?: Maybe<Scalars['Int']['output']>;
+}
+
 /** Lightweight track point optimised for time-series chart rendering. */
 export interface GarminChartPoint {
   __typename?: 'GarminChartPoint';
@@ -150,10 +373,14 @@ export interface GarminChartPoint {
   distance_from_start_km?: Maybe<Scalars['Float']['output']>;
   /** Heart rate in beats per minute */
   heart_rate?: Maybe<Scalars['Int']['output']>;
+  /** Heart-rate zone index (1-5) */
+  hr_zone?: Maybe<Scalars['Int']['output']>;
   /** GPS latitude in decimal degrees (WGS 84) */
   latitude: Scalars['Float']['output'];
   /** GPS longitude in decimal degrees (WGS 84) */
   longitude: Scalars['Float']['output'];
+  /** Respiration rate in breaths per minute */
+  respiration_rate?: Maybe<Scalars['Int']['output']>;
   /** Instantaneous speed in km/h */
   speed_kmh?: Maybe<Scalars['Float']['output']>;
   /** Ambient temperature in degrees C */
@@ -162,6 +389,39 @@ export interface GarminChartPoint {
   timestamp: Scalars['DateTime']['output'];
 }
 
+/** Earliest and latest timestamps in the Garmin activities table. */
+export interface GarminDateRange {
+  __typename?: 'GarminDateRange';
+  /** Latest Garmin activity timestamp (ISO 8601) */
+  max_date: Scalars['DateTime']['output'];
+  /** Earliest Garmin activity timestamp (ISO 8601) */
+  min_date: Scalars['DateTime']['output'];
+}
+
+/** Recording device metadata captured from a Garmin activity's FIT file. */
+export interface GarminDevice {
+  __typename?: 'GarminDevice';
+  /** Recording device serial number */
+  device_id?: Maybe<Scalars['Float']['output']>;
+  /** Raw Garmin product enum id from the FIT file (e.g. 4061) */
+  garmin_product?: Maybe<Scalars['Int']['output']>;
+  /** Device manufacturer (e.g. garmin) */
+  manufacturer?: Maybe<Scalars['String']['output']>;
+  /** Friendly device model name (e.g. Edge 540 Solar) */
+  model?: Maybe<Scalars['String']['output']>;
+  /** Device firmware/software version (e.g. 31.30) */
+  software_version?: Maybe<Scalars['String']['output']>;
+}
+
+/** Garmin activity count grouped by recording device model. */
+export interface GarminDeviceCount {
+  __typename?: 'GarminDeviceCount';
+  /** Number of activities for this device label. */
+  activity_count: Scalars['Int']['output'];
+  /** Device model label, or Manual when an activity has no recording device. */
+  label: Scalars['String']['output'];
+}
+
 /** Result payload returned when triggering an on-demand Garmin sync. */
 export interface GarminSyncTriggerResult {
   __typename?: 'GarminSyncTriggerResult';
@@ -188,6 +448,8 @@ export interface GarminTrackPoint {
   __typename?: 'GarminTrackPoint';
   /** Parent Garmin activity identifier */
   activity_id: Scalars['String']['output'];
+  /** Compact reverse-geocoded address summary, when geocoded */
+  address?: Maybe<GeocodedAddressSummary>;
   /** Elevation above sea level in meters */
   altitude?: Maybe<Scalars['Float']['output']>;
   /** Pedal/step cadence in RPM */
@@ -196,16 +458,24 @@ export interface GarminTrackPoint {
   created_at?: Maybe<Scalars['String']['output']>;
   /** Cumulative distance from activity start in km */
   distance_from_start_km?: Maybe<Scalars['Float']['output']>;
+  /** Effort classification label */
+  effort_level?: Maybe<Scalars['String']['output']>;
   /** Heart rate in beats per minute */
   heart_rate?: Maybe<Scalars['Int']['output']>;
+  /** Heart-rate zone index (1-5) */
+  hr_zone?: Maybe<Scalars['Int']['output']>;
   /** Unique track point record identifier */
   id: Scalars['Int']['output'];
   /** GPS latitude in decimal degrees (WGS 84) */
   latitude: Scalars['Float']['output'];
   /** GPS longitude in decimal degrees (WGS 84) */
   longitude: Scalars['Float']['output'];
+  /** Respiration rate in breaths per minute */
+  respiration_rate?: Maybe<Scalars['Int']['output']>;
   /** Instantaneous speed in km/h */
   speed_kmh?: Maybe<Scalars['Float']['output']>;
+  /** Road or terrain type */
+  surface_type?: Maybe<Scalars['String']['output']>;
   /** Ambient temperature in degrees C */
   temperature_c?: Maybe<Scalars['Float']['output']>;
   /** UTC timestamp of the track point recording */
@@ -225,6 +495,124 @@ export interface GarminTrackPointConnection {
   total: Scalars['Int']['output'];
 }
 
+/** Reverse-geocoded address components from Pelias. */
+export interface GeocodedAddress {
+  __typename?: 'GeocodedAddress';
+  /** Pelias confidence score (0-1) */
+  confidence?: Maybe<Scalars['Float']['output']>;
+  /** Country name */
+  country?: Maybe<Scalars['String']['output']>;
+  /** Full formatted address label from Pelias */
+  display_address?: Maybe<Scalars['String']['output']>;
+  /** UTC timestamp when geocoding was performed */
+  geocoded_at?: Maybe<Scalars['String']['output']>;
+  /** House or building number */
+  housenumber?: Maybe<Scalars['String']['output']>;
+  /** City or town */
+  locality?: Maybe<Scalars['String']['output']>;
+  /** Neighbourhood name */
+  neighbourhood?: Maybe<Scalars['String']['output']>;
+  /** Postal or ZIP code */
+  postalcode?: Maybe<Scalars['String']['output']>;
+  /** State or province */
+  region?: Maybe<Scalars['String']['output']>;
+  /** Geocoding status: success, no_coverage, error, pending */
+  status: Scalars['String']['output'];
+  /** Street name */
+  street?: Maybe<Scalars['String']['output']>;
+}
+
+/** Compact reverse-geocoded address summary embedded in track-point payloads. */
+export interface GeocodedAddressSummary {
+  __typename?: 'GeocodedAddressSummary';
+  /** Pelias confidence score (0-1) */
+  confidence?: Maybe<Scalars['Float']['output']>;
+  /** Country name */
+  country?: Maybe<Scalars['String']['output']>;
+  /** Full formatted address label from Pelias */
+  display_address?: Maybe<Scalars['String']['output']>;
+  /** UTC timestamp when geocoding was performed */
+  geocoded_at?: Maybe<Scalars['String']['output']>;
+  /** House or building number */
+  housenumber?: Maybe<Scalars['String']['output']>;
+  /** City or town */
+  locality?: Maybe<Scalars['String']['output']>;
+  /** Neighbourhood name */
+  neighbourhood?: Maybe<Scalars['String']['output']>;
+  /** Postal or ZIP code */
+  postalcode?: Maybe<Scalars['String']['output']>;
+  /** State or province */
+  region?: Maybe<Scalars['String']['output']>;
+  /** Geocoding status: success, no_coverage, error, pending */
+  status: Scalars['String']['output'];
+  /** Street name */
+  street?: Maybe<Scalars['String']['output']>;
+  /** Role of this waypoint within a Garmin activity (start, end, waypoint). Null for OwnTracks records. */
+  waypoint_kind?: Maybe<Scalars['String']['output']>;
+}
+
+/** Coverage statistics for a single geocoding source (owntracks or garmin). */
+export interface GeocodingSourceStatus {
+  __typename?: 'GeocodingSourceStatus';
+  /** Number of records that failed geocoding */
+  errors: Scalars['Int']['output'];
+  /** Number of records outside Pelias coverage area */
+  no_coverage: Scalars['Int']['output'];
+  /** Number of records awaiting geocoding for this source */
+  pending: Scalars['Int']['output'];
+  /** Number of successfully geocoded records for this source */
+  success: Scalars['Int']['output'];
+  /** Total number of geocoded_addresses rows for this source */
+  total: Scalars['Int']['output'];
+}
+
+/** Coverage statistics for geocoded location records. */
+export interface GeocodingStatus {
+  __typename?: 'GeocodingStatus';
+  /** Per-source breakdown of geocoding coverage (owntracks, garmin) */
+  by_source: GeocodingStatusBySource;
+  /** Percentage of locations with a geocoded address */
+  coverage_percent: Scalars['Float']['output'];
+  /** Number of locations that failed geocoding */
+  errors: Scalars['Int']['output'];
+  /** Number of locations with a geocoded address (any status) */
+  geocoded: Scalars['Int']['output'];
+  /** Number of locations outside Pelias coverage area */
+  no_coverage: Scalars['Int']['output'];
+  /** Number of locations awaiting geocoding */
+  pending: Scalars['Int']['output'];
+  /** Number of successfully geocoded locations */
+  success: Scalars['Int']['output'];
+  /** Total number of OwnTracks location records */
+  total_locations: Scalars['Int']['output'];
+}
+
+/** Per-source breakdown of geocoding coverage. */
+export interface GeocodingStatusBySource {
+  __typename?: 'GeocodingStatusBySource';
+  /** Coverage stats for Garmin rows */
+  garmin: GeocodingSourceStatus;
+  /** Number of Garmin activities that have at least one address row */
+  garmin_activities_geocoded: Scalars['Int']['output'];
+  /** Total number of Garmin activities (denominator for activity-level coverage) */
+  garmin_activities_total: Scalars['Int']['output'];
+  /** Percentage of Garmin activities with at least one geocoded address */
+  garmin_coverage_percent: Scalars['Float']['output'];
+  /** Coverage stats for OwnTracks rows */
+  owntracks: GeocodingSourceStatus;
+}
+
+/** Result of triggering a batch geocoding operation. */
+export interface GeocodingTriggerResult {
+  __typename?: 'GeocodingTriggerResult';
+  /** Number of records processed in this batch */
+  processed: Scalars['Int']['output'];
+  /** Number of records still awaiting geocoding */
+  remaining: Scalars['Int']['output'];
+  /** Number of records skipped via proximity deduplication */
+  skipped_dedup: Scalars['Int']['output'];
+}
+
 /** Service health status. */
 export interface HealthStatus {
   __typename?: 'HealthStatus';
@@ -251,6 +639,8 @@ export interface Location {
   created_at?: Maybe<Scalars['String']['output']>;
   /** OwnTracks device identifier (e.g. iphone_stuart) */
   device_id: Scalars['String']['output'];
+  /** Short formatted address from reverse geocoding */
+  display_address?: Maybe<Scalars['String']['output']>;
   /** Unique location record identifier */
   id: Scalars['Int']['output'];
   /** GPS latitude in decimal degrees (WGS 84) */
@@ -291,11 +681,22 @@ export interface LocationCount {
   device_id?: Maybe<Scalars['String']['output']>;
 }
 
+/** Earliest and latest timestamps in the locations table. */
+export interface LocationDateRange {
+  __typename?: 'LocationDateRange';
+  /** Latest location timestamp (ISO 8601) */
+  max_date: Scalars['DateTime']['output'];
+  /** Earliest location timestamp (ISO 8601) */
+  min_date: Scalars['DateTime']['output'];
+}
+
 /** Full location detail including the original OwnTracks JSON payload. */
 export interface LocationDetail {
   __typename?: 'LocationDetail';
   /** Horizontal accuracy of the GPS fix in meters */
   accuracy?: Maybe<Scalars['Float']['output']>;
+  /** Full reverse-geocoded address components from Pelias */
+  address?: Maybe<GeocodedAddress>;
   /** Altitude above sea level in meters */
   altitude?: Maybe<Scalars['Float']['output']>;
   /** Device battery level as a percentage (0-100) */
@@ -330,14 +731,20 @@ export interface Mutation {
   __typename?: 'Mutation';
   /** Trigger an on-demand Garmin sync in the upstream API. */
   triggerGarminSync: GarminSyncTriggerResult;
+  /** Trigger batch reverse-geocoding of un-geocoded location records. */
+  triggerGeocoding: GeocodingTriggerResult;
 }
 
-
 export interface MutationTriggerGarminSyncArgs {
   lookback?: InputMaybe<Scalars['Int']['input']>;
   window_hours?: InputMaybe<Scalars['Int']['input']>;
 }
 
+export interface MutationTriggerGeocodingArgs {
+  batch_size?: InputMaybe<Scalars['Int']['input']>;
+  retry_failed?: InputMaybe<Scalars['Boolean']['input']>;
+}
+
 /** GPS point found within a spatial proximity search. */
 export interface NearbyPoint {
   __typename?: 'NearbyPoint';
@@ -371,25 +778,43 @@ export interface Query {
   /** Calculate the geodesic distance between two geographic points. */
   calculateDistance: DistanceResult;
   /** Retrieve daily activity summaries combining OwnTracks and Garmin data. */
-  dailySummary: Array<DailyActivitySummary>;
+  dailySummary: DailySummaryConnection;
+  /** Get the earliest and latest activity dates available in the daily activity summary view. */
+  dailySummaryDateRange: DailySummaryDateRange;
   /** List all distinct OwnTracks device identifiers. */
   devices: Array<DeviceInfo>;
   /** Retrieve a paginated list of Garmin activities. */
   garminActivities: GarminActivityConnection;
   /** Retrieve a single Garmin activity by its ID. */
   garminActivity?: Maybe<GarminActivity>;
+  /** Retrieve all reverse-geocoded addresses for a Garmin activity (start, mid-route waypoints, and end). */
+  garminActivityAddresses: Array<GarminActivityAddress>;
+  /** Retrieve Garmin-native ClimbPro typed splits for a Garmin activity. */
+  garminActivityClimbs: Array<GarminActivityClimb>;
+  /** Retrieve Garmin-native or derived laps for a Garmin activity. */
+  garminActivityLaps: Array<GarminActivityLap>;
+  /** Aggregate Garmin activity totals grouped by week, month, or year. */
+  garminActivityTotals: Array<GarminActivityTotal>;
   /** Retrieve chart-optimised track points for a Garmin activity. */
   garminChartData: Array<GarminChartPoint>;
+  /** Get the earliest and latest Garmin activity timestamps. */
+  garminDateRange: GarminDateRange;
+  /** List Garmin recording device labels with activity counts. */
+  garminDeviceCounts: Array<GarminDeviceCount>;
   /** List all distinct sport types with activity counts. */
   garminSports: Array<SportInfo>;
   /** Retrieve paginated GPS track points for a Garmin activity. */
   garminTrackPoints: GarminTrackPointConnection;
+  /** Get geocoding coverage statistics. */
+  geocodingStatus: GeocodingStatus;
   /** Get service health status. */
   health: HealthStatus;
   /** Retrieve a single location by its ID, including raw payload. */
   location?: Maybe<LocationDetail>;
   /** Get aggregate count of location records with optional filters. */
   locationCount: LocationCount;
+  /** Get the earliest and latest location timestamps. */
+  locationDateRange: LocationDateRange;
   /** Retrieve a paginated list of OwnTracks location records. */
   locations: LocationConnection;
   /** Find GPS points within a radius of a geographic coordinate. */
@@ -406,7 +831,6 @@ export interface Query {
   withinReference: WithinReferenceResult;
 }
 
-
 export interface QueryCalculateDistanceArgs {
   from_lat: Scalars['Float']['input'];
   from_lon: Scalars['Float']['input'];
@@ -414,14 +838,13 @@ export interface QueryCalculateDistanceArgs {
   to_lon: Scalars['Float']['input'];
 }
 
-
 export interface QueryDailySummaryArgs {
   date_from?: InputMaybe<Scalars['String']['input']>;
   date_to?: InputMaybe<Scalars['String']['input']>;
   limit?: InputMaybe<Scalars['Int']['input']>;
+  offset?: InputMaybe<Scalars['Int']['input']>;
 }
 
-
 export interface QueryGarminActivitiesArgs {
   date_from?: InputMaybe<Scalars['String']['input']>;
   date_to?: InputMaybe<Scalars['String']['input']>;
@@ -432,16 +855,32 @@ export interface QueryGarminActivitiesArgs {
   sport?: InputMaybe<Scalars['String']['input']>;
 }
 
-
 export interface QueryGarminActivityArgs {
   activity_id: Scalars['String']['input'];
 }
 
+export interface QueryGarminActivityAddressesArgs {
+  activity_id: Scalars['String']['input'];
+}
 
-export interface QueryGarminChartDataArgs {
+export interface QueryGarminActivityClimbsArgs {
   activity_id: Scalars['String']['input'];
 }
 
+export interface QueryGarminActivityLapsArgs {
+  activity_id: Scalars['String']['input'];
+}
+
+export interface QueryGarminActivityTotalsArgs {
+  date_from?: InputMaybe<Scalars['String']['input']>;
+  date_to?: InputMaybe<Scalars['String']['input']>;
+  period: Scalars['String']['input'];
+  sport?: InputMaybe<Scalars['String']['input']>;
+}
+
+export interface QueryGarminChartDataArgs {
+  activity_id: Scalars['String']['input'];
+}
 
 export interface QueryGarminTrackPointsArgs {
   activity_id: Scalars['String']['input'];
@@ -452,18 +891,15 @@ export interface QueryGarminTrackPointsArgs {
   sort?: InputMaybe<Scalars['String']['input']>;
 }
 
-
 export interface QueryLocationArgs {
   id: Scalars['Int']['input'];
 }
 
-
 export interface QueryLocationCountArgs {
   date?: InputMaybe<Scalars['String']['input']>;
   device_id?: InputMaybe<Scalars['String']['input']>;
 }
 
-
 export interface QueryLocationsArgs {
   date_from?: InputMaybe<Scalars['String']['input']>;
   date_to?: InputMaybe<Scalars['String']['input']>;
@@ -474,7 +910,6 @@ export interface QueryLocationsArgs {
   sort?: InputMaybe<Scalars['String']['input']>;
 }
 
-
 export interface QueryNearbyPointsArgs {
   lat: Scalars['Float']['input'];
   limit?: InputMaybe<Scalars['Int']['input']>;
@@ -483,22 +918,21 @@ export interface QueryNearbyPointsArgs {
   source?: InputMaybe<Scalars['String']['input']>;
 }
 
-
 export interface QueryReferenceLocationArgs {
   id: Scalars['Int']['input'];
 }
 
-
 export interface QueryUnifiedGpsArgs {
   date_from?: InputMaybe<Scalars['String']['input']>;
   date_to?: InputMaybe<Scalars['String']['input']>;
+  deduplicate?: InputMaybe<Scalars['Boolean']['input']>;
+  exclude_stationary?: InputMaybe<Scalars['Boolean']['input']>;
   limit?: InputMaybe<Scalars['Int']['input']>;
   offset?: InputMaybe<Scalars['Int']['input']>;
   order?: InputMaybe<SortOrder>;
   source?: InputMaybe<Scalars['String']['input']>;
 }
 
-
 export interface QueryWithinReferenceArgs {
   limit?: InputMaybe<Scalars['Int']['input']>;
   name: Scalars['String']['input'];