@stuartshay/otel-graphql-types 1.0.445 → 1.0.468

package/index.d.ts

@@ -11,6 +11,32 @@ export interface Scalars {
   JSON: { input: Record<string, unknown>; output: Record<string, unknown> };
 }
 
+/** Input for creating a saved Garmin segment (e.g. from an activity lap or climb). */
+export interface CreateGarminSegmentInput {
+  /** Segment length in meters (optional metadata) */
+  distance_meters?: InputMaybe<Scalars['Float']['input']>;
+  /** Segment end latitude */
+  end_latitude: Scalars['Float']['input'];
+  /** Segment end longitude */
+  end_longitude: Scalars['Float']['input'];
+  /** Corridor radius (m) used to match traversing activities (default 35) */
+  match_tolerance_meters?: InputMaybe<Scalars['Float']['input']>;
+  /** Human-readable segment name */
+  name: Scalars['String']['input'];
+  /** Garmin activity this segment is created from, if any */
+  source_activity_id?: InputMaybe<Scalars['String']['input']>;
+  /** Zero-based ClimbPro split index the segment is created from, if any */
+  source_climb_index?: InputMaybe<Scalars['Int']['input']>;
+  /** Zero-based lap index the segment is created from, if any */
+  source_lap_index?: InputMaybe<Scalars['Int']['input']>;
+  /** Sport this segment applies to (e.g. cycling); null matches all sports */
+  sport?: InputMaybe<Scalars['String']['input']>;
+  /** Segment start latitude */
+  start_latitude: Scalars['Float']['input'];
+  /** Segment start longitude */
+  start_longitude: Scalars['Float']['input'];
+}
+
 /** Per-day aggregate combining OwnTracks location stats and Garmin activity metrics. */
 export interface DailyActivitySummary {
   __typename?: 'DailyActivitySummary';
@@ -345,6 +371,15 @@ export interface GarminActivityLap {
   updated_at?: Maybe<Scalars['String']['output']>;
 }
 
+/** Laps for a single activity within the batch laps comparison response. */
+export interface GarminActivityLapsGroup {
+  __typename?: 'GarminActivityLapsGroup';
+  /** Parent activity summary */
+  activity: GarminLapsActivity;
+  /** Laps ordered by lap_index ascending */
+  laps: Array<GarminActivityLap>;
+}
+
 /** Aggregated Garmin activity totals for a single time bucket (week, month, or year). */
 export interface GarminActivityTotal {
   __typename?: 'GarminActivityTotal';
@@ -422,6 +457,133 @@ export interface GarminDeviceCount {
   label: Scalars['String']['output'];
 }
 
+/** Activity summary metadata for a batch laps comparison item. */
+export interface GarminLapsActivity {
+  __typename?: 'GarminLapsActivity';
+  /** Garmin Connect activity identifier */
+  activity_id: Scalars['String']['output'];
+  /** Average activity heart rate in bpm */
+  avg_heart_rate?: Maybe<Scalars['Int']['output']>;
+  /** Average activity speed in km/h */
+  avg_speed_kmh?: Maybe<Scalars['Float']['output']>;
+  /** Total activity distance in kilometers */
+  distance_km?: Maybe<Scalars['Float']['output']>;
+  /** Total activity duration in seconds */
+  duration_seconds?: Maybe<Scalars['Float']['output']>;
+  /** Maximum activity heart rate in bpm */
+  max_heart_rate?: Maybe<Scalars['Int']['output']>;
+  /** Sport type (e.g. cycling) */
+  sport?: Maybe<Scalars['String']['output']>;
+  /** UTC activity start time */
+  start_time?: Maybe<Scalars['String']['output']>;
+  /** Sub-sport type (e.g. road) */
+  sub_sport?: Maybe<Scalars['String']['output']>;
+  /** Total activity elevation gain in meters */
+  total_ascent_m?: Maybe<Scalars['Float']['output']>;
+}
+
+/** Paginated batch of activities (each with their laps) for cross-activity lap comparison. */
+export interface GarminLapsComparisonConnection {
+  __typename?: 'GarminLapsComparisonConnection';
+  /** Activities (newest first), each with their laps ordered by lap_index */
+  items: Array<GarminActivityLapsGroup>;
+  /** Maximum number of activities per page */
+  limit: Scalars['Int']['output'];
+  /** Number of activities skipped from the start */
+  offset: Scalars['Int']['output'];
+  /** Total number of activities matching the query */
+  total: Scalars['Int']['output'];
+}
+
+/**
+ * A saved (named) Garmin segment: a start→end corridor used to compare efforts
+ * across all activities that traverse the same route.
+ */
+export interface GarminSegment {
+  __typename?: 'GarminSegment';
+  /** UTC timestamp when the segment was created */
+  created_at?: Maybe<Scalars['String']['output']>;
+  /** Segment length in meters (optional metadata) */
+  distance_meters?: Maybe<Scalars['Float']['output']>;
+  /** Segment end latitude */
+  end_latitude: Scalars['Float']['output'];
+  /** Segment end longitude */
+  end_longitude: Scalars['Float']['output'];
+  /** Unique segment identifier */
+  id: Scalars['Int']['output'];
+  /** Corridor radius (m) used to match traversing activities */
+  match_tolerance_meters: Scalars['Float']['output'];
+  /** Human-readable segment name (e.g. "Harlem Hill") */
+  name: Scalars['String']['output'];
+  /** Garmin activity this segment was created from, if any */
+  source_activity_id?: Maybe<Scalars['String']['output']>;
+  /** Zero-based ClimbPro split index the segment was created from, if any */
+  source_climb_index?: Maybe<Scalars['Int']['output']>;
+  /** Zero-based lap index the segment was created from, if any */
+  source_lap_index?: Maybe<Scalars['Int']['output']>;
+  /** Sport this segment applies to (e.g. cycling); null matches all sports */
+  sport?: Maybe<Scalars['String']['output']>;
+  /** Segment start latitude */
+  start_latitude: Scalars['Float']['output'];
+  /** Segment start longitude */
+  start_longitude: Scalars['Float']['output'];
+  /** UTC timestamp when the segment was last updated */
+  updated_at?: Maybe<Scalars['String']['output']>;
+}
+
+/** The start→end corridor a segment-efforts query was matched against. */
+export interface GarminSegmentDefinition {
+  __typename?: 'GarminSegmentDefinition';
+  /** Corridor end latitude */
+  end_lat: Scalars['Float']['output'];
+  /** Corridor end longitude */
+  end_lon: Scalars['Float']['output'];
+  /** Corridor start latitude */
+  start_lat: Scalars['Float']['output'];
+  /** Corridor start longitude */
+  start_lon: Scalars['Float']['output'];
+  /** Corridor radius in meters used for matching */
+  tolerance_meters: Scalars['Float']['output'];
+}
+
+/** A single activity's best traversal of a segment, ranked against all others. */
+export interface GarminSegmentEffort {
+  __typename?: 'GarminSegmentEffort';
+  /** Garmin activity identifier for this effort */
+  activity_id: Scalars['String']['output'];
+  /** UTC start time of the parent activity */
+  activity_start_time?: Maybe<Scalars['String']['output']>;
+  /** Average heart rate across the segment in bpm */
+  avg_heart_rate?: Maybe<Scalars['Int']['output']>;
+  /** Average speed across the segment in km/h */
+  avg_speed_kmh?: Maybe<Scalars['Float']['output']>;
+  /** Distance covered across the segment in km */
+  distance_km?: Maybe<Scalars['Float']['output']>;
+  /** UTC timestamp reaching the segment end corridor */
+  effort_end: Scalars['String']['output'];
+  /** UTC timestamp entering the segment start corridor */
+  effort_start: Scalars['String']['output'];
+  /** Segment elapsed time in seconds */
+  elapsed_seconds: Scalars['Float']['output'];
+  /** Maximum heart rate across the segment in bpm */
+  max_heart_rate?: Maybe<Scalars['Int']['output']>;
+  /** 1-based rank by elapsed time (1 = fastest) */
+  rank: Scalars['Int']['output'];
+  /** Sport type (e.g. cycling) */
+  sport?: Maybe<Scalars['String']['output']>;
+}
+
+/** Ranked efforts for a segment across all matching activities (fastest first). */
+export interface GarminSegmentEffortsConnection {
+  __typename?: 'GarminSegmentEffortsConnection';
+  /** Efforts ordered fastest-first */
+  items: Array<GarminSegmentEffort>;
+  /** The corridor the efforts were matched against */
+  segment: GarminSegmentDefinition;
+  /** Total number of matching efforts */
+  total: Scalars['Int']['output'];
+}
+
 /** Result payload returned when triggering an on-demand Garmin sync. */
 export interface GarminSyncTriggerResult {
   __typename?: 'GarminSyncTriggerResult';
@@ -729,12 +891,28 @@ export interface LocationDetail {
 
 export interface Mutation {
   __typename?: 'Mutation';
+  /**
+   * Create a saved Garmin segment (requires authentication). Typically called with
+   * the start/end coordinates of an activity lap or ClimbPro split to "save this
+   * lap as a segment".
+   */
+  createGarminSegment: GarminSegment;
+  /** Delete a saved Garmin segment by id (requires authentication). Returns true on success. */
+  deleteGarminSegment: Scalars['Boolean']['output'];
   /** 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 MutationCreateGarminSegmentArgs {
+  input: CreateGarminSegmentInput;
+}
+
+export interface MutationDeleteGarminSegmentArgs {
+  id: Scalars['Int']['input'];
+}
+
 export interface MutationTriggerGarminSyncArgs {
   lookback?: InputMaybe<Scalars['Int']['input']>;
   window_hours?: InputMaybe<Scalars['Int']['input']>;
@@ -801,6 +979,14 @@ export interface Query {
   garminDateRange: GarminDateRange;
   /** List Garmin recording device labels with activity counts. */
   garminDeviceCounts: Array<GarminDeviceCount>;
+  /** Batch laps across activities for cross-activity comparison (matrix of activities x lap_index). */
+  garminLapsComparison: GarminLapsComparisonConnection;
+  /** Fetch a single saved Garmin segment by id. Returns null if it does not exist. */
+  garminSegment?: Maybe<GarminSegment>;
+  /** Rank all historical activity efforts over a saved segment (fastest first). */
+  garminSegmentEfforts: GarminSegmentEffortsConnection;
+  /** List saved Garmin segments, optionally filtered by sport. */
+  garminSegments: Array<GarminSegment>;
   /** List all distinct sport types with activity counts. */
   garminSports: Array<SportInfo>;
   /** Retrieve paginated GPS track points for a Garmin activity. */
@@ -882,6 +1068,30 @@ export interface QueryGarminChartDataArgs {
   activity_id: Scalars['String']['input'];
 }
 
+export interface QueryGarminLapsComparisonArgs {
+  date_from?: InputMaybe<Scalars['String']['input']>;
+  date_to?: InputMaybe<Scalars['String']['input']>;
+  limit?: InputMaybe<Scalars['Int']['input']>;
+  offset?: InputMaybe<Scalars['Int']['input']>;
+  sport?: InputMaybe<Scalars['String']['input']>;
+}
+
+export interface QueryGarminSegmentArgs {
+  id: Scalars['Int']['input'];
+}
+
+export interface QueryGarminSegmentEffortsArgs {
+  date_from?: InputMaybe<Scalars['String']['input']>;
+  date_to?: InputMaybe<Scalars['String']['input']>;
+  id: Scalars['Int']['input'];
+  limit?: InputMaybe<Scalars['Int']['input']>;
+  max_effort_seconds?: InputMaybe<Scalars['Int']['input']>;
+}
+
+export interface QueryGarminSegmentsArgs {
+  sport?: InputMaybe<Scalars['String']['input']>;
+}
+
 export interface QueryGarminTrackPointsArgs {
   activity_id: Scalars['String']['input'];
   limit?: InputMaybe<Scalars['Int']['input']>;
@@ -942,8 +1152,8 @@ export interface QueryWithinReferenceArgs {
 /** Service readiness status including database connectivity. */
 export interface ReadyStatus {
   __typename?: 'ReadyStatus';
-  /** Database connection status */
-  database?: Maybe<Scalars['String']['output']>;
+  /** Database readiness payload returned by otel-data-api */
+  database?: Maybe<Scalars['JSON']['output']>;
   /** Service readiness status */
   status: Scalars['String']['output'];
   /** Application version from VERSION file */

package/package.json

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

package/schema.graphql

@@ -50,9 +50,9 @@ type ReadyStatus {
   """
   status: String!
   """
-  Database connection status
+  Database readiness payload returned by otel-data-api
   """
-  database: String
+  database: JSON
   """
   Application version from VERSION file
   """
@@ -896,6 +896,295 @@ type GarminActivityLap {
   updated_at: String
 }
 
+"""
+Activity summary metadata for a batch laps comparison item.
+"""
+type GarminLapsActivity {
+  """
+  Garmin Connect activity identifier
+  """
+  activity_id: String!
+  """
+  Sport type (e.g. cycling)
+  """
+  sport: String
+  """
+  Sub-sport type (e.g. road)
+  """
+  sub_sport: String
+  """
+  UTC activity start time
+  """
+  start_time: String
+  """
+  Total activity distance in kilometers
+  """
+  distance_km: Float
+  """
+  Total activity duration in seconds
+  """
+  duration_seconds: Float
+  """
+  Average activity speed in km/h
+  """
+  avg_speed_kmh: Float
+  """
+  Average activity heart rate in bpm
+  """
+  avg_heart_rate: Int
+  """
+  Maximum activity heart rate in bpm
+  """
+  max_heart_rate: Int
+  """
+  Total activity elevation gain in meters
+  """
+  total_ascent_m: Float
+}
+
+"""
+Laps for a single activity within the batch laps comparison response.
+"""
+type GarminActivityLapsGroup {
+  """
+  Parent activity summary
+  """
+  activity: GarminLapsActivity!
+  """
+  Laps ordered by lap_index ascending
+  """
+  laps: [GarminActivityLap!]!
+}
+
+"""
+Paginated batch of activities (each with their laps) for cross-activity lap comparison.
+"""
+type GarminLapsComparisonConnection {
+  """
+  Activities (newest first), each with their laps ordered by lap_index
+  """
+  items: [GarminActivityLapsGroup!]!
+  """
+  Total number of activities matching the query
+  """
+  total: Int!
+  """
+  Maximum number of activities per page
+  """
+  limit: Int!
+  """
+  Number of activities skipped from the start
+  """
+  offset: Int!
+}
+
+"""
+A saved (named) Garmin segment: a start→end corridor used to compare efforts
+across all activities that traverse the same route.
+"""
+type GarminSegment {
+  """
+  Unique segment identifier
+  """
+  id: Int!
+  """
+  Human-readable segment name (e.g. "Harlem Hill")
+  """
+  name: String!
+  """
+  Sport this segment applies to (e.g. cycling); null matches all sports
+  """
+  sport: String
+  """
+  Segment start latitude
+  """
+  start_latitude: Float!
+  """
+  Segment start longitude
+  """
+  start_longitude: Float!
+  """
+  Segment end latitude
+  """
+  end_latitude: Float!
+  """
+  Segment end longitude
+  """
+  end_longitude: Float!
+  """
+  Segment length in meters (optional metadata)
+  """
+  distance_meters: Float
+  """
+  Corridor radius (m) used to match traversing activities
+  """
+  match_tolerance_meters: Float!
+  """
+  Garmin activity this segment was created from, if any
+  """
+  source_activity_id: String
+  """
+  Zero-based lap index the segment was created from, if any
+  """
+  source_lap_index: Int
+  """
+  Zero-based ClimbPro split index the segment was created from, if any
+  """
+  source_climb_index: Int
+  """
+  UTC timestamp when the segment was created
+  """
+  created_at: String
+  """
+  UTC timestamp when the segment was last updated
+  """
+  updated_at: String
+}
+
+"""
+The start→end corridor a segment-efforts query was matched against.
+"""
+type GarminSegmentDefinition {
+  """
+  Corridor start latitude
+  """
+  start_lat: Float!
+  """
+  Corridor start longitude
+  """
+  start_lon: Float!
+  """
+  Corridor end latitude
+  """
+  end_lat: Float!
+  """
+  Corridor end longitude
+  """
+  end_lon: Float!
+  """
+  Corridor radius in meters used for matching
+  """
+  tolerance_meters: Float!
+}
+
+"""
+A single activity's best traversal of a segment, ranked against all others.
+"""
+type GarminSegmentEffort {
+  """
+  1-based rank by elapsed time (1 = fastest)
+  """
+  rank: Int!
+  """
+  Garmin activity identifier for this effort
+  """
+  activity_id: String!
+  """
+  Sport type (e.g. cycling)
+  """
+  sport: String
+  """
+  UTC start time of the parent activity
+  """
+  activity_start_time: String
+  """
+  UTC timestamp entering the segment start corridor
+  """
+  effort_start: String!
+  """
+  UTC timestamp reaching the segment end corridor
+  """
+  effort_end: String!
+  """
+  Segment elapsed time in seconds
+  """
+  elapsed_seconds: Float!
+  """
+  Distance covered across the segment in km
+  """
+  distance_km: Float
+  """
+  Average speed across the segment in km/h
+  """
+  avg_speed_kmh: Float
+  """
+  Average heart rate across the segment in bpm
+  """
+  avg_heart_rate: Int
+  """
+  Maximum heart rate across the segment in bpm
+  """
+  max_heart_rate: Int
+}
+
+"""
+Ranked efforts for a segment across all matching activities (fastest first).
+"""
+type GarminSegmentEffortsConnection {
+  """
+  The corridor the efforts were matched against
+  """
+  segment: GarminSegmentDefinition!
+  """
+  Efforts ordered fastest-first
+  """
+  items: [GarminSegmentEffort!]!
+  """
+  Total number of matching efforts
+  """
+  total: Int!
+}
+
+"""
+Input for creating a saved Garmin segment (e.g. from an activity lap or climb).
+"""
+input CreateGarminSegmentInput {
+  """
+  Human-readable segment name
+  """
+  name: String!
+  """
+  Sport this segment applies to (e.g. cycling); null matches all sports
+  """
+  sport: String
+  """
+  Segment start latitude
+  """
+  start_latitude: Float!
+  """
+  Segment start longitude
+  """
+  start_longitude: Float!
+  """
+  Segment end latitude
+  """
+  end_latitude: Float!
+  """
+  Segment end longitude
+  """
+  end_longitude: Float!
+  """
+  Segment length in meters (optional metadata)
+  """
+  distance_meters: Float
+  """
+  Corridor radius (m) used to match traversing activities (default 35)
+  """
+  match_tolerance_meters: Float
+  """
+  Garmin activity this segment is created from, if any
+  """
+  source_activity_id: String
+  """
+  Zero-based lap index the segment is created from, if any
+  """
+  source_lap_index: Int
+  """
+  Zero-based ClimbPro split index the segment is created from, if any
+  """
+  source_climb_index: Int
+}
+
 """
 Individual GPS track point within a Garmin activity.
 """
@@ -1769,6 +2058,78 @@ type Query {
     activity_id: String!
   ): [GarminActivityLap!]!
 
+  """
+  Batch laps across activities for cross-activity comparison (matrix of activities x lap_index).
+  """
+  garminLapsComparison(
+    """
+    Filter by sport type (e.g. cycling, running)
+    """
+    sport: String
+    """
+    Start date filter (YYYY-MM-DD), inclusive on activity start_time
+    """
+    date_from: String
+    """
+    End date filter (YYYY-MM-DD), inclusive on activity start_time
+    """
+    date_to: String
+    """
+    Maximum number of activities to return per page
+    """
+    limit: Int
+    """
+    Number of activities to skip for pagination
+    """
+    offset: Int
+  ): GarminLapsComparisonConnection!
+
+  """
+  List saved Garmin segments, optionally filtered by sport.
+  """
+  garminSegments(
+    """
+    Filter by sport type (e.g. cycling, running)
+    """
+    sport: String
+  ): [GarminSegment!]!
+
+  """
+  Fetch a single saved Garmin segment by id. Returns null if it does not exist.
+  """
+  garminSegment(
+    """
+    Segment identifier
+    """
+    id: Int!
+  ): GarminSegment
+
+  """
+  Rank all historical activity efforts over a saved segment (fastest first).
+  """
+  garminSegmentEfforts(
+    """
+    Segment identifier
+    """
+    id: Int!
+    """
+    Start date filter (YYYY-MM-DD), inclusive on activity start_time
+    """
+    date_from: String
+    """
+    End date filter (YYYY-MM-DD), inclusive on activity start_time
+    """
+    date_to: String
+    """
+    Ignore traversals longer than this many seconds (filters loop/return mismatches)
+    """
+    max_effort_seconds: Int
+    """
+    Maximum number of efforts to return
+    """
+    limit: Int
+  ): GarminSegmentEffortsConnection!
+
   """
   Retrieve all reverse-geocoded addresses for a Garmin activity (start, mid-route waypoints, and end).
   """
@@ -1987,4 +2348,26 @@ type Mutation {
     """
     retry_failed: Boolean
   ): GeocodingTriggerResult!
+
+  """
+  Create a saved Garmin segment (requires authentication). Typically called with
+  the start/end coordinates of an activity lap or ClimbPro split to "save this
+  lap as a segment".
+  """
+  createGarminSegment(
+    """
+    Segment definition
+    """
+    input: CreateGarminSegmentInput!
+  ): GarminSegment!
+
+  """
+  Delete a saved Garmin segment by id (requires authentication). Returns true on success.
+  """
+  deleteGarminSegment(
+    """
+    Segment identifier
+    """
+    id: Int!
+  ): Boolean!
 }