@findatruck/shared-schemas 2.23.0 → 2.23.1

package/dist/index.cjs

@@ -79,7 +79,6 @@ __export(index_exports, {
   ListDriversRequestSchema: () => ListDriversRequestSchema,
   ListDriversResponseSchema: () => ListDriversResponseSchema,
   ManualBatchEntrySchema: () => ManualBatchEntrySchema,
-  ManualBatchRequestSchema: () => ManualBatchRequestSchema,
   ManualBatchResponseSchema: () => ManualBatchResponseSchema,
   ManualBatchTelemetrySchema: () => ManualBatchTelemetrySchema,
   MockAuthDataSchema: () => MockAuthDataSchema,
@@ -97,6 +96,8 @@ __export(index_exports, {
   PatchDriverDriverResponseSchema: () => PatchDriverDriverResponseSchema,
   PatchDriverRequestSchema: () => PatchDriverRequestSchema,
   PatchDriverResponseSchema: () => PatchDriverResponseSchema,
+  PostDailySummaryRecordSchema: () => PostDailySummaryRecordSchema,
+  PostDailySummaryRequestSchema: () => PostDailySummaryRequestSchema,
   PostDriverTripTelemetryRecordSchema: () => PostDriverTripTelemetryRecordSchema,
   PostDriverTripTelemetryRequestSchema: () => PostDriverTripTelemetryRequestSchema,
   ProviderAuthDataSchema: () => ProviderAuthDataSchema,
@@ -107,6 +108,8 @@ __export(index_exports, {
   StateHeatmapResponseSchema: () => StateHeatmapResponseSchema,
   TruckTypeSchema: () => TruckTypeSchema,
   UpdateScrapeStatusMessage: () => UpdateScrapeStatusMessage,
+  ValidateLoginRequestSchema: () => ValidateLoginRequestSchema,
+  ValidateLoginResponseSchema: () => ValidateLoginResponseSchema,
   ValidatePasswordRequestSchema: () => ValidatePasswordRequestSchema,
   ValidatePasswordResponseSchema: () => ValidatePasswordResponseSchema,
   VistaAuthDataSchema: () => VistaAuthDataSchema,
@@ -360,141 +363,160 @@ var ValidatePasswordResponseSchema = import_zod8.z.object({
   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/delete-provider-account.ts
+// src/schemas/providerAccounts/validate-login.ts
 var import_zod9 = require("zod");
-var DeleteProviderAccountRequestSchema = import_zod9.z.object({
-  providerAccountId: import_zod9.z.string().min(1).describe("The external provider account ID to delete")
+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_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_zod9.z.object({
-  success: import_zod9.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_zod10 = require("zod");
-var DriverRankingsRequestSchema = import_zod10.z.object({
-  start_date: import_zod10.z.string().describe("Start date for the ranking period (ISO 8601 format)"),
-  end_date: import_zod10.z.string().describe("End date for the ranking period (ISO 8601 format)"),
-  state: import_zod10.z.string().length(2).optional().describe("Optional 2-letter state abbreviation to filter telemetry by location"),
-  source: import_zod10.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_zod10.z.object({
-  rank: import_zod10.z.number().int().positive().describe("Rank position based on miles driven"),
-  driver_id: import_zod10.z.string().uuid().describe("Unique identifier of the driver"),
-  driver_name: import_zod10.z.string().describe("Name of the driver"),
-  total_miles: import_zod10.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_zod10.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_zod11 = require("zod");
-var StateHeatmapRequestSchema = import_zod11.z.object({
-  driver_id: import_zod11.z.string().uuid().describe("Unique identifier of the driver"),
-  start_date: import_zod11.z.string().describe("Start date for the heatmap period (ISO 8601 format)"),
-  end_date: import_zod11.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_zod11.z.object({
-  count: import_zod11.z.number().int().min(0).describe("Number of telemetry points in this state"),
-  percentage: import_zod11.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_zod11.z.record(
-  import_zod11.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_zod12 = require("zod");
-var ManualBatchEntrySchema = import_zod12.z.object({
-  driver_id: import_zod12.z.string().uuid().describe("Internal UUID of the driver"),
-  timestamp: import_zod12.z.string().datetime().describe("Timestamp of the GPS reading (ISO 8601 format)"),
-  location_latitude: import_zod12.z.number().min(-90).max(90).describe("GPS latitude coordinate"),
-  location_longitude: import_zod12.z.number().min(-180).max(180).describe("GPS longitude coordinate"),
-  location_address: import_zod12.z.string().optional().describe("Optional human-readable address"),
-  vehicle_odometer_miles: import_zod12.z.number().min(0).optional().describe("Optional vehicle odometer reading in miles"),
-  heading: import_zod12.z.number().min(0).max(360).optional().describe("Optional GPS heading in degrees (0-360)"),
-  speed_mph: import_zod12.z.number().min(0).optional().describe("Optional GPS speed in miles per hour"),
-  altitude_feet: import_zod12.z.number().optional().describe("Optional GPS altitude in feet"),
-  raw: import_zod12.z.record(import_zod12.z.string(), import_zod12.z.unknown()).optional().describe("Optional raw upstream JSON payload to archive alongside this entry"),
-  driving_status: import_zod12.z.enum(["parked", "driving"]).optional().describe("Optional parked/driving status reported by the upstream system"),
-  activity_type: import_zod12.z.string().optional().describe("Optional activity recognition type (e.g. 'in_vehicle', 'on_foot')"),
-  activity_confidence: import_zod12.z.number().int().min(0).max(100).optional().describe("Optional activity recognition confidence (0-100)")
+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_zod12.z.object({
-  entries: import_zod12.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_zod12.z.object({
-  id: import_zod12.z.number().int().describe("Telemetry record ID"),
-  driver_id: import_zod12.z.string().uuid().describe("Internal UUID of the driver"),
-  timestamp: import_zod12.z.union([import_zod12.z.string(), import_zod12.z.date()]).describe("Timestamp of the telemetry reading"),
-  remaining_drive_time_in_seconds: import_zod12.z.number().min(0),
-  remaining_shift_time_in_seconds: import_zod12.z.number().min(0),
-  remaining_cycle_time_in_seconds: import_zod12.z.number().min(0),
-  remaining_break_time_in_seconds: import_zod12.z.number().min(0),
-  location_latitude: import_zod12.z.number().min(-90).max(90),
-  location_longitude: import_zod12.z.number().min(-180).max(180),
-  previous_location_latitude: import_zod12.z.number().min(-90).max(90).nullable(),
-  previous_location_longitude: import_zod12.z.number().min(-180).max(180).nullable(),
-  location_address: import_zod12.z.string().nullable(),
-  location_state: import_zod12.z.string().length(2).nullable(),
-  echoed_odometer_miles: import_zod12.z.number().min(0).nullable().describe("Vehicle odometer reading echoed back from the request (miles)"),
-  osrm_calculated_miles: import_zod12.z.number().min(0).nullable().describe("Road distance calculated by OSRM between this point and the previous point (miles)"),
-  heading: import_zod12.z.number().nullish(),
-  speed_mph: import_zod12.z.number().nullish(),
-  altitude_feet: import_zod12.z.number().nullish(),
-  source: import_zod12.z.enum(["eld", "manual"]),
-  driving_status: import_zod12.z.enum(["parked", "driving"]).nullable(),
-  activity_type: import_zod12.z.string().nullable(),
-  activity_confidence: import_zod12.z.number().int().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_zod12.z.object({
-  message: import_zod12.z.string().describe("Success message"),
-  inserted_count: import_zod12.z.number().int().min(0).describe("Number of telemetry entries inserted"),
-  telemetry: import_zod12.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_zod13 = require("zod");
-var BGGeoCoordsSchema = import_zod13.z.object({
-  latitude: import_zod13.z.number().min(-90).max(90),
-  longitude: import_zod13.z.number().min(-180).max(180),
-  accuracy: import_zod13.z.number().optional(),
-  speed: import_zod13.z.number().describe("Speed in m/s; -1 when unavailable"),
-  heading: import_zod13.z.number().describe("Heading in degrees; -1 when unavailable"),
-  altitude: import_zod13.z.number().describe("Altitude in meters"),
-  altitude_accuracy: import_zod13.z.number().optional(),
-  speed_accuracy: import_zod13.z.number().optional(),
-  heading_accuracy: import_zod13.z.number().optional(),
-  ellipsoidal_altitude: import_zod13.z.number().optional(),
-  floor: import_zod13.z.number().nullable().optional()
+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_zod13.z.object({
-  type: import_zod13.z.string(),
-  confidence: import_zod13.z.number()
+var BGGeoActivitySchema = import_zod14.z.object({
+  type: import_zod14.z.string(),
+  confidence: import_zod14.z.number()
 }).describe("BGGeo activity recognition");
-var BGGeoBatterySchema = import_zod13.z.object({
-  is_charging: import_zod13.z.boolean(),
-  level: import_zod13.z.number()
+var BGGeoBatterySchema = import_zod14.z.object({
+  is_charging: import_zod14.z.boolean(),
+  level: import_zod14.z.number()
 }).describe("BGGeo battery status");
-var BGGeoLocationSchema = import_zod13.z.object({
+var BGGeoLocationSchema = import_zod14.z.object({
   coords: BGGeoCoordsSchema,
-  extras: import_zod13.z.object({}).passthrough().optional(),
+  extras: import_zod14.z.object({}).passthrough().optional(),
   activity: BGGeoActivitySchema.optional(),
   battery: BGGeoBatterySchema.optional(),
-  timestamp: import_zod13.z.string().datetime().describe("ISO 8601 timestamp"),
-  is_moving: import_zod13.z.boolean(),
-  odometer: import_zod13.z.number().min(0).describe("Odometer in meters"),
-  uuid: import_zod13.z.string().optional(),
-  event: import_zod13.z.string().optional(),
-  age: import_zod13.z.number().optional(),
-  geofence: import_zod13.z.record(import_zod13.z.string(), import_zod13.z.unknown()).optional(),
-  mock: import_zod13.z.boolean().optional(),
-  recorded_at: import_zod13.z.string().datetime().optional().describe("ISO 8601 device recording timestamp")
+  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_zod13.z.array(BGGeoLocationSchema).min(1).max(1e3).describe("Array of BGGeo location objects (1-1000)");
-var locationOrArray = import_zod13.z.union([
+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_zod13.z.object({
+var BGGeoBatchRequestSchema = import_zod14.z.object({
   location: locationOrArray.optional(),
   locations: locationOrArray.optional()
 }).refine((data) => data.location ?? data.locations, {
@@ -502,142 +524,169 @@ var BGGeoBatchRequestSchema = import_zod13.z.object({
 }).describe("Request schema for BGGeo batch telemetry ingestion");
 
 // src/schemas/trips/driver-trips.ts
-var import_zod14 = require("zod");
-var DriverTripsRequestSchema = import_zod14.z.object({
-  driver_id: import_zod14.z.string().uuid(),
-  start_date: import_zod14.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_zod14.z.string()
+  end_date: import_zod15.z.string()
   // YYYY-MM-DD
 });
-var DriverTripSchema = import_zod14.z.object({
-  id: import_zod14.z.number(),
-  start_time: import_zod14.z.string(),
-  end_time: import_zod14.z.string(),
-  point_count: import_zod14.z.number(),
-  polyline: import_zod14.z.string().nullable(),
-  highways: import_zod14.z.array(import_zod14.z.string()).nullable(),
-  total_miles: import_zod14.z.number().nullable(),
-  avg_speed_mph: import_zod14.z.number().nullable(),
-  miles_by_weather: import_zod14.z.record(import_zod14.z.string(), import_zod14.z.number()).nullable(),
-  miles_by_light: import_zod14.z.record(import_zod14.z.string(), import_zod14.z.number()).nullable()
-});
-var DriverTripsResponseSchema = import_zod14.z.array(DriverTripSchema);
-var DriverDailySummarySchema = import_zod14.z.object({
-  summary_date: import_zod14.z.string(),
-  total_miles: import_zod14.z.number(),
-  trip_count: import_zod14.z.number(),
-  point_count: import_zod14.z.number(),
-  polyline: import_zod14.z.string().nullable(),
-  highways: import_zod14.z.array(import_zod14.z.string()).nullable(),
-  avg_speed_mph: import_zod14.z.number().nullable(),
-  miles_by_weather: import_zod14.z.record(import_zod14.z.string(), import_zod14.z.number()).nullable(),
-  miles_by_light: import_zod14.z.record(import_zod14.z.string(), import_zod14.z.number()).nullable()
-});
-var DriverDailySummariesResponseSchema = import_zod14.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_zod15 = require("zod");
-var EnrichedTripSummaryRequestSchema = import_zod15.z.object({
-  trip_id: import_zod15.z.number()
+var import_zod16 = require("zod");
+var EnrichedTripSummaryRequestSchema = import_zod16.z.object({
+  trip_id: import_zod16.z.number()
 });
-var DriverEnrichedSummariesRequestSchema = import_zod15.z.object({
-  driver_id: import_zod15.z.string().uuid(),
-  start_date: import_zod15.z.string(),
-  end_date: import_zod15.z.string()
+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 EnrichedStopSchema = import_zod15.z.object({
-  duration_seconds: import_zod15.z.number()
-});
-var EnrichedPointSchema = import_zod15.z.object({
-  lat: import_zod15.z.number(),
-  lon: import_zod15.z.number(),
-  timestamp: import_zod15.z.string(),
-  speed_mph: import_zod15.z.number().nullable(),
-  heading: import_zod15.z.number().nullable(),
-  altitude_feet: import_zod15.z.number().nullable(),
-  weather_condition: import_zod15.z.string().nullable(),
-  temperature_f: import_zod15.z.number().nullable(),
-  visibility_miles: import_zod15.z.number().nullable(),
-  light_condition: import_zod15.z.string().nullable(),
+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_zod15.z.object({
-  trip_id: import_zod15.z.number(),
-  driver_id: import_zod15.z.string(),
-  start_time: import_zod15.z.string(),
-  end_time: import_zod15.z.string(),
-  points: import_zod15.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_zod15.z.array(EnrichedTripSummarySchema);
+var DriverEnrichedSummariesResponseSchema = import_zod16.z.array(EnrichedTripSummarySchema);
 
 // src/schemas/trips/convex-driver-trip.ts
-var import_zod16 = require("zod");
-var ConvexBreadcrumbEventSchema = import_zod16.z.object({
-  ts: import_zod16.z.number(),
+var import_zod17 = require("zod");
+var ConvexBreadcrumbEventSchema = import_zod17.z.object({
+  ts: import_zod17.z.number(),
   // epoch ms
-  status: import_zod16.z.string(),
-  lat: import_zod16.z.number(),
-  lon: import_zod16.z.number(),
-  heading: import_zod16.z.number().optional(),
-  locationText: import_zod16.z.string().optional(),
-  speedKph: import_zod16.z.number().optional(),
-  altitudeFeet: import_zod16.z.number().optional()
-});
-var ConvexDriverTripRequestSchema = import_zod16.z.object({
-  userId: import_zod16.z.string(),
-  breadcrumbs: import_zod16.z.array(ConvexBreadcrumbEventSchema).min(1)
+  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_zod17 = require("zod");
-var PostDriverTripTelemetryRecordSchema = import_zod17.z.object({
-  location_latitude: import_zod17.z.number(),
-  location_longitude: import_zod17.z.number(),
-  location_address: import_zod17.z.string().optional(),
-  heading: import_zod17.z.number(),
-  drivingState: import_zod17.z.string(),
-  speedKph: import_zod17.z.number(),
-  altitudeFeet: import_zod17.z.number(),
-  gps_timestamp: import_zod17.z.string().optional(),
-  odometer: import_zod17.z.number().optional(),
-  activity_type: import_zod17.z.string().optional(),
-  activity_confidence: import_zod17.z.number().int().optional()
-});
-var PostDriverTripTelemetryRequestSchema = import_zod17.z.object({
-  honkUserId: import_zod17.z.string(),
-  telemetry: import_zod17.z.array(PostDriverTripTelemetryRecordSchema).min(1)
+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_zod18 = require("zod");
-var GomotiveAuthDataSchema = import_zod18.z.object({
-  kind: import_zod18.z.literal("gomotive"),
-  token: import_zod18.z.string(),
-  ownerOperator: import_zod18.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_zod18.z.object({
-  kind: import_zod18.z.literal("vista"),
-  driverId: import_zod18.z.string(),
-  cookie: import_zod18.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_zod18.z.object({
-  kind: import_zod18.z.literal("mock"),
-  cookie: import_zod18.z.string()
+var MockAuthDataSchema = import_zod20.z.object({
+  kind: import_zod20.z.literal("mock"),
+  cookie: import_zod20.z.string()
 });
-var NoneAuthDataSchema = import_zod18.z.object({
-  kind: import_zod18.z.literal("none")
+var NoneAuthDataSchema = import_zod20.z.object({
+  kind: import_zod20.z.literal("none")
 });
-var ProviderAuthDataSchema = import_zod18.z.discriminatedUnion("kind", [
+var ProviderAuthDataSchema = import_zod20.z.discriminatedUnion("kind", [
   GomotiveAuthDataSchema,
   VistaAuthDataSchema,
   MockAuthDataSchema,
   NoneAuthDataSchema
 ]);
-var LegacyVistaAuthSchema = import_zod18.z.object({
-  driverId: import_zod18.z.string(),
-  cookie: import_zod18.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") {
@@ -673,46 +722,46 @@ function deserializeAuthData(authToken) {
 }
 
 // src/browser-auth.ts
-var import_zod19 = require("zod");
-var CapturedTrafficEntrySchema = import_zod19.z.object({
-  method: import_zod19.z.string(),
-  url: import_zod19.z.string(),
-  status: import_zod19.z.number(),
-  responseBody: import_zod19.z.string().optional()
-});
-var BrowserAuthRequestSchema = import_zod19.z.object({
-  providerStub: import_zod19.z.string(),
-  providerUrl: import_zod19.z.string(),
-  username: import_zod19.z.string(),
-  encryptedPassword: import_zod19.z.string(),
-  captureTraffic: import_zod19.z.boolean().optional()
-});
-var BrowserAuthSuccessSchema = import_zod19.z.object({
-  success: import_zod19.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_zod19.z.array(CapturedTrafficEntrySchema).optional()
+  capturedTraffic: import_zod21.z.array(CapturedTrafficEntrySchema).optional()
 });
-var BrowserAuthFailureSchema = import_zod19.z.object({
-  success: import_zod19.z.literal(false),
-  error: import_zod19.z.string()
+var BrowserAuthFailureSchema = import_zod21.z.object({
+  success: import_zod21.z.literal(false),
+  error: import_zod21.z.string()
 });
-var BrowserAuthResponseSchema = import_zod19.z.discriminatedUnion("success", [
+var BrowserAuthResponseSchema = import_zod21.z.discriminatedUnion("success", [
   BrowserAuthSuccessSchema,
   BrowserAuthFailureSchema
 ]);
-var CrawlPageSchema = import_zod19.z.object({
-  url: import_zod19.z.string(),
-  html: import_zod19.z.string()
+var CrawlPageSchema = import_zod21.z.object({
+  url: import_zod21.z.string(),
+  html: import_zod21.z.string()
 });
-var BrowserCrawlSuccessSchema = import_zod19.z.object({
-  success: import_zod19.z.literal(true),
-  pages: import_zod19.z.array(CrawlPageSchema)
+var BrowserCrawlSuccessSchema = import_zod21.z.object({
+  success: import_zod21.z.literal(true),
+  pages: import_zod21.z.array(CrawlPageSchema)
 });
-var BrowserCrawlFailureSchema = import_zod19.z.object({
-  success: import_zod19.z.literal(false),
-  error: import_zod19.z.string()
+var BrowserCrawlFailureSchema = import_zod21.z.object({
+  success: import_zod21.z.literal(false),
+  error: import_zod21.z.string()
 });
-var BrowserCrawlResponseSchema = import_zod19.z.discriminatedUnion("success", [
+var BrowserCrawlResponseSchema = import_zod21.z.discriminatedUnion("success", [
   BrowserCrawlSuccessSchema,
   BrowserCrawlFailureSchema
 ]);
@@ -767,7 +816,6 @@ var BrowserCrawlResponseSchema = import_zod19.z.discriminatedUnion("success", [
   ListDriversRequestSchema,
   ListDriversResponseSchema,
   ManualBatchEntrySchema,
-  ManualBatchRequestSchema,
   ManualBatchResponseSchema,
   ManualBatchTelemetrySchema,
   MockAuthDataSchema,
@@ -785,6 +833,8 @@ var BrowserCrawlResponseSchema = import_zod19.z.discriminatedUnion("success", [
   PatchDriverDriverResponseSchema,
   PatchDriverRequestSchema,
   PatchDriverResponseSchema,
+  PostDailySummaryRecordSchema,
+  PostDailySummaryRequestSchema,
   PostDriverTripTelemetryRecordSchema,
   PostDriverTripTelemetryRequestSchema,
   ProviderAuthDataSchema,
@@ -795,6 +845,8 @@ var BrowserCrawlResponseSchema = import_zod19.z.discriminatedUnion("success", [
   StateHeatmapResponseSchema,
   TruckTypeSchema,
   UpdateScrapeStatusMessage,
+  ValidateLoginRequestSchema,
+  ValidateLoginResponseSchema,
   ValidatePasswordRequestSchema,
   ValidatePasswordResponseSchema,
   VistaAuthDataSchema,