@cardog/api 0.1.1

package/dist/react/index.mjs

@@ -0,0 +1,1964 @@
+import { useQuery, useInfiniteQuery } from '@tanstack/react-query';
+import 'axios';
+import { z } from 'zod';
+
+// src/react/hooks.ts
+var MAX_PAGE_SIZE = 250;
+var DEFAULT_RADIUS = 50;
+var MAX_RADIUS = 500;
+z.object({
+  make: z.string(),
+  model: z.string(),
+  year: z.coerce.number().int().min(1900).max(2050)
+});
+z.string().length(17, "VIN must be exactly 17 characters").regex(/^[A-HJ-NPR-Z0-9]{17}$/, "Invalid VIN format");
+var paginationSchema = z.object({
+  page: z.coerce.number().int().min(1, "Page number must be 1 or greater"),
+  // .default(1),
+  limit: z.coerce.number().int().min(1, "Page size must be at least 1").max(MAX_PAGE_SIZE, `Page size cannot exceed ${MAX_PAGE_SIZE}`)
+  // .default(DEFAULT_PAGE_SIZE),
+});
+var locationSchema = z.object({
+  lat: z.coerce.number().min(-90, "Latitude must be between -90 and 90").max(90, "Latitude must be between -90 and 90"),
+  lng: z.coerce.number().min(-180, "Longitude must be between -180 and 180").max(180, "Longitude must be between -180 and 180"),
+  radius: z.coerce.number().min(1, "Radius must be at least 1 km").max(MAX_RADIUS, `Radius cannot exceed ${MAX_RADIUS} km`).default(DEFAULT_RADIUS)
+});
+var rangeSchema = (min, max) => z.object({
+  min: z.number().int().min(min).optional(),
+  max: z.number().int().max(max).optional()
+});
+var sortDirectionsSchema = z.string().transform((val) => val.toLowerCase()).pipe(z.enum(["asc", "desc"]));
+var idSchema = z.string();
+var timestampSchema = z.string().datetime();
+var sellerSchema = z.object({
+  id: idSchema,
+  slug: z.string().optional(),
+  // TODO: Remove soon.
+  type: z.string(),
+  name: z.string(),
+  email: z.string().nullable(),
+  phone: z.string().nullable(),
+  addressId: z.number().nullable(),
+  dealershipId: idSchema.nullable(),
+  // Google My Business enhanced fields
+  gmbPhone: z.string().nullable(),
+  gmbRating: z.string().nullable(),
+  gmbReviewCount: z.number().nullable(),
+  createdAt: timestampSchema,
+  updatedAt: timestampSchema,
+  deactivatedAt: timestampSchema.nullable()
+});
+var dealershipSchema = z.object({
+  id: idSchema,
+  name: z.string(),
+  primaryDomain: z.string(),
+  metadata: z.any(),
+  isVerified: z.boolean(),
+  createdAt: timestampSchema,
+  updatedAt: timestampSchema
+});
+var addressSchema = z.object({
+  id: z.number(),
+  street: z.string(),
+  city: z.string(),
+  state: z.string(),
+  postalCode: z.string(),
+  country: z.string(),
+  latitude: z.string(),
+  longitude: z.string(),
+  location: z.object({
+    x: z.number(),
+    y: z.number()
+  }),
+  createdAt: timestampSchema,
+  updatedAt: timestampSchema
+});
+var mediaSchema = z.object({
+  id: z.number(),
+  listingId: idSchema.nullable(),
+  type: z.string(),
+  url: z.string(),
+  make: z.string().nullable(),
+  model: z.string().nullable(),
+  year: z.number().nullable(),
+  width: z.number().nullable(),
+  height: z.number().nullable(),
+  sizeBytes: z.number().nullable(),
+  mimeType: z.string().nullable(),
+  sourceUri: z.string().nullable(),
+  sourceType: z.string().nullable(),
+  metadata: z.any().nullable(),
+  createdAt: timestampSchema.nullable(),
+  updatedAt: timestampSchema.nullable(),
+  removedAt: timestampSchema.nullable()
+});
+var vehicleReportSchema = z.object({
+  id: z.string(),
+  vin: z.string(),
+  url: z.string().nullable(),
+  version: z.string(),
+  type: z.string(),
+  data: z.any(),
+  // jsonb data
+  createdAt: timestampSchema,
+  updatedAt: timestampSchema
+});
+var patternMatchSchema = z.object({
+  element: z.string(),
+  code: z.string(),
+  attributeId: z.union([z.string(), z.number(), z.null()]),
+  value: z.string().nullable(),
+  confidence: z.number(),
+  positions: z.array(z.number()),
+  schema: z.string(),
+  metadata: z.object({
+    lookupTable: z.string().nullable().optional(),
+    groupName: z.string().nullable().optional(),
+    elementWeight: z.number().nullable().optional(),
+    patternType: z.enum(["VDS", "VIS"]).nullable().optional(),
+    rawPattern: z.string().nullable().optional(),
+    matchDetails: z.object({
+      exactMatches: z.number().optional(),
+      wildcardMatches: z.number().optional(),
+      totalPositions: z.number().optional()
+    }).nullable().optional()
+  }).optional()
+});
+z.object({
+  vin: z.string(),
+  valid: z.boolean(),
+  components: z.object({
+    checkDigit: z.object({
+      position: z.number(),
+      actual: z.string(),
+      expected: z.string().optional(),
+      isValid: z.boolean()
+    }).optional(),
+    modelYear: z.object({
+      year: z.number(),
+      source: z.enum(["position", "override", "calculated"]),
+      confidence: z.number()
+    }).optional(),
+    wmi: z.object({
+      code: z.string(),
+      manufacturer: z.string(),
+      country: z.string(),
+      vehicleType: z.string(),
+      region: z.string(),
+      make: z.string()
+    }).optional(),
+    vds: z.object({
+      raw: z.string(),
+      patterns: z.array(patternMatchSchema)
+    }).optional(),
+    vis: z.object({
+      raw: z.string(),
+      patterns: z.array(patternMatchSchema)
+    }).optional(),
+    vehicle: z.object({
+      make: z.string(),
+      model: z.string(),
+      year: z.number(),
+      series: z.string().optional(),
+      trim: z.string().optional(),
+      bodyStyle: z.string().optional(),
+      driveType: z.string().optional(),
+      engineType: z.string().optional(),
+      fuelType: z.string().optional(),
+      transmission: z.string().optional(),
+      doors: z.string().optional(),
+      gvwr: z.string().optional(),
+      manufacturer: z.string().optional()
+    }).optional(),
+    plant: z.object({
+      country: z.string(),
+      city: z.string().optional(),
+      manufacturer: z.string().optional(),
+      code: z.string()
+    }).optional(),
+    engine: z.object({
+      type: z.string().optional(),
+      model: z.string().optional(),
+      cylinders: z.string().optional(),
+      displacement: z.string().optional(),
+      fuel: z.string().optional(),
+      power: z.string().optional()
+    }).optional()
+  }),
+  errors: z.array(z.unknown()),
+  patterns: z.array(patternMatchSchema).optional(),
+  metadata: z.object({
+    processingTime: z.number(),
+    confidence: z.number(),
+    schemaVersion: z.string(),
+    matchedSchema: z.string().optional(),
+    totalPatterns: z.number().optional(),
+    rawRecords: z.array(z.unknown()).optional(),
+    queries: z.array(
+      z.object({
+        sql: z.string(),
+        params: z.array(z.unknown()),
+        timing: z.number()
+      })
+    ).optional()
+  }).optional()
+});
+z.object({
+  // TODO: Implement this properly with correct structure
+  variants: z.array(z.unknown())
+  // Temporary until research schemas are ported
+});
+z.object({
+  result: z.string(),
+  success: z.boolean()
+});
+z.object({
+  vehicle: z.string().describe("Human-readable vehicle label, e.g. '2022 Honda Civic'"),
+  totalListings: z.number().describe("Count of active listings in the cohort"),
+  avgPrice: z.number().describe("Average listing price (rounded)"),
+  medianPrice: z.number().describe("Median listing price (rounded)"),
+  minPrice: z.number().describe("Minimum listing price"),
+  maxPrice: z.number().describe("Maximum listing price"),
+  q1Price: z.number().describe("25th percentile price (rounded)"),
+  q3Price: z.number().describe("75th percentile price (rounded)"),
+  avgDaysOnMarket: z.number().describe("Average days on market across cohort (rounded)"),
+  avgOdometer: z.number().describe("Average odometer reading across cohort (rounded)")
+});
+var priceDistributionSchema = z.object({
+  bucketMin: z.number().describe("Inclusive lower bound of the bucket"),
+  bucketMax: z.number().describe(
+    "Inclusive upper bound for the last bucket, exclusive for others"
+  ),
+  count: z.number().describe("Number of listings within the bucket bounds"),
+  percentage: z.number().describe("Percentage of total listings that fall into the bucket")
+}).describe("A single price histogram bucket.");
+z.object({
+  distribution: z.array(priceDistributionSchema).describe("Price distribution for a make/model/year cohort")
+});
+var odometerSegmentSchema = z.object({
+  odometerMin: z.number().describe("Inclusive lower bound of odometer segment"),
+  odometerMax: z.number().describe("Inclusive upper bound for last segment, exclusive for others"),
+  listings: z.number().describe("Number of listings within this odometer band"),
+  avgPrice: z.number().describe("Average price within the segment (rounded)"),
+  avgOdometer: z.number().describe("Average odometer within the segment (rounded)"),
+  minPrice: z.number().describe("Minimum observed price in the segment"),
+  maxPrice: z.number().describe("Maximum observed price in the segment")
+});
+z.object({
+  segments: z.array(odometerSegmentSchema).describe("Odometer analysis for a make/model/year cohort")
+});
+var geographicMarketSchema = z.object({
+  state: z.string().describe("Two-letter region code (e.g. US state or CA province)"),
+  listings: z.number().describe("Number of listings in the region"),
+  avgPrice: z.number().describe("Average listing price in region (rounded)"),
+  medianPrice: z.number().describe("Median listing price in region (rounded)"),
+  avgOdometer: z.number().describe("Average odometer reading in region (rounded)"),
+  avgDaysOnMarket: z.number().describe("Average days on market in region (rounded)"),
+  centerLat: z.number().describe("Approximate geographic center latitude of listings in region"),
+  centerLng: z.number().describe("Approximate geographic center longitude of listings in region")
+});
+z.object({
+  markets: z.array(geographicMarketSchema).describe("Geographic analysis for a make/model/year cohort")
+});
+var timeSeriesPointSchema = z.object({
+  period: z.coerce.date().describe("Start of period (Monday for week, first day for month)"),
+  newListings: z.number().describe("Number of new listings observed within the period"),
+  avgPrice: z.number().describe("Period average listing price (rounded)"),
+  avgOdometer: z.number().describe("Period average odometer (rounded)"),
+  priceChangePct: z.number().describe(
+    "Price change vs previous period in percent (one decimal), if applicable"
+  )
+});
+z.object({
+  trends: z.array(timeSeriesPointSchema).describe("Time series data for a make/model/year cohort")
+});
+z.object({
+  similarListings: z.array(
+    z.object({
+      id: z.string(),
+      price: z.number(),
+      odometer: z.number(),
+      vin: z.string(),
+      year: z.number(),
+      make: z.string(),
+      model: z.string(),
+      trim: z.string().nullable(),
+      listingDate: z.coerce.date(),
+      daysOnMarket: z.number(),
+      location: z.string().nullable()
+    })
+  ),
+  priceAnalysis: z.object({
+    count: z.number(),
+    min: z.number(),
+    max: z.number(),
+    average: z.number(),
+    median: z.number(),
+    standardDev: z.number(),
+    priceDistribution: z.array(
+      z.object({
+        range: z.string(),
+        count: z.number(),
+        percentage: z.number()
+      })
+    )
+  }),
+  marketTrends: z.object({
+    averageDaysOnMarket: z.number(),
+    priceTrend: z.number(),
+    listingVolume: z.number()
+  }),
+  pricingGuidance: z.object({
+    suggested: z.number(),
+    confidence: z.enum(["low", "medium", "high"])
+  })
+});
+z.object({
+  id: z.string().describe("Listing Id"),
+  price: z.number().describe("Listing price"),
+  odometer: z.number().describe("Odometer reading"),
+  trim: z.string().nullable().describe("Vehicle trim"),
+  daysonmarket: z.coerce.number().describe("Days on market"),
+  city: z.string().nullable().describe("City"),
+  state: z.string().nullable().describe("State"),
+  pricepercentile: z.coerce.number().describe("Price percentile"),
+  pricevsmedian: z.coerce.number().describe("Price vs median"),
+  pricecategory: z.string().describe("Price category"),
+  marketaverage: z.coerce.number().describe("Market average price")
+});
+z.object({
+  overview: z.object({
+    totalListings: z.number(),
+    avgPrice: z.number(),
+    medianPrice: z.number(),
+    minPrice: z.number(),
+    maxPrice: z.number(),
+    stdDev: z.number()
+  }),
+  priceDistribution: z.array(
+    z.object({
+      range: z.string(),
+      count: z.number()
+    })
+  ).describe(
+    "Distribution of price ranges, e.g. [{ 'range': '$10,000 - $15,000', 'count': 100 }, { 'range': '$15,000 - $20,000', 'count': 50 }]"
+  ),
+  makeDistribution: z.array(
+    z.object({
+      make: z.string(),
+      count: z.number()
+    })
+  ).describe(
+    "Distribution of makes, e.g. [{ 'make': 'Honda', 'count': 100 }, { 'make': 'Toyota', 'count': 50 }]"
+  ),
+  modelDistribution: z.record(
+    z.string(),
+    z.array(
+      z.object({
+        model: z.string(),
+        count: z.number()
+      })
+    )
+  ).describe(
+    "Distribution of models by make, e.g. { 'Honda': [{ 'model': 'Civic', 'count': 100 }, { 'model': 'Accord', 'count': 50 }] }"
+  ),
+  yearDistribution: z.array(
+    z.object({
+      range: z.string(),
+      count: z.number()
+    })
+  ),
+  daysOnMarketByPrice: z.array(
+    z.object({
+      range: z.string(),
+      avgDays: z.number()
+    })
+  )
+});
+var trimBreakdownSchema = z.object({
+  trim: z.string().nullable().describe("Vehicle trim name"),
+  listings: z.number().describe("Number of listings with this trim"),
+  avgPrice: z.number().describe("Average listing price for this trim (rounded)"),
+  medianPrice: z.number().describe("Median listing price for this trim (rounded)"),
+  minPrice: z.number().describe("Minimum listing price for this trim"),
+  maxPrice: z.number().describe("Maximum listing price for this trim"),
+  avgOdometer: z.number().describe("Average odometer reading for this trim (rounded)"),
+  avgDaysOnMarket: z.number().describe("Average days on market for this trim (rounded)"),
+  priceVsMarket: z.number().describe("Percentage difference from overall market average")
+});
+z.object({
+  vehicle: z.string().describe("Human-readable vehicle label, e.g. '2022 Honda Civic'"),
+  totalListings: z.number().describe("Total number of listings across all trims"),
+  overallAvgPrice: z.number().describe("Overall average price across all trims"),
+  overallMedianPrice: z.number().describe("Overall median price across all trims"),
+  trims: z.array(trimBreakdownSchema).describe("Breakdown of prices by trim")
+});
+z.object({
+  make: z.string().describe("Vehicle make (e.g., 'Toyota')"),
+  model: z.string().describe("Vehicle model (e.g., 'Camry')"),
+  year: z.number().int().min(1900).max(2100).describe("Model year"),
+  lat: z.number().min(-90).max(90).describe("Latitude of search center"),
+  lng: z.number().min(-180).max(180).describe("Longitude of search center"),
+  radius: z.number().min(10).max(500).default(75).describe("Search radius in kilometers (default 75km)")
+});
+var marketComparisonSchema = z.object({
+  localAvgPrice: z.number().describe("Local average price"),
+  nationalAvgPrice: z.number().describe("National average price"),
+  priceDifferencePercent: z.number().describe("Percentage difference (positive = local is higher)"),
+  localListings: z.number().describe("Number of local listings"),
+  nationalListings: z.number().describe("Total national listings")
+});
+z.object({
+  vehicle: z.string().describe("Vehicle label (e.g., '2022 Toyota Camry')"),
+  location: z.object({
+    city: z.string().nullable().describe("Nearest city name"),
+    province: z.string().nullable().describe("Province/state"),
+    lat: z.number().describe("Search center latitude"),
+    lng: z.number().describe("Search center longitude"),
+    radiusKm: z.number().describe("Search radius used")
+  }),
+  totalListings: z.number().describe("Total listings found in area"),
+  pricing: z.object({
+    avgPrice: z.number().describe("Average listing price in the area"),
+    medianPrice: z.number().describe("Median listing price in the area"),
+    minPrice: z.number().describe("Minimum listing price found"),
+    maxPrice: z.number().describe("Maximum listing price found"),
+    q1Price: z.number().describe("25th percentile price"),
+    q3Price: z.number().describe("75th percentile price")
+  }),
+  comparison: marketComparisonSchema,
+  priceDistribution: z.array(
+    z.object({
+      range: z.string().describe("Price range label"),
+      count: z.number().describe("Number of listings in this range")
+    })
+  ),
+  odometer: z.object({
+    avgOdometer: z.number().describe("Average odometer reading"),
+    minOdometer: z.number().describe("Minimum odometer"),
+    maxOdometer: z.number().describe("Maximum odometer")
+  }),
+  daysOnMarket: z.object({
+    avg: z.number().describe("Average days on market"),
+    median: z.number().describe("Median days on market")
+  })
+});
+var demandMatrixCellSchema = z.object({
+  count: z.number().describe("Number of listings in this cell"),
+  avgPrice: z.number().describe("Average price in this cell"),
+  avgDaysToSell: z.number().describe("Average days to sell in this cell")
+});
+var demandMatrixRowSchema = z.object({
+  priceBand: z.string().describe("Price band label (e.g., 'P10-P25')"),
+  priceMin: z.number().describe("Minimum price in this band"),
+  priceMax: z.number().describe("Maximum price in this band"),
+  cells: z.array(demandMatrixCellSchema).describe("Cells for each turn rate band")
+});
+z.object({
+  vehicle: z.string().describe("Vehicle label (e.g., '2022 Honda Civic')"),
+  totalListings: z.number().describe("Total listings analyzed"),
+  totalSold: z.number().describe("Total sold/removed listings used for turn rate"),
+  turnRateBands: z.array(z.string()).describe("Turn rate band labels (e.g., ['0-7d', '7-14d', ...])"),
+  priceBands: z.array(demandMatrixRowSchema).describe("Price band rows with cell data"),
+  summary: z.object({
+    medianPrice: z.number().describe("Median price across all listings"),
+    medianDaysToSell: z.number().describe("Median days to sell"),
+    fastestPriceBand: z.string().nullable().describe("Price band with fastest turn"),
+    sweetSpot: z.object({
+      priceBand: z.string(),
+      turnRateBand: z.string(),
+      count: z.number()
+    }).nullable().describe("Optimal price/turn rate combination")
+  })
+});
+var sortFieldMap = {
+  price: "price",
+  year: "year",
+  odometer: "odometer",
+  createdat: "createdAt",
+  random: "random",
+  score: "score"
+};
+var listingSortFieldsSchema = z.string().transform((val) => sortFieldMap[val.toLowerCase()]).refine((val) => val !== void 0, {
+  message: "Invalid sort field. Expected: price, year, odometer, createdAt, random, or score"
+});
+var listingSortSchema = z.object({
+  field: listingSortFieldsSchema,
+  direction: sortDirectionsSchema
+});
+var listingFiltersSchema = z.object({
+  ids: z.array(z.string()).optional().describe('An array of listing IDs to fetch directly. Example: ["abc-123", "def-456"]'),
+  makes: z.array(z.string()).optional().describe('An array of vehicle makes. Example: ["Toyota", "Honda"]'),
+  models: z.record(z.string(), z.array(z.string())).describe(
+    'An object with vehicle makes as keys and an array of models as values. Example: {"Toyota": ["Corolla", "Camry"], "Honda": ["Civic"]}'
+  ).optional(),
+  trims: z.array(z.string()).optional().describe('An array of vehicle trims. Example: ["LE", "SE"]'),
+  year: rangeSchema(1900, 2030).optional().describe(
+    "An object with 'min' and 'max' properties representing the year range. Example: {min: 2010, max: 2020}"
+  ),
+  price: rangeSchema(0, 1e6).optional().describe(
+    "An object with 'min' and 'max' properties representing the price range. Example: {min: 10000, max: 20000}"
+  ),
+  odometer: rangeSchema(0, 1e6).optional().describe(
+    "An object with 'min' and 'max' properties representing the odometer range. Example: {min: 0, max: 50000}"
+  ),
+  saleTypes: z.array(z.string()).optional().describe('An array of sale types. Example: ["new", "used"]'),
+  bodyStyles: z.array(z.string()).optional().describe('An array of body styles. Example: ["SUV", "Sedan"]'),
+  fuelTypes: z.array(z.string()).optional().describe(
+    'An array of fuel types. Example: ["Gasoline", "Electric", "Hybrid"]'
+  ),
+  exteriorColors: z.array(z.string()).optional().describe('An array of exterior colors. Example: ["Red", "Blue"]'),
+  interiorColors: z.array(z.string()).optional().describe('An array of interior colors. Example: ["Black", "Beige"]'),
+  location: locationSchema.optional(),
+  sellers: z.array(z.string()).optional().describe("An array of seller IDs. Example: ['123', '456']"),
+  createdAfter: timestampSchema.optional().describe("Filter listings created after this timestamp"),
+  createdBefore: timestampSchema.optional().describe("Filter listings created before this timestamp"),
+  updatedAfter: timestampSchema.optional().describe("Filter listings updated after this timestamp"),
+  updatedBefore: timestampSchema.optional().describe("Filter listings updated before this timestamp")
+});
+var listingQuerySchema = z.object({
+  filters: listingFiltersSchema.optional(),
+  sort: listingSortSchema.optional(),
+  pagination: paginationSchema.optional()
+});
+var listingSchema = z.object({
+  id: z.string(),
+  vin: z.string(),
+  sellerId: z.string(),
+  websiteDomain: z.string(),
+  price: z.number().positive(),
+  currency: z.string().default("USD"),
+  odometer: z.number().optional(),
+  sourceUri: z.string(),
+  stockNumber: z.string().optional().nullable(),
+  score: z.number(),
+  status: z.string(),
+  mediaCount: z.number(),
+  createdAt: timestampSchema,
+  updatedAt: timestampSchema,
+  removedAt: timestampSchema.nullable(),
+  make: z.string(),
+  model: z.string(),
+  year: z.number().int().min(1900).max(2030),
+  trim: z.string().optional().nullable(),
+  bodyStyle: z.string().optional().nullable(),
+  fuelType: z.string().optional().nullable(),
+  driveTrain: z.string().optional().nullable(),
+  transmission: z.string().optional().nullable(),
+  engineSize: z.string().optional().nullable(),
+  horsepower: z.string().optional().nullable(),
+  torque: z.string().optional().nullable(),
+  exteriorColor: z.string().optional().nullable(),
+  interiorColor: z.string().optional().nullable(),
+  condition: z.enum(["new", "used", "certified"]),
+  seller: sellerSchema,
+  media: z.array(mediaSchema),
+  dealership: dealershipSchema,
+  location: addressSchema,
+  report: vehicleReportSchema.nullable().optional()
+});
+z.object({
+  listings: z.array(listingSchema),
+  pagination: paginationSchema,
+  sort: listingSortSchema.optional(),
+  filters: listingFiltersSchema
+});
+z.object({
+  count: z.number().int().min(0),
+  filters: listingFiltersSchema
+});
+var facetItemSchema = z.object({
+  value: z.string(),
+  count: z.number().int().min(0)
+});
+var histogramBucketSchema = z.object({
+  min: z.number(),
+  max: z.number(),
+  count: z.number().int().min(0)
+});
+z.object({
+  makes: z.array(facetItemSchema),
+  models: z.array(
+    z.object({
+      make: z.string(),
+      model: z.string(),
+      count: z.number().int().min(0)
+    })
+  ),
+  bodyStyles: z.array(facetItemSchema),
+  fuelTypes: z.array(facetItemSchema),
+  saleTypes: z.array(facetItemSchema),
+  exteriorColors: z.array(facetItemSchema),
+  years: z.object({
+    min: z.number().int(),
+    max: z.number().int()
+  }),
+  prices: z.object({
+    min: z.number(),
+    max: z.number(),
+    histogram: z.array(histogramBucketSchema)
+  }),
+  odometer: z.object({
+    min: z.number(),
+    max: z.number(),
+    histogram: z.array(histogramBucketSchema)
+  }),
+  totalCount: z.number().int().min(0),
+  filters: listingFiltersSchema
+});
+var sellerTypeSchema = z.enum([
+  "individual",
+  "dealership",
+  "auction",
+  "aggregator"
+]);
+z.object({
+  lat: z.coerce.number().min(-90).max(90).optional(),
+  lng: z.coerce.number().min(-180).max(180).optional(),
+  radius: z.coerce.number().min(0.1).max(500).optional(),
+  name: z.string().optional(),
+  country: z.string().optional(),
+  sellerType: sellerTypeSchema.optional(),
+  websiteDomain: z.string().optional(),
+  hasActiveListings: z.preprocess(
+    (val) => val === "true" ? true : val === "false" ? false : val,
+    z.boolean().default(false)
+  ),
+  limit: z.coerce.number().int().min(1).max(250).default(50),
+  offset: z.coerce.number().int().min(0).default(0)
+});
+z.object({
+  id: z.string()
+});
+var locationAddressSchema = z.object({
+  id: z.number().nullable(),
+  street: z.string().nullable(),
+  city: z.string().nullable(),
+  state: z.string().nullable(),
+  postalCode: z.string().nullable(),
+  country: z.string().nullable(),
+  latitude: z.string().nullable(),
+  longitude: z.string().nullable()
+}).nullable();
+var locationDealershipSchema = z.object({
+  id: z.string(),
+  name: z.string(),
+  primaryDomain: z.string().nullable()
+}).nullable();
+var locationResultSchema = z.object({
+  id: z.string(),
+  name: z.string(),
+  slug: z.string(),
+  type: sellerTypeSchema,
+  email: z.string().nullable(),
+  phone: z.string().nullable(),
+  // Google My Business enhanced fields
+  gmbPhone: z.string().nullable().optional(),
+  gmbRating: z.string().nullable().optional(),
+  gmbReviewCount: z.number().nullable().optional(),
+  address: locationAddressSchema,
+  dealership: locationDealershipSchema,
+  totalActiveListings: z.number(),
+  distance: z.number().optional()
+});
+z.object({
+  results: z.array(locationResultSchema),
+  meta: z.object({
+    total: z.number(),
+    params: z.any()
+  })
+});
+locationResultSchema.omit({
+  distance: true
+});
+var ConnectorType = /* @__PURE__ */ ((ConnectorType2) => {
+  ConnectorType2[ConnectorType2["TYPE_1"] = 1] = "TYPE_1";
+  ConnectorType2[ConnectorType2["TYPE_2"] = 25] = "TYPE_2";
+  ConnectorType2[ConnectorType2["CCS_TYPE_1"] = 33] = "CCS_TYPE_1";
+  ConnectorType2[ConnectorType2["CCS_TYPE_2"] = 32] = "CCS_TYPE_2";
+  ConnectorType2[ConnectorType2["CHADEMO"] = 2] = "CHADEMO";
+  ConnectorType2[ConnectorType2["TESLA"] = 27] = "TESLA";
+  ConnectorType2[ConnectorType2["NACS"] = 31] = "NACS";
+  ConnectorType2[ConnectorType2["WALL"] = 28] = "WALL";
+  ConnectorType2[ConnectorType2["TYPE_3"] = 3] = "TYPE_3";
+  ConnectorType2[ConnectorType2["IEC_60309"] = 8] = "IEC_60309";
+  ConnectorType2[ConnectorType2["DOMESTIC"] = 10] = "DOMESTIC";
+  ConnectorType2[ConnectorType2["COMMANDO"] = 11] = "COMMANDO";
+  ConnectorType2[ConnectorType2["GB_T"] = 13] = "GB_T";
+  ConnectorType2[ConnectorType2["UNSPECIFIED"] = 0] = "UNSPECIFIED";
+  return ConnectorType2;
+})(ConnectorType || {});
+var ChargingLevel = /* @__PURE__ */ ((ChargingLevel2) => {
+  ChargingLevel2[ChargingLevel2["LEVEL_1"] = 1] = "LEVEL_1";
+  ChargingLevel2[ChargingLevel2["LEVEL_2"] = 2] = "LEVEL_2";
+  ChargingLevel2[ChargingLevel2["LEVEL_3"] = 3] = "LEVEL_3";
+  ChargingLevel2[ChargingLevel2["UNSPECIFIED"] = 0] = "UNSPECIFIED";
+  return ChargingLevel2;
+})(ChargingLevel || {});
+var StationStatus = /* @__PURE__ */ ((StationStatus2) => {
+  StationStatus2["OPERATIONAL"] = "Operational";
+  StationStatus2["PLANNED"] = "Planned";
+  StationStatus2["NON_OPERATIONAL"] = "NonOperational";
+  StationStatus2["UNKNOWN"] = "Unknown";
+  return StationStatus2;
+})(StationStatus || {});
+z.nativeEnum(ConnectorType);
+z.nativeEnum(ChargingLevel);
+z.nativeEnum(StationStatus);
+var chargingConnectionSchema = z.object({
+  connectionTypeId: z.nativeEnum(ConnectorType),
+  connectionType: z.string(),
+  powerKW: z.number(),
+  currentType: z.enum(["AC", "DC"]),
+  level: z.nativeEnum(ChargingLevel),
+  voltage: z.number(),
+  amperage: z.number(),
+  pricing: z.object({
+    costPerKWh: z.number().nullable(),
+    costPerMinute: z.number().nullable(),
+    costPerSession: z.number().nullable(),
+    currency: z.string()
+  }).optional()
+});
+var chargingStationSchema = z.object({
+  id: z.string(),
+  name: z.string(),
+  address: z.object({
+    addressLine1: z.string(),
+    addressLine2: z.string().optional().nullable(),
+    town: z.string(),
+    stateOrProvince: z.string(),
+    postcode: z.string(),
+    countryCode: z.string()
+  }),
+  location: z.object({
+    latitude: z.number(),
+    longitude: z.number()
+  }),
+  connections: z.array(chargingConnectionSchema),
+  status: z.nativeEnum(StationStatus),
+  network: z.string().nullable(),
+  operator: z.string().nullable(),
+  dateCreated: z.string(),
+  dateLastVerified: z.string().nullable(),
+  usage: z.string().nullable(),
+  supportPhone: z.string().nullable(),
+  supportUrl: z.string().nullable(),
+  isMembershipRequired: z.boolean(),
+  isPayAtLocation: z.boolean(),
+  photos: z.array(z.string()).optional(),
+  rating: z.number().optional()
+});
+z.object({
+  country: z.string().default("US").describe("The country to search in"),
+  region: z.string().optional().describe("The region to search in"),
+  lat: z.coerce.number().optional().describe("The latitude to search in"),
+  lng: z.coerce.number().optional().describe("The longitude to search in"),
+  radius: z.coerce.number().optional().describe("The radius to search in"),
+  connector: z.array(z.nativeEnum(ConnectorType)).optional().describe("The connector types to search for"),
+  minPower: z.coerce.number().optional().describe("The minimum power to search for"),
+  limit: z.coerce.number().optional().describe("The number of results to return"),
+  includeInactive: z.boolean().optional().describe("Whether to include inactive stations"),
+  includePhotos: z.coerce.boolean().optional().describe("Whether to include photos")
+});
+z.object({
+  stations: z.array(chargingStationSchema),
+  totalCount: z.number(),
+  location: z.object({
+    name: z.string().nullable(),
+    countryCode: z.string(),
+    regionCode: z.string().nullable()
+  })
+});
+z.object({
+  id: z.string().min(1)
+});
+z.object({
+  station: chargingStationSchema
+});
+var FuelType = /* @__PURE__ */ ((FuelType2) => {
+  FuelType2[FuelType2["REGULAR"] = 1] = "REGULAR";
+  FuelType2[FuelType2["MIDGRADE"] = 2] = "MIDGRADE";
+  FuelType2[FuelType2["PREMIUM"] = 3] = "PREMIUM";
+  FuelType2[FuelType2["DIESEL"] = 4] = "DIESEL";
+  FuelType2[FuelType2["E85"] = 5] = "E85";
+  FuelType2[FuelType2["E15"] = 6] = "E15";
+  FuelType2[FuelType2["PROPANE"] = 7] = "PROPANE";
+  FuelType2[FuelType2["BIODIESEL"] = 8] = "BIODIESEL";
+  FuelType2[FuelType2["CNG"] = 9] = "CNG";
+  FuelType2[FuelType2["LNG"] = 10] = "LNG";
+  return FuelType2;
+})(FuelType || {});
+var fuelTypeEnum = z.nativeEnum(FuelType);
+var fuelStationSchema = z.object({
+  id: z.string(),
+  name: z.string(),
+  address: z.object({
+    line1: z.string(),
+    line2: z.string().optional(),
+    locality: z.string(),
+    region: z.string(),
+    postalCode: z.string(),
+    country: z.string()
+  }),
+  location: z.object({
+    latitude: z.number(),
+    longitude: z.number()
+  }),
+  price: z.object({
+    credit: z.number().nullable(),
+    cash: z.number().nullable(),
+    postedTime: z.string().nullable(),
+    formattedPrice: z.string().nullable(),
+    reportedBy: z.string().nullable()
+  }),
+  amenities: z.array(z.string()),
+  brands: z.array(
+    z.object({
+      id: z.string(),
+      name: z.string(),
+      type: z.string(),
+      imageUrl: z.string().optional().nullable()
+    })
+  ),
+  rating: z.number().nullable(),
+  ratingsCount: z.number(),
+  reviews: z.array(
+    z.object({
+      rating: z.number(),
+      review: z.string(),
+      nickname: z.string(),
+      date: z.string()
+    })
+  ),
+  fuels: z.array(z.string()),
+  isOpen: z.boolean().optional()
+});
+z.object({
+  current: z.number().nullable(),
+  average: z.number().nullable(),
+  postedTime: z.string().nullable(),
+  unit: z.string(),
+  isMetric: z.boolean(),
+  fuelType: fuelTypeEnum,
+  fuelName: z.string(),
+  location: z.object({
+    name: z.string().nullable(),
+    countryCode: z.string(),
+    regionCode: z.string().nullable(),
+    locationType: z.string().nullable(),
+    nearbyLocalities: z.array(z.string())
+  }),
+  history: z.array(
+    z.object({
+      date: z.string(),
+      price: z.number(),
+      formattedPrice: z.string()
+    })
+  ),
+  stations: z.array(fuelStationSchema)
+});
+z.object({
+  // Coordinate-based search (preferred)
+  lat: z.coerce.number().min(-90).max(90).optional(),
+  lng: z.coerce.number().min(-180).max(180).optional(),
+  radius: z.coerce.number().min(1).max(100).optional().default(10),
+  // km
+  // Region-based search (legacy)
+  country: z.string().optional().default("US"),
+  region: z.string().optional(),
+  city: z.string().optional(),
+  // Filter options
+  fuelType: fuelTypeEnum.optional().default(1 /* REGULAR */),
+  limit: z.coerce.number().min(1).max(50).optional().default(50),
+  distanceFormat: z.enum(["auto", "mi", "km"]).optional().default("auto")
+}).refine(
+  (data) => {
+    const hasCoords = data.lat !== void 0 && data.lng !== void 0;
+    const hasRegion = data.country !== void 0;
+    return hasCoords || hasRegion;
+  },
+  {
+    message: "Either lat/lng coordinates or country must be provided"
+  }
+).refine(
+  (data) => {
+    if (data.lat !== void 0 && data.lng === void 0) {
+      return false;
+    }
+    if (data.lng !== void 0 && data.lat === void 0) {
+      return false;
+    }
+    return true;
+  },
+  {
+    message: "Both lat and lng must be provided together"
+  }
+);
+z.object({
+  stationId: z.string().min(1)
+});
+var regionSchema = z.enum(["US", "CA", "EU"]);
+z.enum([
+  "gasoline",
+  "diesel",
+  "electric",
+  "hybrid",
+  "plugin_hybrid",
+  "lpg",
+  "cng",
+  "hydrogen"
+]);
+z.enum(["FWD", "RWD", "AWD", "4WD"]);
+z.enum([
+  "manual",
+  "automatic",
+  "CVT",
+  "DCT",
+  "AMT",
+  "single_speed"
+]);
+z.record(z.string(), z.unknown());
+z.record(z.string(), z.unknown());
+var variantSchema = z.object({
+  id: z.string(),
+  make: z.string(),
+  model: z.string(),
+  year: z.number(),
+  trim: z.string().optional().nullable(),
+  msrp: z.number().optional().nullable(),
+  bodyStyle: z.string().optional().nullable(),
+  styleName: z.string().optional().nullable(),
+  region: regionSchema.optional().nullable(),
+  /** Spec object - passthrough to preserve all fields from different data sources */
+  spec: z.record(z.string(), z.unknown()).optional().nullable(),
+  extra: z.record(z.string(), z.unknown()).optional().nullable()
+});
+z.object({
+  make: z.string().min(1, "Make is required")
+});
+z.object({
+  id: z.string()
+});
+z.object({
+  listingId: z.string()
+});
+z.object({
+  vin: z.string().length(17, "VIN must be exactly 17 characters")
+});
+z.object({
+  make: z.string().min(1, "Make is required"),
+  model: z.string().min(1, "Model is required")
+});
+z.object({
+  make: z.string().min(1, "Make is required"),
+  year: z.coerce.number().int().min(1900).max(2030)
+});
+z.object({
+  make: z.string().min(1, "Make is required"),
+  model: z.string().min(1, "Model is required"),
+  year: z.coerce.number().int().min(1900).max(2030)
+});
+z.object({
+  limit: z.coerce.number().int().min(1).max(1e3).optional()
+});
+z.object({
+  page: z.coerce.number().int().min(1).optional().default(1),
+  limit: z.coerce.number().int().min(1).max(500).optional().default(200),
+  region: regionSchema.optional(),
+  bodyStyle: z.string().optional()
+});
+z.object({
+  region: regionSchema.optional()
+});
+z.object({
+  make: z.string().min(1, "Make is required"),
+  model: z.string().min(1, "Model is required"),
+  year: z.coerce.number().int().min(1900).max(2030),
+  limit: z.coerce.number().int().min(1).max(100).optional(),
+  page: z.coerce.number().int().min(1).optional(),
+  shotType: z.enum([
+    "FQ",
+    "RQ",
+    "I",
+    "RI",
+    "S",
+    "CARGO",
+    "E",
+    "W",
+    "D",
+    "CC",
+    "F",
+    "R",
+    "DETAIL",
+    "B",
+    "O",
+    "PROFILE",
+    "ALL"
+  ]).optional(),
+  category: z.enum(["EXTERIOR", "INTERIOR"]).optional()
+});
+z.object({
+  make: z.string().min(1, "Make is required"),
+  model: z.string().min(1, "Model is required"),
+  year: z.coerce.number().int().min(1900).max(2030)
+});
+var colorInfoSchema = z.object({
+  rgb: z.string(),
+  hex: z.string(),
+  name: z.string()
+});
+z.object({
+  EXTERIOR: z.array(colorInfoSchema).optional(),
+  INTERIOR: z.array(colorInfoSchema).optional()
+});
+var researchImageSchema = z.object({
+  url: z.string(),
+  make: z.string().optional().nullable(),
+  model: z.string().optional().nullable(),
+  year: z.number().optional().nullable(),
+  shotType: z.string().optional().nullable(),
+  category: z.string().optional().nullable(),
+  title: z.string().optional().nullable(),
+  color: z.string().optional().nullable(),
+  metadata: z.any().optional().nullable()
+});
+var lineupItemSchema = z.object({
+  make: z.string(),
+  model: z.string(),
+  year: z.number(),
+  msrp: z.number().optional().nullable(),
+  images: z.array(researchImageSchema).optional()
+});
+z.object({
+  data: z.array(lineupItemSchema),
+  total: z.coerce.number(),
+  page: z.coerce.number(),
+  limit: z.coerce.number()
+});
+z.array(variantSchema);
+variantSchema.nullable();
+z.array(researchImageSchema);
+z.object({
+  makes: z.array(z.string().transform((val) => val.toUpperCase())).optional(),
+  models: z.array(z.string().transform((val) => val.toUpperCase())).optional(),
+  year: z.object({
+    min: z.coerce.number().optional(),
+    max: z.coerce.number().optional()
+  }).optional(),
+  limit: z.coerce.number().optional(),
+  offset: z.coerce.number().optional(),
+  sort: z.enum(["recall_date", "year", "make", "model"]).optional(),
+  order: z.enum(["asc", "desc"]).optional(),
+  // Coerce country to country code
+  country: z.enum(["canada", "usa"]).optional().default("canada").transform((val) => val === "canada" ? "ca" : "us")
+});
+var transportCanadaRecallDetailSchema = z.object({
+  id: z.string(),
+  recallNumber: z.string(),
+  year: z.number(),
+  manufacturerRecallNumber: z.string(),
+  category: z.string(),
+  model: z.string(),
+  make: z.string(),
+  unitsAffected: z.number(),
+  systemType: z.string(),
+  notificationType: z.string(),
+  comment: z.string(),
+  dateYear: z.number(),
+  recallDate: z.string(),
+  processedAt: z.string(),
+  provider: z.literal("Transport Canada")
+});
+var nhtsaRecallSummarySchema = z.object({
+  manufacturer: z.string(),
+  nhtsaCampaignNumber: z.string(),
+  parkIt: z.boolean(),
+  parkOutSide: z.boolean(),
+  overTheAirUpdate: z.boolean(),
+  nhtsaActionNumber: z.string().optional(),
+  reportReceivedDate: z.string(),
+  component: z.string(),
+  summary: z.string(),
+  consequence: z.string(),
+  remedy: z.string(),
+  notes: z.string(),
+  modelYear: z.string(),
+  make: z.string(),
+  model: z.string(),
+  provider: z.literal("NHTSA")
+});
+var recallResponseSchema = z.object({
+  success: z.boolean(),
+  provider: z.enum(["Transport Canada", "NHTSA"]).optional(),
+  data: z.array(
+    z.discriminatedUnion("provider", [
+      transportCanadaRecallDetailSchema,
+      nhtsaRecallSummarySchema
+    ])
+  ),
+  meta: z.object({
+    make: z.string().optional(),
+    model: z.string().optional(),
+    startYear: z.number().optional(),
+    endYear: z.number().optional(),
+    modelYear: z.number().optional(),
+    recallNumber: z.string().optional(),
+    campaignNumber: z.string().optional(),
+    count: z.number()
+  })
+});
+z.object({
+  success: z.boolean(),
+  vin: z.string(),
+  vehicle: z.object({
+    make: z.string(),
+    model: z.string(),
+    year: z.number()
+  }),
+  results: z.array(recallResponseSchema),
+  meta: z.object({
+    totalResults: z.number(),
+    providersSearched: z.array(z.string())
+  })
+});
+var powertrainTypeSchema = z.enum([
+  "ice",
+  "bev",
+  "phev",
+  "hev",
+  "mhev",
+  "fcev"
+]);
+var testCycleSchema = z.enum(["epa", "wltp", "mixed"]);
+var efficiencySourceSchema = z.enum(["epa", "tc", "uk-vca", "eu-eea"]);
+z.object({
+  makes: z.array(z.string().transform((val) => val.toUpperCase())).optional(),
+  models: z.array(z.string().transform((val) => val.toUpperCase())).optional(),
+  year: rangeSchema(1900, 2050).optional(),
+  powertrainTypes: z.array(powertrainTypeSchema).optional(),
+  fuelTypes: z.array(z.string()).optional(),
+  sources: z.array(efficiencySourceSchema).optional(),
+  testCycles: z.array(testCycleSchema).optional(),
+  limit: z.coerce.number().min(1).max(250).optional(),
+  offset: z.coerce.number().min(0).optional(),
+  sort: z.enum([
+    "make",
+    "model",
+    "year",
+    "combined_l_per_100km",
+    "combined_kwh_per_100km",
+    "co2_grams_per_km",
+    "electric_range_km"
+  ]).optional(),
+  order: z.enum(["asc", "desc"]).optional()
+});
+var efficiencyDetailSchema = z.object({
+  id: z.number(),
+  source: efficiencySourceSchema,
+  sourceId: z.string(),
+  year: z.number(),
+  make: z.string(),
+  model: z.string(),
+  variant: z.string().nullable(),
+  powertrainType: powertrainTypeSchema,
+  fuelType: z.string(),
+  transmission: z.string().nullable(),
+  driveType: z.string().nullable(),
+  // Engine specs
+  engineDisplacementCc: z.number().nullable(),
+  enginePowerKw: z.number().nullable(),
+  cylinders: z.number().nullable(),
+  // Fuel consumption (L/100km)
+  combinedLPer100km: z.number().nullable(),
+  cityLPer100km: z.number().nullable(),
+  highwayLPer100km: z.number().nullable(),
+  // Electric consumption (kWh/100km)
+  combinedKwhPer100km: z.number().nullable(),
+  cityKwhPer100km: z.number().nullable(),
+  highwayKwhPer100km: z.number().nullable(),
+  // Emissions & Range
+  co2GramsPerKm: z.number().nullable(),
+  electricRangeKm: z.number().nullable(),
+  totalRangeKm: z.number().nullable(),
+  // Vehicle specs
+  massKg: z.number().nullable(),
+  wheelbaseMm: z.number().nullable(),
+  // Test info
+  testCycle: testCycleSchema
+});
+var efficiencyStatsSchema = z.object({
+  totalRecords: z.number(),
+  bySource: z.array(
+    z.object({
+      source: efficiencySourceSchema,
+      count: z.number()
+    })
+  ),
+  byPowertrain: z.array(
+    z.object({
+      powertrainType: z.string(),
+      count: z.number()
+    })
+  ),
+  byTestCycle: z.array(
+    z.object({
+      testCycle: z.string(),
+      count: z.number()
+    })
+  ),
+  yearRange: z.object({
+    min: z.number(),
+    max: z.number()
+  }),
+  topMakes: z.array(
+    z.object({
+      make: z.string(),
+      count: z.number()
+    })
+  )
+});
+z.object({
+  makes: z.array(z.string().transform((val) => val.toUpperCase())).optional(),
+  models: z.array(z.string().transform((val) => val.toUpperCase())).optional(),
+  year: rangeSchema(1900, 2050).optional(),
+  vehicleClasses: z.array(z.string()).optional(),
+  bodyStyles: z.array(z.string()).optional(),
+  overallStars: z.array(z.string()).optional(),
+  frontalRatings: z.array(z.string()).optional(),
+  sideRatings: z.array(z.string()).optional(),
+  rolloverRatings: z.array(z.string()).optional(),
+  hasAdvancedSafety: z.boolean().optional(),
+  limit: z.coerce.number().optional(),
+  offset: z.coerce.number().optional(),
+  sort: z.enum([
+    "make",
+    "model",
+    "model_year",
+    "overall_stars",
+    "frontal_driver_stars",
+    "side_driver_stars",
+    "rollover_stars",
+    "vehicle_class"
+  ]).optional(),
+  order: z.enum(["asc", "desc"]).optional()
+});
+z.object({
+  id: z.number(),
+  make: z.string(),
+  model: z.string(),
+  modelYear: z.number().nullable(),
+  bodyStyle: z.string().nullable(),
+  vehicleClass: z.string().nullable(),
+  // Core Safety Ratings
+  overallStars: z.string().nullable(),
+  frontalDriverStars: z.string().nullable(),
+  frontalPassengerStars: z.string().nullable(),
+  overallFrontalStars: z.string().nullable(),
+  sideDriverStars: z.string().nullable(),
+  sidePassengerStars: z.string().nullable(),
+  overallSideStars: z.string().nullable(),
+  sidePoleStars: z.string().nullable(),
+  rolloverStars: z.string().nullable(),
+  rolloverPossibility: z.number().nullable(),
+  // Advanced Safety Features
+  frontCollisionWarning: z.string().nullable(),
+  laneDepartureWarning: z.string().nullable(),
+  crashImminentBrake: z.string().nullable(),
+  blindSpotDetection: z.string().nullable(),
+  backupCamera: z.string().nullable(),
+  abs: z.string().nullable(),
+  nhtsaEsc: z.string().nullable(),
+  // Airbag Information
+  headSideAirbag: z.string().nullable(),
+  torsoSideAirbag: z.string().nullable(),
+  // Test Information
+  frontalTestNumber: z.number().nullable(),
+  sideTestNumber: z.number().nullable(),
+  poleTestNumber: z.number().nullable(),
+  // Metadata
+  processedAt: z.string().nullable(),
+  provider: z.literal("NHTSA")
+});
+z.object({
+  totalReviews: z.number(),
+  reviewsWithOverallRating: z.number(),
+  topMakes: z.array(
+    z.object({
+      make: z.string(),
+      count: z.number()
+    })
+  ),
+  topVehicleClasses: z.array(
+    z.object({
+      vehicleClass: z.string(),
+      count: z.number()
+    })
+  ),
+  ratingDistribution: z.array(
+    z.object({
+      stars: z.string(),
+      count: z.number()
+    })
+  ),
+  advancedSafetyFeatures: z.object({
+    frontCollisionWarning: z.number(),
+    laneDepartureWarning: z.number(),
+    crashImminentBrake: z.number(),
+    blindSpotDetection: z.number(),
+    backupCamera: z.number()
+  })
+});
+
+// ../contracts/src/codecs/base.codecs.ts
+function createSchemaWithCodec(schema, codec) {
+  return {
+    ...schema,
+    encode: codec.encode,
+    decode: codec.decode,
+    schema
+    // Original schema for validation
+  };
+}
+var URLParamsBuilder = class {
+  constructor() {
+    this.params = new URLSearchParams();
+  }
+  /**
+   * Set a single key-value pair
+   * @param key - The parameter key
+   * @param value - The value to set (undefined values are ignored)
+   * @returns This builder instance for chaining
+   */
+  set(key, value) {
+    if (value !== void 0) {
+      this.params.set(key, encodeURIComponent(value.toString()));
+    }
+    return this;
+  }
+  /**
+   * Set an array parameter as a comma-separated string
+   * @param key - The parameter key
+   * @param values - Array of strings to join (undefined/empty arrays are ignored)
+   * @returns This builder instance for chaining
+   */
+  setArray(key, values) {
+    if (values?.length) {
+      this.set(key, values.join(","));
+    }
+    return this;
+  }
+  /**
+   * Set a range parameter as separate min/max keys
+   * @param key - The base parameter key
+   * @param range - Object with optional min/max properties
+   * @returns This builder instance for chaining
+   */
+  setRange(key, range) {
+    if (range?.min !== void 0) {
+      this.set(`${key}Min`, range.min);
+    }
+    if (range?.max !== void 0) {
+      this.set(`${key}Max`, range.max);
+    }
+    return this;
+  }
+  /**
+   * Build the final URLSearchParams object
+   * @returns The constructed URLSearchParams instance
+   */
+  build() {
+    return this.params;
+  }
+};
+var URLParamsParser = class {
+  constructor(params) {
+    this.params = params;
+  }
+  /**
+   * Get a single string parameter with proper URL decoding
+   * @param key - The parameter key
+   * @returns The decoded string value or undefined if not present
+   */
+  get(key) {
+    const value = this.params.get(key);
+    return value ? decodeURIComponent(value.replace(/\+/g, " ")) : void 0;
+  }
+  /**
+   * Get a numeric parameter with type conversion
+   * @param key - The parameter key
+   * @param type - Whether to parse as integer or float
+   * @returns The parsed number or undefined if not present/invalid
+   */
+  getNumber(key, type = "int") {
+    const value = this.get(key);
+    if (!value) return void 0;
+    return type === "float" ? parseFloat(value) : parseInt(value);
+  }
+  /**
+   * Get an array parameter by splitting on comma
+   * @param key - The parameter key
+   * @returns Array of trimmed strings or undefined if not present
+   */
+  getArray(key) {
+    const value = this.get(key);
+    return value?.split(",").map((s) => s.trim());
+  }
+  /**
+   * Get a range parameter by looking for {key}Min and {key}Max
+   * @param key - The base parameter key
+   * @returns Object with min/max properties or undefined if neither present
+   */
+  getRange(key) {
+    const min = this.getNumber(`${key}Min`);
+    const max = this.getNumber(`${key}Max`);
+    return min !== void 0 || max !== void 0 ? { min, max } : void 0;
+  }
+};
+
+// ../contracts/src/codecs/listings.codecs.ts
+var MAKE_MODEL_DELIMITER = ";";
+var MODEL_DELIMITER = "|";
+var SUB_MODEL_DELIMITER = ",";
+var ListingFiltersCodec = class {
+  /**
+   * Encode listing filters to URLSearchParams
+   * @param filters - The filters object to encode
+   * @returns URLSearchParams representation
+   */
+  encode(filters) {
+    const builder = new URLParamsBuilder();
+    builder.setArray("ids", filters.ids);
+    builder.setArray("makes", filters.makes);
+    builder.setArray("trims", filters.trims);
+    builder.setArray("saleTypes", filters.saleTypes);
+    builder.setArray("bodyStyles", filters.bodyStyles);
+    builder.setArray("fuelTypes", filters.fuelTypes);
+    builder.setArray("exteriorColors", filters.exteriorColors);
+    builder.setArray("interiorColors", filters.interiorColors);
+    builder.setArray("sellers", filters.sellers);
+    if (filters.models) {
+      const modelsString = Object.entries(filters.models).map(
+        ([make, models]) => `${make}${MODEL_DELIMITER}${models.join(SUB_MODEL_DELIMITER)}`
+      ).join(MAKE_MODEL_DELIMITER);
+      builder.set("models", modelsString);
+    }
+    builder.setRange("year", filters.year);
+    builder.setRange("price", filters.price);
+    builder.setRange("odometer", filters.odometer);
+    if (filters.location) {
+      builder.set("lat", filters.location.lat);
+      builder.set("lng", filters.location.lng);
+      builder.set("radius", filters.location.radius);
+    }
+    return builder.build();
+  }
+  /**
+   * Decode URLSearchParams back to listing filters
+   * @param params - The URLSearchParams to decode
+   * @returns The decoded filters object
+   * @throws z.ZodError if the parameters don't match the expected schema
+   */
+  decode(params) {
+    const parser = new URLParamsParser(params);
+    const rawFilters = {
+      ids: parser.getArray("ids"),
+      makes: parser.getArray("makes"),
+      models: this.parseModels(parser.get("models")),
+      trims: parser.getArray("trims"),
+      year: parser.getRange("year"),
+      price: parser.getRange("price"),
+      odometer: parser.getRange("odometer"),
+      saleTypes: parser.getArray("saleTypes"),
+      bodyStyles: parser.getArray("bodyStyles"),
+      fuelTypes: parser.getArray("fuelTypes"),
+      exteriorColors: parser.getArray("exteriorColors"),
+      interiorColors: parser.getArray("interiorColors"),
+      sellers: parser.getArray("sellers")
+    };
+    const lat = parser.getNumber("lat", "float");
+    const lng = parser.getNumber("lng", "float");
+    if (lat !== void 0 && lng !== void 0) {
+      rawFilters.location = {
+        lat,
+        lng,
+        radius: parser.getNumber("radius") ?? 50
+        // Default radius
+      };
+    }
+    return listingFiltersSchema.parse(rawFilters);
+  }
+  /**
+   * Parse the complex models string format
+   * @param value - The encoded models string
+   * @returns Parsed models object or undefined
+   * @private
+   */
+  parseModels(value) {
+    if (!value) return void 0;
+    return value.split(MAKE_MODEL_DELIMITER).reduce(
+      (acc, makeModelPair) => {
+        const [make, models] = makeModelPair.split(MODEL_DELIMITER);
+        if (make && models) {
+          acc[make] = models.split(SUB_MODEL_DELIMITER);
+        }
+        return acc;
+      },
+      {}
+    );
+  }
+};
+var ListingQueryCodec = class {
+  constructor() {
+    this.filtersCodec = new ListingFiltersCodec();
+  }
+  encode(query) {
+    const params = new URLSearchParams();
+    if (query.filters) {
+      const filterParams = this.filtersCodec.encode(query.filters);
+      filterParams.forEach((value, key) => {
+        params.set(key, value);
+      });
+    }
+    if (query.pagination) {
+      if (query.pagination.page !== void 0) {
+        params.set("page", query.pagination.page.toString());
+      }
+      if (query.pagination.limit !== void 0) {
+        params.set("limit", query.pagination.limit.toString());
+      }
+    }
+    if (query.sort) {
+      params.set("sort", query.sort.field);
+      params.set("order", query.sort.direction);
+    }
+    return params;
+  }
+  decode(params) {
+    const parser = new URLParamsParser(params);
+    const query = {};
+    const filters = this.filtersCodec.decode(params);
+    if (Object.keys(filters).length > 0) {
+      query.filters = filters;
+    }
+    const page = parser.getNumber("page");
+    const limit = parser.getNumber("limit");
+    query.pagination = {
+      page: page ?? 1,
+      limit: limit ?? 25
+    };
+    const sort = parser.get("sort");
+    const order = parser.get("order");
+    if (sort) {
+      query.sort = {
+        field: sort,
+        // Will be validated by schema
+        direction: order ?? "desc"
+      };
+    }
+    return listingQuerySchema.parse(query);
+  }
+};
+createSchemaWithCodec(
+  listingFiltersSchema,
+  new ListingFiltersCodec()
+);
+createSchemaWithCodec(
+  listingQuerySchema,
+  new ListingQueryCodec()
+);
+
+// src/routes/vin.ts
+var vinKeys = {
+  all: ["vin"],
+  image: (base64) => [...vinKeys.all, "image", base64],
+  decode: (vin) => [...vinKeys.all, "decode", vin]
+};
+
+// src/routes/market.ts
+var marketKeys = {
+  all: ["market"],
+  analysis: (vin) => [...marketKeys.all, "analysis", vin],
+  overview: (make, model, year) => [...marketKeys.all, "overview", make, model, year],
+  pricing: (make, model, year) => [...marketKeys.all, "pricing", make, model, year],
+  breakdown: (make, model, year) => [...marketKeys.all, "breakdown", make, model, year],
+  odometer: (make, model, year) => [...marketKeys.all, "odometer", make, model, year],
+  geography: (make, model, year) => [...marketKeys.all, "geography", make, model, year],
+  trends: (make, model, year, period) => [...marketKeys.all, "trends", make, model, year, period],
+  similar: (listingId, limit) => [...marketKeys.all, "similar", listingId, limit],
+  position: (listingId) => [...marketKeys.all, "position", listingId],
+  pulse: (options) => [...marketKeys.all, "pulse", options],
+  byVin: (vin) => [...marketKeys.all, "byVin", vin],
+  local: (params) => [...marketKeys.all, "local", params],
+  demand: (make, model, year) => [...marketKeys.all, "demand", make, model, year]
+};
+
+// src/routes/listings.ts
+var listingsKeys = {
+  all: ["listings"],
+  search: (params) => [...listingsKeys.all, "search", params],
+  count: (params) => [...listingsKeys.all, "count", params],
+  facets: (params) => [...listingsKeys.all, "facets", params],
+  getById: (id) => [...listingsKeys.all, "getById", id]
+};
+z.object({
+  results: z.array(locationResultSchema),
+  meta: z.any().optional()
+});
+var locationsKeys = {
+  all: ["locations"],
+  search: (params) => [...locationsKeys.all, "search", params],
+  detail: (id) => [...locationsKeys.all, "detail", id],
+  bySlug: (slug) => [...locationsKeys.all, "slug", slug]
+};
+
+// src/routes/charging.ts
+var chargingKeys = {
+  all: ["charging"],
+  stations: (params) => [...chargingKeys.all, "stations", params],
+  station: (id) => [...chargingKeys.all, "station", id]
+};
+
+// src/routes/fuel.ts
+var fuelKeys = {
+  all: ["fuel"],
+  search: (params) => [...fuelKeys.all, "search", params]
+};
+
+// src/routes/research.ts
+var researchKeys = {
+  all: ["research"],
+  lineup: (make, params) => [...researchKeys.all, "lineup", make, params],
+  byMake: (make) => [...researchKeys.all, "make", make],
+  byId: (id) => [...researchKeys.all, "id", id],
+  byListingId: (listingId) => [...researchKeys.all, "listing", listingId],
+  byVin: (vin) => [...researchKeys.all, "vin", vin],
+  byModel: (make, model) => [...researchKeys.all, "model", make, model],
+  byYear: (make, year) => [...researchKeys.all, "year", make, year],
+  byModelYear: (make, model, year) => [...researchKeys.all, "modelYear", make, model, year],
+  images: (params) => [...researchKeys.all, "images", params],
+  profileImages: (params) => [...researchKeys.all, "profileImages", params],
+  colors: (params) => [...researchKeys.all, "colors", params]
+};
+
+// src/routes/recalls.ts
+var recallKeys = {
+  all: ["recalls"],
+  search: (params) => [
+    ...recallKeys.all,
+    "search",
+    params.country,
+    params.makes,
+    params.models,
+    params.year
+  ]
+};
+z.object({
+  success: z.boolean(),
+  data: z.array(efficiencyDetailSchema),
+  meta: z.object({
+    filter: z.any().optional(),
+    make: z.string().optional(),
+    model: z.string().optional(),
+    year: z.number().optional(),
+    trim: z.string().optional(),
+    count: z.number(),
+    fallback: z.boolean().optional()
+  })
+});
+z.object({
+  success: z.boolean(),
+  data: efficiencyStatsSchema
+});
+var efficiencyKeys = {
+  all: ["efficiency"],
+  search: (params) => [...efficiencyKeys.all, "search", params],
+  byVehicle: (make, model, year) => [...efficiencyKeys.all, "vehicle", make, model, year],
+  byVehicleTrim: (make, model, year, trim) => [...efficiencyKeys.all, "vehicle", make, model, year, trim],
+  stats: () => [...efficiencyKeys.all, "stats"]
+};
+var complaintSchema = z.object({
+  complaintId: z.number(),
+  odiNumber: z.string().nullable().optional(),
+  manufacturerName: z.string().nullable().optional(),
+  make: z.string(),
+  model: z.string(),
+  year: z.number(),
+  vin: z.string().nullable().optional(),
+  crashInvolved: z.boolean().nullable().optional(),
+  incidentDate: z.string().nullable().optional(),
+  fireInvolved: z.boolean().nullable().optional(),
+  injuredCount: z.number().nullable().optional(),
+  deathsCount: z.number().nullable().optional(),
+  componentDescription: z.string().nullable().optional(),
+  consumerCity: z.string().nullable().optional(),
+  consumerState: z.string().nullable().optional(),
+  dateAdded: z.string().nullable().optional(),
+  dateReceived: z.string().nullable().optional(),
+  mileage: z.number().nullable().optional(),
+  occurrences: z.number().nullable().optional(),
+  complaintDescription: z.string().nullable().optional(),
+  complaintType: z.string().nullable().optional(),
+  policeReportFiled: z.boolean().nullable().optional(),
+  purchaseDate: z.string().nullable().optional(),
+  originalOwner: z.boolean().nullable().optional(),
+  productType: z.string().nullable().optional(),
+  repaired: z.boolean().nullable().optional(),
+  medicalAttention: z.boolean().nullable().optional(),
+  vehicleTowed: z.boolean().nullable().optional(),
+  processedAt: z.string().nullable().optional(),
+  provider: z.string().nullable().optional()
+});
+z.object({
+  success: z.boolean(),
+  provider: z.string(),
+  data: z.array(complaintSchema),
+  meta: z.object({
+    filter: z.any().optional(),
+    count: z.number()
+  })
+});
+var complaintsKeys = {
+  all: ["complaints"],
+  search: (params) => [...complaintsKeys.all, "search", params]
+};
+
+// src/index.ts
+var queryKeys = {
+  vin: vinKeys,
+  market: marketKeys,
+  listings: listingsKeys,
+  locations: locationsKeys,
+  charging: chargingKeys,
+  fuel: fuelKeys,
+  research: researchKeys,
+  recalls: recallKeys,
+  efficiency: efficiencyKeys,
+  complaints: complaintsKeys
+};
+
+// src/react/hooks.ts
+function createHooks(client) {
+  return {
+    useVinDecode(vin, options) {
+      return useQuery({
+        queryKey: queryKeys.vin.decode(vin),
+        queryFn: () => client.vin.decode(vin),
+        ...options
+      });
+    },
+    useVinImage(base64, options) {
+      return useQuery({
+        queryKey: queryKeys.vin.image(base64),
+        queryFn: () => client.vin.image(base64),
+        ...options
+      });
+    },
+    useMarketAnalysis(vin, options) {
+      return useQuery({
+        queryKey: queryKeys.market.byVin(vin),
+        queryFn: () => client.market.byVin(vin),
+        ...options
+      });
+    },
+    useMarketOverview(params, options) {
+      return useQuery({
+        queryKey: queryKeys.market.overview(params.make, params.model, params.year),
+        queryFn: () => client.market.overview(params.make, params.model, params.year),
+        ...options
+      });
+    },
+    useMarketPricing(make, model, year, options) {
+      return useQuery({
+        queryKey: queryKeys.market.pricing(make, model, year),
+        queryFn: () => client.market.pricing(make, model, year),
+        ...options
+      });
+    },
+    useMarketBreakdown(make, model, year, options) {
+      return useQuery({
+        queryKey: queryKeys.market.breakdown(make, model, year),
+        queryFn: () => client.market.breakdown(make, model, year),
+        ...options
+      });
+    },
+    useMarketOdometer(make, model, year, options) {
+      return useQuery({
+        queryKey: queryKeys.market.odometer(make, model, year),
+        queryFn: () => client.market.odometer(make, model, year),
+        ...options
+      });
+    },
+    useMarketGeography(make, model, year, options) {
+      return useQuery({
+        queryKey: queryKeys.market.geography(make, model, year),
+        queryFn: () => client.market.geography(make, model, year),
+        ...options
+      });
+    },
+    useMarketTrends(make, model, year, period, options) {
+      return useQuery({
+        queryKey: queryKeys.market.trends(make, model, year, period),
+        queryFn: () => client.market.trends(make, model, year, period),
+        ...options
+      });
+    },
+    useMarketPosition(listingId, options) {
+      return useQuery({
+        queryKey: queryKeys.market.position(listingId),
+        queryFn: () => client.market.position(listingId),
+        ...options
+      });
+    },
+    useMarketPulse(pulseOptions, queryOptions) {
+      return useQuery({
+        queryKey: queryKeys.market.pulse(pulseOptions),
+        queryFn: () => client.market.pulse(pulseOptions),
+        ...queryOptions
+      });
+    },
+    useLocalMarket(params, options) {
+      return useQuery({
+        queryKey: queryKeys.market.local(params),
+        queryFn: () => client.market.localMarket(params),
+        enabled: !!(params.make && params.model && params.year && params.lat && params.lng),
+        ...options
+      });
+    },
+    useListingsSearch(params, options) {
+      return useQuery({
+        queryKey: queryKeys.listings.search(params),
+        queryFn: () => client.listings.search(params),
+        ...options
+      });
+    },
+    useListingsCount(params, options) {
+      return useQuery({
+        queryKey: queryKeys.listings.count(params),
+        queryFn: () => client.listings.count(params),
+        ...options
+      });
+    },
+    useInfiniteListingsSearch(params, options) {
+      return useInfiniteQuery({
+        queryKey: queryKeys.listings.search({ ...params, pagination: { page: 1, limit: 30 } }),
+        queryFn: ({ pageParam = 1 }) => client.listings.search({
+          ...params,
+          pagination: { page: pageParam, limit: 30 }
+        }),
+        initialPageParam: 1,
+        getNextPageParam: (lastPage) => lastPage.pagination.page + 1,
+        ...options
+      });
+    },
+    useListingById(id, options) {
+      return useQuery({
+        queryKey: queryKeys.listings.getById(id),
+        queryFn: () => client.listings.getById(id),
+        ...options
+      });
+    },
+    useListingsFacets(params, options) {
+      return useQuery({
+        queryKey: queryKeys.listings.facets(params),
+        queryFn: () => client.listings.facets(params),
+        staleTime: 6e4,
+        ...options
+      });
+    },
+    useLocationsSearch(params, options) {
+      return useQuery({
+        queryKey: queryKeys.locations.search(params),
+        queryFn: () => client.locations.search(params),
+        ...options
+      });
+    },
+    useLocationById(id, options) {
+      return useQuery({
+        queryKey: queryKeys.locations.detail(id),
+        queryFn: () => client.locations.getById(id),
+        ...options
+      });
+    },
+    useFuelSearch(params, options) {
+      return useQuery({
+        queryKey: queryKeys.fuel.search(params),
+        queryFn: () => client.fuel.search(params),
+        ...options
+      });
+    },
+    useChargingStations(params, options) {
+      return useQuery({
+        queryKey: queryKeys.charging.stations(params),
+        // @ts-ignore
+        queryFn: () => client.charging.getStations(params),
+        ...options
+      });
+    },
+    useResearchLineup(make, options) {
+      return useQuery({
+        queryKey: queryKeys.research.lineup(make),
+        queryFn: () => client.research.lineup(make),
+        ...options
+      });
+    },
+    useResearchByMake(make, options) {
+      return useQuery({
+        queryKey: queryKeys.research.byMake(make),
+        queryFn: () => client.research.byMake(make),
+        ...options
+      });
+    },
+    useResearchById(id, options) {
+      return useQuery({
+        queryKey: queryKeys.research.byId(id),
+        queryFn: () => client.research.byId(id),
+        ...options
+      });
+    },
+    useResearchByModel(make, model, options) {
+      return useQuery({
+        queryKey: queryKeys.research.byModel(make, model),
+        queryFn: () => client.research.byModel(make, model),
+        ...options
+      });
+    },
+    useResearchByModelYear(make, model, year, options) {
+      return useQuery({
+        queryKey: queryKeys.research.byModelYear(make, model, year),
+        queryFn: () => client.research.byModelYear(make, model, year),
+        ...options
+      });
+    },
+    useResearchImages(params, options) {
+      return useQuery({
+        queryKey: queryKeys.research.images(params),
+        queryFn: () => client.research.getImages(params),
+        ...options
+      });
+    },
+    useResearchColors(params, options) {
+      return useQuery({
+        queryKey: queryKeys.research.colors(params),
+        queryFn: () => client.research.getColors(params),
+        ...options
+      });
+    },
+    useRecalls(params, options) {
+      return useQuery({
+        queryKey: queryKeys.recalls.search(params),
+        queryFn: () => client.recalls.search(params),
+        ...options
+      });
+    },
+    useComplaints(params, options) {
+      return useQuery({
+        queryKey: queryKeys.complaints.search(params),
+        queryFn: () => client.complaints.search(params),
+        ...options
+      });
+    }
+  };
+}
+
+export { createHooks, queryKeys };