@findatruck/shared-schemas 2.20.0 → 2.23.1

package/dist/index.js

@@ -6,6 +6,8 @@ import {
   ConvexUpdateSchema,
   DRIVER_NAME_FORBIDDEN_CHAR_PATTERN,
   DriverNameSchema,
+  ListDriversRequestSchema,
+  ListDriversResponseSchema,
   NewLoginRequest,
   NewLoginRequestSchema,
   NewLoginResponse,
@@ -25,7 +27,7 @@ import {
   UpdateScrapeStatusMessage,
   ValidatePasswordRequestSchema,
   ValidatePasswordResponseSchema
-} from "./chunk-P4S46OZI.js";
+} from "./chunk-EQIUGAWW.js";
 
 // src/schemas/drivers/anonymous-driver.ts
 import z from "zod";
@@ -47,192 +49,330 @@ var DeleteAnonymousDriverResponseSchema = z.object({
   user_id: z.string()
 });
 
-// src/schemas/providerAccounts/delete-provider-account.ts
+// src/schemas/providerAccounts/validate-login.ts
 import { z as z2 } from "zod";
-var DeleteProviderAccountRequestSchema = z2.object({
-  providerAccountId: z2.string().min(1).describe("The external provider account ID to delete")
+var UrlSchema = z2.string().refine(
+  (val) => {
+    try {
+      new URL(val);
+      return true;
+    } catch {
+      return false;
+    }
+  },
+  { message: "Invalid URL" }
+);
+var ValidateLoginRequestSchema = z2.object({
+  providerUrl: UrlSchema.describe("The URL of the ELD provider to validate credentials against"),
+  username: z2.string().min(1).describe("The username to validate"),
+  encryptedPassword: z2.string().min(1).describe("The encrypted password to validate")
+}).describe("Request schema for validating login credentials via browser auth");
+var ValidateLoginResponseSchema = z2.object({
+  success: z2.boolean().describe("Indicates if the login credentials are valid")
+}).describe("Response schema for login validation");
+
+// src/schemas/providerAccounts/delete-provider-account.ts
+import { z as z3 } from "zod";
+var DeleteProviderAccountRequestSchema = z3.object({
+  providerAccountId: z3.string().min(1).describe("The external provider account ID to delete")
 }).describe("Request schema for deleting a provider account");
-var DeleteProviderAccountResponseSchema = z2.object({
-  success: z2.boolean().describe("Indicates if the provider account was successfully deleted")
+var DeleteProviderAccountResponseSchema = z3.object({
+  success: z3.boolean().describe("Indicates if the provider account was successfully deleted")
 }).describe("Response schema for provider account deletion");
 
 // src/schemas/telemetry/driver-rankings.ts
-import { z as z3 } from "zod";
-var DriverRankingsRequestSchema = z3.object({
-  start_date: z3.string().describe("Start date for the ranking period (ISO 8601 format)"),
-  end_date: z3.string().describe("End date for the ranking period (ISO 8601 format)"),
-  state: z3.string().length(2).optional().describe("Optional 2-letter state abbreviation to filter telemetry by location"),
-  source: z3.enum(["eld", "manual"]).default("manual").describe("Telemetry source to rank by: 'manual' uses GPS odometer, 'eld' uses calculated distance")
+import { z as z4 } from "zod";
+var DriverRankingsRequestSchema = z4.object({
+  start_date: z4.string().describe("Start date for the ranking period (ISO 8601 format)"),
+  end_date: z4.string().describe("End date for the ranking period (ISO 8601 format)"),
+  state: z4.string().length(2).optional().describe("Optional 2-letter state abbreviation to filter telemetry by location"),
+  source: z4.enum(["eld", "manual"]).default("manual").describe("Telemetry source to rank by: 'manual' uses GPS odometer, 'eld' uses calculated distance")
 }).describe("Request schema for driver rankings by miles driven");
-var DriverRankingSchema = z3.object({
-  rank: z3.number().int().positive().describe("Rank position based on miles driven"),
-  driver_id: z3.string().uuid().describe("Unique identifier of the driver"),
-  driver_name: z3.string().describe("Name of the driver"),
-  total_miles: z3.number().min(0).describe("Total miles driven in the specified period")
+var DriverRankingSchema = z4.object({
+  rank: z4.number().int().positive().describe("Rank position based on miles driven"),
+  driver_id: z4.string().uuid().describe("Unique identifier of the driver"),
+  driver_name: z4.string().describe("Name of the driver"),
+  total_miles: z4.number().min(0).describe("Total miles driven in the specified period")
 }).describe("Single driver ranking entry");
-var DriverRankingsResponseSchema = z3.array(DriverRankingSchema).describe("Array of driver rankings sorted by miles driven in descending order");
+var DriverRankingsResponseSchema = z4.array(DriverRankingSchema).describe("Array of driver rankings sorted by miles driven in descending order");
 
 // src/schemas/telemetry/state-heatmap.ts
-import { z as z4 } from "zod";
-var StateHeatmapRequestSchema = z4.object({
-  driver_id: z4.string().uuid().describe("Unique identifier of the driver"),
-  start_date: z4.string().describe("Start date for the heatmap period (ISO 8601 format)"),
-  end_date: z4.string().describe("End date for the heatmap period (ISO 8601 format)")
+import { z as z5 } from "zod";
+var StateHeatmapRequestSchema = z5.object({
+  driver_id: z5.string().uuid().describe("Unique identifier of the driver"),
+  start_date: z5.string().describe("Start date for the heatmap period (ISO 8601 format)"),
+  end_date: z5.string().describe("End date for the heatmap period (ISO 8601 format)")
 }).describe("Request schema for driver state heatmap");
-var StateHeatmapEntrySchema = z4.object({
-  count: z4.number().int().min(0).describe("Number of telemetry points in this state"),
-  percentage: z4.number().min(0).max(100).describe("Percentage of total telemetry points in this state")
+var StateHeatmapEntrySchema = z5.object({
+  count: z5.number().int().min(0).describe("Number of telemetry points in this state"),
+  percentage: z5.number().min(0).max(100).describe("Percentage of total telemetry points in this state")
 }).describe("Single state entry in the heatmap");
-var StateHeatmapResponseSchema = z4.record(
-  z4.string().length(2),
+var StateHeatmapResponseSchema = z5.record(
+  z5.string().length(2),
   StateHeatmapEntrySchema
 ).describe("Record of 2-letter state codes to heatmap entries");
 
 // src/schemas/telemetry/manual-batch.ts
-import { z as z5 } from "zod";
-var ManualBatchEntrySchema = z5.object({
-  driver_id: z5.string().uuid().describe("Internal UUID of the driver"),
-  timestamp: z5.string().datetime().describe("Timestamp of the GPS reading (ISO 8601 format)"),
-  location_latitude: z5.number().min(-90).max(90).describe("GPS latitude coordinate"),
-  location_longitude: z5.number().min(-180).max(180).describe("GPS longitude coordinate"),
-  location_address: z5.string().optional().describe("Optional human-readable address"),
-  vehicle_odometer_miles: z5.number().min(0).optional().describe("Optional vehicle odometer reading in miles"),
-  heading: z5.number().min(0).max(360).optional().describe("Optional GPS heading in degrees (0-360)"),
-  speed_mph: z5.number().min(0).optional().describe("Optional GPS speed in miles per hour"),
-  altitude_feet: z5.number().optional().describe("Optional GPS altitude in feet"),
-  raw: z5.record(z5.string(), z5.unknown()).optional().describe("Optional raw upstream JSON payload to archive alongside this entry"),
-  driving_status: z5.enum(["parked", "driving"]).optional().describe("Optional parked/driving status reported by the upstream system")
+import { z as z6 } from "zod";
+var ManualBatchEntrySchema = z6.object({
+  driver_id: z6.string().uuid().describe("Internal UUID of the driver"),
+  timestamp: z6.string().datetime().describe("Timestamp of the GPS reading (ISO 8601 format)"),
+  location_latitude: z6.number().min(-90).max(90).describe("GPS latitude coordinate"),
+  location_longitude: z6.number().min(-180).max(180).describe("GPS longitude coordinate"),
+  location_address: z6.string().optional().describe("Optional human-readable address"),
+  vehicle_odometer_miles: z6.number().min(0).optional().describe("Optional vehicle odometer reading in miles"),
+  heading: z6.number().min(0).max(360).optional().describe("Optional GPS heading in degrees (0-360)"),
+  speed_mph: z6.number().min(0).optional().describe("Optional GPS speed in miles per hour"),
+  altitude_feet: z6.number().optional().describe("Optional GPS altitude in feet"),
+  raw: z6.record(z6.string(), z6.unknown()).optional().describe("Optional raw upstream JSON payload to archive alongside this entry"),
+  driving_status: z6.enum(["parked", "driving"]).optional().describe("Optional parked/driving status reported by the upstream system"),
+  activity_type: z6.string().optional().describe("Optional activity recognition type (e.g. 'in_vehicle', 'on_foot')"),
+  activity_confidence: z6.number().int().min(0).max(100).optional().describe("Optional activity recognition confidence (0-100)")
 }).describe("Single manual telemetry entry");
-var ManualBatchRequestSchema = z5.object({
-  entries: z5.array(ManualBatchEntrySchema).min(1).max(1e3).describe("Array of manual telemetry entries (1-1000)")
-}).describe("Request schema for manual batch telemetry insertion");
-var ManualBatchTelemetrySchema = z5.object({
-  id: z5.number().int().describe("Telemetry record ID"),
-  driver_id: z5.string().uuid().describe("Internal UUID of the driver"),
-  timestamp: z5.union([z5.string(), z5.date()]).describe("Timestamp of the telemetry reading"),
-  remaining_drive_time_in_seconds: z5.number().min(0),
-  remaining_shift_time_in_seconds: z5.number().min(0),
-  remaining_cycle_time_in_seconds: z5.number().min(0),
-  remaining_break_time_in_seconds: z5.number().min(0),
-  location_latitude: z5.number().min(-90).max(90),
-  location_longitude: z5.number().min(-180).max(180),
-  previous_location_latitude: z5.number().min(-90).max(90).nullable(),
-  previous_location_longitude: z5.number().min(-180).max(180).nullable(),
-  location_address: z5.string().nullable(),
-  location_state: z5.string().length(2).nullable(),
-  echoed_odometer_miles: z5.number().min(0).nullable().describe("Vehicle odometer reading echoed back from the request (miles)"),
-  osrm_calculated_miles: z5.number().min(0).nullable().describe("Road distance calculated by OSRM between this point and the previous point (miles)"),
-  heading: z5.number().nullish(),
-  speed_mph: z5.number().nullish(),
-  altitude_feet: z5.number().nullish(),
-  source: z5.enum(["eld", "manual"]),
-  driving_status: z5.enum(["parked", "driving"]).nullable()
+var ManualBatchTelemetrySchema = z6.object({
+  id: z6.number().int().describe("Telemetry record ID"),
+  driver_id: z6.string().uuid().describe("Internal UUID of the driver"),
+  timestamp: z6.union([z6.string(), z6.date()]).describe("Timestamp of the telemetry reading"),
+  remaining_drive_time_in_seconds: z6.number().min(0),
+  remaining_shift_time_in_seconds: z6.number().min(0),
+  remaining_cycle_time_in_seconds: z6.number().min(0),
+  remaining_break_time_in_seconds: z6.number().min(0),
+  location_latitude: z6.number().min(-90).max(90),
+  location_longitude: z6.number().min(-180).max(180),
+  previous_location_latitude: z6.number().min(-90).max(90).nullable(),
+  previous_location_longitude: z6.number().min(-180).max(180).nullable(),
+  location_address: z6.string().nullable(),
+  location_state: z6.string().length(2).nullable(),
+  echoed_odometer_miles: z6.number().min(0).nullable().describe("Vehicle odometer reading echoed back from the request (miles)"),
+  osrm_calculated_miles: z6.number().min(0).nullable().describe("Road distance calculated by OSRM between this point and the previous point (miles)"),
+  heading: z6.number().nullish(),
+  speed_mph: z6.number().nullish(),
+  altitude_feet: z6.number().nullish(),
+  source: z6.enum(["eld", "manual"]),
+  driving_status: z6.enum(["parked", "driving"]).nullable(),
+  activity_type: z6.string().nullable(),
+  activity_confidence: z6.number().int().nullable()
 }).describe("Telemetry record returned from manual batch insertion");
-var ManualBatchResponseSchema = z5.object({
-  message: z5.string().describe("Success message"),
-  inserted_count: z5.number().int().min(0).describe("Number of telemetry entries inserted"),
-  telemetry: z5.array(ManualBatchTelemetrySchema).describe("Array of inserted telemetry records")
+var ManualBatchResponseSchema = z6.object({
+  message: z6.string().describe("Success message"),
+  inserted_count: z6.number().int().min(0).describe("Number of telemetry entries inserted"),
+  telemetry: z6.array(ManualBatchTelemetrySchema).describe("Array of inserted telemetry records")
 }).describe("Response schema for manual batch telemetry insertion");
 
+// src/schemas/telemetry/bggeo-batch.ts
+import { z as z7 } from "zod";
+var BGGeoCoordsSchema = z7.object({
+  latitude: z7.number().min(-90).max(90),
+  longitude: z7.number().min(-180).max(180),
+  accuracy: z7.number().optional(),
+  speed: z7.number().describe("Speed in m/s; -1 when unavailable"),
+  heading: z7.number().describe("Heading in degrees; -1 when unavailable"),
+  altitude: z7.number().describe("Altitude in meters"),
+  altitude_accuracy: z7.number().optional(),
+  speed_accuracy: z7.number().optional(),
+  heading_accuracy: z7.number().optional(),
+  ellipsoidal_altitude: z7.number().optional(),
+  floor: z7.number().nullable().optional()
+}).describe("BGGeo coords object");
+var BGGeoActivitySchema = z7.object({
+  type: z7.string(),
+  confidence: z7.number()
+}).describe("BGGeo activity recognition");
+var BGGeoBatterySchema = z7.object({
+  is_charging: z7.boolean(),
+  level: z7.number()
+}).describe("BGGeo battery status");
+var BGGeoLocationSchema = z7.object({
+  coords: BGGeoCoordsSchema,
+  extras: z7.object({}).passthrough().optional(),
+  activity: BGGeoActivitySchema.optional(),
+  battery: BGGeoBatterySchema.optional(),
+  timestamp: z7.string().datetime().describe("ISO 8601 timestamp"),
+  is_moving: z7.boolean(),
+  odometer: z7.number().min(0).describe("Odometer in meters"),
+  uuid: z7.string().optional(),
+  event: z7.string().optional(),
+  age: z7.number().optional(),
+  geofence: z7.record(z7.string(), z7.unknown()).optional(),
+  mock: z7.boolean().optional(),
+  recorded_at: z7.string().datetime().optional().describe("ISO 8601 device recording timestamp")
+}).passthrough().describe("Single BGGeo location object");
+var locationArray = z7.array(BGGeoLocationSchema).min(1).max(1e3).describe("Array of BGGeo location objects (1-1000)");
+var locationOrArray = z7.union([
+  BGGeoLocationSchema.transform((loc) => [loc]),
+  locationArray
+]);
+var BGGeoBatchRequestSchema = z7.object({
+  location: locationOrArray.optional(),
+  locations: locationOrArray.optional()
+}).refine((data) => data.location ?? data.locations, {
+  message: "Either 'location' or 'locations' must be provided"
+}).describe("Request schema for BGGeo batch telemetry ingestion");
+
 // src/schemas/trips/driver-trips.ts
-import { z as z6 } from "zod";
-var DriverTripsRequestSchema = z6.object({
-  driver_id: z6.string().uuid(),
-  start_date: z6.string(),
+import { z as z8 } from "zod";
+var DriverTripsRequestSchema = z8.object({
+  driver_id: z8.string().uuid(),
+  start_date: z8.string(),
   // YYYY-MM-DD
-  end_date: z6.string()
+  end_date: z8.string()
   // YYYY-MM-DD
 });
-var DriverTripSchema = z6.object({
-  id: z6.number(),
-  start_time: z6.string(),
-  end_time: z6.string(),
-  point_count: z6.number(),
-  polyline: z6.string().nullable(),
-  highways: z6.array(z6.string()).nullable(),
-  total_miles: z6.number().nullable(),
-  avg_speed_mph: z6.number().nullable(),
-  miles_by_weather: z6.record(z6.string(), z6.number()).nullable(),
-  miles_by_light: z6.record(z6.string(), z6.number()).nullable()
+var DriverTripSchema = z8.object({
+  id: z8.number(),
+  start_time: z8.string(),
+  end_time: z8.string(),
+  point_count: z8.number(),
+  polyline: z8.string().nullable(),
+  highways: z8.array(z8.string()).nullable(),
+  total_miles: z8.number().nullable(),
+  avg_speed_mph: z8.number().nullable(),
+  miles_by_weather: z8.record(z8.string(), z8.number()).nullable(),
+  miles_by_light: z8.record(z8.string(), z8.number()).nullable()
 });
-var DriverTripsResponseSchema = z6.array(DriverTripSchema);
-var DriverDailySummarySchema = z6.object({
-  summary_date: z6.string(),
-  total_miles: z6.number(),
-  trip_count: z6.number(),
-  point_count: z6.number(),
-  polyline: z6.string().nullable(),
-  highways: z6.array(z6.string()).nullable(),
-  avg_speed_mph: z6.number().nullable(),
-  miles_by_weather: z6.record(z6.string(), z6.number()).nullable(),
-  miles_by_light: z6.record(z6.string(), z6.number()).nullable()
+var DriverTripsResponseSchema = z8.array(DriverTripSchema);
+var DriverDailySummarySchema = z8.object({
+  summary_date: z8.string(),
+  total_miles: z8.number(),
+  trip_count: z8.number(),
+  point_count: z8.number(),
+  polyline: z8.string().nullable(),
+  highways: z8.array(z8.string()).nullable(),
+  avg_speed_mph: z8.number().nullable(),
+  miles_by_weather: z8.record(z8.string(), z8.number()).nullable(),
+  miles_by_light: z8.record(z8.string(), z8.number()).nullable()
 });
-var DriverDailySummariesResponseSchema = z6.array(DriverDailySummarySchema);
+var DriverDailySummariesResponseSchema = z8.array(DriverDailySummarySchema);
 
 // src/schemas/trips/enriched-trip-summary.ts
-import { z as z7 } from "zod";
-var EnrichedTripSummaryRequestSchema = z7.object({
-  trip_id: z7.number()
+import { z as z9 } from "zod";
+var EnrichedTripSummaryRequestSchema = z9.object({
+  trip_id: z9.number()
 });
-var DriverEnrichedSummariesRequestSchema = z7.object({
-  driver_id: z7.string().uuid(),
-  start_date: z7.string(),
-  end_date: z7.string()
+var DriverEnrichedSummariesRequestSchema = z9.object({
+  driver_id: z9.string().uuid(),
+  start_date: z9.string(),
+  end_date: z9.string()
 });
-var EnrichedStopSchema = z7.object({
-  duration_seconds: z7.number()
+var EnrichedStopSchema = z9.object({
+  duration_seconds: z9.number()
 });
-var EnrichedPointSchema = z7.object({
-  lat: z7.number(),
-  lon: z7.number(),
-  timestamp: z7.string(),
-  speed_mph: z7.number().nullable(),
-  heading: z7.number().nullable(),
-  altitude_feet: z7.number().nullable(),
-  weather_condition: z7.string().nullable(),
-  temperature_f: z7.number().nullable(),
-  visibility_miles: z7.number().nullable(),
-  light_condition: z7.string().nullable(),
+var EnrichedPointSchema = z9.object({
+  lat: z9.number(),
+  lon: z9.number(),
+  timestamp: z9.string(),
+  speed_mph: z9.number().nullable(),
+  heading: z9.number().nullable(),
+  altitude_feet: z9.number().nullable(),
+  weather_condition: z9.string().nullable(),
+  temperature_f: z9.number().nullable(),
+  visibility_miles: z9.number().nullable(),
+  light_condition: z9.string().nullable(),
   stop: EnrichedStopSchema.nullable()
 });
-var EnrichedTripSummarySchema = z7.object({
-  trip_id: z7.number(),
-  driver_id: z7.string(),
-  start_time: z7.string(),
-  end_time: z7.string(),
-  points: z7.array(EnrichedPointSchema)
+var EnrichedTripSummarySchema = z9.object({
+  trip_id: z9.number(),
+  driver_id: z9.string(),
+  start_time: z9.string(),
+  end_time: z9.string(),
+  points: z9.array(EnrichedPointSchema)
 });
 var EnrichedTripSummaryResponseSchema = EnrichedTripSummarySchema;
-var DriverEnrichedSummariesResponseSchema = z7.array(EnrichedTripSummarySchema);
+var DriverEnrichedSummariesResponseSchema = z9.array(EnrichedTripSummarySchema);
+
+// src/schemas/trips/convex-driver-trip.ts
+import { z as z10 } from "zod";
+var ConvexBreadcrumbEventSchema = z10.object({
+  ts: z10.number(),
+  // epoch ms
+  status: z10.string(),
+  lat: z10.number(),
+  lon: z10.number(),
+  heading: z10.number().optional(),
+  locationText: z10.string().optional(),
+  speedKph: z10.number().optional(),
+  altitudeFeet: z10.number().optional()
+});
+var ConvexDriverTripRequestSchema = z10.object({
+  userId: z10.string(),
+  breadcrumbs: z10.array(ConvexBreadcrumbEventSchema).min(1)
+});
+
+// src/schemas/trips/post-driver-trip-telemetry.ts
+import { z as z11 } from "zod";
+var PostDriverTripTelemetryRecordSchema = z11.object({
+  location_latitude: z11.number(),
+  location_longitude: z11.number(),
+  location_address: z11.string().optional(),
+  heading: z11.number(),
+  drivingState: z11.string(),
+  speedKph: z11.number(),
+  altitudeFeet: z11.number(),
+  gps_timestamp: z11.string().optional(),
+  odometer: z11.number().optional(),
+  activity_type: z11.string().optional(),
+  activity_confidence: z11.number().int().optional()
+});
+var PostDriverTripTelemetryRequestSchema = z11.object({
+  honkUserId: z11.string(),
+  telemetry: z11.array(PostDriverTripTelemetryRecordSchema).min(1)
+});
+
+// src/schemas/trips/post-daily-summary.ts
+import { z as z12 } from "zod";
+var PostDailySummaryRecordSchema = z12.object({
+  externalDriverId: z12.string(),
+  // drivers.id from Postgres
+  date: z12.string(),
+  // "YYYY-MM-DD"
+  totalMiles: z12.number(),
+  tripCount: z12.number(),
+  pointCount: z12.number(),
+  polyline: z12.string().optional(),
+  highways: z12.array(z12.string()).optional(),
+  avgSpeedMph: z12.number().optional(),
+  milesByWeather: z12.record(z12.string(), z12.number()).optional(),
+  milesByLight: z12.record(z12.string(), z12.number()).optional(),
+  states: z12.array(z12.string()).optional(),
+  origin: z12.string().optional(),
+  destination: z12.string().optional(),
+  altitudeGainedFeet: z12.number().optional(),
+  altitudeLostFeet: z12.number().optional(),
+  userId: z12.string().optional()
+  // Convex user ID (honk_user_id) for fallback driver resolution
+});
+var PostDailySummaryRequestSchema = z12.object({
+  summaries: z12.array(PostDailySummaryRecordSchema).min(1)
+});
 
 // src/auth-data.ts
-import { z as z8 } from "zod";
-var GomotiveAuthDataSchema = z8.object({
-  kind: z8.literal("gomotive"),
-  token: z8.string(),
-  ownerOperator: z8.boolean()
+import { z as z13 } from "zod";
+var GomotiveAuthDataSchema = z13.object({
+  kind: z13.literal("gomotive"),
+  token: z13.string(),
+  ownerOperator: z13.boolean()
 });
-var VistaAuthDataSchema = z8.object({
-  kind: z8.literal("vista"),
-  driverId: z8.string(),
-  cookie: z8.string()
+var VistaAuthDataSchema = z13.object({
+  kind: z13.literal("vista"),
+  driverId: z13.string(),
+  cookie: z13.string()
 });
-var MockAuthDataSchema = z8.object({
-  kind: z8.literal("mock"),
-  cookie: z8.string()
+var MockAuthDataSchema = z13.object({
+  kind: z13.literal("mock"),
+  cookie: z13.string()
 });
-var NoneAuthDataSchema = z8.object({
-  kind: z8.literal("none")
+var NoneAuthDataSchema = z13.object({
+  kind: z13.literal("none")
 });
-var ProviderAuthDataSchema = z8.discriminatedUnion("kind", [
+var ProviderAuthDataSchema = z13.discriminatedUnion("kind", [
   GomotiveAuthDataSchema,
   VistaAuthDataSchema,
   MockAuthDataSchema,
   NoneAuthDataSchema
 ]);
-var LegacyVistaAuthSchema = z8.object({
-  driverId: z8.string(),
-  cookie: z8.string()
+var LegacyVistaAuthSchema = z13.object({
+  driverId: z13.string(),
+  cookie: z13.string()
 });
 function serializeAuthData(data) {
   if (data.kind === "none") {
@@ -268,52 +408,57 @@ function deserializeAuthData(authToken) {
 }
 
 // src/browser-auth.ts
-import { z as z9 } from "zod";
-var CapturedTrafficEntrySchema = z9.object({
-  method: z9.string(),
-  url: z9.string(),
-  status: z9.number(),
-  responseBody: z9.string().optional()
+import { z as z14 } from "zod";
+var CapturedTrafficEntrySchema = z14.object({
+  method: z14.string(),
+  url: z14.string(),
+  status: z14.number(),
+  responseBody: z14.string().optional()
 });
-var BrowserAuthRequestSchema = z9.object({
-  providerStub: z9.string(),
-  providerUrl: z9.string(),
-  username: z9.string(),
-  encryptedPassword: z9.string(),
-  captureTraffic: z9.boolean().optional()
+var BrowserAuthRequestSchema = z14.object({
+  providerStub: z14.string(),
+  providerUrl: z14.string(),
+  username: z14.string(),
+  encryptedPassword: z14.string(),
+  captureTraffic: z14.boolean().optional()
 });
-var BrowserAuthSuccessSchema = z9.object({
-  success: z9.literal(true),
+var BrowserAuthSuccessSchema = z14.object({
+  success: z14.literal(true),
   authData: ProviderAuthDataSchema,
-  capturedTraffic: z9.array(CapturedTrafficEntrySchema).optional()
+  capturedTraffic: z14.array(CapturedTrafficEntrySchema).optional()
 });
-var BrowserAuthFailureSchema = z9.object({
-  success: z9.literal(false),
-  error: z9.string()
+var BrowserAuthFailureSchema = z14.object({
+  success: z14.literal(false),
+  error: z14.string()
 });
-var BrowserAuthResponseSchema = z9.discriminatedUnion("success", [
+var BrowserAuthResponseSchema = z14.discriminatedUnion("success", [
   BrowserAuthSuccessSchema,
   BrowserAuthFailureSchema
 ]);
-var CrawlPageSchema = z9.object({
-  url: z9.string(),
-  html: z9.string()
+var CrawlPageSchema = z14.object({
+  url: z14.string(),
+  html: z14.string()
 });
-var BrowserCrawlSuccessSchema = z9.object({
-  success: z9.literal(true),
-  pages: z9.array(CrawlPageSchema)
+var BrowserCrawlSuccessSchema = z14.object({
+  success: z14.literal(true),
+  pages: z14.array(CrawlPageSchema)
 });
-var BrowserCrawlFailureSchema = z9.object({
-  success: z9.literal(false),
-  error: z9.string()
+var BrowserCrawlFailureSchema = z14.object({
+  success: z14.literal(false),
+  error: z14.string()
 });
-var BrowserCrawlResponseSchema = z9.discriminatedUnion("success", [
+var BrowserCrawlResponseSchema = z14.discriminatedUnion("success", [
   BrowserCrawlSuccessSchema,
   BrowserCrawlFailureSchema
 ]);
 export {
   AnonymousDriverErrorResponseSchema,
   AnonymousDriverResponseSchema,
+  BGGeoActivitySchema,
+  BGGeoBatchRequestSchema,
+  BGGeoBatterySchema,
+  BGGeoCoordsSchema,
+  BGGeoLocationSchema,
   BatchConvexUpdate,
   BatchConvexUpdateSchema,
   BrowserAuthFailureSchema,
@@ -324,7 +469,9 @@ export {
   BrowserCrawlResponseSchema,
   BrowserCrawlSuccessSchema,
   CapturedTrafficEntrySchema,
+  ConvexBreadcrumbEventSchema,
   ConvexDriverSchema,
+  ConvexDriverTripRequestSchema,
   ConvexUpdate,
   ConvexUpdateSchema,
   CrawlPageSchema,
@@ -351,8 +498,9 @@ export {
   EnrichedTripSummaryResponseSchema,
   EnrichedTripSummarySchema,
   GomotiveAuthDataSchema,
+  ListDriversRequestSchema,
+  ListDriversResponseSchema,
   ManualBatchEntrySchema,
-  ManualBatchRequestSchema,
   ManualBatchResponseSchema,
   ManualBatchTelemetrySchema,
   MockAuthDataSchema,
@@ -370,6 +518,10 @@ export {
   PatchDriverDriverResponseSchema,
   PatchDriverRequestSchema,
   PatchDriverResponseSchema,
+  PostDailySummaryRecordSchema,
+  PostDailySummaryRequestSchema,
+  PostDriverTripTelemetryRecordSchema,
+  PostDriverTripTelemetryRequestSchema,
   ProviderAuthDataSchema,
   ScrapeStatus,
   SharedDriverResponseSchema,
@@ -378,6 +530,8 @@ export {
   StateHeatmapResponseSchema,
   TruckTypeSchema,
   UpdateScrapeStatusMessage,
+  ValidateLoginRequestSchema,
+  ValidateLoginResponseSchema,
   ValidatePasswordRequestSchema,
   ValidatePasswordResponseSchema,
   VistaAuthDataSchema,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@findatruck/shared-schemas",
-  "version": "2.20.0",
+  "version": "2.23.1",
   "type": "module",
   "main": "./dist/index.cjs",
   "module": "./dist/index.js",