@findatruck/shared-schemas 2.20.0 → 2.23.1

package/dist/index.cjs

@@ -32,6 +32,11 @@ var index_exports = {};
 __export(index_exports, {
   AnonymousDriverErrorResponseSchema: () => AnonymousDriverErrorResponseSchema,
   AnonymousDriverResponseSchema: () => AnonymousDriverResponseSchema,
+  BGGeoActivitySchema: () => BGGeoActivitySchema,
+  BGGeoBatchRequestSchema: () => BGGeoBatchRequestSchema,
+  BGGeoBatterySchema: () => BGGeoBatterySchema,
+  BGGeoCoordsSchema: () => BGGeoCoordsSchema,
+  BGGeoLocationSchema: () => BGGeoLocationSchema,
   BatchConvexUpdate: () => BatchConvexUpdate,
   BatchConvexUpdateSchema: () => BatchConvexUpdateSchema,
   BrowserAuthFailureSchema: () => BrowserAuthFailureSchema,
@@ -42,7 +47,9 @@ __export(index_exports, {
   BrowserCrawlResponseSchema: () => BrowserCrawlResponseSchema,
   BrowserCrawlSuccessSchema: () => BrowserCrawlSuccessSchema,
   CapturedTrafficEntrySchema: () => CapturedTrafficEntrySchema,
+  ConvexBreadcrumbEventSchema: () => ConvexBreadcrumbEventSchema,
   ConvexDriverSchema: () => ConvexDriverSchema,
+  ConvexDriverTripRequestSchema: () => ConvexDriverTripRequestSchema,
   ConvexUpdate: () => ConvexUpdate,
   ConvexUpdateSchema: () => ConvexUpdateSchema,
   CrawlPageSchema: () => CrawlPageSchema,
@@ -69,8 +76,9 @@ __export(index_exports, {
   EnrichedTripSummaryResponseSchema: () => EnrichedTripSummaryResponseSchema,
   EnrichedTripSummarySchema: () => EnrichedTripSummarySchema,
   GomotiveAuthDataSchema: () => GomotiveAuthDataSchema,
+  ListDriversRequestSchema: () => ListDriversRequestSchema,
+  ListDriversResponseSchema: () => ListDriversResponseSchema,
   ManualBatchEntrySchema: () => ManualBatchEntrySchema,
-  ManualBatchRequestSchema: () => ManualBatchRequestSchema,
   ManualBatchResponseSchema: () => ManualBatchResponseSchema,
   ManualBatchTelemetrySchema: () => ManualBatchTelemetrySchema,
   MockAuthDataSchema: () => MockAuthDataSchema,
@@ -88,6 +96,10 @@ __export(index_exports, {
   PatchDriverDriverResponseSchema: () => PatchDriverDriverResponseSchema,
   PatchDriverRequestSchema: () => PatchDriverRequestSchema,
   PatchDriverResponseSchema: () => PatchDriverResponseSchema,
+  PostDailySummaryRecordSchema: () => PostDailySummaryRecordSchema,
+  PostDailySummaryRequestSchema: () => PostDailySummaryRequestSchema,
+  PostDriverTripTelemetryRecordSchema: () => PostDriverTripTelemetryRecordSchema,
+  PostDriverTripTelemetryRequestSchema: () => PostDriverTripTelemetryRequestSchema,
   ProviderAuthDataSchema: () => ProviderAuthDataSchema,
   ScrapeStatus: () => ScrapeStatus,
   SharedDriverResponseSchema: () => SharedDriverResponseSchema,
@@ -96,6 +108,8 @@ __export(index_exports, {
   StateHeatmapResponseSchema: () => StateHeatmapResponseSchema,
   TruckTypeSchema: () => TruckTypeSchema,
   UpdateScrapeStatusMessage: () => UpdateScrapeStatusMessage,
+  ValidateLoginRequestSchema: () => ValidateLoginRequestSchema,
+  ValidateLoginResponseSchema: () => ValidateLoginResponseSchema,
   ValidatePasswordRequestSchema: () => ValidatePasswordRequestSchema,
   ValidatePasswordResponseSchema: () => ValidatePasswordResponseSchema,
   VistaAuthDataSchema: () => VistaAuthDataSchema,
@@ -230,7 +244,7 @@ var SharedDriverResponseSchema = import_zod4.default.object({
   // because providers emit non-UUID identifiers there.
   id: import_zod4.default.uuid(),
   name: import_zod4.default.string(),
-  eld_external_id: import_zod4.default.string(),
+  eld_external_id: import_zod4.default.string().nullable(),
   license_number: import_zod4.default.string().nullable(),
   license_state: import_zod4.default.string().nullable(),
   license_expiration_date: import_zod4.default.string().nullable(),
@@ -239,6 +253,7 @@ var SharedDriverResponseSchema = import_zod4.default.object({
   created_at: import_zod4.default.union([import_zod4.default.string(), import_zod4.default.date()]),
   updated_at: import_zod4.default.union([import_zod4.default.string(), import_zod4.default.date()]),
   truck_type: import_zod4.default.string().nullable(),
+  honk_user_id: import_zod4.default.string().nullable(),
   last_location_latitude: import_zod4.default.number().nullable(),
   last_location_longitude: import_zod4.default.number().nullable()
 });
@@ -279,10 +294,14 @@ var DriverNameSchema = import_zod5.default.string().trim().min(1).max(PATCH_DRIV
 );
 var TruckTypeSchema = import_zod5.default.string().trim().min(1).max(PATCH_DRIVER_TRUCK_TYPE_MAX_LENGTH);
 var PatchDriverRequestSchema = import_zod5.default.object({
-  driver_id: import_zod5.default.uuid(),
+  driver_id: import_zod5.default.uuid().optional(),
+  honk_user_id: import_zod5.default.string().min(1).max(255).optional(),
   name: DriverNameSchema.optional(),
   truck_type: TruckTypeSchema.nullable().optional()
 }).refine(
+  (d) => d.driver_id !== void 0 !== (d.honk_user_id !== void 0),
+  { message: "Exactly one of driver_id or honk_user_id must be provided" }
+).refine(
   (d) => d.name !== void 0 || d.truck_type !== void 0,
   { message: "At least one of name or truck_type must be provided" }
 );
@@ -300,8 +319,17 @@ var PatchDriverResponseSchema = import_zod5.default.object({
   driver: PatchDriverDriverResponseSchema
 });
 
-// src/schemas/providerAccounts/update-status.ts
+// src/schemas/drivers/list-drivers.ts
 var import_zod6 = __toESM(require("zod"), 1);
+var ListDriversRequestSchema = import_zod6.default.object({
+  name: import_zod6.default.string().optional()
+});
+var ListDriversResponseSchema = import_zod6.default.object({
+  drivers: import_zod6.default.array(SharedDriverResponseSchema)
+});
+
+// src/schemas/providerAccounts/update-status.ts
+var import_zod7 = __toESM(require("zod"), 1);
 var ScrapeStatus = /* @__PURE__ */ ((ScrapeStatus2) => {
   ScrapeStatus2["NEW_LOGIN_RECEIVED"] = "NEW_LOGIN_RECEIVED";
   ScrapeStatus2["LOGIN_IN_PROGRESS"] = "LOGIN_IN_PROGRESS";
@@ -314,213 +342,351 @@ var ScrapeStatus = /* @__PURE__ */ ((ScrapeStatus2) => {
   ScrapeStatus2["DATA_FETCH_FAILED"] = "DATA_FETCH_FAILED";
   return ScrapeStatus2;
 })(ScrapeStatus || {});
-var UpdateScrapeStatusMessage = import_zod6.default.object({
-  status: import_zod6.default.nativeEnum(ScrapeStatus).describe("The current status of the scrape process"),
-  correctPassword: import_zod6.default.boolean().optional().describe("Indicates if the provided password was correct, if applicable"),
-  externalProviderAccountId: import_zod6.default.string().describe("The external identifier for the provider account (convex ID or similar)"),
-  username: import_zod6.default.string().describe("The username of the provider account whose status is being updated"),
-  provider_url: import_zod6.default.string().describe("The URL of the ELD provider"),
-  driverCount: import_zod6.default.number().optional().describe("The number of drivers associated with the account, if applicable"),
-  providerSlug: import_zod6.default.string().optional().describe("The slug identifier for the provider")
+var UpdateScrapeStatusMessage = import_zod7.default.object({
+  status: import_zod7.default.nativeEnum(ScrapeStatus).describe("The current status of the scrape process"),
+  correctPassword: import_zod7.default.boolean().optional().describe("Indicates if the provided password was correct, if applicable"),
+  externalProviderAccountId: import_zod7.default.string().describe("The external identifier for the provider account (convex ID or similar)"),
+  username: import_zod7.default.string().describe("The username of the provider account whose status is being updated"),
+  provider_url: import_zod7.default.string().describe("The URL of the ELD provider"),
+  driverCount: import_zod7.default.number().optional().describe("The number of drivers associated with the account, if applicable"),
+  providerSlug: import_zod7.default.string().optional().describe("The slug identifier for the provider")
 }).describe("Schema for update status messages");
 
 // src/schemas/providerAccounts/validate-password.ts
-var import_zod7 = require("zod");
-var ValidatePasswordRequestSchema = import_zod7.z.object({
-  providerAccountId: import_zod7.z.string().min(1).describe("The unique identifier of the provider account in postgres to validate the password for"),
-  encryptedPassword: import_zod7.z.string().min(1).describe("The encrypted password to validate against the stored password")
+var import_zod8 = require("zod");
+var ValidatePasswordRequestSchema = import_zod8.z.object({
+  providerAccountId: import_zod8.z.string().min(1).describe("The unique identifier of the provider account in postgres to validate the password for"),
+  encryptedPassword: import_zod8.z.string().min(1).describe("The encrypted password to validate against the stored password")
 }).describe("Request schema for validating a provider account password");
-var ValidatePasswordResponseSchema = import_zod7.z.object({
-  isValid: import_zod7.z.boolean().describe("Indicates if the provided password is valid"),
-  driverIds: import_zod7.z.array(import_zod7.z.string()).describe("List of driver IDs associated with the provider account")
+var ValidatePasswordResponseSchema = import_zod8.z.object({
+  isValid: import_zod8.z.boolean().describe("Indicates if the provided password is valid"),
+  driverIds: import_zod8.z.array(import_zod8.z.string()).describe("List of driver IDs associated with the provider account")
 }).describe("Response schema for password validation");
 
+// src/schemas/providerAccounts/validate-login.ts
+var import_zod9 = require("zod");
+var UrlSchema3 = import_zod9.z.string().refine(
+  (val) => {
+    try {
+      new URL(val);
+      return true;
+    } catch {
+      return false;
+    }
+  },
+  { message: "Invalid URL" }
+);
+var ValidateLoginRequestSchema = import_zod9.z.object({
+  providerUrl: UrlSchema3.describe("The URL of the ELD provider to validate credentials against"),
+  username: import_zod9.z.string().min(1).describe("The username to validate"),
+  encryptedPassword: import_zod9.z.string().min(1).describe("The encrypted password to validate")
+}).describe("Request schema for validating login credentials via browser auth");
+var ValidateLoginResponseSchema = import_zod9.z.object({
+  success: import_zod9.z.boolean().describe("Indicates if the login credentials are valid")
+}).describe("Response schema for login validation");
+
 // src/schemas/providerAccounts/delete-provider-account.ts
-var import_zod8 = require("zod");
-var DeleteProviderAccountRequestSchema = import_zod8.z.object({
-  providerAccountId: import_zod8.z.string().min(1).describe("The external provider account ID to delete")
+var import_zod10 = require("zod");
+var DeleteProviderAccountRequestSchema = import_zod10.z.object({
+  providerAccountId: import_zod10.z.string().min(1).describe("The external provider account ID to delete")
 }).describe("Request schema for deleting a provider account");
-var DeleteProviderAccountResponseSchema = import_zod8.z.object({
-  success: import_zod8.z.boolean().describe("Indicates if the provider account was successfully deleted")
+var DeleteProviderAccountResponseSchema = import_zod10.z.object({
+  success: import_zod10.z.boolean().describe("Indicates if the provider account was successfully deleted")
 }).describe("Response schema for provider account deletion");
 
 // src/schemas/telemetry/driver-rankings.ts
-var import_zod9 = require("zod");
-var DriverRankingsRequestSchema = import_zod9.z.object({
-  start_date: import_zod9.z.string().describe("Start date for the ranking period (ISO 8601 format)"),
-  end_date: import_zod9.z.string().describe("End date for the ranking period (ISO 8601 format)"),
-  state: import_zod9.z.string().length(2).optional().describe("Optional 2-letter state abbreviation to filter telemetry by location"),
-  source: import_zod9.z.enum(["eld", "manual"]).default("manual").describe("Telemetry source to rank by: 'manual' uses GPS odometer, 'eld' uses calculated distance")
+var import_zod11 = require("zod");
+var DriverRankingsRequestSchema = import_zod11.z.object({
+  start_date: import_zod11.z.string().describe("Start date for the ranking period (ISO 8601 format)"),
+  end_date: import_zod11.z.string().describe("End date for the ranking period (ISO 8601 format)"),
+  state: import_zod11.z.string().length(2).optional().describe("Optional 2-letter state abbreviation to filter telemetry by location"),
+  source: import_zod11.z.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 = import_zod9.z.object({
-  rank: import_zod9.z.number().int().positive().describe("Rank position based on miles driven"),
-  driver_id: import_zod9.z.string().uuid().describe("Unique identifier of the driver"),
-  driver_name: import_zod9.z.string().describe("Name of the driver"),
-  total_miles: import_zod9.z.number().min(0).describe("Total miles driven in the specified period")
+var DriverRankingSchema = import_zod11.z.object({
+  rank: import_zod11.z.number().int().positive().describe("Rank position based on miles driven"),
+  driver_id: import_zod11.z.string().uuid().describe("Unique identifier of the driver"),
+  driver_name: import_zod11.z.string().describe("Name of the driver"),
+  total_miles: import_zod11.z.number().min(0).describe("Total miles driven in the specified period")
 }).describe("Single driver ranking entry");
-var DriverRankingsResponseSchema = import_zod9.z.array(DriverRankingSchema).describe("Array of driver rankings sorted by miles driven in descending order");
+var DriverRankingsResponseSchema = import_zod11.z.array(DriverRankingSchema).describe("Array of driver rankings sorted by miles driven in descending order");
 
 // src/schemas/telemetry/state-heatmap.ts
-var import_zod10 = require("zod");
-var StateHeatmapRequestSchema = import_zod10.z.object({
-  driver_id: import_zod10.z.string().uuid().describe("Unique identifier of the driver"),
-  start_date: import_zod10.z.string().describe("Start date for the heatmap period (ISO 8601 format)"),
-  end_date: import_zod10.z.string().describe("End date for the heatmap period (ISO 8601 format)")
+var import_zod12 = require("zod");
+var StateHeatmapRequestSchema = import_zod12.z.object({
+  driver_id: import_zod12.z.string().uuid().describe("Unique identifier of the driver"),
+  start_date: import_zod12.z.string().describe("Start date for the heatmap period (ISO 8601 format)"),
+  end_date: import_zod12.z.string().describe("End date for the heatmap period (ISO 8601 format)")
 }).describe("Request schema for driver state heatmap");
-var StateHeatmapEntrySchema = import_zod10.z.object({
-  count: import_zod10.z.number().int().min(0).describe("Number of telemetry points in this state"),
-  percentage: import_zod10.z.number().min(0).max(100).describe("Percentage of total telemetry points in this state")
+var StateHeatmapEntrySchema = import_zod12.z.object({
+  count: import_zod12.z.number().int().min(0).describe("Number of telemetry points in this state"),
+  percentage: import_zod12.z.number().min(0).max(100).describe("Percentage of total telemetry points in this state")
 }).describe("Single state entry in the heatmap");
-var StateHeatmapResponseSchema = import_zod10.z.record(
-  import_zod10.z.string().length(2),
+var StateHeatmapResponseSchema = import_zod12.z.record(
+  import_zod12.z.string().length(2),
   StateHeatmapEntrySchema
 ).describe("Record of 2-letter state codes to heatmap entries");
 
 // src/schemas/telemetry/manual-batch.ts
-var import_zod11 = require("zod");
-var ManualBatchEntrySchema = import_zod11.z.object({
-  driver_id: import_zod11.z.string().uuid().describe("Internal UUID of the driver"),
-  timestamp: import_zod11.z.string().datetime().describe("Timestamp of the GPS reading (ISO 8601 format)"),
-  location_latitude: import_zod11.z.number().min(-90).max(90).describe("GPS latitude coordinate"),
-  location_longitude: import_zod11.z.number().min(-180).max(180).describe("GPS longitude coordinate"),
-  location_address: import_zod11.z.string().optional().describe("Optional human-readable address"),
-  vehicle_odometer_miles: import_zod11.z.number().min(0).optional().describe("Optional vehicle odometer reading in miles"),
-  heading: import_zod11.z.number().min(0).max(360).optional().describe("Optional GPS heading in degrees (0-360)"),
-  speed_mph: import_zod11.z.number().min(0).optional().describe("Optional GPS speed in miles per hour"),
-  altitude_feet: import_zod11.z.number().optional().describe("Optional GPS altitude in feet"),
-  raw: import_zod11.z.record(import_zod11.z.string(), import_zod11.z.unknown()).optional().describe("Optional raw upstream JSON payload to archive alongside this entry"),
-  driving_status: import_zod11.z.enum(["parked", "driving"]).optional().describe("Optional parked/driving status reported by the upstream system")
+var import_zod13 = require("zod");
+var ManualBatchEntrySchema = import_zod13.z.object({
+  driver_id: import_zod13.z.string().uuid().describe("Internal UUID of the driver"),
+  timestamp: import_zod13.z.string().datetime().describe("Timestamp of the GPS reading (ISO 8601 format)"),
+  location_latitude: import_zod13.z.number().min(-90).max(90).describe("GPS latitude coordinate"),
+  location_longitude: import_zod13.z.number().min(-180).max(180).describe("GPS longitude coordinate"),
+  location_address: import_zod13.z.string().optional().describe("Optional human-readable address"),
+  vehicle_odometer_miles: import_zod13.z.number().min(0).optional().describe("Optional vehicle odometer reading in miles"),
+  heading: import_zod13.z.number().min(0).max(360).optional().describe("Optional GPS heading in degrees (0-360)"),
+  speed_mph: import_zod13.z.number().min(0).optional().describe("Optional GPS speed in miles per hour"),
+  altitude_feet: import_zod13.z.number().optional().describe("Optional GPS altitude in feet"),
+  raw: import_zod13.z.record(import_zod13.z.string(), import_zod13.z.unknown()).optional().describe("Optional raw upstream JSON payload to archive alongside this entry"),
+  driving_status: import_zod13.z.enum(["parked", "driving"]).optional().describe("Optional parked/driving status reported by the upstream system"),
+  activity_type: import_zod13.z.string().optional().describe("Optional activity recognition type (e.g. 'in_vehicle', 'on_foot')"),
+  activity_confidence: import_zod13.z.number().int().min(0).max(100).optional().describe("Optional activity recognition confidence (0-100)")
 }).describe("Single manual telemetry entry");
-var ManualBatchRequestSchema = import_zod11.z.object({
-  entries: import_zod11.z.array(ManualBatchEntrySchema).min(1).max(1e3).describe("Array of manual telemetry entries (1-1000)")
-}).describe("Request schema for manual batch telemetry insertion");
-var ManualBatchTelemetrySchema = import_zod11.z.object({
-  id: import_zod11.z.number().int().describe("Telemetry record ID"),
-  driver_id: import_zod11.z.string().uuid().describe("Internal UUID of the driver"),
-  timestamp: import_zod11.z.union([import_zod11.z.string(), import_zod11.z.date()]).describe("Timestamp of the telemetry reading"),
-  remaining_drive_time_in_seconds: import_zod11.z.number().min(0),
-  remaining_shift_time_in_seconds: import_zod11.z.number().min(0),
-  remaining_cycle_time_in_seconds: import_zod11.z.number().min(0),
-  remaining_break_time_in_seconds: import_zod11.z.number().min(0),
-  location_latitude: import_zod11.z.number().min(-90).max(90),
-  location_longitude: import_zod11.z.number().min(-180).max(180),
-  previous_location_latitude: import_zod11.z.number().min(-90).max(90).nullable(),
-  previous_location_longitude: import_zod11.z.number().min(-180).max(180).nullable(),
-  location_address: import_zod11.z.string().nullable(),
-  location_state: import_zod11.z.string().length(2).nullable(),
-  echoed_odometer_miles: import_zod11.z.number().min(0).nullable().describe("Vehicle odometer reading echoed back from the request (miles)"),
-  osrm_calculated_miles: import_zod11.z.number().min(0).nullable().describe("Road distance calculated by OSRM between this point and the previous point (miles)"),
-  heading: import_zod11.z.number().nullish(),
-  speed_mph: import_zod11.z.number().nullish(),
-  altitude_feet: import_zod11.z.number().nullish(),
-  source: import_zod11.z.enum(["eld", "manual"]),
-  driving_status: import_zod11.z.enum(["parked", "driving"]).nullable()
+var ManualBatchTelemetrySchema = import_zod13.z.object({
+  id: import_zod13.z.number().int().describe("Telemetry record ID"),
+  driver_id: import_zod13.z.string().uuid().describe("Internal UUID of the driver"),
+  timestamp: import_zod13.z.union([import_zod13.z.string(), import_zod13.z.date()]).describe("Timestamp of the telemetry reading"),
+  remaining_drive_time_in_seconds: import_zod13.z.number().min(0),
+  remaining_shift_time_in_seconds: import_zod13.z.number().min(0),
+  remaining_cycle_time_in_seconds: import_zod13.z.number().min(0),
+  remaining_break_time_in_seconds: import_zod13.z.number().min(0),
+  location_latitude: import_zod13.z.number().min(-90).max(90),
+  location_longitude: import_zod13.z.number().min(-180).max(180),
+  previous_location_latitude: import_zod13.z.number().min(-90).max(90).nullable(),
+  previous_location_longitude: import_zod13.z.number().min(-180).max(180).nullable(),
+  location_address: import_zod13.z.string().nullable(),
+  location_state: import_zod13.z.string().length(2).nullable(),
+  echoed_odometer_miles: import_zod13.z.number().min(0).nullable().describe("Vehicle odometer reading echoed back from the request (miles)"),
+  osrm_calculated_miles: import_zod13.z.number().min(0).nullable().describe("Road distance calculated by OSRM between this point and the previous point (miles)"),
+  heading: import_zod13.z.number().nullish(),
+  speed_mph: import_zod13.z.number().nullish(),
+  altitude_feet: import_zod13.z.number().nullish(),
+  source: import_zod13.z.enum(["eld", "manual"]),
+  driving_status: import_zod13.z.enum(["parked", "driving"]).nullable(),
+  activity_type: import_zod13.z.string().nullable(),
+  activity_confidence: import_zod13.z.number().int().nullable()
 }).describe("Telemetry record returned from manual batch insertion");
-var ManualBatchResponseSchema = import_zod11.z.object({
-  message: import_zod11.z.string().describe("Success message"),
-  inserted_count: import_zod11.z.number().int().min(0).describe("Number of telemetry entries inserted"),
-  telemetry: import_zod11.z.array(ManualBatchTelemetrySchema).describe("Array of inserted telemetry records")
+var ManualBatchResponseSchema = import_zod13.z.object({
+  message: import_zod13.z.string().describe("Success message"),
+  inserted_count: import_zod13.z.number().int().min(0).describe("Number of telemetry entries inserted"),
+  telemetry: import_zod13.z.array(ManualBatchTelemetrySchema).describe("Array of inserted telemetry records")
 }).describe("Response schema for manual batch telemetry insertion");
 
+// src/schemas/telemetry/bggeo-batch.ts
+var import_zod14 = require("zod");
+var BGGeoCoordsSchema = import_zod14.z.object({
+  latitude: import_zod14.z.number().min(-90).max(90),
+  longitude: import_zod14.z.number().min(-180).max(180),
+  accuracy: import_zod14.z.number().optional(),
+  speed: import_zod14.z.number().describe("Speed in m/s; -1 when unavailable"),
+  heading: import_zod14.z.number().describe("Heading in degrees; -1 when unavailable"),
+  altitude: import_zod14.z.number().describe("Altitude in meters"),
+  altitude_accuracy: import_zod14.z.number().optional(),
+  speed_accuracy: import_zod14.z.number().optional(),
+  heading_accuracy: import_zod14.z.number().optional(),
+  ellipsoidal_altitude: import_zod14.z.number().optional(),
+  floor: import_zod14.z.number().nullable().optional()
+}).describe("BGGeo coords object");
+var BGGeoActivitySchema = import_zod14.z.object({
+  type: import_zod14.z.string(),
+  confidence: import_zod14.z.number()
+}).describe("BGGeo activity recognition");
+var BGGeoBatterySchema = import_zod14.z.object({
+  is_charging: import_zod14.z.boolean(),
+  level: import_zod14.z.number()
+}).describe("BGGeo battery status");
+var BGGeoLocationSchema = import_zod14.z.object({
+  coords: BGGeoCoordsSchema,
+  extras: import_zod14.z.object({}).passthrough().optional(),
+  activity: BGGeoActivitySchema.optional(),
+  battery: BGGeoBatterySchema.optional(),
+  timestamp: import_zod14.z.string().datetime().describe("ISO 8601 timestamp"),
+  is_moving: import_zod14.z.boolean(),
+  odometer: import_zod14.z.number().min(0).describe("Odometer in meters"),
+  uuid: import_zod14.z.string().optional(),
+  event: import_zod14.z.string().optional(),
+  age: import_zod14.z.number().optional(),
+  geofence: import_zod14.z.record(import_zod14.z.string(), import_zod14.z.unknown()).optional(),
+  mock: import_zod14.z.boolean().optional(),
+  recorded_at: import_zod14.z.string().datetime().optional().describe("ISO 8601 device recording timestamp")
+}).passthrough().describe("Single BGGeo location object");
+var locationArray = import_zod14.z.array(BGGeoLocationSchema).min(1).max(1e3).describe("Array of BGGeo location objects (1-1000)");
+var locationOrArray = import_zod14.z.union([
+  BGGeoLocationSchema.transform((loc) => [loc]),
+  locationArray
+]);
+var BGGeoBatchRequestSchema = import_zod14.z.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
-var import_zod12 = require("zod");
-var DriverTripsRequestSchema = import_zod12.z.object({
-  driver_id: import_zod12.z.string().uuid(),
-  start_date: import_zod12.z.string(),
+var import_zod15 = require("zod");
+var DriverTripsRequestSchema = import_zod15.z.object({
+  driver_id: import_zod15.z.string().uuid(),
+  start_date: import_zod15.z.string(),
   // YYYY-MM-DD
-  end_date: import_zod12.z.string()
+  end_date: import_zod15.z.string()
   // YYYY-MM-DD
 });
-var DriverTripSchema = import_zod12.z.object({
-  id: import_zod12.z.number(),
-  start_time: import_zod12.z.string(),
-  end_time: import_zod12.z.string(),
-  point_count: import_zod12.z.number(),
-  polyline: import_zod12.z.string().nullable(),
-  highways: import_zod12.z.array(import_zod12.z.string()).nullable(),
-  total_miles: import_zod12.z.number().nullable(),
-  avg_speed_mph: import_zod12.z.number().nullable(),
-  miles_by_weather: import_zod12.z.record(import_zod12.z.string(), import_zod12.z.number()).nullable(),
-  miles_by_light: import_zod12.z.record(import_zod12.z.string(), import_zod12.z.number()).nullable()
-});
-var DriverTripsResponseSchema = import_zod12.z.array(DriverTripSchema);
-var DriverDailySummarySchema = import_zod12.z.object({
-  summary_date: import_zod12.z.string(),
-  total_miles: import_zod12.z.number(),
-  trip_count: import_zod12.z.number(),
-  point_count: import_zod12.z.number(),
-  polyline: import_zod12.z.string().nullable(),
-  highways: import_zod12.z.array(import_zod12.z.string()).nullable(),
-  avg_speed_mph: import_zod12.z.number().nullable(),
-  miles_by_weather: import_zod12.z.record(import_zod12.z.string(), import_zod12.z.number()).nullable(),
-  miles_by_light: import_zod12.z.record(import_zod12.z.string(), import_zod12.z.number()).nullable()
-});
-var DriverDailySummariesResponseSchema = import_zod12.z.array(DriverDailySummarySchema);
+var DriverTripSchema = import_zod15.z.object({
+  id: import_zod15.z.number(),
+  start_time: import_zod15.z.string(),
+  end_time: import_zod15.z.string(),
+  point_count: import_zod15.z.number(),
+  polyline: import_zod15.z.string().nullable(),
+  highways: import_zod15.z.array(import_zod15.z.string()).nullable(),
+  total_miles: import_zod15.z.number().nullable(),
+  avg_speed_mph: import_zod15.z.number().nullable(),
+  miles_by_weather: import_zod15.z.record(import_zod15.z.string(), import_zod15.z.number()).nullable(),
+  miles_by_light: import_zod15.z.record(import_zod15.z.string(), import_zod15.z.number()).nullable()
+});
+var DriverTripsResponseSchema = import_zod15.z.array(DriverTripSchema);
+var DriverDailySummarySchema = import_zod15.z.object({
+  summary_date: import_zod15.z.string(),
+  total_miles: import_zod15.z.number(),
+  trip_count: import_zod15.z.number(),
+  point_count: import_zod15.z.number(),
+  polyline: import_zod15.z.string().nullable(),
+  highways: import_zod15.z.array(import_zod15.z.string()).nullable(),
+  avg_speed_mph: import_zod15.z.number().nullable(),
+  miles_by_weather: import_zod15.z.record(import_zod15.z.string(), import_zod15.z.number()).nullable(),
+  miles_by_light: import_zod15.z.record(import_zod15.z.string(), import_zod15.z.number()).nullable()
+});
+var DriverDailySummariesResponseSchema = import_zod15.z.array(DriverDailySummarySchema);
 
 // src/schemas/trips/enriched-trip-summary.ts
-var import_zod13 = require("zod");
-var EnrichedTripSummaryRequestSchema = import_zod13.z.object({
-  trip_id: import_zod13.z.number()
-});
-var DriverEnrichedSummariesRequestSchema = import_zod13.z.object({
-  driver_id: import_zod13.z.string().uuid(),
-  start_date: import_zod13.z.string(),
-  end_date: import_zod13.z.string()
-});
-var EnrichedStopSchema = import_zod13.z.object({
-  duration_seconds: import_zod13.z.number()
-});
-var EnrichedPointSchema = import_zod13.z.object({
-  lat: import_zod13.z.number(),
-  lon: import_zod13.z.number(),
-  timestamp: import_zod13.z.string(),
-  speed_mph: import_zod13.z.number().nullable(),
-  heading: import_zod13.z.number().nullable(),
-  altitude_feet: import_zod13.z.number().nullable(),
-  weather_condition: import_zod13.z.string().nullable(),
-  temperature_f: import_zod13.z.number().nullable(),
-  visibility_miles: import_zod13.z.number().nullable(),
-  light_condition: import_zod13.z.string().nullable(),
+var import_zod16 = require("zod");
+var EnrichedTripSummaryRequestSchema = import_zod16.z.object({
+  trip_id: import_zod16.z.number()
+});
+var DriverEnrichedSummariesRequestSchema = import_zod16.z.object({
+  driver_id: import_zod16.z.string().uuid(),
+  start_date: import_zod16.z.string(),
+  end_date: import_zod16.z.string()
+});
+var EnrichedStopSchema = import_zod16.z.object({
+  duration_seconds: import_zod16.z.number()
+});
+var EnrichedPointSchema = import_zod16.z.object({
+  lat: import_zod16.z.number(),
+  lon: import_zod16.z.number(),
+  timestamp: import_zod16.z.string(),
+  speed_mph: import_zod16.z.number().nullable(),
+  heading: import_zod16.z.number().nullable(),
+  altitude_feet: import_zod16.z.number().nullable(),
+  weather_condition: import_zod16.z.string().nullable(),
+  temperature_f: import_zod16.z.number().nullable(),
+  visibility_miles: import_zod16.z.number().nullable(),
+  light_condition: import_zod16.z.string().nullable(),
   stop: EnrichedStopSchema.nullable()
 });
-var EnrichedTripSummarySchema = import_zod13.z.object({
-  trip_id: import_zod13.z.number(),
-  driver_id: import_zod13.z.string(),
-  start_time: import_zod13.z.string(),
-  end_time: import_zod13.z.string(),
-  points: import_zod13.z.array(EnrichedPointSchema)
+var EnrichedTripSummarySchema = import_zod16.z.object({
+  trip_id: import_zod16.z.number(),
+  driver_id: import_zod16.z.string(),
+  start_time: import_zod16.z.string(),
+  end_time: import_zod16.z.string(),
+  points: import_zod16.z.array(EnrichedPointSchema)
 });
 var EnrichedTripSummaryResponseSchema = EnrichedTripSummarySchema;
-var DriverEnrichedSummariesResponseSchema = import_zod13.z.array(EnrichedTripSummarySchema);
+var DriverEnrichedSummariesResponseSchema = import_zod16.z.array(EnrichedTripSummarySchema);
+
+// src/schemas/trips/convex-driver-trip.ts
+var import_zod17 = require("zod");
+var ConvexBreadcrumbEventSchema = import_zod17.z.object({
+  ts: import_zod17.z.number(),
+  // epoch ms
+  status: import_zod17.z.string(),
+  lat: import_zod17.z.number(),
+  lon: import_zod17.z.number(),
+  heading: import_zod17.z.number().optional(),
+  locationText: import_zod17.z.string().optional(),
+  speedKph: import_zod17.z.number().optional(),
+  altitudeFeet: import_zod17.z.number().optional()
+});
+var ConvexDriverTripRequestSchema = import_zod17.z.object({
+  userId: import_zod17.z.string(),
+  breadcrumbs: import_zod17.z.array(ConvexBreadcrumbEventSchema).min(1)
+});
+
+// src/schemas/trips/post-driver-trip-telemetry.ts
+var import_zod18 = require("zod");
+var PostDriverTripTelemetryRecordSchema = import_zod18.z.object({
+  location_latitude: import_zod18.z.number(),
+  location_longitude: import_zod18.z.number(),
+  location_address: import_zod18.z.string().optional(),
+  heading: import_zod18.z.number(),
+  drivingState: import_zod18.z.string(),
+  speedKph: import_zod18.z.number(),
+  altitudeFeet: import_zod18.z.number(),
+  gps_timestamp: import_zod18.z.string().optional(),
+  odometer: import_zod18.z.number().optional(),
+  activity_type: import_zod18.z.string().optional(),
+  activity_confidence: import_zod18.z.number().int().optional()
+});
+var PostDriverTripTelemetryRequestSchema = import_zod18.z.object({
+  honkUserId: import_zod18.z.string(),
+  telemetry: import_zod18.z.array(PostDriverTripTelemetryRecordSchema).min(1)
+});
+
+// src/schemas/trips/post-daily-summary.ts
+var import_zod19 = require("zod");
+var PostDailySummaryRecordSchema = import_zod19.z.object({
+  externalDriverId: import_zod19.z.string(),
+  // drivers.id from Postgres
+  date: import_zod19.z.string(),
+  // "YYYY-MM-DD"
+  totalMiles: import_zod19.z.number(),
+  tripCount: import_zod19.z.number(),
+  pointCount: import_zod19.z.number(),
+  polyline: import_zod19.z.string().optional(),
+  highways: import_zod19.z.array(import_zod19.z.string()).optional(),
+  avgSpeedMph: import_zod19.z.number().optional(),
+  milesByWeather: import_zod19.z.record(import_zod19.z.string(), import_zod19.z.number()).optional(),
+  milesByLight: import_zod19.z.record(import_zod19.z.string(), import_zod19.z.number()).optional(),
+  states: import_zod19.z.array(import_zod19.z.string()).optional(),
+  origin: import_zod19.z.string().optional(),
+  destination: import_zod19.z.string().optional(),
+  altitudeGainedFeet: import_zod19.z.number().optional(),
+  altitudeLostFeet: import_zod19.z.number().optional(),
+  userId: import_zod19.z.string().optional()
+  // Convex user ID (honk_user_id) for fallback driver resolution
+});
+var PostDailySummaryRequestSchema = import_zod19.z.object({
+  summaries: import_zod19.z.array(PostDailySummaryRecordSchema).min(1)
+});
 
 // src/auth-data.ts
-var import_zod14 = require("zod");
-var GomotiveAuthDataSchema = import_zod14.z.object({
-  kind: import_zod14.z.literal("gomotive"),
-  token: import_zod14.z.string(),
-  ownerOperator: import_zod14.z.boolean()
+var import_zod20 = require("zod");
+var GomotiveAuthDataSchema = import_zod20.z.object({
+  kind: import_zod20.z.literal("gomotive"),
+  token: import_zod20.z.string(),
+  ownerOperator: import_zod20.z.boolean()
 });
-var VistaAuthDataSchema = import_zod14.z.object({
-  kind: import_zod14.z.literal("vista"),
-  driverId: import_zod14.z.string(),
-  cookie: import_zod14.z.string()
+var VistaAuthDataSchema = import_zod20.z.object({
+  kind: import_zod20.z.literal("vista"),
+  driverId: import_zod20.z.string(),
+  cookie: import_zod20.z.string()
 });
-var MockAuthDataSchema = import_zod14.z.object({
-  kind: import_zod14.z.literal("mock"),
-  cookie: import_zod14.z.string()
+var MockAuthDataSchema = import_zod20.z.object({
+  kind: import_zod20.z.literal("mock"),
+  cookie: import_zod20.z.string()
 });
-var NoneAuthDataSchema = import_zod14.z.object({
-  kind: import_zod14.z.literal("none")
+var NoneAuthDataSchema = import_zod20.z.object({
+  kind: import_zod20.z.literal("none")
 });
-var ProviderAuthDataSchema = import_zod14.z.discriminatedUnion("kind", [
+var ProviderAuthDataSchema = import_zod20.z.discriminatedUnion("kind", [
   GomotiveAuthDataSchema,
   VistaAuthDataSchema,
   MockAuthDataSchema,
   NoneAuthDataSchema
 ]);
-var LegacyVistaAuthSchema = import_zod14.z.object({
-  driverId: import_zod14.z.string(),
-  cookie: import_zod14.z.string()
+var LegacyVistaAuthSchema = import_zod20.z.object({
+  driverId: import_zod20.z.string(),
+  cookie: import_zod20.z.string()
 });
 function serializeAuthData(data) {
   if (data.kind === "none") {
@@ -556,46 +722,46 @@ function deserializeAuthData(authToken) {
 }
 
 // src/browser-auth.ts
-var import_zod15 = require("zod");
-var CapturedTrafficEntrySchema = import_zod15.z.object({
-  method: import_zod15.z.string(),
-  url: import_zod15.z.string(),
-  status: import_zod15.z.number(),
-  responseBody: import_zod15.z.string().optional()
-});
-var BrowserAuthRequestSchema = import_zod15.z.object({
-  providerStub: import_zod15.z.string(),
-  providerUrl: import_zod15.z.string(),
-  username: import_zod15.z.string(),
-  encryptedPassword: import_zod15.z.string(),
-  captureTraffic: import_zod15.z.boolean().optional()
-});
-var BrowserAuthSuccessSchema = import_zod15.z.object({
-  success: import_zod15.z.literal(true),
+var import_zod21 = require("zod");
+var CapturedTrafficEntrySchema = import_zod21.z.object({
+  method: import_zod21.z.string(),
+  url: import_zod21.z.string(),
+  status: import_zod21.z.number(),
+  responseBody: import_zod21.z.string().optional()
+});
+var BrowserAuthRequestSchema = import_zod21.z.object({
+  providerStub: import_zod21.z.string(),
+  providerUrl: import_zod21.z.string(),
+  username: import_zod21.z.string(),
+  encryptedPassword: import_zod21.z.string(),
+  captureTraffic: import_zod21.z.boolean().optional()
+});
+var BrowserAuthSuccessSchema = import_zod21.z.object({
+  success: import_zod21.z.literal(true),
   authData: ProviderAuthDataSchema,
-  capturedTraffic: import_zod15.z.array(CapturedTrafficEntrySchema).optional()
+  capturedTraffic: import_zod21.z.array(CapturedTrafficEntrySchema).optional()
 });
-var BrowserAuthFailureSchema = import_zod15.z.object({
-  success: import_zod15.z.literal(false),
-  error: import_zod15.z.string()
+var BrowserAuthFailureSchema = import_zod21.z.object({
+  success: import_zod21.z.literal(false),
+  error: import_zod21.z.string()
 });
-var BrowserAuthResponseSchema = import_zod15.z.discriminatedUnion("success", [
+var BrowserAuthResponseSchema = import_zod21.z.discriminatedUnion("success", [
   BrowserAuthSuccessSchema,
   BrowserAuthFailureSchema
 ]);
-var CrawlPageSchema = import_zod15.z.object({
-  url: import_zod15.z.string(),
-  html: import_zod15.z.string()
+var CrawlPageSchema = import_zod21.z.object({
+  url: import_zod21.z.string(),
+  html: import_zod21.z.string()
 });
-var BrowserCrawlSuccessSchema = import_zod15.z.object({
-  success: import_zod15.z.literal(true),
-  pages: import_zod15.z.array(CrawlPageSchema)
+var BrowserCrawlSuccessSchema = import_zod21.z.object({
+  success: import_zod21.z.literal(true),
+  pages: import_zod21.z.array(CrawlPageSchema)
 });
-var BrowserCrawlFailureSchema = import_zod15.z.object({
-  success: import_zod15.z.literal(false),
-  error: import_zod15.z.string()
+var BrowserCrawlFailureSchema = import_zod21.z.object({
+  success: import_zod21.z.literal(false),
+  error: import_zod21.z.string()
 });
-var BrowserCrawlResponseSchema = import_zod15.z.discriminatedUnion("success", [
+var BrowserCrawlResponseSchema = import_zod21.z.discriminatedUnion("success", [
   BrowserCrawlSuccessSchema,
   BrowserCrawlFailureSchema
 ]);
@@ -603,6 +769,11 @@ var BrowserCrawlResponseSchema = import_zod15.z.discriminatedUnion("success", [
 0 && (module.exports = {
   AnonymousDriverErrorResponseSchema,
   AnonymousDriverResponseSchema,
+  BGGeoActivitySchema,
+  BGGeoBatchRequestSchema,
+  BGGeoBatterySchema,
+  BGGeoCoordsSchema,
+  BGGeoLocationSchema,
   BatchConvexUpdate,
   BatchConvexUpdateSchema,
   BrowserAuthFailureSchema,
@@ -613,7 +784,9 @@ var BrowserCrawlResponseSchema = import_zod15.z.discriminatedUnion("success", [
   BrowserCrawlResponseSchema,
   BrowserCrawlSuccessSchema,
   CapturedTrafficEntrySchema,
+  ConvexBreadcrumbEventSchema,
   ConvexDriverSchema,
+  ConvexDriverTripRequestSchema,
   ConvexUpdate,
   ConvexUpdateSchema,
   CrawlPageSchema,
@@ -640,8 +813,9 @@ var BrowserCrawlResponseSchema = import_zod15.z.discriminatedUnion("success", [
   EnrichedTripSummaryResponseSchema,
   EnrichedTripSummarySchema,
   GomotiveAuthDataSchema,
+  ListDriversRequestSchema,
+  ListDriversResponseSchema,
   ManualBatchEntrySchema,
-  ManualBatchRequestSchema,
   ManualBatchResponseSchema,
   ManualBatchTelemetrySchema,
   MockAuthDataSchema,
@@ -659,6 +833,10 @@ var BrowserCrawlResponseSchema = import_zod15.z.discriminatedUnion("success", [
   PatchDriverDriverResponseSchema,
   PatchDriverRequestSchema,
   PatchDriverResponseSchema,
+  PostDailySummaryRecordSchema,
+  PostDailySummaryRequestSchema,
+  PostDriverTripTelemetryRecordSchema,
+  PostDriverTripTelemetryRequestSchema,
   ProviderAuthDataSchema,
   ScrapeStatus,
   SharedDriverResponseSchema,
@@ -667,6 +845,8 @@ var BrowserCrawlResponseSchema = import_zod15.z.discriminatedUnion("success", [
   StateHeatmapResponseSchema,
   TruckTypeSchema,
   UpdateScrapeStatusMessage,
+  ValidateLoginRequestSchema,
+  ValidateLoginResponseSchema,
   ValidatePasswordRequestSchema,
   ValidatePasswordResponseSchema,
   VistaAuthDataSchema,