@bowmark/web 1.21.0 → 1.22.1

package/dist/generated/library.d.ts

@@ -5,8 +5,8 @@
 // rather than imported. An `import` or `export` at the top level of this file would
 // turn it into a module and every declaration below would stop being global.
 //
-// Manifest version: 8f74962f532da5df8d2905deb36fe43233b84c4f09f37cb4c76b92a153333d03
-// 46 capabilities, 404 providers, 984 typed functions, 20 refused.
+// Manifest version: d7a4e150ac8b92a335cf1f8c899427d12236d7556bd04d8e873ba0729e5a347b
+// 49 capabilities, 416 providers, 1090 typed functions, 20 refused.
 // 51,715 family members, sharing 2 interface(s) — declared once and pointed at, never repeated per member.
 //
 // REFUSED — these functions are real and callable, and their declared arguments
@@ -36,6 +36,125 @@
 
 
 
+declare namespace BowmarkCapability_booking_links {
+  // ── Booking links — find a person's Calendly or Cal.com link and read its form — the unit's own declarations, verbatim ──
+type BookingPlatform = "calendly" | "cal.com" | "savvycal" | "tidycal" | "zcal" | "hubspot"
+  | "acuity" | "chilipiper" | "google-calendar" | "microsoft-bookings"
+
+// published: READ off a page (foundOn is the citation). archived: read off an old
+// Wayback capture of a page (archivedAt dates it). indexed: Google's site:cal.com search for
+// the name returned it (context quotes the result). name_match: built from the name and
+// it exists — nothing shows the person published it, and a namesake can own it.
+type BookingLinkMethod = "published" | "archived" | "indexed" | "name_match"
+
+interface BookingLinkFinding {
+  url: string
+  platform: BookingPlatform
+  method: BookingLinkMethod        // the strongest way it was found
+  foundBy: BookingLinkMethod[]     // every way it was found
+  foundOn: string | null           // the page it was written on
+  archivedAt: string | null        // YYYY-MM-DD capture date, for "archived"
+  archiveUrl: string | null
+  context: string | null           // the link's anchor text or the words around it
+  ownerName: string | null         // the name the booking page itself shows (name_match)
+  nameConfirmed: boolean           // name_match: page owner carries both names; published/archived: the name is on that page
+}
+
+interface FindBookingLinksInput {
+  name: string          // full name, first and last
+  company?: string       // name or domain — adds "first-company" slugs
+  domain?: string        // their company site: about/team/contact/services pages + homepage scanned
+  github?: string        // a handle READ off a page that names them, never guessed
+  urls?: string[]        // personal site, speaker bio, blog post — any page of theirs
+}
+
+interface FindBookingLinksOptions {
+  archive?: boolean      // read Wayback captures of the domain's about/team/contact pages; default true with a domain
+  search?: boolean       // Google site:cal.com "<name>" via Serper; default true; each search is charged to your account, or send your own key as the x-bowmark-vendor-key-serper header
+  timeoutMs?: number
+}
+
+interface BookingLinkSearch {
+  name: string
+  links: BookingLinkFinding[]   // published first, then archived, then name_match
+  checked: { pagesScanned: number; pagesUnreachable: string[]; archivedPagesRead: number; slugsChecked: string[] }
+  warnings: string[]
+}
+
+interface PublishedBookingLink { url: string; platform: BookingPlatform; context: string; nearbyText: string }
+interface PageScan { url: string; finalUrl: string; status: number; links: PublishedBookingLink[]; warnings: string[] }
+
+interface BookingQuestion { label: string; kind: string; required: boolean; choices: string[] }
+interface BookingEvent { name: string; url: string; description: string | null; durationMinutes: number | null }
+
+interface BookingPage {
+  url: string
+  platform: "calendly" | "cal.com"
+  ownerName: string | null
+  organization: string | null        // the org/team the platform files the account under (Cal.com)
+  avatarUrl: string | null
+  events: BookingEvent[]             // every event a profile lists
+  event: BookingEvent | null         // the event whose form was read; null if several and none named
+  questions: BookingQuestion[]       // everything the form asks
+  qualifyingQuestions: string[]      // the questions beyond name/email/notes — "company", "team size": a sales funnel asks these, a personal chat does not
+  bookable: "open" | "fully_booked" | "closed" | "unknown"   // Cal.com is always "unknown" here; use cal_com.getAvailability
+  nextAvailability: string | null
+  unavailableReason: string | null   // the platform's own words when it cannot be booked
+  warnings: string[]
+}
+
+interface ReadBookingPageOptions { event?: string; timeoutMs?: number }
+
+type CallOptions = {
+  timeoutMs?: number   // per-provider budget in ms, default 30000, clamped to 1000-55000.
+                       // A provider slower than this is DROPPED from the results and
+                       // NAMED in warnings — never silently absent
+}
+
+  /**
+   * Finds the public booking link (Calendly, Cal.com, SavvyCal, HubSpot…) a named person
+   * publishes — on their company's pages, their GitHub, an old archived copy of their site, or
+   * under their own name on Calendly and Cal.com — and reads what the booking form asks and
+   * whether the calendar is open, without booking anything.
+   */
+  interface Unit {
+    /**
+     * Finds a person's public booking links from their name. Runs four searches at once and merges
+     * them, strongest evidence first: links PUBLISHED on their company's
+     * about/team/contact/services pages and homepage, their GitHub profile README, the website
+     * that profile lists and any `urls` of theirs (each with the page it was on and the words
+     * around it); links on ARCHIVED Wayback Machine captures of the company's about/team/contact
+     * pages, dated (catches a link since removed); Cal.com pages Google has INDEXED under their
+     * name (a `site:cal.com "<name>"` Google search through Serper — each search is charged to
+     * your account on Bowmark's key, or send your own as the `x-bowmark-vendor-key-serper` header;
+     * if no key can serve it, it is skipped and named in `warnings`); and their name as a slug on
+     * Calendly and Cal.com, including "first-company" shapes (NAME_MATCH — exists, but a namesake
+     * can own it, so check `ownerName` and tie it to the company). Pass `company` and `domain`
+     * whenever known. Google does not index Calendly pages, so the slug check is the only way to
+     * find those. Never books.
+     */
+    find(person: FindBookingLinksInput, options?: FindBookingLinksOptions): Promise<BookingLinkSearch>;
+
+    /**
+     * Lists every booking link written on one page — hrefs, Cal.com embed buttons
+     * (`data-cal-link`) and plain-text links — with each link's anchor text and the words around
+     * it, ignoring the platforms' own pricing/login/blog pages. Use it on a personal site, a
+     * speaker bio or a newsletter footer.
+     */
+    scanPage(url: string, options?: CallOptions): Promise<PageScan>;
+
+    /**
+     * Reads a Calendly or Cal.com booking page without booking: who owns it, the events it offers,
+     * every question its form asks, `qualifyingQuestions` (anything beyond name/email/notes — a
+     * sales funnel asks for your company, a personal chat does not), and whether it can be booked
+     * (Calendly: open, fully booked, or closed with the platform's own reason). Works on a
+     * fully-booked calendar. A profile with several events returns `event: null` and the list
+     * unless `options.event` names one (slug or part of the name).
+     */
+    read(url: string, options?: ReadBookingPageOptions): Promise<BookingPage>;
+  }
+}
+
 declare namespace BowmarkCapability_bundles {
   // ── Check whether a set of products can be built and bought right now — the unit's own declarations, verbatim ──
 interface BundleItemAvailability {
@@ -291,6 +410,25 @@ type CallOptions = {
   }
 }
 
+declare namespace BowmarkCapability_currency_exchange {
+  // ── Currency exchange — the unit's own declarations, verbatim ──
+interface currency_exchangeResult {
+  rate: number;
+  warnings: string[];
+}
+type CallOptions = {
+  timeoutMs?: number   // per-provider budget in ms, default 30000, clamped to 1000-55000.
+                       // A provider slower than this is DROPPED from the results and
+                       // NAMED in warnings — never silently absent
+}
+
+  /** Get real-time exchange rates between currencies */
+  interface Unit {
+    /** Returns the current exchange rate between two currencies */
+    getRate(from: string, to: string, options?: CallOptions): Promise<currency_exchangeResult>;
+  }
+}
+
 declare namespace BowmarkCapability_custom_sofa_configurator {
   // ── Custom sofa configurator (fabric selection, live pricing) — the unit's own declarations, verbatim ──
 type CustomSofa = {
@@ -444,20 +582,14 @@ type CallOptions = {
    */
   interface Unit {
     /**
-     * Signs up for a real API key on a developer dashboard — RUN this, don't just explain how —
-     * `bowmark.developer_api_key_signup.signUp("alphavantage", { organization: "Acme Corp", email:
-     * `qa-${Date.now()}@example.com` })`. `service` selects which dashboard (today: "alphavantage"
-     * only — THROWS naming the supported list otherwise, a caller-fixable error).
-     * `details.organization` and `details.email` are required; when the caller did not supply
-     * their own, invent placeholder-shaped ones like the example's — the signup is instant and
-     * unverified, so nothing is lost by not stopping to ask first. MAKE THE EMAIL UNIQUE EVERY
-     * CALL (e.g. embed `Date.now()`, as the example does) — the dashboard rejects a repeated
-     * address with "Redundant origin", so a literal copied example email fails on the second and
-     * every later run. `details.occupation` is optional and dashboard-specific. Returns the real
-     * key plus the dashboard's own confirmation sentence. `options.timeoutMs` sets the call budget
-     * (default 30000).
+     * Signs up for a real developer API key on a dashboard. `service` selects which dashboard:
+     * "alphavantage" for stock data. Supported today: alphavantage — THROWS naming the supported
+     * list otherwise. Signs up instantly; `details.organization` and `details.email` required
+     * (MAKE EMAIL UNIQUE PER CALL, e.g. `qa-${Date.now()}@example.com`, dashboard rejects
+     * repeats). `details.occupation` optional. Returns real key plus confirmation.
+     * `options.timeoutMs` sets call budget (default 30000).
      */
-    signUp(service: string, details: { organization: string, email: string, occupation?: string }, options?: CallOptions): Promise<DeveloperApiKeySignupResult>;
+    signUp(service: string, details: object, options?: CallOptions): Promise<DeveloperApiKeySignupResult>;
   }
 }
 
@@ -2500,6 +2632,60 @@ type CallOptions = {
   }
 }
 
+declare namespace BowmarkCapability_stream_highlights {
+  // ── Stream highlights — cut a highlight of your own live broadcast — the unit's own declarations, verbatim ──
+interface CreateHighlightOptions {
+  platform?: "twitch"      // the default, and the only one today
+  videoId?: string         // id or video link; omit for the newest broadcast (the live one, while live)
+  startSeconds: number     // seconds into that broadcast
+  endSeconds: number
+  title: string
+  description?: string
+  language?: string        // default "en"
+  tags?: string[]
+  game?: string            // category name, e.g. "Wetrix"
+}
+interface StreamHighlight {
+  // "created" by this call; "existing" = a highlight with this exact title was
+  // already on the channel, nothing new made; "unknown" = no answer came back —
+  // check dashboardUrl. Calling again with the same title is always safe.
+  status: "created" | "existing" | "unknown"
+  platform: "twitch"
+  highlightId: string | null   // null only when status is "unknown"
+  url: string | null
+  title: string
+  videoId: string
+  startSeconds: number
+  endSeconds: number
+  channel: string
+  dashboardUrl: string
+  warnings: string[]
+}
+
+type CallOptions = {
+  timeoutMs?: number   // per-provider budget in ms, default 30000, clamped to 1000-55000.
+                       // A provider slower than this is DROPPED from the results and
+                       // NAMED in warnings — never silently absent
+}
+
+  /**
+   * Cuts a permanent Highlight out of a streamer's own broadcast on Twitch — including the one
+   * still live — between two offsets in seconds, with a title. Needs the streamer's Twitch
+   * sign-in: the first run answers needs_user with a link to sign in, and later runs reuse it.
+   */
+  interface Unit {
+    /**
+     * Cuts a highlight from [startSeconds, endSeconds] of the signed-in streamer's broadcast
+     * (`videoId`, or the newest one — the live one while streaming) and titles it. Safe to call
+     * again with the same title: an existing highlight of that title is returned with status
+     * "existing" instead of being cut twice. THROWS with "Retry shortly" when the live broadcast's
+     * archive has not recorded up to endSeconds yet (it trails real time by a minute or two).
+     * Needs a Twitch sign-in.
+     */
+    create(options: CreateHighlightOptions): Promise<StreamHighlight>;
+  }
+}
+
 declare namespace BowmarkCapability_tariff {
   // ── HS/HTS tariff code lookup — the unit's own declarations, verbatim ──
 
@@ -3717,6 +3903,291 @@ interface AlphavantageSignUpResult {
   }
 }
 
+declare namespace BowmarkProvider_amazon {
+  // ── Amazon — the unit's own declarations, verbatim ──
+interface AmazonProduct {
+  asin: string;
+  title: string;
+  url: string;
+  price: number | null;
+  listPrice: number | null;
+  rating: number | null;
+  ratingCount: number | null;
+  sponsored: boolean;
+}
+interface SearchProductsArgs {
+  keywords: string;
+  department?: string;
+  sort?: string;
+  priceMin?: number;
+  priceMax?: number;
+  brand?: string;
+}
+interface AmazonKeywordSuggestion {
+  value: string;
+}
+interface AmazonBestSellerCategory {
+  name: string;
+  slug: string;
+}
+interface AmazonBestSellerEntry {
+  asin: string;
+  rank: number;
+  title: string;
+  url: string;
+  price: number | null;
+  rating: number | null;
+  ratingCount: number | null;
+}
+interface AmazonBestSellerRankEntry {
+  category: string;
+  rank: number;
+}
+interface AmazonProductDetail {
+  asin: string;
+  title: string;
+  url: string;
+  brand: string | null;
+  price: number | null;
+  listPrice: number | null;
+  inStock: boolean;
+  availabilityText: string | null;
+  rating: number | null;
+  ratingCount: number | null;
+  features: string[]; // the site's own free-text bullet points — read them off a result, never guess one from prose
+  specifications: Record<string, string>;
+  breadcrumbs: string[];
+  bestSellersRank: AmazonBestSellerRankEntry[];
+  images: string[];
+  soldBy: string | null;
+  sellerId: string | null;
+}
+interface AmazonVariation {
+  asin: string;
+  dimensions: Record<string, string>; // e.g. { style_name: "Skillet", size_name: "12-inch" } — the site's own dimension names
+  isCurrent: boolean;
+}
+interface AmazonReview {
+  reviewId: string;
+  author: string;
+  rating: number;
+  title: string;
+  date: string; // the site's own sentence, e.g. "Reviewed in the United States on August 9, 2026"
+  variant: string | null; // e.g. "Style: Skillet, Size: 15-inch"
+  verifiedPurchase: boolean;
+  body: string; // paragraphs joined with a blank line, in the site's own order
+  helpfulCount: number;
+}
+interface AmazonRelatedProduct {
+  asin: string;
+  title: string;
+  url: string;
+  price: number | null;
+  rating: number | null; // null on a "Frequently bought together" row — that rail never shows one
+  ratingCount: number | null;
+}
+interface AmazonRelatedProducts {
+  boughtTogether: AmazonRelatedProduct[]; // complements, never the current ASIN
+  related: AmazonRelatedProduct[]; // "Customers who viewed this item also viewed" — substitutes
+  unavailableRails: string[]; // sims-consolidated-N_feature_div ids Amazon lazy-loads rather than serving inline
+}
+interface AmazonDeal {
+  asin: string;
+  title: string;
+  url: string;
+  dealPrice: number;
+  listPrice: number | null;
+  percentOff: number | null;
+  limitedTimeText: string | null; // e.g. "Limited time deal", or "Ends in 2026-09-16T06:59:59.000Z" for a countdown deal
+}
+interface AmazonSellerRatingPeriod {
+  averageRating: number | null;
+  ratingCount: number | null;
+}
+interface AmazonSeller {
+  sellerId: string;
+  name: string;
+  positivePercentageLast12Months: number | null; // Amazon's own headline figure; no lifetime equivalent is published
+  ratings: {
+    last30Days: AmazonSellerRatingPeriod;
+    last90Days: AmazonSellerRatingPeriod;
+    last12Months: AmazonSellerRatingPeriod;
+    lifetime: AmazonSellerRatingPeriod;
+  };
+  businessName: string | null;
+  businessAddress: string[];
+  aboutSeller: string | null;
+}
+interface GetDeliveryEstimateArgs {
+  product: string;
+  zip: string;
+}
+interface AmazonDeliveryEstimate {
+  asin: string;
+  zip: string;
+  zipResolved: boolean; // false = the fields below are Amazon's default location, not this zip
+  deliveryDate: string | null;
+  priceLabel: string | null;
+  condition: string | null;  // the site's own labels — read the values off a result, never guess one from prose
+}
+interface AmazonSellerOffer {
+  condition: string; // e.g. "New", "Used - Good", "Used - Acceptable" — read the values off a result, never guess one from prose
+  price: number | null;
+  shippingCost: number | null; // derived from shippingLabel ("FREE" -> 0)
+  shippingLabel: string | null; // the site's own delivery-price label, e.g. "FREE" or "$3.99"
+  deliveryEstimate: string | null; // e.g. "September 24 - 29"
+  sellerName: string; // "Amazon.com" when Amazon itself is the seller
+  sellerId: string | null; // null when sold by Amazon.com itself — getSeller's argument otherwise
+  sellerRating: number | null; // 0-5
+  sellerRatingCount: number | null;
+}
+interface AmazonSellerOffersResult {
+  asin: string;
+  totalOfferCount: number | null; // Amazon's own count, including offers this page did not render
+  offers: AmazonSellerOffer[]; // page one only, up to 10 — see the note on listSellerOffers
+}
+
+  /**
+   * Search Amazon's catalogue and read a product the way a shopper does — price, stock, rating,
+   * the customer reviews, the other products it recommends, every size and colour the listing
+   * sells, when it would arrive at a given ZIP — plus the rankings (best sellers, new releases,
+   * movers and shakers, most wished for), today's deals and a marketplace seller's feedback.
+   * searchProducts, suggestKeywords, listBestSellerCategories, getProduct, listVariations,
+   * listReviews, listRelatedProducts, listBestSellers, listNewReleases, listMostWishedFor,
+   * listDeals, getSeller, getDeliveryEstimate and listSellerOffers are built; everything else is
+   * still a declared stub.
+   */
+  interface Unit {
+    /**
+     * Search Amazon's catalogue for what a person would type — "cast iron skillet", "usb c hub" —
+     * and get back the result cards as the site ranks them: ASIN, title, price, list price, star
+     * rating, review count, whether the row is a paid placement, and its product URL. Optionally
+     * narrowed to a department, a brand, a price range and a sort order. THE provider's door:
+     * every function below that takes an ASIN is fed by this one.
+     */
+    searchProducts(args: SearchProductsArgs): Promise<AmazonProduct[]>;
+
+    /**
+     * Ask Amazon's own search box what it would autocomplete a prefix to — "cast iron" comes back
+     * as "cast iron skillets", "cast iron", "cast iron dutch oven". What an agent holding a vague
+     * noun calls before it commits to a search, and the cheapest call in the provider.
+     */
+    suggestKeywords(prefix: string): Promise<AmazonKeywordSuggestion[]>;
+
+    /**
+     * List the departments Amazon publishes Best Sellers rankings for — Electronics, Kitchen &
+     * Dining, Books, roughly forty of them — each with the slug ("electronics", "kitchen",
+     * "books") that listBestSellers, listNewReleases, listMostWishedFor and listMoversAndShakers
+     * take. The door for all four ranking functions: a caller holding the word "kitchen" cannot
+     * reach a ranking without this.
+     */
+    listBestSellerCategories(): Promise<AmazonBestSellerCategory[]>;
+
+    /**
+     * Read one product page the way a shopper reads it: title, brand, ASIN, current price and list
+     * price, whether it is in stock, the star rating and how many ratings it has, the bullet-point
+     * features, the specification table, the images, its category breadcrumb, its Best Sellers
+     * Rank, and who it is sold by. The single most-wanted read on the whole site.
+     */
+    getProduct(asinOrUrl: string): Promise<AmazonProductDetail>;
+
+    /**
+     * List every version of a product that is really the same listing — the 8-inch, 10.25-inch,
+     * 12-inch and 15-inch skillet; the colours; the pack sizes — each with the ASIN that buys it.
+     * What an agent needs when the person said "the 12 inch one" and the search returned whichever
+     * size Amazon ranked first. Empty when the listing has no variations — a real answer, not a
+     * parse failure.
+     */
+    listVariations(asinOrUrl: string): Promise<AmazonVariation[]>;
+
+    /**
+     * Read what customers actually wrote about a product — reviewer name, star rating, headline,
+     * date, the variant they bought, whether the purchase was Verified, the review body, and how
+     * many people found it helpful. Amazon shows a logged-out visitor its top eight reviews on the
+     * product page itself; sorting, filtering and paging past them needs a signed-in account,
+     * which sign-up has not shipped for yet. The read an agent needs to answer "is this any good"
+     * rather than "what does it cost".
+     */
+    listReviews(asinOrUrl: string): Promise<AmazonReview[]>;
+
+    /**
+     * The other products Amazon puts next to this one — "Frequently bought together" and
+     * "Customers who viewed this item also viewed" — each with its ASIN, title, price and rating,
+     * kept in separate arrays so a caller can tell a complement from a substitute. Names any
+     * further rail Amazon lazy-loads rather than serving inline rather than silently dropping it.
+     * How an agent moves from one product to the alternatives without inventing a new search
+     * query.
+     */
+    listRelatedProducts(asinOrUrl: string): Promise<AmazonRelatedProducts>;
+
+    /**
+     * Amazon's hourly-updated top sellers in one department (the slug listBestSellerCategories
+     * returns, e.g. "kitchen") — each row's ASIN, rank, title, price and rating, in rank order.
+     * What is actually selling right now, as opposed to searchProducts' relevance ranking. Page
+     * one only (up to 30 rows) — Amazon publishes more per department across a paging control this
+     * pass did not find.
+     */
+    listBestSellers(department: string): Promise<AmazonBestSellerEntry[]>;
+
+    /**
+     * What is newly out in a department (the slug listBestSellerCategories returns, e.g.
+     * "kitchen"), in Amazon's own hot-new-releases order — each row's ASIN, rank, title, price and
+     * rating. The ranking a caller wants when "best seller" would only ever return the same
+     * entrenched products. Page one only (up to 30 rows), the same limit listBestSellers carries
+     * and for the same reason.
+     */
+    listNewReleases(department: string): Promise<AmazonBestSellerEntry[]>;
+
+    /**
+     * What people in a department (the slug listBestSellerCategories returns, e.g. "kitchen") are
+     * adding to wish lists and registries most — each row's ASIN, rank, title, price and rating.
+     * Demand that has not turned into a purchase yet, which is a different signal from
+     * listBestSellers' sales rank. Page one only (up to 30 rows), the same limit the other
+     * rankings carry.
+     */
+    listMostWishedFor(department: string): Promise<AmazonBestSellerEntry[]>;
+
+    /**
+     * Today's Deals — what is discounted right now: ASIN, title, the deal price, the price it was,
+     * the percentage off, and any "limited time" wording (a plain label, or, for a countdown deal,
+     * the fragment plus its ISO deadline). Read off the page's own widget JSON rather than scraped
+     * from a card, so the discount is a published field rather than something to compute. Page one
+     * only (30 deals) — the site's own paging control was not found this pass.
+     */
+    listDeals(): Promise<AmazonDeal[]>;
+
+    /**
+     * Read a marketplace seller's storefront — their name, feedback across four windows (30 days,
+     * 90 days, the last 12 months and lifetime), the one positive-percentage figure Amazon
+     * publishes (last 12 months only), their registered business name and address, and their
+     * free-text "About Seller" text. What tells an agent whether the cheap third-party offer is
+     * from a shop with 86,000 ratings or one with thirty. The door is getProduct's sellerId field
+     * — a listing Amazon sells itself has none.
+     */
+    getSeller(sellerId: string): Promise<AmazonSeller>;
+
+    /**
+     * When a product would actually arrive at a given US ZIP, and what it costs to get it there —
+     * sets the ZIP for one session (Amazon's own "glow" location picker, no account needed) and
+     * reads the delivery block the product page then re-renders for it: the site's own delivery
+     * sentence, the price label and the condition it attaches. `zipResolved` is false, and the
+     * three fields are Amazon's DEFAULT location rather than the caller's ZIP, on an invalid ZIP.
+     */
+    getDeliveryEstimate(args: GetDeliveryEstimateArgs): Promise<AmazonDeliveryEstimate>;
+
+    /**
+     * Every seller offering the same listing side by side — condition (new, used, its grade),
+     * price, shipping cost and estimate, and the seller's own name, id and star rating — read off
+     * the site's "All Offers Display" modal rather than the buy-box winner alone. What tells an
+     * agent who has it cheapest, and whether the cheap one is Amazon itself or a thirty-rating
+     * marketplace seller. Page one only (up to 10 offers, `totalOfferCount` reports the site's own
+     * full count) — no paging control was found in the modal's static markup this pass. Empty
+     * `offers` on a listing with no other sellers is a real answer, not a parse failure.
+     */
+    listSellerOffers(asinOrUrl: string): Promise<AmazonSellerOffersResult>;
+  }
+}
+
 declare namespace BowmarkProvider_americandreamvacations {
   // ── American Dream Vacations — the unit's own declarations, verbatim ──
 interface AdvLocation {
@@ -4179,6 +4650,300 @@ interface AosomProduct {
   }
 }
 
+declare namespace BowmarkProvider_app_store {
+  // ── Apple App Store — the unit's own declarations, verbatim ──
+interface AppStoreApp {
+  id: string;
+  name: string;
+  bundleId: string;
+  developer: { id: string; name: string };
+  price: { amount: number; currency: string; formatted: string } | null;
+  rating: { average: number; count: number } | null;
+  category: string;
+  url: string;
+}
+type AppStorePlatform = "iphone" | "ipad" | "mac";
+interface SearchAppsArgs {
+  term: string;
+  platform?: AppStorePlatform;
+  genreId?: string | number;
+  country?: string;
+  limit?: number;
+}
+interface AppStoreSearchResult {
+  term: string;
+  platform: AppStorePlatform;
+  country: string;
+  total: number;
+  apps: AppStoreApp[];
+}
+interface GetAppArgs {
+  app: string | number;
+  country?: string;
+}
+interface GetAppsArgs {
+  apps: (string | number)[];
+  country?: string;
+}
+interface GetAppsResult {
+  apps: AppStoreApp[];
+  warnings: string[];
+}
+interface GetAppDetailsArgs {
+  app: string | number;
+}
+interface AppStoreRatingHistogram {
+  average: number;
+  total: number;
+  counts: number[];
+}
+interface AppStoreChartPosition {
+  category: string;
+  position: number;
+}
+interface AppStoreInAppPurchase {
+  name: string;
+  price: string;
+}
+interface AppStorePrivacyCategory {
+  type: string;
+  title: string;
+  categories: string[];
+}
+interface AppStoreVersionInfo {
+  version: string | null;
+  releaseDate: string | null;
+  notes: string;
+}
+interface AppStoreLink {
+  label: string;
+  url: string;
+}
+interface AppStoreFeaturedStory {
+  title: string;
+  url: string;
+}
+interface AppStoreAppDetails {
+  id: string;
+  url: string;
+  ratings: AppStoreRatingHistogram | null;
+  chartPosition: AppStoreChartPosition | null;
+  editorsChoice: boolean;
+  information: Record<string, string>;
+  inAppPurchases: AppStoreInAppPurchase[];
+  privacy: AppStorePrivacyCategory[];
+  mostRecentVersion: AppStoreVersionInfo | null;
+  accessibilityFeatures: string[];
+  links: AppStoreLink[];
+  featuredIn: AppStoreFeaturedStory[];
+}
+interface AppStoreCategory {
+  id: string;
+  name: string;
+  parentId: string | null;
+}
+interface ListCategoriesResult {
+  categories: AppStoreCategory[];
+}
+type AppStoreChartDevice = "iphone" | "ipad" | "mac";
+type AppStoreChartKind = "free" | "paid";
+interface ListTopChartsArgs {
+  device?: AppStoreChartDevice;
+  chart?: AppStoreChartKind;
+  genreId?: string | number;
+  limit?: number;
+}
+interface AppStoreChartApp {
+  position: number;
+  id: string;
+  bundleId: string;
+  name: string;
+  subtitle: string;
+  developer: string;
+  ageRating: string;
+  price: string;
+  rating: { average: number; countLabel: string } | null;
+  url: string;
+}
+interface ListTopChartsResult {
+  device: AppStoreChartDevice;
+  chart: AppStoreChartKind;
+  genreId: string;
+  source: "page" | "feed";
+  apps: AppStoreChartApp[];
+}
+interface ListDeveloperAppsArgs {
+  developer?: string | number;
+  app?: string | number;
+  country?: string;
+  limit?: number;
+}
+interface ListDeveloperAppsResult {
+  developer: { id: string; name: string };
+  apps: AppStoreApp[];
+}
+interface ListSimilarAppsArgs {
+  app: string | number;
+}
+interface AppStoreSimilarApp {
+  id: string;
+  bundleId: string;
+  name: string;
+  subtitle: string;
+  ageRating: string;
+  price: string;
+  rating: { average: number; countLabel: string } | null;
+  url: string;
+}
+interface AppStoreSimilarAppsResult {
+  id: string;
+  apps: AppStoreSimilarApp[];
+}
+interface GetStoryArgs {
+  story: string | number;
+  platform?: AppStoreChartDevice;
+}
+interface AppStoreStoryApp {
+  id: string;
+  bundleId: string;
+  name: string;
+  subtitle: string;
+  developer: string;
+  ageRating: string;
+  rating: { average: number; countLabel: string } | null;
+  price: string;
+  url: string;
+}
+interface AppStoreStory {
+  id: string;
+  url: string;
+  heading: string;
+  title: string;
+  subtitle: string;
+  body: string;
+  apps: AppStoreStoryApp[];
+}
+type AppStoreReviewSort = "mostRecent" | "mostHelpful";
+interface ListReviewsArgs {
+  app: string | number;
+  page?: number;
+  sortBy?: AppStoreReviewSort;
+  country?: string;
+}
+interface AppStoreReview {
+  id: string;
+  author: string;
+  title: string;
+  body: string;
+  rating: number | null;
+  version: string;
+  helpfulVotes: number;
+  totalVotes: number;
+  updated: string;
+}
+interface ListReviewsResult {
+  app: string;
+  page: number;
+  sortBy: AppStoreReviewSort;
+  country: string;
+  hasMore: boolean;
+  reviews: AppStoreReview[];
+}
+
+  /**
+   * Search every iPhone, iPad and Mac app Apple lists, read one app's price, rating, reviews,
+   * in-app purchases and privacy labels, and see what is charting right now — off Apple's own
+   * keyless public API and its server-rendered store pages.
+   */
+  interface Unit {
+    /**
+     * Search the App Store for what a person would actually type — "budget tracker", "slack",
+     * "photo editor" — and get back the apps Apple's own store search ranks, narrowable by
+     * platform (iPhone/iPad/Mac), category and store country. THE door: every id-taking function
+     * in this provider is fed by an id this returns.
+     */
+    searchApps(args: SearchAppsArgs): Promise<AppStoreSearchResult>;
+
+    /**
+     * Read one app the way its store listing reads: name, developer, price, average rating and
+     * rating count, category, and the id every other function here takes — from a numeric app id,
+     * its bundle id, or an apps.apple.com URL a person pasted. The core read of the provider, and
+     * the cheapest call in it.
+     */
+    getApp(args: GetAppArgs): Promise<AppStoreApp>;
+
+    /**
+     * Read up to fifty apps in ONE request, for when an agent already holds a list of ids — the
+     * ranks past the top of a chart, the ids in a "you might also like" shelf, a comparison a
+     * person asked for. Same record as getApp, one round trip instead of fifty; an id that does
+     * not resolve is named in warnings rather than silently dropped.
+     */
+    getApps(args: GetAppsArgs): Promise<GetAppsResult>;
+
+    /**
+     * Everything the store page shows that the API does not: the five-star rating histogram, the
+     * app's live chart position, every in-app purchase by name and price, Apple's privacy
+     * nutrition labels, the Editors' Choice citation, the latest version's notes, size, seller,
+     * compatibility, languages, copyright, accessibility features, developer-website and
+     * privacy-policy links, and the editorial stories it has been featured in. Every field is
+     * optional — a missing shelf on the app's own page is an absent field here, never a throw.
+     */
+    getAppDetails(args: GetAppDetailsArgs): Promise<AppStoreAppDetails>;
+
+    /**
+     * Answer "what else is like this one" with the App Store's own You Might Also Like shelf — the
+     * apps Apple itself puts next to this one, each with its name, tagline, developer, age rating,
+     * price and the id every function here takes. What an agent reaches for when the app a person
+     * named is wrong, too expensive, or not on their device. Shares getAppDetails' page cache, so
+     * calling both for one app costs one fetch.
+     */
+    listSimilarApps(args: ListSimilarAppsArgs): Promise<AppStoreSimilarAppsResult>;
+
+    /**
+     * List every app one developer has on the store — from the developer's numeric artist id,
+     * their apps.apple.com developer URL, or just one of their apps (resolved to its developer
+     * first). The read behind "what else did the people who made this write" and behind checking
+     * whether an app is from who it claims to be.
+     */
+    listDeveloperApps(args: ListDeveloperAppsArgs): Promise<ListDeveloperAppsResult>;
+
+    /**
+     * List every category and subcategory the App Store sorts apps into — Business, Education,
+     * Games and its nineteen sub-genres, and the rest — each with the numeric id that narrows
+     * searchApps and listTopCharts. The finder that lets an agent holding the word "puzzle" reach
+     * a real listing without being told an id.
+     */
+    listCategories(): Promise<ListCategoriesResult>;
+
+    /**
+     * What is charting on the App Store right now — top free or top paid, on iPhone, iPad or Mac,
+     * for the whole store or narrowed to any genre id listCategories returns — in rank order, each
+     * entry with its position, name, tagline, developer, age rating, price and the id every other
+     * function here takes. The question this provider exists to answer that no search engine
+     * answers, because the answer changes every day.
+     */
+    listTopCharts(args?: ListTopChartsArgs): Promise<ListTopChartsResult>;
+
+    /**
+     * Read an App Store editorial story — the Today-tab piece Apple's editors wrote ("Master Your
+     * Major", "About In-App Purchases") — its heading, title, body and the apps it recommends,
+     * each with the id every other function here takes. Takes the story URL
+     * getAppDetails().featuredIn[].url returns, or a bare story id plus the platform it was
+     * featured under. How an agent answers "what does Apple say about this" and finds apps nobody
+     * searches for by name.
+     */
+    getStory(args: GetStoryArgs): Promise<AppStoreStory>;
+
+    /**
+     * Read what people actually wrote about an app — the review body, its title, the star rating,
+     * the reviewer's name, which app version they were on, and how many others found it helpful —
+     * fifty at a time, newest first or most helpful first. The one read that turns "4.1 stars"
+     * into a reason.
+     */
+    listReviews(args: ListReviewsArgs): Promise<ListReviewsResult>;
+  }
+}
+
 declare namespace BowmarkProvider_apple {
   // ── Apple — the unit's own declarations, verbatim ──
 interface AppleSearchResult {
@@ -4192,6 +4957,15 @@ interface AppleSearchResponse {
   query: string;
   results: AppleSearchResult[];
 }
+interface AppleSuggestionRow {
+  label: string;
+  url: string;
+}
+interface AppleSuggestResponse {
+  query: string;
+  suggestions: AppleSuggestionRow[];
+  quickLinks: AppleSuggestionRow[];
+}
 interface AppleProduct {
   name: string;
   lowPrice: number | null;
@@ -4204,11 +4978,158 @@ interface AppleProductPage {
   url: string;
   products: AppleProduct[];
 }
+interface AppleConfigChoice {
+  key: string;
+  label: string;
+}
+interface AppleConfigDimension {
+  key: string;
+  label: string;
+  choices: AppleConfigChoice[];
+}
+interface AppleConfiguration {
+  dimensions: Record<string, string>;
+  partNumber: string | null;
+  buildToOrder: boolean;
+  price: number | null;
+  priceCurrency: string | null;
+}
+interface AppleConfigurationOptions {
+  url: string;
+  dimensions: AppleConfigDimension[];
+  configDimensions: AppleConfigDimension[];
+  configurations: AppleConfiguration[];
+}
+interface AppleFamilyModel {
+  name: string;
+  startingPrice: number | null;
+  url: string;
+}
+interface AppleFamilyModelList {
+  family: "mac" | "iphone" | "ipad" | "watch";
+  models: AppleFamilyModel[];
+}
+interface AppleRefurbishedListing {
+  partNumber: string;
+  name: string;
+  price: number | null;
+  priceCurrency: string | null;
+  url: string;
+  image: string | null;
+}
+interface AppleRefurbishedCatalog {
+  category: "mac" | "ipad" | "iphone" | "watch" | "appletv" | "homepod" | "airpods" | "accessories";
+  listings: AppleRefurbishedListing[];
+}
 interface AppleTradeInEstimate {
   device: string;
   upToUsd: number;
   sourceUrl: string;
 }
+interface AppleTradeInDeviceValue {
+  modelId: string | null;
+  modelName: string;
+  maxValueUsd: number;
+}
+interface AppleTradeInCatalog {
+  category: "smartphone" | "computer" | "watch";
+  devices: AppleTradeInDeviceValue[];
+}
+interface AppleSupportResult {
+  docid: string;
+  title: string;
+  url: string;
+  snippet: string;
+}
+interface AppleSupportSearchResponse {
+  query: string;
+  results: AppleSupportResult[];
+  totalResults: number;
+}
+interface AppleSupportArticle {
+  docid: string;
+  title: string;
+  description: string;
+  url: string;
+  body: string;
+}
+interface AppleLocationSuggestion {
+  displayValue: string;
+  city: string;
+  state: string;
+}
+interface AppleResolvedLocation {
+  place: string;
+  location: string;
+  city: string;
+  state: string;
+  alternates: AppleLocationSuggestion[];
+}
+interface AppleNearbyStore {
+  storeNumber: string;
+  storeName: string;
+  city: string;
+  state: string;
+  address: string;
+  phoneNumber: string;
+  distanceMiles: number | null;
+}
+interface AppleStoresNear {
+  location: string;
+  stores: AppleNearbyStore[];
+}
+interface ApplePickupStore {
+  storeNumber: string;
+  storeName: string;
+  city: string;
+  state: string;
+  address: string;
+  phoneNumber: string;
+  distanceMiles: number | null;
+  available: boolean;
+  pickupQuote: string | null;
+}
+interface ApplePickupAvailability {
+  partNumber: string;
+  location: string;
+  stores: ApplePickupStore[];
+}
+interface AppleDeliveryOption {
+  displayName: string;
+  date: string;
+  shippingCost: string;
+}
+interface AppleDeliveryEstimate {
+  partNumber: string;
+  postalCode: string;
+  options: AppleDeliveryOption[];
+}
+interface AppleStoreListing {
+  storeNumber: string;
+  name: string;
+  url: string;
+}
+interface AppleStoreList {
+  stores: AppleStoreListing[];
+}
+interface AppleStoreHours {
+  days: string[];
+  opens: string;
+  closes: string;
+}
+interface AppleStore {
+  storeNumber: string;
+  name: string;
+  url: string;
+  phoneNumber: string;
+  address: string;
+  city: string;
+  state: string;
+  postalCode: string;
+  latitude: number | null;
+  longitude: number | null;
+  hours: AppleStoreHours[];
+}
 
   /** apple.com's own site search and product pages — no API, no login, no browser. */
   interface Unit {
@@ -4218,12 +5139,59 @@ interface AppleTradeInEstimate {
      */
     search(query: string): Promise<AppleSearchResponse>;
 
+    /**
+     * Types a partial query into apple.com's own search box and returns what it suggests:
+     * completed search phrases ("AirPods Pro 3") and quick links straight to a product page
+     * ("AirPods" → apple.com/airpods/). A caller holding only the words somebody said gets a real
+     * product URL with no id to know first.
+     */
+    suggestSearches(query: string): Promise<AppleSuggestResponse>;
+
     /**
      * Reads one apple.com product/buy page (a URL or path, e.g. search()'s own rows) and returns
      * every schema.org Product block it publishes.
      */
     getProduct(urlOrPath: string): Promise<AppleProductPage>;
 
+    /**
+     * Turns an Apple part number — the "MYAP3LL/A"-shaped code printed on every buy page and
+     * returned by getPickupAvailability/getDeliveryEstimate — into the product it names: real
+     * name, price and currency, straight off the configured buy page apple.com redirects a part
+     * number to. Also accepts a /shop/ path or apple.com URL, resolved the same way getProduct's
+     * argument is.
+     */
+    getProductByPartNumber(partNumber: string): Promise<AppleProductPage>;
+
+    /**
+     * Reads every choice a Mac/iPhone/iPad buy page actually offers — screen size, colour, chip,
+     * memory, storage, keyboard layout, connectivity — straight off the page's own configurator
+     * data, with the part number and price each fixed combination already resolves to. "Configure
+     * and price it" as one read instead of clicking through the on-page configurator: every part
+     * number this returns is directly usable by getProductByPartNumber, getPickupAvailability and
+     * getDeliveryEstimate. A combination apple.com has not fixed a single part number for yet
+     * (memory/storage still open) comes back with `buildToOrder: true` and a null part number,
+     * listing the further choices rather than guessing a price for combinations apple.com computes
+     * client-side.
+     */
+    getConfigurationOptions(urlOrPath: string): Promise<AppleConfigurationOptions>;
+
+    /**
+     * Lists every model apple.com currently sells in one product family — the chooser page's own
+     * cards (e.g. "MacBook Air", "iPad mini"), each with its starting price and the buy page that
+     * configures it. Takes "mac", "iphone", "ipad" or "watch" — apple.com publishes no equivalent
+     * chooser page for AirPods or Vision Pro, each sold as a single named model with no lineup to
+     * list.
+     */
+    listFamilyModels(family: "mac" | "iphone" | "ipad" | "watch"): Promise<AppleFamilyModelList>;
+
+    /**
+     * Apple's own certified refurbished store, read as data: every listing currently in stock in
+     * one category, each with its real name, its current price and the part number that resolves
+     * it straight through getProductByPartNumber. Stock turns over daily and a category can
+     * legitimately be empty when Apple has nothing left in it.
+     */
+    listRefurbished(category: "mac" | "ipad" | "iphone" | "watch" | "appletv" | "homepod" | "airpods" | "accessories"): Promise<AppleRefurbishedCatalog>;
+
     /**
      * Reads apple.com's own trade-in value table and returns the CEILING ("up to $X")
      * cash-or-credit estimate it publishes for one device — a human name ("iPhone 14 Pro") or the
@@ -4232,6 +5200,82 @@ interface AppleTradeInEstimate {
      * best-case figure, not a quote for a specific unit's actual condition.
      */
     getTradeInEstimate(model: string): Promise<AppleTradeInEstimate>;
+
+    /**
+     * The whole Apple Trade In price list in one call. "smartphone" is the RICH catalog behind the
+     * estimator — every individual phone model apple.com will take, INCLUDING non-Apple ones
+     * (Samsung, Google, …), each with its own ceiling. "computer" and "watch" are coarser: a
+     * ceiling per product LINE ("MacBook Pro", "Apple Watch Ultra 3"), the same table
+     * getTradeInEstimate reads for iPhone. apple.com has no measured trade-in catalog for "tablet"
+     * at all — neither surface this function uses covers it.
+     */
+    listTradeInValues(category: "smartphone" | "computer" | "watch"): Promise<AppleTradeInCatalog>;
+
+    /**
+     * Searches Apple's own support library the way a person describes a problem ("iphone battery
+     * draining") and returns the articles Apple ranks for it — HelpKB pages, User Guide pages and
+     * Apple Support Community threads mixed in one list, each with its document id, title, URL and
+     * a plain-text snippet. A DOOR: the way into the support half of this provider before
+     * getSupportArticle reads one page in full.
+     */
+    searchSupport(query: string): Promise<AppleSupportSearchResponse>;
+
+    /**
+     * Reads one Apple support article end to end — the real instructions under its headline, not a
+     * search snippet — from the docid or URL one of searchSupport()'s own rows carries. The read
+     * an agent reaches for once searchSupport has narrowed the problem to one page.
+     */
+    getSupportArticle(docidOrUrl: string): Promise<AppleSupportArticle>;
+
+    /**
+     * Turns the place a person said — "cupertino", "san francisco" — into the exact "<city>,
+     * <state>" string apple.com's own store and delivery lookups accept, off apple.com's own
+     * location typeahead. A DOOR HOP: the small step that makes findStoresNear,
+     * getPickupAvailability and getDeliveryEstimate callable from words alone instead of a
+     * pre-resolved location string.
+     */
+    resolveLocation(place: string): Promise<AppleResolvedLocation>;
+
+    /**
+     * Finds the Apple Stores near a place a person named — "Cupertino", "94108", "San Francisco" —
+     * with each store's name, number, city, state, address, phone and distance, nearest first. The
+     * finder that turns a place into the store records every other retail function here takes, for
+     * a caller who holds no part number and must not have to invent one.
+     */
+    findStoresNear(place: string): Promise<AppleStoresNear>;
+
+    /**
+     * Answers the one question apple.com is uniquely able to answer: can I walk into a store today
+     * and pick this up. Give it a part number (or a /shop/ path or apple.com URL — resolved the
+     * same way getProduct's argument is) and a place, and it returns every nearby Apple Store with
+     * whether that exact configuration is in stock, the pickup window, and the store's name,
+     * number, address, phone and distance.
+     */
+    getPickupAvailability(partNumber: string, place: string): Promise<ApplePickupAvailability>;
+
+    /**
+     * When would this actually arrive if ordered now, to a ZIP code — the shipping options and
+     * delivery dates apple.com quotes on the buy page for one exact configuration, without
+     * starting a checkout. Takes a bare 5-digit ZIP, NOT the resolved place string
+     * getPickupAvailability takes: apple.com's own delivery-message endpoint reads a different
+     * parameter and ignores a "<city>, <state>" value entirely.
+     */
+    getDeliveryEstimate(partNumber: string, postalCode: string): Promise<AppleDeliveryEstimate>;
+
+    /**
+     * Every Apple Store in the US on one call — its name, its store number and its page — off
+     * apple.com's own store-locator directory, so a caller can browse or filter them rather than
+     * guess a slug. The store number is the SAME id findStoresNear and getPickupAvailability's
+     * rows carry, so a listing here joins straight to either.
+     */
+    listStores(): Promise<AppleStoreList>;
+
+    /**
+     * Read one Apple Store: its full address, phone number, map coordinates, store number and the
+     * hours it is open each day of the week — everything a person needs before driving there.
+     * Takes a URL or /retail/ path, e.g. one of listStores()'s own rows.
+     */
+    getStore(urlOrPath: string): Promise<AppleStore>;
   }
 }
 
@@ -4402,11 +5446,59 @@ interface archive_orgAvailability {
   archivedStatus: string | null;     // the original page's own HTTP status when captured
 }
 
+interface archive_orgSnapshotOptions {
+  scope?: "exact" | "prefix";   // default: "prefix" for a bare domain (every page under it), "exact" for a url with a path
+  limit?: number;               // 1-500, default 50 — newest first
+  pathContains?: string[];      // keep only urls whose path contains one of these, e.g. ["about", "team", "contact"]
+}
+
+interface archive_orgSnapshot {
+  timestamp: string;            // YYYYMMDDhhmmss
+  originalUrl: string;
+  archivedUrl: string;          // the browsable capture, web.archive.org/web/<ts>/<url>
+  statusCode: string;
+  mimeType: string;
+}
+
+interface archive_orgSnapshotList {
+  query: string;
+  scope: "exact" | "prefix";
+  snapshots: archive_orgSnapshot[];   // prefix: newest capture of each distinct url; exact: each distinct VERSION of the page
+  warnings: string[];
+}
+
+interface archive_orgSnapshotPage {
+  originalUrl: string;
+  timestamp: string;
+  archivedUrl: string;
+  html: string;                 // the ORIGINAL bytes as captured, without the archive's toolbar or rewritten links
+  warnings: string[];
+}
+
   /**
-   * The Wayback Machine's own public availability lookup — is a site or page archived, and
-   * where.
+   * The Wayback Machine — is a site or page archived, every capture it holds, and the page
+   * itself as it was captured, so a caller can see what a site published before it was changed
+   * or removed.
    */
   interface Unit {
+    /**
+     * Lists what the Wayback Machine has captured, newest first. A bare domain ("humanlayer.dev")
+     * returns the newest capture of every distinct page under it — narrow it with `pathContains:
+     * ["about", "team", "contact"]`. A url with a path returns every distinct VERSION of that one
+     * page, which is the axis that answers "was this ever on the page". Each row carries the
+     * capture timestamp, the original url and its browsable archive url. Use getSnapshot to read
+     * one.
+     */
+    listSnapshots(site: string, opts?: archive_orgSnapshotOptions): Promise<archive_orgSnapshotList>;
+
+    /**
+     * Reads one archived page as it was captured — the original HTML, without the archive's
+     * toolbar or rewritten links — for a url and a `YYYYMMDDhhmmss` timestamp from listSnapshots
+     * (a nearby timestamp is redirected to the closest capture). Use it to find something a page
+     * carried in the past and has since removed.
+     */
+    getSnapshot(url: string, timestamp: string): Promise<archive_orgSnapshotPage>;
+
     /**
      * Checks the Wayback Machine's own public availability endpoint for one site or page — a bare
      * domain ("carpetlandusa.net"), a domain plus path
@@ -5896,15 +6988,17 @@ interface bestbuyProduct {
      * Runs a Best Buy product search the way bestbuy.com's own search box does, via Best Buy's
      * documented Products API, and returns the matching products — name, sale/regular price,
      * online and in-store availability, manufacturer, model number, UPC and review stats.
-     * `pageSize` caps the row count (default 10, Best Buy's own ceiling 100). Requires a Best Buy
-     * developer API key — see this provider's `auth`.
+     * `pageSize` caps the row count (default 10, Best Buy's own ceiling 100). Uses Bowmark's Best
+     * Buy key and charges each request to your account; send your own key as the
+     * `x-bowmark-vendor-key-bestbuy` header instead.
      */
     search(args: string | { query: string; pageSize?: number }): Promise<bestbuyProduct[]>;
 
     /**
      * Looks up one product by Best Buy's own numeric SKU (the id `search`'s rows carry) and
-     * returns its full detail — the same fields as `search`. Requires a Best Buy developer API key
-     * — see this provider's `auth`.
+     * returns its full detail — the same fields as `search`. Uses Bowmark's Best Buy key and
+     * charges each request to your account; send your own key as the
+     * `x-bowmark-vendor-key-bestbuy` header instead.
      */
     getProduct(sku: string | number): Promise<bestbuyProduct>;
   }
@@ -7562,9 +8656,58 @@ interface CalComAvailabilityResult {
   otherEventTypes: CalComEventType[];
 }
 
+interface CalComFormQuestion {
+  label: string;       // what a booker reads
+  name: string;        // Cal.com's own field name ("name", "email", or a custom slug)
+  type: string;        // Cal.com's own type: "name" | "email" | "phone" | "text" | "textarea" | "select" | "radio" | …
+  required: boolean;
+  choices: string[];
+}
+
+interface CalComBookingEvent {
+  title: string;
+  slug: string;
+  url: string;
+  description: string | null;
+  lengthInMinutes: number | null;
+}
+
+interface CalComBookingFormOptions {
+  event?: string;      // which event on a multi-event profile — its slug or part of its title
+}
+
+interface CalComBookingForm {
+  url: string;
+  username: string;
+  eventTypes: CalComEventType[];     // a profile's list; empty when the url already named an event
+  event: CalComBookingEvent | null;  // null when several events exist and none was named
+  ownerName: string | null;
+  organization: string | null;       // the org/team Cal.com itself files the account under
+  avatarUrl: string | null;
+  questions: CalComFormQuestion[];   // only what a booker is shown — hidden and reschedule-only fields dropped
+  warnings: string[];
+}
+
+interface CalComProfileCandidate {
+  slug: string;
+  url: string;                // where the page landed; a one-event profile redirects to that event
+  title: string;              // the page's own <title>
+  ownerName: string | null;   // read off the title
+  nameMatches: boolean;       // ownerName carries BOTH names asked for — a hint, a namesake passes too
+}
+
+interface CalComFindProfilesResult {
+  name: string;
+  company: string | null;
+  slugsChecked: string[];
+  candidates: CalComProfileCandidate[];
+  warnings: string[];
+}
+
   /**
-   * Cal.com's own documented, keyless public API — the event types a booking page offers and the
-   * real, currently-open time slots for one of them — no browser, no key.
+   * Cal.com's own public surfaces — find a person's Cal.com page from their name, read the event
+   * types it offers, the questions its booking form asks and who owns it, and the real,
+   * currently-open time slots — no browser, no key.
    */
   interface Unit {
     /**
@@ -7581,6 +8724,28 @@ interface CalComAvailabilityResult {
      * event type and reports the rest in `otherEventTypes`.
      */
     getAvailability(username: string, opts?: CalComAvailabilityOptions): Promise<CalComAvailabilityResult>;
+
+    /**
+     * Reads what a Cal.com booking page will ask before anyone books: the event's
+     * title/description/length, every question on its booking form (only the ones a booker is
+     * actually shown, with choices and whether each is required), the owner's name and avatar, and
+     * the organization or team Cal.com files the account under. Needs no open slot. Takes an event
+     * url ("https://cal.com/alexatallah/15min"), a team or org-subdomain event url, or a profile
+     * url — a profile with several events returns `event: null` and the list unless `opts.event`
+     * names one. Never books anything.
+     */
+    getBookingForm(url: string, opts?: CalComBookingFormOptions): Promise<CalComBookingForm>;
+
+    /**
+     * Finds a person's own Cal.com page from their full name, and optionally their company (pass
+     * it). Checks the slug shapes that measured reliable (first-last, firstlast, lastfirst,
+     * first-company, firstcompany, last-company, and the bare company slug — which often belongs
+     * to a stranger, so read `ownerName`) and returns each page that exists with its own title,
+     * the owner name the title states, and `nameMatches`. A match is a GUESS: a namesake passes,
+     * so tie the page to the company before relying on it. Works on pages no search engine has
+     * indexed.
+     */
+    findProfiles(name: string, company?: string): Promise<CalComFindProfilesResult>;
   }
 }
 
@@ -7629,10 +8794,58 @@ interface CalendlyAvailabilityResult {
   otherEventTypes: CalendlyEventType[];
 }
 
+interface CalendlyFormQuestion {
+  label: string;
+  format: string;     // Calendly's own: "string" | "text" | "phone_number" | "select" | "multi_select" | "radios" | "checkboxes"
+  required: boolean;
+  choices: string[];
+}
+
+interface CalendlyBookingEvent {
+  name: string;
+  slug: string | null;
+  url: string;
+  description: string | null;
+  durationMinutes: number | null;
+}
+
+interface CalendlyBookingFormOptions {
+  event?: string;     // which event on a multi-event profile — its slug or part of its name
+}
+
+interface CalendlyBookingForm {
+  url: string;
+  profileSlug: string | null;         // null for a calendly.com/d/<hash> share link
+  ownerName: string | null;
+  eventTypes: CalendlyEventType[];
+  event: CalendlyBookingEvent | null; // null when several events exist and none was named
+  questions: CalendlyFormQuestion[];  // CUSTOM questions; name + email are always asked on top
+  nextAvailability: string | null;    // null + unavailableReason null = fully booked, not unread
+  unavailableReason: string | null;   // non-null = Calendly says this cannot be booked
+  warnings: string[];
+}
+
+interface CalendlyProfileCandidate {
+  slug: string;
+  url: string;
+  ownerName: string;       // the name the profile itself shows
+  nameMatches: boolean;    // ownerName carries BOTH names asked for — a hint, a namesake passes too
+  timezone: string;
+}
+
+interface CalendlyFindProfilesResult {
+  name: string;
+  company: string | null;
+  slugsChecked: string[];
+  candidates: CalendlyProfileCandidate[];
+  warnings: string[];
+}
+
   /**
-   * Calendly's own public booking-widget data — the event types a scheduling page offers and the
-   * real, currently-open time slots for one of them — read straight off the widget's
-   * undocumented JSON endpoints, no browser, no key.
+   * Calendly's own public booking-widget data — find a person's Calendly page from their name,
+   * read the event types it offers, the questions its booking form asks, and the real,
+   * currently-open time slots — read straight off the widget's undocumented JSON endpoints, no
+   * browser, no key.
    */
   interface Unit {
     /**
@@ -7650,6 +8863,29 @@ interface CalendlyAvailabilityResult {
      * first event type and reports the rest in `otherEventTypes`.
      */
     getAvailability(profile: string, opts?: CalendlyAvailabilityOptions): Promise<CalendlyAvailabilityResult>;
+
+    /**
+     * Reads what a Calendly booking page will ask before anyone books: the owner's name, the
+     * event's name/description/duration, every custom form question (with its choices and whether
+     * it is required), the next open time, and Calendly's own reason when the calendar cannot be
+     * booked. Needs no open slot, so it reads a fully-booked calendar too. Takes a profile url
+     * ("https://calendly.com/eric-ciarla"), an event url, or a one-off share link
+     * ("https://calendly.com/d/ctbt-d45-rgb/simbie-ai-demo"). A profile with several events
+     * returns `event: null` and the list unless `opts.event` names one. Never books anything.
+     */
+    getBookingForm(url: string, opts?: CalendlyBookingFormOptions): Promise<CalendlyBookingForm>;
+
+    /**
+     * Finds a person's own Calendly page from their full name, and optionally their company (pass
+     * it — "caleb-firecrawl" is found only by the company shape). Checks the slug shapes that
+     * measured reliable (first-last, firstlast, lastfirst, first-company, firstcompany,
+     * last-company, and the bare company slug — which often belongs to a stranger, so read
+     * `ownerName`) and returns every one that exists with the name the page itself shows and
+     * `nameMatches`. A match is a GUESS: a namesake with the same first and last name passes, so
+     * tie the page to the company before relying on it. Search engines do not index Calendly
+     * pages, so this is the way to find one.
+     */
+    findProfiles(name: string, company?: string): Promise<CalendlyFindProfilesResult>;
   }
 }
 
@@ -10485,6 +11721,19 @@ interface CuriocityListEventsQuery {
   }
 }
 
+declare namespace BowmarkProvider_currency_exchange {
+  // ── ExchangeRate-API — the unit's own declarations, verbatim ──
+interface currency_exchangeRow {
+  rate: number;
+}
+
+  /** Get real-time exchange rates from ExchangeRate-API */
+  interface Unit {
+    /** Returns the current exchange rate between two currencies */
+    getRate(from: string, to: string): Promise<currency_exchangeRow>;
+  }
+}
+
 declare namespace BowmarkProvider_cyberpowerpc {
   // ── CyberPowerPC — the unit's own declarations, verbatim ──
 interface CyberpowerpcConfigurator {
@@ -11025,6 +12274,29 @@ interface DdCartHandoff {
   }
 }
 
+declare namespace BowmarkProvider_dell {
+  // ── Dell — the unit's own declarations, verbatim ──
+interface SearchForumThreadsArgs {
+  query: string;
+}
+
+interface DellForumThread {
+  title: string;
+  url: string;
+  postCount: number;
+}
+
+  /** Search Dell's community forum for discussion threads. */
+  interface Unit {
+    /**
+     * Search Dell community forums for threads matching a query — needs a topic or keywords (e.g.
+     * "storage issues", "laptop battery"), never a bare "search the forum" with nothing to search
+     * for.
+     */
+    searchForumThreads(args: SearchForumThreadsArgs): Promise<DellForumThread[]>;
+  }
+}
+
 declare namespace BowmarkProvider_deltadentalma {
   // ── Delta Dental of Massachusetts — the unit's own declarations, verbatim ──
 // Delta Dental of Massachusetts's OWN shapes — not a capability contract.
@@ -12354,7 +13626,8 @@ interface etsyListing {
      * Searches Etsy's live catalog of active listings by keyword, via Etsy's documented Open API
      * v3, and returns the matching listings — id, title, price, currency, quantity available, tags
      * and the listing's own etsy.com URL. `limit` caps the row count (default 10, Etsy's own
-     * ceiling 100). Requires an Etsy developer API key — see this provider's `auth`.
+     * ceiling 100). Uses Bowmark's Etsy key and charges each request to your account; send your
+     * own key as the `x-bowmark-vendor-key-etsy` header instead.
      */
     search(args: string | { query: string; limit?: number }): Promise<etsyListing[]>;
   }
@@ -14608,6 +15881,19 @@ interface GithubListReleasesResult {
   warnings: string[];
 }
 
+interface GithubProfileReadme {
+  login: string;
+  name: string | null;
+  company: string | null;
+  blog: string | null;            // the website they list on their profile
+  bio: string | null;
+  twitterUsername: string | null;
+  profileUrl: string;
+  readme: string | null;          // the profile README's raw markdown; null when they have none
+  readmeUrl: string | null;
+  warnings: string[];
+}
+
   /**
    * GitHub's own REST API, keyless. Built: a public repo's commit log (sha, author, date,
    * message), paged and windowed; a public repo's release history (tag, name, dates, release
@@ -14639,6 +15925,16 @@ interface GithubListReleasesResult {
      * `releases: []`, not a throw.
      */
     listReleases(owner: string, repo: string, options?: GithubListReleasesOptions): Promise<GithubListReleasesResult>;
+
+    /**
+     * Reads a person's own GitHub profile — display name, company, the website they list, bio, X
+     * handle — and the raw markdown of their profile README (the `<handle>/<handle>` repo GitHub
+     * shows on the profile page), which is where people put a personal site, a booking link or
+     * contact details. Takes a username, `@handle` or github.com url. `readme` is null when they
+     * have no profile README. Unauthenticated calls share GitHub's 60 requests/hour per IP; this
+     * spends two. THROWS on an unknown user or a rate limit.
+     */
+    getProfileReadme(handle: string): Promise<GithubProfileReadme>;
   }
 }
 
@@ -14971,6 +16267,718 @@ interface GooglePriceGraph {
   }
 }
 
+declare namespace BowmarkProvider_google_maps {
+  // ── Google Maps — the unit's own declarations, verbatim ──
+interface SuggestPlacesArgs {
+  query: string;
+}
+interface SearchPlacesArgs {
+  query: string;
+}
+interface SearchPlacesResult {
+  featureId: string;
+  name: string;
+  address: string;
+  coordinates: { lat: number; lng: number } | null;
+  categories: string[];
+  rating?: number;
+  reviewCount?: number;
+}
+interface GeocodeAddressArgs {
+  address: string;
+}
+interface GeocodeAddressResult {
+  featureId: string;
+  name: string;
+  formattedAddress: string;
+  coordinates: { lat: number; lng: number } | null;
+}
+interface ReverseGeocodeArgs {
+  lat: number;
+  lng: number;
+}
+interface ReverseGeocodeResult {
+  formatted: string;
+  plusCode: string;
+  locality: string;
+  dms: string;
+  coordinates: { lat: number; lng: number };
+}
+interface GetPlaceArgs {
+  query: string;
+}
+interface GetPlaceResult {
+  featureId: string;
+  name: string;
+  address: string;
+  coordinates: { lat: number; lng: number } | null;
+  categories: string[];
+  neighborhood?: string;
+  phone?: string;
+  website?: string;
+  rating?: number;
+  reviewCount?: number;
+  hours?: { day: string; hours: string[] }[];
+}
+interface ListReviewsArgs {
+  query: string;
+}
+interface Review {
+  author: string;
+  authorId?: string;
+  rating: number;
+  text: string;
+  relativeDate?: string;
+}
+interface ListRelatedPlacesArgs {
+  query: string;
+}
+interface RelatedPlace {
+  featureId: string;
+  name: string;
+  coordinates: { lat: number; lng: number } | null;
+  categories: string[];
+  rating?: number;
+  reviewCount?: number;
+}
+interface GetDirectionsArgs {
+  origin: string;
+  destination: string;
+  mode?: "driving" | "walking" | "transit";
+}
+interface DirectionsStep {
+  instruction: string;
+  distance: string;
+  duration: string;
+}
+interface GetDirectionsResult {
+  distance: string;
+  duration: string;
+  distanceMeters: number;
+  durationSeconds: number;
+  steps: DirectionsStep[];
+}
+interface ResolvePlaceUrlArgs {
+  url: string;
+}
+interface GoogleMapsPlace {
+  featureId: string;
+  name?: string;
+}
+interface ListPhotosArgs {
+  featureId: string;
+}
+interface Photo {
+  url: string;
+  width: number;
+  height: number;
+  takenAt?: string;
+  source?: string;
+}
+
+  /**
+   * Local business search on Google Maps — find places by what a person would say, then read the
+   * address, hours, rating, reviews, photos, co-located tenants and route. suggestPlaces
+   * (autocomplete), searchPlaces (the door), geocodeAddress, getPlace, listReviews, listPhotos,
+   * listRelatedPlaces, getDirections, resolvePlaceUrl and reverseGeocode are built; everything
+   * else is still a declared stub.
+   */
+  interface Unit {
+    /**
+     * Google Maps' own autocomplete for a half-typed query — what the search box offers while
+     * somebody types. Returns the completed queries, ready to hand to searchPlaces once it lands.
+     */
+    suggestPlaces(args: SuggestPlacesArgs): Promise<string[]>;
+
+    /**
+     * The door every other Maps function chains off. Takes what a person would say — "coffee shops
+     * in Seattle WA", "pizza near Austin TX" — and returns the ranked places Google shows for it:
+     * feature id, name, address, coordinates and categories, plus rating and review count when the
+     * site's response carries them. The location lives in the query text; Google resolves it from
+     * there rather than from a separate coordinate.
+     */
+    searchPlaces(args: SearchPlacesArgs): Promise<SearchPlacesResult[]>;
+
+    /**
+     * A street address, a city, or a business name in — the matching Google Maps place, its
+     * feature id and its coordinates out. Rides the same door as searchPlaces (a second reading of
+     * the same response), so it only resolves a query that names ONE place; a category or
+     * list-style query throws.
+     */
+    geocodeAddress(args: GeocodeAddressArgs): Promise<GeocodeAddressResult>;
+
+    /**
+     * A point in — the Plus Code and locality Google Maps shows for it out, the same string a
+     * person sees when they drop a pin ("JMC2+57W Seattle, Washington"), never a street address:
+     * that is what the site itself answers for a bare point, verified live against the White
+     * House's own coordinates. Rides the same tbm=map door searchPlaces and geocodeAddress use,
+     * with a different field mask — not the browser rung the survey queued this for; the browser
+     * pass that found the field mask was how the shape was discovered, not what the shipped
+     * function needs.
+     */
+    reverseGeocode(args: ReverseGeocodeArgs): Promise<ReverseGeocodeResult>;
+
+    /**
+     * Everything Google Maps shows on one business's panel — name, full address, coordinates,
+     * category, neighborhood, phone, website, rating, review count and weekly hours, each present
+     * only when the site's own response carried it. A THIRD reading of searchPlaces' door: takes
+     * the same resolving query geocodeAddress does (typically a name plus address, since this does
+     * not take a feature id — measured live, neither the raw id nor a cid string resolves through
+     * this door), and throws when the query names a category or list rather than one business.
+     */
+    getPlace(args: GetPlaceArgs): Promise<GetPlaceResult>;
+
+    /**
+     * The reviews Google Maps shows on a business's own panel — up to 5, each with author, star
+     * rating, review text and the site's own relative date. A FOURTH reading of searchPlaces' door
+     * (the same record getPlace reads, one section further in), not the listugcposts route the
+     * survey planned: that route needed a session token minted by a place-page bootstrap that was
+     * never cracked, but the same reviews the token would have fetched are already sitting in the
+     * panel response. Takes the same resolving query getPlace does. Returns [] for a place with no
+     * reviews rather than throwing; throws only when the query itself does not resolve to one
+     * place.
+     */
+    listReviews(args: ListReviewsArgs): Promise<Review[]>;
+
+    /**
+     * Other businesses Google Maps lists "At this place" — the site's own label for a shared
+     * address, not the "people also search for" competitor set the survey planned. A FIFTH reading
+     * of searchPlaces' door (the same record getPlace reads, at [204]). Verified 2026-09-15:
+     * `null` for an ordinary standalone business (confirmed against four, including Analog Coffee
+     * and Pike Place Market), populated only for a multi-tenant venue — Space Needle's own gift
+     * shop, café and lounge; a 61-store list for Westlake Center mall. Returns [] for a
+     * single-business query rather than throwing; throws only when the query itself does not
+     * resolve to one place.
+     */
+    listRelatedPlaces(args: ListRelatedPlacesArgs): Promise<RelatedPlace[]>;
+
+    /**
+     * A DIFFERENT door from searchPlaces' — www.google.com/maps/preview/directions, its own
+     * reusable pb= template (BUILD_QUEUE.md), one per mode. Takes origin and destination as text,
+     * exactly what a person would type ("Space Needle, Seattle, WA") or a
+     * searchPlaces/geocodeAddress result's name plus address — not a feature id, measured live the
+     * same way getPlace measured it. mode defaults to "driving"; "walking" and "transit" are also
+     * built. "bicycling" is not: its response shape diverges enough that a route total cannot be
+     * read off it safely yet. Returns the site's own trip total (distance, duration, traffic-aware
+     * for driving) plus the turn-by-turn instructions, each carrying the site's own distance and
+     * duration text. Throws when either place does not resolve to a route.
+     */
+    getDirections(args: GetDirectionsArgs): Promise<GetDirectionsResult>;
+
+    /**
+     * A Google Maps link somebody pasted — a maps.app.goo.gl short link, a full /maps/place/ link,
+     * or the older ?ftid=/?cid= link — turned into the feature id and name it points at. Two of
+     * the three shapes need no network call at all: everything returned is already sitting in the
+     * URL string, since fetching a resolved link live only echoes the request back rather than
+     * adding data (measured 2026-09-15). Only a short link costs a request — one redirect-follow,
+     * reading the destination out of the "location" header rather than the (contentless) body. A
+     * bare ?cid= link resolves only the LOW half of the feature id and carries no name, reported
+     * as "0x0:0x<lo>" the same way the site's own echo does. Throws when the link resolves to
+     * something that is not a place — a dropped-pin share or a review share, both measured live.
+     */
+    resolvePlaceUrl(args: ResolvePlaceUrlArgs): Promise<GoogleMapsPlace>;
+
+    /**
+     * The photos Google Maps shows in a place's gallery panel — up to 20, each with a url, its
+     * real dimensions and the site's own upload-source tag ("photos:gmm_ios_review_post" and
+     * similar — which app and flow it came in through, not a caption; none was found at any
+     * position tried), plus a date when the response carried one. A THIRD door, not searchPlaces'
+     * field mask: opening the place page's own photo panel fires its own batchexecute RPC, which
+     * is not a bootstrap-derived static template the way searchPlaces' and reverseGeocode's are —
+     * a browser genuinely has to run to get the real gallery back, measured 2026-09-16. Takes a
+     * featureId (searchPlaces/geocodeAddress/getPlace/resolvePlaceUrl all hand one back), not a
+     * resolving query.
+     */
+    listPhotos(args: ListPhotosArgs): Promise<Photo[]>;
+  }
+}
+
+declare namespace BowmarkProvider_google_news {
+  // ── Google News — the unit's own declarations, verbatim ──
+interface GoogleNewsLocaleArg {
+  hl?: string;
+  gl?: string;
+  ceid?: string;
+}
+interface GoogleNewsClusterEntry {
+  title: string;
+  link: string;
+  publisher: string;
+}
+interface GoogleNewsArticle {
+  articleId: string;
+  title: string;
+  link: string;
+  publisher: string;
+  publisherUrl: string | null;
+  publishedAt: string | null;
+  cluster: GoogleNewsClusterEntry[];
+}
+interface GoogleNewsSearchResult {
+  query: string;
+  articles: GoogleNewsArticle[];
+}
+interface GoogleNewsTopStories {
+  title: string;
+  clusters: GoogleNewsArticle[];
+}
+interface GoogleNewsTopicHeadlines {
+  section: "World" | "Nation" | "Business" | "Technology" | "Entertainment" | "Sports" | "Science" | "Health";
+  title: string;
+  articles: GoogleNewsArticle[];
+}
+interface GoogleNewsPublisherHeadlines {
+  publisher: string;
+  query: string;
+  articles: GoogleNewsArticle[];
+}
+interface GoogleNewsLocalHeadlines {
+  place: string;
+  title: string;
+  articles: GoogleNewsArticle[];
+}
+interface GoogleNewsArticleResolution {
+  articleId: string;
+  url: string;
+}
+interface GoogleNewsTopic {
+  topicId: string;
+  name: string;
+}
+interface GoogleNewsTopicFeed {
+  topicId: string;
+  title: string;
+  articles: GoogleNewsArticle[];
+}
+interface GoogleNewsStory {
+  storyId: string;
+  title: string;
+}
+interface GoogleNewsCoverageArticle {
+  articleId: string;
+  title: string;
+  snippet: string | null;
+  publisher: string;
+  publisherUrl: string | null;
+  url: string;
+  publishedAt: string | null;
+}
+interface GoogleNewsFullCoverage {
+  storyId: string;
+  articles: GoogleNewsCoverageArticle[];
+}
+
+  /**
+   * Headlines from every publisher at once — today's top stories as clusters, a section or a
+   * city's local news, one outlet's own coverage, and everything indexed about a subject with
+   * Google's own when: and site: operators. searchNews (the door), topStories,
+   * listTopicHeadlines, listLocalHeadlines, listPublisherHeadlines, resolveArticleUrl (the
+   * redirector-to-publisher resolver every other function's links need), listTopics (the finder
+   * for getTopicHeadlines), listStories (the finder for getFullCoverage) and getFullCoverage
+   * (every outlet reporting one story) are built; everything else is still a declared stub.
+   */
+  interface Unit {
+    /**
+     * Everything Google News has indexed about a subject, across every publisher at once —
+     * headline, publisher, publication time and the Google News link, newest first. `query` is
+     * exactly what a person would type into Google News' own search box, and Google's own
+     * operators work inside it: `when:1h`/`when:1d`/`when:7d` narrows the window,
+     * `site:reuters.com` pins one publisher, quotes pin a phrase and `(a OR b)` unions two
+     * subjects — measured 2026-09-15: `site:reuters.com tesla` returned 100 items of which 100
+     * carried `<source>Reuters</source>`. This is the provider's main door: a caller holding only
+     * words gets in here. A query that matches nothing returns an empty `articles` array rather
+     * than throwing. `locale` — `{ hl, gl, ceid }` — asks for another country/language edition,
+     * e.g. `{ hl: "es-419", gl: "MX", ceid: "MX:es" }` for Mexico; omitted, every field defaults
+     * to the US English edition.
+     */
+    searchNews(query: string, locale?: GoogleNewsLocaleArg): Promise<GoogleNewsSearchResult>;
+
+    /**
+     * What Google News is leading with right now — the front page, as ranked story CLUSTERS rather
+     * than a flat list. Each entry carries the lead headline and publisher plus every other outlet
+     * covering the same story, which is the one thing a single publisher's own feed can never give
+     * a caller asking "what is everyone saying about this today". `locale` — `{ hl, gl, ceid }` —
+     * asks for another country/language edition, e.g. `{ hl: "es-419", gl: "MX", ceid: "MX:es" }`
+     * for Mexico; omitted, the US English front page.
+     */
+    topStories(locale?: GoogleNewsLocaleArg): Promise<GoogleNewsTopStories>;
+
+    /**
+     * The latest headlines in one of Google News' own eight sections — World, Nation, Business,
+     * Technology, Entertainment, Sports, Science or Health — by section NAME, so a caller who has
+     * only the word "technology" never has to hold an opaque topic id. The name is matched
+     * case-insensitively against the closed list of eight; anything else throws before any request
+     * is made, because an unrecognized section answers 200 with Google News' own app-shell HTML
+     * rather than a 404 (measured 2026-09-15) — reading that as an empty section would be silently
+     * wrong rather than refused. `locale` — `{ hl, gl, ceid }` — asks for another country/language
+     * edition; omitted, the US English one.
+     */
+    listTopicHeadlines(section: string, locale?: GoogleNewsLocaleArg): Promise<GoogleNewsTopicHeadlines>;
+
+    /**
+     * Everything Google News has indexed from one publisher — `publisher` is a domain like
+     * "reuters.com" or "apnews.com" — newest first, optionally narrowed with `query` the same way
+     * `searchNews` takes one. Built on the search door with a `site:` filter
+     * (`/rss/search?q=site:<publisher> <query>`), NOT on the route that looks like its own:
+     * `/rss/headlines/section/publication/<NAME>` answers 200 with the Top stories feed
+     * byte-for-byte for a name it cannot resolve, so it would look like it worked and be wrong for
+     * every publisher. Measured 2026-09-15: `site:reuters.com tesla` returned 100 items of which
+     * 100 carried a `<source>` domain on `reuters.com`. `locale` — `{ hl, gl, ceid }` — asks for
+     * another country/language edition; omitted, the US English one.
+     */
+    listPublisherHeadlines(publisher: string, query?: string, locale?: GoogleNewsLocaleArg): Promise<GoogleNewsPublisherHeadlines>;
+
+    /**
+     * What is being reported in one place — the local-news edition for a city or region, by NAME
+     * ("Seattle", "San Francisco"), not a place id. There is no closed list of valid places, so a
+     * place Google News has no edition for is refused only after the request comes back: it
+     * answers 200 with an in-protocol "This feed is not available." sentinel item and a bare
+     * "Google News" channel title rather than the place's own name (measured 2026-09-15 on a
+     * nonsense place; the same sentinel `_client` already drops out of every other feed by guid) —
+     * reading that as an empty result would be silently wrong, so this throws instead. A
+     * recognized place's own channel title is echoed back in `place`, in the site's own spelling,
+     * so `"seattle"` and `"Seattle"` both resolve to `"Seattle"`. `locale` — `{ hl, gl, ceid }` —
+     * asks for another country/language edition; omitted, the US English one.
+     */
+    listLocalHeadlines(place: string, locale?: GoogleNewsLocaleArg): Promise<GoogleNewsLocalHeadlines>;
+
+    /**
+     * The publisher's real article URL behind a Google News link — every `link` in every feed
+     * above is a `news.google.com/rss/articles/<id>` redirector that does NOT redirect (it 302s to
+     * itself, then serves an interstitial with no publisher URL anywhere in its bytes), so this is
+     * what turns a headline into something a caller can actually read. Takes either the bare
+     * `articleId` (a feed item's own `<guid>`) or a full redirector link someone pasted. Two hops,
+     * both browserless: GET the interstitial for a `data-n-a-id`/`-ts`/`-sg` signature minted for
+     * that article page, then POST it to the site's `batchexecute` RPC for the real URL — the
+     * signature cannot be skipped or reused across articles, so this is always two requests.
+     */
+    resolveArticleUrl(articleIdOrLink: string): Promise<GoogleNewsArticleResolution>;
+
+    /**
+     * The topics Google News' own home-page nav rail is offering today — the eight standing
+     * sections plus "Your local news" (measured 2026-09-15: nine entries, geo-scoped to whichever
+     * exit made the request) — each with the opaque topic id `getTopicHeadlines` takes. Read off
+     * the home page's own embedded `AF_initDataCallback({key: 'ds:2'…})` state rather than scraped
+     * from the rendered nav, so it needs no browser. The finder that makes a topic id reachable by
+     * somebody who only holds words. `locale` — `{ hl, gl, ceid }` — asks for another
+     * country/language edition's own nav rail; omitted, the US English one.
+     */
+    listTopics(locale?: GoogleNewsLocaleArg): Promise<GoogleNewsTopic[]>;
+
+    /**
+     * The headlines under any Google News topic id — the opaque key `/rss/topics/<id>` takes,
+     * which the eight named sections `listTopicHeadlines` takes by word are only a subset of.
+     * Identical fetch and parse to `listTopicHeadlines` (`/rss/topics/<topicId>` rather than
+     * `/rss/headlines/section/topic/<NAME>`) — the only difference is the key, since a topic id
+     * has no canonical spelling for the site to correct it to. Measured 2026-09-15: the Technology
+     * section's own topic id answers the identical feed shape as its section-name door, 70 items,
+     * titled "Technology - Latest - Google News". THE ONLY IDS REACHABLE WITHOUT AN ACCOUNT ARE
+     * THE NINE `listTopics` RETURNS. Google News also runs entity and interest topics (a company,
+     * a person, a sports league), but measured 2026-09-16 nothing logged-out hands their ids out —
+     * a topic page, a story page, `/home` and `/publications` each carry only the nav rail's own
+     * nine, and the HTML `/search` page that renders the entity's Follow chip answers 429 through
+     * the proxy. To follow a company or a person today, use `searchNews`. `locale` — `{ hl, gl,
+     * ceid }` — asks for another country/language edition; omitted, the US English one.
+     */
+    getTopicHeadlines(topicId: string, locale?: GoogleNewsLocaleArg): Promise<GoogleNewsTopicFeed>;
+
+    /**
+     * The story CLUSTERS Google News is running right now, as ids — the finder for
+     * `getFullCoverage`. Pass a `topicId` (from `listTopics`, or one of the eight section names'
+     * own topic id) to read a topic page — measured 2026-09-15: 43 distinct stories on the
+     * Technology topic page, the richer of the two doors — or omit it to read the front page
+     * instead, which surfaces far fewer (2 measured) since most front-page items are
+     * single-outlet. Reads the "Full Coverage" anchor Google News renders on every multi-outlet
+     * story directly off the page's HTML, rather than the page's own embedded state — no RSS feed
+     * on this site emits a story id at all, so this is the only door. `locale` — `{ hl, gl, ceid
+     * }` — asks for another country/language edition of whichever page is read; omitted, the US
+     * English one.
+     */
+    listStories(topicId?: string, locale?: GoogleNewsLocaleArg): Promise<GoogleNewsStory[]>;
+
+    /**
+     * Every outlet reporting one story — Google News' own Full Coverage, chained off a `storyId`
+     * from `listStories`. Reads the story page's own `AF_initDataCallback({key: 'ds:0'…})` state:
+     * a mix of named groups ("Top news", "Personal perspective", an occasional "Posts on X" of
+     * social posts rather than articles, which are excluded) and ungrouped rows, folded into one
+     * flat list. Unlike every other function here, each article's `url` is the PUBLISHER's own
+     * page directly — no `news.google.com` redirector, so no `resolveArticleUrl` hop is needed. A
+     * story id is as short-lived as a headline; hold one only as long as the `listStories` call
+     * that produced it — a stale id throws, naming that as the likely cause, rather than answering
+     * with 0 articles. `locale` — `{ hl, gl, ceid }` — matters here even though every article
+     * already carries its own publisher URL: the STORY PAGE ITSELF is read in whichever edition is
+     * asked for, and reading it in the wrong one silently truncates or empties the coverage
+     * (measured 2026-09-16: the same story id answered 0 articles under the US default and 53
+     * under `{ hl: "es-419", gl: "MX", ceid: "MX:es" }`). Pass the SAME locale the `listStories`
+     * call that produced this id used; omitted, the US English edition.
+     */
+    getFullCoverage(storyId: string, locale?: GoogleNewsLocaleArg): Promise<GoogleNewsFullCoverage>;
+  }
+}
+
+declare namespace BowmarkProvider_google_translate {
+  // ── Google Translate — the unit's own declarations, verbatim ──
+interface TranslateArgs {
+  text: string | readonly string[];
+  to: string;
+  from?: string;
+}
+interface GoogleTranslateResult {
+  source: string;
+  translated: string;
+  targetLanguage: string;
+  sourceLanguage: string;
+  detected: boolean;
+}
+interface DetectLanguageArgs {
+  text: string;
+}
+interface GoogleTranslateLanguageCandidate {
+  language: string;
+  confidence: number;
+}
+interface GoogleTranslateLanguageDetection {
+  language: string;
+  confidence: number;
+  candidates: GoogleTranslateLanguageCandidate[];
+}
+interface ListLanguagesArgs {
+  hl?: string;
+}
+interface GoogleTranslateLanguage {
+  code: string;
+  name: string;
+  sourceSupported: boolean;
+  targetSupported: boolean;
+}
+interface LookupWordArgs {
+  word: string;
+  to: string;
+  from: string;
+  hl?: string;
+}
+interface GoogleTranslateWordCandidate {
+  word: string;
+  reverseTranslations: string[];
+  score: number;
+}
+interface GoogleTranslateWordSense {
+  partOfSpeech: string;
+  candidates: GoogleTranslateWordCandidate[];
+}
+interface GoogleTranslateWordLookup {
+  word: string;
+  targetLanguage: string;
+  sourceLanguage: string;
+  senses: GoogleTranslateWordSense[];
+}
+interface GetDefinitionsArgs {
+  word: string;
+  language: string;
+}
+interface GoogleTranslateDefinitionExample {
+  text: string;
+}
+interface GoogleTranslateDefinition {
+  definitionId: string;
+  gloss: string;
+  examples: GoogleTranslateDefinitionExample[];
+  subject?: string[];
+  register?: string[];
+}
+interface GoogleTranslateDefinitionSense {
+  partOfSpeech: string;
+  definitions: GoogleTranslateDefinition[];
+}
+interface GoogleTranslateWordDefinitions {
+  word: string;
+  language: string;
+  senses: GoogleTranslateDefinitionSense[];
+}
+interface GetSynonymsArgs {
+  word: string;
+  language: string;
+}
+interface GoogleTranslateSynonymGroup {
+  definitionId: string;
+  synonyms: string[];
+  register?: string[];
+}
+interface GoogleTranslateSynonymSense {
+  partOfSpeech: string;
+  groups: GoogleTranslateSynonymGroup[];
+}
+interface GoogleTranslateWordSynonyms {
+  word: string;
+  language: string;
+  senses: GoogleTranslateSynonymSense[];
+}
+interface GetAlternativeTranslationsArgs {
+  text: string;
+  to: string;
+  from?: string;
+}
+interface GoogleTranslateAlternative {
+  text: string;
+  backends: number[];
+}
+interface GoogleTranslateAlternativeSegment {
+  sourceSegment: string;
+  offsets: { begin: number; end: number };
+  alternatives: GoogleTranslateAlternative[];
+}
+interface GoogleTranslateAlternativeTranslations {
+  text: string;
+  targetLanguage: string;
+  sourceLanguage: string;
+  segments: GoogleTranslateAlternativeSegment[];
+}
+interface CheckSpellingArgs {
+  text: string;
+  language: string;
+}
+interface GoogleTranslateSpellCheck {
+  text: string;
+  language: string;
+  correct: boolean;
+  corrected?: string;
+  correctedHtml?: string;
+  correctionType?: number[];
+  confident?: boolean;
+}
+interface RomanizeArgs {
+  text: string;
+  to: string;
+  from?: string;
+}
+interface GoogleTranslateRomanization {
+  text: string;
+  targetLanguage: string;
+  sourceLanguage: string;
+  detected: boolean;
+  targetRomanization?: string;
+  sourceRomanization?: string;
+}
+interface SpeakArgs {
+  text: string;
+  language: string;
+}
+interface GoogleTranslateSpeech {
+  audioBase64: string;
+  contentType: string;
+  chunkCount: number;
+}
+
+  /**
+   * Translate text into any of 249 languages, in a batch if you have a list, and find out what
+   * language something already is — plus the dictionary underneath: senses, definitions,
+   * synonyms, alternative wordings, the romanization and the spoken audio. `translate` is built;
+   * everything else is still a declared stub.
+   */
+  interface Unit {
+    /**
+     * Turn text into another language. `args.text` is one string or a list translated together in
+     * one request, in order; `args.to` names the target language by name ("Spanish") or code
+     * ("es", "pt-BR"); `args.from` is optional and, left out, the source is detected per string,
+     * with `detected: true` and the detected code coming back on each result. Returns one
+     * `GoogleTranslateResult` per input string, aligned by position.
+     */
+    translate(args: TranslateArgs): Promise<GoogleTranslateResult[]>;
+
+    /**
+     * Work out what language a string is written in. Returns `language` (Google's own code) and
+     * `confidence` (0-1) rather than swallowing it — a single word can come back confidently wrong
+     * (measured 2026-09-15: "Bonjour" alone detects as "en"), so a caller reading only `language`
+     * cannot tell a guess from a sure thing. `candidates` carries every language Google's detector
+     * considered, most confident first.
+     */
+    detectLanguage(args: DetectLanguageArgs): Promise<GoogleTranslateLanguageDetection>;
+
+    /**
+     * Every language this site supports — the table that turns a caller's "Portuguese" into the
+     * `pt`/`pt-BR` code the rest of this provider takes, and the honest answer to "can Google
+     * Translate do Cherokee". `args.hl` optionally localizes the returned `name`s (`{ hl: "es" }`
+     * returns "abjasio" for `ab`); left out, names come back in English.
+     * `sourceSupported`/`targetSupported` are not both always true — `sl` alone carries `"auto"`
+     * ("Detect language") and `tl` alone carries `"zh-TW"`, measured 2026-09-15.
+     */
+    listLanguages(args?: ListLanguagesArgs): Promise<GoogleTranslateLanguage[]>;
+
+    /**
+     * The full "translations of <word>" dictionary panel: every part of speech Google has for
+     * `args.word`, the candidate translations under each (ordered by Google's own frequency
+     * `score`), and for each candidate the words it itself translates back to — the difference
+     * between "run means correr" and knowing `ejecutar` is the software sense and `huir` is the
+     * fleeing sense. `args.from` is required, unlike `translate` — there is no "detect it" reading
+     * of a dictionary lookup. `senses` comes back empty when Google has no per-sense breakdown for
+     * the term (a longer phrase, or a string its dictionary does not recognize); the plain
+     * `translate` function still works on those.
+     */
+    lookupWord(args: LookupWordArgs): Promise<GoogleTranslateWordLookup>;
+
+    /**
+     * What `args.word` MEANS, IN `args.language` — monolingual, unlike `lookupWord`, which
+     * translates between two. Groups every sense by part of speech, each carrying a plain-English
+     * gloss and, where Google has one, a real usage example (its own `<b>`-highlight markup
+     * stripped). `senses` comes back empty when Google's dictionary has nothing for the term.
+     */
+    getDefinitions(args: GetDefinitionsArgs): Promise<GoogleTranslateWordDefinitions>;
+
+    /**
+     * Other words that mean the same thing as `args.word`, IN `args.language` — grouped by sense
+     * (`definitionId` matches a `GoogleTranslateDefinition.definitionId` from `getDefinitions`)
+     * rather than thrown into one list, and labelled where Google knows the register: "informal"
+     * synonyms for "run" (belt, zip, leg it, hotfoot it) come back in a separate group from the
+     * neutral ones (sprint, race, dart, dash), and a group with no `register` is the neutral case.
+     * `senses` comes back empty when Google has no synonyms for the term.
+     */
+    getSynonyms(args: GetSynonymsArgs): Promise<GoogleTranslateWordSynonyms>;
+
+    /**
+     * The other ways Google would have translated `args.text` — the list that appears when a
+     * person clicks a translated phrase to see what else it could have said. Works on a whole
+     * sentence, not just a word: `args.text` splits into `segments`, one per sentence Google
+     * recognizes, each carrying its own `alternatives` — the unit of the answer is the SEGMENT,
+     * never the whole input. `args.from` is optional and, left out, the source is detected, same
+     * as `translate`.
+     */
+    getAlternativeTranslations(args: GetAlternativeTranslationsArgs): Promise<GoogleTranslateAlternativeTranslations>;
+
+    /**
+     * Google Translate's own "Did you mean …" line for `args.text`, written in `args.language` —
+     * `correct: true` when nothing needed fixing, otherwise the corrected text plain and
+     * HTML-marked-up. What a caller runs before trusting a translation of something a human typed
+     * in a hurry.
+     */
+    checkSpelling(args: CheckSpellingArgs): Promise<GoogleTranslateSpellCheck>;
+
+    /**
+     * A Latin-alphabet (or phonetic) rendering of `args.text` or its translation —
+     * "Ohayōgozaimasu, ogenkidesuka?" under a Japanese translation, "rən" under the English word
+     * "run". `targetRomanization` comes back when the TARGET script is non-Latin,
+     * `sourceRomanization` when the SOURCE is — measured 2026-09-16, that includes a short
+     * Latin-script dictionary lookup, which still carries an English pronunciation guide. Both are
+     * absent on an ordinary sentence between two Latin-script languages, which is a normal answer,
+     * not a failure. `args.from` is optional and, left out, the source is detected, same as
+     * `translate`.
+     */
+    romanize(args: RomanizeArgs): Promise<GoogleTranslateRomanization>;
+
+    /**
+     * Hear `args.text` spoken in `args.language`, as the MP3 the site's own speaker button plays.
+     * Google's `/translate_tts` refuses anything over 200 characters with a hard 400, so this
+     * function chunks longer text on SENTENCE boundaries (never mid-sentence) and stitches the
+     * resulting MP3s into one file — confirmed 2026-09-16 that concatenating raw `/translate_tts`
+     * bytes decodes as one continuous, correctly-timed clip, since the door answers a bare MPEG
+     * stream with no container. `chunkCount` says how many `/translate_tts` calls the answer is
+     * built from. Throws when a single SENTENCE in `args.text` is itself over 200 characters —
+     * there is no boundary left to chunk on, and truncating it silently is the one thing this
+     * function must not do.
+     */
+    speak(args: SpeakArgs): Promise<GoogleTranslateSpeech>;
+  }
+}
+
 declare namespace BowmarkProvider_gostoreit {
   // ── Go Store It — the unit's own declarations, verbatim ──
 interface GetFacilityUnitsArgs { facilityUrl: string; }
@@ -15608,6 +17616,14 @@ interface HavenPricingProgram {
 
 interface HavenPricingProgramsResult { programs: HavenPricingProgram[] }
 
+interface HavenListPricingProgramsResult {
+  property: HavenPropertyDetails;
+  state: string | null;      // read off the caller's own address, e.g. "CA"
+  programs: HavenPricingProgram[]; // filtered to what `state` qualifies for
+}
+
+interface HavenListPricingProgramsArgs { address: string }
+
   /**
    * Haven Energy home battery quoting — read a US address's own property attributes (home size,
    * county, energy-community status) the way Haven's /quote flow does, and read the site's own
@@ -15633,6 +17649,16 @@ interface HavenPricingProgramsResult { programs: HavenPricingProgram[] }
      * county/utility context to narrow to the programs a specific home actually qualifies for.
      */
     getPricingPrograms(): Promise<HavenPricingProgramsResult>;
+
+    /**
+     * One call for the question getPropertyDetails + getPricingPrograms need composing to answer:
+     * which of Haven's active programs does THIS address actually qualify for. Reads the property
+     * attributes and the full program table (the same two live calls the two other functions make)
+     * and filters to the state parsed out of the address string. `state` is null and `programs` is
+     * the full unfiltered table when no 2-letter state code could be read from the address —
+     * Haven's own property-details response never returns one to fall back on.
+     */
+    listPricingPrograms(arg0: HavenListPricingProgramsArgs): Promise<HavenListPricingProgramsResult>;
   }
 }
 
@@ -15697,6 +17723,32 @@ interface HaydenhomesSearchFilters {
   }
 }
 
+declare namespace BowmarkProvider_hccts {
+  // ── hccts.org Online Application Appointment Booking — the unit's own declarations, verbatim ──
+interface ApplicationStatus {
+  available: boolean;
+  formUrl: string;
+  message: string;
+  lastChecked: string;
+}
+
+interface CheckApplicationAvailabilityArgs {
+  refresh?: boolean;
+}
+
+  /**
+   * Checks application availability and appointment scheduling for Highlands' adult education
+   * programs.
+   */
+  interface Unit {
+    /**
+     * Checks if the HCCTS online application form is currently accessible and returns the
+     * application status.
+     */
+    checkApplicationAvailability(args: CheckApplicationAvailabilityArgs): Promise<ApplicationStatus>;
+  }
+}
+
 declare namespace BowmarkProvider_healthcare_gov {
   // ── HealthCare.gov — the unit's own declarations, verbatim ──
 interface healthcare_govPlan {
@@ -19229,12 +21281,14 @@ interface KeepaProduct { asin: string; domainId: number; title: string; csv?: un
 
   /**
    * Keepa's documented Amazon product API — reads a product's native price history and metadata
-   * by ASIN. Requires a caller-provided Keepa API key.
+   * by ASIN. Uses Bowmark's Keepa key and charges each request to your account; send your own
+   * key as the `x-bowmark-vendor-key-keepa` header to spend your own Keepa tokens instead.
    */
   interface Unit {
     /**
      * Reads Keepa's native Amazon product record and compact price-history series for one ASIN.
-     * Requires a caller-provided Keepa API key.
+     * Uses Bowmark's Keepa key and charges each request to your account; send your own key as the
+     * `x-bowmark-vendor-key-keepa` header to spend your own Keepa tokens instead.
      */
     getProduct(args: { asin: string; domain?: number; stats?: number }): Promise<KeepaProductResult>;
   }
@@ -20627,7 +22681,7 @@ interface LululemonProductAttributes {
   /** The site's own ProductGroup category, e.g. "Leggings". */
   category: string | null;
   description: string | null;
-  /** Trademarked fabric names off the detail accordion, e.g. ["Nulu"]. */
+  /** Trademarked fabric names off the product-detail region, e.g. ["Nulu"]. */
   fabrics: string[];
   fit: string | null;
   /** "High-Rise" / "Mid-Rise" / "Low-Rise", as the title spells it. */
@@ -24895,6 +26949,357 @@ interface PremierbuildingsDealer {
   }
 }
 
+declare namespace BowmarkProvider_prime_video {
+  // ── Prime Video — the unit's own declarations, verbatim ──
+interface PrimeVideoTitle {
+  titleId: string;
+  catalogId: string | null;
+  title: string;
+  url: string;
+  entityType: string | null;
+  releaseYear: number | null;
+  maturityRating: string | null;
+  entitled: boolean;
+  watchMessage: string | null;
+}
+interface PrimeVideoTitleSuggestion {
+  value: string;
+}
+interface PrimeVideoWatchOffer {
+  kind: "rent" | "buy" | "subscribe";
+  label: string;
+  price: { currency: string; value: string } | null;
+  quality: "SD" | "HD" | "UHD" | null;
+  channel: { benefitId: string; link: string } | null;
+}
+interface PrimeVideoWatchOptions {
+  titleId: string;
+  entitlementType: "Entitled" | "Unentitled";
+  entitled: boolean;
+  message: string;
+  channel: { name: string; link: string } | null;
+  offers: PrimeVideoWatchOffer[];
+}
+interface PrimeVideoSeason {
+  seasonId: string;
+  seasonLink: string;
+  displayName: string;
+  sequenceNumber: number;
+  seasonSelectorIcon: string | null;
+}
+interface PrimeVideoCredit {
+  name: string;
+  searchLink: string | null;
+}
+interface PrimeVideoRatingBucket {
+  stars: 1 | 2 | 3 | 4 | 5;
+  percentage: number;
+}
+interface PrimeVideoTitleDetail {
+  titleId: string;
+  catalogId: string | null;
+  title: string;
+  seriesTitle: string | null;
+  seasonNumber: number | null;
+  titleType: string | null;
+  synopsis: string | null;
+  releaseYear: number | null;
+  releaseDate: string | null;
+  runtime: string | null;
+  genres: string[];
+  maturityRating: string | null;
+  cast: PrimeVideoCredit[];
+  directors: PrimeVideoCredit[];
+  studios: string[];
+  amazonRating: { value: number; count: number } | null;
+  ratingsHistogram: PrimeVideoRatingBucket[];
+  imdbScore: number | null;
+  audioTracks: string[];
+  subtitles: string[];
+  isUhd: boolean;
+  isHdr: boolean;
+  isDolbyVision: boolean;
+  isDolbyAtmos: boolean;
+  isXRay: boolean;
+  isClosedCaption: boolean;
+  isPrime: boolean;
+  isAd: boolean;
+}
+interface PrimeVideoEpisode {
+  titleId: string | null;
+  episodeNumber: number;
+  title: string;
+  synopsis: string | null;
+  runtime: string | null;
+  durationSeconds: number | null;
+  releaseDate: string | null;
+  releaseYear: number | null;
+  images: { packshot: string | null; covershot: string | null };
+  audioTracks: string[];
+  subtitles: string[];
+  isUhd: boolean;
+  isHdr: boolean;
+  isDolbyVision: boolean;
+  isDolbyAtmos: boolean;
+  isXRay: boolean;
+  isClosedCaption: boolean;
+  isPrime: boolean;
+  isAd: boolean;
+}
+interface PrimeVideoCategory {
+  name: string;
+  slug: string;
+  kind: "genre" | "collection" | "storefront";
+  path: string;
+}
+interface PrimeVideoCategoryRow {
+  heading: string;
+  titles: PrimeVideoTitle[];
+}
+interface PrimeVideoTop10Entry extends PrimeVideoTitle {
+  position: number;
+  list: "tv" | "movies" | "channel";
+}
+interface PrimeVideoChannel {
+  name: string;
+  channelId: string | null;
+  benefitId: string | null;
+  synopsis: string | null;
+  offerMessage: string | null;
+}
+interface PrimeVideoChannelDetail {
+  name: string;
+  rows: PrimeVideoCategoryRow[];
+}
+interface PrimeVideoLiveProgram {
+  title: string;
+  seriesTitle: string | null;
+  start: number;
+  end: number;
+}
+interface PrimeVideoLiveStation {
+  id: string;
+  name: string;
+  logo: string | null;
+  group: string;
+  nowPlaying: PrimeVideoLiveProgram | null;
+}
+
+  /**
+   * Search Prime Video's catalogue and read a film or series the way a viewer does — synopsis,
+   * cast, rating, seasons and episodes — and above all say how it can actually be watched:
+   * included with Prime, free with ads, on a named add-on channel, or rentable and buyable with
+   * the real price. Plus the browse surfaces (genres, collections, the top ten, this week's
+   * deals), the add-on channels, and the free live TV, news and sports schedules. searchTitles,
+   * suggestTitles, getTitle, getWatchOptions, listSeasons, listEpisodes and listCategories are
+   * built; everything else is still a declared stub.
+   */
+  interface Unit {
+    /**
+     * Search Prime Video's whole catalogue for what a person would type — "matrix", "the boys" —
+     * and get back the title cards the site itself ranks: display title, the titleId every other
+     * function here takes, whether it is a film or a series, the year, the maturity rating, and
+     * the site's own sentence for how to watch it. THE provider's door: every titleId-taking
+     * function below is fed by this one. Returns the FIRST page only — Prime Video's search page
+     * carries no pagination markers at all (measured 2026-09-15) — and the site's six refinement
+     * filters (film-or-series, how you can watch it, which channel, HD/UHD, theme, audio language)
+     * are not built here: they ride an opaque per-page `serviceToken`, not a query parameter, and
+     * a query parameter silently returns the unfiltered set rather than erroring. A query that
+     * matches nothing returns an empty array rather than throwing.
+     */
+    searchTitles(query: string): Promise<PrimeVideoTitle[]>;
+
+    /**
+     * Ask Prime Video's own search box what it would autocomplete a prefix to — "the boy" comes
+     * back as "the boys", "the boy", "the boy and the heron". What an agent holding a
+     * half-remembered title calls before it commits to a search, and the cheapest call in the
+     * provider.
+     */
+    suggestTitles(prefix: string): Promise<PrimeVideoTitleSuggestion[]>;
+
+    /**
+     * Read one film, series-season or episode the way a viewer reads its page: title, synopsis,
+     * year, release date, runtime, genres, maturity rating, cast, directors, studio, the Amazon
+     * customer rating and its five-star histogram, the IMDb score, which audio languages and
+     * subtitles it ships, and whether it is in UHD, HDR, Dolby Atmos or X-Ray. The core read of
+     * the whole provider. Takes a titleId or a title URL, e.g. one read off searchTitles(). THE
+     * REVIEW TEXT IS NOT HERE — the aggregate rating and histogram are real and logged out, but
+     * review bodies are amazon.com's own surface behind amazon.com's sign-in wall.
+     */
+    getTitle(titleId: string): Promise<PrimeVideoTitleDetail>;
+
+    /**
+     * Say how you would actually watch a title: included with your Prime membership, free with
+     * ads, on an add-on channel you would have to subscribe to (and which one), or available to
+     * rent or buy — and when it is rent-or-buy, every offer with its real price and quality. THE
+     * question this provider exists to answer, and the one no general search result answers about
+     * Amazon's catalogue. Takes a titleId or a title URL, e.g. one read off searchTitles() or
+     * getTitle(). Reads the SAME page as getTitle, never fetches it twice. Placing any of these
+     * orders is never a function of this provider — a flow that costs money stops before the
+     * payment step, always.
+     */
+    getWatchOptions(titleId: string): Promise<PrimeVideoWatchOptions>;
+
+    /**
+     * List every season of a series with the titleId that opens each one, its number, its display
+     * name, and whether it needs paying for beyond what the current season needs. What an agent
+     * needs when the person said "season 4" and the search returned whichever season Prime Video
+     * ranked first. Takes a titleId or a title URL, e.g. one read off searchTitles() or
+     * getTitle(). Reads the SAME cached page as getTitle and getWatchOptions, never fetches it
+     * twice. A film returns an empty array — a real, measured answer, since a film's own /detail/
+     * page carries no seasons at all.
+     */
+    listSeasons(titleId: string): Promise<PrimeVideoSeason[]>;
+
+    /**
+     * List a season's episodes with number, title, synopsis, runtime, release date, artwork, and
+     * the audio and subtitle languages each one ships. The read behind "what happens in episode 3"
+     * and "how long is the finale". Takes the SEASON's titleId — one read off listSeasons() or
+     * getTitle() — or a title URL. Reads the SAME cached page as getTitle, getWatchOptions and
+     * listSeasons, never fetches it twice; episodes come with whichever season is selected, so
+     * reading another season means calling this on THAT season's own titleId, off listSeasons(). A
+     * film returns an empty array — a real, measured answer, matching listSeasons() on the same
+     * title.
+     */
+    listEpisodes(titleId: string): Promise<PrimeVideoEpisode[]>;
+
+    /**
+     * List the ways Prime Video lets you browse — its genres (action, comedy, horror, anime,
+     * documentary and more, plus kids), its editorial collections (new and upcoming, award
+     * winners, free to watch) and its storefronts (movies, TV, store, sports, news, live TV,
+     * subscriptions) — each with the token the browse function below this one in the queue takes.
+     * The door for every browse read here: an agent holding the word "horror" can reach a real
+     * listing without being told a URL. Every row carries `name` (the site's own display text),
+     * `slug` (the literal, inconsistently-cased path token — "science-fiction", "mgForYou" — never
+     * guess its casing) and `kind`. Resolve a caller's typed word against `name`, never `slug`.
+     */
+    listCategories(): Promise<PrimeVideoCategory[]>;
+
+    /**
+     * Browse one genre, collection or storefront and get its rows of titles back — "what horror is
+     * on Prime Video", "what is in the free-with-ads collection" — each row carrying the site's
+     * own heading ("Popular movies", "Free comedy movies") and every title under it in the site's
+     * own order, with the same fields searchTitles() returns. Takes a `path` off listCategories(),
+     * e.g. "/genre/comedy", "/collection/streamfree", "/movie", "/tv" or "/store" — those five are
+     * the only shapes this pass measured. Drops the leading, unheaded hero carousel every
+     * storefront page opens with; every other row is real. Returns the FIRST page only, exactly
+     * like searchTitles() — these pages carry no pagination markers either.
+     */
+    listCategoryTitles(path: string): Promise<PrimeVideoCategoryRow[]>;
+
+    /**
+     * What has just arrived on Prime Video and what is coming — the read behind "anything new
+     * worth watching", which a genre browse can never answer because a genre ranks by popularity
+     * and this ranks by recency. Same row shape as listCategoryTitles(): a heading ("Premium New
+     * Releases", "Recently added to Prime – Movies") and every title under it. No arguments — this
+     * is a named call over listCategoryTitles' own parser, pointed at the site's own newness
+     * surfaces (`/collection/newandupcoming` plus `/tv`'s "Explore: Latest TV" row) rather than a
+     * caller-supplied path. Prime Video publishes no logged-out "leaving soon" surface — none of
+     * "leaving", "expires", "available until" or "last chance" appear anywhere the survey read —
+     * so there is no sibling function for that half of the question.
+     */
+    listNewReleases(): Promise<PrimeVideoCategoryRow[]>;
+
+    /**
+     * What you can watch on Prime Video without paying anything at all — the free-with-ads
+     * catalogue, a different answer from "included with Prime" and the honest one for a caller
+     * with no Amazon subscription. No arguments — `GET /collection/streamfree`, filtered
+     * card-by-card to the site's own `freewithads` entitlement marker rather than trusted by row
+     * heading: a "Free popular TV" row on that page mixes titles a visitor with no subscription
+     * can watch with titles that need Prime, and both carry the identical "Watch for free" message
+     * and "Entitled" verdict, so the row heading alone cannot tell them apart (measured
+     * 2026-09-16: 8 of 20 cards on that row are Prime-included, not free-with-ads). A row whose
+     * cards are all Prime-included, not free-with-ads, is dropped rather than returned empty.
+     */
+    listFreeToWatch(): Promise<PrimeVideoCategoryRow[]>;
+
+    /**
+     * Prime Video's own top ten right now — the most-watched TV shows in the US ("tv", off `/tv`),
+     * the top films to rent or buy ("movies", off `/store`), or the top ten on one add-on channel
+     * ("channel", off that channel's own page — pass its uuid as `channelId`, e.g. one read off
+     * listChannels() or a channel URL). The read behind "what is everyone watching", and one
+     * search can never give you, because search ranks by relevance and this ranks by what is
+     * actually being played. Every row carries `position` (the card's own 1-based rank within that
+     * list — Prime Video never prints a rank number, so this is the card's own order) and `list`
+     * (which of the three it came from) alongside the same fields searchTitles() returns; a merged
+     * top ten that does not say whether it means streaming or renting is a wrong answer wearing a
+     * right one. **The row is intermittent** — measured this build pass, three spaced captures of
+     * `/tv` in one minute carried it on only one — so a request that lands without it returns
+     * `[]`, a real and honest answer, never an error.
+     */
+    listTop10(list: "tv" | "movies" | "channel", channelId?: string): Promise<PrimeVideoTop10Entry[]>;
+
+    /**
+     * What is discounted to rent or buy on Prime Video this week — "Prime deals this week", "New
+     * release deals", time-boxed sales and film bundles — the read behind "how do I watch this"
+     * when the answer turns out to be "buy it" and the follow-up is "is it cheaper right now". No
+     * arguments — `GET /store/deals`, read with the same listCategoryTitles() parser: same row
+     * shape (a heading and every title under it), same dropped leading hero carousel. **Carries no
+     * price.** Exactly three dollar strings exist on the whole page and all three are a row
+     * heading ("$15.99 or less TV deals"), never a per-title price, so a caller who wants the
+     * number calls getWatchOptions() on a titleId from one of these rows, where the price comes
+     * off a decoded offerToken rather than a scraped string.
+     */
+    listDeals(): Promise<PrimeVideoCategoryRow[]>;
+
+    /**
+     * List the add-on subscriptions Prime Video sells inside itself — HBO Max, Paramount+,
+     * Britbox, ViX Premium and seventy-odd more — with the two ids each one is addressed by:
+     * `channelId`, which opens the channel's own page (getChannel(), listTop10("channel",
+     * channelId)), and `benefitId`, which `GET /offers?benefitId=<benefitId>` takes to start a
+     * subscription. The door for getChannel() and the thing that turns getWatchOptions' "get an
+     * add-on subscription" into a named service a person can decide about. No arguments — `GET
+     * /addons`, read off the "Subscriptions you might like" row with the shared hydration parser.
+     * **Carries no price.** The two dollar strings on the whole page are a card's own compact
+     * offer wording, never a clean number, so `offerMessage` carries the site's own sentence
+     * instead. Most cards carry both ids; a card with no channel page of its own (CNN All Access)
+     * carries only `benefitId`, and one further outlier (NBA League Pass, a subscription pass
+     * rather than a channel) carries neither — both real, measured gaps, never a guess.
+     */
+    listChannels(): Promise<PrimeVideoChannel[]>;
+
+    /**
+     * Read one add-on channel: what it is called, its top ten, its originals and series, and the
+     * live events it is carrying — the rest of a channel's catalogue, for answering "is it worth
+     * subscribing to this to watch that" rather than one title. Takes the channel's uuid off
+     * listChannels(), e.g. one read off `channelId` there — NOT the same card's `benefitId`, which
+     * opens a different route. `GET /channel/<uuid>`, read off the same carousel parser
+     * listCategoryTitles() uses: a heading and every title under it, per row, in the site's own
+     * order. `rows` never includes the channel's own hero banner, which carries no title list of
+     * its own.
+     */
+    getChannel(channelId: string): Promise<PrimeVideoChannelDetail>;
+
+    /**
+     * List the free live TV ("livetv", off `/livetv`) or news ("news", off `/news`) stations Prime
+     * Video streams — their name, their logo, the id that addresses them, which row they are
+     * grouped under (on `/livetv` the channel selling them, "Prime" or "AMC+"; on `/news` a topic
+     * like "National news"), and what is on each one right now. The half of this site that has
+     * nothing to do with the on-demand catalogue. `nowPlaying` is derived by walking the station's
+     * own schedule for the entry covering this moment, never read off a per-entry badge — measured
+     * 2026-09-16, every schedule entry on both pages carries the identical `linearBadge: {label:
+     * "ON NOW"}` whether or not it is actually airing, so that field cannot say which slot is
+     * current. `nowPlaying` is `null`, a real answer, when no entry covers this instant. A station
+     * whose card appears on more than one row on the same page (an unheaded hero container
+     * duplicating a station a headed row below it already carries) is returned once, off the
+     * headed row — an unheaded container is dropped whole.
+     */
+    listLiveChannels(section: "livetv" | "news"): Promise<PrimeVideoLiveStation[]>;
+
+    /**
+     * Read one live TV or news station's FULL schedule — every program the page carries for it, in
+     * order, never filtered to what is on now (that single entry is `listLiveChannels()`'s own
+     * `nowPlaying`). `start` and `end` are EPOCH MILLISECONDS, never the page's
+     * `localizedTimeRange` ("9 - 9:30 AM EDT"), which is rendered for Amazon's assumed timezone
+     * and useless to a caller in another one. Takes the SAME `section` `listLiveChannels(section)`
+     * was called with and a `stationId` read off one of its rows — `/livetv` and `/news` carry
+     * different stations, so a `livetv` id will not resolve on `/news`. Refuses (caller-fixable)
+     * when the page carries no station with that id.
+     */
+    getLiveSchedule(section: "livetv" | "news", stationId: string): Promise<PrimeVideoLiveProgram[]>;
+  }
+}
+
 declare namespace BowmarkProvider_progressive {
   // ── Progressive — the unit's own declarations, verbatim ──
 // Progressive's OWN shapes — not a capability contract.
@@ -27356,6 +29761,47 @@ interface SemihandmadePriceResult {
   }
 }
 
+declare namespace BowmarkProvider_serper {
+  // ── Serper — the unit's own declarations, verbatim ──
+interface SerperOrganicResult {
+  position: number;
+  title: string;
+  link: string;              // the destination url
+  snippet: string | null;
+  date: string | null;
+}
+
+interface SerperSearchOptions {
+  num?: number;              // 1-100, default 10
+  gl?: string;               // country, e.g. "us"
+  hl?: string;               // language, e.g. "en"
+}
+
+interface SerperSearchResult {
+  query: string;
+  results: SerperOrganicResult[];   // empty only when Google matched nothing
+  credits: number | null;           // Serper credits this search spent
+  warnings: string[];
+}
+
+  /**
+   * Google's own search results as JSON through Serper's API — honours site:, quoted phrases and
+   * every other Google operator, in about a second. Uses Bowmark's Serper key and charges each
+   * search to your account, or your own key sent as the `x-bowmark-vendor-key-serper` header.
+   */
+  interface Unit {
+    /**
+     * Runs a Google search and returns Google's organic results — position, title, destination
+     * url, snippet — with every Google operator honoured. `site:cal.com "Chris Field"` returns
+     * only cal.com pages naming him (cal.com/analytics/quick-chat among them), which is how to
+     * find a page on one site by any words printed on it. An empty `results` is Google matching
+     * nothing. Uses Bowmark's Serper key and charges each search to your account; send your own
+     * key as the `x-bowmark-vendor-key-serper` header to spend your own credits instead.
+     */
+    searchGoogle(query: string, opts?: SerperSearchOptions): Promise<SerperSearchResult>;
+  }
+}
+
 declare namespace BowmarkProvider_sitmeanssit {
   // ── Sit Means Sit — the unit's own declarations, verbatim ──
 interface SitmeanssitLocation {
@@ -27699,6 +30145,88 @@ interface ScPlaylist {
   }
 }
 
+declare namespace BowmarkProvider_speedrun {
+  // ── speedrun.com — the unit's own declarations, verbatim ──
+interface FindGameArgs {
+  name: string;
+}
+
+interface CategoriesArgs {
+  gameId: string;
+}
+
+interface PlatformsArgs {
+  gameId?: string;
+}
+
+interface Game {
+  id: string;
+  names: { international: string; japanese?: string };
+  abbreviation: string;
+  weblink: string;
+  released: number;
+  "release-date": string;
+  platforms?: string[];
+  ruleset?: { "require-video": boolean; "require-verification": boolean; "show-milliseconds": boolean };
+}
+
+interface Category {
+  id: string;
+  name: string;
+  weblink: string;
+  type: string;            // "per-game" | "per-level"
+  rules?: string;
+  players?: { type: string; value?: number }
+  miscellaneous?: boolean; // hidden from the default leaderboard view
+  variables?: { data: CategoryVariable[] }
+}
+
+interface CategoryVariable {
+  id: string;
+  name: string;
+  mandatory: boolean;
+  "user-defined": boolean;
+  // submitRun takes the KEY of a choice, never its label
+  values?: { choices?: Record<string, { label: string }>; default?: string }
+}
+
+interface Platform {
+  id: string;
+  name: string;
+  released?: number;
+}
+
+  /** Submit speedruns and search game metadata on speedrun.com */
+  interface Unit {
+    /**
+     * Searches games by name and returns the matches with the metadata every other call here needs
+     * — the opaque `id`, the abbreviation, the weblink, the platform ids, and the `ruleset` that
+     * says whether a video is required and whether milliseconds are shown. Start here:
+     * speedrun.com addresses everything by id and nothing by title. The search is fuzzy and
+     * ranked, so read the first row rather than assuming one match, and an unknown title returns
+     * an empty array rather than an error.
+     */
+    findGame(args: FindGameArgs): Promise<Game[]>;
+
+    /**
+     * Lists every category for one game, with the variables each one carries. The `variables`
+     * block is the part that matters before a submit: a category with a `mandatory` variable
+     * rejects a run that omits it, and the accepted values are the keys of `values.choices`, not
+     * their labels. `type` separates a per-game category from a per-level one, and
+     * `is-miscellaneous` marks the ones the leaderboard hides by default.
+     */
+    categories(args: CategoriesArgs): Promise<Category[]>;
+
+    /**
+     * Lists platforms as `{ id, name, released }` — called with no argument it returns the whole
+     * speedrun.com platform table, and with a `gameId` only the platforms that game accepts.
+     * Prefer the `gameId` form when you need the platform a specific game accepts — the whole
+     * table is ~140 rows and most of them are not playable for any one game.
+     */
+    platforms(args?: PlatformsArgs): Promise<Platform[]>;
+  }
+}
+
 declare namespace BowmarkProvider_spirithalloween {
   // ── Spirit Halloween — the unit's own declarations, verbatim ──
 interface SpiritHalloweenSearchResult {
@@ -30152,6 +32680,99 @@ type TwiddyQuote =
   }
 }
 
+declare namespace BowmarkProvider_twitch {
+  // ── Twitch — the unit's own declarations, verbatim ──
+interface TwitchVideo {
+  id: string;
+  title: string;
+  /** Seconds. For a live archive this GROWS, trailing real time by a minute or two. */
+  lengthSeconds: number;
+  /** "RECORDING" while the broadcast is live, "RECORDED" after. */
+  status: string;
+  /** "ARCHIVE" (a past broadcast), "HIGHLIGHT" or "UPLOAD". */
+  type: string;
+  createdAt: string;
+  ownerLogin: string;
+  url: string;
+}
+interface GetVideoArgs {
+  /** A Twitch video id, or a twitch.tv/videos/<id> link. */
+  vodId: string;
+}
+interface CreateHighlightArgs {
+  /** The broadcast to cut from — an id or a twitch.tv/videos/<id> link. Omit it
+   * for the signed-in channel's NEWEST archive, which during a broadcast is the
+   * live one. */
+  vodId?: string;
+  /** Seconds into that video. Rounded outward to whole seconds. */
+  startSeconds: number;
+  endSeconds: number;
+  title: string;
+  description?: string;
+  /** Default "en". */
+  language?: string;
+  tags?: string[];
+  /** Category name, e.g. "Wetrix". */
+  game?: string;
+}
+interface TwitchHighlight {
+  /** "created" by this call; "existing" when a highlight with this exact title
+   * was already on the channel (nothing new made); "unknown" when the request
+   * went out and no answer came back — check dashboardUrl before retrying. */
+  status: "created" | "existing" | "unknown";
+  highlightId: string | null;
+  url: string | null;
+  title: string;
+  vodId: string;
+  startSeconds: number;
+  endSeconds: number;
+  channel: string;
+  dashboardUrl: string;
+}
+interface RegisterDeveloperAppArgs {
+  /** Application name */
+  name: string;
+  /** OAuth redirect URI(s), comma-separated if multiple */
+  redirectUri: string;
+  /** "Application Integration" or "Website Integration" */
+  category: string;
+  /** "Public" or "Confidential" */
+  clientType?: string;
+}
+interface TwitchDeveloperApp {
+  clientId: string;
+  clientSecret?: string;
+  name: string;
+  redirectUri: string;
+  dashboardUrl: string;
+}
+
+  /**
+   * Twitch — cut a Highlight of your own broadcast, including the one still live, and read any
+   * public video's length and status.
+   */
+  interface Unit {
+    /**
+     * Reads one public Twitch video by id or twitch.tv/videos link — title, length in seconds,
+     * whether it is still RECORDING (a live broadcast's archive) or RECORDED, its type (ARCHIVE,
+     * HIGHLIGHT, UPLOAD) and its channel. No sign-in. THROWS naming the id when Twitch has no such
+     * video.
+     */
+    getVideo(args: GetVideoArgs): Promise<TwitchVideo>;
+
+    /**
+     * Cuts a permanent Highlight from the signed-in streamer's own broadcast — including the one
+     * still live — between two offsets in seconds, with a title. Omit vodId to cut from the newest
+     * archive. NEEDS the streamer's Twitch sign-in, which only a capability can hold: call it as
+     * bowmark.stream_highlights.create. Idempotent on the title: a highlight whose title already
+     * exists on the channel is returned with status "existing" rather than made twice. Refuses,
+     * without asking for a sign-in, a vod id Twitch does not have or an end offset past what the
+     * live archive has recorded so far (retry shortly in that case).
+     */
+    createHighlight(args: CreateHighlightArgs): Promise<TwitchHighlight>;
+  }
+}
+
 declare namespace BowmarkProvider_uhc_smallbusiness {
   // ── UnitedHealthcare Small Business — the unit's own declarations, verbatim ──
 interface UhcSmallbusinessPlan {
@@ -32576,6 +35197,7 @@ interface BowmarkProviders {
   ajmadison: BowmarkProvider_ajmadison.Unit;
   allied: BowmarkProvider_allied.Unit;
   alphavantage: BowmarkProvider_alphavantage.Unit;
+  amazon: BowmarkProvider_amazon.Unit;
   americandreamvacations: BowmarkProvider_americandreamvacations.Unit;
   americanstandard: BowmarkProvider_americanstandard.Unit;
   americanvisionwindows: BowmarkProvider_americanvisionwindows.Unit;
@@ -32586,6 +35208,7 @@ interface BowmarkProviders {
   anthropic_com: BowmarkProvider_anthropic_com.Unit;
   antunes: BowmarkProvider_antunes.Unit;
   aosom: BowmarkProvider_aosom.Unit;
+  app_store: BowmarkProvider_app_store.Unit;
   apple: BowmarkProvider_apple.Unit;
   aquaphoenixsci: BowmarkProvider_aquaphoenixsci.Unit;
   arajet: BowmarkProvider_arajet.Unit;
@@ -32690,6 +35313,7 @@ interface BowmarkProviders {
   cruiselakegeneva: BowmarkProvider_cruiselakegeneva.Unit;
   culturefly: BowmarkProvider_culturefly.Unit;
   curiocity: BowmarkProvider_curiocity.Unit;
+  currency_exchange: BowmarkProvider_currency_exchange.Unit;
   cyberpowerpc: BowmarkProvider_cyberpowerpc.Unit;
   dahlconsulting: BowmarkProvider_dahlconsulting.Unit;
   dansons: BowmarkProvider_dansons.Unit;
@@ -32697,6 +35321,7 @@ interface BowmarkProviders {
   deangroup: BowmarkProvider_deangroup.Unit;
   decked: BowmarkProvider_decked.Unit;
   decksdirect: BowmarkProvider_decksdirect.Unit;
+  dell: BowmarkProvider_dell.Unit;
   deltadentalma: BowmarkProvider_deltadentalma.Unit;
   dentalplans: BowmarkProvider_dentalplans.Unit;
   detailxperts: BowmarkProvider_detailxperts.Unit;
@@ -32754,6 +35379,9 @@ interface BowmarkProviders {
   goloadup: BowmarkProvider_goloadup.Unit;
   goodway: BowmarkProvider_goodway.Unit;
   google_flights: BowmarkProvider_google_flights.Unit;
+  google_maps: BowmarkProvider_google_maps.Unit;
+  google_news: BowmarkProvider_google_news.Unit;
+  google_translate: BowmarkProvider_google_translate.Unit;
   gostoreit: BowmarkProvider_gostoreit.Unit;
   gotchacovered: BowmarkProvider_gotchacovered.Unit;
   grainger: BowmarkProvider_grainger.Unit;
@@ -32767,6 +35395,7 @@ interface BowmarkProviders {
   hauslabs: BowmarkProvider_hauslabs.Unit;
   havenenergy: BowmarkProvider_havenenergy.Unit;
   haydenhomes: BowmarkProvider_haydenhomes.Unit;
+  hccts: BowmarkProvider_hccts.Unit;
   healthcare_gov: BowmarkProvider_healthcare_gov.Unit;
   heatherwood: BowmarkProvider_heatherwood.Unit;
   hellofresh: BowmarkProvider_hellofresh.Unit;
@@ -32875,6 +35504,7 @@ interface BowmarkProviders {
   positivegrid: BowmarkProvider_positivegrid.Unit;
   postiz: BowmarkProvider_postiz.Unit;
   premierbuildings: BowmarkProvider_premierbuildings.Unit;
+  prime_video: BowmarkProvider_prime_video.Unit;
   progressive: BowmarkProvider_progressive.Unit;
   prolook: BowmarkProvider_prolook.Unit;
   prose: BowmarkProvider_prose.Unit;
@@ -32903,6 +35533,7 @@ interface BowmarkProviders {
   selectblinds: BowmarkProvider_selectblinds.Unit;
   sellcell: BowmarkProvider_sellcell.Unit;
   semihandmade: BowmarkProvider_semihandmade.Unit;
+  serper: BowmarkProvider_serper.Unit;
   sitmeanssit: BowmarkProvider_sitmeanssit.Unit;
   sixflags: BowmarkProvider_sixflags.Unit;
   smartsign: BowmarkProvider_smartsign.Unit;
@@ -32910,6 +35541,7 @@ interface BowmarkProviders {
   smithery: BowmarkProvider_smithery.Unit;
   solostove: BowmarkProvider_solostove.Unit;
   soundcloud: BowmarkProvider_soundcloud.Unit;
+  speedrun: BowmarkProvider_speedrun.Unit;
   spirithalloween: BowmarkProvider_spirithalloween.Unit;
   starlighthomes: BowmarkProvider_starlighthomes.Unit;
   statefarm: BowmarkProvider_statefarm.Unit;
@@ -32941,6 +35573,7 @@ interface BowmarkProviders {
   tryalma_com: BowmarkProvider_tryalma_com.Unit;
   tweethunter: BowmarkProvider_tweethunter.Unit;
   twiddy: BowmarkProvider_twiddy.Unit;
+  twitch: BowmarkProvider_twitch.Unit;
   uhc_smallbusiness: BowmarkProvider_uhc_smallbusiness.Unit;
   ulrichlifestyle: BowmarkProvider_ulrichlifestyle.Unit;
   upkeepstl_com: BowmarkProvider_upkeepstl_com.Unit;
@@ -84690,11 +87323,13 @@ interface BowmarkProviders {
  * `run()` script, and the Proxy over HTTP in a caller's own process. They are
  * generated once precisely so those two cannot drift. */
 interface BowmarkLibrary {
+  booking_links: BowmarkCapability_booking_links.Unit;
   bundles: BowmarkCapability_bundles.Unit;
   cable_railing_quote: BowmarkCapability_cable_railing_quote.Unit;
   cars: BowmarkCapability_cars.Unit;
   costume_size_check: BowmarkCapability_costume_size_check.Unit;
   coworking: BowmarkCapability_coworking.Unit;
+  currency_exchange: BowmarkCapability_currency_exchange.Unit;
   custom_sofa_configurator: BowmarkCapability_custom_sofa_configurator.Unit;
   delivery: BowmarkCapability_delivery.Unit;
   developer_api_key_signup: BowmarkCapability_developer_api_key_signup.Unit;
@@ -84729,6 +87364,7 @@ interface BowmarkLibrary {
   search: BowmarkCapability_search.Unit;
   sheds: BowmarkCapability_sheds.Unit;
   shipping: BowmarkCapability_shipping.Unit;
+  stream_highlights: BowmarkCapability_stream_highlights.Unit;
   tariff: BowmarkCapability_tariff.Unit;
   text_to_speech: BowmarkCapability_text_to_speech.Unit;
   theme_park_tickets: BowmarkCapability_theme_park_tickets.Unit;