@cardog/api 0.1.1

package/dist/index.js

@@ -0,0 +1,2245 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var axios = require('axios');
+var zod = require('zod');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var axios__default = /*#__PURE__*/_interopDefault(axios);
+
+// src/base.ts
+var APIError = class extends Error {
+  constructor(message, status, code, data) {
+    super(message);
+    this.status = status;
+    this.code = code;
+    this.data = data;
+    this.name = "APIError";
+  }
+};
+var BaseClient = class {
+  constructor(config) {
+    this.config = config;
+    this.client = axios__default.default.create({
+      baseURL: config.baseUrl || "https://api.cardog.io",
+      headers: {
+        "Content-Type": "application/json",
+        ...config.apiKey && { Authorization: `Bearer ${config.apiKey}` }
+      }
+    });
+    this.setupInterceptors();
+  }
+  setConfig(config) {
+    this.config = config;
+    if (config.apiKey) {
+      this.client.defaults.headers.Authorization = `Bearer ${config.apiKey}`;
+    } else {
+      delete this.client.defaults.headers.Authorization;
+    }
+  }
+  setupInterceptors() {
+    this.client.interceptors.response.use(
+      (response) => response.data,
+      (error) => {
+        if (error.response) {
+          const { status, data } = error.response;
+          throw new APIError(
+            error.message,
+            status,
+            data?.code || "unknown_error",
+            data
+          );
+        }
+        throw error;
+      }
+    );
+  }
+  async get(path, options = {}) {
+    return this.client.get(path, {
+      headers: options.headers,
+      params: options.params
+    });
+  }
+  async post(path, data, options = {}) {
+    return this.client.post(path, data, {
+      headers: options.headers,
+      params: options.params
+    });
+  }
+  async put(path, data, options = {}) {
+    return this.client.put(path, data, {
+      headers: options.headers,
+      params: options.params
+    });
+  }
+  async patch(path, data, options = {}) {
+    return this.client.patch(path, data, {
+      headers: options.headers,
+      params: options.params
+    });
+  }
+  async delete(path, options = {}) {
+    return this.client.delete(path, {
+      headers: options.headers,
+      params: options.params
+    });
+  }
+};
+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()
+});
+var vinDecodeResponseSchema = zod.z.object({
+  // TODO: Implement this properly with correct structure
+  variants: zod.z.array(zod.z.unknown())
+  // Temporary until research schemas are ported
+});
+var vinImageResponseSchema = zod.z.object({
+  result: zod.z.string(),
+  success: zod.z.boolean()
+});
+var marketOverviewSchema = 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.");
+var pricingResponseSchema = 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")
+});
+var odometerResponseSchema = 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")
+});
+var geographicResponseSchema = 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"
+  )
+});
+var timeSeriesResponseSchema = zod.z.object({
+  trends: zod.z.array(timeSeriesPointSchema).describe("Time series data for a make/model/year cohort")
+});
+var marketAnalysisSchema = 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"])
+  })
+});
+var marketPositionSchema = 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")
+});
+var pulseResponseSchema = 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")
+});
+var breakdownResponseSchema = 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")
+});
+var localMarketResponseSchema = 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")
+});
+var demandMatrixResponseSchema = 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()
+});
+var listingSearchResponseSchema = zod.z.object({
+  listings: zod.z.array(listingSchema),
+  pagination: paginationSchema,
+  sort: listingSortSchema.optional(),
+  filters: listingFiltersSchema
+});
+var listingCountResponseSchema = 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)
+});
+var listingFacetsResponseSchema = 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"
+]);
+var locationSearchParamsSchema = 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")
+});
+var chargingStationResponseSchema = 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)
+});
+var chargingStationDetailResponseSchema = 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()
+});
+var fuelStationResponseSchema = 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()
+});
+var colorDataSchema = 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()
+});
+var lineupResponseSchema = zod.z.object({
+  data: zod.z.array(lineupItemSchema),
+  total: zod.z.coerce.number(),
+  page: zod.z.coerce.number(),
+  limit: zod.z.coerce.number()
+});
+var variantArrayResponseSchema = zod.z.array(variantSchema);
+var variantResponseSchema = variantSchema.nullable();
+var researchImageArraySchema = 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()
+);
+var listingFiltersCodec = new ListingFiltersCodec();
+var listingQueryCodec = new ListingQueryCodec();
+
+// src/routes/vin.ts
+var vinKeys = {
+  all: ["vin"],
+  image: (base64) => [...vinKeys.all, "image", base64],
+  decode: (vin) => [...vinKeys.all, "decode", vin]
+};
+var VinAPI = class extends BaseClient {
+  async decode(vin) {
+    const response = await this.get(`/vin/${vin}`);
+    return vinDecodeResponseSchema.parse(response);
+  }
+  async corgi(vin) {
+    const response = await this.get(`/vin/corgi/${vin}`);
+    return response;
+  }
+  async image(base64) {
+    const response = await this.post(`/vin/image`, {
+      image: base64
+    });
+    return vinImageResponseSchema.parse(response);
+  }
+};
+
+// 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]
+};
+var MarketAPI = class extends BaseClient {
+  constructor() {
+    super(...arguments);
+    this.analysis = async (vin) => {
+      const response = await this.get(`/market/analysis/vin/${vin}`);
+      return marketAnalysisSchema.parse(response);
+    };
+    this.overview = async (make, model, year) => {
+      const response = await this.get(
+        `/market/${make}/${model}/${year}/overview`
+      );
+      return marketOverviewSchema.parse(response);
+    };
+    this.pricing = async (make, model, year) => {
+      const response = await this.get(
+        `/market/${make}/${model}/${year}/pricing`
+      );
+      return pricingResponseSchema.parse(response);
+    };
+    this.breakdown = async (make, model, year) => {
+      const response = await this.get(
+        `/market/${make}/${model}/${year}/breakdown`
+      );
+      return breakdownResponseSchema.parse(response);
+    };
+    this.odometer = async (make, model, year) => {
+      const response = await this.get(
+        `/market/${make}/${model}/${year}/odometer`
+      );
+      return odometerResponseSchema.parse(response);
+    };
+    this.geography = async (make, model, year) => {
+      const response = await this.get(
+        `/market/${make}/${model}/${year}/geography`
+      );
+      return geographicResponseSchema.parse(response);
+    };
+    this.trends = async (make, model, year, period) => {
+      const response = await this.get(
+        `/market/${make}/${model}/${year}/trends`,
+        {
+          params: {
+            period
+          }
+        }
+      );
+      return timeSeriesResponseSchema.parse(response);
+    };
+    this.similar = async (listingId, limit) => {
+      const response = await this.get(
+        `/market/listings/${listingId}/similar`,
+        {
+          params: {
+            limit
+          }
+        }
+      );
+      return response;
+    };
+    this.position = async (listingId) => {
+      const response = await this.get(
+        `/market/listings/${listingId}/position`
+      );
+      return marketPositionSchema.parse(response);
+    };
+    this.pulse = async (options) => {
+      const response = await this.get(`/market/overview`, {
+        params: options
+      });
+      return pulseResponseSchema.parse(response);
+    };
+    this.byVin = async (vin) => {
+      return this.analysis(vin);
+    };
+    this.localMarket = async (params) => {
+      const { make, model, year, lat, lng, radius } = params;
+      const response = await this.get(
+        `/market/${make}/${model}/${year}/local`,
+        {
+          params: { lat, lng, radius }
+        }
+      );
+      return localMarketResponseSchema.parse(response);
+    };
+    this.demand = async (make, model, year) => {
+      const response = await this.get(
+        `/market/${make}/${model}/${year}/demand`
+      );
+      return demandMatrixResponseSchema.parse(response);
+    };
+  }
+};
+
+// 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]
+};
+var ListingsAPI = class extends BaseClient {
+  async search(params) {
+    const searchParams = listingQueryCodec.encode(params);
+    const response = await this.get("/listings/search", {
+      params: searchParams
+    });
+    return listingSearchResponseSchema.parse(response);
+  }
+  async count(params) {
+    const searchParams = listingQueryCodec.encode(params);
+    const response = await this.get("/listings/count", {
+      params: searchParams
+    });
+    return listingCountResponseSchema.parse(response);
+  }
+  async getById(id) {
+    const response = await this.get(`/listings/id/${id}`);
+    return listingSchema.parse(response);
+  }
+  async facets(params) {
+    const searchParams = listingQueryCodec.encode(params);
+    const response = await this.get("/listings/facets", {
+      params: searchParams
+    });
+    return listingFacetsResponseSchema.parse(response);
+  }
+  decodeSearchParams(searchParams) {
+    return listingFiltersCodec.decode(searchParams);
+  }
+  encodeFilters(filters) {
+    return listingFiltersCodec.encode(filters);
+  }
+};
+var searchResponseSchema = 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]
+};
+var LocationsAPI = class extends BaseClient {
+  async search(params) {
+    const parsed = locationSearchParamsSchema.parse(params);
+    const cleanParams = Object.fromEntries(
+      Object.entries(parsed).filter(([_, v]) => v !== void 0)
+    );
+    const response = await this.get("/locations/search", {
+      params: cleanParams
+    });
+    return searchResponseSchema.parse(response);
+  }
+  async getById(id) {
+    const response = await this.get(`/locations/id/${id}`);
+    return locationResultSchema.parse(response);
+  }
+  async getByName(name) {
+    const response = await this.get(
+      `/locations/name/${encodeURIComponent(name)}`
+    );
+    return locationResultSchema.parse(response);
+  }
+  async getBySlug(slug) {
+    const response = await this.get(`/locations/slug/${slug}`);
+    return locationResultSchema.parse(response);
+  }
+  async getByIdentifier(identifier) {
+    const response = await this.get(
+      `/locations/${encodeURIComponent(identifier)}`
+    );
+    return locationResultSchema.parse(response);
+  }
+};
+
+// src/routes/charging.ts
+var chargingKeys = {
+  all: ["charging"],
+  stations: (params) => [...chargingKeys.all, "stations", params],
+  station: (id) => [...chargingKeys.all, "station", id]
+};
+var ChargingAPI = class extends BaseClient {
+  async getStations(params) {
+    const response = await this.get("/charging", { params });
+    return chargingStationResponseSchema.parse(response);
+  }
+  async getStation(id) {
+    try {
+      const response = await this.get(`/charging/${id}`);
+      const parsed = chargingStationDetailResponseSchema.parse(response);
+      return parsed.station;
+    } catch {
+      return null;
+    }
+  }
+};
+
+// src/routes/fuel.ts
+var fuelKeys = {
+  all: ["fuel"],
+  search: (params) => [...fuelKeys.all, "search", params]
+};
+var FuelAPI = class extends BaseClient {
+  /**
+   * Search for fuel prices and stations
+   */
+  async search(params) {
+    const { fuelType, ...queryParams } = params;
+    const response = await this.get(
+      `/fuel/${fuelType.toLowerCase()}`,
+      { params: queryParams }
+    );
+    return fuelStationResponseSchema.parse(response);
+  }
+};
+
+// 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]
+};
+var ResearchAPI = class extends BaseClient {
+  async lineup(make, params) {
+    const searchParams = new URLSearchParams();
+    if (params?.page) searchParams.set("page", params.page.toString());
+    if (params?.limit) searchParams.set("limit", params.limit.toString());
+    if (params?.region) searchParams.set("region", params.region);
+    if (params?.bodyStyle) searchParams.set("bodyStyle", params.bodyStyle);
+    const query = searchParams.toString();
+    const url = `/research/lineup/${make}${query ? `?${query}` : ""}`;
+    const response = await this.get(url);
+    return lineupResponseSchema.parse(response);
+  }
+  async byMake(make) {
+    const response = await this.get(`/research/make/${make}`);
+    return variantArrayResponseSchema.parse(response);
+  }
+  async byId(id) {
+    const response = await this.get(`/research/id/${id}`);
+    return variantResponseSchema.parse(response);
+  }
+  async byListingId(listingId) {
+    const response = await this.get(`/research/listing/${listingId}`);
+    return variantResponseSchema.parse(response);
+  }
+  async byVin(vin) {
+    const response = await this.get(`/research/vin/${vin}`);
+    return variantResponseSchema.parse(response);
+  }
+  async byModel(make, model) {
+    const response = await this.get(
+      `/research/make/${make}/model/${model}`
+    );
+    return variantArrayResponseSchema.parse(response);
+  }
+  async byYear(make, year) {
+    const response = await this.get(
+      `/research/make/${make}/year/${year}`
+    );
+    return variantArrayResponseSchema.parse(response);
+  }
+  async byModelYear(make, model, year) {
+    const response = await this.get(
+      `/research/make/${make}/model/${model}/year/${year}`
+    );
+    return variantArrayResponseSchema.parse(response);
+  }
+  async getImages(params) {
+    const searchParams = new URLSearchParams({
+      make: params.make,
+      model: params.model,
+      year: params.year.toString(),
+      ...params.limit && { limit: params.limit.toString() },
+      ...params.shotType && { shotType: params.shotType },
+      ...params.category && { category: params.category }
+    });
+    const response = await this.get(
+      `/research/images?${searchParams}`
+    );
+    return researchImageArraySchema.parse(response);
+  }
+  async getProfileImages(params) {
+    const response = await this.get(
+      `/research/images/profiles/${params.make}/${params.model}/${params.year}`
+    );
+    return researchImageArraySchema.parse(response);
+  }
+  async getColors(params) {
+    const searchParams = new URLSearchParams({
+      make: params.make,
+      model: params.model,
+      year: params.year.toString()
+    });
+    const response = await this.get(
+      `/research/colors?${searchParams}`
+    );
+    return colorDataSchema.parse(response);
+  }
+};
+
+// src/routes/recalls.ts
+var recallKeys = {
+  all: ["recalls"],
+  search: (params) => [
+    ...recallKeys.all,
+    "search",
+    params.country,
+    params.makes,
+    params.models,
+    params.year
+  ]
+};
+var RecallsAPI = class extends BaseClient {
+  constructor() {
+    super(...arguments);
+    this.search = async (params) => {
+      const response = await this.get(
+        `/recalls/${params.country}/search`,
+        {
+          params: {
+            yearMin: params.year?.min,
+            yearMax: params.year?.max,
+            makes: params.makes?.join(","),
+            models: params.models?.join(","),
+            limit: params.limit,
+            offset: params.offset,
+            sort: params.sort,
+            order: params.order
+          }
+        }
+      );
+      return recallResponseSchema.parse(response);
+    };
+  }
+};
+var efficiencyResponseSchema = 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()
+  })
+});
+var efficiencyStatsResponseSchema = 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 EfficiencyAPI = class extends BaseClient {
+  constructor() {
+    super(...arguments);
+    this.search = async (params) => {
+      const response = await this.get("/efficiency/search", {
+        params: {
+          makes: params.makes?.join(","),
+          models: params.models?.join(","),
+          yearMin: params.year?.min,
+          yearMax: params.year?.max,
+          powertrainTypes: params.powertrainTypes?.join(","),
+          fuelTypes: params.fuelTypes?.join(","),
+          sources: params.sources?.join(","),
+          testCycles: params.testCycles?.join(","),
+          limit: params.limit,
+          offset: params.offset,
+          sort: params.sort,
+          order: params.order
+        }
+      });
+      return efficiencyResponseSchema.parse(response);
+    };
+    this.byVehicle = async (make, model, year) => {
+      const response = await this.get(
+        `/efficiency/${encodeURIComponent(make)}/${encodeURIComponent(model)}/${year}`
+      );
+      return efficiencyResponseSchema.parse(response);
+    };
+    this.byVehicleTrim = async (make, model, year, trim) => {
+      const response = await this.get(
+        `/efficiency/${encodeURIComponent(make)}/${encodeURIComponent(model)}/${year}/${encodeURIComponent(trim)}`
+      );
+      return efficiencyResponseSchema.parse(response);
+    };
+    this.stats = async () => {
+      const response = await this.get("/efficiency/stats/overview");
+      return efficiencyStatsResponseSchema.parse(response);
+    };
+  }
+};
+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()
+});
+var complaintsResponseSchema = 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]
+};
+var ComplaintsAPI = class extends BaseClient {
+  constructor() {
+    super(...arguments);
+    this.search = async (params) => {
+      const response = await this.get("/complaints/search", {
+        params: {
+          makes: params.makes?.join(","),
+          models: params.models?.join(","),
+          yearMin: params.year?.min,
+          yearMax: params.year?.max,
+          components: params.components?.join(","),
+          limit: params.limit,
+          offset: params.offset,
+          sort: params.sort,
+          order: params.order
+        }
+      });
+      return complaintsResponseSchema.parse(response);
+    };
+  }
+};
+
+// 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
+};
+var CardogClient = class {
+  constructor(config = {}) {
+    this.vin = new VinAPI(config);
+    this.market = new MarketAPI(config);
+    this.listings = new ListingsAPI(config);
+    this.locations = new LocationsAPI(config);
+    this.fuel = new FuelAPI(config);
+    this.charging = new ChargingAPI(config);
+    this.research = new ResearchAPI(config);
+    this.recalls = new RecallsAPI(config);
+    this.efficiency = new EfficiencyAPI(config);
+    this.complaints = new ComplaintsAPI(config);
+  }
+  setConfig(config) {
+    this.vin.setConfig(config);
+    this.market.setConfig(config);
+    this.listings.setConfig(config);
+    this.locations.setConfig(config);
+    this.fuel.setConfig(config);
+    this.charging.setConfig(config);
+    this.research.setConfig(config);
+    this.recalls.setConfig(config);
+    this.efficiency.setConfig(config);
+    this.complaints.setConfig(config);
+  }
+};
+var index_default = CardogClient;
+
+exports.APIError = APIError;
+exports.CardogClient = CardogClient;
+exports.ChargingAPI = ChargingAPI;
+exports.ComplaintsAPI = ComplaintsAPI;
+exports.EfficiencyAPI = EfficiencyAPI;
+exports.FuelAPI = FuelAPI;
+exports.FuelType = FuelType;
+exports.ListingsAPI = ListingsAPI;
+exports.LocationsAPI = LocationsAPI;
+exports.MarketAPI = MarketAPI;
+exports.RecallsAPI = RecallsAPI;
+exports.ResearchAPI = ResearchAPI;
+exports.VinAPI = VinAPI;
+exports.chargingKeys = chargingKeys;
+exports.complaintSchema = complaintSchema;
+exports.complaintsKeys = complaintsKeys;
+exports.complaintsResponseSchema = complaintsResponseSchema;
+exports.default = index_default;
+exports.efficiencyKeys = efficiencyKeys;
+exports.efficiencyResponseSchema = efficiencyResponseSchema;
+exports.efficiencyStatsResponseSchema = efficiencyStatsResponseSchema;
+exports.fuelKeys = fuelKeys;
+exports.listingSchema = listingSchema;
+exports.listingsKeys = listingsKeys;
+exports.locationsKeys = locationsKeys;
+exports.marketKeys = marketKeys;
+exports.queryKeys = queryKeys;
+exports.recallKeys = recallKeys;
+exports.researchKeys = researchKeys;
+exports.vinKeys = vinKeys;