@cardog/api 0.1.1

package/dist/react/index.js

@@ -0,0 +1,1967 @@
+'use strict';
+
+var reactQuery = require('@tanstack/react-query');
+require('axios');
+var zod = require('zod');
+
+// src/react/hooks.ts
+var MAX_PAGE_SIZE = 250;
+var DEFAULT_RADIUS = 50;
+var MAX_RADIUS = 500;
+zod.z.object({
+  make: zod.z.string(),
+  model: zod.z.string(),
+  year: zod.z.coerce.number().int().min(1900).max(2050)
+});
+zod.z.string().length(17, "VIN must be exactly 17 characters").regex(/^[A-HJ-NPR-Z0-9]{17}$/, "Invalid VIN format");
+var paginationSchema = zod.z.object({
+  page: zod.z.coerce.number().int().min(1, "Page number must be 1 or greater"),
+  // .default(1),
+  limit: zod.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 = zod.z.object({
+  lat: zod.z.coerce.number().min(-90, "Latitude must be between -90 and 90").max(90, "Latitude must be between -90 and 90"),
+  lng: zod.z.coerce.number().min(-180, "Longitude must be between -180 and 180").max(180, "Longitude must be between -180 and 180"),
+  radius: zod.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) => zod.z.object({
+  min: zod.z.number().int().min(min).optional(),
+  max: zod.z.number().int().max(max).optional()
+});
+var sortDirectionsSchema = zod.z.string().transform((val) => val.toLowerCase()).pipe(zod.z.enum(["asc", "desc"]));
+var idSchema = zod.z.string();
+var timestampSchema = zod.z.string().datetime();
+var sellerSchema = zod.z.object({
+  id: idSchema,
+  slug: zod.z.string().optional(),
+  // TODO: Remove soon.
+  type: zod.z.string(),
+  name: zod.z.string(),
+  email: zod.z.string().nullable(),
+  phone: zod.z.string().nullable(),
+  addressId: zod.z.number().nullable(),
+  dealershipId: idSchema.nullable(),
+  // Google My Business enhanced fields
+  gmbPhone: zod.z.string().nullable(),
+  gmbRating: zod.z.string().nullable(),
+  gmbReviewCount: zod.z.number().nullable(),
+  createdAt: timestampSchema,
+  updatedAt: timestampSchema,
+  deactivatedAt: timestampSchema.nullable()
+});
+var dealershipSchema = zod.z.object({
+  id: idSchema,
+  name: zod.z.string(),
+  primaryDomain: zod.z.string(),
+  metadata: zod.z.any(),
+  isVerified: zod.z.boolean(),
+  createdAt: timestampSchema,
+  updatedAt: timestampSchema
+});
+var addressSchema = zod.z.object({
+  id: zod.z.number(),
+  street: zod.z.string(),
+  city: zod.z.string(),
+  state: zod.z.string(),
+  postalCode: zod.z.string(),
+  country: zod.z.string(),
+  latitude: zod.z.string(),
+  longitude: zod.z.string(),
+  location: zod.z.object({
+    x: zod.z.number(),
+    y: zod.z.number()
+  }),
+  createdAt: timestampSchema,
+  updatedAt: timestampSchema
+});
+var mediaSchema = zod.z.object({
+  id: zod.z.number(),
+  listingId: idSchema.nullable(),
+  type: zod.z.string(),
+  url: zod.z.string(),
+  make: zod.z.string().nullable(),
+  model: zod.z.string().nullable(),
+  year: zod.z.number().nullable(),
+  width: zod.z.number().nullable(),
+  height: zod.z.number().nullable(),
+  sizeBytes: zod.z.number().nullable(),
+  mimeType: zod.z.string().nullable(),
+  sourceUri: zod.z.string().nullable(),
+  sourceType: zod.z.string().nullable(),
+  metadata: zod.z.any().nullable(),
+  createdAt: timestampSchema.nullable(),
+  updatedAt: timestampSchema.nullable(),
+  removedAt: timestampSchema.nullable()
+});
+var vehicleReportSchema = zod.z.object({
+  id: zod.z.string(),
+  vin: zod.z.string(),
+  url: zod.z.string().nullable(),
+  version: zod.z.string(),
+  type: zod.z.string(),
+  data: zod.z.any(),
+  // jsonb data
+  createdAt: timestampSchema,
+  updatedAt: timestampSchema
+});
+var patternMatchSchema = zod.z.object({
+  element: zod.z.string(),
+  code: zod.z.string(),
+  attributeId: zod.z.union([zod.z.string(), zod.z.number(), zod.z.null()]),
+  value: zod.z.string().nullable(),
+  confidence: zod.z.number(),
+  positions: zod.z.array(zod.z.number()),
+  schema: zod.z.string(),
+  metadata: zod.z.object({
+    lookupTable: zod.z.string().nullable().optional(),
+    groupName: zod.z.string().nullable().optional(),
+    elementWeight: zod.z.number().nullable().optional(),
+    patternType: zod.z.enum(["VDS", "VIS"]).nullable().optional(),
+    rawPattern: zod.z.string().nullable().optional(),
+    matchDetails: zod.z.object({
+      exactMatches: zod.z.number().optional(),
+      wildcardMatches: zod.z.number().optional(),
+      totalPositions: zod.z.number().optional()
+    }).nullable().optional()
+  }).optional()
+});
+zod.z.object({
+  vin: zod.z.string(),
+  valid: zod.z.boolean(),
+  components: zod.z.object({
+    checkDigit: zod.z.object({
+      position: zod.z.number(),
+      actual: zod.z.string(),
+      expected: zod.z.string().optional(),
+      isValid: zod.z.boolean()
+    }).optional(),
+    modelYear: zod.z.object({
+      year: zod.z.number(),
+      source: zod.z.enum(["position", "override", "calculated"]),
+      confidence: zod.z.number()
+    }).optional(),
+    wmi: zod.z.object({
+      code: zod.z.string(),
+      manufacturer: zod.z.string(),
+      country: zod.z.string(),
+      vehicleType: zod.z.string(),
+      region: zod.z.string(),
+      make: zod.z.string()
+    }).optional(),
+    vds: zod.z.object({
+      raw: zod.z.string(),
+      patterns: zod.z.array(patternMatchSchema)
+    }).optional(),
+    vis: zod.z.object({
+      raw: zod.z.string(),
+      patterns: zod.z.array(patternMatchSchema)
+    }).optional(),
+    vehicle: zod.z.object({
+      make: zod.z.string(),
+      model: zod.z.string(),
+      year: zod.z.number(),
+      series: zod.z.string().optional(),
+      trim: zod.z.string().optional(),
+      bodyStyle: zod.z.string().optional(),
+      driveType: zod.z.string().optional(),
+      engineType: zod.z.string().optional(),
+      fuelType: zod.z.string().optional(),
+      transmission: zod.z.string().optional(),
+      doors: zod.z.string().optional(),
+      gvwr: zod.z.string().optional(),
+      manufacturer: zod.z.string().optional()
+    }).optional(),
+    plant: zod.z.object({
+      country: zod.z.string(),
+      city: zod.z.string().optional(),
+      manufacturer: zod.z.string().optional(),
+      code: zod.z.string()
+    }).optional(),
+    engine: zod.z.object({
+      type: zod.z.string().optional(),
+      model: zod.z.string().optional(),
+      cylinders: zod.z.string().optional(),
+      displacement: zod.z.string().optional(),
+      fuel: zod.z.string().optional(),
+      power: zod.z.string().optional()
+    }).optional()
+  }),
+  errors: zod.z.array(zod.z.unknown()),
+  patterns: zod.z.array(patternMatchSchema).optional(),
+  metadata: zod.z.object({
+    processingTime: zod.z.number(),
+    confidence: zod.z.number(),
+    schemaVersion: zod.z.string(),
+    matchedSchema: zod.z.string().optional(),
+    totalPatterns: zod.z.number().optional(),
+    rawRecords: zod.z.array(zod.z.unknown()).optional(),
+    queries: zod.z.array(
+      zod.z.object({
+        sql: zod.z.string(),
+        params: zod.z.array(zod.z.unknown()),
+        timing: zod.z.number()
+      })
+    ).optional()
+  }).optional()
+});
+zod.z.object({
+  // TODO: Implement this properly with correct structure
+  variants: zod.z.array(zod.z.unknown())
+  // Temporary until research schemas are ported
+});
+zod.z.object({
+  result: zod.z.string(),
+  success: zod.z.boolean()
+});
+zod.z.object({
+  vehicle: zod.z.string().describe("Human-readable vehicle label, e.g. '2022 Honda Civic'"),
+  totalListings: zod.z.number().describe("Count of active listings in the cohort"),
+  avgPrice: zod.z.number().describe("Average listing price (rounded)"),
+  medianPrice: zod.z.number().describe("Median listing price (rounded)"),
+  minPrice: zod.z.number().describe("Minimum listing price"),
+  maxPrice: zod.z.number().describe("Maximum listing price"),
+  q1Price: zod.z.number().describe("25th percentile price (rounded)"),
+  q3Price: zod.z.number().describe("75th percentile price (rounded)"),
+  avgDaysOnMarket: zod.z.number().describe("Average days on market across cohort (rounded)"),
+  avgOdometer: zod.z.number().describe("Average odometer reading across cohort (rounded)")
+});
+var priceDistributionSchema = zod.z.object({
+  bucketMin: zod.z.number().describe("Inclusive lower bound of the bucket"),
+  bucketMax: zod.z.number().describe(
+    "Inclusive upper bound for the last bucket, exclusive for others"
+  ),
+  count: zod.z.number().describe("Number of listings within the bucket bounds"),
+  percentage: zod.z.number().describe("Percentage of total listings that fall into the bucket")
+}).describe("A single price histogram bucket.");
+zod.z.object({
+  distribution: zod.z.array(priceDistributionSchema).describe("Price distribution for a make/model/year cohort")
+});
+var odometerSegmentSchema = zod.z.object({
+  odometerMin: zod.z.number().describe("Inclusive lower bound of odometer segment"),
+  odometerMax: zod.z.number().describe("Inclusive upper bound for last segment, exclusive for others"),
+  listings: zod.z.number().describe("Number of listings within this odometer band"),
+  avgPrice: zod.z.number().describe("Average price within the segment (rounded)"),
+  avgOdometer: zod.z.number().describe("Average odometer within the segment (rounded)"),
+  minPrice: zod.z.number().describe("Minimum observed price in the segment"),
+  maxPrice: zod.z.number().describe("Maximum observed price in the segment")
+});
+zod.z.object({
+  segments: zod.z.array(odometerSegmentSchema).describe("Odometer analysis for a make/model/year cohort")
+});
+var geographicMarketSchema = zod.z.object({
+  state: zod.z.string().describe("Two-letter region code (e.g. US state or CA province)"),
+  listings: zod.z.number().describe("Number of listings in the region"),
+  avgPrice: zod.z.number().describe("Average listing price in region (rounded)"),
+  medianPrice: zod.z.number().describe("Median listing price in region (rounded)"),
+  avgOdometer: zod.z.number().describe("Average odometer reading in region (rounded)"),
+  avgDaysOnMarket: zod.z.number().describe("Average days on market in region (rounded)"),
+  centerLat: zod.z.number().describe("Approximate geographic center latitude of listings in region"),
+  centerLng: zod.z.number().describe("Approximate geographic center longitude of listings in region")
+});
+zod.z.object({
+  markets: zod.z.array(geographicMarketSchema).describe("Geographic analysis for a make/model/year cohort")
+});
+var timeSeriesPointSchema = zod.z.object({
+  period: zod.z.coerce.date().describe("Start of period (Monday for week, first day for month)"),
+  newListings: zod.z.number().describe("Number of new listings observed within the period"),
+  avgPrice: zod.z.number().describe("Period average listing price (rounded)"),
+  avgOdometer: zod.z.number().describe("Period average odometer (rounded)"),
+  priceChangePct: zod.z.number().describe(
+    "Price change vs previous period in percent (one decimal), if applicable"
+  )
+});
+zod.z.object({
+  trends: zod.z.array(timeSeriesPointSchema).describe("Time series data for a make/model/year cohort")
+});
+zod.z.object({
+  similarListings: zod.z.array(
+    zod.z.object({
+      id: zod.z.string(),
+      price: zod.z.number(),
+      odometer: zod.z.number(),
+      vin: zod.z.string(),
+      year: zod.z.number(),
+      make: zod.z.string(),
+      model: zod.z.string(),
+      trim: zod.z.string().nullable(),
+      listingDate: zod.z.coerce.date(),
+      daysOnMarket: zod.z.number(),
+      location: zod.z.string().nullable()
+    })
+  ),
+  priceAnalysis: zod.z.object({
+    count: zod.z.number(),
+    min: zod.z.number(),
+    max: zod.z.number(),
+    average: zod.z.number(),
+    median: zod.z.number(),
+    standardDev: zod.z.number(),
+    priceDistribution: zod.z.array(
+      zod.z.object({
+        range: zod.z.string(),
+        count: zod.z.number(),
+        percentage: zod.z.number()
+      })
+    )
+  }),
+  marketTrends: zod.z.object({
+    averageDaysOnMarket: zod.z.number(),
+    priceTrend: zod.z.number(),
+    listingVolume: zod.z.number()
+  }),
+  pricingGuidance: zod.z.object({
+    suggested: zod.z.number(),
+    confidence: zod.z.enum(["low", "medium", "high"])
+  })
+});
+zod.z.object({
+  id: zod.z.string().describe("Listing Id"),
+  price: zod.z.number().describe("Listing price"),
+  odometer: zod.z.number().describe("Odometer reading"),
+  trim: zod.z.string().nullable().describe("Vehicle trim"),
+  daysonmarket: zod.z.coerce.number().describe("Days on market"),
+  city: zod.z.string().nullable().describe("City"),
+  state: zod.z.string().nullable().describe("State"),
+  pricepercentile: zod.z.coerce.number().describe("Price percentile"),
+  pricevsmedian: zod.z.coerce.number().describe("Price vs median"),
+  pricecategory: zod.z.string().describe("Price category"),
+  marketaverage: zod.z.coerce.number().describe("Market average price")
+});
+zod.z.object({
+  overview: zod.z.object({
+    totalListings: zod.z.number(),
+    avgPrice: zod.z.number(),
+    medianPrice: zod.z.number(),
+    minPrice: zod.z.number(),
+    maxPrice: zod.z.number(),
+    stdDev: zod.z.number()
+  }),
+  priceDistribution: zod.z.array(
+    zod.z.object({
+      range: zod.z.string(),
+      count: zod.z.number()
+    })
+  ).describe(
+    "Distribution of price ranges, e.g. [{ 'range': '$10,000 - $15,000', 'count': 100 }, { 'range': '$15,000 - $20,000', 'count': 50 }]"
+  ),
+  makeDistribution: zod.z.array(
+    zod.z.object({
+      make: zod.z.string(),
+      count: zod.z.number()
+    })
+  ).describe(
+    "Distribution of makes, e.g. [{ 'make': 'Honda', 'count': 100 }, { 'make': 'Toyota', 'count': 50 }]"
+  ),
+  modelDistribution: zod.z.record(
+    zod.z.string(),
+    zod.z.array(
+      zod.z.object({
+        model: zod.z.string(),
+        count: zod.z.number()
+      })
+    )
+  ).describe(
+    "Distribution of models by make, e.g. { 'Honda': [{ 'model': 'Civic', 'count': 100 }, { 'model': 'Accord', 'count': 50 }] }"
+  ),
+  yearDistribution: zod.z.array(
+    zod.z.object({
+      range: zod.z.string(),
+      count: zod.z.number()
+    })
+  ),
+  daysOnMarketByPrice: zod.z.array(
+    zod.z.object({
+      range: zod.z.string(),
+      avgDays: zod.z.number()
+    })
+  )
+});
+var trimBreakdownSchema = zod.z.object({
+  trim: zod.z.string().nullable().describe("Vehicle trim name"),
+  listings: zod.z.number().describe("Number of listings with this trim"),
+  avgPrice: zod.z.number().describe("Average listing price for this trim (rounded)"),
+  medianPrice: zod.z.number().describe("Median listing price for this trim (rounded)"),
+  minPrice: zod.z.number().describe("Minimum listing price for this trim"),
+  maxPrice: zod.z.number().describe("Maximum listing price for this trim"),
+  avgOdometer: zod.z.number().describe("Average odometer reading for this trim (rounded)"),
+  avgDaysOnMarket: zod.z.number().describe("Average days on market for this trim (rounded)"),
+  priceVsMarket: zod.z.number().describe("Percentage difference from overall market average")
+});
+zod.z.object({
+  vehicle: zod.z.string().describe("Human-readable vehicle label, e.g. '2022 Honda Civic'"),
+  totalListings: zod.z.number().describe("Total number of listings across all trims"),
+  overallAvgPrice: zod.z.number().describe("Overall average price across all trims"),
+  overallMedianPrice: zod.z.number().describe("Overall median price across all trims"),
+  trims: zod.z.array(trimBreakdownSchema).describe("Breakdown of prices by trim")
+});
+zod.z.object({
+  make: zod.z.string().describe("Vehicle make (e.g., 'Toyota')"),
+  model: zod.z.string().describe("Vehicle model (e.g., 'Camry')"),
+  year: zod.z.number().int().min(1900).max(2100).describe("Model year"),
+  lat: zod.z.number().min(-90).max(90).describe("Latitude of search center"),
+  lng: zod.z.number().min(-180).max(180).describe("Longitude of search center"),
+  radius: zod.z.number().min(10).max(500).default(75).describe("Search radius in kilometers (default 75km)")
+});
+var marketComparisonSchema = zod.z.object({
+  localAvgPrice: zod.z.number().describe("Local average price"),
+  nationalAvgPrice: zod.z.number().describe("National average price"),
+  priceDifferencePercent: zod.z.number().describe("Percentage difference (positive = local is higher)"),
+  localListings: zod.z.number().describe("Number of local listings"),
+  nationalListings: zod.z.number().describe("Total national listings")
+});
+zod.z.object({
+  vehicle: zod.z.string().describe("Vehicle label (e.g., '2022 Toyota Camry')"),
+  location: zod.z.object({
+    city: zod.z.string().nullable().describe("Nearest city name"),
+    province: zod.z.string().nullable().describe("Province/state"),
+    lat: zod.z.number().describe("Search center latitude"),
+    lng: zod.z.number().describe("Search center longitude"),
+    radiusKm: zod.z.number().describe("Search radius used")
+  }),
+  totalListings: zod.z.number().describe("Total listings found in area"),
+  pricing: zod.z.object({
+    avgPrice: zod.z.number().describe("Average listing price in the area"),
+    medianPrice: zod.z.number().describe("Median listing price in the area"),
+    minPrice: zod.z.number().describe("Minimum listing price found"),
+    maxPrice: zod.z.number().describe("Maximum listing price found"),
+    q1Price: zod.z.number().describe("25th percentile price"),
+    q3Price: zod.z.number().describe("75th percentile price")
+  }),
+  comparison: marketComparisonSchema,
+  priceDistribution: zod.z.array(
+    zod.z.object({
+      range: zod.z.string().describe("Price range label"),
+      count: zod.z.number().describe("Number of listings in this range")
+    })
+  ),
+  odometer: zod.z.object({
+    avgOdometer: zod.z.number().describe("Average odometer reading"),
+    minOdometer: zod.z.number().describe("Minimum odometer"),
+    maxOdometer: zod.z.number().describe("Maximum odometer")
+  }),
+  daysOnMarket: zod.z.object({
+    avg: zod.z.number().describe("Average days on market"),
+    median: zod.z.number().describe("Median days on market")
+  })
+});
+var demandMatrixCellSchema = zod.z.object({
+  count: zod.z.number().describe("Number of listings in this cell"),
+  avgPrice: zod.z.number().describe("Average price in this cell"),
+  avgDaysToSell: zod.z.number().describe("Average days to sell in this cell")
+});
+var demandMatrixRowSchema = zod.z.object({
+  priceBand: zod.z.string().describe("Price band label (e.g., 'P10-P25')"),
+  priceMin: zod.z.number().describe("Minimum price in this band"),
+  priceMax: zod.z.number().describe("Maximum price in this band"),
+  cells: zod.z.array(demandMatrixCellSchema).describe("Cells for each turn rate band")
+});
+zod.z.object({
+  vehicle: zod.z.string().describe("Vehicle label (e.g., '2022 Honda Civic')"),
+  totalListings: zod.z.number().describe("Total listings analyzed"),
+  totalSold: zod.z.number().describe("Total sold/removed listings used for turn rate"),
+  turnRateBands: zod.z.array(zod.z.string()).describe("Turn rate band labels (e.g., ['0-7d', '7-14d', ...])"),
+  priceBands: zod.z.array(demandMatrixRowSchema).describe("Price band rows with cell data"),
+  summary: zod.z.object({
+    medianPrice: zod.z.number().describe("Median price across all listings"),
+    medianDaysToSell: zod.z.number().describe("Median days to sell"),
+    fastestPriceBand: zod.z.string().nullable().describe("Price band with fastest turn"),
+    sweetSpot: zod.z.object({
+      priceBand: zod.z.string(),
+      turnRateBand: zod.z.string(),
+      count: zod.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 = zod.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 = zod.z.object({
+  field: listingSortFieldsSchema,
+  direction: sortDirectionsSchema
+});
+var listingFiltersSchema = zod.z.object({
+  ids: zod.z.array(zod.z.string()).optional().describe('An array of listing IDs to fetch directly. Example: ["abc-123", "def-456"]'),
+  makes: zod.z.array(zod.z.string()).optional().describe('An array of vehicle makes. Example: ["Toyota", "Honda"]'),
+  models: zod.z.record(zod.z.string(), zod.z.array(zod.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: zod.z.array(zod.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: zod.z.array(zod.z.string()).optional().describe('An array of sale types. Example: ["new", "used"]'),
+  bodyStyles: zod.z.array(zod.z.string()).optional().describe('An array of body styles. Example: ["SUV", "Sedan"]'),
+  fuelTypes: zod.z.array(zod.z.string()).optional().describe(
+    'An array of fuel types. Example: ["Gasoline", "Electric", "Hybrid"]'
+  ),
+  exteriorColors: zod.z.array(zod.z.string()).optional().describe('An array of exterior colors. Example: ["Red", "Blue"]'),
+  interiorColors: zod.z.array(zod.z.string()).optional().describe('An array of interior colors. Example: ["Black", "Beige"]'),
+  location: locationSchema.optional(),
+  sellers: zod.z.array(zod.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 = zod.z.object({
+  filters: listingFiltersSchema.optional(),
+  sort: listingSortSchema.optional(),
+  pagination: paginationSchema.optional()
+});
+var listingSchema = zod.z.object({
+  id: zod.z.string(),
+  vin: zod.z.string(),
+  sellerId: zod.z.string(),
+  websiteDomain: zod.z.string(),
+  price: zod.z.number().positive(),
+  currency: zod.z.string().default("USD"),
+  odometer: zod.z.number().optional(),
+  sourceUri: zod.z.string(),
+  stockNumber: zod.z.string().optional().nullable(),
+  score: zod.z.number(),
+  status: zod.z.string(),
+  mediaCount: zod.z.number(),
+  createdAt: timestampSchema,
+  updatedAt: timestampSchema,
+  removedAt: timestampSchema.nullable(),
+  make: zod.z.string(),
+  model: zod.z.string(),
+  year: zod.z.number().int().min(1900).max(2030),
+  trim: zod.z.string().optional().nullable(),
+  bodyStyle: zod.z.string().optional().nullable(),
+  fuelType: zod.z.string().optional().nullable(),
+  driveTrain: zod.z.string().optional().nullable(),
+  transmission: zod.z.string().optional().nullable(),
+  engineSize: zod.z.string().optional().nullable(),
+  horsepower: zod.z.string().optional().nullable(),
+  torque: zod.z.string().optional().nullable(),
+  exteriorColor: zod.z.string().optional().nullable(),
+  interiorColor: zod.z.string().optional().nullable(),
+  condition: zod.z.enum(["new", "used", "certified"]),
+  seller: sellerSchema,
+  media: zod.z.array(mediaSchema),
+  dealership: dealershipSchema,
+  location: addressSchema,
+  report: vehicleReportSchema.nullable().optional()
+});
+zod.z.object({
+  listings: zod.z.array(listingSchema),
+  pagination: paginationSchema,
+  sort: listingSortSchema.optional(),
+  filters: listingFiltersSchema
+});
+zod.z.object({
+  count: zod.z.number().int().min(0),
+  filters: listingFiltersSchema
+});
+var facetItemSchema = zod.z.object({
+  value: zod.z.string(),
+  count: zod.z.number().int().min(0)
+});
+var histogramBucketSchema = zod.z.object({
+  min: zod.z.number(),
+  max: zod.z.number(),
+  count: zod.z.number().int().min(0)
+});
+zod.z.object({
+  makes: zod.z.array(facetItemSchema),
+  models: zod.z.array(
+    zod.z.object({
+      make: zod.z.string(),
+      model: zod.z.string(),
+      count: zod.z.number().int().min(0)
+    })
+  ),
+  bodyStyles: zod.z.array(facetItemSchema),
+  fuelTypes: zod.z.array(facetItemSchema),
+  saleTypes: zod.z.array(facetItemSchema),
+  exteriorColors: zod.z.array(facetItemSchema),
+  years: zod.z.object({
+    min: zod.z.number().int(),
+    max: zod.z.number().int()
+  }),
+  prices: zod.z.object({
+    min: zod.z.number(),
+    max: zod.z.number(),
+    histogram: zod.z.array(histogramBucketSchema)
+  }),
+  odometer: zod.z.object({
+    min: zod.z.number(),
+    max: zod.z.number(),
+    histogram: zod.z.array(histogramBucketSchema)
+  }),
+  totalCount: zod.z.number().int().min(0),
+  filters: listingFiltersSchema
+});
+var sellerTypeSchema = zod.z.enum([
+  "individual",
+  "dealership",
+  "auction",
+  "aggregator"
+]);
+zod.z.object({
+  lat: zod.z.coerce.number().min(-90).max(90).optional(),
+  lng: zod.z.coerce.number().min(-180).max(180).optional(),
+  radius: zod.z.coerce.number().min(0.1).max(500).optional(),
+  name: zod.z.string().optional(),
+  country: zod.z.string().optional(),
+  sellerType: sellerTypeSchema.optional(),
+  websiteDomain: zod.z.string().optional(),
+  hasActiveListings: zod.z.preprocess(
+    (val) => val === "true" ? true : val === "false" ? false : val,
+    zod.z.boolean().default(false)
+  ),
+  limit: zod.z.coerce.number().int().min(1).max(250).default(50),
+  offset: zod.z.coerce.number().int().min(0).default(0)
+});
+zod.z.object({
+  id: zod.z.string()
+});
+var locationAddressSchema = zod.z.object({
+  id: zod.z.number().nullable(),
+  street: zod.z.string().nullable(),
+  city: zod.z.string().nullable(),
+  state: zod.z.string().nullable(),
+  postalCode: zod.z.string().nullable(),
+  country: zod.z.string().nullable(),
+  latitude: zod.z.string().nullable(),
+  longitude: zod.z.string().nullable()
+}).nullable();
+var locationDealershipSchema = zod.z.object({
+  id: zod.z.string(),
+  name: zod.z.string(),
+  primaryDomain: zod.z.string().nullable()
+}).nullable();
+var locationResultSchema = zod.z.object({
+  id: zod.z.string(),
+  name: zod.z.string(),
+  slug: zod.z.string(),
+  type: sellerTypeSchema,
+  email: zod.z.string().nullable(),
+  phone: zod.z.string().nullable(),
+  // Google My Business enhanced fields
+  gmbPhone: zod.z.string().nullable().optional(),
+  gmbRating: zod.z.string().nullable().optional(),
+  gmbReviewCount: zod.z.number().nullable().optional(),
+  address: locationAddressSchema,
+  dealership: locationDealershipSchema,
+  totalActiveListings: zod.z.number(),
+  distance: zod.z.number().optional()
+});
+zod.z.object({
+  results: zod.z.array(locationResultSchema),
+  meta: zod.z.object({
+    total: zod.z.number(),
+    params: zod.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 || {});
+zod.z.nativeEnum(ConnectorType);
+zod.z.nativeEnum(ChargingLevel);
+zod.z.nativeEnum(StationStatus);
+var chargingConnectionSchema = zod.z.object({
+  connectionTypeId: zod.z.nativeEnum(ConnectorType),
+  connectionType: zod.z.string(),
+  powerKW: zod.z.number(),
+  currentType: zod.z.enum(["AC", "DC"]),
+  level: zod.z.nativeEnum(ChargingLevel),
+  voltage: zod.z.number(),
+  amperage: zod.z.number(),
+  pricing: zod.z.object({
+    costPerKWh: zod.z.number().nullable(),
+    costPerMinute: zod.z.number().nullable(),
+    costPerSession: zod.z.number().nullable(),
+    currency: zod.z.string()
+  }).optional()
+});
+var chargingStationSchema = zod.z.object({
+  id: zod.z.string(),
+  name: zod.z.string(),
+  address: zod.z.object({
+    addressLine1: zod.z.string(),
+    addressLine2: zod.z.string().optional().nullable(),
+    town: zod.z.string(),
+    stateOrProvince: zod.z.string(),
+    postcode: zod.z.string(),
+    countryCode: zod.z.string()
+  }),
+  location: zod.z.object({
+    latitude: zod.z.number(),
+    longitude: zod.z.number()
+  }),
+  connections: zod.z.array(chargingConnectionSchema),
+  status: zod.z.nativeEnum(StationStatus),
+  network: zod.z.string().nullable(),
+  operator: zod.z.string().nullable(),
+  dateCreated: zod.z.string(),
+  dateLastVerified: zod.z.string().nullable(),
+  usage: zod.z.string().nullable(),
+  supportPhone: zod.z.string().nullable(),
+  supportUrl: zod.z.string().nullable(),
+  isMembershipRequired: zod.z.boolean(),
+  isPayAtLocation: zod.z.boolean(),
+  photos: zod.z.array(zod.z.string()).optional(),
+  rating: zod.z.number().optional()
+});
+zod.z.object({
+  country: zod.z.string().default("US").describe("The country to search in"),
+  region: zod.z.string().optional().describe("The region to search in"),
+  lat: zod.z.coerce.number().optional().describe("The latitude to search in"),
+  lng: zod.z.coerce.number().optional().describe("The longitude to search in"),
+  radius: zod.z.coerce.number().optional().describe("The radius to search in"),
+  connector: zod.z.array(zod.z.nativeEnum(ConnectorType)).optional().describe("The connector types to search for"),
+  minPower: zod.z.coerce.number().optional().describe("The minimum power to search for"),
+  limit: zod.z.coerce.number().optional().describe("The number of results to return"),
+  includeInactive: zod.z.boolean().optional().describe("Whether to include inactive stations"),
+  includePhotos: zod.z.coerce.boolean().optional().describe("Whether to include photos")
+});
+zod.z.object({
+  stations: zod.z.array(chargingStationSchema),
+  totalCount: zod.z.number(),
+  location: zod.z.object({
+    name: zod.z.string().nullable(),
+    countryCode: zod.z.string(),
+    regionCode: zod.z.string().nullable()
+  })
+});
+zod.z.object({
+  id: zod.z.string().min(1)
+});
+zod.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 = zod.z.nativeEnum(FuelType);
+var fuelStationSchema = zod.z.object({
+  id: zod.z.string(),
+  name: zod.z.string(),
+  address: zod.z.object({
+    line1: zod.z.string(),
+    line2: zod.z.string().optional(),
+    locality: zod.z.string(),
+    region: zod.z.string(),
+    postalCode: zod.z.string(),
+    country: zod.z.string()
+  }),
+  location: zod.z.object({
+    latitude: zod.z.number(),
+    longitude: zod.z.number()
+  }),
+  price: zod.z.object({
+    credit: zod.z.number().nullable(),
+    cash: zod.z.number().nullable(),
+    postedTime: zod.z.string().nullable(),
+    formattedPrice: zod.z.string().nullable(),
+    reportedBy: zod.z.string().nullable()
+  }),
+  amenities: zod.z.array(zod.z.string()),
+  brands: zod.z.array(
+    zod.z.object({
+      id: zod.z.string(),
+      name: zod.z.string(),
+      type: zod.z.string(),
+      imageUrl: zod.z.string().optional().nullable()
+    })
+  ),
+  rating: zod.z.number().nullable(),
+  ratingsCount: zod.z.number(),
+  reviews: zod.z.array(
+    zod.z.object({
+      rating: zod.z.number(),
+      review: zod.z.string(),
+      nickname: zod.z.string(),
+      date: zod.z.string()
+    })
+  ),
+  fuels: zod.z.array(zod.z.string()),
+  isOpen: zod.z.boolean().optional()
+});
+zod.z.object({
+  current: zod.z.number().nullable(),
+  average: zod.z.number().nullable(),
+  postedTime: zod.z.string().nullable(),
+  unit: zod.z.string(),
+  isMetric: zod.z.boolean(),
+  fuelType: fuelTypeEnum,
+  fuelName: zod.z.string(),
+  location: zod.z.object({
+    name: zod.z.string().nullable(),
+    countryCode: zod.z.string(),
+    regionCode: zod.z.string().nullable(),
+    locationType: zod.z.string().nullable(),
+    nearbyLocalities: zod.z.array(zod.z.string())
+  }),
+  history: zod.z.array(
+    zod.z.object({
+      date: zod.z.string(),
+      price: zod.z.number(),
+      formattedPrice: zod.z.string()
+    })
+  ),
+  stations: zod.z.array(fuelStationSchema)
+});
+zod.z.object({
+  // Coordinate-based search (preferred)
+  lat: zod.z.coerce.number().min(-90).max(90).optional(),
+  lng: zod.z.coerce.number().min(-180).max(180).optional(),
+  radius: zod.z.coerce.number().min(1).max(100).optional().default(10),
+  // km
+  // Region-based search (legacy)
+  country: zod.z.string().optional().default("US"),
+  region: zod.z.string().optional(),
+  city: zod.z.string().optional(),
+  // Filter options
+  fuelType: fuelTypeEnum.optional().default(1 /* REGULAR */),
+  limit: zod.z.coerce.number().min(1).max(50).optional().default(50),
+  distanceFormat: zod.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"
+  }
+);
+zod.z.object({
+  stationId: zod.z.string().min(1)
+});
+var regionSchema = zod.z.enum(["US", "CA", "EU"]);
+zod.z.enum([
+  "gasoline",
+  "diesel",
+  "electric",
+  "hybrid",
+  "plugin_hybrid",
+  "lpg",
+  "cng",
+  "hydrogen"
+]);
+zod.z.enum(["FWD", "RWD", "AWD", "4WD"]);
+zod.z.enum([
+  "manual",
+  "automatic",
+  "CVT",
+  "DCT",
+  "AMT",
+  "single_speed"
+]);
+zod.z.record(zod.z.string(), zod.z.unknown());
+zod.z.record(zod.z.string(), zod.z.unknown());
+var variantSchema = zod.z.object({
+  id: zod.z.string(),
+  make: zod.z.string(),
+  model: zod.z.string(),
+  year: zod.z.number(),
+  trim: zod.z.string().optional().nullable(),
+  msrp: zod.z.number().optional().nullable(),
+  bodyStyle: zod.z.string().optional().nullable(),
+  styleName: zod.z.string().optional().nullable(),
+  region: regionSchema.optional().nullable(),
+  /** Spec object - passthrough to preserve all fields from different data sources */
+  spec: zod.z.record(zod.z.string(), zod.z.unknown()).optional().nullable(),
+  extra: zod.z.record(zod.z.string(), zod.z.unknown()).optional().nullable()
+});
+zod.z.object({
+  make: zod.z.string().min(1, "Make is required")
+});
+zod.z.object({
+  id: zod.z.string()
+});
+zod.z.object({
+  listingId: zod.z.string()
+});
+zod.z.object({
+  vin: zod.z.string().length(17, "VIN must be exactly 17 characters")
+});
+zod.z.object({
+  make: zod.z.string().min(1, "Make is required"),
+  model: zod.z.string().min(1, "Model is required")
+});
+zod.z.object({
+  make: zod.z.string().min(1, "Make is required"),
+  year: zod.z.coerce.number().int().min(1900).max(2030)
+});
+zod.z.object({
+  make: zod.z.string().min(1, "Make is required"),
+  model: zod.z.string().min(1, "Model is required"),
+  year: zod.z.coerce.number().int().min(1900).max(2030)
+});
+zod.z.object({
+  limit: zod.z.coerce.number().int().min(1).max(1e3).optional()
+});
+zod.z.object({
+  page: zod.z.coerce.number().int().min(1).optional().default(1),
+  limit: zod.z.coerce.number().int().min(1).max(500).optional().default(200),
+  region: regionSchema.optional(),
+  bodyStyle: zod.z.string().optional()
+});
+zod.z.object({
+  region: regionSchema.optional()
+});
+zod.z.object({
+  make: zod.z.string().min(1, "Make is required"),
+  model: zod.z.string().min(1, "Model is required"),
+  year: zod.z.coerce.number().int().min(1900).max(2030),
+  limit: zod.z.coerce.number().int().min(1).max(100).optional(),
+  page: zod.z.coerce.number().int().min(1).optional(),
+  shotType: zod.z.enum([
+    "FQ",
+    "RQ",
+    "I",
+    "RI",
+    "S",
+    "CARGO",
+    "E",
+    "W",
+    "D",
+    "CC",
+    "F",
+    "R",
+    "DETAIL",
+    "B",
+    "O",
+    "PROFILE",
+    "ALL"
+  ]).optional(),
+  category: zod.z.enum(["EXTERIOR", "INTERIOR"]).optional()
+});
+zod.z.object({
+  make: zod.z.string().min(1, "Make is required"),
+  model: zod.z.string().min(1, "Model is required"),
+  year: zod.z.coerce.number().int().min(1900).max(2030)
+});
+var colorInfoSchema = zod.z.object({
+  rgb: zod.z.string(),
+  hex: zod.z.string(),
+  name: zod.z.string()
+});
+zod.z.object({
+  EXTERIOR: zod.z.array(colorInfoSchema).optional(),
+  INTERIOR: zod.z.array(colorInfoSchema).optional()
+});
+var researchImageSchema = zod.z.object({
+  url: zod.z.string(),
+  make: zod.z.string().optional().nullable(),
+  model: zod.z.string().optional().nullable(),
+  year: zod.z.number().optional().nullable(),
+  shotType: zod.z.string().optional().nullable(),
+  category: zod.z.string().optional().nullable(),
+  title: zod.z.string().optional().nullable(),
+  color: zod.z.string().optional().nullable(),
+  metadata: zod.z.any().optional().nullable()
+});
+var lineupItemSchema = zod.z.object({
+  make: zod.z.string(),
+  model: zod.z.string(),
+  year: zod.z.number(),
+  msrp: zod.z.number().optional().nullable(),
+  images: zod.z.array(researchImageSchema).optional()
+});
+zod.z.object({
+  data: zod.z.array(lineupItemSchema),
+  total: zod.z.coerce.number(),
+  page: zod.z.coerce.number(),
+  limit: zod.z.coerce.number()
+});
+zod.z.array(variantSchema);
+variantSchema.nullable();
+zod.z.array(researchImageSchema);
+zod.z.object({
+  makes: zod.z.array(zod.z.string().transform((val) => val.toUpperCase())).optional(),
+  models: zod.z.array(zod.z.string().transform((val) => val.toUpperCase())).optional(),
+  year: zod.z.object({
+    min: zod.z.coerce.number().optional(),
+    max: zod.z.coerce.number().optional()
+  }).optional(),
+  limit: zod.z.coerce.number().optional(),
+  offset: zod.z.coerce.number().optional(),
+  sort: zod.z.enum(["recall_date", "year", "make", "model"]).optional(),
+  order: zod.z.enum(["asc", "desc"]).optional(),
+  // Coerce country to country code
+  country: zod.z.enum(["canada", "usa"]).optional().default("canada").transform((val) => val === "canada" ? "ca" : "us")
+});
+var transportCanadaRecallDetailSchema = zod.z.object({
+  id: zod.z.string(),
+  recallNumber: zod.z.string(),
+  year: zod.z.number(),
+  manufacturerRecallNumber: zod.z.string(),
+  category: zod.z.string(),
+  model: zod.z.string(),
+  make: zod.z.string(),
+  unitsAffected: zod.z.number(),
+  systemType: zod.z.string(),
+  notificationType: zod.z.string(),
+  comment: zod.z.string(),
+  dateYear: zod.z.number(),
+  recallDate: zod.z.string(),
+  processedAt: zod.z.string(),
+  provider: zod.z.literal("Transport Canada")
+});
+var nhtsaRecallSummarySchema = zod.z.object({
+  manufacturer: zod.z.string(),
+  nhtsaCampaignNumber: zod.z.string(),
+  parkIt: zod.z.boolean(),
+  parkOutSide: zod.z.boolean(),
+  overTheAirUpdate: zod.z.boolean(),
+  nhtsaActionNumber: zod.z.string().optional(),
+  reportReceivedDate: zod.z.string(),
+  component: zod.z.string(),
+  summary: zod.z.string(),
+  consequence: zod.z.string(),
+  remedy: zod.z.string(),
+  notes: zod.z.string(),
+  modelYear: zod.z.string(),
+  make: zod.z.string(),
+  model: zod.z.string(),
+  provider: zod.z.literal("NHTSA")
+});
+var recallResponseSchema = zod.z.object({
+  success: zod.z.boolean(),
+  provider: zod.z.enum(["Transport Canada", "NHTSA"]).optional(),
+  data: zod.z.array(
+    zod.z.discriminatedUnion("provider", [
+      transportCanadaRecallDetailSchema,
+      nhtsaRecallSummarySchema
+    ])
+  ),
+  meta: zod.z.object({
+    make: zod.z.string().optional(),
+    model: zod.z.string().optional(),
+    startYear: zod.z.number().optional(),
+    endYear: zod.z.number().optional(),
+    modelYear: zod.z.number().optional(),
+    recallNumber: zod.z.string().optional(),
+    campaignNumber: zod.z.string().optional(),
+    count: zod.z.number()
+  })
+});
+zod.z.object({
+  success: zod.z.boolean(),
+  vin: zod.z.string(),
+  vehicle: zod.z.object({
+    make: zod.z.string(),
+    model: zod.z.string(),
+    year: zod.z.number()
+  }),
+  results: zod.z.array(recallResponseSchema),
+  meta: zod.z.object({
+    totalResults: zod.z.number(),
+    providersSearched: zod.z.array(zod.z.string())
+  })
+});
+var powertrainTypeSchema = zod.z.enum([
+  "ice",
+  "bev",
+  "phev",
+  "hev",
+  "mhev",
+  "fcev"
+]);
+var testCycleSchema = zod.z.enum(["epa", "wltp", "mixed"]);
+var efficiencySourceSchema = zod.z.enum(["epa", "tc", "uk-vca", "eu-eea"]);
+zod.z.object({
+  makes: zod.z.array(zod.z.string().transform((val) => val.toUpperCase())).optional(),
+  models: zod.z.array(zod.z.string().transform((val) => val.toUpperCase())).optional(),
+  year: rangeSchema(1900, 2050).optional(),
+  powertrainTypes: zod.z.array(powertrainTypeSchema).optional(),
+  fuelTypes: zod.z.array(zod.z.string()).optional(),
+  sources: zod.z.array(efficiencySourceSchema).optional(),
+  testCycles: zod.z.array(testCycleSchema).optional(),
+  limit: zod.z.coerce.number().min(1).max(250).optional(),
+  offset: zod.z.coerce.number().min(0).optional(),
+  sort: zod.z.enum([
+    "make",
+    "model",
+    "year",
+    "combined_l_per_100km",
+    "combined_kwh_per_100km",
+    "co2_grams_per_km",
+    "electric_range_km"
+  ]).optional(),
+  order: zod.z.enum(["asc", "desc"]).optional()
+});
+var efficiencyDetailSchema = zod.z.object({
+  id: zod.z.number(),
+  source: efficiencySourceSchema,
+  sourceId: zod.z.string(),
+  year: zod.z.number(),
+  make: zod.z.string(),
+  model: zod.z.string(),
+  variant: zod.z.string().nullable(),
+  powertrainType: powertrainTypeSchema,
+  fuelType: zod.z.string(),
+  transmission: zod.z.string().nullable(),
+  driveType: zod.z.string().nullable(),
+  // Engine specs
+  engineDisplacementCc: zod.z.number().nullable(),
+  enginePowerKw: zod.z.number().nullable(),
+  cylinders: zod.z.number().nullable(),
+  // Fuel consumption (L/100km)
+  combinedLPer100km: zod.z.number().nullable(),
+  cityLPer100km: zod.z.number().nullable(),
+  highwayLPer100km: zod.z.number().nullable(),
+  // Electric consumption (kWh/100km)
+  combinedKwhPer100km: zod.z.number().nullable(),
+  cityKwhPer100km: zod.z.number().nullable(),
+  highwayKwhPer100km: zod.z.number().nullable(),
+  // Emissions & Range
+  co2GramsPerKm: zod.z.number().nullable(),
+  electricRangeKm: zod.z.number().nullable(),
+  totalRangeKm: zod.z.number().nullable(),
+  // Vehicle specs
+  massKg: zod.z.number().nullable(),
+  wheelbaseMm: zod.z.number().nullable(),
+  // Test info
+  testCycle: testCycleSchema
+});
+var efficiencyStatsSchema = zod.z.object({
+  totalRecords: zod.z.number(),
+  bySource: zod.z.array(
+    zod.z.object({
+      source: efficiencySourceSchema,
+      count: zod.z.number()
+    })
+  ),
+  byPowertrain: zod.z.array(
+    zod.z.object({
+      powertrainType: zod.z.string(),
+      count: zod.z.number()
+    })
+  ),
+  byTestCycle: zod.z.array(
+    zod.z.object({
+      testCycle: zod.z.string(),
+      count: zod.z.number()
+    })
+  ),
+  yearRange: zod.z.object({
+    min: zod.z.number(),
+    max: zod.z.number()
+  }),
+  topMakes: zod.z.array(
+    zod.z.object({
+      make: zod.z.string(),
+      count: zod.z.number()
+    })
+  )
+});
+zod.z.object({
+  makes: zod.z.array(zod.z.string().transform((val) => val.toUpperCase())).optional(),
+  models: zod.z.array(zod.z.string().transform((val) => val.toUpperCase())).optional(),
+  year: rangeSchema(1900, 2050).optional(),
+  vehicleClasses: zod.z.array(zod.z.string()).optional(),
+  bodyStyles: zod.z.array(zod.z.string()).optional(),
+  overallStars: zod.z.array(zod.z.string()).optional(),
+  frontalRatings: zod.z.array(zod.z.string()).optional(),
+  sideRatings: zod.z.array(zod.z.string()).optional(),
+  rolloverRatings: zod.z.array(zod.z.string()).optional(),
+  hasAdvancedSafety: zod.z.boolean().optional(),
+  limit: zod.z.coerce.number().optional(),
+  offset: zod.z.coerce.number().optional(),
+  sort: zod.z.enum([
+    "make",
+    "model",
+    "model_year",
+    "overall_stars",
+    "frontal_driver_stars",
+    "side_driver_stars",
+    "rollover_stars",
+    "vehicle_class"
+  ]).optional(),
+  order: zod.z.enum(["asc", "desc"]).optional()
+});
+zod.z.object({
+  id: zod.z.number(),
+  make: zod.z.string(),
+  model: zod.z.string(),
+  modelYear: zod.z.number().nullable(),
+  bodyStyle: zod.z.string().nullable(),
+  vehicleClass: zod.z.string().nullable(),
+  // Core Safety Ratings
+  overallStars: zod.z.string().nullable(),
+  frontalDriverStars: zod.z.string().nullable(),
+  frontalPassengerStars: zod.z.string().nullable(),
+  overallFrontalStars: zod.z.string().nullable(),
+  sideDriverStars: zod.z.string().nullable(),
+  sidePassengerStars: zod.z.string().nullable(),
+  overallSideStars: zod.z.string().nullable(),
+  sidePoleStars: zod.z.string().nullable(),
+  rolloverStars: zod.z.string().nullable(),
+  rolloverPossibility: zod.z.number().nullable(),
+  // Advanced Safety Features
+  frontCollisionWarning: zod.z.string().nullable(),
+  laneDepartureWarning: zod.z.string().nullable(),
+  crashImminentBrake: zod.z.string().nullable(),
+  blindSpotDetection: zod.z.string().nullable(),
+  backupCamera: zod.z.string().nullable(),
+  abs: zod.z.string().nullable(),
+  nhtsaEsc: zod.z.string().nullable(),
+  // Airbag Information
+  headSideAirbag: zod.z.string().nullable(),
+  torsoSideAirbag: zod.z.string().nullable(),
+  // Test Information
+  frontalTestNumber: zod.z.number().nullable(),
+  sideTestNumber: zod.z.number().nullable(),
+  poleTestNumber: zod.z.number().nullable(),
+  // Metadata
+  processedAt: zod.z.string().nullable(),
+  provider: zod.z.literal("NHTSA")
+});
+zod.z.object({
+  totalReviews: zod.z.number(),
+  reviewsWithOverallRating: zod.z.number(),
+  topMakes: zod.z.array(
+    zod.z.object({
+      make: zod.z.string(),
+      count: zod.z.number()
+    })
+  ),
+  topVehicleClasses: zod.z.array(
+    zod.z.object({
+      vehicleClass: zod.z.string(),
+      count: zod.z.number()
+    })
+  ),
+  ratingDistribution: zod.z.array(
+    zod.z.object({
+      stars: zod.z.string(),
+      count: zod.z.number()
+    })
+  ),
+  advancedSafetyFeatures: zod.z.object({
+    frontCollisionWarning: zod.z.number(),
+    laneDepartureWarning: zod.z.number(),
+    crashImminentBrake: zod.z.number(),
+    blindSpotDetection: zod.z.number(),
+    backupCamera: zod.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]
+};
+zod.z.object({
+  results: zod.z.array(locationResultSchema),
+  meta: zod.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
+  ]
+};
+zod.z.object({
+  success: zod.z.boolean(),
+  data: zod.z.array(efficiencyDetailSchema),
+  meta: zod.z.object({
+    filter: zod.z.any().optional(),
+    make: zod.z.string().optional(),
+    model: zod.z.string().optional(),
+    year: zod.z.number().optional(),
+    trim: zod.z.string().optional(),
+    count: zod.z.number(),
+    fallback: zod.z.boolean().optional()
+  })
+});
+zod.z.object({
+  success: zod.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 = zod.z.object({
+  complaintId: zod.z.number(),
+  odiNumber: zod.z.string().nullable().optional(),
+  manufacturerName: zod.z.string().nullable().optional(),
+  make: zod.z.string(),
+  model: zod.z.string(),
+  year: zod.z.number(),
+  vin: zod.z.string().nullable().optional(),
+  crashInvolved: zod.z.boolean().nullable().optional(),
+  incidentDate: zod.z.string().nullable().optional(),
+  fireInvolved: zod.z.boolean().nullable().optional(),
+  injuredCount: zod.z.number().nullable().optional(),
+  deathsCount: zod.z.number().nullable().optional(),
+  componentDescription: zod.z.string().nullable().optional(),
+  consumerCity: zod.z.string().nullable().optional(),
+  consumerState: zod.z.string().nullable().optional(),
+  dateAdded: zod.z.string().nullable().optional(),
+  dateReceived: zod.z.string().nullable().optional(),
+  mileage: zod.z.number().nullable().optional(),
+  occurrences: zod.z.number().nullable().optional(),
+  complaintDescription: zod.z.string().nullable().optional(),
+  complaintType: zod.z.string().nullable().optional(),
+  policeReportFiled: zod.z.boolean().nullable().optional(),
+  purchaseDate: zod.z.string().nullable().optional(),
+  originalOwner: zod.z.boolean().nullable().optional(),
+  productType: zod.z.string().nullable().optional(),
+  repaired: zod.z.boolean().nullable().optional(),
+  medicalAttention: zod.z.boolean().nullable().optional(),
+  vehicleTowed: zod.z.boolean().nullable().optional(),
+  processedAt: zod.z.string().nullable().optional(),
+  provider: zod.z.string().nullable().optional()
+});
+zod.z.object({
+  success: zod.z.boolean(),
+  provider: zod.z.string(),
+  data: zod.z.array(complaintSchema),
+  meta: zod.z.object({
+    filter: zod.z.any().optional(),
+    count: zod.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 reactQuery.useQuery({
+        queryKey: queryKeys.vin.decode(vin),
+        queryFn: () => client.vin.decode(vin),
+        ...options
+      });
+    },
+    useVinImage(base64, options) {
+      return reactQuery.useQuery({
+        queryKey: queryKeys.vin.image(base64),
+        queryFn: () => client.vin.image(base64),
+        ...options
+      });
+    },
+    useMarketAnalysis(vin, options) {
+      return reactQuery.useQuery({
+        queryKey: queryKeys.market.byVin(vin),
+        queryFn: () => client.market.byVin(vin),
+        ...options
+      });
+    },
+    useMarketOverview(params, options) {
+      return reactQuery.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 reactQuery.useQuery({
+        queryKey: queryKeys.market.pricing(make, model, year),
+        queryFn: () => client.market.pricing(make, model, year),
+        ...options
+      });
+    },
+    useMarketBreakdown(make, model, year, options) {
+      return reactQuery.useQuery({
+        queryKey: queryKeys.market.breakdown(make, model, year),
+        queryFn: () => client.market.breakdown(make, model, year),
+        ...options
+      });
+    },
+    useMarketOdometer(make, model, year, options) {
+      return reactQuery.useQuery({
+        queryKey: queryKeys.market.odometer(make, model, year),
+        queryFn: () => client.market.odometer(make, model, year),
+        ...options
+      });
+    },
+    useMarketGeography(make, model, year, options) {
+      return reactQuery.useQuery({
+        queryKey: queryKeys.market.geography(make, model, year),
+        queryFn: () => client.market.geography(make, model, year),
+        ...options
+      });
+    },
+    useMarketTrends(make, model, year, period, options) {
+      return reactQuery.useQuery({
+        queryKey: queryKeys.market.trends(make, model, year, period),
+        queryFn: () => client.market.trends(make, model, year, period),
+        ...options
+      });
+    },
+    useMarketPosition(listingId, options) {
+      return reactQuery.useQuery({
+        queryKey: queryKeys.market.position(listingId),
+        queryFn: () => client.market.position(listingId),
+        ...options
+      });
+    },
+    useMarketPulse(pulseOptions, queryOptions) {
+      return reactQuery.useQuery({
+        queryKey: queryKeys.market.pulse(pulseOptions),
+        queryFn: () => client.market.pulse(pulseOptions),
+        ...queryOptions
+      });
+    },
+    useLocalMarket(params, options) {
+      return reactQuery.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 reactQuery.useQuery({
+        queryKey: queryKeys.listings.search(params),
+        queryFn: () => client.listings.search(params),
+        ...options
+      });
+    },
+    useListingsCount(params, options) {
+      return reactQuery.useQuery({
+        queryKey: queryKeys.listings.count(params),
+        queryFn: () => client.listings.count(params),
+        ...options
+      });
+    },
+    useInfiniteListingsSearch(params, options) {
+      return reactQuery.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 reactQuery.useQuery({
+        queryKey: queryKeys.listings.getById(id),
+        queryFn: () => client.listings.getById(id),
+        ...options
+      });
+    },
+    useListingsFacets(params, options) {
+      return reactQuery.useQuery({
+        queryKey: queryKeys.listings.facets(params),
+        queryFn: () => client.listings.facets(params),
+        staleTime: 6e4,
+        ...options
+      });
+    },
+    useLocationsSearch(params, options) {
+      return reactQuery.useQuery({
+        queryKey: queryKeys.locations.search(params),
+        queryFn: () => client.locations.search(params),
+        ...options
+      });
+    },
+    useLocationById(id, options) {
+      return reactQuery.useQuery({
+        queryKey: queryKeys.locations.detail(id),
+        queryFn: () => client.locations.getById(id),
+        ...options
+      });
+    },
+    useFuelSearch(params, options) {
+      return reactQuery.useQuery({
+        queryKey: queryKeys.fuel.search(params),
+        queryFn: () => client.fuel.search(params),
+        ...options
+      });
+    },
+    useChargingStations(params, options) {
+      return reactQuery.useQuery({
+        queryKey: queryKeys.charging.stations(params),
+        // @ts-ignore
+        queryFn: () => client.charging.getStations(params),
+        ...options
+      });
+    },
+    useResearchLineup(make, options) {
+      return reactQuery.useQuery({
+        queryKey: queryKeys.research.lineup(make),
+        queryFn: () => client.research.lineup(make),
+        ...options
+      });
+    },
+    useResearchByMake(make, options) {
+      return reactQuery.useQuery({
+        queryKey: queryKeys.research.byMake(make),
+        queryFn: () => client.research.byMake(make),
+        ...options
+      });
+    },
+    useResearchById(id, options) {
+      return reactQuery.useQuery({
+        queryKey: queryKeys.research.byId(id),
+        queryFn: () => client.research.byId(id),
+        ...options
+      });
+    },
+    useResearchByModel(make, model, options) {
+      return reactQuery.useQuery({
+        queryKey: queryKeys.research.byModel(make, model),
+        queryFn: () => client.research.byModel(make, model),
+        ...options
+      });
+    },
+    useResearchByModelYear(make, model, year, options) {
+      return reactQuery.useQuery({
+        queryKey: queryKeys.research.byModelYear(make, model, year),
+        queryFn: () => client.research.byModelYear(make, model, year),
+        ...options
+      });
+    },
+    useResearchImages(params, options) {
+      return reactQuery.useQuery({
+        queryKey: queryKeys.research.images(params),
+        queryFn: () => client.research.getImages(params),
+        ...options
+      });
+    },
+    useResearchColors(params, options) {
+      return reactQuery.useQuery({
+        queryKey: queryKeys.research.colors(params),
+        queryFn: () => client.research.getColors(params),
+        ...options
+      });
+    },
+    useRecalls(params, options) {
+      return reactQuery.useQuery({
+        queryKey: queryKeys.recalls.search(params),
+        queryFn: () => client.recalls.search(params),
+        ...options
+      });
+    },
+    useComplaints(params, options) {
+      return reactQuery.useQuery({
+        queryKey: queryKeys.complaints.search(params),
+        queryFn: () => client.complaints.search(params),
+        ...options
+      });
+    }
+  };
+}
+
+exports.createHooks = createHooks;
+exports.queryKeys = queryKeys;