@bowmark/web 1.22.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: 629f1aeb04463086ca99af95377a310bbd807733f6a06b36d16890fbc8e3314d
-// 48 capabilities, 410 providers, 1008 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
@@ -582,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>;
   }
 }
 
@@ -2638,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 ──
 
@@ -3855,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 {
@@ -4317,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 {
@@ -4330,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;
@@ -4342,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 {
@@ -4356,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
@@ -4370,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>;
   }
 }
 
@@ -15363,10 +16269,6 @@ interface GooglePriceGraph {
 
 declare namespace BowmarkProvider_google_maps {
   // ── Google Maps — the unit's own declarations, verbatim ──
-interface GoogleMapsPlace {
-  featureId: string;
-  name: string;
-}
 interface SuggestPlacesArgs {
   query: string;
 }
@@ -15391,6 +16293,17 @@ interface GeocodeAddressResult {
   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;
 }
@@ -15417,12 +16330,58 @@ interface Review {
   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 and route. suggestPlaces (autocomplete), searchPlaces (the
-   * door), geocodeAddress, getPlace and listReviews are built; everything else is still a
-   * declared stub.
+   * 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 {
     /**
@@ -15448,6 +16407,17 @@ interface Review {
      */
     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
@@ -15469,11 +16439,67 @@ interface Review {
      * 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;
@@ -15501,12 +16527,55 @@ interface GoogleNewsTopicHeadlines {
   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, and everything indexed about a subject with Google's own when: and site:
-   * operators. searchNews (the door) and topStories are built; everything else is still a
-   * declared stub.
+   * 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 {
     /**
@@ -15518,18 +16587,21 @@ interface GoogleNewsTopicHeadlines {
      * 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.
+     * 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): Promise<GoogleNewsSearchResult>;
+    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". No arguments: the front page is
-     * the whole ask.
+     * 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(): Promise<GoogleNewsTopStories>;
+    topStories(locale?: GoogleNewsLocaleArg): Promise<GoogleNewsTopStories>;
 
     /**
      * The latest headlines in one of Google News' own eight sections — World, Nation, Business,
@@ -15538,9 +16610,372 @@ interface GoogleNewsTopicHeadlines {
      * 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.
+     * 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`.
      */
-    listTopicHeadlines(section: string): Promise<GoogleNewsTopicHeadlines>;
+    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>;
   }
 }
 
@@ -21246,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. */
@@ -25514,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.
@@ -28359,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 {
@@ -30812,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 {
@@ -33236,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;
@@ -33246,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;
@@ -33418,6 +35381,7 @@ interface BowmarkProviders {
   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;
@@ -33540,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;
@@ -33576,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;
@@ -33607,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;
@@ -85397,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;