scrapebadger 0.4.0 → 0.8.0

package/dist/index.mjs

@@ -2186,7 +2186,7 @@ var StreamClient = class {
           return;
         }
         if (!reconnect) {
-          const reasonStr = reason instanceof Buffer ? reason.toString() : String(reason ?? "");
+          const reasonStr = reason instanceof Buffer ? reason.toString() : typeof reason === "string" ? reason : "";
           emitter.emit(
             "error",
             new WebSocketStreamError(`WebSocket closed: ${reasonStr || String(code)}`)
@@ -2427,94 +2427,1523 @@ var WebClient = class {
   }
   /**
    * 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
    */
   async scrape(url, options = {}) {
     const body = { url };
-    if (options.renderJs) body.render_js = true;
-    if (options.outputFormat && options.outputFormat !== "html")
-      body.output_format = options.outputFormat;
-    if (options.proxyCountry) body.proxy_country = options.proxyCountry;
-    if (options.proxyType) body.proxy_type = options.proxyType;
-    if (options.sessionId) body.session_id = options.sessionId;
-    if (options.engine) body.engine = options.engine;
+    if (options.format !== void 0) body.format = options.format;
+    if (options.renderJs !== void 0) body.render_js = options.renderJs;
+    if (options.engine !== void 0) body.engine = options.engine;
+    if (options.waitFor !== void 0) body.wait_for = options.waitFor;
+    if (options.waitTimeout !== void 0) body.wait_timeout = options.waitTimeout;
+    if (options.waitAfterLoad !== void 0) body.wait_after_load = options.waitAfterLoad;
+    if (options.jsScenario !== void 0) body.js_scenario = options.jsScenario;
+    if (options.sessionId !== void 0) body.session_id = options.sessionId;
+    if (options.retryCount !== void 0) body.retry_count = options.retryCount;
+    if (options.retryOnBlock !== void 0) body.retry_on_block = options.retryOnBlock;
+    if (options.country !== void 0) body.country = options.country;
+    if (options.customHeaders !== void 0) body.custom_headers = options.customHeaders;
+    if (options.screenshot !== void 0) body.screenshot = options.screenshot;
+    if (options.video !== void 0) body.video = options.video;
+    if (options.antiBot !== void 0) body.anti_bot = options.antiBot;
+    if (options.escalate !== void 0) body.escalate = options.escalate;
     if (options.maxCost !== void 0) body.max_cost = options.maxCost;
-    if (options.headers) body.headers = options.headers;
-    if (options.waitFor) body.wait_for = options.waitFor;
-    if (options.timeout !== void 0) body.timeout = options.timeout;
-    if (options.jsScenario) body.js_scenario = options.jsScenario;
+    if (options.aiExtract !== void 0) body.ai_extract = options.aiExtract;
+    if (options.aiPrompt !== void 0) body.ai_prompt = options.aiPrompt;
+    if (options.rawContent !== void 0) body.raw_content = options.rawContent;
+    if (options.skipBotDetection !== void 0) body.skip_bot_detection = options.skipBotDetection;
     return this.client.request("/v1/web/scrape", {
       method: "POST",
       body
     });
   }
   /**
-   * 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
    */
-  async screenshot(url, options = {}) {
-    const body = { url };
-    if (options.fullPage) body.full_page = true;
-    if (options.viewportWidth && options.viewportWidth !== 1280)
-      body.viewport_width = options.viewportWidth;
-    if (options.viewportHeight && options.viewportHeight !== 720)
-      body.viewport_height = options.viewportHeight;
-    if (options.imageFormat && options.imageFormat !== "png")
-      body.image_format = options.imageFormat;
-    if (options.waitFor) body.wait_for = options.waitFor;
-    if (options.timeout !== void 0) body.timeout = options.timeout;
-    return this.client.request("/v1/web/screenshot", {
-      method: "POST",
-      body
+  async extract(url, prompt, options = {}) {
+    return this.scrape(url, {
+      format: "markdown",
+      ...options,
+      aiExtract: true,
+      aiPrompt: prompt
     });
   }
   /**
-   * Extract structured data from a web page.
+   * 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
    */
-  async extract(url, options = {}) {
+  async detect(url, options = {}) {
     const body = { url };
-    if (options.schema) body.extraction_schema = options.schema;
-    if (options.renderJs) body.render_js = true;
-    if (options.waitFor) body.wait_for = options.waitFor;
     if (options.timeout !== void 0) body.timeout = options.timeout;
-    return this.client.request("/v1/web/extract", {
+    if (options.country !== void 0) body.country = options.country;
+    return this.client.request("/v1/web/detect", {
       method: "POST",
       body
     });
   }
+};
+
+// src/vinted/search.ts
+var SearchClient = class {
+  client;
+  constructor(client) {
+    this.client = client;
+  }
   /**
-   * Scrape multiple URLs in a batch.
+   * 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`);
+   * ```
    */
-  async batch(urls, options = {}) {
-    const body = { urls };
-    if (options.renderJs) body.render_js = true;
-    if (options.outputFormat && options.outputFormat !== "html")
-      body.output_format = options.outputFormat;
-    if (options.maxConcurrency && options.maxConcurrency !== 5)
-      body.max_concurrency = options.maxConcurrency;
-    if (options.engine) body.engine = options.engine;
-    if (options.timeout !== void 0) body.timeout = options.timeout;
-    return this.client.request("/v1/web/batch", {
-      method: "POST",
-      body
+  async search(params) {
+    return this.client.request("/v1/vinted/search", {
+      params: {
+        query: params.query,
+        market: params.market,
+        page: params.page,
+        per_page: params.per_page,
+        price_from: params.price_from,
+        price_to: params.price_to,
+        brand_ids: params.brand_ids,
+        color_ids: params.color_ids,
+        status_ids: params.status_ids,
+        order: params.order
+      }
     });
   }
+};
+
+// src/vinted/items.ts
+var ItemsClient = class {
+  client;
+  constructor(client) {
+    this.client = client;
+  }
   /**
-   * Create a new scraping session for a domain.
+   * 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}`);
+   * ```
    */
-  async createSession(domain, persist = true) {
-    return this.client.request("/v1/web/sessions", {
-      method: "POST",
-      body: {
-        domain,
-        new_session: true,
-        persist_session: persist
+  async get(itemId, options = {}) {
+    return this.client.request(
+      `/v1/vinted/items/${itemId}`,
+      { params: { market: options.market } }
+    );
+  }
+};
+
+// src/vinted/users.ts
+var UsersClient2 = class {
+  client;
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * 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}`);
+   * ```
+   */
+  async getProfile(userId, options = {}) {
+    return this.client.request(
+      `/v1/vinted/users/${userId}`,
+      { params: { market: options.market } }
+    );
+  }
+  /**
+   * 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}`);
+   * }
+   * ```
+   */
+  async getItems(userId, options = {}) {
+    return this.client.request(
+      `/v1/vinted/users/${userId}/items`,
+      {
+        params: {
+          market: options.market,
+          page: options.page,
+          per_page: options.per_page
+        }
+      }
+    );
+  }
+};
+
+// src/vinted/reference.ts
+var ReferenceClient = class {
+  client;
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * 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`);
+   * }
+   * ```
+   */
+  async brands(options = {}) {
+    return this.client.request("/v1/vinted/brands", {
+      params: {
+        keyword: options.keyword,
+        market: options.market,
+        per_page: options.per_page
       }
     });
   }
   /**
-   * Scrape using an existing session.
+   * 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})`);
+   * }
+   * ```
+   */
+  async colors(options = {}) {
+    return this.client.request("/v1/vinted/colors", {
+      params: { market: options.market }
+    });
+  }
+  /**
+   * 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}`);
+   * }
+   * ```
+   */
+  async statuses(options = {}) {
+    return this.client.request("/v1/vinted/statuses", {
+      params: { market: options.market }
+    });
+  }
+  /**
+   * 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})`);
+   * }
+   * ```
+   */
+  async markets() {
+    return this.client.request("/v1/vinted/markets");
+  }
+};
+
+// src/vinted/client.ts
+var VintedClient = class {
+  /** Client for item search operations */
+  search;
+  /** Client for individual item operations */
+  items;
+  /** Client for user operations */
+  users;
+  /** Client for reference data (brands, colors, statuses, markets) */
+  reference;
+  /**
+   * Create a new Vinted client.
+   *
+   * @param client - The base HTTP client for making requests.
+   */
+  constructor(client) {
+    this.search = new SearchClient(client);
+    this.items = new ItemsClient(client);
+    this.users = new UsersClient2(client);
+    this.reference = new ReferenceClient(client);
+  }
+};
+
+// src/google/ai-mode.ts
+var AiModeClient = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async search(params) {
+    return this.client.request("/v1/google/ai-mode/search", {
+      params: { ...params }
+    });
+  }
+};
+
+// src/google/autocomplete.ts
+var AutocompleteClient = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * 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);
+   * }
+   * ```
+   */
+  async get(params) {
+    return this.client.request("/v1/google/autocomplete", {
+      params: { ...params }
+    });
+  }
+};
+
+// src/google/finance.ts
+var FinanceClient = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async quote(params) {
+    return this.client.request("/v1/google/finance/quote", {
+      params: { ...params }
+    });
+  }
+};
+
+// src/google/flights.ts
+var FlightsClient = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /** Search Google Flights for available itineraries. */
+  async search(params) {
+    return this.client.request("/v1/google/flights/search", {
+      params: { ...params }
+    });
+  }
+};
+
+// src/google/hotels.ts
+var HotelsClient = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async search(params) {
+    return this.client.request("/v1/google/hotels/search", {
+      params: { ...params }
+    });
+  }
+  async details(params) {
+    return this.client.request("/v1/google/hotels/details", {
+      params: { ...params }
+    });
+  }
+};
+
+// src/google/images.ts
+var ImagesClient = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async search(params) {
+    return this.client.request("/v1/google/images/search", {
+      params: { ...params }
+    });
+  }
+};
+
+// src/google/jobs.ts
+var JobsClient = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async search(params) {
+    return this.client.request("/v1/google/jobs/search", {
+      params: { ...params }
+    });
+  }
+};
+
+// src/google/lens.ts
+var LensClient = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async search(params) {
+    return this.client.request("/v1/google/lens/search", {
+      params: { ...params }
+    });
+  }
+};
+
+// src/google/maps.ts
+var MapsClient = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * 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.
+   */
+  async search(params) {
+    if (!params.q && !params.place_id && !params.ludocid) {
+      throw new Error("q, place_id, or ludocid is required");
+    }
+    return this.client.request("/v1/google/maps/search", {
+      params: { ...params }
+    });
+  }
+  /**
+   * 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.
+   */
+  async place(params) {
+    if (!params.place_id && !params.data_id) {
+      throw new Error("place_id or data_id is required");
+    }
+    return this.client.request("/v1/google/maps/place", {
+      params: { ...params }
+    });
+  }
+  /**
+   * 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.
+   */
+  async reviews(params) {
+    return this.client.request("/v1/google/maps/reviews", {
+      params: { ...params }
+    });
+  }
+  /**
+   * 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).
+   */
+  async photos(params) {
+    return this.client.request("/v1/google/maps/photos", {
+      params: { ...params }
+    });
+  }
+  /** Get business posts (promotional updates, announcements) for a place. */
+  async posts(params) {
+    if (!params.data_id && !params.place_id) {
+      throw new Error("data_id or place_id is required");
+    }
+    return this.client.request("/v1/google/maps/posts", {
+      params: { ...params }
+    });
+  }
+};
+
+// src/google/news.ts
+var NewsClient = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * 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`.
+   */
+  async search(params = {}) {
+    if (!params.q && !params.topic_token && !params.publication_token && !params.story_token) {
+      throw new Error("Provide q, topic_token, publication_token, or story_token");
+    }
+    return this.client.request("/v1/google/news/search", {
+      params: { ...params }
+    });
+  }
+  async topics(params) {
+    return this.client.request("/v1/google/news/topics", {
+      params: { ...params }
+    });
+  }
+  async trending(params = {}) {
+    return this.client.request("/v1/google/news/trending", {
+      params: { ...params }
+    });
+  }
+};
+
+// src/google/patents.ts
+var PatentsClient = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async search(params) {
+    return this.client.request("/v1/google/patents/search", {
+      params: { ...params }
+    });
+  }
+  /**
+   * 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.
    */
-  async reuseSession(url, sessionId, options = {}) {
-    return this.scrape(url, { ...options, sessionId });
+  async detail(params) {
+    return this.client.request("/v1/google/patents/detail", {
+      params: { ...params }
+    });
+  }
+};
+
+// src/google/products.ts
+var ProductsClient = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async detail(params) {
+    return this.client.request("/v1/google/products/detail", {
+      params: { ...params }
+    });
+  }
+};
+
+// src/google/scholar.ts
+var ScholarClient = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * 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.
+   */
+  async search(params) {
+    return this.client.request("/v1/google/scholar/search", {
+      params: { ...params }
+    });
+  }
+  /** Search Google Scholar for author profiles by name. */
+  async profiles(params) {
+    return this.client.request("/v1/google/scholar/profiles", {
+      params: { ...params }
+    });
+  }
+  /**
+   * Full Scholar author profile: structured `interests_detailed`,
+   * publications (with per-article `citation_id` + nested
+   * `cited_by{value, link, citation_id}`), stats, and co-authors.
+   */
+  async author(params) {
+    return this.client.request("/v1/google/scholar/author", {
+      params: { ...params }
+    });
+  }
+  /** Citations-per-year chart for a Scholar author. */
+  async authorCitation(params) {
+    return this.client.request("/v1/google/scholar/author/citation", {
+      params: { ...params }
+    });
+  }
+  /**
+   * MLA / APA / Chicago / Harvard / Vancouver citation formats plus
+   * BibTeX / RIS / EndNote / RefWorks export links for a paper.
+   */
+  async cite(params) {
+    return this.client.request("/v1/google/scholar/cite", {
+      params: { ...params }
+    });
+  }
+};
+
+// src/google/search.ts
+var SearchClient2 = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * Search Google and get a structured SERP response with organic results,
+   * knowledge graph, People Also Ask, related searches, AI overview, and
+   * pagination.
+   */
+  async search(params) {
+    return this.client.request("/v1/google/search", { params: { ...params } });
+  }
+  /**
+   * 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" });
+   * ```
+   */
+  async light(params) {
+    return this.client.request("/v1/google/search", {
+      params: { ...params, mode: "fast" }
+    });
+  }
+};
+
+// src/google/shopping.ts
+var ShoppingClient = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /** Search Google Shopping for products. */
+  async search(params) {
+    return this.client.request("/v1/google/shopping/search", {
+      params: { ...params }
+    });
+  }
+  /** Fetch the Google Shopping product detail page by `product_id`. */
+  async product(params) {
+    return this.client.request("/v1/google/shopping/product", {
+      params: { ...params }
+    });
+  }
+  /**
+   * 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.
+   */
+  async click(params) {
+    return this.client.request("/v1/google/shopping/product/click", {
+      params: { ...params }
+    });
+  }
+};
+
+// src/google/shorts.ts
+var ShortsClient = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async search(params) {
+    return this.client.request("/v1/google/shorts/search", {
+      params: { ...params }
+    });
+  }
+};
+
+// src/google/trends.ts
+var TrendsClient2 = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async interest(params) {
+    return this.client.request("/v1/google/trends/interest", {
+      params: { ...params }
+    });
+  }
+  async regions(params) {
+    return this.client.request("/v1/google/trends/regions", {
+      params: { ...params }
+    });
+  }
+  async related(params) {
+    return this.client.request("/v1/google/trends/related", {
+      params: { ...params }
+    });
+  }
+  async trending(params = {}) {
+    return this.client.request("/v1/google/trends/trending", {
+      params: { ...params }
+    });
+  }
+  /**
+   * Current trending searches with the full Google Trends UI filter set
+   * — `geo`, `hours`, `category`, `status`, `sort`, `hl`.
+   */
+  async trendingNow(params = {}) {
+    return this.client.request("/v1/google/trends/trending-now", {
+      params: { ...params }
+    });
+  }
+  /**
+   * Unified Google Trends query — pick the response shape via
+   * `data_type` (TIMESERIES | GEO_MAP | GEO_MAP_0 | RELATED_TOPICS |
+   * RELATED_QUERIES).
+   */
+  async search(params) {
+    return this.client.request("/v1/google/trends/search", {
+      params: { ...params }
+    });
+  }
+  /**
+   * Return categorized Knowledge Graph topic entities (`mid`, `type`,
+   * direct link into Trends explore) for a query prefix. Distinct from
+   * Google Search autocomplete.
+   */
+  async autocomplete(params) {
+    return this.client.request("/v1/google/trends/autocomplete", {
+      params: { ...params }
+    });
+  }
+};
+
+// src/google/videos.ts
+var VideosClient = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async search(params) {
+    return this.client.request("/v1/google/videos/search", {
+      params: { ...params }
+    });
+  }
+};
+
+// src/google/client.ts
+var GoogleClient = class {
+  /** Google Web Search (SERP) — with optional deferred AI Overview follow-up. */
+  search;
+  /** Google Maps — places, reviews, photos, posts. */
+  maps;
+  /** Google News — articles, topics, trending. */
+  news;
+  /** Google Hotels — search and property details. */
+  hotels;
+  /** Google Trends — interest, regions, related, trending, topic autocomplete. */
+  trends;
+  /** Google Jobs. */
+  jobs;
+  /** Google Shopping — search, details, click enrichment. */
+  shopping;
+  /** Google Patents — search and document details. */
+  patents;
+  /** Google Scholar — search, profiles, author, author citation, cite formats. */
+  scholar;
+  /** Google Autocomplete — search suggestions. */
+  autocomplete;
+  /** Google Images. */
+  images;
+  /** Google Videos. */
+  videos;
+  /** Google Finance — stock and index quotes. */
+  finance;
+  /** Google AI Mode — generative answer responses. */
+  aiMode;
+  /** Google Lens — visual image search. */
+  lens;
+  /** Google Shorts — short-form vertical video results (udm=39). */
+  shorts;
+  /** Google Flights — one-way, round-trip, and multi-city itineraries. */
+  flights;
+  /** Google Products — immersive product detail. */
+  products;
+  constructor(client) {
+    this.search = new SearchClient2(client);
+    this.maps = new MapsClient(client);
+    this.news = new NewsClient(client);
+    this.hotels = new HotelsClient(client);
+    this.trends = new TrendsClient2(client);
+    this.jobs = new JobsClient(client);
+    this.shopping = new ShoppingClient(client);
+    this.patents = new PatentsClient(client);
+    this.scholar = new ScholarClient(client);
+    this.autocomplete = new AutocompleteClient(client);
+    this.images = new ImagesClient(client);
+    this.videos = new VideosClient(client);
+    this.finance = new FinanceClient(client);
+    this.aiMode = new AiModeClient(client);
+    this.lens = new LensClient(client);
+    this.shorts = new ShortsClient(client);
+    this.flights = new FlightsClient(client);
+    this.products = new ProductsClient(client);
+  }
+};
+
+// src/reddit/search.ts
+var SearchClient3 = class {
+  client;
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * 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`);
+   * ```
+   */
+  async posts(options) {
+    return this.client.request("/v1/reddit/search/posts", {
+      params: {
+        query: options.query,
+        subreddit: options.subreddit,
+        sort: options.sort,
+        time: options.time,
+        after: options.after,
+        limit: options.limit
+      }
+    });
+  }
+  /**
+   * 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`);
+   * }
+   * ```
+   */
+  async subreddits(options) {
+    return this.client.request(
+      "/v1/reddit/search/subreddits",
+      {
+        params: {
+          query: options.query,
+          after: options.after,
+          limit: options.limit
+        }
+      }
+    );
+  }
+  /**
+   * 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`);
+   * }
+   * ```
+   */
+  async users(options) {
+    return this.client.request(
+      "/v1/reddit/search/users",
+      {
+        params: {
+          query: options.query,
+          after: options.after,
+          limit: options.limit
+        }
+      }
+    );
+  }
+  /**
+   * 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}`);
+   * }
+   * ```
+   */
+  async domainPosts(options) {
+    return this.client.request(
+      "/v1/reddit/search/domain",
+      {
+        params: {
+          domain: options.domain,
+          sort: options.sort,
+          time: options.time,
+          after: options.after,
+          limit: options.limit
+        }
+      }
+    );
+  }
+};
+
+// src/reddit/posts.ts
+var PostsClient = class {
+  client;
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * 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)`);
+   * }
+   * ```
+   */
+  async trending(options = {}) {
+    return this.client.request("/v1/reddit/posts", {
+      params: {
+        subreddit: options.subreddit,
+        sort: options.sort,
+        time: options.time,
+        after: options.after,
+        limit: options.limit
+      }
+    });
+  }
+  /**
+   * 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}`);
+   * ```
+   */
+  async get(postId, options = {}) {
+    return this.client.request(
+      `/v1/reddit/posts/${postId}`,
+      { params: { subreddit: options.subreddit } }
+    );
+  }
+  /**
+   * 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)}`);
+   * }
+   * ```
+   */
+  async comments(postId, options = {}) {
+    return this.client.request(
+      `/v1/reddit/posts/${postId}/comments`,
+      {
+        params: {
+          subreddit: options.subreddit,
+          sort: options.sort,
+          depth: options.depth,
+          limit: options.limit
+        }
+      }
+    );
+  }
+  /**
+   * 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`);
+   * }
+   * ```
+   */
+  async duplicates(postId, options = {}) {
+    return this.client.request(
+      `/v1/reddit/posts/${postId}/duplicates`,
+      {
+        params: {
+          after: options.after,
+          limit: options.limit
+        }
+      }
+    );
+  }
+};
+
+// src/reddit/subreddits.ts
+var SubredditsClient = class {
+  client;
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * 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}`);
+   * ```
+   */
+  async get(subreddit) {
+    return this.client.request(
+      `/v1/reddit/subreddits/${subreddit}`
+    );
+  }
+  /**
+   * 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`);
+   * }
+   * ```
+   */
+  async posts(subreddit, options = {}) {
+    return this.client.request(
+      `/v1/reddit/subreddits/${subreddit}/posts`,
+      {
+        params: {
+          sort: options.sort,
+          time: options.time,
+          after: options.after,
+          limit: options.limit
+        }
+      }
+    );
+  }
+  /**
+   * 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}`);
+   * }
+   * ```
+   */
+  async rules(subreddit) {
+    return this.client.request(
+      `/v1/reddit/subreddits/${subreddit}/rules`
+    );
+  }
+  /**
+   * 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(", ")}]`);
+   * }
+   * ```
+   */
+  async moderators(subreddit, options = {}) {
+    return this.client.request(
+      `/v1/reddit/subreddits/${subreddit}/moderators`,
+      {
+        params: {
+          after: options.after,
+          limit: options.limit
+        }
+      }
+    );
+  }
+  /**
+   * 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}`);
+   * }
+   * ```
+   */
+  async wikiPages(subreddit) {
+    return this.client.request(
+      `/v1/reddit/subreddits/${subreddit}/wiki`
+    );
+  }
+  /**
+   * 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);
+   * ```
+   */
+  async wikiPage(subreddit, page) {
+    return this.client.request(
+      `/v1/reddit/subreddits/${subreddit}/wiki/${page}`
+    );
+  }
+  /**
+   * 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`);
+   * }
+   * ```
+   */
+  async popular(options = {}) {
+    return this.client.request(
+      "/v1/reddit/subreddits/popular",
+      {
+        params: {
+          after: options.after,
+          limit: options.limit
+        }
+      }
+    );
+  }
+  /**
+   * 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()})`);
+   * }
+   * ```
+   */
+  async newSubreddits(options = {}) {
+    return this.client.request(
+      "/v1/reddit/subreddits/new",
+      {
+        params: {
+          after: options.after,
+          limit: options.limit
+        }
+      }
+    );
+  }
+};
+
+// src/reddit/users.ts
+var UsersClient3 = class {
+  client;
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * 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()}`);
+   * ```
+   */
+  async get(username) {
+    return this.client.request(
+      `/v1/reddit/users/${username}`
+    );
+  }
+  /**
+   * 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)`);
+   * }
+   * ```
+   */
+  async posts(username, options = {}) {
+    return this.client.request(
+      `/v1/reddit/users/${username}/posts`,
+      {
+        params: {
+          sort: options.sort,
+          time: options.time,
+          after: options.after,
+          limit: options.limit
+        }
+      }
+    );
+  }
+  /**
+   * 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)}`);
+   * }
+   * ```
+   */
+  async comments(username, options = {}) {
+    return this.client.request(
+      `/v1/reddit/users/${username}/comments`,
+      {
+        params: {
+          sort: options.sort,
+          time: options.time,
+          after: options.after,
+          limit: options.limit
+        }
+      }
+    );
+  }
+  /**
+   * 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`);
+   * }
+   * ```
+   */
+  async moderated(username) {
+    return this.client.request(
+      `/v1/reddit/users/${username}/moderated`
+    );
+  }
+  /**
+   * 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}` : ""}`);
+   * }
+   * ```
+   */
+  async trophies(username) {
+    return this.client.request(
+      `/v1/reddit/users/${username}/trophies`
+    );
+  }
+};
+
+// src/reddit/client.ts
+var RedditClient = class {
+  /** Client for search operations (posts, subreddits, users, domain posts) */
+  search;
+  /** Client for post operations (trending, details, comments, duplicates) */
+  posts;
+  /** Client for subreddit operations (details, posts, rules, moderators, wiki) */
+  subreddits;
+  /** Client for user operations (profile, posts, comments, moderated, trophies) */
+  users;
+  /**
+   * Create a new Reddit client.
+   *
+   * @param client - The base HTTP client for making requests.
+   */
+  constructor(client) {
+    this.search = new SearchClient3(client);
+    this.posts = new PostsClient(client);
+    this.subreddits = new SubredditsClient(client);
+    this.users = new UsersClient3(client);
   }
 };
 
@@ -2525,6 +3954,12 @@ var ScrapeBadger = class {
   twitter;
   /** Web scraping API client */
   web;
+  /** Vinted scraper API client */
+  vinted;
+  /** Google Scraper API client — 19 Google product APIs */
+  google;
+  /** Reddit scraper API client */
+  reddit;
   /**
    * Create a new ScrapeBadger client.
    *
@@ -2561,9 +3996,12 @@ var ScrapeBadger = class {
     this.baseClient = new BaseClient(resolvedConfig);
     this.twitter = new TwitterClient(this.baseClient);
     this.web = new WebClient(this.baseClient);
+    this.vinted = new VintedClient(this.baseClient);
+    this.google = new GoogleClient(this.baseClient);
+    this.reddit = new RedditClient(this.baseClient);
   }
 };
 
-export { AccountRestrictedError, AuthenticationError, CommunitiesClient, ConflictError, GeoClient, InsufficientCreditsError, ListsClient, NotFoundError, RateLimitError, ScrapeBadger, ScrapeBadgerError, ServerError, SpacesClient, StreamClient, TimeoutError, TrendsClient, TweetsClient, TwitterClient, UsersClient, ValidationError, WebClient, WebSocketStreamError, collectAll, verifyWebhookSignature };
+export { AccountRestrictedError, AuthenticationError, CommunitiesClient, ConflictError, GeoClient, 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, ScholarClient as GoogleScholarClient, SearchClient2 as GoogleSearchClient, ShoppingClient as GoogleShoppingClient, ShortsClient as GoogleShortsClient, TrendsClient2 as GoogleTrendsClient, VideosClient as GoogleVideosClient, InsufficientCreditsError, ListsClient, NotFoundError, RateLimitError, RedditClient, PostsClient as RedditPostsClient, SearchClient3 as RedditSearchClient, SubredditsClient as RedditSubredditsClient, UsersClient3 as RedditUsersClient, ScrapeBadger, ScrapeBadgerError, ServerError, SpacesClient, StreamClient, TimeoutError, TrendsClient, TweetsClient, TwitterClient, UsersClient, ValidationError, VintedClient, ItemsClient as VintedItemsClient, ReferenceClient as VintedReferenceClient, SearchClient as VintedSearchClient, UsersClient2 as VintedUsersClient, WebClient, WebSocketStreamError, collectAll, verifyWebhookSignature };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map