@findatruck/shared-schemas 2.16.0 → 2.18.0

package/dist/index.cjs

@@ -47,13 +47,27 @@ __export(index_exports, {
   ConvexUpdateSchema: () => ConvexUpdateSchema,
   CrawlPageSchema: () => CrawlPageSchema,
   CreateAnonymousDriverBodySchema: () => CreateAnonymousDriverBodySchema,
+  DRIVER_NAME_FORBIDDEN_CHAR_PATTERN: () => DRIVER_NAME_FORBIDDEN_CHAR_PATTERN,
   DeleteAnonymousDriverParamsSchema: () => DeleteAnonymousDriverParamsSchema,
   DeleteAnonymousDriverResponseSchema: () => DeleteAnonymousDriverResponseSchema,
   DeleteProviderAccountRequestSchema: () => DeleteProviderAccountRequestSchema,
   DeleteProviderAccountResponseSchema: () => DeleteProviderAccountResponseSchema,
+  DriverDailySummariesResponseSchema: () => DriverDailySummariesResponseSchema,
+  DriverDailySummarySchema: () => DriverDailySummarySchema,
+  DriverEnrichedSummariesRequestSchema: () => DriverEnrichedSummariesRequestSchema,
+  DriverEnrichedSummariesResponseSchema: () => DriverEnrichedSummariesResponseSchema,
+  DriverNameSchema: () => DriverNameSchema,
   DriverRankingSchema: () => DriverRankingSchema,
   DriverRankingsRequestSchema: () => DriverRankingsRequestSchema,
   DriverRankingsResponseSchema: () => DriverRankingsResponseSchema,
+  DriverTripSchema: () => DriverTripSchema,
+  DriverTripsRequestSchema: () => DriverTripsRequestSchema,
+  DriverTripsResponseSchema: () => DriverTripsResponseSchema,
+  EnrichedPointSchema: () => EnrichedPointSchema,
+  EnrichedStopSchema: () => EnrichedStopSchema,
+  EnrichedTripSummaryRequestSchema: () => EnrichedTripSummaryRequestSchema,
+  EnrichedTripSummaryResponseSchema: () => EnrichedTripSummaryResponseSchema,
+  EnrichedTripSummarySchema: () => EnrichedTripSummarySchema,
   GomotiveAuthDataSchema: () => GomotiveAuthDataSchema,
   ManualBatchEntrySchema: () => ManualBatchEntrySchema,
   ManualBatchRequestSchema: () => ManualBatchRequestSchema,
@@ -69,8 +83,13 @@ __export(index_exports, {
   NewLoginResponseSuccess: () => NewLoginResponseSuccess,
   NewLoginResponseSuccessSchema: () => NewLoginResponseSuccessSchema,
   NoneAuthDataSchema: () => NoneAuthDataSchema,
+  PATCH_DRIVER_NAME_MAX_LENGTH: () => PATCH_DRIVER_NAME_MAX_LENGTH,
+  PatchDriverDriverResponseSchema: () => PatchDriverDriverResponseSchema,
+  PatchDriverRequestSchema: () => PatchDriverRequestSchema,
+  PatchDriverResponseSchema: () => PatchDriverResponseSchema,
   ProviderAuthDataSchema: () => ProviderAuthDataSchema,
   ScrapeStatus: () => ScrapeStatus,
+  SharedDriverResponseSchema: () => SharedDriverResponseSchema,
   StateHeatmapEntrySchema: () => StateHeatmapEntrySchema,
   StateHeatmapRequestSchema: () => StateHeatmapRequestSchema,
   StateHeatmapResponseSchema: () => StateHeatmapResponseSchema,
@@ -198,8 +217,85 @@ var DeleteAnonymousDriverResponseSchema = import_zod3.default.object({
   user_id: import_zod3.default.string()
 });
 
-// src/schemas/providerAccounts/update-status.ts
+// src/schemas/drivers/driver.ts
 var import_zod4 = __toESM(require("zod"), 1);
+var SharedDriverResponseSchema = import_zod4.default.object({
+  // The `drivers.id` column is a Postgres UUID (migration 0001), and every
+  // input-side schema (`IdParamsSchema`, `PatchDriverRequestSchema.driver_id`)
+  // is already `z.uuid()`. Tightening the response side keeps the contract
+  // symmetric — a client that statically relies on `id` being UUID-shaped on
+  // input can rely on the same on output. `eld_external_id` stays loose
+  // because providers emit non-UUID identifiers there.
+  id: import_zod4.default.uuid(),
+  name: import_zod4.default.string(),
+  eld_external_id: import_zod4.default.string(),
+  license_number: import_zod4.default.string().nullable(),
+  license_state: import_zod4.default.string().nullable(),
+  license_expiration_date: import_zod4.default.string().nullable(),
+  license_class: import_zod4.default.string().nullable(),
+  is_placeholder: import_zod4.default.boolean(),
+  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()]),
+  last_location_latitude: import_zod4.default.number().nullable(),
+  last_location_longitude: import_zod4.default.number().nullable()
+});
+
+// src/schemas/drivers/patch-driver.ts
+var import_zod5 = __toESM(require("zod"), 1);
+var PATCH_DRIVER_NAME_MAX_LENGTH = 255;
+var DRIVER_NAME_FORBIDDEN_RANGES = [
+  [0, 31],
+  // C0 controls (includes NUL, CR, LF, TAB)
+  [127, 159],
+  // DEL + C1 controls
+  [8203, 8205],
+  // ZWSP, ZWNJ, ZWJ
+  [65279, 65279],
+  // BOM / ZWNBSP
+  [8234, 8238],
+  // bidi overrides
+  [8294, 8297]
+  // bidi isolates
+];
+var buildForbiddenCharPattern = () => {
+  const cls = DRIVER_NAME_FORBIDDEN_RANGES.map(([lo, hi]) => {
+    const loEsc = "\\u" + lo.toString(16).padStart(4, "0");
+    if (lo === hi) return loEsc;
+    const hiEsc = "\\u" + hi.toString(16).padStart(4, "0");
+    return `${loEsc}-${hiEsc}`;
+  }).join("");
+  return new RegExp(`[${cls}]`);
+};
+var DRIVER_NAME_FORBIDDEN_CHAR_PATTERN = buildForbiddenCharPattern();
+var DriverNameSchema = import_zod5.default.string().trim().min(1).max(PATCH_DRIVER_NAME_MAX_LENGTH).refine(
+  (s) => !DRIVER_NAME_FORBIDDEN_CHAR_PATTERN.test(s),
+  {
+    message: "name contains disallowed control, zero-width, or bidirectional-override characters"
+  }
+);
+var PatchDriverRequestSchema = import_zod5.default.object({
+  driver_id: import_zod5.default.uuid(),
+  // Tenant scoping: the caller MUST identify which provider account owns the
+  // driver. The aggregator verifies (provider_account_id, driver_id) exists in
+  // `provider_account_to_driver` before mutating, preventing cross-tenant IDOR.
+  provider_account_id: import_zod5.default.uuid(),
+  name: DriverNameSchema
+});
+var PatchDriverDriverResponseSchema = SharedDriverResponseSchema.pick({
+  id: true,
+  name: true,
+  eld_external_id: true,
+  is_placeholder: true,
+  created_at: true,
+  updated_at: true
+}).strict();
+var PatchDriverResponseSchema = import_zod5.default.object({
+  message: import_zod5.default.string(),
+  driver: PatchDriverDriverResponseSchema
+});
+
+// src/schemas/providerAccounts/update-status.ts
+var import_zod6 = __toESM(require("zod"), 1);
 var ScrapeStatus = /* @__PURE__ */ ((ScrapeStatus2) => {
   ScrapeStatus2["NEW_LOGIN_RECEIVED"] = "NEW_LOGIN_RECEIVED";
   ScrapeStatus2["LOGIN_IN_PROGRESS"] = "LOGIN_IN_PROGRESS";
@@ -212,140 +308,213 @@ var ScrapeStatus = /* @__PURE__ */ ((ScrapeStatus2) => {
   ScrapeStatus2["DATA_FETCH_FAILED"] = "DATA_FETCH_FAILED";
   return ScrapeStatus2;
 })(ScrapeStatus || {});
-var UpdateScrapeStatusMessage = import_zod4.default.object({
-  status: import_zod4.default.nativeEnum(ScrapeStatus).describe("The current status of the scrape process"),
-  correctPassword: import_zod4.default.boolean().optional().describe("Indicates if the provided password was correct, if applicable"),
-  externalProviderAccountId: import_zod4.default.string().describe("The external identifier for the provider account (convex ID or similar)"),
-  username: import_zod4.default.string().describe("The username of the provider account whose status is being updated"),
-  provider_url: import_zod4.default.string().describe("The URL of the ELD provider"),
-  driverCount: import_zod4.default.number().optional().describe("The number of drivers associated with the account, if applicable"),
-  providerSlug: import_zod4.default.string().optional().describe("The slug identifier for the provider")
+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")
 }).describe("Schema for update status messages");
 
 // src/schemas/providerAccounts/validate-password.ts
-var import_zod5 = require("zod");
-var ValidatePasswordRequestSchema = import_zod5.z.object({
-  providerAccountId: import_zod5.z.string().min(1).describe("The unique identifier of the provider account in postgres to validate the password for"),
-  encryptedPassword: import_zod5.z.string().min(1).describe("The encrypted password to validate against the stored password")
+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")
 }).describe("Request schema for validating a provider account password");
-var ValidatePasswordResponseSchema = import_zod5.z.object({
-  isValid: import_zod5.z.boolean().describe("Indicates if the provided password is valid"),
-  driverIds: import_zod5.z.array(import_zod5.z.string()).describe("List of driver IDs associated with the provider account")
+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")
 }).describe("Response schema for password validation");
 
 // src/schemas/providerAccounts/delete-provider-account.ts
-var import_zod6 = require("zod");
-var DeleteProviderAccountRequestSchema = import_zod6.z.object({
-  providerAccountId: import_zod6.z.string().min(1).describe("The external provider account ID to delete")
+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")
 }).describe("Request schema for deleting a provider account");
-var DeleteProviderAccountResponseSchema = import_zod6.z.object({
-  success: import_zod6.z.boolean().describe("Indicates if the provider account was successfully deleted")
+var DeleteProviderAccountResponseSchema = import_zod8.z.object({
+  success: import_zod8.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_zod7 = require("zod");
-var DriverRankingsRequestSchema = import_zod7.z.object({
-  start_date: import_zod7.z.string().describe("Start date for the ranking period (ISO 8601 format)"),
-  end_date: import_zod7.z.string().describe("End date for the ranking period (ISO 8601 format)"),
-  state: import_zod7.z.string().length(2).optional().describe("Optional 2-letter state abbreviation to filter telemetry by location"),
-  source: import_zod7.z.enum(["eld", "manual"]).default("manual").describe("Telemetry source to rank by: 'manual' uses GPS odometer, 'eld' uses calculated distance")
+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")
 }).describe("Request schema for driver rankings by miles driven");
-var DriverRankingSchema = import_zod7.z.object({
-  rank: import_zod7.z.number().int().positive().describe("Rank position based on miles driven"),
-  driver_id: import_zod7.z.string().uuid().describe("Unique identifier of the driver"),
-  driver_name: import_zod7.z.string().describe("Name of the driver"),
-  total_miles: import_zod7.z.number().min(0).describe("Total miles driven in the specified period")
+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")
 }).describe("Single driver ranking entry");
-var DriverRankingsResponseSchema = import_zod7.z.array(DriverRankingSchema).describe("Array of driver rankings sorted by miles driven in descending order");
+var DriverRankingsResponseSchema = import_zod9.z.array(DriverRankingSchema).describe("Array of driver rankings sorted by miles driven in descending order");
 
 // src/schemas/telemetry/state-heatmap.ts
-var import_zod8 = require("zod");
-var StateHeatmapRequestSchema = import_zod8.z.object({
-  driver_id: import_zod8.z.string().uuid().describe("Unique identifier of the driver"),
-  start_date: import_zod8.z.string().describe("Start date for the heatmap period (ISO 8601 format)"),
-  end_date: import_zod8.z.string().describe("End date for the heatmap period (ISO 8601 format)")
+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)")
 }).describe("Request schema for driver state heatmap");
-var StateHeatmapEntrySchema = import_zod8.z.object({
-  count: import_zod8.z.number().int().min(0).describe("Number of telemetry points in this state"),
-  percentage: import_zod8.z.number().min(0).max(100).describe("Percentage of total telemetry points in this state")
+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")
 }).describe("Single state entry in the heatmap");
-var StateHeatmapResponseSchema = import_zod8.z.record(
-  import_zod8.z.string().length(2),
+var StateHeatmapResponseSchema = import_zod10.z.record(
+  import_zod10.z.string().length(2),
   StateHeatmapEntrySchema
 ).describe("Record of 2-letter state codes to heatmap entries");
 
 // src/schemas/telemetry/manual-batch.ts
-var import_zod9 = require("zod");
-var ManualBatchEntrySchema = import_zod9.z.object({
-  driver_id: import_zod9.z.string().uuid().describe("Internal UUID of the driver"),
-  timestamp: import_zod9.z.string().datetime().describe("Timestamp of the GPS reading (ISO 8601 format)"),
-  location_latitude: import_zod9.z.number().min(-90).max(90).describe("GPS latitude coordinate"),
-  location_longitude: import_zod9.z.number().min(-180).max(180).describe("GPS longitude coordinate"),
-  location_address: import_zod9.z.string().optional().describe("Optional human-readable address"),
-  vehicle_odometer_miles: import_zod9.z.number().min(0).optional().describe("Optional vehicle odometer reading in miles"),
-  heading: import_zod9.z.number().min(0).max(360).optional().describe("Optional GPS heading in degrees (0-360)"),
-  speed_mph: import_zod9.z.number().min(0).optional().describe("Optional GPS speed in miles per hour"),
-  altitude_feet: import_zod9.z.number().optional().describe("Optional GPS altitude in feet"),
-  raw: import_zod9.z.record(import_zod9.z.string(), import_zod9.z.unknown()).optional().describe("Optional raw upstream JSON payload to archive alongside this entry")
+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")
 }).describe("Single manual telemetry entry");
-var ManualBatchRequestSchema = import_zod9.z.object({
-  entries: import_zod9.z.array(ManualBatchEntrySchema).min(1).max(1e3).describe("Array of manual telemetry entries (1-1000)")
+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_zod9.z.object({
-  id: import_zod9.z.number().int().describe("Telemetry record ID"),
-  driver_id: import_zod9.z.string().uuid().describe("Internal UUID of the driver"),
-  timestamp: import_zod9.z.union([import_zod9.z.string(), import_zod9.z.date()]).describe("Timestamp of the telemetry reading"),
-  remaining_drive_time_in_seconds: import_zod9.z.number().min(0),
-  remaining_shift_time_in_seconds: import_zod9.z.number().min(0),
-  remaining_cycle_time_in_seconds: import_zod9.z.number().min(0),
-  remaining_break_time_in_seconds: import_zod9.z.number().min(0),
-  location_latitude: import_zod9.z.number().min(-90).max(90),
-  location_longitude: import_zod9.z.number().min(-180).max(180),
-  previous_location_latitude: import_zod9.z.number().min(-90).max(90).nullable(),
-  previous_location_longitude: import_zod9.z.number().min(-180).max(180).nullable(),
-  location_address: import_zod9.z.string().nullable(),
-  location_state: import_zod9.z.string().length(2).nullable(),
-  echoed_odometer_miles: import_zod9.z.number().min(0).nullable().describe("Vehicle odometer reading echoed back from the request (miles)"),
-  osrm_calculated_miles: import_zod9.z.number().min(0).nullable().describe("Road distance calculated by OSRM between this point and the previous point (miles)"),
-  heading: import_zod9.z.number().nullish(),
-  speed_mph: import_zod9.z.number().nullish(),
-  altitude_feet: import_zod9.z.number().nullish(),
-  source: import_zod9.z.enum(["eld", "manual"])
+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()
 }).describe("Telemetry record returned from manual batch insertion");
-var ManualBatchResponseSchema = import_zod9.z.object({
-  message: import_zod9.z.string().describe("Success message"),
-  inserted_count: import_zod9.z.number().int().min(0).describe("Number of telemetry entries inserted"),
-  telemetry: import_zod9.z.array(ManualBatchTelemetrySchema).describe("Array of inserted telemetry records")
+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")
 }).describe("Response schema for manual batch telemetry insertion");
 
+// 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(),
+  // YYYY-MM-DD
+  end_date: import_zod12.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);
+
+// 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(),
+  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 EnrichedTripSummaryResponseSchema = EnrichedTripSummarySchema;
+var DriverEnrichedSummariesResponseSchema = import_zod13.z.array(EnrichedTripSummarySchema);
+
 // src/auth-data.ts
-var import_zod10 = require("zod");
-var GomotiveAuthDataSchema = import_zod10.z.object({
-  kind: import_zod10.z.literal("gomotive"),
-  token: import_zod10.z.string(),
-  ownerOperator: import_zod10.z.boolean()
+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 VistaAuthDataSchema = import_zod10.z.object({
-  kind: import_zod10.z.literal("vista"),
-  driverId: import_zod10.z.string(),
-  cookie: import_zod10.z.string()
+var VistaAuthDataSchema = import_zod14.z.object({
+  kind: import_zod14.z.literal("vista"),
+  driverId: import_zod14.z.string(),
+  cookie: import_zod14.z.string()
 });
-var MockAuthDataSchema = import_zod10.z.object({
-  kind: import_zod10.z.literal("mock"),
-  cookie: import_zod10.z.string()
+var MockAuthDataSchema = import_zod14.z.object({
+  kind: import_zod14.z.literal("mock"),
+  cookie: import_zod14.z.string()
 });
-var NoneAuthDataSchema = import_zod10.z.object({
-  kind: import_zod10.z.literal("none")
+var NoneAuthDataSchema = import_zod14.z.object({
+  kind: import_zod14.z.literal("none")
 });
-var ProviderAuthDataSchema = import_zod10.z.discriminatedUnion("kind", [
+var ProviderAuthDataSchema = import_zod14.z.discriminatedUnion("kind", [
   GomotiveAuthDataSchema,
   VistaAuthDataSchema,
   MockAuthDataSchema,
   NoneAuthDataSchema
 ]);
-var LegacyVistaAuthSchema = import_zod10.z.object({
-  driverId: import_zod10.z.string(),
-  cookie: import_zod10.z.string()
+var LegacyVistaAuthSchema = import_zod14.z.object({
+  driverId: import_zod14.z.string(),
+  cookie: import_zod14.z.string()
 });
 function serializeAuthData(data) {
   if (data.kind === "none") {
@@ -381,46 +550,46 @@ function deserializeAuthData(authToken) {
 }
 
 // src/browser-auth.ts
-var import_zod11 = require("zod");
-var CapturedTrafficEntrySchema = import_zod11.z.object({
-  method: import_zod11.z.string(),
-  url: import_zod11.z.string(),
-  status: import_zod11.z.number(),
-  responseBody: import_zod11.z.string().optional()
-});
-var BrowserAuthRequestSchema = import_zod11.z.object({
-  providerStub: import_zod11.z.string(),
-  providerUrl: import_zod11.z.string(),
-  username: import_zod11.z.string(),
-  encryptedPassword: import_zod11.z.string(),
-  captureTraffic: import_zod11.z.boolean().optional()
-});
-var BrowserAuthSuccessSchema = import_zod11.z.object({
-  success: import_zod11.z.literal(true),
+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),
   authData: ProviderAuthDataSchema,
-  capturedTraffic: import_zod11.z.array(CapturedTrafficEntrySchema).optional()
+  capturedTraffic: import_zod15.z.array(CapturedTrafficEntrySchema).optional()
 });
-var BrowserAuthFailureSchema = import_zod11.z.object({
-  success: import_zod11.z.literal(false),
-  error: import_zod11.z.string()
+var BrowserAuthFailureSchema = import_zod15.z.object({
+  success: import_zod15.z.literal(false),
+  error: import_zod15.z.string()
 });
-var BrowserAuthResponseSchema = import_zod11.z.discriminatedUnion("success", [
+var BrowserAuthResponseSchema = import_zod15.z.discriminatedUnion("success", [
   BrowserAuthSuccessSchema,
   BrowserAuthFailureSchema
 ]);
-var CrawlPageSchema = import_zod11.z.object({
-  url: import_zod11.z.string(),
-  html: import_zod11.z.string()
+var CrawlPageSchema = import_zod15.z.object({
+  url: import_zod15.z.string(),
+  html: import_zod15.z.string()
 });
-var BrowserCrawlSuccessSchema = import_zod11.z.object({
-  success: import_zod11.z.literal(true),
-  pages: import_zod11.z.array(CrawlPageSchema)
+var BrowserCrawlSuccessSchema = import_zod15.z.object({
+  success: import_zod15.z.literal(true),
+  pages: import_zod15.z.array(CrawlPageSchema)
 });
-var BrowserCrawlFailureSchema = import_zod11.z.object({
-  success: import_zod11.z.literal(false),
-  error: import_zod11.z.string()
+var BrowserCrawlFailureSchema = import_zod15.z.object({
+  success: import_zod15.z.literal(false),
+  error: import_zod15.z.string()
 });
-var BrowserCrawlResponseSchema = import_zod11.z.discriminatedUnion("success", [
+var BrowserCrawlResponseSchema = import_zod15.z.discriminatedUnion("success", [
   BrowserCrawlSuccessSchema,
   BrowserCrawlFailureSchema
 ]);
@@ -443,13 +612,27 @@ var BrowserCrawlResponseSchema = import_zod11.z.discriminatedUnion("success", [
   ConvexUpdateSchema,
   CrawlPageSchema,
   CreateAnonymousDriverBodySchema,
+  DRIVER_NAME_FORBIDDEN_CHAR_PATTERN,
   DeleteAnonymousDriverParamsSchema,
   DeleteAnonymousDriverResponseSchema,
   DeleteProviderAccountRequestSchema,
   DeleteProviderAccountResponseSchema,
+  DriverDailySummariesResponseSchema,
+  DriverDailySummarySchema,
+  DriverEnrichedSummariesRequestSchema,
+  DriverEnrichedSummariesResponseSchema,
+  DriverNameSchema,
   DriverRankingSchema,
   DriverRankingsRequestSchema,
   DriverRankingsResponseSchema,
+  DriverTripSchema,
+  DriverTripsRequestSchema,
+  DriverTripsResponseSchema,
+  EnrichedPointSchema,
+  EnrichedStopSchema,
+  EnrichedTripSummaryRequestSchema,
+  EnrichedTripSummaryResponseSchema,
+  EnrichedTripSummarySchema,
   GomotiveAuthDataSchema,
   ManualBatchEntrySchema,
   ManualBatchRequestSchema,
@@ -465,8 +648,13 @@ var BrowserCrawlResponseSchema = import_zod11.z.discriminatedUnion("success", [
   NewLoginResponseSuccess,
   NewLoginResponseSuccessSchema,
   NoneAuthDataSchema,
+  PATCH_DRIVER_NAME_MAX_LENGTH,
+  PatchDriverDriverResponseSchema,
+  PatchDriverRequestSchema,
+  PatchDriverResponseSchema,
   ProviderAuthDataSchema,
   ScrapeStatus,
+  SharedDriverResponseSchema,
   StateHeatmapEntrySchema,
   StateHeatmapRequestSchema,
   StateHeatmapResponseSchema,