scrapebadger 0.4.0 → 0.7.0

package/dist/index.d.ts

@@ -6,100 +6,99 @@ import 'node:events';
  * TypeScript types for web scraping API responses.
  */
 interface ScrapeOptions {
+    /** Output format */
+    format?: "html" | "markdown" | "text";
     /** Whether to render JavaScript */
     renderJs?: boolean;
-    /** Output format (html, markdown, text, json) */
-    outputFormat?: "html" | "markdown" | "text" | "json";
-    /** Country code for proxy (e.g. "US") */
-    proxyCountry?: string;
-    /** Proxy type (datacenter, residential) */
-    proxyType?: "datacenter" | "residential" | "mobile" | "isp";
-    /** Reuse an existing session */
-    sessionId?: string;
-    /** Force a specific engine */
-    engine?: string;
-    /** Maximum credit cost */
-    maxCost?: number;
-    /** Custom HTTP headers */
-    headers?: Record<string, string>;
-    /** CSS selector to wait for */
+    /** Force a specific engine (auto, browser) */
+    engine?: "auto" | "browser";
+    /** CSS selector or XPath to wait for */
     waitFor?: string;
-    /** Request timeout in seconds */
-    timeout?: number;
-    /** JavaScript actions to execute */
+    /** Timeout in ms for waitFor selector (1000-120000) */
+    waitTimeout?: number;
+    /** Additional ms to wait after page load (0-30000) */
+    waitAfterLoad?: number;
+    /** Browser actions to perform before extracting */
     jsScenario?: Array<Record<string, unknown>>;
-}
-interface ScreenshotOptions {
-    /** Capture full page (not just viewport) */
-    fullPage?: boolean;
-    /** Viewport width in pixels */
-    viewportWidth?: number;
-    /** Viewport height in pixels */
-    viewportHeight?: number;
-    /** Image format (png, jpeg) */
-    imageFormat?: "png" | "jpeg";
-    /** CSS selector to wait for */
-    waitFor?: string;
-    /** Request timeout in seconds */
-    timeout?: number;
-}
-interface ExtractOptions {
-    /** Extraction schema (CSS/XPath selectors) */
-    schema?: Record<string, unknown>;
-    /** Whether to render JavaScript */
-    renderJs?: boolean;
-    /** CSS selector to wait for */
-    waitFor?: string;
-    /** Request timeout in seconds */
-    timeout?: number;
-}
-interface BatchOptions {
-    /** Whether to render JavaScript */
-    renderJs?: boolean;
-    /** Output format */
-    outputFormat?: "html" | "markdown" | "text" | "json";
-    /** Maximum concurrent requests */
-    maxConcurrency?: number;
-    /** Force a specific engine */
-    engine?: string;
-    /** Request timeout in seconds */
-    timeout?: number;
+    /** Session ID for persistent cookies/state */
+    sessionId?: string;
+    /** Max retry attempts on blocking (0-10) */
+    retryCount?: number;
+    /** Auto-retry on blocking detection */
+    retryOnBlock?: boolean;
+    /** ISO country code for proxy geo-targeting */
+    country?: string;
+    /** Custom HTTP headers */
+    customHeaders?: Record<string, string>;
+    /** Capture full-page screenshot */
+    screenshot?: boolean;
+    /** Record browser session as video (+3 credits) */
+    video?: boolean;
+    /** Attempt anti-bot bypass */
+    antiBot?: boolean;
+    /** Allow auto-escalation to stronger engines */
+    escalate?: boolean;
+    /** Maximum credits budget */
+    maxCost?: number;
+    /** Run AI extraction on content */
+    aiExtract?: boolean;
+    /** Natural language prompt for AI extraction (max 2000 chars) */
+    aiPrompt?: string;
+    /**
+     * When true, the server streams the raw body as `text/html` with
+     * metadata in `X-Scrape-*` response headers instead of JSON-wrapping
+     * the content. Saves 300–1000 ms on large (>1 MB) pages. Incompatible
+     * with `aiExtract`, `screenshot`, `video`.
+     */
+    rawContent?: boolean;
+    /**
+     * When true, the server skips the generic blocking-page + anti-bot /
+     * CAPTCHA regex scans on the response body. Saves ~1.3 s on large
+     * responses. Only safe for origins known not to use consumer WAFs
+     * (Cloudflare, DataDome, Akamai, Kasada). Default false — keep
+     * disabled for general-purpose scraping.
+     */
+    skipBotDetection?: boolean;
 }
 interface ScrapeResult {
-    content: string;
-    status_code: number;
+    success: boolean;
     url: string;
-    engine_used?: string;
-    credits_used: number;
-    processing_time_ms?: number;
-    anti_bot_detected: boolean;
-    anti_bot_provider?: string;
-    captcha_solved: boolean;
-    session_id?: string;
-    session_reused: boolean;
-}
-interface ScreenshotResult {
-    image_data: string;
+    status_code: number;
+    content: string | null;
     format: string;
-    url: string;
+    engine_used: string;
     credits_used: number;
+    duration_ms: number;
+    retries_used: number;
+    content_length: number;
+    screenshot_url: string | null;
+    video_url: string | null;
+    headers: Record<string, string>;
+    blocking_detected: boolean;
+    blocking_details: Record<string, unknown> | null;
+    antibot_systems: Array<Record<string, unknown>>;
+    captcha_systems: Array<Record<string, unknown>>;
+    anti_bot_solved: boolean;
+    solver_used: string | null;
+    ai_extraction: Record<string, unknown> | string | unknown[] | null;
+    ai_model: string | null;
+    ai_error: string | null;
+}
+interface DetectOptions {
+    /** Request timeout in ms (1000-60000) */
+    timeout?: number;
+    /** ISO country code for proxy geo-targeting */
+    country?: string;
 }
-interface ExtractResult {
-    data: Record<string, unknown>;
+interface DetectResult {
     url: string;
+    antibot_systems: Array<Record<string, unknown>>;
+    captcha_systems: Array<Record<string, unknown>>;
+    is_blocked: boolean;
+    blocking_type: string | null;
+    recommendation: string | null;
     credits_used: number;
-}
-interface BatchResult {
-    results: ScrapeResult[];
-    total: number;
-    successful: number;
-    failed: number;
-}
-interface SessionInfo {
-    session_id: string;
-    domain: string;
-    reused: boolean;
-    fingerprint_id?: string;
+    duration_ms: number;
 }
 
 /**
@@ -114,19 +113,24 @@ interface SessionInfo {
  * const client = new ScrapeBadger({ apiKey: "key" });
  *
  * // Simple scrape
- * const result = await client.web.scrape("https://example.com");
+ * const result = await client.web.scrape("https://scrapebadger.com");
  * console.log(result.content);
  *
- * // Screenshot
- * const screenshot = await client.web.screenshot("https://example.com");
- *
- * // Extract structured data
- * const data = await client.web.extract("https://example.com", {
- *   schema: { title: "css:h1" }
+ * // Scrape with JavaScript rendering
+ * const rendered = await client.web.scrape("https://scrapebadger.com", {
+ *   renderJs: true,
+ *   format: "markdown",
  * });
  *
- * // Batch scrape
- * const batch = await client.web.batch(["https://a.com", "https://b.com"]);
+ * // AI extraction
+ * const extracted = await client.web.extract(
+ *   "https://scrapebadger.com/pricing",
+ *   "Extract all pricing plans with their features"
+ * );
+ *
+ * // Detect anti-bot systems
+ * const detection = await client.web.detect("https://scrapebadger.com");
+ * console.log(detection.antibot_systems);
  * ```
  */
 declare class WebClient {
@@ -134,28 +138,1822 @@ declare class WebClient {
     constructor(client: BaseClient);
     /**
      * Scrape a web page.
+     *
+     * @param url - The URL to scrape
+     * @param options - Scrape configuration options
+     * @returns The scrape result including content, metadata, and credit usage
      */
     scrape(url: string, options?: ScrapeOptions): Promise<ScrapeResult>;
     /**
-     * Take a screenshot of a web page.
+     * Extract structured data from a web page using AI.
+     *
+     * Convenience wrapper around {@link scrape} that enables AI extraction
+     * with the given prompt and defaults to markdown format.
+     *
+     * @param url - The URL to extract data from
+     * @param prompt - Natural language prompt describing what to extract (max 2000 chars)
+     * @param options - Additional scrape options (aiExtract and aiPrompt are set automatically)
+     * @returns The scrape result with ai_extraction populated
+     */
+    extract(url: string, prompt: string, options?: ScrapeOptions): Promise<ScrapeResult>;
+    /**
+     * Detect anti-bot systems on a URL.
+     *
+     * @param url - The URL to analyze
+     * @param options - Detection options
+     * @returns Detection results including identified anti-bot and captcha systems
+     */
+    detect(url: string, options?: DetectOptions): Promise<DetectResult>;
+}
+
+/**
+ * TypeScript types for Vinted API responses.
+ *
+ * This module contains all the data types used by the Vinted API client.
+ */
+/**
+ * A price with amount and currency.
+ */
+interface VintedPrice {
+    /** Price amount as a string (e.g. "12.50") */
+    amount: string;
+    /** ISO currency code (e.g. "EUR") */
+    currency_code: string;
+}
+/**
+ * A photo attached to a Vinted item.
+ */
+interface VintedPhoto {
+    /** Unique photo identifier */
+    id: number;
+    /** Photo URL */
+    url: string;
+    /** Dominant color hex code */
+    dominant_color: string | null;
+    /** Whether this is the main/cover photo */
+    is_main: boolean;
+    /** Image width in pixels */
+    width: number | null;
+    /** Image height in pixels */
+    height: number | null;
+    /** Full resolution image URL */
+    full_size_url: string | null;
+}
+/**
+ * Brief user information shown on item listings.
+ */
+interface VintedUserSummary {
+    /** Unique user identifier */
+    id: number;
+    /** Username / login handle */
+    login: string;
+    /** Profile photo URL */
+    photo_url: string | null;
+    /** Whether the user is a business account */
+    business: boolean;
+}
+/**
+ * Seller summary with feedback and item stats.
+ */
+interface VintedSellerSummary extends VintedUserSummary {
+    /** Total number of feedback ratings */
+    feedback_count: number;
+    /** Overall feedback reputation score (0-1) */
+    feedback_reputation: number;
+    /** Number of items listed */
+    item_count: number;
+    /** Seller's location */
+    location: string | null;
+    /** Last activity timestamp (ISO format) */
+    last_seen: string | null;
+    /** Achievement badges */
+    badges: string[];
+}
+/**
+ * A Vinted item summary as returned in search results and listings.
+ */
+interface VintedItemSummary {
+    /** Unique item identifier */
+    id: number;
+    /** Item title */
+    title: string;
+    /** Item price */
+    price: VintedPrice;
+    /** Brand name */
+    brand_title: string;
+    /** Size label */
+    size_title: string;
+    /** Item condition status */
+    status: string;
+    /** Item URL on Vinted */
+    url: string;
+    /** Number of users who favorited this item */
+    favourite_count: number;
+    /** Number of views */
+    view_count: number;
+    /** Item owner summary */
+    user: VintedUserSummary;
+    /** Main photo */
+    photo: VintedPhoto;
+    /** All photos */
+    photos: VintedPhoto[];
+}
+/**
+ * Full item detail with all metadata.
+ */
+interface VintedItemDetail extends VintedItemSummary {
+    /** Item description */
+    description: string;
+    /** Catalog category identifier */
+    catalog_id: number;
+    /** Primary color */
+    color1: string;
+    /** Seller details */
+    seller: VintedSellerSummary;
+    /** Category name */
+    category: string;
+    /** Upload timestamp (ISO format) */
+    upload_date: string;
+    /** Whether the item can be purchased */
+    can_buy: boolean;
+    /** Whether instant buy is enabled */
+    instant_buy: boolean;
+    /** Whether the listing is closed */
+    is_closed: boolean;
+    /** Whether the item is reserved */
+    is_reserved: boolean;
+    /** Whether the item is hidden */
+    is_hidden: boolean;
+    /** Size identifier */
+    size_id: number;
+    /** Status identifier */
+    status_id: number;
+    /** Brand identifier */
+    brand_id: number;
+}
+/**
+ * Full Vinted user profile.
+ */
+interface VintedUserProfile {
+    /** Unique user identifier */
+    id: number;
+    /** Username / login handle */
+    login: string;
+    /** Profile photo URL */
+    photo_url: string | null;
+    /** Whether the user is a business account */
+    business: boolean;
+    /** ISO country code */
+    country_code: string;
+    /** City name */
+    city: string;
+    /** Total feedback count */
+    feedback_count: number;
+    /** Overall feedback reputation (0-1) */
+    feedback_reputation: number;
+    /** Number of positive ratings */
+    positive_feedback_count: number;
+    /** Number of neutral ratings */
+    neutral_feedback_count: number;
+    /** Number of negative ratings */
+    negative_feedback_count: number;
+    /** Number of items listed */
+    item_count: number;
+    /** Number of followers */
+    followers_count: number;
+    /** Number of users this user follows */
+    following_count: number;
+    /** Whether the user is currently online */
+    is_online: boolean;
+    /** Whether the user is on holiday mode */
+    is_on_holiday: boolean;
+    /** Last login timestamp (Unix) */
+    last_loged_on_ts: string;
+    /** Full profile URL */
+    profile_url: string;
+    /** User locale */
+    locale: string;
+}
+/**
+ * A Vinted brand.
+ */
+interface VintedBrand {
+    /** Unique brand identifier */
+    id: number;
+    /** Brand name */
+    title: string;
+    /** URL-friendly slug */
+    slug: string;
+    /** Number of items with this brand */
+    item_count: number;
+    /** Number of users who favorited this brand */
+    favourite_count: number;
+    /** Whether the brand is classified as luxury */
+    is_luxury: boolean;
+    /** Brand page URL */
+    url: string;
+}
+/**
+ * A Vinted color option.
+ */
+interface VintedColor {
+    /** Unique color identifier */
+    id: number;
+    /** Color display name */
+    title: string;
+    /** Hex color code */
+    hex: string;
+    /** Internal color code */
+    code: string;
+}
+/**
+ * A Vinted item condition status.
+ */
+interface VintedStatus {
+    /** Unique status identifier */
+    id: number;
+    /** Status display name */
+    title: string;
+}
+/**
+ * A Vinted marketplace/country.
+ */
+interface VintedMarket {
+    /** Market code (e.g. "fr", "de") */
+    code: string;
+    /** Vinted domain for this market */
+    domain: string;
+    /** Country name */
+    country: string;
+    /** Currency code */
+    currency: string;
+    /** Market display name */
+    name: string;
+}
+/**
+ * Pagination metadata for list responses.
+ */
+interface VintedPagination {
+    /** Current page number */
+    current_page: number;
+    /** Total number of pages */
+    total_pages: number;
+    /** Total number of entries */
+    total_entries: number;
+    /** Items per page */
+    per_page: number;
+}
+/**
+ * Response from the search endpoint.
+ */
+interface SearchResponse {
+    /** List of matching items */
+    items: VintedItemSummary[];
+    /** Pagination metadata */
+    pagination: VintedPagination;
+    /** Market code used for this search */
+    market: string;
+}
+/**
+ * Response from the item detail endpoint.
+ */
+interface ItemDetailResponse {
+    /** Full item details */
+    item: VintedItemDetail;
+    /** Market code used */
+    market: string;
+}
+/**
+ * Response from the user profile endpoint.
+ */
+interface UserProfileResponse {
+    /** Full user profile */
+    user: VintedUserProfile;
+    /** Market code used */
+    market: string;
+}
+/**
+ * Response from the user items endpoint.
+ */
+interface UserItemsResponse {
+    /** List of user's items */
+    items: VintedItemSummary[];
+    /** Pagination metadata */
+    pagination: VintedPagination;
+    /** Market code used */
+    market: string;
+}
+/**
+ * Response from the brands endpoint.
+ */
+interface BrandsResponse {
+    /** List of brands */
+    brands: VintedBrand[];
+    /** Pagination metadata (null when no pagination) */
+    pagination: VintedPagination | null;
+}
+/**
+ * Response from the colors endpoint.
+ */
+interface ColorsResponse {
+    /** List of available colors */
+    colors: VintedColor[];
+}
+/**
+ * Response from the statuses endpoint.
+ */
+interface StatusesResponse {
+    /** List of item condition statuses */
+    statuses: VintedStatus[];
+}
+/**
+ * Response from the markets endpoint.
+ */
+interface MarketsResponse {
+    /** List of available markets */
+    markets: VintedMarket[];
+}
+/**
+ * Parameters for searching Vinted items.
+ */
+interface VintedSearchParams {
+    /** Search query string */
+    query: string;
+    /** Market code (default: "fr") */
+    market?: string;
+    /** Page number */
+    page?: number;
+    /** Items per page */
+    per_page?: number;
+    /** Minimum price filter */
+    price_from?: number;
+    /** Maximum price filter */
+    price_to?: number;
+    /** Comma-separated brand IDs */
+    brand_ids?: string;
+    /** Comma-separated color IDs */
+    color_ids?: string;
+    /** Comma-separated status IDs */
+    status_ids?: string;
+    /** Sort order */
+    order?: "relevance" | "newest_first" | "price_low_to_high" | "price_high_to_low";
+}
+
+/**
+ * Vinted Search API client.
+ *
+ * Provides methods for searching Vinted item listings.
+ */
+
+/**
+ * Client for Vinted search endpoints.
+ *
+ * @example
+ * ```typescript
+ * const client = new ScrapeBadger({ apiKey: "key" });
+ *
+ * // Basic search
+ * const results = await client.vinted.search.search({ query: "nike air max" });
+ * for (const item of results.items) {
+ *   console.log(`${item.title} — ${item.price.amount} ${item.price.currency_code}`);
+ * }
+ *
+ * // Search with filters
+ * const filtered = await client.vinted.search.search({
+ *   query: "adidas",
+ *   market: "de",
+ *   price_from: 10,
+ *   price_to: 50,
+ *   order: "price_low_to_high",
+ * });
+ * ```
+ */
+declare class SearchClient$1 {
+    private readonly client;
+    constructor(client: BaseClient);
+    /**
+     * Search for Vinted items.
+     *
+     * @param params - Search parameters including query, filters, and pagination.
+     * @returns Search results with items and pagination metadata.
+     * @throws AuthenticationError - If the API key is invalid.
+     * @throws ValidationError - If the search parameters are invalid.
+     *
+     * @example
+     * ```typescript
+     * const results = await client.vinted.search.search({
+     *   query: "vintage jacket",
+     *   market: "fr",
+     *   page: 1,
+     *   per_page: 20,
+     *   order: "newest_first",
+     * });
+     * console.log(`Found ${results.pagination.total_entries} items`);
+     * ```
+     */
+    search(params: VintedSearchParams): Promise<SearchResponse>;
+}
+
+/**
+ * Vinted Items API client.
+ *
+ * Provides methods for fetching individual Vinted item details.
+ */
+
+/**
+ * Client for Vinted item endpoints.
+ *
+ * @example
+ * ```typescript
+ * const client = new ScrapeBadger({ apiKey: "key" });
+ *
+ * const item = await client.vinted.items.get(123456789, { market: "fr" });
+ * console.log(`${item.item.title} — ${item.item.price.amount} ${item.item.price.currency_code}`);
+ * console.log(`Seller: ${item.item.seller.login}`);
+ * ```
+ */
+declare class ItemsClient {
+    private readonly client;
+    constructor(client: BaseClient);
+    /**
+     * Get a single item by ID.
+     *
+     * @param itemId - The Vinted item ID to fetch.
+     * @param options - Optional parameters.
+     * @param options.market - Market code (default: "fr").
+     * @returns The item detail response including full item data.
+     * @throws NotFoundError - If the item doesn't exist.
+     * @throws AuthenticationError - If the API key is invalid.
+     *
+     * @example
+     * ```typescript
+     * const response = await client.vinted.items.get(123456789);
+     * const { item } = response;
+     * console.log(`${item.title}: ${item.description}`);
+     * console.log(`Brand: ${item.brand_title}, Size: ${item.size_title}`);
+     * console.log(`Photos: ${item.photos.length}`);
+     * ```
+     */
+    get(itemId: number, options?: {
+        market?: string;
+    }): Promise<ItemDetailResponse>;
+}
+
+/**
+ * Vinted Users API client.
+ *
+ * Provides methods for fetching Vinted user profiles and their item listings.
+ */
+
+/**
+ * Client for Vinted user endpoints.
+ *
+ * @example
+ * ```typescript
+ * const client = new ScrapeBadger({ apiKey: "key" });
+ *
+ * // Get user profile
+ * const profile = await client.vinted.users.getProfile(12345);
+ * console.log(`${profile.user.login} — ${profile.user.item_count} items`);
+ *
+ * // Get user's items
+ * const items = await client.vinted.users.getItems(12345);
+ * for (const item of items.items) {
+ *   console.log(`${item.title} — ${item.price.amount} ${item.price.currency_code}`);
+ * }
+ * ```
+ */
+declare class UsersClient {
+    private readonly client;
+    constructor(client: BaseClient);
+    /**
+     * Get a user's profile.
+     *
+     * @param userId - The Vinted user ID.
+     * @param options - Optional parameters.
+     * @param options.market - Market code (default: "fr").
+     * @returns The user profile response.
+     * @throws NotFoundError - If the user doesn't exist.
+     * @throws AuthenticationError - If the API key is invalid.
+     *
+     * @example
+     * ```typescript
+     * const response = await client.vinted.users.getProfile(12345);
+     * const { user } = response;
+     * console.log(`${user.login} from ${user.city}, ${user.country_code}`);
+     * console.log(`Reputation: ${user.feedback_reputation}`);
+     * console.log(`Items: ${user.item_count}, Followers: ${user.followers_count}`);
+     * ```
+     */
+    getProfile(userId: number, options?: {
+        market?: string;
+    }): Promise<UserProfileResponse>;
+    /**
+     * Get items listed by a user.
+     *
+     * @param userId - The Vinted user ID.
+     * @param options - Optional parameters for pagination and market.
+     * @param options.market - Market code (default: "fr").
+     * @param options.page - Page number.
+     * @param options.per_page - Items per page.
+     * @returns The user's items with pagination metadata.
+     * @throws NotFoundError - If the user doesn't exist.
+     * @throws AuthenticationError - If the API key is invalid.
+     *
+     * @example
+     * ```typescript
+     * const response = await client.vinted.users.getItems(12345, {
+     *   market: "de",
+     *   page: 1,
+     *   per_page: 20,
+     * });
+     * console.log(`Page ${response.pagination.current_page} of ${response.pagination.total_pages}`);
+     * for (const item of response.items) {
+     *   console.log(`${item.title} — ${item.price.amount} ${item.price.currency_code}`);
+     * }
+     * ```
      */
-    screenshot(url: string, options?: ScreenshotOptions): Promise<ScreenshotResult>;
+    getItems(userId: number, options?: {
+        market?: string;
+        page?: number;
+        per_page?: number;
+    }): Promise<UserItemsResponse>;
+}
+
+/**
+ * Vinted Reference Data API client.
+ *
+ * Provides methods for fetching brands, colors, statuses, and markets.
+ */
+
+/**
+ * Client for Vinted reference data endpoints.
+ *
+ * @example
+ * ```typescript
+ * const client = new ScrapeBadger({ apiKey: "key" });
+ *
+ * // Get available markets
+ * const markets = await client.vinted.reference.markets();
+ * for (const market of markets.markets) {
+ *   console.log(`${market.name} (${market.code}) — ${market.currency}`);
+ * }
+ *
+ * // Search brands
+ * const brands = await client.vinted.reference.brands({ keyword: "nike" });
+ * for (const brand of brands.brands) {
+ *   console.log(`${brand.title}: ${brand.item_count} items`);
+ * }
+ * ```
+ */
+declare class ReferenceClient {
+    private readonly client;
+    constructor(client: BaseClient);
     /**
-     * Extract structured data from a web page.
+     * Search for brands by keyword.
+     *
+     * @param options - Optional parameters.
+     * @param options.keyword - Brand name to search for.
+     * @param options.market - Market code (default: "fr").
+     * @param options.per_page - Number of results per page.
+     * @returns Brands matching the keyword.
+     *
+     * @example
+     * ```typescript
+     * const response = await client.vinted.reference.brands({
+     *   keyword: "adidas",
+     *   market: "de",
+     *   per_page: 10,
+     * });
+     * for (const brand of response.brands) {
+     *   console.log(`${brand.title} (${brand.slug}): ${brand.item_count} items`);
+     * }
+     * ```
      */
-    extract(url: string, options?: ExtractOptions): Promise<ExtractResult>;
+    brands(options?: {
+        keyword?: string;
+        market?: string;
+        per_page?: number;
+    }): Promise<BrandsResponse>;
     /**
-     * Scrape multiple URLs in a batch.
+     * Get available colors for a market.
+     *
+     * @param options - Optional parameters.
+     * @param options.market - Market code (default: "fr").
+     * @returns List of available colors.
+     *
+     * @example
+     * ```typescript
+     * const response = await client.vinted.reference.colors({ market: "fr" });
+     * for (const color of response.colors) {
+     *   console.log(`${color.title} (#${color.hex})`);
+     * }
+     * ```
      */
-    batch(urls: string[], options?: BatchOptions): Promise<BatchResult>;
+    colors(options?: {
+        market?: string;
+    }): Promise<ColorsResponse>;
     /**
-     * Create a new scraping session for a domain.
+     * Get available item condition statuses for a market.
+     *
+     * @param options - Optional parameters.
+     * @param options.market - Market code (default: "fr").
+     * @returns List of item condition statuses.
+     *
+     * @example
+     * ```typescript
+     * const response = await client.vinted.reference.statuses({ market: "fr" });
+     * for (const status of response.statuses) {
+     *   console.log(`${status.id}: ${status.title}`);
+     * }
+     * ```
      */
-    createSession(domain: string, persist?: boolean): Promise<SessionInfo>;
+    statuses(options?: {
+        market?: string;
+    }): Promise<StatusesResponse>;
     /**
-     * Scrape using an existing session.
+     * Get all available Vinted markets.
+     *
+     * @returns List of all supported Vinted markets/countries.
+     *
+     * @example
+     * ```typescript
+     * const response = await client.vinted.reference.markets();
+     * for (const market of response.markets) {
+     *   console.log(`${market.name}: ${market.domain} (${market.currency})`);
+     * }
+     * ```
      */
-    reuseSession(url: string, sessionId: string, options?: ScrapeOptions): Promise<ScrapeResult>;
+    markets(): Promise<MarketsResponse>;
+}
+
+/**
+ * Vinted API client.
+ *
+ * Provides access to all Vinted API endpoints through specialized sub-clients.
+ */
+
+/**
+ * Vinted API client with access to all Vinted endpoints.
+ *
+ * Provides sub-clients for different resource types:
+ * - `search` - Search for items across Vinted marketplaces
+ * - `items` - Get individual item details
+ * - `users` - User profiles and their item listings
+ * - `reference` - Reference data (brands, colors, statuses, markets)
+ *
+ * @example
+ * ```typescript
+ * const client = new ScrapeBadger({ apiKey: "key" });
+ *
+ * // Search items
+ * const results = await client.vinted.search.search({ query: "nike air max" });
+ *
+ * // Get item details
+ * const item = await client.vinted.items.get(123456789);
+ *
+ * // Get user profile
+ * const user = await client.vinted.users.getProfile(12345);
+ *
+ * // Get reference data
+ * const markets = await client.vinted.reference.markets();
+ * ```
+ */
+declare class VintedClient {
+    /** Client for item search operations */
+    readonly search: SearchClient$1;
+    /** Client for individual item operations */
+    readonly items: ItemsClient;
+    /** Client for user operations */
+    readonly users: UsersClient;
+    /** Client for reference data (brands, colors, statuses, markets) */
+    readonly reference: ReferenceClient;
+    /**
+     * Create a new Vinted client.
+     *
+     * @param client - The base HTTP client for making requests.
+     */
+    constructor(client: BaseClient);
+}
+
+/**
+ * TypeScript parameter types for Google Scraper API sub-clients.
+ *
+ * Response types use `Record<string, unknown>` rather than strict interfaces
+ * because the Google API returns rich nested data that mirrors the server-side
+ * Pydantic models; users can cast to their own typed shapes as needed. All
+ * parameter types are strictly typed.
+ */
+type GoogleResponse = Record<string, unknown>;
+interface GoogleSearchParams {
+    q: string;
+    gl?: string;
+    hl?: string;
+    num?: number;
+    start?: number;
+    domain?: string;
+    device?: "desktop" | "mobile";
+    location?: string;
+    lr?: string;
+    tbs?: string;
+    safe?: "off" | "medium" | "high";
+    uule?: string;
+    filter?: number;
+    nfpr?: number;
+    cr?: string;
+    ludocid?: string;
+    lsig?: string;
+    kgmid?: string;
+    si?: string;
+    ibp?: string;
+    uds?: string;
+    /**
+     * When true, chase Google's deferred AI Overview `page_token` with a
+     * follow-up fetch and merge the result back into `ai_overview`. Adds
+     * ~1s when the SERP actually defers the overview. Credit cost is
+     * configured per-endpoint by admins — query `/public/pricing` for the
+     * live rate.
+     */
+    ai_overview?: boolean;
+}
+interface MapsSearchParams {
+    /** Search query. Required unless `place_id` or `ludocid` is supplied. */
+    q?: string;
+    /** GPS coords as `@lat,lng,zoom` (e.g. `@40.745,-74.008,14z`). */
+    ll?: string;
+    gl?: string;
+    hl?: string;
+    start?: number;
+    /** 1-indexed page number (alternative to `start`). */
+    page?: number;
+    /** Business-type slug (e.g. `restaurant`, `hotel`). */
+    type?: string;
+    /** Raw Google Maps `pb=` override for advanced queries. */
+    data?: string;
+    /** Google Place ID (`ChIJ...`) — direct-lookup a single place. */
+    place_id?: string;
+    /** Google Location Document ID (CID) — direct-lookup by CID. */
+    ludocid?: string;
+}
+interface MapsPlaceParams {
+    place_id?: string;
+    data_id?: string;
+    hl?: string;
+    gl?: string;
+}
+interface MapsReviewsParams {
+    data_id: string;
+    sort_by?: "qualityScore" | "newestFirst" | "ratingHigh" | "ratingLow";
+    hl?: string;
+    next_page_token?: string;
+    results?: number;
+}
+interface MapsPhotosParams {
+    data_id: string;
+    hl?: string;
+    next_page_token?: string;
+}
+interface MapsPostsParams {
+    /** Google Maps data ID (`0x...:0x...`). Required unless `place_id` is set. */
+    data_id?: string;
+    /** Google Place ID — alternative to `data_id`. */
+    place_id?: string;
+    hl?: string;
+    gl?: string;
+    next_page_token?: string;
+}
+interface NewsSearchParams {
+    /** Free-text keyword query. Pass this OR one of the token fields below. */
+    q?: string;
+    hl?: string;
+    gl?: string;
+    max_results?: number;
+    /** Google News topic token (from a previous response's `topic_token`). */
+    topic_token?: string;
+    /** Google News publication token — scopes results to a single publisher. */
+    publication_token?: string;
+    /** Google News story token — scopes results to a single story cluster. */
+    story_token?: string;
+}
+/**
+ * Canonical Google News topic codes. Any string is accepted at runtime —
+ * use `NewsTopic` for IDE autocomplete on the standard topics and fall
+ * back to a plain `string` when you know the topic code out-of-band.
+ */
+type NewsTopic = "WORLD" | "BUSINESS" | "TECHNOLOGY" | "ENTERTAINMENT" | "SPORTS" | "SCIENCE" | "HEALTH";
+interface NewsTopicsParams {
+    topic: NewsTopic | (string & {});
+    hl?: string;
+    gl?: string;
+    max_results?: number;
+}
+interface NewsTrendingParams {
+    hl?: string;
+    gl?: string;
+    max_results?: number;
+}
+interface HotelsSearchParams {
+    q: string;
+    check_in: string;
+    check_out: string;
+    adults?: number;
+    currency?: string;
+    gl?: string;
+}
+interface HotelsDetailsParams {
+    property_token: string;
+    check_in: string;
+    check_out: string;
+}
+interface TrendsInterestParams {
+    q: string;
+    geo?: string;
+    date?: string;
+}
+interface TrendsRegionsParams {
+    q: string;
+    geo?: string;
+}
+interface TrendsRelatedParams {
+    q: string;
+    geo?: string;
+}
+interface TrendsTrendingParams {
+    geo?: string;
+}
+type TrendsCategory = "all" | "business" | "entertainment" | "health" | "sci_tech" | "sports" | "top_stories" | "b" | "e" | "m" | "t" | "s" | "h";
+type TrendsTrendingStatus = "all" | "active";
+type TrendsTrendingSort = "relevance" | "search_volume" | "title" | "recency";
+interface TrendsTrendingNowParams {
+    /** Country code (e.g. "US", "LT", "GB"). */
+    geo?: string;
+    /** Look-back window in hours. Common: 4, 24, 48, 168. */
+    hours?: number;
+    /** Category filter. */
+    category?: TrendsCategory;
+    /** Trend state: "all" (default) or "active" (only non-zero search volume). */
+    status?: TrendsTrendingStatus;
+    /** Sort order: relevance / search_volume / title / recency. */
+    sort?: TrendsTrendingSort;
+    /** Language code (e.g. "en-US"). */
+    hl?: string;
+}
+type TrendsDataType = "TIMESERIES" | "GEO_MAP" | "GEO_MAP_0" | "RELATED_TOPICS" | "RELATED_QUERIES";
+interface TrendsSearchParams {
+    /** Search term(s). Comma-separated (max 5) for TIMESERIES / GEO_MAP. */
+    q: string;
+    data_type?: TrendsDataType;
+    geo?: string;
+    date?: string;
+    cat?: number;
+    gprop?: string;
+    region?: "COUNTRY" | "REGION" | "DMA" | "CITY";
+    language?: string;
+    tz?: string;
+}
+interface TrendsAutocompleteParams {
+    /** Query prefix to resolve into Trends topics. */
+    q: string;
+    /** Language code (e.g. "en-US"). */
+    hl?: string;
+    /** Timezone offset in minutes. */
+    tz?: string;
+}
+interface JobsSearchParams {
+    q: string;
+    /**
+     * Data source.
+     * - `"rpc"` (default, ~1-2 s): Google Careers batchexecute RPC —
+     *   structured JSON, scope = Google's own openings.
+     * - `"serp"`: public Google Jobs SERP aggregator — 3rd-party listings
+     *   (LinkedIn, Indeed, Built In, ZipRecruiter, …).
+     */
+    mode?: "rpc" | "serp";
+    location?: string;
+    gl?: string;
+    /** Alias for gl. */
+    country?: string;
+    hl?: string;
+    /** Alias for hl (accepts "en-US" etc). */
+    language?: string;
+    /** Google domain (google.com, google.co.uk, …). */
+    domain?: string;
+    job_type?: "FULLTIME" | "PARTTIME" | "CONTRACTOR" | "INTERN";
+    date_posted?: "today" | "3days" | "week" | "month";
+    /** Work arrangement — SERP mode only. */
+    ltype?: "remote" | "hybrid" | "onsite" | "work_from_home";
+    /** Raw Google chip filter string — SERP mode only. */
+    chips?: string;
+    /** Opaque Google filter token — SERP mode only. */
+    uds?: string;
+    /** UULE-encoded location — SERP mode only. */
+    uule?: string;
+    /** Search radius in miles — SERP mode only. */
+    lrad?: string;
+    /** Pagination token from prior response. */
+    next_page_token?: string;
+}
+interface ShoppingSearchParams {
+    q: string;
+    gl?: string;
+    hl?: string;
+    domain?: string;
+    /** Zero-based page index (each page ≈ 60 tiles). */
+    page?: number;
+    min_price?: number;
+    max_price?: number;
+    sort_by?: "price_low" | "price_high" | "rating" | "reviews";
+    /** Free-shipping filter. */
+    free_shipping?: boolean;
+    /** On-sale filter. */
+    on_sale?: boolean;
+    safe?: "off" | "active";
+    /** `1` disables auto-correction. */
+    nfpr?: number;
+    /** Language restrict (e.g. `lang_en`). */
+    lr?: string;
+    /** Raw Google tbs filter. */
+    tbs?: string;
+    /** Google internal shoprs helper token. */
+    shoprs?: string;
+}
+/**
+ * Params for `/v1/google/shopping/product` — Google Shopping product
+ * detail page lookup.
+ */
+interface ShoppingProductParams {
+    product_id: string;
+    gl?: string;
+    hl?: string;
+    domain?: string;
+}
+/**
+ * Params for `/v1/google/shopping/product/click` — resolve the direct
+ * merchant URL for a Shopping product tile. Uses Google's "I'm Feeling
+ * Lucky" redirect scoped to the card's `source` merchant via the
+ * `site:` operator.
+ */
+interface ShoppingClickParams {
+    title: string;
+    source: string;
+    q: string;
+    product_id?: string;
+}
+/**
+ * Params for `/v1/google/patents/search`. Backed by Google Patents'
+ * `/xhr/query` JSON RPC — ~1 s regardless of filter complexity.
+ */
+interface PatentsSearchParams {
+    /** Query string — supports Boolean logic (e.g. "quantum AND compute"). */
+    q: string;
+    page?: number;
+    num?: number;
+    sort?: "new" | "old";
+    /** Comma-separated inventor names. */
+    inventor?: string;
+    /** Comma-separated assignee / company names. */
+    assignee?: string;
+    /** Patent-office country code (US, EP, WO, …). */
+    country?: string;
+    language?: "ENGLISH" | "GERMAN" | "CHINESE" | "FRENCH" | "JAPANESE" | "KOREAN" | "SPANISH";
+    status?: "GRANT" | "APPLICATION";
+    patent_type?: "PATENT" | "DESIGN";
+    /** Filing/priority-date upper bound (YYYYMMDD). */
+    before?: string;
+    /** Filing/priority-date lower bound (YYYYMMDD). */
+    after?: string;
+}
+interface PatentsDetailParams {
+    /** Publication number (e.g. "US10000000B2", "EP3097156B1"). */
+    patent_id: string;
+}
+interface ScholarSearchParams {
+    q: string;
+    hl?: string;
+    as_ylo?: number;
+    as_yhi?: number;
+    as_sdt?: string;
+    page?: number;
+    num?: number;
+}
+interface ScholarProfilesParams {
+    /** Author name query (e.g. "Geoffrey Hinton"). */
+    mauthors: string;
+    hl?: string;
+    /** Next-page pagination token from a previous response. */
+    after_author?: string;
+    /** Previous-page pagination token. */
+    before_author?: string;
+}
+interface ScholarAuthorParams {
+    /** Scholar user ID (the `user` query parameter on a profile URL). */
+    author_id: string;
+    hl?: string;
+    /** Articles pagination offset. */
+    cstart?: number;
+    /** Articles per page. */
+    pagesize?: number;
+}
+interface ScholarAuthorCitationParams {
+    author_id: string;
+    hl?: string;
+}
+interface ScholarCiteParams {
+    /** Cluster ID from a Scholar search result. */
+    q: string;
+    hl?: string;
+}
+interface AutocompleteParams {
+    q: string;
+    hl?: string;
+    gl?: string;
+}
+interface ImagesSearchParams {
+    q: string;
+    gl?: string;
+    hl?: string;
+    /** Zero-based page index (each page ≈ 100 tiles). */
+    page?: number;
+    /** Max tiles to return (1-500, client-side cap). */
+    results?: number;
+    safe?: "off" | "active";
+    /** Raw Google tbs filter (e.g. `qdr:d`). */
+    tbs?: string;
+    /** Size: `l`, `m`, `i`, `xXl`, `xxl`, `xxxl`. */
+    imgsz?: string;
+    /** Colour: `color`, `gray`, `transparent`, `red`, `orange`, … */
+    imgcolor?: string;
+    /** Type: `face`, `photo`, `clipart`, `lineart`, `animated`. */
+    imgtype?: string;
+}
+interface VideosSearchParams {
+    q: string;
+    gl?: string;
+    hl?: string;
+    /** Zero-based page index (each page ≈ 10 tiles). */
+    page?: number;
+    /** Google domain (`google.com`, `google.co.uk`, …). */
+    domain?: string;
+    /** City-level geo-targeting. */
+    location?: string;
+    /** Language restrict (e.g. `lang_en`). */
+    lr?: string;
+    /** UULE-encoded location. */
+    uule?: string;
+    /** `1` disables auto-correction. */
+    nfpr?: number;
+    safe?: "off" | "active";
+    /** Time/duration chip: `qdr:d/w/m`, `dur:s/m/l`. */
+    tbs?: string;
+}
+interface FinanceQuoteParams {
+    /** Ticker, optionally with exchange — `AAPL`, `AAPL:NASDAQ`, `BTC-USD`, `EURUSD`. */
+    q: string;
+    hl?: string;
+    gl?: string;
+}
+interface AiModeSearchParams {
+    q: string;
+    gl?: string;
+    hl?: string;
+}
+/**
+ * Params for `/v1/google/lens/search`. Response carries `lens_results`
+ * (Scrapingdog parity — each item has `title`, `source`,
+ * `source_favicon`, `thumbnail`, optional `tag` price chip and
+ * `in_stock`) plus `related_searches` chips. Legacy `results` alias
+ * retained for backwards compat.
+ */
+interface LensSearchParams {
+    /** Public URL of the image to search visually. */
+    url: string;
+    /** Optional text refinement (e.g. `"pizza"`) to bias Lens. */
+    query?: string;
+    /** ISO country code — Scrapingdog-parity alias for `gl`. */
+    country?: string;
+    /** Language code — Scrapingdog-parity alias for `hl`. */
+    language?: string;
+    gl?: string;
+    hl?: string;
+    /** Bias towards shoppable product matches. */
+    product?: boolean;
+    /** Include the visual-matches carousel (default: true). */
+    visual_matches?: boolean;
+    /** Restrict to exact-match results only. */
+    exact_matches?: boolean;
+}
+/**
+ * Params for `/v1/google/products/detail`. Backed by Google's
+ * `/async/oapv` RPC — full product payload (title, brand, price, rating,
+ * specs) in ~2s via warm-session curl_cffi.
+ */
+interface ProductsDetailParams {
+    /** Google Shopping `gpcid`. Search results expose this on each tile. */
+    product_id: string;
+    /** Original search query — required, used to build the oapv context blob. */
+    q: string;
+    gl?: string;
+    hl?: string;
+    /** Extra IDs Google surfaces on Shopping tiles. Improves routing accuracy. */
+    catalog_id?: string;
+    image_docid?: string;
+    headline_offer_docid?: string;
+    mid?: string;
+    /** When true, also fetches `/async/piu_ps` for the merchant offers list. */
+    include_offers?: boolean;
+    /** When true, also fetches `/async/toy_v` for size/colour variants. */
+    include_variants?: boolean;
+}
+interface ShortsSearchParams {
+    q: string;
+    gl?: string;
+    hl?: string;
+    domain?: string;
+    /** Max tiles to return (1-60 cap). */
+    num?: number;
+    /** Pagination offset. */
+    start?: number;
+    safe?: "off" | "active";
+    /** `1` disables auto-correction. */
+    nfpr?: number;
+    /** Raw Google tbs filter (e.g. `qdr:d`). */
+    tbs?: string;
+}
+type FlightsTripType = "round_trip" | "one_way" | "multi_city";
+type FlightsTravelClass = "economy" | "premium_economy" | "business" | "first";
+type FlightsStopsFilter = "any" | "nonstop" | "one_stop" | "two_stops";
+interface FlightsSearchParams {
+    /** Departure airport IATA code (e.g. "JFK") or location ID. */
+    departure_id: string;
+    /** Arrival airport IATA code (e.g. "LHR") or location ID. */
+    arrival_id: string;
+    /** Outbound date in YYYY-MM-DD format. */
+    outbound_date: string;
+    /** Return date (required for round_trip). */
+    return_date?: string;
+    trip_type?: FlightsTripType;
+    /** Adult passengers (1-9). */
+    adults?: number;
+    /** Children passengers (0-8). */
+    children?: number;
+    /** Infants in seat (0-4). */
+    infants_in_seat?: number;
+    /** Infants on lap (0-4). */
+    infants_on_lap?: number;
+    travel_class?: FlightsTravelClass;
+    /** ISO-4217 currency code (default "USD"). */
+    currency?: string;
+    gl?: string;
+    hl?: string;
+    stops?: FlightsStopsFilter;
+    /** Upper price filter. */
+    max_price?: number;
+}
+
+/**
+ * Google AI Mode API client (udm=50 generative answers).
+ */
+
+/**
+ * Client for Google AI Mode.
+ */
+declare class AiModeClient {
+    private readonly client;
+    constructor(client: BaseClient);
+    search(params: AiModeSearchParams): Promise<GoogleResponse>;
+}
+
+/**
+ * Google Autocomplete API client.
+ *
+ * Returns up to 10 search suggestions. Suggestions that resolve to
+ * Knowledge-Graph entities (companies, people, movies, stocks, local
+ * businesses, …) additionally carry `entity_name` and `thumbnail` —
+ * the same enrichment Google's own search-box surfaces.
+ */
+
+/**
+ * Client for Google Autocomplete (search suggestions).
+ */
+declare class AutocompleteClient {
+    private readonly client;
+    constructor(client: BaseClient);
+    /**
+     * Get Google autocomplete suggestions for a query.
+     *
+     * @example
+     * ```typescript
+     * const res = await client.google.autocomplete.get({ q: "apple" });
+     * for (const s of res.suggestions) {
+     *   console.log(s.value, s.entity_name, s.thumbnail);
+     * }
+     * ```
+     */
+    get(params: AutocompleteParams): Promise<GoogleResponse>;
+}
+
+/**
+ * Google Finance API client.
+ *
+ * Powered by the same `mKsvE` batchexecute RPC the Google Finance SPA
+ * uses internally. Returns price / change / change% / previous_close /
+ * after-hours / market hours / timezone / currency / country /
+ * alternate exchange listings in ~1 s.
+ */
+
+/**
+ * Client for Google Finance quotes.
+ *
+ * @example
+ * ```typescript
+ * const quote = await client.google.finance.quote({ q: "AAPL:NASDAQ" });
+ * console.log(quote.price, quote.currency, quote.after_hours);
+ * ```
+ */
+declare class FinanceClient {
+    private readonly client;
+    constructor(client: BaseClient);
+    quote(params: FinanceQuoteParams): Promise<GoogleResponse>;
+}
+
+/**
+ * Google Flights API client — one-way, round-trip, multi-city.
+ */
+
+/**
+ * Client for Google Flights search.
+ *
+ * Supports one-way, round-trip, and multi-city itineraries with
+ * passenger configuration, cabin class, stops filter, and max-price.
+ * Returns Google's Best flights recommendations plus the full Other
+ * flights result set, with per-offer pricing, duration, stops,
+ * layovers, carbon emissions, and price insights (low / typical /
+ * high + typical price range) when Google shows them.
+ *
+ * @example
+ * ```typescript
+ * const flights = await client.google.flights.search({
+ *   departure_id: "JFK",
+ *   arrival_id: "LHR",
+ *   outbound_date: "2026-06-15",
+ *   return_date: "2026-06-22",
+ *   adults: 2,
+ * });
+ * for (const offer of flights.best_flights) {
+ *   console.log(offer.price, offer.currency, offer.total_duration_minutes);
+ * }
+ * if (flights.price_insights) {
+ *   console.log("Price level:", flights.price_insights.price_level);
+ * }
+ * ```
+ */
+declare class FlightsClient {
+    private readonly client;
+    constructor(client: BaseClient);
+    /** Search Google Flights for available itineraries. */
+    search(params: FlightsSearchParams): Promise<GoogleResponse>;
+}
+
+/**
+ * Google Hotels API client — search, property details.
+ */
+
+/**
+ * Client for Google Hotels endpoints.
+ *
+ * @example
+ * ```typescript
+ * const hotels = await client.google.hotels.search({
+ *   q: "Paris",
+ *   check_in: "2026-05-01",
+ *   check_out: "2026-05-05",
+ *   adults: 2,
+ * });
+ * ```
+ */
+declare class HotelsClient {
+    private readonly client;
+    constructor(client: BaseClient);
+    search(params: HotelsSearchParams): Promise<GoogleResponse>;
+    details(params: HotelsDetailsParams): Promise<GoogleResponse>;
+}
+
+/**
+ * Google Images API client.
+ *
+ * Returns up to 100 tiles per page with `title`, `source`, `link`
+ * (referrer page), `thumbnail`, `image` (inline preview), `original`
+ * (full-res URL), `original_width` / `original_height`,
+ * `original_size` (e.g. `"635KB"`), plus licensability flags.
+ */
+
+/**
+ * Client for Google Images search.
+ *
+ * @example
+ * ```typescript
+ * const res = await client.google.images.search({
+ *   q: "golden retriever",
+ *   imgsz: "l",
+ *   imgcolor: "color",
+ * });
+ * for (const img of res.results) {
+ *   console.log(img.rank, img.title, img.original);
+ * }
+ * ```
+ */
+declare class ImagesClient {
+    private readonly client;
+    constructor(client: BaseClient);
+    search(params: ImagesSearchParams): Promise<GoogleResponse>;
+}
+
+/**
+ * Google Jobs API client.
+ */
+
+/**
+ * Client for Google Jobs search.
+ *
+ * @example
+ * ```typescript
+ * const jobs = await client.google.jobs.search({
+ *   q: "software engineer",
+ *   location: "San Francisco, CA",
+ *   job_type: "FULLTIME",
+ * });
+ * ```
+ */
+declare class JobsClient {
+    private readonly client;
+    constructor(client: BaseClient);
+    search(params: JobsSearchParams): Promise<GoogleResponse>;
+}
+
+/**
+ * Google Lens API client (visual image search).
+ */
+
+/**
+ * Client for Google Lens visual search by image URL.
+ *
+ * Response carries `lens_results` (Scrapingdog-parity alias) with
+ * `title`, `source`, `source_favicon`, `thumbnail`, optional `tag`
+ * price chip and `in_stock`, plus `related_searches` chips. Legacy
+ * `results` alias retained for backwards compat.
+ *
+ * @example
+ * ```typescript
+ * const out = await client.google.lens.search({
+ *   url: "https://example.com/photo.jpg",
+ *   product: true, // bias towards shoppable matches
+ * });
+ * for (const match of out.lens_results) {
+ *   console.log(match.title, match.tag);
+ * }
+ * ```
+ */
+declare class LensClient {
+    private readonly client;
+    constructor(client: BaseClient);
+    search(params: LensSearchParams): Promise<GoogleResponse>;
+}
+
+/**
+ * Google Maps API client — search, place details, reviews, photos, posts.
+ */
+
+/**
+ * Client for Google Maps endpoints.
+ *
+ * @example
+ * ```typescript
+ * const places = await client.google.maps.search({ q: "coffee shops sf" });
+ * const detail = await client.google.maps.place({ data_id: "0x...:0x..." });
+ * const reviews = await client.google.maps.reviews({
+ *   data_id: "0x...:0x...",
+ *   sort_by: "newestFirst",
+ * });
+ * ```
+ */
+declare class MapsClient {
+    private readonly client;
+    constructor(client: BaseClient);
+    /**
+     * Search Maps for places by text query, place_id, or ludocid.
+     *
+     * Returns up to 20 results per page with full details (place_id,
+     * data_id, GPS, rating, reviews, address, phone, website, extensions,
+     * weekly hours, thumbnail) in a single call.
+     */
+    search(params: MapsSearchParams): Promise<GoogleResponse>;
+    /**
+     * Get full place detail by `place_id` or `data_id`.
+     *
+     * Returns title, address, phone, website, GPS, rating, reviews_count,
+     * rating_summary (per-star distribution), categories, extensions
+     * (service_options, accessibility, offerings, payments), weekly
+     * operating hours, popular_times graph, provider_id,
+     * permanently_closed, thumbnail, and photo list.
+     */
+    place(params: MapsPlaceParams): Promise<GoogleResponse>;
+    /**
+     * Get reviews for a place (paginated, optional topic filter).
+     *
+     * Pass the `next_page_token` from `response.pagination.next` for
+     * subsequent pages, or use `topic_id` from `response.topics[].id`
+     * to scope to a specific review topic.
+     */
+    reviews(params: MapsReviewsParams): Promise<GoogleResponse>;
+    /**
+     * Get photos for a place with place-specific categories.
+     *
+     * Returns place-specific categories (Menu, Vibe, Comfort food, dish
+     * names) and photo URLs from all CDN families. Use `category_id` to
+     * scope to a category, or `page_size: 200` to fetch all photos in
+     * one call (Google caps at ~120 photos per response).
+     */
+    photos(params: MapsPhotosParams): Promise<GoogleResponse>;
+    /** Get business posts (promotional updates, announcements) for a place. */
+    posts(params: MapsPostsParams): Promise<GoogleResponse>;
+}
+
+/**
+ * Google News API client — search, topics, trending.
+ */
+
+/**
+ * Client for Google News endpoints.
+ *
+ * @example
+ * ```typescript
+ * const articles = await client.google.news.search({ q: "openai" });
+ * const tech = await client.google.news.topics({ topic: "TECHNOLOGY" });
+ * const trending = await client.google.news.trending();
+ * ```
+ */
+declare class NewsClient {
+    private readonly client;
+    constructor(client: BaseClient);
+    /**
+     * Search Google News. One of `q`, `topic_token`, `publication_token`,
+     * or `story_token` is required (or pass no params for the trending
+     * home feed). Returns `menu_links`, `news_results`, `related_topics`.
+     */
+    search(params?: NewsSearchParams): Promise<GoogleResponse>;
+    topics(params: NewsTopicsParams): Promise<GoogleResponse>;
+    trending(params?: NewsTrendingParams): Promise<GoogleResponse>;
+}
+
+/**
+ * Google Patents API client — search, detail.
+ */
+
+/**
+ * Client for Google Patents endpoints.
+ *
+ * @example
+ * ```typescript
+ * const results = await client.google.patents.search({
+ *   q: "distributed lock",
+ *   assignee: "Google",
+ * });
+ * ```
+ */
+declare class PatentsClient {
+    private readonly client;
+    constructor(client: BaseClient);
+    search(params: PatentsSearchParams): Promise<GoogleResponse>;
+    /**
+     * Get rich patent document details by patent number.
+     *
+     * Response includes full abstract + every claim + complete description,
+     * plus structured `cpc_classifications` (code + description), split
+     * `backward_citations` / `forward_citations` (with `primary_examiner`
+     * flag), `non_patent_citations`, `concepts` (research fields),
+     * `legal_events` (prosecution history), `figures` (full-res URLs),
+     * every `inventor`, and the full `assignees_original` history.
+     */
+    detail(params: PatentsDetailParams): Promise<GoogleResponse>;
+}
+
+/**
+ * Google Products API client (immersive product detail).
+ */
+
+/**
+ * Client for Google's immersive product detail endpoint.
+ */
+declare class ProductsClient {
+    private readonly client;
+    constructor(client: BaseClient);
+    detail(params: ProductsDetailParams): Promise<GoogleResponse>;
+}
+
+/**
+ * Google Scholar API client.
+ */
+
+/**
+ * Client for Google Scholar — search, author profiles, citation charts,
+ * and citation formats.
+ *
+ * Search results carry doc `id`, `type` badge, wrapped `inline_links`
+ * (versions + cited_by + related), PDF `resources`, and author objects
+ * with `author_id` for pipe-through into {@link ScholarClient.author}.
+ * The author endpoint returns structured `interests_detailed`,
+ * publications with per-article `citation_id` + nested `cited_by`, and
+ * lifetime + since-year citation stats.
+ *
+ * @example
+ * ```typescript
+ * const papers = await client.google.scholar.search({
+ *   q: "transformer neural networks",
+ *   as_ylo: 2020,
+ * });
+ * const first = papers.scholar_results[0];
+ * // Pipe a profiled author into the author endpoint:
+ * if (first.authors[0].author_id) {
+ *   const profile = await client.google.scholar.author({
+ *     author_id: first.authors[0].author_id,
+ *   });
+ * }
+ * ```
+ */
+declare class ScholarClient {
+    private readonly client;
+    constructor(client: BaseClient);
+    /**
+     * Search Google Scholar. Returns each result with doc `id`, `type`
+     * badge, wrapped `inline_links`, PDF `resources`, and structured
+     * authors. Envelope includes `scholar_results` alias,
+     * `related_searches`, and matched `profiles` cards.
+     */
+    search(params: ScholarSearchParams): Promise<GoogleResponse>;
+    /** Search Google Scholar for author profiles by name. */
+    profiles(params: ScholarProfilesParams): Promise<GoogleResponse>;
+    /**
+     * Full Scholar author profile: structured `interests_detailed`,
+     * publications (with per-article `citation_id` + nested
+     * `cited_by{value, link, citation_id}`), stats, and co-authors.
+     */
+    author(params: ScholarAuthorParams): Promise<GoogleResponse>;
+    /** Citations-per-year chart for a Scholar author. */
+    authorCitation(params: ScholarAuthorCitationParams): Promise<GoogleResponse>;
+    /**
+     * MLA / APA / Chicago / Harvard / Vancouver citation formats plus
+     * BibTeX / RIS / EndNote / RefWorks export links for a paper.
+     */
+    cite(params: ScholarCiteParams): Promise<GoogleResponse>;
+}
+
+/**
+ * Google Web Search (SERP) API client.
+ */
+
+/**
+ * Client for Google Web Search.
+ *
+ * @example
+ * ```typescript
+ * const serp = await client.google.search.search({ q: "python 3.13" });
+ * for (const r of serp.organic_results as any[]) {
+ *   console.log(r.title, r.link);
+ * }
+ * ```
+ */
+declare class SearchClient {
+    private readonly client;
+    constructor(client: BaseClient);
+    /**
+     * Search Google and get a structured SERP response with organic results,
+     * knowledge graph, People Also Ask, related searches, AI overview, and
+     * pagination.
+     */
+    search(params: GoogleSearchParams): Promise<GoogleResponse>;
+    /**
+     * Lightweight Google Search — organic results + related searches only.
+     *
+     * ~40% faster than {@link search}. Skips ads, Knowledge Graph, AI
+     * Overview, local pack, news, inline videos, and shopping blocks.
+     * Credit cost is configured per-endpoint by admins — query
+     * `/public/pricing` for the live rate.
+     *
+     * @example
+     * ```typescript
+     * const lite = await client.google.search.light({ q: "python 3.13" });
+     * ```
+     */
+    light(params: GoogleSearchParams): Promise<GoogleResponse>;
+}
+
+/**
+ * Google Shopping API client — search and product detail.
+ */
+
+/**
+ * Client for Google Shopping endpoints.
+ *
+ * Each search tile now carries Google's native `gpcid`, `catalog_id`,
+ * `headline_offer_docid`, `image_docid`, and `mid`, so callers can pipe a
+ * tile directly into `client.google.products.detail()` for full specs
+ * plus merchant offers via the fast `/async/oapv` RPC (~2s).
+ *
+ * @example
+ * ```typescript
+ * const products = await client.google.shopping.search({ q: "laptop" });
+ * const first = (products.results as any[])[0];
+ * const detail = await client.google.products.detail({
+ *   product_id: first.gpcid,
+ *   q: "laptop",
+ *   include_offers: true, // real merchant URLs from /async/piu_ps
+ * });
+ * ```
+ */
+declare class ShoppingClient {
+    private readonly client;
+    constructor(client: BaseClient);
+    /** Search Google Shopping for products. */
+    search(params: ShoppingSearchParams): Promise<GoogleResponse>;
+    /** Fetch the Google Shopping product detail page by `product_id`. */
+    product(params: ShoppingProductParams): Promise<GoogleResponse>;
+    /**
+     * Resolve the direct merchant URL for a Shopping product tile via
+     * Google's "I'm Feeling Lucky" redirect (scoped to the card's `source`
+     * merchant via the `site:` operator). You only pay for the call when
+     * you actually want the merchant link — no bulk enrichment of every
+     * tile.
+     */
+    click(params: ShoppingClickParams): Promise<GoogleResponse>;
+}
+
+/**
+ * Google Shorts API client — short-form vertical video results.
+ */
+
+/**
+ * Client for Google Shorts search (`udm=39`).
+ *
+ * Returns a carousel of short-form videos — YouTube Shorts plus
+ * TikToks, Instagram Reels, Facebook Reels, and other platforms.
+ * Every tile carries `title`, `link`, `source` (platform),
+ * `account_name`, `thumbnail`, `image` (inline preview),
+ * `duration`, and `video_id` (YouTube only).
+ *
+ * @example
+ * ```typescript
+ * const shorts = await client.google.shorts.search({ q: "cooking hacks" });
+ * for (const v of shorts.short_videos_results) {
+ *   console.log(v.rank, v.title, v.source, v.account_name);
+ * }
+ * ```
+ */
+declare class ShortsClient {
+    private readonly client;
+    constructor(client: BaseClient);
+    search(params: ShortsSearchParams): Promise<GoogleResponse>;
+}
+
+/**
+ * Google Trends API client — interest, regions, related, trending.
+ */
+
+/**
+ * Client for Google Trends endpoints.
+ *
+ * @example
+ * ```typescript
+ * const interest = await client.google.trends.interest({
+ *   q: "python,javascript",
+ *   date: "today 12-m",
+ * });
+ * ```
+ */
+declare class TrendsClient {
+    private readonly client;
+    constructor(client: BaseClient);
+    interest(params: TrendsInterestParams): Promise<GoogleResponse>;
+    regions(params: TrendsRegionsParams): Promise<GoogleResponse>;
+    related(params: TrendsRelatedParams): Promise<GoogleResponse>;
+    trending(params?: TrendsTrendingParams): Promise<GoogleResponse>;
+    /**
+     * Current trending searches with the full Google Trends UI filter set
+     * — `geo`, `hours`, `category`, `status`, `sort`, `hl`.
+     */
+    trendingNow(params?: TrendsTrendingNowParams): Promise<GoogleResponse>;
+    /**
+     * Unified Google Trends query — pick the response shape via
+     * `data_type` (TIMESERIES | GEO_MAP | GEO_MAP_0 | RELATED_TOPICS |
+     * RELATED_QUERIES).
+     */
+    search(params: TrendsSearchParams): Promise<GoogleResponse>;
+    /**
+     * Return categorized Knowledge Graph topic entities (`mid`, `type`,
+     * direct link into Trends explore) for a query prefix. Distinct from
+     * Google Search autocomplete.
+     */
+    autocomplete(params: TrendsAutocompleteParams): Promise<GoogleResponse>;
+}
+
+/**
+ * Google Videos API client.
+ *
+ * Returns up to 10 tiles per page with `title`, `link`
+ * (YouTube / Vimeo / etc.), `displayed_link`, `snippet`, `thumbnail`,
+ * `image` (inline base-64), `favicon`, `duration`, `channel`,
+ * `source` (platform), `date`, `video_id`, and raw `extensions`.
+ */
+
+/**
+ * Client for Google Videos search.
+ *
+ * @example
+ * ```typescript
+ * const res = await client.google.videos.search({ q: "python tutorial" });
+ * for (const v of res.results) {
+ *   console.log(v.rank, v.title, v.duration, v.channel);
+ * }
+ * ```
+ */
+declare class VideosClient {
+    private readonly client;
+    constructor(client: BaseClient);
+    search(params: VideosSearchParams): Promise<GoogleResponse>;
+}
+
+/**
+ * Google Scraper API aggregator — exposes all 16 Google product sub-clients.
+ */
+
+/**
+ * Google Scraper API client with access to all 19 Google product APIs.
+ *
+ * @example
+ * ```typescript
+ * const client = new ScrapeBadger({ apiKey: "key" });
+ *
+ * const serp = await client.google.search.search({ q: "python 3.13" });
+ * const places = await client.google.maps.search({ q: "coffee shops sf" });
+ * const products = await client.google.shopping.search({ q: "laptop" });
+ *
+ * // Per-product merchant URL enrichment
+ * const enriched = await client.google.shopping.click({
+ *   title: (products.results as any[])[0].title,
+ *   source: (products.results as any[])[0].source,
+ * });
+ * console.log(enriched.merchant_url);
+ *
+ * // New in v0.3: Shorts, Flights, and Scholar depth
+ * const shorts = await client.google.shorts.search({ q: "cooking hacks" });
+ * const flights = await client.google.flights.search({
+ *   departure_id: "JFK",
+ *   arrival_id: "LHR",
+ *   outbound_date: "2026-06-15",
+ *   return_date: "2026-06-22",
+ * });
+ * const profiles = await client.google.scholar.profiles({
+ *   mauthors: "Geoffrey Hinton",
+ * });
+ * ```
+ */
+declare class GoogleClient {
+    /** Google Web Search (SERP) — with optional deferred AI Overview follow-up. */
+    readonly search: SearchClient;
+    /** Google Maps — places, reviews, photos, posts. */
+    readonly maps: MapsClient;
+    /** Google News — articles, topics, trending. */
+    readonly news: NewsClient;
+    /** Google Hotels — search and property details. */
+    readonly hotels: HotelsClient;
+    /** Google Trends — interest, regions, related, trending, topic autocomplete. */
+    readonly trends: TrendsClient;
+    /** Google Jobs. */
+    readonly jobs: JobsClient;
+    /** Google Shopping — search, details, click enrichment. */
+    readonly shopping: ShoppingClient;
+    /** Google Patents — search and document details. */
+    readonly patents: PatentsClient;
+    /** Google Scholar — search, profiles, author, author citation, cite formats. */
+    readonly scholar: ScholarClient;
+    /** Google Autocomplete — search suggestions. */
+    readonly autocomplete: AutocompleteClient;
+    /** Google Images. */
+    readonly images: ImagesClient;
+    /** Google Videos. */
+    readonly videos: VideosClient;
+    /** Google Finance — stock and index quotes. */
+    readonly finance: FinanceClient;
+    /** Google AI Mode — generative answer responses. */
+    readonly aiMode: AiModeClient;
+    /** Google Lens — visual image search. */
+    readonly lens: LensClient;
+    /** Google Shorts — short-form vertical video results (udm=39). */
+    readonly shorts: ShortsClient;
+    /** Google Flights — one-way, round-trip, and multi-city itineraries. */
+    readonly flights: FlightsClient;
+    /** Google Products — immersive product detail. */
+    readonly products: ProductsClient;
+    constructor(client: BaseClient);
 }
 
 /**
@@ -202,6 +2000,10 @@ declare class ScrapeBadger {
     readonly twitter: TwitterClient;
     /** Web scraping API client */
     readonly web: WebClient;
+    /** Vinted scraper API client */
+    readonly vinted: VintedClient;
+    /** Google Scraper API client — 19 Google product APIs */
+    readonly google: GoogleClient;
     /**
      * Create a new ScrapeBadger client.
      *
@@ -230,4 +2032,4 @@ declare class ScrapeBadger {
     constructor(config?: Partial<ScrapeBadgerConfig>);
 }
 
-export { type BatchOptions, type BatchResult, type ExtractOptions, type ExtractResult, ScrapeBadger, ScrapeBadgerConfig, type ScrapeOptions, type ScrapeResult, type ScreenshotOptions, type ScreenshotResult, type SessionInfo, TwitterClient, WebClient };
+export { type AiModeSearchParams, type AutocompleteParams, type DetectOptions, type DetectResult, type FinanceQuoteParams, type FlightsSearchParams, type FlightsStopsFilter, type FlightsTravelClass, type FlightsTripType, AiModeClient as GoogleAiModeClient, AutocompleteClient as GoogleAutocompleteClient, GoogleClient, FinanceClient as GoogleFinanceClient, FlightsClient as GoogleFlightsClient, HotelsClient as GoogleHotelsClient, ImagesClient as GoogleImagesClient, JobsClient as GoogleJobsClient, LensClient as GoogleLensClient, MapsClient as GoogleMapsClient, NewsClient as GoogleNewsClient, PatentsClient as GooglePatentsClient, ProductsClient as GoogleProductsClient, type GoogleResponse, ScholarClient as GoogleScholarClient, SearchClient as GoogleSearchClient, type GoogleSearchParams, ShoppingClient as GoogleShoppingClient, ShortsClient as GoogleShortsClient, TrendsClient as GoogleTrendsClient, VideosClient as GoogleVideosClient, type HotelsDetailsParams, type HotelsSearchParams, type ImagesSearchParams, type JobsSearchParams, type LensSearchParams, type MapsPhotosParams, type MapsPlaceParams, type MapsPostsParams, type MapsReviewsParams, type MapsSearchParams, type NewsSearchParams, type NewsTopicsParams, type NewsTrendingParams, type PatentsDetailParams, type PatentsSearchParams, type ProductsDetailParams, type ScholarAuthorCitationParams, type ScholarAuthorParams, type ScholarCiteParams, type ScholarProfilesParams, type ScholarSearchParams, ScrapeBadger, ScrapeBadgerConfig, type ScrapeOptions, type ScrapeResult, type ShoppingClickParams, type ShoppingProductParams, type ShoppingSearchParams, type ShortsSearchParams, type TrendsAutocompleteParams, type TrendsInterestParams, type TrendsRegionsParams, type TrendsRelatedParams, type TrendsTrendingParams, TwitterClient, type VideosSearchParams, type VintedBrand, type BrandsResponse as VintedBrandsResponse, VintedClient, type VintedColor, type ColorsResponse as VintedColorsResponse, type VintedItemDetail, type ItemDetailResponse as VintedItemDetailResponse, type VintedItemSummary, ItemsClient as VintedItemsClient, type VintedMarket, type MarketsResponse as VintedMarketsResponse, type VintedPagination, type VintedPhoto, type VintedPrice, ReferenceClient as VintedReferenceClient, SearchClient$1 as VintedSearchClient, type VintedSearchParams, type SearchResponse as VintedSearchResponse, type VintedSellerSummary, type VintedStatus, type StatusesResponse as VintedStatusesResponse, type UserItemsResponse as VintedUserItemsResponse, type VintedUserProfile, type UserProfileResponse as VintedUserProfileResponse, type VintedUserSummary, UsersClient as VintedUsersClient, WebClient };