scrapebadger 0.4.0 → 0.8.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,3203 @@ 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$1 {
+    /** 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$2 {
+    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$1 {
+    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$1>;
+    /**
+     * 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$2;
+    /** Client for individual item operations */
+    readonly items: ItemsClient;
+    /** Client for user operations */
+    readonly users: UsersClient$1;
+    /** 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 {
+    /** Up to 5 comma-separated terms. */
+    q: string;
+    /** Geographic location code (empty = worldwide). */
+    geo?: string;
+    /** Time range — e.g. `now 1-H`, `today 12-m`, `all`, or `YYYY-MM-DD YYYY-MM-DD`. */
+    date?: string;
+    /** Category filter id (0 = all). */
+    category?: number;
+    /** Property filter — `""`, `images`, `news`, `froogle`, or `youtube`. */
+    gprop?: string;
+}
+interface TrendsRegionsParams {
+    q: string;
+    geo?: string;
+    date?: string;
+    /** Region granularity — `auto` (default), `COUNTRY`, `REGION`, `DMA`, or `CITY`. */
+    resolution?: "auto" | "COUNTRY" | "REGION" | "DMA" | "CITY";
+}
+interface TrendsRelatedParams {
+    q: string;
+    geo?: string;
+    date?: string;
+}
+interface TrendsTrendingParams {
+    /** Country code (ISO 3166 alpha-2). Defaults to `US`. */
+    geo?: string;
+    /** Language code (e.g. `en-US`). */
+    hl?: string;
+    /** Look-back window — Google supports `24` (default), `48`, `168` (= 1 week). */
+    hours?: number;
+}
+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;
+    /** Google domain used to localise the SERP that yields oapv session tokens. */
+    domain?: 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;
+    /**
+     * Only meaningful with `include_offers=true`. When true, browser-renders
+     * the Shopping SERP so additional merchant deep URLs surface from the
+     * rendered HTML. Adds ~5–8 s latency.
+     */
+    resolve_deep_urls?: 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$1 {
+    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$1;
+    /** 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);
+}
+
+/**
+ * TypeScript types for Reddit API responses.
+ *
+ * This module contains all the data types used by the Reddit API client.
+ */
+/**
+ * A preview image with dimensions.
+ */
+interface RedditPreviewImage {
+    /** Image URL */
+    url: string;
+    /** Image width in pixels */
+    width: number;
+    /** Image height in pixels */
+    height: number;
+}
+/**
+ * Embedded media attached to a post.
+ */
+interface RedditMedia {
+    /** Media type identifier */
+    type: string | null;
+    /** Direct media URL */
+    url: string | null;
+    /** Thumbnail URL */
+    thumbnail_url: string | null;
+    /** Media width in pixels */
+    width: number | null;
+    /** Media height in pixels */
+    height: number | null;
+}
+/**
+ * An award given to a post or comment.
+ */
+interface RedditAward {
+    /** Award ID */
+    id: string | null;
+    /** Award name */
+    name: string;
+    /** Number of this award given */
+    count: number;
+    /** Award icon URL */
+    icon_url: string | null;
+}
+/**
+ * A Reddit post (link or self post).
+ */
+interface RedditPost {
+    /** Unique post identifier (without t3_ prefix) */
+    id: string;
+    /** Fullname with t3_ prefix */
+    fullname: string;
+    /** Post title */
+    title: string;
+    /** Self post text body */
+    selftext: string;
+    /** Self post text as HTML */
+    selftext_html: string | null;
+    /** External or self URL */
+    url: string;
+    /** Permalink to post on Reddit */
+    permalink: string;
+    /** Post domain */
+    domain: string;
+    /** Author username */
+    author: string;
+    /** Author fullname (t2_ prefixed) */
+    author_fullname: string | null;
+    /** Author flair text */
+    author_flair_text: string | null;
+    /** Author flair type (text or richtext) */
+    author_flair_type: string | null;
+    /** Author flair template ID */
+    author_flair_template_id: string | null;
+    /** Subreddit name (without r/ prefix) */
+    subreddit: string;
+    /** Subreddit fullname (t5_ prefixed) */
+    subreddit_id: string | null;
+    /** Subreddit with r/ prefix */
+    subreddit_name_prefixed: string | null;
+    /** Subreddit type (public, private, restricted, etc.) */
+    subreddit_type: string | null;
+    /** Number of subscribers in the subreddit */
+    subreddit_subscribers: number | null;
+    /** Post score (upvotes minus downvotes) */
+    score: number;
+    /** Raw upvotes */
+    ups: number;
+    /** Raw downvotes */
+    downs: number;
+    /** Upvote ratio as a decimal (e.g. 0.95) */
+    upvote_ratio: number | null;
+    /** Number of comments */
+    num_comments: number;
+    /** Number of crossposts */
+    num_crossposts: number;
+    /** Number of duplicate submissions */
+    num_duplicates: number | null;
+    /** View count (null if not available) */
+    view_count: number | null;
+    /** Post creation timestamp (Unix) */
+    created_utc: number;
+    /** Post creation time as ISO 8601 UTC string */
+    created_at: string | null;
+    /** Edited timestamp as float, false if not edited, or null */
+    edited: number | boolean | null;
+    /** Edit time as ISO 8601 UTC string (null if not edited) */
+    edited_at: string | null;
+    /** Whether the post is a self (text) post */
+    is_self: boolean;
+    /** Whether the post is a video */
+    is_video: boolean;
+    /** Whether the post is a gallery */
+    is_gallery: boolean;
+    /** Whether the post is marked NSFW */
+    is_nsfw: boolean;
+    /** Whether the post is marked as a spoiler */
+    is_spoiler: boolean;
+    /** Whether the post is locked */
+    is_locked: boolean;
+    /** Whether the post is stickied */
+    is_stickied: boolean;
+    /** Whether the post is archived */
+    is_archived: boolean;
+    /** Whether the post is pinned */
+    is_pinned: boolean;
+    /** Whether the post is original content */
+    is_original_content: boolean;
+    /** Whether the post is robot-indexable */
+    is_robot_indexable: boolean;
+    /** Whether the post is a meta post */
+    is_meta: boolean;
+    /** Whether the post can be crossposted */
+    is_crosspostable: boolean;
+    /** Whether to send reply notifications */
+    send_replies: boolean;
+    /** Post flair text (null if no flair) */
+    link_flair_text: string | null;
+    /** Post flair background color */
+    link_flair_background_color: string | null;
+    /** Post flair text color */
+    link_flair_text_color: string | null;
+    /** Post flair template ID */
+    link_flair_template_id: string | null;
+    /** Post flair type (text or richtext) */
+    link_flair_type: string | null;
+    /** Post flair CSS class */
+    link_flair_css_class: string | null;
+    /** Distinguished status (moderator, admin, or null) */
+    distinguished: string | null;
+    /** Post thumbnail URL (may be "self", "default", or "nsfw") */
+    thumbnail: string | null;
+    /** Thumbnail width in pixels */
+    thumbnail_width: number | null;
+    /** Thumbnail height in pixels */
+    thumbnail_height: number | null;
+    /** Post hint (image, video, link, self, etc.) */
+    post_hint: string | null;
+    /** Preview images */
+    preview_images: RedditPreviewImage[];
+    /** Embedded media metadata */
+    media: RedditMedia | null;
+    /** Gallery item data */
+    gallery_data: Record<string, unknown>[] | null;
+    /** Parent post fullname if this is a crosspost */
+    crosspost_parent: string | null;
+    /** Suggested sort for comments (null if default) */
+    suggested_sort: string | null;
+    /** Total awards received */
+    total_awards: number;
+    /** Award details */
+    awards: RedditAward[];
+    /** Number of gildings */
+    gilded: number;
+    /** Content categories */
+    content_categories: string[] | null;
+    /** Removal category (null if not removed) */
+    removed_by_category: string | null;
+    /** Treatment tags */
+    treatment_tags: string[];
+}
+/**
+ * A Reddit comment.
+ */
+interface RedditComment {
+    /** Unique comment identifier (without t1_ prefix) */
+    id: string;
+    /** Fullname with t1_ prefix */
+    fullname: string;
+    /** Comment body text */
+    body: string;
+    /** Comment body as HTML */
+    body_html: string | null;
+    /** Author username */
+    author: string;
+    /** Author fullname (t2_ prefixed) */
+    author_fullname: string | null;
+    /** Author flair text */
+    author_flair_text: string | null;
+    /** Author flair type (text or richtext) */
+    author_flair_type: string | null;
+    /** Subreddit name (without r/ prefix) */
+    subreddit: string;
+    /** Subreddit fullname (t5_ prefixed) */
+    subreddit_id: string | null;
+    /** Subreddit with r/ prefix */
+    subreddit_name_prefixed: string | null;
+    /** Subreddit type (public, private, restricted, etc.) */
+    subreddit_type: string | null;
+    /** Post ID this comment belongs to */
+    post_id: string | null;
+    /** Title of the parent post */
+    post_title: string | null;
+    /** Parent ID (t3_ for top-level, t1_ for reply) */
+    parent_id: string | null;
+    /** Permalink to comment */
+    permalink: string;
+    /** Comment score (upvotes minus downvotes) */
+    score: number;
+    /** Raw upvotes */
+    ups: number;
+    /** Raw downvotes */
+    downs: number;
+    /** Controversiality score */
+    controversiality: number;
+    /** Depth level (0 for top-level comments) */
+    depth: number;
+    /** Comment creation timestamp (Unix) */
+    created_utc: number;
+    /** Comment creation time as ISO 8601 UTC string */
+    created_at: string | null;
+    /** Edited timestamp as float, false if not edited, or null */
+    edited: number | boolean | null;
+    /** Edit time as ISO 8601 UTC string (null if not edited) */
+    edited_at: string | null;
+    /** Whether the author is the post submitter */
+    is_submitter: boolean;
+    /** Whether the comment is stickied */
+    is_stickied: boolean;
+    /** Whether the comment is locked */
+    is_locked: boolean;
+    /** Whether the comment score is hidden */
+    is_score_hidden: boolean;
+    /** Whether to send reply notifications */
+    send_replies: boolean;
+    /** Distinguished status (moderator, admin, or null) */
+    distinguished: string | null;
+    /** Total awards received */
+    total_awards: number;
+    /** Number of gildings */
+    gilded: number;
+    /** Nested replies (empty array if none) */
+    replies: RedditComment[];
+}
+/**
+ * A Reddit subreddit.
+ */
+interface RedditSubreddit {
+    /** Unique subreddit identifier */
+    id: string;
+    /** Fullname with t5_ prefix */
+    fullname: string;
+    /** Subreddit name (without r/ prefix) */
+    name: string;
+    /** Subreddit with r/ prefix */
+    display_name_prefixed: string | null;
+    /** Subreddit title */
+    title: string;
+    /** Full sidebar description (markdown) */
+    description: string;
+    /** Full sidebar description as HTML */
+    description_html: string | null;
+    /** Short public description */
+    public_description: string;
+    /** Short public description as HTML */
+    public_description_html: string | null;
+    /** Text shown when submitting a new post */
+    submit_text: string;
+    /** Submit text as HTML */
+    submit_text_html: string | null;
+    /** Header title text */
+    header_title: string | null;
+    /** Subreddit URL path */
+    url: string;
+    /** Subreddit type (public, private, restricted, etc.) */
+    type: string;
+    /** Allowed submission type (any, link, self) */
+    submission_type: string | null;
+    /** Number of subscribers */
+    subscribers: number;
+    /** Number of users currently online */
+    active_users: number | null;
+    /** Creation timestamp (Unix) */
+    created_utc: number;
+    /** Creation time as ISO 8601 UTC string */
+    created_at: string | null;
+    /** Whether the subreddit is marked NSFW */
+    is_nsfw: boolean;
+    /** Whether the subreddit is quarantined */
+    is_quarantined: boolean;
+    /** Whether the subreddit is advertiser-friendly */
+    is_advertiser_friendly: boolean;
+    /** Advertiser category */
+    advertiser_category: string | null;
+    /** Subreddit language code */
+    language: string | null;
+    /** Subreddit icon URL */
+    icon_url: string | null;
+    /** Header image URL */
+    header_url: string | null;
+    /** Banner image URL */
+    banner_url: string | null;
+    /** Banner background color (hex) */
+    banner_background_color: string | null;
+    /** Primary theme color (hex) */
+    primary_color: string | null;
+    /** Key theme color (hex) */
+    key_color: string | null;
+    /** Whether the wiki is enabled */
+    wiki_enabled: boolean;
+    /** Whether image posts are allowed */
+    allow_images: boolean;
+    /** Whether video posts are allowed */
+    allow_videos: boolean;
+    /** Whether gallery posts are allowed */
+    allow_galleries: boolean;
+    /** Whether polls are allowed */
+    allow_polls: boolean;
+    /** Whether the subreddit appears in discovery feeds */
+    allow_discovery: boolean;
+    /** Whether spoiler tags are enabled */
+    spoilers_enabled: boolean;
+    /** Whether custom emojis are enabled */
+    emojis_enabled: boolean;
+    /** Whether free-form reports are enabled */
+    free_form_reports: boolean;
+    /** Whether the subreddit accepts followers */
+    accept_followers: boolean;
+    /** Whether posting is restricted */
+    restrict_posting: boolean;
+    /** Whether link flairs are enabled */
+    link_flair_enabled: boolean;
+    /** Position of link flair (left, right, or null) */
+    link_flair_position: string | null;
+    /** Whether user flairs are enabled */
+    user_flair_enabled: boolean;
+    /** Position of user flair (left, right, or null) */
+    user_flair_position: string | null;
+    /** Minutes before comment scores are shown */
+    comment_score_hide_mins: number;
+    /** Whether posts are automatically archived */
+    should_archive_posts: boolean;
+    /** Media types allowed in comments */
+    allowed_media_in_comments: string[];
+}
+/**
+ * A Reddit user profile.
+ */
+interface RedditUser {
+    /** Unique user identifier */
+    id: string;
+    /** Fullname with t2_ prefix */
+    fullname: string | null;
+    /** Username (without u/ prefix) */
+    name: string;
+    /** Username with u/ prefix */
+    display_name_prefixed: string | null;
+    /** Avatar/profile icon URL */
+    icon_url: string | null;
+    /** Snoovatar image URL */
+    snoovatar_url: string | null;
+    /** Profile banner URL */
+    banner_url: string | null;
+    /** Profile title/tagline */
+    profile_title: string | null;
+    /** Profile page URL */
+    profile_url: string | null;
+    /** User description / about text */
+    description: string;
+    /** Post karma */
+    link_karma: number;
+    /** Comment karma */
+    comment_karma: number;
+    /** Karma from received awards */
+    awardee_karma: number;
+    /** Karma from given awards */
+    awarder_karma: number;
+    /** Combined total karma */
+    total_karma: number;
+    /** Account creation timestamp (Unix) */
+    created_utc: number;
+    /** Account creation time as ISO 8601 UTC string */
+    created_at: string | null;
+    /** Whether the account email is verified */
+    has_verified_email: boolean;
+    /** Whether the account is verified */
+    verified: boolean;
+    /** Whether the account accepts followers */
+    accepts_followers: boolean;
+    /** Whether the account has subscribed to Reddit */
+    has_subscribed: boolean;
+    /** Whether the account is a Reddit employee */
+    is_employee: boolean;
+    /** Whether the account is a moderator somewhere */
+    is_mod: boolean;
+    /** Whether the account has Reddit Premium */
+    is_gold: boolean;
+    /** Whether the account is suspended */
+    is_suspended: boolean;
+    /** Whether the profile is NSFW */
+    is_nsfw: boolean;
+    /** Whether the snoovatar is shown in comments */
+    pref_show_snoovatar: boolean;
+}
+/**
+ * A subreddit rule.
+ */
+interface RedditRule {
+    /** Rule priority order */
+    priority: number;
+    /** Short name / title of the rule */
+    short_name: string;
+    /** Full rule description (markdown) */
+    description: string;
+    /** Full rule description as HTML */
+    description_html: string | null;
+    /** What the rule applies to (link, comment, all) */
+    kind: "link" | "comment" | "all" | string;
+    /** Violation reason label */
+    violation_reason: string | null;
+}
+/**
+ * A subreddit wiki page.
+ */
+interface RedditWikiPage {
+    /** Wiki page title/slug */
+    title: string;
+    /** Page content (markdown) */
+    content_md: string;
+    /** Page content as HTML */
+    content_html: string | null;
+    /** Author of latest revision */
+    revision_by: string | null;
+    /** Revision timestamp (Unix), null if unknown */
+    revision_date: number | null;
+}
+/**
+ * A Reddit user trophy.
+ */
+interface RedditTrophy {
+    /** Trophy name */
+    name: string;
+    /** Trophy description */
+    description: string | null;
+    /** Trophy icon URL */
+    icon_url: string | null;
+    /** URL associated with the trophy */
+    url: string | null;
+}
+/**
+ * A subreddit moderator entry.
+ */
+interface RedditModerator {
+    /** Moderator username */
+    name: string;
+    /** Moderator user ID */
+    id: string | null;
+    /** Moderator permissions list */
+    mod_permissions: string[];
+    /** Date added as moderator (Unix), null if unknown */
+    date: number | null;
+}
+/**
+ * Pagination metadata for list responses.
+ */
+interface RedditPagination {
+    /** Cursor for fetching the next page (null if no more pages) */
+    after: string | null;
+    /** Cursor for fetching the previous page (null if on first page) */
+    before: string | null;
+    /** Total number of items fetched so far */
+    count: number;
+    /** Maximum number of items per page */
+    limit: number;
+}
+/**
+ * Response from the post search endpoint.
+ */
+interface SearchPostsResponse {
+    /** List of matching posts */
+    posts: RedditPost[];
+    /** Pagination metadata */
+    pagination: RedditPagination;
+    /** Search query string */
+    query: string;
+    /** Sort method used */
+    sort: string;
+}
+/**
+ * Response from the subreddit posts endpoint.
+ */
+interface SubredditPostsResponse {
+    /** List of posts in the subreddit */
+    posts: RedditPost[];
+    /** Pagination metadata */
+    pagination: RedditPagination;
+    /** Subreddit name */
+    subreddit: string;
+    /** Sort method used */
+    sort: string;
+}
+/**
+ * Response from the post detail endpoint.
+ */
+interface PostDetailResponse {
+    /** Full post details */
+    post: RedditPost;
+}
+/**
+ * Response from the post comments endpoint.
+ */
+interface PostCommentsResponse {
+    /** Post details */
+    post: RedditPost;
+    /** Top-level comments with nested replies */
+    comments: RedditComment[];
+    /** Pagination metadata */
+    pagination: RedditPagination;
+}
+/**
+ * Response from the post duplicates endpoint.
+ */
+interface PostDuplicatesResponse {
+    /** The original post */
+    original: RedditPost;
+    /** Cross-posts and duplicate submissions */
+    duplicates: RedditPost[];
+    /** Pagination metadata */
+    pagination: RedditPagination;
+}
+/**
+ * Response from the subreddit detail endpoint.
+ */
+interface SubredditDetailResponse {
+    /** Full subreddit details */
+    subreddit: RedditSubreddit;
+}
+/**
+ * Response from the subreddit rules endpoint.
+ */
+interface SubredditRulesResponse {
+    /** List of subreddit rules */
+    rules: RedditRule[];
+    /** Subreddit name */
+    subreddit: string;
+}
+/**
+ * Response from the subreddit moderators endpoint.
+ */
+interface SubredditModeratorsResponse {
+    /** List of moderators */
+    moderators: RedditModerator[];
+    /** Subreddit name */
+    subreddit: string;
+}
+/**
+ * Response from the subreddit wiki pages list endpoint.
+ */
+interface SubredditWikiPagesResponse {
+    /** List of wiki page slugs */
+    pages: string[];
+    /** Subreddit name */
+    subreddit: string;
+}
+/**
+ * Response from the wiki page endpoint.
+ */
+interface WikiPageResponse {
+    /** The wiki page content */
+    page: RedditWikiPage;
+    /** Subreddit name */
+    subreddit: string;
+}
+/**
+ * Response from the user profile endpoint.
+ */
+interface UserProfileResponse {
+    /** Full user profile */
+    user: RedditUser;
+}
+/**
+ * Response from the user posts endpoint.
+ */
+interface UserPostsResponse {
+    /** List of user's posts */
+    posts: RedditPost[];
+    /** Pagination metadata */
+    pagination: RedditPagination;
+    /** Username */
+    username: string;
+}
+/**
+ * Response from the user comments endpoint.
+ */
+interface UserCommentsResponse {
+    /** List of user's comments */
+    comments: RedditComment[];
+    /** Pagination metadata */
+    pagination: RedditPagination;
+    /** Username */
+    username: string;
+}
+/**
+ * Response from the user moderated subreddits endpoint.
+ */
+interface UserModeratedResponse {
+    /** Subreddits moderated by the user */
+    subreddits: RedditSubreddit[];
+    /** Username */
+    username: string;
+}
+/**
+ * Response from the user trophies endpoint.
+ */
+interface UserTrophiesResponse {
+    /** List of trophies awarded to the user */
+    trophies: RedditTrophy[];
+    /** Username */
+    username: string;
+}
+/**
+ * Response from the subreddit search endpoint.
+ */
+interface SearchSubredditsResponse {
+    /** List of matching subreddits */
+    subreddits: RedditSubreddit[];
+    /** Pagination metadata */
+    pagination: RedditPagination;
+    /** Search query string */
+    query: string;
+}
+/**
+ * Response from the user search endpoint.
+ */
+interface SearchUsersResponse {
+    /** List of matching users */
+    users: RedditUser[];
+    /** Pagination metadata */
+    pagination: RedditPagination;
+    /** Search query string */
+    query: string;
+}
+/**
+ * Response from the trending posts endpoint.
+ */
+interface TrendingPostsResponse {
+    /** List of trending posts */
+    posts: RedditPost[];
+    /** Pagination metadata */
+    pagination: RedditPagination;
+    /** Sort method used */
+    sort: string;
+}
+/**
+ * Response from the popular subreddits endpoint.
+ */
+interface PopularSubredditsResponse {
+    /** List of popular subreddits */
+    subreddits: RedditSubreddit[];
+    /** Pagination metadata */
+    pagination: RedditPagination;
+}
+/**
+ * Response from the domain posts endpoint.
+ */
+interface DomainPostsResponse {
+    /** List of posts linking to the domain */
+    posts: RedditPost[];
+    /** Pagination metadata */
+    pagination: RedditPagination;
+    /** Domain name */
+    domain: string;
+}
+
+/**
+ * Reddit Search API client.
+ *
+ * Provides methods for searching Reddit posts, subreddits, users, and domain posts.
+ */
+
+/**
+ * Client for Reddit search endpoints.
+ *
+ * @example
+ * ```typescript
+ * const client = new ScrapeBadger({ apiKey: "key" });
+ *
+ * // Search posts
+ * const results = await client.reddit.search.posts({ query: "typescript tips" });
+ * for (const post of results.posts) {
+ *   console.log(`${post.title} — ${post.score} points`);
+ * }
+ *
+ * // Search subreddits
+ * const subs = await client.reddit.search.subreddits({ query: "programming" });
+ *
+ * // Get posts from a domain
+ * const domainPosts = await client.reddit.search.domainPosts({ domain: "github.com" });
+ * ```
+ */
+declare class SearchClient {
+    private readonly client;
+    constructor(client: BaseClient);
+    /**
+     * Search Reddit posts.
+     *
+     * @param options - Search parameters.
+     * @param options.query - Search query string.
+     * @param options.subreddit - Restrict search to a specific subreddit.
+     * @param options.sort - Sort order (relevance, hot, top, new, comments).
+     * @param options.time - Time filter (hour, day, week, month, year, all).
+     * @param options.after - Pagination cursor for the next page.
+     * @param options.limit - Number of results to return (max 100).
+     * @returns Search results with posts 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.reddit.search.posts({
+     *   query: "best practices",
+     *   subreddit: "programming",
+     *   sort: "top",
+     *   time: "month",
+     *   limit: 25,
+     * });
+     * console.log(`Found ${results.posts.length} posts`);
+     * ```
+     */
+    posts(options: {
+        query: string;
+        subreddit?: string;
+        sort?: "relevance" | "hot" | "top" | "new" | "comments";
+        time?: "hour" | "day" | "week" | "month" | "year" | "all";
+        after?: string;
+        limit?: number;
+    }): Promise<SearchPostsResponse>;
+    /**
+     * Search Reddit subreddits.
+     *
+     * @param options - Search parameters.
+     * @param options.query - Search query string.
+     * @param options.after - Pagination cursor for the next page.
+     * @param options.limit - Number of results to return (max 100).
+     * @returns Matching subreddits with pagination metadata.
+     * @throws AuthenticationError - If the API key is invalid.
+     * @throws ValidationError - If the search parameters are invalid.
+     *
+     * @example
+     * ```typescript
+     * const results = await client.reddit.search.subreddits({
+     *   query: "javascript",
+     *   limit: 10,
+     * });
+     * for (const sub of results.subreddits) {
+     *   console.log(`r/${sub.display_name}: ${sub.subscribers.toLocaleString()} subscribers`);
+     * }
+     * ```
+     */
+    subreddits(options: {
+        query: string;
+        after?: string;
+        limit?: number;
+    }): Promise<SearchSubredditsResponse>;
+    /**
+     * Search Reddit users.
+     *
+     * @param options - Search parameters.
+     * @param options.query - Search query string.
+     * @param options.after - Pagination cursor for the next page.
+     * @param options.limit - Number of results to return (max 100).
+     * @returns Matching users with pagination metadata.
+     * @throws AuthenticationError - If the API key is invalid.
+     * @throws ValidationError - If the search parameters are invalid.
+     *
+     * @example
+     * ```typescript
+     * const results = await client.reddit.search.users({
+     *   query: "john",
+     *   limit: 20,
+     * });
+     * for (const user of results.users) {
+     *   console.log(`u/${user.name}: ${user.total_karma.toLocaleString()} karma`);
+     * }
+     * ```
+     */
+    users(options: {
+        query: string;
+        after?: string;
+        limit?: number;
+    }): Promise<SearchUsersResponse>;
+    /**
+     * Get Reddit posts linking to a specific domain.
+     *
+     * @param options - Request parameters.
+     * @param options.domain - Domain name to search for (e.g. "github.com").
+     * @param options.sort - Sort order (hot, new, top, rising).
+     * @param options.time - Time filter for top sort (hour, day, week, month, year, all).
+     * @param options.after - Pagination cursor for the next page.
+     * @param options.limit - Number of results to return (max 100).
+     * @returns Posts linking to the domain with pagination metadata.
+     * @throws AuthenticationError - If the API key is invalid.
+     * @throws ValidationError - If the parameters are invalid.
+     *
+     * @example
+     * ```typescript
+     * const results = await client.reddit.search.domainPosts({
+     *   domain: "github.com",
+     *   sort: "top",
+     *   time: "week",
+     *   limit: 25,
+     * });
+     * for (const post of results.posts) {
+     *   console.log(`r/${post.subreddit}: ${post.title}`);
+     * }
+     * ```
+     */
+    domainPosts(options: {
+        domain: string;
+        sort?: "hot" | "new" | "top" | "rising";
+        time?: "hour" | "day" | "week" | "month" | "year" | "all";
+        after?: string;
+        limit?: number;
+    }): Promise<DomainPostsResponse>;
+}
+
+/**
+ * Reddit Posts API client.
+ *
+ * Provides methods for fetching trending posts, post details, comments, and duplicates.
+ */
+
+/**
+ * Client for Reddit post endpoints.
+ *
+ * @example
+ * ```typescript
+ * const client = new ScrapeBadger({ apiKey: "key" });
+ *
+ * // Get trending posts
+ * const trending = await client.reddit.posts.trending({ subreddit: "programming" });
+ *
+ * // Get post details
+ * const post = await client.reddit.posts.get("t3_abc123");
+ *
+ * // Get post comments
+ * const { comments } = await client.reddit.posts.comments("abc123", { subreddit: "programming" });
+ * ```
+ */
+declare class PostsClient {
+    private readonly client;
+    constructor(client: BaseClient);
+    /**
+     * Get trending/hot posts from Reddit or a specific subreddit.
+     *
+     * @param options - Request parameters.
+     * @param options.subreddit - Subreddit name (without r/). If omitted, returns site-wide posts.
+     * @param options.sort - Sort order (hot, new, top, rising, controversial).
+     * @param options.time - Time filter for top/controversial (hour, day, week, month, year, all).
+     * @param options.after - Pagination cursor for the next page.
+     * @param options.limit - Number of results to return (max 100).
+     * @returns Trending posts with pagination metadata.
+     * @throws AuthenticationError - If the API key is invalid.
+     *
+     * @example
+     * ```typescript
+     * const results = await client.reddit.posts.trending({
+     *   subreddit: "worldnews",
+     *   sort: "hot",
+     *   limit: 25,
+     * });
+     * for (const post of results.posts) {
+     *   console.log(`${post.title} (${post.num_comments} comments)`);
+     * }
+     * ```
+     */
+    trending(options?: {
+        subreddit?: string;
+        sort?: "hot" | "new" | "top" | "rising" | "controversial";
+        time?: "hour" | "day" | "week" | "month" | "year" | "all";
+        after?: string;
+        limit?: number;
+    }): Promise<TrendingPostsResponse>;
+    /**
+     * Get full details of a single Reddit post.
+     *
+     * @param postId - The Reddit post ID (e.g. "abc123" or "t3_abc123").
+     * @param options - Optional parameters.
+     * @param options.subreddit - Subreddit name (helps resolve the post URL).
+     * @returns Full post details.
+     * @throws NotFoundError - If the post doesn't exist.
+     * @throws AuthenticationError - If the API key is invalid.
+     *
+     * @example
+     * ```typescript
+     * const response = await client.reddit.posts.get("abc123", { subreddit: "programming" });
+     * const { post } = response;
+     * console.log(`${post.title} by u/${post.author}`);
+     * console.log(`Score: ${post.score}, Comments: ${post.num_comments}`);
+     * ```
+     */
+    get(postId: string, options?: {
+        subreddit?: string;
+    }): Promise<PostDetailResponse>;
+    /**
+     * Get comments for a Reddit post.
+     *
+     * @param postId - The Reddit post ID (e.g. "abc123" or "t3_abc123").
+     * @param options - Optional parameters.
+     * @param options.subreddit - Subreddit name (helps resolve the post URL).
+     * @param options.sort - Comment sort order (confidence, top, new, controversial, old, qa).
+     * @param options.depth - Maximum comment tree depth.
+     * @param options.limit - Number of top-level comments to return.
+     * @returns Post details and nested comment tree.
+     * @throws NotFoundError - If the post doesn't exist.
+     * @throws AuthenticationError - If the API key is invalid.
+     *
+     * @example
+     * ```typescript
+     * const response = await client.reddit.posts.comments("abc123", {
+     *   subreddit: "programming",
+     *   sort: "top",
+     *   limit: 50,
+     * });
+     * for (const comment of response.comments) {
+     *   console.log(`u/${comment.author}: ${comment.body.slice(0, 100)}`);
+     * }
+     * ```
+     */
+    comments(postId: string, options?: {
+        subreddit?: string;
+        sort?: "confidence" | "top" | "new" | "controversial" | "old" | "qa";
+        depth?: number;
+        limit?: number;
+    }): Promise<PostCommentsResponse>;
+    /**
+     * Get cross-posts and duplicate submissions of a Reddit post.
+     *
+     * @param postId - The Reddit post ID (e.g. "abc123" or "t3_abc123").
+     * @param options - Optional parameters.
+     * @param options.after - Pagination cursor for the next page.
+     * @param options.limit - Number of results to return (max 100).
+     * @returns The original post and its duplicate submissions.
+     * @throws NotFoundError - If the post doesn't exist.
+     * @throws AuthenticationError - If the API key is invalid.
+     *
+     * @example
+     * ```typescript
+     * const response = await client.reddit.posts.duplicates("abc123");
+     * console.log(`Original: ${response.post.title}`);
+     * console.log(`Cross-posted ${response.duplicates.length} times`);
+     * for (const dupe of response.duplicates) {
+     *   console.log(`  r/${dupe.subreddit}: ${dupe.score} points`);
+     * }
+     * ```
+     */
+    duplicates(postId: string, options?: {
+        after?: string;
+        limit?: number;
+    }): Promise<PostDuplicatesResponse>;
+}
+
+/**
+ * Reddit Subreddits API client.
+ *
+ * Provides methods for fetching subreddit details, posts, rules, moderators, and wiki pages.
+ */
+
+/**
+ * Client for Reddit subreddit endpoints.
+ *
+ * @example
+ * ```typescript
+ * const client = new ScrapeBadger({ apiKey: "key" });
+ *
+ * // Get subreddit details
+ * const sub = await client.reddit.subreddits.get("programming");
+ * console.log(`r/programming: ${sub.subreddit.subscribers.toLocaleString()} subscribers`);
+ *
+ * // Get subreddit posts
+ * const posts = await client.reddit.subreddits.posts("programming", { sort: "top" });
+ *
+ * // Get subreddit rules
+ * const rules = await client.reddit.subreddits.rules("programming");
+ * ```
+ */
+declare class SubredditsClient {
+    private readonly client;
+    constructor(client: BaseClient);
+    /**
+     * Get a subreddit's full details and metadata.
+     *
+     * @param subreddit - Subreddit name (without r/ prefix).
+     * @returns Full subreddit details.
+     * @throws NotFoundError - If the subreddit doesn't exist.
+     * @throws AuthenticationError - If the API key is invalid.
+     *
+     * @example
+     * ```typescript
+     * const response = await client.reddit.subreddits.get("javascript");
+     * const { subreddit } = response;
+     * console.log(`${subreddit.title}: ${subreddit.subscribers.toLocaleString()} members`);
+     * console.log(`Description: ${subreddit.public_description}`);
+     * ```
+     */
+    get(subreddit: string): Promise<SubredditDetailResponse>;
+    /**
+     * Get posts from a subreddit.
+     *
+     * @param subreddit - Subreddit name (without r/ prefix).
+     * @param options - Optional parameters.
+     * @param options.sort - Sort order (hot, new, top, rising, controversial).
+     * @param options.time - Time filter for top/controversial (hour, day, week, month, year, all).
+     * @param options.after - Pagination cursor for the next page.
+     * @param options.limit - Number of results to return (max 100).
+     * @returns Subreddit posts with pagination metadata.
+     * @throws NotFoundError - If the subreddit doesn't exist.
+     * @throws AuthenticationError - If the API key is invalid.
+     *
+     * @example
+     * ```typescript
+     * const response = await client.reddit.subreddits.posts("typescript", {
+     *   sort: "top",
+     *   time: "week",
+     *   limit: 25,
+     * });
+     * for (const post of response.posts) {
+     *   console.log(`${post.title} — ${post.score} pts`);
+     * }
+     * ```
+     */
+    posts(subreddit: string, options?: {
+        sort?: "hot" | "new" | "top" | "rising" | "controversial";
+        time?: "hour" | "day" | "week" | "month" | "year" | "all";
+        after?: string;
+        limit?: number;
+    }): Promise<SubredditPostsResponse>;
+    /**
+     * Get the rules for a subreddit.
+     *
+     * @param subreddit - Subreddit name (without r/ prefix).
+     * @returns List of subreddit rules.
+     * @throws NotFoundError - If the subreddit doesn't exist.
+     * @throws AuthenticationError - If the API key is invalid.
+     *
+     * @example
+     * ```typescript
+     * const response = await client.reddit.subreddits.rules("AskReddit");
+     * for (const rule of response.rules) {
+     *   console.log(`${rule.priority}. ${rule.short_name}`);
+     *   console.log(`   ${rule.description}`);
+     * }
+     * ```
+     */
+    rules(subreddit: string): Promise<SubredditRulesResponse>;
+    /**
+     * Get the moderators of a subreddit.
+     *
+     * @param subreddit - Subreddit name (without r/ prefix).
+     * @param options - Optional parameters.
+     * @param options.after - Pagination cursor for the next page.
+     * @param options.limit - Number of results to return.
+     * @returns List of moderators with pagination metadata.
+     * @throws NotFoundError - If the subreddit doesn't exist.
+     * @throws AuthenticationError - If the API key is invalid.
+     *
+     * @example
+     * ```typescript
+     * const response = await client.reddit.subreddits.moderators("programming");
+     * for (const mod of response.moderators) {
+     *   console.log(`u/${mod.name}: [${mod.mod_permissions.join(", ")}]`);
+     * }
+     * ```
+     */
+    moderators(subreddit: string, options?: {
+        after?: string;
+        limit?: number;
+    }): Promise<SubredditModeratorsResponse>;
+    /**
+     * List all wiki pages in a subreddit.
+     *
+     * @param subreddit - Subreddit name (without r/ prefix).
+     * @returns List of wiki page slugs.
+     * @throws NotFoundError - If the subreddit doesn't exist.
+     * @throws AuthenticationError - If the API key is invalid.
+     *
+     * @example
+     * ```typescript
+     * const response = await client.reddit.subreddits.wikiPages("rust");
+     * for (const page of response.pages) {
+     *   console.log(`/r/rust/wiki/${page}`);
+     * }
+     * ```
+     */
+    wikiPages(subreddit: string): Promise<SubredditWikiPagesResponse>;
+    /**
+     * Get the content of a specific wiki page in a subreddit.
+     *
+     * @param subreddit - Subreddit name (without r/ prefix).
+     * @param page - Wiki page slug (e.g. "index", "faq").
+     * @returns Wiki page content and metadata.
+     * @throws NotFoundError - If the subreddit or wiki page doesn't exist.
+     * @throws AuthenticationError - If the API key is invalid.
+     *
+     * @example
+     * ```typescript
+     * const response = await client.reddit.subreddits.wikiPage("learnprogramming", "faq");
+     * console.log(`Last edited by: u/${response.page.revision_by}`);
+     * console.log(response.page.content_md);
+     * ```
+     */
+    wikiPage(subreddit: string, page: string): Promise<WikiPageResponse>;
+    /**
+     * Get the most popular subreddits on Reddit.
+     *
+     * @param options - Optional parameters.
+     * @param options.after - Pagination cursor for the next page.
+     * @param options.limit - Number of results to return (max 100).
+     * @returns Popular subreddits with pagination metadata.
+     * @throws AuthenticationError - If the API key is invalid.
+     *
+     * @example
+     * ```typescript
+     * const response = await client.reddit.subreddits.popular({ limit: 20 });
+     * for (const sub of response.subreddits) {
+     *   console.log(`r/${sub.display_name}: ${sub.subscribers.toLocaleString()} subscribers`);
+     * }
+     * ```
+     */
+    popular(options?: {
+        after?: string;
+        limit?: number;
+    }): Promise<PopularSubredditsResponse>;
+    /**
+     * Get newly created subreddits on Reddit.
+     *
+     * @param options - Optional parameters.
+     * @param options.after - Pagination cursor for the next page.
+     * @param options.limit - Number of results to return (max 100).
+     * @returns New subreddits with pagination metadata.
+     * @throws AuthenticationError - If the API key is invalid.
+     *
+     * @example
+     * ```typescript
+     * const response = await client.reddit.subreddits.newSubreddits({ limit: 20 });
+     * for (const sub of response.subreddits) {
+     *   console.log(`r/${sub.display_name} (created: ${new Date(sub.created_utc * 1000).toLocaleDateString()})`);
+     * }
+     * ```
+     */
+    newSubreddits(options?: {
+        after?: string;
+        limit?: number;
+    }): Promise<PopularSubredditsResponse>;
+}
+
+/**
+ * Reddit Users API client.
+ *
+ * Provides methods for fetching Reddit user profiles, posts, comments, moderated subreddits, and trophies.
+ */
+
+/**
+ * Client for Reddit user endpoints.
+ *
+ * @example
+ * ```typescript
+ * const client = new ScrapeBadger({ apiKey: "key" });
+ *
+ * // Get user profile
+ * const profile = await client.reddit.users.get("spez");
+ * console.log(`u/${profile.user.name}: ${profile.user.total_karma.toLocaleString()} karma`);
+ *
+ * // Get user's recent posts
+ * const posts = await client.reddit.users.posts("spez", { sort: "top", limit: 10 });
+ *
+ * // Get user's comments
+ * const comments = await client.reddit.users.comments("spez", { sort: "new" });
+ * ```
+ */
+declare class UsersClient {
+    private readonly client;
+    constructor(client: BaseClient);
+    /**
+     * Get a Reddit user's profile.
+     *
+     * @param username - The Reddit username (without u/ prefix).
+     * @returns The user profile response.
+     * @throws NotFoundError - If the user doesn't exist or is suspended.
+     * @throws AuthenticationError - If the API key is invalid.
+     *
+     * @example
+     * ```typescript
+     * const response = await client.reddit.users.get("spez");
+     * const { user } = response;
+     * console.log(`u/${user.name}`);
+     * console.log(`Karma: ${user.total_karma.toLocaleString()} (${user.link_karma} post, ${user.comment_karma} comment)`);
+     * console.log(`Account age: ${new Date(user.created_utc * 1000).toLocaleDateString()}`);
+     * ```
+     */
+    get(username: string): Promise<UserProfileResponse>;
+    /**
+     * Get posts submitted by a Reddit user.
+     *
+     * @param username - The Reddit username (without u/ prefix).
+     * @param options - Optional parameters.
+     * @param options.sort - Sort order (hot, new, top, controversial).
+     * @param options.time - Time filter for top/controversial (hour, day, week, month, year, all).
+     * @param options.after - Pagination cursor for the next page.
+     * @param options.limit - Number of results to return (max 100).
+     * @returns The user's posts 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.reddit.users.posts("spez", {
+     *   sort: "top",
+     *   time: "all",
+     *   limit: 25,
+     * });
+     * for (const post of response.posts) {
+     *   console.log(`r/${post.subreddit}: ${post.title} (${post.score} pts)`);
+     * }
+     * ```
+     */
+    posts(username: string, options?: {
+        sort?: "hot" | "new" | "top" | "controversial";
+        time?: "hour" | "day" | "week" | "month" | "year" | "all";
+        after?: string;
+        limit?: number;
+    }): Promise<UserPostsResponse>;
+    /**
+     * Get comments made by a Reddit user.
+     *
+     * @param username - The Reddit username (without u/ prefix).
+     * @param options - Optional parameters.
+     * @param options.sort - Sort order (hot, new, top, controversial).
+     * @param options.time - Time filter for top/controversial (hour, day, week, month, year, all).
+     * @param options.after - Pagination cursor for the next page.
+     * @param options.limit - Number of results to return (max 100).
+     * @returns The user's comments 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.reddit.users.comments("spez", {
+     *   sort: "new",
+     *   limit: 50,
+     * });
+     * for (const comment of response.comments) {
+     *   console.log(`r/${comment.subreddit}: ${comment.body.slice(0, 80)}`);
+     * }
+     * ```
+     */
+    comments(username: string, options?: {
+        sort?: "hot" | "new" | "top" | "controversial";
+        time?: "hour" | "day" | "week" | "month" | "year" | "all";
+        after?: string;
+        limit?: number;
+    }): Promise<UserCommentsResponse>;
+    /**
+     * Get subreddits moderated by a Reddit user.
+     *
+     * @param username - The Reddit username (without u/ prefix).
+     * @returns Subreddits moderated by the user.
+     * @throws NotFoundError - If the user doesn't exist.
+     * @throws AuthenticationError - If the API key is invalid.
+     *
+     * @example
+     * ```typescript
+     * const response = await client.reddit.users.moderated("spez");
+     * for (const sub of response.subreddits) {
+     *   console.log(`r/${sub.display_name}: ${sub.subscribers.toLocaleString()} subscribers`);
+     * }
+     * ```
+     */
+    moderated(username: string): Promise<UserModeratedResponse>;
+    /**
+     * Get trophies awarded to a Reddit user.
+     *
+     * @param username - The Reddit username (without u/ prefix).
+     * @returns List of trophies awarded to the user.
+     * @throws NotFoundError - If the user doesn't exist.
+     * @throws AuthenticationError - If the API key is invalid.
+     *
+     * @example
+     * ```typescript
+     * const response = await client.reddit.users.trophies("spez");
+     * for (const trophy of response.trophies) {
+     *   console.log(`${trophy.name}${trophy.description ? `: ${trophy.description}` : ""}`);
+     * }
+     * ```
+     */
+    trophies(username: string): Promise<UserTrophiesResponse>;
+}
+
+/**
+ * Reddit API client.
+ *
+ * Provides access to all Reddit API endpoints through specialized sub-clients.
+ */
+
+/**
+ * Reddit API client with access to all Reddit endpoints.
+ *
+ * Provides sub-clients for different resource types:
+ * - `search` - Search posts, subreddits, users, and domain posts
+ * - `posts` - Trending posts, post details, comments, and cross-posts
+ * - `subreddits` - Subreddit details, posts, rules, moderators, and wiki pages
+ * - `users` - User profiles, posts, comments, moderated subreddits, and trophies
+ *
+ * @example
+ * ```typescript
+ * const client = new ScrapeBadger({ apiKey: "key" });
+ *
+ * // Search posts
+ * const results = await client.reddit.search.posts({ query: "typescript tips" });
+ *
+ * // Get subreddit details
+ * const sub = await client.reddit.subreddits.get("programming");
+ *
+ * // Get user profile
+ * const user = await client.reddit.users.get("spez");
+ *
+ * // Get trending posts
+ * const trending = await client.reddit.posts.trending({ sort: "hot" });
+ * ```
+ */
+declare class RedditClient {
+    /** Client for search operations (posts, subreddits, users, domain posts) */
+    readonly search: SearchClient;
+    /** Client for post operations (trending, details, comments, duplicates) */
+    readonly posts: PostsClient;
+    /** Client for subreddit operations (details, posts, rules, moderators, wiki) */
+    readonly subreddits: SubredditsClient;
+    /** Client for user operations (profile, posts, comments, moderated, trophies) */
+    readonly users: UsersClient;
+    /**
+     * Create a new Reddit client.
+     *
+     * @param client - The base HTTP client for making requests.
+     */
+    constructor(client: BaseClient);
 }
 
 /**
@@ -202,6 +3381,12 @@ 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;
+    /** Reddit scraper API client */
+    readonly reddit: RedditClient;
     /**
      * Create a new ScrapeBadger client.
      *
@@ -230,4 +3415,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 DomainPostsResponse, 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$1 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 PopularSubredditsResponse, type PostCommentsResponse, type PostDetailResponse, type PostDuplicatesResponse, type ProductsDetailParams, RedditClient, type RedditComment, type RedditModerator, type RedditPagination, type RedditPost, PostsClient as RedditPostsClient, type RedditRule, SearchClient as RedditSearchClient, type RedditSubreddit, SubredditsClient as RedditSubredditsClient, type RedditTrophy, type RedditUser, type UserProfileResponse as RedditUserProfileResponse, UsersClient as RedditUsersClient, type RedditWikiPage, type ScholarAuthorCitationParams, type ScholarAuthorParams, type ScholarCiteParams, type ScholarProfilesParams, type ScholarSearchParams, ScrapeBadger, ScrapeBadgerConfig, type ScrapeOptions, type ScrapeResult, type SearchPostsResponse, type SearchSubredditsResponse, type SearchUsersResponse, type ShoppingClickParams, type ShoppingProductParams, type ShoppingSearchParams, type ShortsSearchParams, type SubredditDetailResponse, type SubredditModeratorsResponse, type SubredditPostsResponse, type SubredditRulesResponse, type SubredditWikiPagesResponse, type TrendingPostsResponse, type TrendsAutocompleteParams, type TrendsInterestParams, type TrendsRegionsParams, type TrendsRelatedParams, type TrendsTrendingParams, TwitterClient, type UserCommentsResponse, type UserModeratedResponse, type UserPostsResponse, type UserTrophiesResponse, 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$2 as VintedSearchClient, type VintedSearchParams, type SearchResponse as VintedSearchResponse, type VintedSellerSummary, type VintedStatus, type StatusesResponse as VintedStatusesResponse, type UserItemsResponse as VintedUserItemsResponse, type VintedUserProfile, type UserProfileResponse$1 as VintedUserProfileResponse, type VintedUserSummary, UsersClient$1 as VintedUsersClient, WebClient, type WikiPageResponse };