scavio 0.14.0 → 0.15.0

package/dist/index.cjs

@@ -20,17 +20,48 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  AirbnbNamespace: () => AirbnbNamespace,
+  AmazonNamespace: () => AmazonNamespace,
+  AppStoreNamespace: () => AppStoreNamespace,
   BadRequestError: () => BadRequestError,
+  BookingNamespace: () => BookingNamespace,
+  CapterraNamespace: () => CapterraNamespace,
+  CompaniesHouseNamespace: () => CompaniesHouseNamespace,
+  EbayNamespace: () => EbayNamespace,
+  G2Namespace: () => G2Namespace,
+  GlassdoorNamespace: () => GlassdoorNamespace,
+  GoogleAdsNamespace: () => GoogleAdsNamespace,
+  GoogleNamespace: () => GoogleNamespace,
+  GooglePlayNamespace: () => GooglePlayNamespace,
+  HomeDepotNamespace: () => HomeDepotNamespace,
+  IndeedNamespace: () => IndeedNamespace,
+  InstagramNamespace: () => InstagramNamespace,
   InsufficientCreditsError: () => InsufficientCreditsError,
   InvalidAPIKeyError: () => InvalidAPIKeyError,
+  KuaishouNamespace: () => KuaishouNamespace,
+  LinkedInNamespace: () => LinkedInNamespace,
+  MetaAdsNamespace: () => MetaAdsNamespace,
   MissingAPIKeyError: () => MissingAPIKeyError,
   NotFoundError: () => NotFoundError,
   RateLimitError: () => RateLimitError,
+  RedditNamespace: () => RedditNamespace,
+  RedfinNamespace: () => RedfinNamespace,
+  SECNamespace: () => SECNamespace,
   Scavio: () => Scavio,
   ScavioAPIError: () => ScavioAPIError,
   ScavioConnectionError: () => ScavioConnectionError,
   ScavioError: () => ScavioError,
-  ScavioTimeoutError: () => ScavioTimeoutError
+  ScavioTimeoutError: () => ScavioTimeoutError,
+  TargetNamespace: () => TargetNamespace,
+  ThreadsNamespace: () => ThreadsNamespace,
+  TikTokNamespace: () => TikTokNamespace,
+  TikTokShopNamespace: () => TikTokShopNamespace,
+  TripadvisorNamespace: () => TripadvisorNamespace,
+  WalmartNamespace: () => WalmartNamespace,
+  XNamespace: () => XNamespace,
+  YelpNamespace: () => YelpNamespace,
+  YouTubeNamespace: () => YouTubeNamespace,
+  ZillowNamespace: () => ZillowNamespace
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -80,12 +111,13 @@ var InsufficientCreditsError = class extends ScavioError {
   }
 };
 var BadRequestError = class extends ScavioError {
-  statusCode = 400;
+  statusCode;
   responseBody;
-  constructor(message = "Bad request", responseBody) {
+  constructor(message = "Bad request", responseBody, statusCode = 400) {
     super(message);
     this.name = "BadRequestError";
     this.responseBody = responseBody;
+    this.statusCode = statusCode;
   }
 };
 var NotFoundError = class extends ScavioError {
@@ -187,7 +219,9 @@ function handleError(statusCode, body) {
   }
   const msg = String(error);
   const responseBody = Object.keys(body).length > 0 ? body : void 0;
-  if (statusCode === 400) throw new BadRequestError(msg, responseBody);
+  if (statusCode === 400 || statusCode === 422) {
+    throw new BadRequestError(msg, responseBody, statusCode);
+  }
   if (statusCode === 401) throw new InvalidAPIKeyError(msg, responseBody);
   if (statusCode === 402) throw new InsufficientCreditsError(msg, responseBody);
   if (statusCode === 404) throw new NotFoundError(msg, responseBody);
@@ -640,12 +674,71 @@ var WalmartNamespace = class {
     this.client = client;
   }
   client;
+  /**
+   * Structured Walmart search results: `products[]`, `products_count` and the
+   * resolved `location`. Page through with `page` (1-indexed).
+   *
+   * Costs 1 credit for `domain` "com" or "ca", 2 credits for "com.mx".
+   */
   async search(options) {
     return this.client._post("/api/v1/walmart/search", options);
   }
+  /**
+   * Full product detail: price, rating, images, specifications, availability
+   * and seller.
+   *
+   * Costs 1 credit. Walmart.ca product pages are not fetchable, so this is
+   * walmart.com only.
+   */
   async product(options) {
     return this.client._post("/api/v1/walmart/product", options);
   }
+  /**
+   * Customer reviews with ratings, text, author, date and the rating
+   * breakdown. 10 reviews per page; advance with `page`.
+   *
+   * Costs 1 credit.
+   */
+  async reviews(options) {
+    return this.client._post("/api/v1/walmart/reviews", options);
+  }
+  /**
+   * Products within a category, in the same product shape as `search()`.
+   * Page through with `page`; `limit` only trims the response.
+   *
+   * Costs 1 credit for `domain` "com" or "ca", 2 credits for "com.mx".
+   */
+  async category(options) {
+    return this.client._post("/api/v1/walmart/category", options);
+  }
+  /**
+   * Seller offer for a product: price, seller, condition and buy-box flag.
+   * Returns the BUY-BOX SELLER ONLY, not the full offer list.
+   *
+   * Costs 1 credit.
+   */
+  async offers(options) {
+    return this.client._post("/api/v1/walmart/offers", options);
+  }
+  /**
+   * Marketplace seller storefront: name, rating, review count, Pro Seller
+   * badge and business details.
+   *
+   * Costs 1 credit. `seller_id` must be the numeric catalog seller id.
+   */
+  async seller(options) {
+    return this.client._post("/api/v1/walmart/seller", options);
+  }
+  /**
+   * A seller's catalog. Roughly the first 40 items are server-rendered and
+   * that is all this returns - there is no pagination. `total_count` reports
+   * the seller's real catalog size, which is usually far larger.
+   *
+   * Costs 1 credit. `seller_id` must be the numeric catalog seller id.
+   */
+  async sellerProducts(options) {
+    return this.client._post("/api/v1/walmart/seller-products", options);
+  }
 };
 
 // src/namespaces/youtube.ts
@@ -852,74 +945,1497 @@ var LinkedInNamespace = class {
   }
 };
 
-// src/client.ts
-var Scavio = class {
-  google;
-  amazon;
-  walmart;
-  youtube;
-  reddit;
-  tiktok;
-  tiktokShop;
-  instagram;
-  x;
-  linkedin;
-  apiKey;
-  baseUrl;
-  timeout;
-  maxRetries;
-  rateLimiter;
-  constructor(config) {
-    this.apiKey = config?.apiKey ?? process.env.SCAVIO_API_KEY ?? "";
-    if (!this.apiKey) {
-      throw new MissingAPIKeyError();
-    }
-    this.baseUrl = (config?.baseUrl ?? BASE_URL).replace(/\/+$/, "");
-    this.timeout = config?.timeout ?? DEFAULT_TIMEOUT;
-    this.maxRetries = config?.maxRetries ?? DEFAULT_MAX_RETRIES;
-    const rps = config?.maxRequestsPerSecond ?? 1;
-    if (rps < 1 || rps > 10) {
-      throw new ScavioError("maxRequestsPerSecond must be between 1 and 10");
-    }
-    this.rateLimiter = new RateLimiter(rps);
-    this.google = new GoogleNamespace(this);
-    this.amazon = new AmazonNamespace(this);
-    this.walmart = new WalmartNamespace(this);
-    this.youtube = new YouTubeNamespace(this);
-    this.reddit = new RedditNamespace(this);
-    this.tiktok = new TikTokNamespace(this);
-    this.tiktokShop = new TikTokShopNamespace(this);
-    this.instagram = new InstagramNamespace(this);
-    this.x = new XNamespace(this);
-    this.linkedin = new LinkedInNamespace(this);
+// src/namespaces/threads.ts
+var ThreadsNamespace = class {
+  constructor(client) {
+    this.client = client;
   }
-  /** @internal */
-  async _post(path, body) {
-    return request({
-      method: "POST",
-      path,
-      apiKey: this.apiKey,
-      baseUrl: this.baseUrl,
-      timeout: this.timeout,
-      maxRetries: this.maxRetries,
-      rateLimiter: this.rateLimiter,
-      body
-    });
+  client;
+  /**
+   * Profile details for a Threads user. Pass `user_id` or `username`;
+   * sending neither returns 422 and no match returns 404.
+   *
+   * Costs 2 credits by `user_id`, 4 credits by `username`.
+   */
+  async profile(options) {
+    return this.client._post("/api/v1/threads/profile", options);
   }
-  /** @internal */
-  async _get(path) {
-    return request({
-      method: "GET",
-      path,
-      apiKey: this.apiKey,
-      baseUrl: this.baseUrl,
-      timeout: this.timeout,
-      maxRetries: this.maxRetries,
-      rateLimiter: this.rateLimiter
-    });
+  /**
+   * A user's Threads posts. Advance with the previous response's
+   * `next_cursor`. Pass `user_id` or `username`.
+   *
+   * Costs 2 credits by `user_id`, 4 credits by `username` - and that surcharge
+   * applies to every page, so resolve the id once before paging.
+   */
+  async userPosts(options) {
+    return this.client._post("/api/v1/threads/user/posts", options);
+  }
+  /**
+   * A user's replies. Advance with the previous response's `next_cursor`.
+   * Pass `user_id` or `username`.
+   *
+   * Costs 2 credits by `user_id`, 4 credits by `username` - and that surcharge
+   * applies to every page, so resolve the id once before paging.
+   */
+  async userReplies(options) {
+    return this.client._post("/api/v1/threads/user/replies", options);
+  }
+  /**
+   * A single post, addressed by `post_id` or by its threads.net `url`.
+   * Sending neither returns 422.
+   *
+   * Costs 2 credits.
+   */
+  async post(options) {
+    return this.client._post("/api/v1/threads/post", options);
+  }
+  /**
+   * Replies to a post. Advance with the previous response's `next_cursor`.
+   *
+   * Costs 2 credits - this endpoint is never username-keyed, so there is no
+   * handle surcharge.
+   */
+  async postComments(options) {
+    return this.client._post("/api/v1/threads/post/comments", options);
+  }
+  /**
+   * Threads profiles matching a name or handle. This is people search, and it
+   * is the only search Threads exposes - there is no content/post search.
+   * Use it to turn a handle into the `user_id` every other method prefers.
+   *
+   * Costs 2 credits. Single response, no pagination.
+   */
+  async searchUsers(options) {
+    return this.client._post("/api/v1/threads/search/users", options);
+  }
+};
+
+// src/namespaces/kuaishou.ts
+var KuaishouNamespace = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  /**
+   * Profile details for a Kuaishou user, addressed by numeric `user_id`.
+   *
+   * Costs 10 credits - the dearest single-object call on the platform. If you
+   * only have a share link, resolve it with `userResolve()` (1 credit) first.
+   */
+  async profile(options) {
+    return this.client._post("/api/v1/kuaishou/profile", options);
+  }
+  /**
+   * A user's top posts. Advance with the previous response's `next_cursor`.
+   *
+   * Costs 1 credit per page.
+   */
+  async userPosts(options) {
+    return this.client._post("/api/v1/kuaishou/user/posts", options);
+  }
+  /**
+   * A user's current live-stream status.
+   *
+   * Costs 1 credit.
+   */
+  async userLive(options) {
+    return this.client._post("/api/v1/kuaishou/user/live", options);
+  }
+  /**
+   * Turns a Kuaishou share link into a `user_id` you can feed to the other
+   * user endpoints. kuaishou.com and v.kuaishou.com links only - kwai.com is
+   * not supported.
+   *
+   * Costs 1 credit.
+   */
+  async userResolve(options) {
+    return this.client._post("/api/v1/kuaishou/user/resolve", options);
+  }
+  /**
+   * A single video, addressed by `photo_id` or by its Kuaishou `url`.
+   * Sending neither returns 422.
+   *
+   * Costs 2 credits.
+   */
+  async video(options) {
+    return this.client._post("/api/v1/kuaishou/video", options);
+  }
+  /**
+   * Comments on a video. Advance with the previous response's `next_cursor`.
+   *
+   * Costs 1 credit per page.
+   */
+  async videoComments(options) {
+    return this.client._post("/api/v1/kuaishou/video/comments", options);
+  }
+  /**
+   * Replies under a root comment. Advance with the previous response's
+   * `next_cursor`; `count` (1-50) sizes the page.
+   *
+   * Costs 1 credit per page.
+   */
+  async commentReplies(options) {
+    return this.client._post("/api/v1/kuaishou/video/sub-comments", options);
+  }
+  /**
+   * Several videos in one call, up to 20 photo ids (a hard cap - a longer
+   * `photo_ids` array is rejected).
+   *
+   * Costs 40 credits per call, flat, whether you send 1 id or 20 - so batch
+   * to the cap. For a single video `video()` costs 2.
+   */
+  async videosBatch(options) {
+    return this.client._post("/api/v1/kuaishou/videos/batch", options);
   }
+  /**
+   * Mixed-result search across Kuaishou. Advance with the previous response's
+   * `next_cursor`.
+   *
+   * Costs 10 credits per page.
+   */
   async search(options) {
-    return this.google.search(options);
+    return this.client._post("/api/v1/kuaishou/search", options);
+  }
+  /**
+   * Video search results. Advance with the previous response's `next_cursor`.
+   *
+   * Costs 10 credits per page.
+   */
+  async searchVideos(options) {
+    return this.client._post("/api/v1/kuaishou/search/videos", options);
+  }
+  /**
+   * User search results. Advance with the previous response's `next_cursor`.
+   *
+   * Costs 10 credits per page.
+   */
+  async searchUsers(options) {
+    return this.client._post("/api/v1/kuaishou/search/users", options);
+  }
+  /**
+   * Live-stream search results. Advance with the previous response's
+   * `next_cursor`.
+   *
+   * Costs 10 credits per page.
+   */
+  async searchLive(options) {
+    return this.client._post("/api/v1/kuaishou/search/live", options);
+  }
+  /**
+   * Posts under a hashtag. Advance with the previous response's `next_cursor`.
+   *
+   * Costs 1 credit per page - the cheap way to pull volume, versus 10 for
+   * `search()`.
+   */
+  async tagFeed(options) {
+    return this.client._post("/api/v1/kuaishou/tag/feed", options);
+  }
+  /**
+   * Leaderboards: hot, live, shopping, brand or music. Defaults to "hot".
+   *
+   * Costs 1 credit.
+   */
+  async trending(options = {}) {
+    return this.client._post("/api/v1/kuaishou/trending", options);
+  }
+};
+
+// src/namespaces/ebay.ts
+var EbayNamespace = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  /**
+   * Structured eBay listing results: price, condition, bids, shipping, seller,
+   * feedback, plus `count` and `total_results`.
+   *
+   * Either `query` or `seller` is required. Set `sold: true` to search
+   * completed listings that actually sold - on that view `total_results` is
+   * always null because eBay publishes no headline count for it.
+   *
+   * Paged with `page`; `per_page` accepts only 60, 120 or 240 and silently
+   * falls back to 60 for any other value.
+   *
+   * Costs 1 credit.
+   */
+  async search(options) {
+    return this.client._post("/api/v1/ebay/search", options);
+  }
+  /**
+   * One eBay listing in full: price, condition, images, item specifics,
+   * shipping, returns, auction state and seller.
+   *
+   * Costs 1 credit. Single response, no pagination.
+   */
+  async product(options) {
+    return this.client._post("/api/v1/ebay/product", options);
+  }
+  /**
+   * A seller's profile card: store name, feedback score and percentage, items
+   * sold, followers, location and categories.
+   *
+   * PROFILE ONLY - it cannot list what the seller is selling. For inventory,
+   * call search({ seller }) with no query and page through it.
+   *
+   * Costs 1 credit. Single response, no pagination.
+   */
+  async seller(options) {
+    return this.client._post("/api/v1/ebay/seller", options);
+  }
+};
+
+// src/namespaces/target.ts
+var TargetNamespace = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  /**
+   * Search Target.com: prices, ratings, badges and promotions.
+   *
+   * Paged with `page` + `count` (1-28, default 24). `seller_id` and
+   * `seller_name` are null on first-party rows, which means "sold by Target".
+   *
+   * Costs 1 credit. Typically ~9s - it runs through a headless browser.
+   */
+  async search(options) {
+    return this.client._post("/api/v1/target/search", options);
+  }
+  /**
+   * Products in a Target category: the same shape as search() plus the
+   * category breadcrumb.
+   *
+   * Paged with `page` + `count` (1-28, default 24).
+   *
+   * Costs 1 credit. The slowest endpoint here at ~37s - set a generous client
+   * timeout before calling it.
+   */
+  async category(options) {
+    return this.client._post("/api/v1/target/category", options);
+  }
+  /**
+   * Target product details by TCIN: price, rating, images, specifications,
+   * variants, return policy and fulfillment.
+   *
+   * `store_id` is a real request param here - the price and availability you
+   * get back are the store you asked for.
+   *
+   * Costs 1 credit. Typically ~4s. Single response, no pagination.
+   */
+  async product(options) {
+    return this.client._post("/api/v1/target/product", options);
+  }
+  /**
+   * Target reviews with the rating breakdown, per-attribute averages and
+   * guest photos.
+   *
+   * Returns 8 review BODIES MAXIMUM regardless of the product's review_count.
+   * `limit` only trims that set; there is no page or offset param, so the
+   * aggregate distribution is the full-population signal here, not the bodies.
+   *
+   * Costs 1 credit. Typically ~40s.
+   */
+  async reviews(options) {
+    return this.client._post("/api/v1/target/reviews", options);
+  }
+};
+
+// src/namespaces/home-depot.ts
+var HomeDepotNamespace = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  /**
+   * Search Home Depot: price and promotions, brand and model, ratings,
+   * badges, and per-store pickup/delivery.
+   *
+   * Page size is FIXED at 12 products and cannot be raised - page through
+   * with `page` to read further.
+   *
+   * Costs 2 credits.
+   */
+  async search(options) {
+    return this.client._post("/api/v1/homedepot/search", options);
+  }
+  /**
+   * Full item detail: pricing and promotions, images and videos, the spec
+   * table, dimensions, bullets, documents and return policy.
+   *
+   * Carries only a 10-review PREVIEW - reviews() is the paginated surface.
+   * An unknown item id comes back as 404.
+   *
+   * Costs 2 credits. Single response, no pagination.
+   */
+  async product(options) {
+    return this.client._post("/api/v1/homedepot/product", options);
+  }
+  /**
+   * One page of full review bodies with the rating distribution,
+   * per-attribute ratings, photos and seller responses.
+   *
+   * 30 reviews per page. `total_pages` is the last page that exists; a page
+   * beyond it is a 404, not an empty result.
+   *
+   * Costs 2 credits.
+   */
+  async reviews(options) {
+    return this.client._post("/api/v1/homedepot/reviews", options);
+  }
+};
+
+// src/namespaces/zillow.ts
+var ZillowNamespace = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  /**
+   * Listings in a region: price, beds, baths, living area, Zestimate,
+   * coordinates, images and days on market.
+   *
+   * Paged with `page`. A bare ZIP works alone but not alongside a filter or a
+   * sort - use the city name when filtering. On listing_status "for_rent",
+   * min_price / max_price are MONTHLY RENT. A region Zillow cannot resolve is
+   * a 404, not an empty list.
+   *
+   * Costs 1 credit.
+   */
+  async search(options) {
+    return this.client._post("/api/v1/zillow/search", options);
+  }
+  /**
+   * Full listing detail: price and price history, Zestimate, tax history,
+   * description, RESO facts, rooms, schools, open houses, photos and
+   * attribution. Rental buildings return floor plans, amenities and unit
+   * counts instead.
+   *
+   * Costs 1 credit. Single response, no pagination.
+   */
+  async property(options) {
+    return this.client._post("/api/v1/zillow/property", options);
+  }
+  /**
+   * An AGENT's profile and reviews: rating, review count, bodies with
+   * sub-ratings, specialties, languages, licenses, service areas and sales
+   * counts.
+   *
+   * This addresses an agent by screen name, NOT a property. Zillow
+   * server-renders the first five reviews only: `count` is what came back,
+   * `total_review_count` is what the agent actually has, and there is no way
+   * to page to the rest.
+   *
+   * Costs 1 credit.
+   */
+  async agentReviews(options) {
+    return this.client._post("/api/v1/zillow/reviews", options);
+  }
+};
+
+// src/namespaces/redfin.ts
+var RedfinNamespace = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  /**
+   * Redfin listings: price, price per sqft, beds, baths, living area, lot
+   * size, year built, coordinates, listing remarks and full photo galleries.
+   *
+   * Pass `location` (a redfin.com region URL or a bare ZIP - city NAMES are
+   * not accepted) or `region_id` AND `region_type` together. Paged with
+   * `page` + `limit`, up to 350 listings per page.
+   *
+   * `days_on_market` comes back NULL on every row: Redfin's mainHouseInfo has
+   * no `dom` key. Fractional numeric filters are rejected, not rounded.
+   * `sold_within_days` requires `listing_status: "sold"`, and
+   * `max_days_on_market` / `min_days_on_market` cannot be combined.
+   *
+   * Costs 1 credit.
+   */
+  async search(options) {
+    return this.client._post("/api/v1/redfin/search", options);
+  }
+  /**
+   * One Redfin listing in full: price, Redfin Estimate and rental estimate,
+   * complete MLS fact sheet, price and tax history, listing agents, open
+   * houses, schools, climate risk, walkability and location scores, sun
+   * exposure, monthly weather, permits, zoning, comparable sales and photos.
+   *
+   * Reads the property PAGE, whose inlined request cache replaces the ~40
+   * upstream calls that page made - which is why it is the same price as
+   * search().
+   *
+   * Costs 1 credit. Single response, no pagination.
+   */
+  async property(options) {
+    return this.client._post("/api/v1/redfin/property", options);
+  }
+  /**
+   * Housing-market stats for a region: median list and sale price, price per
+   * sqft, sale-to-list ratio, average offers and days on market, YoY
+   * movement, Redfin's 0-100 compete score, live inventory by property type,
+   * median price and active listings per bedroom count, plus Redfin agent
+   * presence and aggregate rating.
+   *
+   * Pass `location` (city NAMES are not accepted) or `region_id` AND
+   * `region_type` together.
+   *
+   * Costs 1 credit. Single response, no pagination.
+   */
+  async market(options) {
+    return this.client._post("/api/v1/redfin/market", options);
+  }
+};
+
+// src/namespaces/booking.ts
+var BookingNamespace = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  /**
+   * Search Booking.com properties for a destination and stay: live nightly
+   * price, review score, star rating, location, room type and deal badges.
+   *
+   * Either `destination` or `dest_id` is required - without one the request
+   * would land on Booking's homepage, so it is rejected instead of billed.
+   * `dest_type` requires `dest_id`.
+   *
+   * Paged with `page`, 25 properties per page. `checkin` and `checkout` must
+   * be sent together or Booking prices a range of its own choosing.
+   *
+   * Each row carries a `url` - chain it into hotel() rather than rebuilding a
+   * slug, which risks a BILLED 404 on the wrong `country_code`.
+   *
+   * Costs 1 credit.
+   */
+  async search(options) {
+    return this.client._post("/api/v1/booking/search", options);
+  }
+  /**
+   * One Booking.com property in full: rooms and rate plans, facilities, house
+   * rules, check-in windows, policies, images, location and review scores -
+   * priced for the stay you ask for.
+   *
+   * Takes dates because Booking prices a STAY. Omit them and the response
+   * carries prices for a two-night window Booking picked; the response echoes
+   * whichever dates were used.
+   *
+   * Single response, no pagination.
+   *
+   * Costs 1 credit.
+   */
+  async hotel(options) {
+    return this.client._post("/api/v1/booking/hotel", options);
+  }
+  /**
+   * Booking.com guest reviews with the score breakdown by category and
+   * Booking's own praise/complaint summary.
+   *
+   * NO PAGE PARAM - do not invent one. `total_count` is the property's whole
+   * review history; `count` is what this response holds.
+   *
+   * Costs 1 credit.
+   */
+  async reviews(options) {
+    return this.client._post("/api/v1/booking/reviews", options);
+  }
+};
+
+// src/namespaces/airbnb.ts
+var AirbnbNamespace = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  /**
+   * Search Airbnb stays: stay-total and per-night price with the full
+   * discount ledger, rating and review count, bedrooms/beds/baths,
+   * coordinates, badges, images and `dates_are_defaulted`.
+   *
+   * This is the ONLY endpoint that carries a price - listing() has no nightly
+   * rate field at all.
+   *
+   * Paged with `page` (18 listings per page) XOR `cursor`; `cursor` wins, so
+   * sending both is rejected. `min_price` / `max_price` are WHOLE-STAY totals,
+   * not per night.
+   *
+   * Pass `check_in` + `check_out` together whenever price matters: a dateless
+   * search defaults to +30 days / 5 nights and A/Bs both the window and the
+   * prices, which the response flags as `dates_are_defaulted`.
+   *
+   * Costs 1 credit.
+   */
+  async search(options) {
+    return this.client._post("/api/v1/airbnb/search", options);
+  }
+  /**
+   * One Airbnb listing in full: description, property and room type, capacity
+   * and room counts, the complete grouped amenity list (including the
+   * amenities the place does NOT have), host profile and stats, house rules
+   * with parsed check-in/out times, cancellation policy, sleeping
+   * arrangements, photo tour, every image, and the RATING BREAKDOWN - six
+   * category ratings, the five-bucket star distribution and Airbnb's
+   * AI-synthesised review tags.
+   *
+   * NO NIGHTLY PRICE. The room page carries no rate under any parameters,
+   * with or without dates. Prices come from search() only.
+   *
+   * Single response, no pagination.
+   *
+   * Costs 1 credit.
+   */
+  async listing(options) {
+    return this.client._post("/api/v1/airbnb/listing", options);
+  }
+  /**
+   * Airbnb review BODIES with per-review rating, date, and reviewer name,
+   * photo and location.
+   *
+   * Paged with `limit` (1-50, default 30) + `offset`. Send `limit`
+   * explicitly - upstream returns a fixed 7 rows when none is given.
+   *
+   * `count` is the listing's TOTAL review count; `returned` is how many rows
+   * this page holds. The rating breakdown is NOT here - it lives on
+   * listing().
+   *
+   * Costs 1 credit.
+   */
+  async reviews(options) {
+    return this.client._post("/api/v1/airbnb/reviews", options);
+  }
+};
+
+// src/namespaces/tripadvisor.ts
+var TripadvisorNamespace = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  /**
+   * START HERE. Resolve a place or business NAME to the Tripadvisor
+   * geo_id / location_id pairs every other endpoint needs.
+   *
+   * A GEO row answers `geo_id` for search(); a business row answers the
+   * `geo_id` + `location_id` pair location() and reviews() take. Those ids
+   * exist only inside Tripadvisor's own URLs, so this is the only entry point
+   * from a name.
+   *
+   * `limit` (1-20, default 12) sizes the response; there is no pagination.
+   *
+   * Costs 2 credits.
+   */
+  async locations(options) {
+    return this.client._post("/api/v1/tripadvisor/locations", options);
+  }
+  /**
+   * Restaurants, hotels or attractions in a Tripadvisor geo, Tripadvisor-
+   * ranked: rating, review count, price band, address, coordinates, phone,
+   * hours and Travelers' Choice badge. Each row carries the location_id +
+   * geo_id pair the detail endpoints take.
+   *
+   * `geo_id` or `url` is required - get `geo_id` from locations().
+   *
+   * Paged with `page`, 30 locations per page. A page beyond the last is a
+   * 404, not an empty result.
+   *
+   * Costs 2 credits.
+   */
+  async search(options) {
+    return this.client._post("/api/v1/tripadvisor/search", options);
+  }
+  /**
+   * One Tripadvisor location in full: rating, review histogram and per-aspect
+   * sub-ratings, city ranking, price band, cuisines, amenities, address,
+   * coordinates, contact, photos, and the FIRST PAGE OF REVIEWS.
+   *
+   * `location_id` or `url` is required, and the transport additionally
+   * requires a geo when a bare d-id is sent.
+   *
+   * Page 1 of the reviews is already here - call reviews() only to page PAST
+   * it. An unknown location id is a 404 (upstream answers a billed city
+   * listing that the transport restates).
+   *
+   * Costs 2 credits.
+   */
+  async location(options) {
+    return this.client._post("/api/v1/tripadvisor/location", options);
+  }
+  /**
+   * A page of Tripadvisor reviews: rating, trip date and type, reviewer home
+   * town and contribution count, and any management response.
+   *
+   * `location_id` or `url` is required. Page size follows `category` - 15 per
+   * page for restaurants, 10 for hotels and attractions - so keep it matched
+   * to the location's own type on any page past the first.
+   *
+   * Consecutive pages can REPEAT one review at the boundary; de-duplicate on
+   * review_id when concatenating.
+   *
+   * Costs 2 credits.
+   */
+  async reviews(options) {
+    return this.client._post("/api/v1/tripadvisor/reviews", options);
+  }
+};
+
+// src/namespaces/yelp.ts
+var YelpNamespace = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  /**
+   * Businesses in Yelp's ranked order: rating, review count, price band,
+   * categories, address, contact rails, hours, photos and a review snippet.
+   * Each row carries both business_id and alias, either of which addresses
+   * business(). `count` is the 10-row page, `total_results` is Yelp's headline
+   * count.
+   *
+   * `term` + `location` or `url` is required, and `location` is effectively
+   * mandatory - Yelp geolocates a location-less search off the proxy exit.
+   * Paged with `page`; the page size is fixed at 10.
+   *
+   * Costs 2 credits.
+   */
+  async search(options) {
+    return this.client._post("/api/v1/yelp/search", options);
+  }
+  /**
+   * One business in full: rating and per-star histogram, review count, price
+   * band, categories, address and coordinates, phone, website and menu links,
+   * hours and holidays, amenities, photos and videos, popular items, health
+   * inspections, Q&A, licences and claim status - PLUS the first page of
+   * reviews at no extra cost.
+   *
+   * Because those reviews ride along, calling reviews({ page: 1 }) after this
+   * buys the same document twice. Yelp's recommendation software hides some
+   * reviews entirely; those are never returned and are counted in
+   * not_recommended_review_count here. popular_items rows can arrive as stub
+   * shells with every field null but `identifier` - those are dropped and
+   * popular_items_omitted flags it.
+   *
+   * `business_id` or `url` is required. Costs 2 credits. Single response, no
+   * pagination.
+   */
+  async business(options) {
+    return this.client._post("/api/v1/yelp/business", options);
+  }
+  /**
+   * A page of reviews: rating, full text, language, author profile and
+   * expertise counts, attached photos, reaction counts and owner response.
+   *
+   * START AT PAGE 2 - page 1 re-fetches the document business() already
+   * returned and costs another 2 credits. 10 reviews per page, and a page past
+   * the last review is a 404, not an empty result. `rating` changes
+   * filtered_review_count, not review_count.
+   *
+   * `business_id` or `url` is required. Costs 2 credits.
+   */
+  async reviews(options) {
+    return this.client._post("/api/v1/yelp/reviews", options);
+  }
+};
+
+// src/namespaces/indeed.ts
+var IndeedNamespace = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  /**
+   * Search Indeed job postings: title, employer, rating, location, salary
+   * range, job type, benefits, posting age and apply route.
+   *
+   * Either `query` or `location` is required; a location-only search is valid
+   * and returns every posting in the metro.
+   *
+   * Paged with `page`, 10 postings per page. `radius` and `max_age_days` are
+   * closed sets - Indeed silently ignores an off-list value and bills the
+   * unfiltered search. `min_salary` filters on Indeed's own ESTIMATE for the
+   * role, not a posted figure.
+   *
+   * Costs 2 credits.
+   */
+  async search(options) {
+    return this.client._post("/api/v1/indeed/search", options);
+  }
+  /**
+   * One Indeed posting in full: description text and HTML, structured salary,
+   * employment types, benefits, geocoded address, employer rating, applicant
+   * count and the original ATS link.
+   *
+   * Single response, no pagination. An unknown job key is a real 404 that
+   * scrape.do BILLS - take `job_id` from a search row.
+   *
+   * Costs 2 credits.
+   */
+  async job(options) {
+    return this.client._post("/api/v1/indeed/job", options);
+  }
+  /**
+   * Indeed employer profile: description, industry, HQ, size, revenue, CEO
+   * approval, overall and per-category ratings, reported salaries, open roles
+   * and locations.
+   *
+   * Single response, no pagination. An unknown company slug is a real 404
+   * that scrape.do BILLS.
+   *
+   * Costs 2 credits.
+   */
+  async company(options) {
+    return this.client._post("/api/v1/indeed/company", options);
+  }
+  /**
+   * Indeed employee reviews with per-category ratings, pros/cons, reviewer
+   * job title and location, plus aggregated sentiment and topic / location /
+   * job-title breakdowns.
+   *
+   * Paged with `page`, 20 reviews per page.
+   *
+   * Costs 2 credits.
+   */
+  async companyReviews(options) {
+    return this.client._post("/api/v1/indeed/company/reviews", options);
+  }
+};
+
+// src/namespaces/glassdoor.ts
+var GlassdoorNamespace = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  /**
+   * START HERE. Search Glassdoor for a company by NAME and resolve it to the
+   * employer_id every other method needs, ranked by Glassdoor and
+   * de-duplicated.
+   *
+   * company(), reviews() and salaries() all key off an employer_id that exists
+   * only inside Glassdoor's /Overview/ URLs, so this lookup is the entry
+   * point.
+   *
+   * Costs 1 credit. Single response, no pagination.
+   */
+  async companies(options) {
+    return this.client._post("/api/v1/glassdoor/companies", options);
+  }
+  /**
+   * Employer profile: description, mission, industry, sector, HQ, size band,
+   * revenue band, stock symbol, year founded, overall and per-category
+   * ratings, star distribution, CEO approval, awards, FAQ, the five
+   * server-rendered reviews, AND reviews_url / salaries_url.
+   *
+   * THE CHAINING ENDPOINT: pass reviews_url / salaries_url back as `url` on
+   * reviews() and salaries() to halve the upstream fetches. `employer_id` or
+   * `url` is required - `company` is cosmetic and does not satisfy it.
+   *
+   * Costs 1 credit. Single response, no pagination. Typically ~3-47s.
+   */
+  async company(options) {
+    return this.client._post("/api/v1/glassdoor/company", options);
+  }
+  /**
+   * Full reviews with per-axis scores, pros, cons, advice, job title,
+   * location, employment status and employer response - plus complete rating
+   * statistics, star distribution, aggregate pro/con highlight terms and
+   * per-job-title review counts.
+   *
+   * HARD CAP OF THREE REVIEW BODIES per response: that is Glassdoor's login
+   * wall, not a limit option. There is deliberately NO `page` param. Move the
+   * window with `category` and `employment_status` and read
+   * filtered_review_count to see how many match; the aggregate statistics are
+   * the full-population signal here, not the bodies.
+   *
+   * `employer_id` or `url` is required. Costs 1 credit. Typically ~75s.
+   */
+  async reviews(options) {
+    return this.client._post("/api/v1/glassdoor/reviews", options);
+  }
+  /**
+   * Salaries by job title: base-pay and total-pay percentiles P10-P90 with
+   * medians called out, sample counts, currency, pay period and last-reported
+   * date.
+   *
+   * These are Glassdoor's ESTIMATES for the title, not individual reported
+   * salaries. Paged with `page` at 10 job titles per page; `page_count` on the
+   * response is how many pages exist.
+   *
+   * `employer_id` or `url` is required. Costs 1 credit. Typically ~41s.
+   */
+  async salaries(options) {
+    return this.client._post("/api/v1/glassdoor/salaries", options);
+  }
+};
+
+// src/namespaces/app-store.ts
+var AppStoreNamespace = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  /**
+   * Up to 200 fully-shaped App Store apps - the same 43-field row as app() -
+   * which makes this a bulk metadata fetch as well as a search, and a
+   * publisher lookup when the term is a developer name.
+   *
+   * NO PAGINATION. `limit` (1-200, default 25) is the only lever on volume;
+   * every offset spelling is silently ignored. Mac rows carry no iPad or Apple
+   * TV screenshots, advisories, features, supported devices or Game Center
+   * flag.
+   *
+   * Costs 1 credit.
+   */
+  async search(options) {
+    return this.client._post("/api/v1/appstore/search", options);
+  }
+  /**
+   * Full listing: title, description, developer and seller identity, price and
+   * currency, all-time and current-version ratings, version and release notes,
+   * genres, content rating and advisories, icons at three sizes, screenshots,
+   * download size, minimum OS, languages, supported devices, Game Center and
+   * VPP flags.
+   *
+   * Takes a numeric App Store id or a bundle id interchangeably. An id Apple
+   * cannot resolve is a BILLED 404 - Apple charges for the empty result list.
+   *
+   * Costs 1 credit. Single response, no pagination.
+   */
+  async app(options) {
+    return this.client._post("/api/v1/appstore/app", options);
+  }
+  /**
+   * A page of reviews: star rating, title, full text, author, and the APP
+   * VERSION the review was written against.
+   *
+   * NUMERIC APP IDS ONLY here. Paged 1-10 at 50 reviews each and hard-stopped
+   * at page 10 - 500 reviews per storefront is Apple's anonymous ceiling, so
+   * ask a different `country` to reach further. This endpoint CANNOT 404: an
+   * unknown id and a real app with zero reviews return the same empty feed.
+   * Under sort "most_recent" the vote fields are zeroes.
+   *
+   * Costs 1 credit.
+   */
+  async reviews(options) {
+    return this.client._post("/api/v1/appstore/reviews", options);
+  }
+};
+
+// src/namespaces/google-play.ts
+var GooglePlayNamespace = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  /**
+   * Ranked apps: package name, title, developer, rating, install count, price
+   * and IAP range, content rating, icon and screenshots. A branded query
+   * returns the hero card as result 1 projected to the same row shape, plus
+   * Play's related-query rail.
+   *
+   * NO PAGINATION - one shelf of ~30 apps, with no page or cursor param.
+   * `hl` moves the whole storefront, not just the language of the strings.
+   *
+   * Costs 2 credits.
+   */
+  async search(options) {
+    return this.client._post("/api/v1/googleplay/search", options);
+  }
+  /**
+   * Full store listing: installs including the REAL count Play publishes but
+   * never renders, rating and star histogram, description, developer identity
+   * and legal contact, price and IAPs, categories and gameplay tags,
+   * screenshots and trailer, version and Android requirement, release and
+   * update dates, changelog, full permission tree, Data safety table, the 20
+   * server-rendered reviews, and the similar-apps and more-by-developer rails.
+   *
+   * Those 20 reviews ride along at no extra cost - use reviews() only to page
+   * past them or to sort differently.
+   *
+   * Costs 2 credits. Single response, no pagination.
+   */
+  async app(options) {
+    return this.client._post("/api/v1/googleplay/app", options);
+  }
+  /**
+   * A page of reviews: star score, full text, author, thumbs-up count,
+   * developer reply, and the APP VERSION the reviewer was running.
+   *
+   * Paged with `cursor` -> next_cursor. The cursor is opaque and SINGLE-USE
+   * and encodes the sort as well as the position, so send it back with the
+   * same `sort` it came from; a cursor past the last review is a 404, not an
+   * empty page. `count` is capped at 200. An empty payload here is a BILLED
+   * 404 - the premium price is paid to learn the package has no reviews or
+   * does not exist.
+   *
+   * Costs 2 credits.
+   */
+  async reviews(options) {
+    return this.client._post("/api/v1/googleplay/reviews", options);
+  }
+};
+
+// src/namespaces/g2.ts
+var G2Namespace = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  /**
+   * Ranked B2B software products on G2: star rating, review count, vendor,
+   * categories, seller description and logo. Every row carries `product_id`
+   * and `slug` to feed product() and reviews().
+   *
+   * Paged with `page` and `limit` (1-100, default 20). `total_results` is
+   * G2's Products-tab headline and is CAPPED AT 10000, so treat a 10000 as a
+   * floor rather than a count; `total_by_type` breaks the same query across
+   * products, sellers, categories and discussions.
+   *
+   * Pass `query` or `url`.
+   *
+   * Costs 5 credits.
+   */
+  async search(options) {
+    return this.client._post("/api/v1/g2/search", options);
+  }
+  /**
+   * A full G2 software profile: rating with per-star histogram, review count,
+   * vendor, description and seller website, pricing editions with parsed
+   * amounts, feature groups, categories and breadcrumbs, supported languages,
+   * integrations, alternatives, head-to-head comparisons, media, community
+   * discussions and G2's AI-derived pros and cons.
+   *
+   * CARRIES NO REVIEW TEXT. G2 loads review bodies in a separate frame, so
+   * this endpoint returns none at all - call reviews() for text.
+   *
+   * Pass `product_id` (slug or numeric id as a string) or `url`.
+   *
+   * Costs 5 credits. Single response, no pagination.
+   */
+  async product(options) {
+    return this.client._post("/api/v1/g2/product", options);
+  }
+  /**
+   * A page of G2 reviews: rating, title, likes and dislikes, problems solved,
+   * reviewer job title, industry and company size, validated and incentivized
+   * flags - PLUS what the profile page has no form of: exact per-star counts,
+   * pros and cons with per-theme counts, and company-size / role / industry /
+   * region / category facets with counts.
+   *
+   * Fixed at 10 reviews per page; advance with `page`. This paginates well
+   * past the 10 pages G2's own widget links to.
+   *
+   * `rating` buckets are HALF-STAR-INCLUSIVE (1 returns 0, 0.5 and 1-star).
+   * Every filter is a closed enum because an unrecognised value matches
+   * nothing upstream and comes back as an empty, plausible-looking result set.
+   *
+   * Pass `product_id` or `url`.
+   *
+   * Costs 5 credits.
+   */
+  async reviews(options) {
+    return this.client._post("/api/v1/g2/reviews", options);
+  }
+};
+
+// src/namespaces/capterra.ts
+var CapterraNamespace = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  /**
+   * 20 ranked Capterra software products: name, vendor description, rating,
+   * review count, logo and the paid-placement flag. Every row carries
+   * `product_id` and `slug` to feed product() and reviews().
+   *
+   * NO PAGINATION. Capterra fixes the result set at 20 and page 2 returns the
+   * identical rows, so there is deliberately no page param - narrow the query
+   * instead.
+   *
+   * Pass `query` or `url`.
+   *
+   * Costs 2 credits.
+   */
+  async search(options) {
+    return this.client._post("/api/v1/capterra/search", options);
+  }
+  /**
+   * A full Capterra profile: rating with per-star histogram and the four
+   * scored criteria, likelihood to recommend, review sentiment and topics, the
+   * complete pricing table with every plan and its features, every rated
+   * feature, every integration, AI-derived pros and cons with the quoted
+   * review, FAQs, screenshots, badges and awards, competitor comparisons and
+   * alternatives, and the buyer profile by company size / industry / job
+   * function - PLUS the 25 most recent reviews, which ride along at no extra
+   * cost.
+   *
+   * `vendor` IS ALWAYS NULL here: Capterra does not publish it as structured
+   * data on the product page. The reviews name the vendor per review.
+   *
+   * Pass `product_id` (a string) or `url`. `slug` is cosmetic on this
+   * endpoint.
+   *
+   * Costs 2 credits. Single response, no pagination.
+   */
+  async product(options) {
+    return this.client._post("/api/v1/capterra/product", options);
+  }
+  /**
+   * A page of Capterra reviews: overall score plus five per-criterion scores,
+   * title, pros, cons, advice, usage duration, incentivized flag, alternatives
+   * considered and what the reviewer switched from, reviewer job title /
+   * industry / company size, and the vendor response - plus a richer
+   * competitor list than the profile carries, each alternative with its own
+   * rating histogram and starting price.
+   *
+   * 25 reviews per page, CAPPED AT PAGE 100. Past it Capterra answers 200 with
+   * PAGE ONE and the page quietly dropped from the canonical, so nothing
+   * signals the cap but repeated rows. Page 1 is already inside product(), so
+   * use this to page past it.
+   *
+   * Pass `product_id` or `url`. `slug` is load-bearing here and case-sensitive
+   * upstream - a wrong one silently serves page one.
+   *
+   * Costs 2 credits.
+   */
+  async reviews(options) {
+    return this.client._post("/api/v1/capterra/reviews", options);
+  }
+};
+
+// src/namespaces/sec.ts
+var SECNamespace = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  /**
+   * START HERE. Resolves a company name or ticker to the CIK every other SEC
+   * EDGAR endpoint is keyed by: matching filers with symbol, listing
+   * exchange, and ready-made submissions / company-facts / EDGAR URLs, tiered
+   * by match quality (each row carries its tier as `match`).
+   *
+   * `limit` sizes the response; there is no pagination. `exchange` is a
+   * closed set matched case-insensitively, and filers listed with no exchange
+   * are excluded by ANY value.
+   *
+   * Costs 1 credit.
+   */
+  async lookup(options) {
+    return this.client._post("/api/v1/sec/lookup", options);
+  }
+  /**
+   * Filer profile: legal and former names, SIC industry, filer category, EIN,
+   * LEI, state of incorporation, fiscal year end, business and mailing
+   * addresses, every ticker with its exchange, which forms it files and how
+   * often, plus a preview of its 10 most recent filings.
+   *
+   * Either `cik` or `ticker` is required; `ticker` wins when both are given.
+   *
+   * Costs 1 credit. Single response, no pagination.
+   */
+  async company(options) {
+    return this.client._post("/api/v1/sec/company", options);
+  }
+  /**
+   * A page of one filer's filings: accession number, form and root form,
+   * filing and period dates, 8-K item codes, and direct links to the primary
+   * document, filing index and attachment directory.
+   *
+   * Either `cik` or `ticker` is required. Paged with `page` + `limit`.
+   * `form` matches the form AND its root form, so "10-K" also returns 10-K/A.
+   * EDGAR's "recent" block is not a fixed window - a decade for a quiet
+   * filer, about a year for a prolific one; `include_history` reaches back
+   * through up to 10 archived shards and sets `history_truncated` when the
+   * filer had more.
+   *
+   * Costs 1 credit - including with `include_history`, which is the one call
+   * that can buy more than one upstream fetch.
+   */
+  async filings(options) {
+    return this.client._post("/api/v1/sec/filings", options);
+  }
+  /**
+   * Every value a filer reported for one XBRL concept, newest period first,
+   * with the form and filing each number came from. Restatements are KEPT,
+   * not collapsed; `latest` disambiguates a quarter from its year-to-date
+   * twin using the SEC's comparability flag.
+   *
+   * Either `cik` or `ticker` is required. The `concept` tag is CASE-SENSITIVE
+   * - "netincomeloss" is a 404 upstream, not a match; call facts() to find
+   * the real tag. `form` is an EXACT match here, so "10-K" excludes 10-K/A.
+   * `limit` sizes the response; there is no pagination.
+   *
+   * Costs 1 credit.
+   */
+  async concept(options) {
+    return this.client._post("/api/v1/sec/concept", options);
+  }
+  /**
+   * The index of every XBRL concept a filer reports - tag, label,
+   * description, units and most recent value - across us-gaap, dei and any
+   * other taxonomy it uses. This is how you find what to ask concept() for.
+   *
+   * Either `cik` or `ticker` is required. `limit` sizes the response; there
+   * is no pagination.
+   *
+   * Costs 1 credit.
+   */
+  async facts(options) {
+    return this.client._post("/api/v1/sec/facts", options);
+  }
+  /**
+   * EDGAR full-text search: each hit is the matching DOCUMENT with its URL,
+   * form, filing date and filer identity, plus facets breaking the whole
+   * result set down by company, form, industry and state.
+   *
+   * Coverage STARTS IN 2001 - nothing earlier is indexed. Accepts NO query at
+   * all: a cik, ticker, form or date filter on its own is a valid search.
+   * Paged with `page`, capped at 100 (100 documents per page) because the
+   * index refuses a result window past 10,000.
+   *
+   * Costs 1 credit.
+   */
+  async search(options) {
+    return this.client._post("/api/v1/sec/search", options);
+  }
+};
+
+// src/namespaces/companies-house.ts
+var CompaniesHouseNamespace = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  /**
+   * START HERE. Searches the UK register by name and returns the
+   * `company_number` every other endpoint is keyed by, plus name, status,
+   * incorporation or dissolution date, registered office address and matched
+   * former names.
+   *
+   * Matches CURRENT AND FORMER names. Paged with `page`, 20 results per page,
+   * CAPPED AT PAGE 50 - the register serves a 1000-result window per term
+   * whatever hit count it prints, and answers page 51 with HTTP 416.
+   *
+   * Costs 1 credit.
+   */
+  async search(options) {
+    return this.client._post("/api/v1/companieshouse/search", options);
+  }
+  /**
+   * Full register entry: status, type, incorporation and dissolution dates,
+   * registered office, SIC codes, previous names, accounts and
+   * confirmation-statement due dates with overdue flags, and whether it has
+   * charges, insolvency history, officers or UK establishments. FC companies
+   * return home registry / legal form / governing law, BR returns the parent,
+   * CE returns the charity number.
+   *
+   * `company_number` is zero-padded and upper-cased for you, so a number off
+   * a letterhead or out of a spreadsheet that ate its leading zeros still
+   * resolves.
+   *
+   * Costs 1 credit. Single response, no pagination.
+   */
+  async company(options) {
+    return this.client._post("/api/v1/companieshouse/company", options);
+  }
+  /**
+   * Officers current and resigned: name, role, appointment and resignation
+   * dates, correspondence address, nationality, country of residence,
+   * month-and-year date of birth, and identity-verification status.
+   *
+   * Paged with `page`, 35 officers per page, NO upper bound - past the last
+   * page the register answers an ordinary 200 with an empty list, identical
+   * to a company with no officers.
+   *
+   * `officers_count` is EVERY appointment ever made and `resignations_count`
+   * how many ended, so the active count is the difference. There is no
+   * server-side active/resigned filter - filter on each officer's `status` in
+   * the response.
+   *
+   * Costs 1 credit.
+   */
+  async officers(options) {
+    return this.client._post("/api/v1/companieshouse/officers", options);
+  }
+  /**
+   * Filings, most recent first: date, filing type code (AA, CS01, SH03),
+   * description, register annotations and child documents, and a link to the
+   * filed PDF with its page count.
+   *
+   * A filing the register has not finished processing carries a
+   * `processing_note` instead of a document.
+   *
+   * Paged with `page`, NO upper bound - past the last page it is an ordinary
+   * 200 with an empty list.
+   *
+   * Costs 1 credit.
+   */
+  async filingHistory(options) {
+    return this.client._post("/api/v1/companieshouse/filing-history", options);
+  }
+};
+
+// src/namespaces/google-ads.ts
+var GoogleAdsNamespace = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  /**
+   * START HERE. Resolves a brand name or a domain to the `advertiser_id` that
+   * search() and creative() are keyed by.
+   *
+   * Returns two row kinds in one list: `advertiser` rows carry the id, the
+   * verified name, the verification country and the total ad count AS A RANGE
+   * (total_ads_min / total_ads_max - Google never publishes an exact figure);
+   * `domain` rows carry a website. A name query returns both kinds, a
+   * domain-shaped query returns domains only.
+   *
+   * NO PAGINATION - this is an autocomplete, roughly 20 rows per arm, and
+   * `limit` caps each arm separately.
+   *
+   * Costs 1 credit.
+   */
+  async advertisers(options) {
+    return this.client._post("/api/v1/googleads/advertisers", options);
+  }
+  /**
+   * Every ad Google is running for one advertiser: the creative (archived
+   * image, rich-media bundle, Google's renderer link, dimensions), advertiser
+   * id and name, format, first and last seen dates, days actually run, plus
+   * total_ads_min / total_ads_max.
+   *
+   * Cursor-paginated: read `next_cursor` off the response and send it back as
+   * `cursor` WITH THE SAME FILTERS, up to 100 rows per page. `next_cursor` is
+   * null once exhausted. A `limit` above 100 is not an error - Google answers
+   * it with ZERO rows.
+   *
+   * The three `format` sets are disjoint, and `domain` is dropped from every
+   * row when the query is by `advertiser_id`, so query by domain if you need
+   * that field. The headline total is a RANGE, never an exact count.
+   *
+   * Pass `domain` or `advertiser_id`.
+   *
+   * Costs 1 credit per page.
+   */
+  async search(options) {
+    return this.client._post("/api/v1/googleads/search", options);
+  }
+  /**
+   * One creative in full, and the ONLY endpoint carrying its history: every
+   * size variation of the asset, the impression bucket, the per-region
+   * breakdown with first and last shown dates and a per-surface impression
+   * split inside each region, the format, Google's category label, and the
+   * funder disclosure on political ads.
+   *
+   * IMPRESSIONS AND REACH ARE EEA-ONLY: impressions_min, impressions_max and
+   * first_shown are NULL on US creatives because Google publishes reach only
+   * where the DSA compels it. A bucket row can carry a lower bound, an upper
+   * bound, or one alone.
+   *
+   * Keyed by the `advertiser_id` + `creative_id` PAIR - a mismatched pair is a
+   * 404, not an empty response.
+   *
+   * Costs 1 credit. Single response, no pagination.
+   */
+  async creative(options) {
+    return this.client._post("/api/v1/googleads/creative", options);
+  }
+};
+
+// src/namespaces/meta-ads.ts
+var MetaAdsNamespace = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  /**
+   * Search the Meta Ad Library. Page 1 returns 30 ads with the full creative:
+   * page name, ad copy, headline, CTA, images and videos, the platforms each
+   * ran on, and run dates - plus `total_results`, `total_is_capped`,
+   * `has_next_page` and `next_cursor`.
+   *
+   * Cursor-paginated the whole way down: 30 ads on page 1, then 10 per page.
+   * Walk `has_next_page` to pull an entire query. THE OTHER FILTERS ARE
+   * IGNORED once `cursor` is set, because the cursor carries them itself.
+   *
+   * `total_results` CAPS AT 50000 with `total_is_capped: true` - Meta only
+   * reports ">50,000", so never present it as an exact count. Spend, reach,
+   * impressions and the paid-for-by disclosure are null unless
+   * `ad_type` is "political_and_issue_ads".
+   *
+   * Costs 1 credit PER PAGE, so depth costs roughly 10 ads per credit past the
+   * first 30.
+   */
+  async search(options) {
+    return this.client._post("/api/v1/meta-ads/search", options);
+  }
+  /**
+   * Every ad a Facebook Page is running, addressed by its numeric page id.
+   * Page 1 returns 30 ads with the same creative detail as search(), then 10
+   * per page off `next_cursor`; walk `has_next_page` to pull the advertiser's
+   * whole library.
+   *
+   * The other filters are ignored once `cursor` is set. Spend, reach,
+   * impressions and the paid-for-by disclosure are null on commercial ads -
+   * only political/issue ads carry them.
+   *
+   * Costs 1 credit per page.
+   */
+  async advertiser(options) {
+    return this.client._post("/api/v1/meta-ads/advertiser", options);
+  }
+  /**
+   * One ad in full by archive id: creative, advertiser, run dates, platforms
+   * and any political disclosure.
+   *
+   * Spend, reach and impressions are null unless the ad is a political/issue
+   * ad.
+   *
+   * Costs 1 credit. Single response, no pagination.
+   */
+  async ad(options) {
+    return this.client._post("/api/v1/meta-ads/ad", options);
+  }
+};
+
+// src/client.ts
+var Scavio = class {
+  google;
+  amazon;
+  walmart;
+  youtube;
+  reddit;
+  tiktok;
+  tiktokShop;
+  instagram;
+  x;
+  linkedin;
+  threads;
+  kuaishou;
+  ebay;
+  target;
+  homeDepot;
+  zillow;
+  redfin;
+  booking;
+  airbnb;
+  tripadvisor;
+  yelp;
+  indeed;
+  glassdoor;
+  appStore;
+  googlePlay;
+  g2;
+  capterra;
+  sec;
+  companiesHouse;
+  googleAds;
+  metaAds;
+  apiKey;
+  baseUrl;
+  timeout;
+  maxRetries;
+  rateLimiter;
+  constructor(config) {
+    this.apiKey = config?.apiKey ?? process.env.SCAVIO_API_KEY ?? "";
+    if (!this.apiKey) {
+      throw new MissingAPIKeyError();
+    }
+    this.baseUrl = (config?.baseUrl ?? BASE_URL).replace(/\/+$/, "");
+    this.timeout = config?.timeout ?? DEFAULT_TIMEOUT;
+    this.maxRetries = config?.maxRetries ?? DEFAULT_MAX_RETRIES;
+    const rps = config?.maxRequestsPerSecond ?? 1;
+    if (rps < 1 || rps > 10) {
+      throw new ScavioError("maxRequestsPerSecond must be between 1 and 10");
+    }
+    this.rateLimiter = new RateLimiter(rps);
+    this.google = new GoogleNamespace(this);
+    this.amazon = new AmazonNamespace(this);
+    this.walmart = new WalmartNamespace(this);
+    this.youtube = new YouTubeNamespace(this);
+    this.reddit = new RedditNamespace(this);
+    this.tiktok = new TikTokNamespace(this);
+    this.tiktokShop = new TikTokShopNamespace(this);
+    this.instagram = new InstagramNamespace(this);
+    this.x = new XNamespace(this);
+    this.linkedin = new LinkedInNamespace(this);
+    this.threads = new ThreadsNamespace(this);
+    this.kuaishou = new KuaishouNamespace(this);
+    this.ebay = new EbayNamespace(this);
+    this.target = new TargetNamespace(this);
+    this.homeDepot = new HomeDepotNamespace(this);
+    this.zillow = new ZillowNamespace(this);
+    this.redfin = new RedfinNamespace(this);
+    this.booking = new BookingNamespace(this);
+    this.airbnb = new AirbnbNamespace(this);
+    this.tripadvisor = new TripadvisorNamespace(this);
+    this.yelp = new YelpNamespace(this);
+    this.indeed = new IndeedNamespace(this);
+    this.glassdoor = new GlassdoorNamespace(this);
+    this.appStore = new AppStoreNamespace(this);
+    this.googlePlay = new GooglePlayNamespace(this);
+    this.g2 = new G2Namespace(this);
+    this.capterra = new CapterraNamespace(this);
+    this.sec = new SECNamespace(this);
+    this.companiesHouse = new CompaniesHouseNamespace(this);
+    this.googleAds = new GoogleAdsNamespace(this);
+    this.metaAds = new MetaAdsNamespace(this);
+  }
+  /** @internal */
+  async _post(path, body) {
+    return request({
+      method: "POST",
+      path,
+      apiKey: this.apiKey,
+      baseUrl: this.baseUrl,
+      timeout: this.timeout,
+      maxRetries: this.maxRetries,
+      rateLimiter: this.rateLimiter,
+      body
+    });
+  }
+  /** @internal */
+  async _get(path) {
+    return request({
+      method: "GET",
+      path,
+      apiKey: this.apiKey,
+      baseUrl: this.baseUrl,
+      timeout: this.timeout,
+      maxRetries: this.maxRetries,
+      rateLimiter: this.rateLimiter
+    });
+  }
+  async search(options) {
+    return this.google.search(options);
+  }
+  /**
+   * Read ANY web page and get it back as readability Markdown (the default),
+   * plain text, or raw HTML. Returns `{ url, format, mode, content,
+   * content_length }`.
+   *
+   * This is a core endpoint, not a platform, so it lives on the client itself:
+   * `scavio.extract({ url })`, never `scavio.extract.extract()`.
+   *
+   * Credits are a function of `mode`, not a flat per-call constant:
+   * "normal" costs 1, "advanced" costs 1, "ultra" costs 2. Billing happens
+   * only on a successful extraction - a dead link, bot wall or timeout costs
+   * nothing.
+   *
+   * Start on "normal". Move to "advanced" when the page builds its content in
+   * the browser, and to "ultra" only when a bot wall blocks the other two.
+   *
+   * @example
+   * const page = await scavio.extract({ url: "https://example.com/pricing" });
+   * console.log(page.content);
+   */
+  async extract(options) {
+    return this._post("/api/v1/extract", options);
   }
   async getUsage() {
     return this._get("/api/v1/usage");
@@ -927,16 +2443,47 @@ var Scavio = class {
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  AirbnbNamespace,
+  AmazonNamespace,
+  AppStoreNamespace,
   BadRequestError,
+  BookingNamespace,
+  CapterraNamespace,
+  CompaniesHouseNamespace,
+  EbayNamespace,
+  G2Namespace,
+  GlassdoorNamespace,
+  GoogleAdsNamespace,
+  GoogleNamespace,
+  GooglePlayNamespace,
+  HomeDepotNamespace,
+  IndeedNamespace,
+  InstagramNamespace,
   InsufficientCreditsError,
   InvalidAPIKeyError,
+  KuaishouNamespace,
+  LinkedInNamespace,
+  MetaAdsNamespace,
   MissingAPIKeyError,
   NotFoundError,
   RateLimitError,
+  RedditNamespace,
+  RedfinNamespace,
+  SECNamespace,
   Scavio,
   ScavioAPIError,
   ScavioConnectionError,
   ScavioError,
-  ScavioTimeoutError
+  ScavioTimeoutError,
+  TargetNamespace,
+  ThreadsNamespace,
+  TikTokNamespace,
+  TikTokShopNamespace,
+  TripadvisorNamespace,
+  WalmartNamespace,
+  XNamespace,
+  YelpNamespace,
+  YouTubeNamespace,
+  ZillowNamespace
 });
 //# sourceMappingURL=index.cjs.map