@stuartshay/otel-graphql-types 1.0.94 → 1.0.95

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,59 @@ 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'];
 }
 
 /** Paginated list of Garmin activities. */
@@ -139,6 +227,23 @@ export interface GarminActivityConnection {
   total: Scalars['Int']['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 +255,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 +271,30 @@ 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']>;
+}
+
 /** Result payload returned when triggering an on-demand Garmin sync. */
 export interface GarminSyncTriggerResult {
   __typename?: 'GarminSyncTriggerResult';
@@ -188,6 +321,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 +331,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 +368,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 +512,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 +554,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 +604,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 +651,37 @@ 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>;
+  /** 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 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 +698,6 @@ export interface Query {
   withinReference: WithinReferenceResult;
 }
 
-
 export interface QueryCalculateDistanceArgs {
   from_lat: Scalars['Float']['input'];
   from_lon: Scalars['Float']['input'];
@@ -414,14 +705,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,17 +722,25 @@ 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 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'];
   limit?: InputMaybe<Scalars['Int']['input']>;
@@ -452,18 +750,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 +769,6 @@ export interface QueryLocationsArgs {
   sort?: InputMaybe<Scalars['String']['input']>;
 }
 
-
 export interface QueryNearbyPointsArgs {
   lat: Scalars['Float']['input'];
   limit?: InputMaybe<Scalars['Int']['input']>;
@@ -483,22 +777,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'];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stuartshay/otel-graphql-types",
-  "version": "1.0.94",
+  "version": "1.0.95",
   "description": "TypeScript types for otel-data-gateway — Auto-generated from GraphQL schema",
   "types": "index.d.ts",
   "exports": {

package/schema.graphql

@@ -122,6 +122,10 @@ type Location {
   UTC timestamp when the record was inserted into the database
   """
   created_at: String
+  """
+  Short formatted address from reverse geocoding
+  """
+  display_address: String
 }
 
 """
@@ -188,10 +192,175 @@ type LocationDetail {
   Original OwnTracks JSON payload as received from the MQTT broker
   """
   raw_payload: JSON
+  """
+  Full reverse-geocoded address components from Pelias
+  """
+  address: GeocodedAddress
 }
 
 scalar JSON
 
+# -------------------------------------------------------
+# Geocoding
+# -------------------------------------------------------
+"""
+Reverse-geocoded address components from Pelias.
+"""
+type GeocodedAddress {
+  """
+  Full formatted address label from Pelias
+  """
+  display_address: String
+  """
+  Street name
+  """
+  street: String
+  """
+  House or building number
+  """
+  housenumber: String
+  """
+  Neighbourhood name
+  """
+  neighbourhood: String
+  """
+  City or town
+  """
+  locality: String
+  """
+  State or province
+  """
+  region: String
+  """
+  Country name
+  """
+  country: String
+  """
+  Postal or ZIP code
+  """
+  postalcode: String
+  """
+  Pelias confidence score (0-1)
+  """
+  confidence: Float
+  """
+  Geocoding status: success, no_coverage, error, pending
+  """
+  status: String!
+  """
+  UTC timestamp when geocoding was performed
+  """
+  geocoded_at: String
+}
+
+"""
+Coverage statistics for geocoded location records.
+"""
+type GeocodingStatus {
+  """
+  Total number of OwnTracks location records
+  """
+  total_locations: Int!
+  """
+  Number of locations with a geocoded address (any status)
+  """
+  geocoded: Int!
+  """
+  Number of successfully geocoded locations
+  """
+  success: Int!
+  """
+  Number of locations awaiting geocoding
+  """
+  pending: Int!
+  """
+  Number of locations outside Pelias coverage area
+  """
+  no_coverage: Int!
+  """
+  Number of locations that failed geocoding
+  """
+  errors: Int!
+  """
+  Percentage of locations with a geocoded address
+  """
+  coverage_percent: Float!
+  """
+  Per-source breakdown of geocoding coverage (owntracks, garmin)
+  """
+  by_source: GeocodingStatusBySource!
+}
+
+"""
+Coverage statistics for a single geocoding source (owntracks or garmin).
+"""
+type GeocodingSourceStatus {
+  """
+  Number of successfully geocoded records for this source
+  """
+  success: Int!
+  """
+  Number of records awaiting geocoding for this source
+  """
+  pending: Int!
+  """
+  Number of records outside Pelias coverage area
+  """
+  no_coverage: Int!
+  """
+  Number of records that failed geocoding
+  """
+  errors: Int!
+  """
+  Total number of geocoded_addresses rows for this source
+  """
+  total: Int!
+}
+
+"""
+Per-source breakdown of geocoding coverage.
+"""
+type GeocodingStatusBySource {
+  """
+  Coverage stats for OwnTracks rows
+  """
+  owntracks: GeocodingSourceStatus!
+  """
+  Coverage stats for Garmin rows
+  """
+  garmin: GeocodingSourceStatus!
+  """
+  Total number of Garmin activities (denominator for activity-level coverage)
+  """
+  garmin_activities_total: Int!
+  """
+  Number of Garmin activities that have at least one address row
+  """
+  garmin_activities_geocoded: Int!
+  """
+  Percentage of Garmin activities with at least one geocoded address
+  """
+  garmin_coverage_percent: Float!
+}
+
+"""
+Result of triggering a batch geocoding operation.
+"""
+type GeocodingTriggerResult {
+  """
+  Number of records processed in this batch
+  """
+  processed: Int!
+  """
+  Number of records still awaiting geocoding
+  """
+  remaining: Int!
+  """
+  Number of records skipped via proximity deduplication
+  """
+  skipped_dedup: Int!
+}
+
 """
 Paginated list of OwnTracks location records.
 """
@@ -242,9 +411,49 @@ type LocationCount {
   device_id: String
 }
 
+"""
+Earliest and latest timestamps in the locations table.
+"""
+type LocationDateRange {
+  """
+  Earliest location timestamp (ISO 8601)
+  """
+  min_date: DateTime!
+  """
+  Latest location timestamp (ISO 8601)
+  """
+  max_date: DateTime!
+}
+
 # -------------------------------------------------------
 # Garmin
 # -------------------------------------------------------
+"""
+Recording device metadata captured from a Garmin activity's FIT file.
+"""
+type GarminDevice {
+  """
+  Recording device serial number
+  """
+  device_id: Float
+  """
+  Device manufacturer (e.g. garmin)
+  """
+  manufacturer: String
+  """
+  Raw Garmin product enum id from the FIT file (e.g. 4061)
+  """
+  garmin_product: Int
+  """
+  Friendly device model name (e.g. Edge 540 Solar)
+  """
+  model: String
+  """
+  Device firmware/software version (e.g. 31.30)
+  """
+  software_version: String
+}
+
 """
 Summary of a Garmin Connect activity parsed from a FIT file.
 """
@@ -286,6 +495,62 @@ type GarminActivity {
   """
   max_heart_rate: Int
   """
+  Whether this activity has usable heart-rate data in summary or track points
+  """
+  hr_available: Boolean!
+  """
+  Minimum heart rate in beats per minute
+  """
+  min_heart_rate: Int
+  """
+  Aerobic training effect score
+  """
+  aerobic_training_effect: Float
+  """
+  Anaerobic training effect score
+  """
+  anaerobic_training_effect: Float
+  """
+  Exercise load score
+  """
+  exercise_load: Int
+  """
+  Average respiration rate in breaths per minute
+  """
+  avg_respiration_rate: Int
+  """
+  Minimum respiration rate in breaths per minute
+  """
+  min_respiration_rate: Int
+  """
+  Maximum respiration rate in breaths per minute
+  """
+  max_respiration_rate: Int
+  """
+  Estimated sweat loss in millilitres
+  """
+  sweat_loss_ml: Int
+  """
+  Moderate intensity minutes
+  """
+  moderate_intensity_minutes: Int
+  """
+  Vigorous intensity minutes
+  """
+  vigorous_intensity_minutes: Int
+  """
+  Total intensity minutes
+  """
+  total_intensity_minutes: Int
+  """
+  Distance over paved surfaces in kilometres
+  """
+  paved_distance_km: Float
+  """
+  Distance over unpaved surfaces in kilometres
+  """
+  unpaved_distance_km: Float
+  """
   Average cadence in RPM
   """
   avg_cadence: Int
@@ -294,6 +559,10 @@ type GarminActivity {
   """
   max_cadence: Int
   """
+  Total activity strokes
+  """
+  total_strokes: Int
+  """
   Total calories burned
   """
   calories: Int
@@ -326,6 +595,10 @@ type GarminActivity {
   """
   device_manufacturer: String
   """
+  Recording device metadata (manufacturer, model, firmware)
+  """
+  device: GarminDevice
+  """
   Average ambient temperature in degrees C
   """
   avg_temperature_c: Int
@@ -381,6 +654,20 @@ type GarminActivityConnection {
   offset: Int!
 }
 
+"""
+Earliest and latest timestamps in the Garmin activities table.
+"""
+type GarminDateRange {
+  """
+  Earliest Garmin activity timestamp (ISO 8601)
+  """
+  min_date: DateTime!
+  """
+  Latest Garmin activity timestamp (ISO 8601)
+  """
+  max_date: DateTime!
+}
+
 """
 Individual GPS track point within a Garmin activity.
 """
@@ -422,6 +709,14 @@ type GarminTrackPoint {
   """
   heart_rate: Int
   """
+  Heart-rate zone index (1-5)
+  """
+  hr_zone: Int
+  """
+  Respiration rate in breaths per minute
+  """
+  respiration_rate: Int
+  """
   Pedal/step cadence in RPM
   """
   cadence: Int
@@ -430,9 +725,149 @@ type GarminTrackPoint {
   """
   temperature_c: Float
   """
+  Road or terrain type
+  """
+  surface_type: String
+  """
+  Effort classification label
+  """
+  effort_level: String
+  """
   UTC timestamp when the record was inserted
   """
   created_at: String
+  """
+  Compact reverse-geocoded address summary, when geocoded
+  """
+  address: GeocodedAddressSummary
+}
+
+"""
+Compact reverse-geocoded address summary embedded in track-point payloads.
+"""
+type GeocodedAddressSummary {
+  """
+  Full formatted address label from Pelias
+  """
+  display_address: String
+  """
+  Street name
+  """
+  street: String
+  """
+  House or building number
+  """
+  housenumber: String
+  """
+  Neighbourhood name
+  """
+  neighbourhood: String
+  """
+  City or town
+  """
+  locality: String
+  """
+  State or province
+  """
+  region: String
+  """
+  Country name
+  """
+  country: String
+  """
+  Postal or ZIP code
+  """
+  postalcode: String
+  """
+  Pelias confidence score (0-1)
+  """
+  confidence: Float
+  """
+  Role of this waypoint within a Garmin activity (start, end, waypoint). Null for OwnTracks records.
+  """
+  waypoint_kind: String
+  """
+  Geocoding status: success, no_coverage, error, pending
+  """
+  status: String!
+  """
+  UTC timestamp when geocoding was performed
+  """
+  geocoded_at: String
+}
+
+"""
+Full reverse-geocoded address attached to a Garmin activity waypoint.
+"""
+type GarminActivityAddress {
+  """
+  garmin_track_points.id this address was geocoded from
+  """
+  track_point_id: Int!
+  """
+  Parent Garmin activity identifier
+  """
+  activity_id: String!
+  """
+  Role of this waypoint within the activity: start, end, or waypoint
+  """
+  waypoint_kind: String!
+  """
+  UTC timestamp of the track point this address was derived from
+  """
+  timestamp: DateTime!
+  """
+  GPS latitude in decimal degrees (WGS 84)
+  """
+  latitude: Float!
+  """
+  GPS longitude in decimal degrees (WGS 84)
+  """
+  longitude: Float!
+  """
+  Full formatted address label from Pelias
+  """
+  display_address: String
+  """
+  Street name
+  """
+  street: String
+  """
+  House or building number
+  """
+  housenumber: String
+  """
+  Neighbourhood name
+  """
+  neighbourhood: String
+  """
+  City or town
+  """
+  locality: String
+  """
+  State or province
+  """
+  region: String
+  """
+  Country name
+  """
+  country: String
+  """
+  Postal or ZIP code
+  """
+  postalcode: String
+  """
+  Pelias confidence score (0-1)
+  """
+  confidence: Float
+  """
+  Geocoding status: success, no_coverage, error, pending
+  """
+  status: String!
+  """
+  UTC timestamp when geocoding was performed
+  """
+  geocoded_at: String
 }
 
 """
@@ -496,6 +931,14 @@ type GarminChartPoint {
   """
   heart_rate: Int
   """
+  Heart-rate zone index (1-5)
+  """
+  hr_zone: Int
+  """
+  Respiration rate in breaths per minute
+  """
+  respiration_rate: Int
+  """
   Pedal/step cadence in RPM
   """
   cadence: Int
@@ -513,6 +956,36 @@ type GarminChartPoint {
   longitude: Float!
 }
 
+"""
+Aggregated Garmin activity totals for a single time bucket (week, month, or year).
+"""
+type GarminActivityTotal {
+  """
+  Start date of the period bucket (DATE_TRUNC of week/month/year)
+  """
+  period_start: String!
+  """
+  Number of activities in the period
+  """
+  activity_count: Int!
+  """
+  Sum of distance in kilometres
+  """
+  total_distance_km: Float
+  """
+  Sum of active duration in seconds (excludes pauses)
+  """
+  total_duration_seconds: Int
+  """
+  Sum of elevation gain in meters
+  """
+  total_ascent_m: Int
+  """
+  Sum of calories burned
+  """
+  total_calories: Int
+}
+
 # -------------------------------------------------------
 # Unified GPS
 # -------------------------------------------------------
@@ -638,6 +1111,42 @@ type DailyActivitySummary {
   total_calories: Int
 }
 
+"""
+Paginated list of daily activity summaries.
+"""
+type DailySummaryConnection {
+  """
+  List of daily activity summary items in the current page
+  """
+  items: [DailyActivitySummary!]!
+  """
+  Total number of items matching the query
+  """
+  total: Int!
+  """
+  Maximum number of items per page
+  """
+  limit: Int!
+  """
+  Number of items skipped from the start
+  """
+  offset: Int!
+}
+
+"""
+Earliest and latest activity dates available in the daily activity summary view.
+"""
+type DailySummaryDateRange {
+  """
+  Earliest activity date with daily summary data (YYYY-MM-DD)
+  """
+  min_date: String!
+  """
+  Latest activity date with daily summary data (YYYY-MM-DD)
+  """
+  max_date: String!
+}
+
 # -------------------------------------------------------
 # Reference Locations
 # -------------------------------------------------------
@@ -893,7 +1402,17 @@ type Query {
     device_id: String
   ): LocationCount!
 
+  """
+  Get the earliest and latest location timestamps.
+  """
+  locationDateRange: LocationDateRange!
+
   # Garmin
+  """
+  Get the earliest and latest Garmin activity timestamps.
+  """
+  garminDateRange: GarminDateRange!
+
   """
   Retrieve a paginated list of Garmin activities.
   """
@@ -983,6 +1502,38 @@ type Query {
     activity_id: String!
   ): [GarminChartPoint!]!
 
+  """
+  Retrieve all reverse-geocoded addresses for a Garmin activity (start, mid-route waypoints, and end).
+  """
+  garminActivityAddresses(
+    """
+    Garmin Connect activity identifier
+    """
+    activity_id: String!
+  ): [GarminActivityAddress!]!
+
+  """
+  Aggregate Garmin activity totals grouped by week, month, or year.
+  """
+  garminActivityTotals(
+    """
+    Aggregation period: 'week', 'month', or 'year'
+    """
+    period: String!
+    """
+    Filter by sport (e.g. cycling, running)
+    """
+    sport: String
+    """
+    Inclusive lower bound on activity start time (YYYY-MM-DD)
+    """
+    date_from: String
+    """
+    Inclusive upper bound on activity start time (YYYY-MM-DD)
+    """
+    date_to: String
+  ): [GarminActivityTotal!]!
+
   # Unified GPS
   """
   Retrieve a paginated list of unified GPS points from all sources.
@@ -1012,6 +1563,14 @@ type Query {
     Sort direction
     """
     order: SortOrder
+    """
+    Exclude stationary points where speed is zero
+    """
+    exclude_stationary: Boolean
+    """
+    Remove points with duplicate coordinates (rounded to ~11m precision)
+    """
+    deduplicate: Boolean
   ): UnifiedGpsConnection!
 
   """
@@ -1027,10 +1586,19 @@ type Query {
     """
     date_to: String
     """
-    Maximum number of days to return
+    Maximum number of days to return per page
     """
     limit: Int
-  ): [DailyActivitySummary!]!
+    """
+    Number of items to skip for pagination
+    """
+    offset: Int
+  ): DailySummaryConnection!
+
+  """
+  Get the earliest and latest activity dates available in the daily activity summary view.
+  """
+  dailySummaryDateRange: DailySummaryDateRange!
 
   # Reference Locations
   """
@@ -1113,6 +1681,12 @@ type Query {
     """
     limit: Int
   ): WithinReferenceResult!
+
+  # Geocoding
+  """
+  Get geocoding coverage statistics.
+  """
+  geocodingStatus: GeocodingStatus!
 }
 
 # -------------------------------------------------------
@@ -1132,4 +1706,18 @@ type Mutation {
     """
     lookback: Int
   ): GarminSyncTriggerResult!
+
+  """
+  Trigger batch reverse-geocoding of un-geocoded location records.
+  """
+  triggerGeocoding(
+    """
+    Number of locations to geocode in this batch (default 100)
+    """
+    batch_size: Int
+    """
+    Re-process previously failed location records (for example, those with status `no_coverage`)
+    """
+    retry_failed: Boolean
+  ): GeocodingTriggerResult!
 }