@findatruck/shared-schemas 2.12.0 → 2.14.0

package/dist/browser.cjs

@@ -153,6 +153,7 @@ var ScrapeStatus = /* @__PURE__ */ ((ScrapeStatus2) => {
   ScrapeStatus2["LOGIN_SUCCESS"] = "LOGIN_SUCCESS";
   ScrapeStatus2["LOGIN_FAILED"] = "LOGIN_FAILED";
   ScrapeStatus2["LOGIN_SUCCESS_FETCH_FAILED"] = "LOGIN_SUCCESS_FETCH_FAILED";
+  ScrapeStatus2["LOGIN_SUCCESS_UNSUPPORTED_PROVIDER"] = "LOGIN_SUCCESS_UNSUPPORTED_PROVIDER";
   ScrapeStatus2["DATA_FETCH_IN_PROGRESS"] = "DATA_FETCH_IN_PROGRESS";
   ScrapeStatus2["DATA_FETCH_SUCCESS"] = "DATA_FETCH_SUCCESS";
   ScrapeStatus2["DATA_FETCH_FAILED"] = "DATA_FETCH_FAILED";

package/dist/browser.d.cts

@@ -297,6 +297,7 @@ declare enum ScrapeStatus {
     LOGIN_SUCCESS = "LOGIN_SUCCESS",
     LOGIN_FAILED = "LOGIN_FAILED",
     LOGIN_SUCCESS_FETCH_FAILED = "LOGIN_SUCCESS_FETCH_FAILED",
+    LOGIN_SUCCESS_UNSUPPORTED_PROVIDER = "LOGIN_SUCCESS_UNSUPPORTED_PROVIDER",
     DATA_FETCH_IN_PROGRESS = "DATA_FETCH_IN_PROGRESS",
     DATA_FETCH_SUCCESS = "DATA_FETCH_SUCCESS",
     DATA_FETCH_FAILED = "DATA_FETCH_FAILED"

package/dist/browser.d.ts

@@ -297,6 +297,7 @@ declare enum ScrapeStatus {
     LOGIN_SUCCESS = "LOGIN_SUCCESS",
     LOGIN_FAILED = "LOGIN_FAILED",
     LOGIN_SUCCESS_FETCH_FAILED = "LOGIN_SUCCESS_FETCH_FAILED",
+    LOGIN_SUCCESS_UNSUPPORTED_PROVIDER = "LOGIN_SUCCESS_UNSUPPORTED_PROVIDER",
     DATA_FETCH_IN_PROGRESS = "DATA_FETCH_IN_PROGRESS",
     DATA_FETCH_SUCCESS = "DATA_FETCH_SUCCESS",
     DATA_FETCH_FAILED = "DATA_FETCH_FAILED"

package/dist/browser.js

@@ -16,7 +16,7 @@ import {
   UpdateScrapeStatusMessage,
   ValidatePasswordRequestSchema,
   ValidatePasswordResponseSchema
-} from "./chunk-UWBIQBUR.js";
+} from "./chunk-S53TIE72.js";
 export {
   BatchConvexUpdate,
   BatchConvexUpdateSchema,

package/dist/{chunk-UWBIQBUR.js → chunk-S53TIE72.js}

@@ -101,6 +101,7 @@ var ScrapeStatus = /* @__PURE__ */ ((ScrapeStatus2) => {
   ScrapeStatus2["LOGIN_SUCCESS"] = "LOGIN_SUCCESS";
   ScrapeStatus2["LOGIN_FAILED"] = "LOGIN_FAILED";
   ScrapeStatus2["LOGIN_SUCCESS_FETCH_FAILED"] = "LOGIN_SUCCESS_FETCH_FAILED";
+  ScrapeStatus2["LOGIN_SUCCESS_UNSUPPORTED_PROVIDER"] = "LOGIN_SUCCESS_UNSUPPORTED_PROVIDER";
   ScrapeStatus2["DATA_FETCH_IN_PROGRESS"] = "DATA_FETCH_IN_PROGRESS";
   ScrapeStatus2["DATA_FETCH_SUCCESS"] = "DATA_FETCH_SUCCESS";
   ScrapeStatus2["DATA_FETCH_FAILED"] = "DATA_FETCH_FAILED";

package/dist/index.cjs

@@ -30,6 +30,8 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  AnonymousDriverErrorResponseSchema: () => AnonymousDriverErrorResponseSchema,
+  AnonymousDriverResponseSchema: () => AnonymousDriverResponseSchema,
   BatchConvexUpdate: () => BatchConvexUpdate,
   BatchConvexUpdateSchema: () => BatchConvexUpdateSchema,
   BrowserAuthFailureSchema: () => BrowserAuthFailureSchema,
@@ -39,10 +41,12 @@ __export(index_exports, {
   BrowserCrawlFailureSchema: () => BrowserCrawlFailureSchema,
   BrowserCrawlResponseSchema: () => BrowserCrawlResponseSchema,
   BrowserCrawlSuccessSchema: () => BrowserCrawlSuccessSchema,
+  CapturedTrafficEntrySchema: () => CapturedTrafficEntrySchema,
   ConvexDriverSchema: () => ConvexDriverSchema,
   ConvexUpdate: () => ConvexUpdate,
   ConvexUpdateSchema: () => ConvexUpdateSchema,
   CrawlPageSchema: () => CrawlPageSchema,
+  CreateAnonymousDriverBodySchema: () => CreateAnonymousDriverBodySchema,
   DeleteProviderAccountRequestSchema: () => DeleteProviderAccountRequestSchema,
   DeleteProviderAccountResponseSchema: () => DeleteProviderAccountResponseSchema,
   DriverRankingSchema: () => DriverRankingSchema,
@@ -172,144 +176,157 @@ var BatchConvexUpdateSchema = import_zod2.default.object({
 var ConvexUpdate = ConvexUpdateSchema;
 var BatchConvexUpdate = BatchConvexUpdateSchema;
 
-// src/schemas/providerAccounts/update-status.ts
+// src/schemas/drivers/anonymous-driver.ts
 var import_zod3 = __toESM(require("zod"), 1);
+var CreateAnonymousDriverBodySchema = import_zod3.default.object({
+  convex_user_id: import_zod3.default.string().min(1)
+});
+var AnonymousDriverResponseSchema = import_zod3.default.object({
+  driver_id: import_zod3.default.string()
+});
+var AnonymousDriverErrorResponseSchema = import_zod3.default.object({
+  error: import_zod3.default.string()
+});
+
+// src/schemas/providerAccounts/update-status.ts
+var import_zod4 = __toESM(require("zod"), 1);
 var ScrapeStatus = /* @__PURE__ */ ((ScrapeStatus2) => {
   ScrapeStatus2["NEW_LOGIN_RECEIVED"] = "NEW_LOGIN_RECEIVED";
   ScrapeStatus2["LOGIN_IN_PROGRESS"] = "LOGIN_IN_PROGRESS";
   ScrapeStatus2["LOGIN_SUCCESS"] = "LOGIN_SUCCESS";
   ScrapeStatus2["LOGIN_FAILED"] = "LOGIN_FAILED";
   ScrapeStatus2["LOGIN_SUCCESS_FETCH_FAILED"] = "LOGIN_SUCCESS_FETCH_FAILED";
+  ScrapeStatus2["LOGIN_SUCCESS_UNSUPPORTED_PROVIDER"] = "LOGIN_SUCCESS_UNSUPPORTED_PROVIDER";
   ScrapeStatus2["DATA_FETCH_IN_PROGRESS"] = "DATA_FETCH_IN_PROGRESS";
   ScrapeStatus2["DATA_FETCH_SUCCESS"] = "DATA_FETCH_SUCCESS";
   ScrapeStatus2["DATA_FETCH_FAILED"] = "DATA_FETCH_FAILED";
   return ScrapeStatus2;
 })(ScrapeStatus || {});
-var UpdateScrapeStatusMessage = import_zod3.default.object({
-  status: import_zod3.default.nativeEnum(ScrapeStatus).describe("The current status of the scrape process"),
-  correctPassword: import_zod3.default.boolean().optional().describe("Indicates if the provided password was correct, if applicable"),
-  externalProviderAccountId: import_zod3.default.string().describe("The external identifier for the provider account (convex ID or similar)"),
-  username: import_zod3.default.string().describe("The username of the provider account whose status is being updated"),
-  provider_url: import_zod3.default.string().describe("The URL of the ELD provider"),
-  driverCount: import_zod3.default.number().optional().describe("The number of drivers associated with the account, if applicable"),
-  providerSlug: import_zod3.default.string().optional().describe("The slug identifier for the provider")
+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")
 }).describe("Schema for update status messages");
 
 // src/schemas/providerAccounts/validate-password.ts
-var import_zod4 = require("zod");
-var ValidatePasswordRequestSchema = import_zod4.z.object({
-  providerAccountId: import_zod4.z.string().min(1).describe("The unique identifier of the provider account in postgres to validate the password for"),
-  encryptedPassword: import_zod4.z.string().min(1).describe("The encrypted password to validate against the stored password")
+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")
 }).describe("Request schema for validating a provider account password");
-var ValidatePasswordResponseSchema = import_zod4.z.object({
-  isValid: import_zod4.z.boolean().describe("Indicates if the provided password is valid"),
-  driverIds: import_zod4.z.array(import_zod4.z.string()).describe("List of driver IDs associated with the provider account")
+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")
 }).describe("Response schema for password validation");
 
 // src/schemas/providerAccounts/delete-provider-account.ts
-var import_zod5 = require("zod");
-var DeleteProviderAccountRequestSchema = import_zod5.z.object({
-  providerAccountId: import_zod5.z.string().min(1).describe("The external provider account ID to delete")
+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")
 }).describe("Request schema for deleting a provider account");
-var DeleteProviderAccountResponseSchema = import_zod5.z.object({
-  success: import_zod5.z.boolean().describe("Indicates if the provider account was successfully deleted")
+var DeleteProviderAccountResponseSchema = import_zod6.z.object({
+  success: import_zod6.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_zod6 = require("zod");
-var DriverRankingsRequestSchema = import_zod6.z.object({
-  start_date: import_zod6.z.string().describe("Start date for the ranking period (ISO 8601 format)"),
-  end_date: import_zod6.z.string().describe("End date for the ranking period (ISO 8601 format)"),
-  state: import_zod6.z.string().length(2).optional().describe("Optional 2-letter state abbreviation to filter telemetry by location")
+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")
 }).describe("Request schema for driver rankings by miles driven");
-var DriverRankingSchema = import_zod6.z.object({
-  rank: import_zod6.z.number().int().positive().describe("Rank position based on miles driven"),
-  driver_id: import_zod6.z.string().uuid().describe("Unique identifier of the driver"),
-  driver_name: import_zod6.z.string().describe("Name of the driver"),
-  total_miles: import_zod6.z.number().min(0).describe("Total miles driven in the specified period")
+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")
 }).describe("Single driver ranking entry");
-var DriverRankingsResponseSchema = import_zod6.z.array(DriverRankingSchema).describe("Array of driver rankings sorted by miles driven in descending order");
+var DriverRankingsResponseSchema = import_zod7.z.array(DriverRankingSchema).describe("Array of driver rankings sorted by miles driven in descending order");
 
 // src/schemas/telemetry/state-heatmap.ts
-var import_zod7 = require("zod");
-var StateHeatmapRequestSchema = import_zod7.z.object({
-  driver_id: import_zod7.z.string().uuid().describe("Unique identifier of the driver"),
-  start_date: import_zod7.z.string().describe("Start date for the heatmap period (ISO 8601 format)"),
-  end_date: import_zod7.z.string().describe("End date for the heatmap period (ISO 8601 format)")
+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)")
 }).describe("Request schema for driver state heatmap");
-var StateHeatmapEntrySchema = import_zod7.z.object({
-  count: import_zod7.z.number().int().min(0).describe("Number of telemetry points in this state"),
-  percentage: import_zod7.z.number().min(0).max(100).describe("Percentage of total telemetry points in this state")
+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")
 }).describe("Single state entry in the heatmap");
-var StateHeatmapResponseSchema = import_zod7.z.record(
-  import_zod7.z.string().length(2),
+var StateHeatmapResponseSchema = import_zod8.z.record(
+  import_zod8.z.string().length(2),
   StateHeatmapEntrySchema
 ).describe("Record of 2-letter state codes to heatmap entries");
 
 // src/schemas/telemetry/manual-batch.ts
-var import_zod8 = require("zod");
-var ManualBatchEntrySchema = import_zod8.z.object({
-  driver_id: import_zod8.z.string().uuid().describe("Internal UUID of the driver"),
-  timestamp: import_zod8.z.string().datetime().describe("Timestamp of the GPS reading (ISO 8601 format)"),
-  location_latitude: import_zod8.z.number().min(-90).max(90).describe("GPS latitude coordinate"),
-  location_longitude: import_zod8.z.number().min(-180).max(180).describe("GPS longitude coordinate"),
-  location_address: import_zod8.z.string().optional().describe("Optional human-readable address"),
-  vehicle_odometer_miles: import_zod8.z.number().min(0).optional().describe("Optional vehicle odometer reading in miles")
+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")
 }).describe("Single manual telemetry entry");
-var ManualBatchRequestSchema = import_zod8.z.object({
-  entries: import_zod8.z.array(ManualBatchEntrySchema).min(1).max(1e3).describe("Array of manual telemetry entries (1-1000)")
+var ManualBatchRequestSchema = import_zod9.z.object({
+  entries: import_zod9.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_zod8.z.object({
-  id: import_zod8.z.number().int().describe("Telemetry record ID"),
-  driver_id: import_zod8.z.string().uuid().describe("Internal UUID of the driver"),
-  timestamp: import_zod8.z.union([import_zod8.z.string(), import_zod8.z.date()]).describe("Timestamp of the telemetry reading"),
-  remaining_drive_time_in_seconds: import_zod8.z.number().min(0),
-  remaining_shift_time_in_seconds: import_zod8.z.number().min(0),
-  remaining_cycle_time_in_seconds: import_zod8.z.number().min(0),
-  remaining_break_time_in_seconds: import_zod8.z.number().min(0),
-  location_latitude: import_zod8.z.number().min(-90).max(90),
-  location_longitude: import_zod8.z.number().min(-180).max(180),
-  previous_location_latitude: import_zod8.z.number().min(-90).max(90).nullable(),
-  previous_location_longitude: import_zod8.z.number().min(-180).max(180).nullable(),
-  location_address: import_zod8.z.string().nullable(),
-  location_state: import_zod8.z.string().length(2).nullable(),
-  vehicle_odometer_miles: import_zod8.z.number().min(0).nullable(),
-  source: import_zod8.z.enum(["eld", "manual"])
+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(),
+  vehicle_odometer_miles: import_zod9.z.number().min(0).nullable(),
+  source: import_zod9.z.enum(["eld", "manual"])
 }).describe("Telemetry record returned from manual batch insertion");
-var ManualBatchResponseSchema = import_zod8.z.object({
-  message: import_zod8.z.string().describe("Success message"),
-  inserted_count: import_zod8.z.number().int().min(0).describe("Number of telemetry entries inserted"),
-  telemetry: import_zod8.z.array(ManualBatchTelemetrySchema).describe("Array of inserted telemetry records")
+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")
 }).describe("Response schema for manual batch telemetry insertion");
 
 // src/auth-data.ts
-var import_zod9 = require("zod");
-var GomotiveAuthDataSchema = import_zod9.z.object({
-  kind: import_zod9.z.literal("gomotive"),
-  token: import_zod9.z.string(),
-  ownerOperator: import_zod9.z.boolean()
+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 VistaAuthDataSchema = import_zod9.z.object({
-  kind: import_zod9.z.literal("vista"),
-  driverId: import_zod9.z.string(),
-  cookie: import_zod9.z.string()
+var VistaAuthDataSchema = import_zod10.z.object({
+  kind: import_zod10.z.literal("vista"),
+  driverId: import_zod10.z.string(),
+  cookie: import_zod10.z.string()
 });
-var MockAuthDataSchema = import_zod9.z.object({
-  kind: import_zod9.z.literal("mock"),
-  cookie: import_zod9.z.string()
+var MockAuthDataSchema = import_zod10.z.object({
+  kind: import_zod10.z.literal("mock"),
+  cookie: import_zod10.z.string()
 });
-var NoneAuthDataSchema = import_zod9.z.object({
-  kind: import_zod9.z.literal("none")
+var NoneAuthDataSchema = import_zod10.z.object({
+  kind: import_zod10.z.literal("none")
 });
-var ProviderAuthDataSchema = import_zod9.z.discriminatedUnion("kind", [
+var ProviderAuthDataSchema = import_zod10.z.discriminatedUnion("kind", [
   GomotiveAuthDataSchema,
   VistaAuthDataSchema,
   MockAuthDataSchema,
   NoneAuthDataSchema
 ]);
-var LegacyVistaAuthSchema = import_zod9.z.object({
-  driverId: import_zod9.z.string(),
-  cookie: import_zod9.z.string()
+var LegacyVistaAuthSchema = import_zod10.z.object({
+  driverId: import_zod10.z.string(),
+  cookie: import_zod10.z.string()
 });
 function serializeAuthData(data) {
   if (data.kind === "none") {
@@ -345,43 +362,53 @@ function deserializeAuthData(authToken) {
 }
 
 // src/browser-auth.ts
-var import_zod10 = require("zod");
-var BrowserAuthRequestSchema = import_zod10.z.object({
-  providerStub: import_zod10.z.string(),
-  providerUrl: import_zod10.z.string(),
-  username: import_zod10.z.string(),
-  encryptedPassword: import_zod10.z.string()
+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_zod10.z.object({
-  success: import_zod10.z.literal(true),
-  authData: ProviderAuthDataSchema
+var BrowserAuthSuccessSchema = import_zod11.z.object({
+  success: import_zod11.z.literal(true),
+  authData: ProviderAuthDataSchema,
+  capturedTraffic: import_zod11.z.array(CapturedTrafficEntrySchema).optional()
 });
-var BrowserAuthFailureSchema = import_zod10.z.object({
-  success: import_zod10.z.literal(false),
-  error: import_zod10.z.string()
+var BrowserAuthFailureSchema = import_zod11.z.object({
+  success: import_zod11.z.literal(false),
+  error: import_zod11.z.string()
 });
-var BrowserAuthResponseSchema = import_zod10.z.discriminatedUnion("success", [
+var BrowserAuthResponseSchema = import_zod11.z.discriminatedUnion("success", [
   BrowserAuthSuccessSchema,
   BrowserAuthFailureSchema
 ]);
-var CrawlPageSchema = import_zod10.z.object({
-  url: import_zod10.z.string(),
-  html: import_zod10.z.string()
+var CrawlPageSchema = import_zod11.z.object({
+  url: import_zod11.z.string(),
+  html: import_zod11.z.string()
 });
-var BrowserCrawlSuccessSchema = import_zod10.z.object({
-  success: import_zod10.z.literal(true),
-  pages: import_zod10.z.array(CrawlPageSchema)
+var BrowserCrawlSuccessSchema = import_zod11.z.object({
+  success: import_zod11.z.literal(true),
+  pages: import_zod11.z.array(CrawlPageSchema)
 });
-var BrowserCrawlFailureSchema = import_zod10.z.object({
-  success: import_zod10.z.literal(false),
-  error: import_zod10.z.string()
+var BrowserCrawlFailureSchema = import_zod11.z.object({
+  success: import_zod11.z.literal(false),
+  error: import_zod11.z.string()
 });
-var BrowserCrawlResponseSchema = import_zod10.z.discriminatedUnion("success", [
+var BrowserCrawlResponseSchema = import_zod11.z.discriminatedUnion("success", [
   BrowserCrawlSuccessSchema,
   BrowserCrawlFailureSchema
 ]);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  AnonymousDriverErrorResponseSchema,
+  AnonymousDriverResponseSchema,
   BatchConvexUpdate,
   BatchConvexUpdateSchema,
   BrowserAuthFailureSchema,
@@ -391,10 +418,12 @@ var BrowserCrawlResponseSchema = import_zod10.z.discriminatedUnion("success", [
   BrowserCrawlFailureSchema,
   BrowserCrawlResponseSchema,
   BrowserCrawlSuccessSchema,
+  CapturedTrafficEntrySchema,
   ConvexDriverSchema,
   ConvexUpdate,
   ConvexUpdateSchema,
   CrawlPageSchema,
+  CreateAnonymousDriverBodySchema,
   DeleteProviderAccountRequestSchema,
   DeleteProviderAccountResponseSchema,
   DriverRankingSchema,