scrapebadger 0.4.0 → 0.8.0

package/dist/index.js

@@ -2192,7 +2192,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)}`)
@@ -2433,94 +2433,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);
   }
 };
 
@@ -2531,6 +3960,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.
    *
@@ -2567,6 +4002,9 @@ 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);
   }
 };
 
@@ -2575,10 +4013,34 @@ exports.AuthenticationError = AuthenticationError;
 exports.CommunitiesClient = CommunitiesClient;
 exports.ConflictError = ConflictError;
 exports.GeoClient = GeoClient;
+exports.GoogleAiModeClient = AiModeClient;
+exports.GoogleAutocompleteClient = AutocompleteClient;
+exports.GoogleClient = GoogleClient;
+exports.GoogleFinanceClient = FinanceClient;
+exports.GoogleFlightsClient = FlightsClient;
+exports.GoogleHotelsClient = HotelsClient;
+exports.GoogleImagesClient = ImagesClient;
+exports.GoogleJobsClient = JobsClient;
+exports.GoogleLensClient = LensClient;
+exports.GoogleMapsClient = MapsClient;
+exports.GoogleNewsClient = NewsClient;
+exports.GooglePatentsClient = PatentsClient;
+exports.GoogleProductsClient = ProductsClient;
+exports.GoogleScholarClient = ScholarClient;
+exports.GoogleSearchClient = SearchClient2;
+exports.GoogleShoppingClient = ShoppingClient;
+exports.GoogleShortsClient = ShortsClient;
+exports.GoogleTrendsClient = TrendsClient2;
+exports.GoogleVideosClient = VideosClient;
 exports.InsufficientCreditsError = InsufficientCreditsError;
 exports.ListsClient = ListsClient;
 exports.NotFoundError = NotFoundError;
 exports.RateLimitError = RateLimitError;
+exports.RedditClient = RedditClient;
+exports.RedditPostsClient = PostsClient;
+exports.RedditSearchClient = SearchClient3;
+exports.RedditSubredditsClient = SubredditsClient;
+exports.RedditUsersClient = UsersClient3;
 exports.ScrapeBadger = ScrapeBadger;
 exports.ScrapeBadgerError = ScrapeBadgerError;
 exports.ServerError = ServerError;
@@ -2590,6 +4052,11 @@ exports.TweetsClient = TweetsClient;
 exports.TwitterClient = TwitterClient;
 exports.UsersClient = UsersClient;
 exports.ValidationError = ValidationError;
+exports.VintedClient = VintedClient;
+exports.VintedItemsClient = ItemsClient;
+exports.VintedReferenceClient = ReferenceClient;
+exports.VintedSearchClient = SearchClient;
+exports.VintedUsersClient = UsersClient2;
 exports.WebClient = WebClient;
 exports.WebSocketStreamError = WebSocketStreamError;
 exports.collectAll = collectAll;