@bowmark/web 1.24.0 → 1.24.2

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: 0d8827f7a99d497bd9259feb3f5bd13b057c5a6793454c543b7ac1b7c784b9e2
-// 50 capabilities, 419 providers, 1129 typed functions, 20 refused.
+// Manifest version: 8cc406ad353aaf7223bd7938597d0198b89ecc312e3388dff6a1c405b92c38a8
+// 56 capabilities, 434 providers, 1182 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
@@ -217,18 +217,34 @@ type CallOptions = {
 
   /**
    * LAST RESORT, and it costs money: hands a plain-language task to a hosted AI browser agent
-   * (Browser Use) when no Bowmark function covers the site or a script against one failed.
-   * Returns a session id and a private link your user can open to watch and take over the live
-   * browser; later scripts poll it, answer its questions and stop it.
+   * (Browser Use) when no Bowmark function covers the site or a script against one failed. When
+   * it is the only path left, USE it rather than silently declining or only describing it: call
+   * `start`, and in the same reply tell your user it is starting, that it is billed, and give
+   * them the real watchUrl it returns so they can watch and take over (log in, solve a captcha).
+   * A site gated on a login only your user holds is exactly this case, not a reason to stop
+   * short of calling `start` — the watchUrl is how they supply the credential, not something you
+   * need in hand first. Never start a session without your user knowing it happened. **CRITICAL:
+   * one task = one independent goal. Bundle multiple date ranges, product SKUs, or queries into
+   * one task and the agent may silently reuse a single search result across all of them with no
+   * warning. For each distinct item, start a separate session.** RUN-ONLY: a typed session
+   * cannot call it (that is refused with code "run_only", and it is never an API-key problem),
+   * and one run is killed at 120s of wall clock — so `start` in one run and poll `status` from
+   * LATER runs, never in a loop inside one.
    */
   interface Unit {
     /**
      * Starts a hosted browser agent on `task` and returns at once with its session `id` and a
-     * `watchUrl`. Use ONLY after the library had nothing for this site or a function failed — each
-     * turn spends real vendor money, charged to the account. Your account may hold up to 3
-     * concurrent sessions; call `list()` before starting if looping over multiple tasks. Show
-     * `watchUrl` to your user: it lets them watch the agent and take over the browser (log in,
-     * solve a captcha). Then poll with `status`. Always `stop()` a session when done.
+     * `watchUrl`. **CRITICAL: one task = one independent goal.** If you need prices for 5 date
+     * ranges, 5 SKUs, or 5 queries, start 5 separate sessions — bundling them into one task causes
+     * the agent to silently reuse results across different items with no warning. Use ONLY after
+     * the library had nothing for this site or a function failed — each turn spends real vendor
+     * money, charged to the account. Call it, don't just describe it: tell your user you're doing
+     * this and why, in the same reply as calling it — don't wait for permission first just because
+     * it's billed, and don't decide silently on their behalf either. A login only your user holds
+     * is what `watchUrl` is for, not a reason to stop before calling `start`. Your account may
+     * hold up to 3 concurrent sessions; call `list()` before starting if looping over multiple
+     * tasks. Show `watchUrl` to your user: it lets them watch the agent and take over the browser
+     * (log in, solve a captcha). Then poll with `status`. Always `stop()` a session when done.
      */
     start(options: StartBrowserAgentOptions): Promise<StartBrowserAgentResult>;
 
@@ -544,6 +560,34 @@ type CallOptions = {
   }
 }
 
+declare namespace BowmarkCapability_custom_packaging_quote {
+  // ── Custom Packaging Quote — the unit's own declarations, verbatim ──
+interface CustomPackagingQuote {
+  price: { amount: number; currency: string };
+  unitPrice: { amount: number; currency: string };
+}
+
+interface custom_packaging_quoteResult {
+  quotes: CustomPackagingQuote[];
+  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
+}
+
+  /**
+   * Quotes custom printed packaging boxes — shipping boxes, mailer boxes — with real,
+   * quantity-tiered pricing from live configurators.
+   */
+  interface Unit {
+    /** Gets a real, quantity-tiered price for a custom printed box from available suppliers. */
+    quoteCustomBox(args: { size: string; printArea: string; quantity: number }): Promise<custom_packaging_quoteResult>;
+  }
+}
+
 declare namespace BowmarkCapability_custom_sofa_configurator {
   // ── Custom sofa configurator (fabric selection, live pricing) — the unit's own declarations, verbatim ──
 type CustomSofa = {
@@ -704,6 +748,35 @@ type CallOptions = {
   }
 }
 
+declare namespace BowmarkCapability_dfs_ownership_projections {
+  // ── DFS Ownership & Salary Projections — the unit's own declarations, verbatim ──
+interface DFSProjection {
+  player: string;
+  salary: number;
+  ownership: number;
+  sport?: string;
+  position?: string;
+  team?: string;
+}
+
+interface dfs_ownership_projectionsResult {
+  projections: DFSProjection[];
+  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
+}
+
+  /** Projected ownership percentages and salary caps for daily fantasy sports slates */
+  interface Unit {
+    /** Search for DFS ownership percentages and salary data across sports and slates */
+    search(query: string, options?: CallOptions): Promise<dfs_ownership_projectionsResult>;
+  }
+}
+
 declare namespace BowmarkCapability_domain {
   // ── Domain name availability check — the unit's own declarations, verbatim ──
 
@@ -1732,6 +1805,25 @@ interface HtmlPreviewResult {
   }
 }
 
+declare namespace BowmarkCapability_mac_trade_in {
+  // ── Mac trade-in value — the unit's own declarations, verbatim ──
+interface MacTradeInEstimate {
+  model: string;
+  chip?: string;
+  storage?: string;
+  ram?: string;
+  condition?: "like_new" | "good" | "fair" | "broken";
+  appleTradeInValue: number | null;
+  warnings: string[];
+}
+
+  /** Get Mac trade-in credit estimates from Apple Trade In. */
+  interface Unit {
+    /** Get the Apple Trade In credit value for a Mac model, with optional specs. */
+    estimate(model: string, options?: { chip?: string; storage?: string; ram?: string; condition?: string }): Promise<MacTradeInEstimate>;
+  }
+}
+
 declare namespace BowmarkCapability_mcp_registry {
   // ── MCP Registry — the unit's own declarations, verbatim ──
 interface McpRegistryEntry {
@@ -2076,6 +2168,40 @@ type CallOptions = {
   }
 }
 
+declare namespace BowmarkCapability_postcard_direct_mail_quote {
+  // ── Direct mail postcard printing quote — the unit's own declarations, verbatim ──
+interface GetQuoteArgs {
+  quantity: number
+  size?: string
+  stock?: string
+}
+
+interface PostcardQuoteLineItem {
+  size: string
+  stock: string
+  totalPrice: number
+  unitPrice: number
+  currency: string
+}
+
+interface PostcardDirectMailQuote {
+  quantity: number
+  lineItems: PostcardQuoteLineItem[]
+  estimatedDeliveryDays?: number
+  checkoutUrl?: string
+  warnings: string[]
+}
+
+  /** Get a quote for printing direct mail postcards — pricing by quantity, size, and stock. */
+  interface Unit {
+    /**
+     * Returns pricing for direct mail postcards at a requested quantity, with optional size and
+     * stock specifications.
+     */
+    getQuote(args: { quantity: number; size?: string; stock?: string }): Promise<PostcardDirectMailQuote>;
+  }
+}
+
 declare namespace BowmarkCapability_pricing {
   // ── Check whether a product page quotes a different price to different shoppers — the unit's own declarations, verbatim ──
 interface PersonalizationPersona {
@@ -2284,14 +2410,21 @@ type ReadResult = {
      * Loads one page and returns its content. Tries a plain GET first and escalates to a real
      * browser only when the response proves it needs one (a bot wall, an interstitial, or markup
      * carrying no words) — `servedBy` says which leg paid for it. Reports a failure IN the result
-     * rather than throwing.
+     * rather than throwing. RUN-ONLY: because the rung is decided per call, neither `session()`
+     * nor the bare top-level `bowmark` client (which opens a session internally, even for one
+     * call) can serve this — both are refused with code "rung_undeclared". Call it through `run()`
+     * instead.
      */
     page(url: string, options?: ReadOptions): Promise<ReadResult>;
 
     /**
-     * The same read over many urls, six in flight at a time, results in the order the urls were
+     * The same read over many urls: requests to the SAME origin are serialized (one at a time) to
+     * avoid triggering bot defenses on sites that block concurrent connections from one IP, while
+     * requests to DIFFERENT origins run in parallel. Results arrive in the order the urls were
      * given. One dead url never costs you the others — it comes back with `ok: false` and `error`
-     * set.
+     * set. RUN-ONLY: same reason as `page` — the rung is decided per call, so `session()` and the
+     * top-level `bowmark` client are both refused with code "rung_undeclared". Call it through
+     * `run()` instead.
      */
     pages(urls: string[], options?: ReadOptions): Promise<ReadResult[]>;
   }
@@ -2359,7 +2492,13 @@ type RetailOffer = {
                                   // across stores as one normalized fact
 }
 type RetailSearchResult = {
-  results: RetailOffer[]   // ONE query across ALL stores, price-sorted (cheapest first)
+  results: RetailOffer[]   // ONE query across ALL stores, price-sorted (cheapest first).
+                           // These are each STORE'S OWN keyword results, so a search for
+                           // a product also returns its ACCESSORIES and its lookalikes —
+                           // and because the list is price-sorted, those sort ABOVE it.
+                           // "AirPods Pro 3" puts ~20 cases from $8.50 ahead of the
+                           // $199 earbuds. FILTER ON title before reading a cheapest
+                           // price off the top row.
   warnings: string[]       // always present; names any store that did not answer. A
                            // store named here priced NOTHING, so read this before
                            // concluding a store has no stock or a worse price
@@ -2374,17 +2513,22 @@ type CallOptions = {
   /**
    * General-merchandise retail across Walmart, Target and Best Buy — one keyword search, fanned
    * out in parallel and returned price-sorted, so an agent can answer 'where can I actually buy
-   * this and what does it cost' without querying each store by hand. Best Buy's leg needs the
-   * caller's own Best Buy developer key; without one the search still returns Walmart + Target
-   * with a `warnings` entry naming the drop.
+   * this and what does it cost' without querying each store by hand. Rows are the stores' own
+   * keyword results, so accessories and lookalikes come back too and sort above the product;
+   * filter on `title`. Best Buy's leg needs the caller's own Best Buy developer key; without one
+   * the search still returns Walmart + Target with a `warnings` entry naming the drop.
    */
   interface Unit {
     /**
      * Searches Walmart, Target and Best Buy in parallel for a keyword and returns one price-sorted
-     * list of offers across all stores, each tagged with which store it's from. `warnings` names
-     * any store that did not answer — including Best Buy when the caller holds no Best Buy
-     * developer key — so a caller can tell a genuinely cheaper/only offer from one where a store
-     * simply didn't answer.
+     * list of offers across all stores, each tagged with which store it's from. THE ROWS ARE EACH
+     * STORE'S OWN KEYWORD RESULTS, so a product search also returns that product's accessories and
+     * its lookalikes, and price-sorting puts those FIRST — filter on `title` for the thing you
+     * were actually asked about before reading a price off the top row. Everything you need is in
+     * one call; a store returning accessories is not a reason to go query that store directly.
+     * `warnings` names any store that did not answer — including Best Buy when the caller holds no
+     * Best Buy developer key — so a caller can tell a genuinely cheaper/only offer from one where
+     * a store simply didn't answer.
      */
     search(args: { query: string }): Promise<RetailSearchResult>;
   }
@@ -2771,6 +2915,52 @@ type CallOptions = {
   }
 }
 
+declare namespace BowmarkCapability_stream_channel {
+  // ── Stream channel settings — read and change your own channel's title, category and language — the unit's own declarations, verbatim ──
+interface ChannelSettings {
+  platform: "twitch"       // the default, and the only one today
+  id: string               // the site's own id for these broadcast settings
+  title: string            // the channel title shown on the stream page
+  language: string         // ISO 639-1, e.g. "en"
+  gameId: string           // the category; empty strings when never set
+  gameName: string
+  warnings: string[]       // always present
+}
+interface SetChannelOptions {
+  platform?: "twitch"      // the default, and the only one today
+  title?: string           // the channel title shown on the stream page
+  language?: string        // ISO 639-1, e.g. "en"
+  game?: string            // category NAME, e.g. "Wetrix" — not a category id
+}
+
+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
+}
+
+  /**
+   * Reads and updates a streamer's own Twitch channel settings — the title shown on the stream
+   * page, the category being played, and the language. 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 {
+    /**
+     * Reads the signed-in streamer's own channel settings: the title shown on the stream page, the
+     * category being played, and the language. Takes no arguments. Needs a Twitch sign-in.
+     */
+    get(): Promise<ChannelSettings>;
+
+    /**
+     * Updates the signed-in streamer's own channel settings and returns them as they now stand.
+     * Pass only the fields you are changing; anything you leave out is left alone. `game` is the
+     * category NAME, e.g. "Wetrix". It cannot set tags — Twitch's own update input has no tags
+     * field. Needs a Twitch sign-in.
+     */
+    set(options: SetChannelOptions): Promise<ChannelSettings>;
+  }
+}
+
 declare namespace BowmarkCapability_stream_highlights {
   // ── Stream highlights — cut a highlight of your own live broadcast — the unit's own declarations, verbatim ──
 interface CreateHighlightOptions {
@@ -2958,6 +3148,118 @@ type CallOptions = {
   }
 }
 
+declare namespace BowmarkCapability_video_library {
+  // ── Video library — the caller's own saved, liked and playlisted videos — the unit's own declarations, verbatim ──
+interface LibraryVideo {
+  videoId: string
+  url: string
+  title: string
+  channel: string | null
+  views: string | null    // the site's own text, e.g. "1.2M views" — never a parsed number
+  length: string | null   // e.g. "22:28"; null for a live stream
+}
+interface LibraryPage {
+  videos: LibraryVideo[]
+  continuation: string | null   // pass back for the next page; null on the last
+  warnings: string[]
+}
+interface CreatePlaylistOptions {
+  title: string
+  description?: string
+  privacy?: "private" | "unlisted" | "public"   // default "private"
+  // "unlisted" and "public" need the signed-in account to HAVE a YouTube channel;
+  // "private" does not. Without one the call fails and says so.
+}
+interface CreatedChannel {
+  channelId: string
+  name: string           // the account's own Google profile name
+  url: string
+  alreadyExisted: boolean // true when it already had one; nothing was created
+  warnings: string[]
+}
+interface CreatedPlaylist {
+  playlistId: string
+  title: string
+  privacy: "private" | "unlisted" | "public"
+  url: string            // show this to your user — it opens the playlist
+  warnings: string[]
+}
+interface AddToPlaylistOptions {
+  playlist: string       // a playlist id, or any URL carrying a "list" param
+  video?: string         // one video id or watch URL
+  videos?: string[]      // or several — sent as ONE edit
+}
+interface PlaylistEdit {
+  playlistId: string
+  added: string[]        // what was sent and accepted, in order — not a per-video receipt
+  url: 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
+}
+
+  /**
+   * Reads and writes the caller's OWN YouTube account: their Watch Later list, their liked
+   * videos, and the playlists they keep — including making a new one and adding videos to it.
+   * Needs the caller's YouTube sign-in: the first run answers needs_user with a link to sign in,
+   * and later runs reuse it with no browser.
+   */
+  interface Unit {
+    /**
+     * The videos on the caller's OWN YouTube home page — the personalized recommendation grid, in
+     * YouTube's own order, which is what they see when they open youtube.com right now. It exists
+     * nowhere else: not in YouTube's public API, and logged out the same request answers an EMPTY
+     * grid rather than an error. `continuation` is always null; the home feed is one ranked page.
+     * Needs a YouTube sign-in.
+     */
+    homeFeed(options?: { limit?: number }): Promise<LibraryPage>;
+
+    /**
+     * The caller's own Watch Later queue, newest first. Not reachable through YouTube's public API
+     * at all — Google removed access to this list in 2016. Needs a YouTube sign-in.
+     */
+    watchLater(options?: { continuation?: string }): Promise<LibraryPage>;
+
+    /** The videos the caller has liked, newest first. Needs a YouTube sign-in. */
+    liked(options?: { continuation?: string }): Promise<LibraryPage>;
+
+    /**
+     * Creates an empty playlist on the caller's own account and returns its id and URL. Defaults
+     * to "private". A "public" or "unlisted" playlist also needs the account to have a YouTube
+     * channel — a private one does not — and the call says so when it is missing; `createChannel`
+     * makes one, with the account holder's say-so. NOT idempotent — calling it twice makes two
+     * playlists, because YouTube allows duplicate titles and picking one for you would be a guess.
+     * TITLE IT FOR THE PERSON WHOSE ACCOUNT IT LANDS ON — the subject in their own words, never a
+     * tool name, run id or timestamp — and fill in `description` saying what the videos have in
+     * common; see `CreatePlaylistOptions`. Needs a YouTube sign-in.
+     */
+    createPlaylist(options: CreatePlaylistOptions): Promise<CreatedPlaylist>;
+
+    /**
+     * Gives the signed-in account a YouTube CHANNEL, under its own Google profile name and photo —
+     * there is nothing to fill in, because YouTube's own dialog offers nothing. Most Google
+     * accounts have never had one, and without one YouTube REFUSES to create a public or unlisted
+     * playlist (a private one still works, because that belongs to the account rather than to a
+     * channel). THIS ACCEPTS YOUTUBE'S TERMS OF SERVICE for the account holder, exactly as their
+     * own Create channel button does — so call it when the person whose account it is has asked
+     * for a channel, and never on your own to clear an error. Safe to call twice: an account that
+     * already has one gets `alreadyExisted: true` and nothing is created. Needs a YouTube sign-in.
+     */
+    createChannel(): Promise<CreatedChannel>;
+
+    /**
+     * Adds one or many videos to one of the caller's own playlists, as a single edit. Adding a
+     * video already in the playlist adds it again — YouTube permits duplicates and does not report
+     * which is which. Needs a YouTube sign-in.
+     */
+    addToPlaylist(options: AddToPlaylistOptions): Promise<PlaylistEdit>;
+  }
+}
+
 declare namespace BowmarkCapability_weather {
   // ── Weather forecast for a place — the unit's own declarations, verbatim ──
 
@@ -3938,6 +4240,78 @@ interface AiperPoolRecommendation {
   }
 }
 
+declare namespace BowmarkProvider_airtable {
+  // ── Airtable — the unit's own declarations, verbatim ──
+interface AirtableBase {
+  id: string;
+  name: string;
+  permissionLevel: string;
+}
+
+interface AirtableTable {
+  id: string;
+  name: string;
+  primaryFieldId: string;
+  fields: Array<{ id: string; name: string; type: string }>;
+}
+
+interface AirtableRecord {
+  id: string;
+  createdTime: string;
+  fields: Record<string, unknown>;
+}
+
+interface ListTablesArgs {
+  baseId: string;
+}
+
+interface ListRecordsArgs {
+  baseId: string;
+  tableId: string;
+  pageSize?: number;
+}
+
+interface GetRecordArgs {
+  baseId: string;
+  tableId: string;
+  recordId: string;
+}
+
+interface CreateRecordArgs {
+  baseId: string;
+  tableId: string;
+  fields: Record<string, unknown>;
+}
+
+interface UpdateRecordArgs {
+  baseId: string;
+  tableId: string;
+  recordId: string;
+  fields: Record<string, unknown>;
+}
+
+  /** Access Airtable bases, tables, and records via the REST API. */
+  interface Unit {
+    /** Lists all bases the authenticated user can access. */
+    listBases(): Promise<AirtableBase[]>;
+
+    /** Lists all tables in a specified base. */
+    listTables(baseId: ListTablesArgs): Promise<AirtableTable[]>;
+
+    /** Lists all records in a specified table with optional filtering and sorting. */
+    listRecords(args: ListRecordsArgs): Promise<AirtableRecord[]>;
+
+    /** Retrieves a single record by its ID from a specified table. */
+    getRecord(args: GetRecordArgs): Promise<AirtableRecord>;
+
+    /** Creates a new record in a specified table. */
+    createRecord(args: CreateRecordArgs): Promise<AirtableRecord>;
+
+    /** Updates an existing record by its ID. */
+    updateRecord(args: UpdateRecordArgs): Promise<AirtableRecord>;
+  }
+}
+
 declare namespace BowmarkProvider_ajmadison {
   // ── AJ Madison — the unit's own declarations, verbatim ──
 interface AjmadisonSearchArgs {
@@ -4054,6 +4428,10 @@ interface AmazonProduct {
   ratingCount: number | null;
   sponsored: boolean;
 }
+interface AmazonSearchResult {
+  products: AmazonProduct[];
+  totalResultCount: number;
+}
 interface SearchProductsArgs {
   keywords: string;
   department?: string;
@@ -4061,6 +4439,16 @@ interface SearchProductsArgs {
   priceMin?: number;
   priceMax?: number;
   brand?: string;
+  page?: number;
+}
+interface ListCategoryProductsArgs {
+  department: string;
+  sort?: string;
+  page?: number;
+}
+interface AmazonCategoryListing {
+  department: string;
+  products: AmazonProduct[];
 }
 interface AmazonKeywordSuggestion {
   value: string;
@@ -4200,11 +4588,23 @@ interface AmazonSellerOffersResult {
     /**
      * 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.
+     * rating, review count, whether the row is a paid placement, and its product URL, beside the
+     * site's own totalResultCount so a caller paging with `page` can tell "this is the last page"
+     * from "the site is walled". Optionally narrowed to a department, a brand, a price range, a
+     * sort order and a page (1-based; page 2 is a genuinely different set of rows, not page one
+     * repeated). THE provider's door: every function below that takes an ASIN is fed by this one.
      */
-    searchProducts(args: SearchProductsArgs): Promise<AmazonProduct[]>;
+    searchProducts(args: SearchProductsArgs): Promise<AmazonSearchResult>;
+
+    /**
+     * Browse a whole department with no keyword at all — "what is in Home & Kitchen, best-reviewed
+     * first" — and page through it, sorted the way searchProducts sorts. Returns the department
+     * Amazon actually searched (never the caller's slug echoed back — a department slug can
+     * resolve to a DIFFERENT department than the same word means to listBestSellers) beside the
+     * product rows. The function a caller reaches for when it has a category rather than a product
+     * in mind.
+     */
+    listCategoryProducts(args: ListCategoryProductsArgs): Promise<AmazonCategoryListing>;
 
     /**
      * Ask Amazon's own search box what it would autocomplete a prefix to — "cast iron" comes back
@@ -5346,6 +5746,23 @@ interface AppleStore {
   longitude: number | null;
   hours: AppleStoreHours[];
 }
+interface AppleTodaySession {
+  sessionId: string;
+  title: string;
+  prefix: string;
+  description: string;
+  startTime: string;
+  endTime: string;
+  timeZone: string;
+  status: string;  // the site's own labels — read the values off a result, never guess one from prose
+  storeNum: string;
+  storeName: string;
+  icalUrl: string;
+}
+interface AppleTodaySessionList {
+  storeSlug: string;
+  sessions: AppleTodaySession[];
+}
 interface AppleNewsroomPost {
   title: string;
   category: string;
@@ -5433,15 +5850,17 @@ interface AppleCompareModels {
     getPurchaseOptions(urlOrPath: string): Promise<ApplePurchaseOptions>;
 
     /**
-     * Puts two or more iPhone models side by side on the specs apple.com itself compares them on —
-     * screen size, chip, camera system, battery, capacity, finish, durability rating, connectivity
-     * — straight off apple.com's own /iphone/compare/ grid. Model names must match the page's own
-     * naming exactly (e.g. "iPhone 17 Pro", not "17 Pro" or "iphone17pro"); an unmatched name
-     * throws naming the page's own list. Carries no price: apple.com's own compare page renders
-     * its Price row as an unfilled client-side template with no number in the static HTML, so this
-     * omits it rather than guess — read a price off getConfigurationOptions or getPurchaseOptions
-     * instead. A spec absent for one model (an older phone with no Dynamic Island) is simply
-     * missing from that model's own list, never a false "no".
+     * Puts two or more models of the SAME family — Mac, iPhone, iPad or Apple Watch — side by side
+     * on the specs apple.com itself compares them on, straight off apple.com's own
+     * /<family>/compare/ grid; which family is read off the model names themselves, never a second
+     * argument. Model names must match the page's own naming exactly (e.g. "iPhone 17 Pro", not
+     * "17 Pro" or "iphone17pro"; "MacBook Air 13-in. (M5)", not "MacBook Air"); an unmatched name
+     * throws naming the page's own list, and names spanning two families throws too. Carries no
+     * price: apple.com's own compare page renders its Price row as an unfilled client-side
+     * template with no number in the static HTML, so this omits it rather than guess — read a
+     * price off getConfigurationOptions or getPurchaseOptions instead. A spec absent for one model
+     * (an older phone with no Dynamic Island) is simply missing from that model's own list, never
+     * a false "no".
      */
     compareModels(models: string[]): Promise<AppleCompareModels>;
 
@@ -5501,8 +5920,13 @@ interface AppleCompareModels {
 
     /**
      * 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.
+     * search snippet — from the docid or URL one of searchSupport()'s own rows carries. Opens a
+     * HelpKB article (docid or URL), a User Guide page ("url" field only — its own docid carries
+     * no URL apple.com could resolve), and an Apple Support Community thread ("thread_<id>" docid
+     * or a discussions.apple.com URL) — the last of those through a headless browser past
+     * discussions.apple.com's bot-verification redirect, since it is the door Apple ranks first
+     * for an ordinary problem. The read an agent reaches for once searchSupport has narrowed the
+     * problem to one page.
      */
     getSupportArticle(docidOrUrl: string): Promise<AppleSupportArticle>;
 
@@ -5556,6 +5980,13 @@ interface AppleCompareModels {
      */
     getStore(urlOrPath: string): Promise<AppleStore>;
 
+    /**
+     * The free Today at Apple sessions one store is running, with each one's title, description,
+     * start/end time and RSVP status — off the store's own calendar page. Takes a bare store slug
+     * ("unionsquare") or a URL/path from listStores() or getStore()'s own rows.
+     */
+    listTodaySessions(storeSlugOrUrl: string): Promise<AppleTodaySessionList>;
+
     /**
      * Apple's official announcements, newest first, off its own published RSS feed — every product
      * launch, financial result and press release, with its headline, category, publish date and
@@ -6630,6 +7061,36 @@ interface AzureListServicesResult {
   }
 }
 
+declare namespace BowmarkProvider_bahn {
+  // ── Deutsche Bahn — Disruptions — the unit's own declarations, verbatim ──
+interface DisruptionRow {
+  id: string;
+  headline: string;
+  begin: string;             // ISO 8601 UTC
+  end: string | null;        // ISO 8601 UTC, null if open-ended
+  cause: string;              // the site's own enum, e.g. "TECHNICAL_PROBLEM_RAILWAY_SECTION"
+  effect: string;             // the site's own enum, e.g. "IMPAIRMENT"
+  trainCategories: string[]; // e.g. ["IC", "ICE"]
+  states: string[];           // German federal states affected
+  affectedRoutes: string[];  // e.g. ["Mainz Hbf – Bingen(Rhein) Hbf"]
+}
+
+  /**
+   * Lists current long-distance (ICE/IC/EC) train disruptions across the Deutsche Bahn network —
+   * the same live data its verkehrslage.bahnhof.de disruption map shows, read directly off the
+   * map widget's own API rather than through the client-side-rendered map.
+   */
+  interface Unit {
+    /**
+     * Lists current Deutsche Bahn long-distance (ICE/IC/EC) disruptions network-wide — cause,
+     * effect, affected train categories, states and named railway sections — read live off the
+     * same API bahn.de's own disruption map calls. Pass a trainCategory (e.g. "ICE") to narrow to
+     * disruptions affecting that category.
+     */
+    listDisruptions(trainCategory?: string): Promise<DisruptionRow[]>;
+  }
+}
+
 declare namespace BowmarkProvider_bankmycell {
   // ── BankMyCell — the unit's own declarations, verbatim ──
 interface BankmycellSearchResult {
@@ -8546,107 +9007,6 @@ interface BrixtonCheckoutLink {
   }
 }
 
-declare namespace BowmarkProvider_browser_use {
-  // ── Browser Use — the unit's own declarations, verbatim ──
-type BrowserUseRunStatus = "queued" | "dispatching" | "running" | "completed" | "failed" | "cancelled";
-
-interface BrowserUseCreateRunArgs {
-  task: string;
-  model?: string;             // e.g. "claude-sonnet-5"; absent = vendor default
-  sessionId?: string;         // continue a session
-  maxCostUsd?: number;
-  proxyCountryCode?: string;  // e.g. "us"
-}
-
-interface BrowserUseRunStatusReading { runId: string; status: BrowserUseRunStatus }
-interface BrowserUseCreatedRun { id: string; status: BrowserUseRunStatus; model: string; sessionId: string; workspaceId: string }
-
-interface BrowserUseRun {
-  id: string; sessionId: string; task: string; title: string | null; model: string;
-  status: BrowserUseRunStatus; result: string | null; error: string | null;
-  inputTokens: number; outputTokens: number;
-  costUsd: number;            // LLM cost only
-  createdAt: string; updatedAt: string;
-}
-
-interface BrowserUseRunList { runs: BrowserUseRun[]; hasMore: boolean }
-interface BrowserUseEvent { id: number; ts: string; type: string; data: Record<string, unknown> }
-interface BrowserUseEventsPage { events: BrowserUseEvent[]; nextAfter: number | null; hasMore: boolean }
-interface BrowserUseEventsArgs { runId: string; after?: number; limit?: number }
-
-interface BrowserUseSession { sessionId: string; latestRunId: string; status: string; title: string | null; createdAt: string; updatedAt: string }
-
-interface BrowserUseQueueArgs { sessionId: string; text: string; interrupt?: boolean }
-interface BrowserUseQueuedMessage { id: number; sessionId: string; status: string; mode: string }
-
-interface BrowserUseBrowser {
-  id: string; status: string;
-  liveUrl: string | null;     // interactive; whoever holds it drives the browser
-  agentSessionId: string | null;
-  timeoutAt: string; startedAt: string; finishedAt: string | null;
-  browserCostUsd: number; proxyCostUsd: number; proxyUsedMb: number;
-}
-
-  /**
-   * Browser Use Cloud's hosted browser agent. Not callable directly: use
-   * `bowmark.browser_agent`, which runs it for you with a private watch link and bills the
-   * session to your account.
-   */
-  interface Unit {
-    /**
-     * Starts a Browser Use agent run on a natural-language task, optionally continuing an existing
-     * session. Returns immediately; the run executes on Browser Use's cloud for seconds to
-     * minutes. Spends money.
-     */
-    createRun(args: BrowserUseCreateRunArgs): Promise<BrowserUseCreatedRun>;
-
-    /** Reads one run: status, final result or error, token totals and LLM cost. */
-    getRun(runId: string): Promise<BrowserUseRun>;
-
-    /** The cheap status poll for one run. */
-    getRunStatus(runId: string): Promise<BrowserUseRunStatusReading>;
-
-    /**
-     * A run's step-by-step event stream after a cursor — the agent's reasoning, tool calls, and
-     * the `browser.ready` event carrying the live view url.
-     */
-    listRunEvents(args: BrowserUseEventsArgs): Promise<BrowserUseEventsPage>;
-
-    /**
-     * Lists every run (agent turn) in a session, newest first, each with its status and LLM cost —
-     * how a session's whole spend is read.
-     */
-    listSessionRuns(sessionId: string): Promise<BrowserUseRunList>;
-
-    /**
-     * Cancels an in-flight run; idempotent on a finished one. The browser keeps running — stop it
-     * separately.
-     */
-    cancelRun(runId: string): Promise<BrowserUseRun>;
-
-    /** Reads a session, including the id of its latest run (a queued message becomes a new run). */
-    getSession(sessionId: string): Promise<BrowserUseSession>;
-
-    /**
-     * Sends a follow-up instruction into a session: it runs as the next turn when the current one
-     * ends, or at once with `interrupt: true`.
-     */
-    queueMessage(args: BrowserUseQueueArgs): Promise<BrowserUseQueuedMessage>;
-
-    /** The cloud browser attached to a session, with its live view url and running cost, or null. */
-    findSessionBrowser(sessionId: string): Promise<BrowserUseBrowser | null>;
-
-    /** Reads one cloud browser: status, live view url, browser and proxy cost. */
-    getBrowser(browserId: string): Promise<BrowserUseBrowser>;
-
-    /**
-     * Stops a cloud browser (cannot be undone). Its cost is then settled down to the time actually
-     * used.
-     */
-    stopBrowser(browserId: string): Promise<BrowserUseBrowser>;
-  }
-}
-
 declare namespace BowmarkProvider_builder_strucsure_com {
   // ── StrucSure Home Warranty — the unit's own declarations, verbatim ──
 interface StrucsureRegistrationState {
@@ -9188,6 +9548,7 @@ interface CalendlyAvailabilityResult {
   timezone: string;
   days: CalendlyDay[];
   otherEventTypes: CalendlyEventType[];
+  unavailableReason: string | null;   // non-null = Calendly says this event cannot be booked at all; days is [] BECAUSE of that, not because nothing is open
 }
 
 interface CalendlyFormQuestion {
@@ -9256,7 +9617,9 @@ interface CalendlyFindProfilesResult {
      * Returns the real, currently-open time slots for one Calendly event type — accepts a bare
      * profile slug ("jason-frazier"), a profile url, or a specific event url
      * ("https://calendly.com/jason-frazier/15min"). Given a bare profile, it picks that profile's
-     * first event type and reports the rest in `otherEventTypes`.
+     * first event type and reports the rest in `otherEventTypes`. `days` is empty both when
+     * nothing is open and when Calendly reports the calendar cannot be booked at all (a broken
+     * calendar connection, a deactivated event) — check `unavailableReason` to tell the two apart.
      */
     getAvailability(profile: string, opts?: CalendlyAvailabilityOptions): Promise<CalendlyAvailabilityResult>;
 
@@ -11891,6 +12254,39 @@ interface CostcoProduct {
   }
 }
 
+declare namespace BowmarkProvider_countycourt_vic_gov_au {
+  // ── County Court of Victoria — the unit's own declarations, verbatim ──
+type CountycourtListSlug = "crime-and-appeals" | "civil" | "circuit";
+interface CountycourtHearing {
+  list: CountycourtListSlug;
+  publishDate: string | null;  // e.g. "2026-09-18"
+  room: string | null;         // e.g. "County Court G.1"
+  judge: string | null;        // e.g. "Judge Malik"
+  time: string | null;         // ISO timestamp
+  caseId: string | null;       // e.g. "AP-25-1265"
+  caseName: string | null;     // e.g. "HEIDARIKAKOLAKI, Amin"
+  hearingType: string | null;  // e.g. "For Sentence"
+  partHeard: boolean;
+}
+
+  /**
+   * Reads the County Court of Victoria's daily hearing lists — Crime and Appeals, Civil, Circuit
+   * — straight off the site's own headless-Drupal JSON:API, no key, no browser.
+   */
+  interface Unit {
+    /**
+     * Returns the County Court of Victoria's currently-published daily hearing list as structured
+     * rows — one row per case sitting, with its room, judge, case id, case name, hearing type,
+     * listed time and part-heard flag. `list` is OPTIONAL and defaults to "crime-and-appeals"
+     * (criminal trials, pleas, appeals); pass "civil" for common law and commercial hearings or
+     * "circuit" for regional sittings. The site republishes each list by ~5:30pm on the day before
+     * it takes effect (Melbourne time) — check `publishDate` on the returned rows rather than
+     * assuming "today".
+     */
+    dailyList(list?: CountycourtListSlug): Promise<CountycourtHearing[]>;
+  }
+}
+
 declare namespace BowmarkProvider_couponfollow {
   // ── CouponFollow — the unit's own declarations, verbatim ──
 interface CouponFollowOffer {
@@ -12871,6 +13267,26 @@ interface DetailxpertsQuote {
   }
 }
 
+declare namespace BowmarkProvider_deutschepost {
+  // ── Deutsche Post — the unit's own declarations, verbatim ──
+interface DialogpostRate {
+  weightCategory: string;
+  format: string;
+  priceInCents: number;
+  currency: string;
+  description?: string;
+}
+
+  /** Dialogpost pricing for unaddressed bulk direct mail in Germany. */
+  interface Unit {
+    /**
+     * Retrieves Deutsche Post Dialogpost pricing rates by weight and format. Returns rates for
+     * unaddressed bulk direct mail delivery (household-level distribution).
+     */
+    getDialogpostRates(options?: { format?: string }): Promise<DialogpostRate[]>;
+  }
+}
+
 declare namespace BowmarkProvider_developersopenai {
   // ── OpenAI Developer Docs — the unit's own declarations, verbatim ──
 interface DevelopersOpenaiDocPage {
@@ -12897,6 +13313,36 @@ interface DevelopersOpenaiDocPage {
   }
 }
 
+declare namespace BowmarkProvider_dfs_rotogrinderssearch {
+  // ── RotoGrinders — the unit's own declarations, verbatim ──
+interface SearchArgs {
+  query: string;
+}
+
+interface DFSProjectionRow {
+  player: string;
+  salary: number;
+  ownership: number;
+  sport?: string;
+  position?: string;
+  team?: string;
+}
+
+interface SearchResults {
+  projections: DFSProjectionRow[];
+  warnings: string[];
+}
+
+  /** Search RotoGrinders for DFS projections, ownership percentages, and salary caps */
+  interface Unit {
+    /**
+     * Searches RotoGrinders for DFS projections, ownership percentages, and salary caps across
+     * sports (NFL, NBA, MLB, etc.)
+     */
+    search(args: SearchArgs): Promise<SearchResults>;
+  }
+}
+
 declare namespace BowmarkProvider_dice {
   // ── Dice — the unit's own declarations, verbatim ──
 interface DiceSearchResult {
@@ -13753,6 +14199,34 @@ interface EmbrokerQuoteEntryPoint {
   }
 }
 
+declare namespace BowmarkProvider_energyaustralia_com_au {
+  // ── EnergyAustralia — business electricity quote — the unit's own declarations, verbatim ──
+interface EnergyaustraliaBusinessQuote {
+  postcode: string;
+  state: string;
+  serviceable: boolean;
+  plans: Array<{
+    name: string;
+    displayName: string;
+    retailer: string;
+    annualCost: number;
+    monthlyEstimate: number;
+    ratePerUnit: number;
+    dmoReference: number;
+  }>;
+}
+
+  /** Priced business electricity plans in a postcode's distributor territory. */
+  interface Unit {
+    /**
+     * Returns every business electricity plan EnergyAustralia offers in a postcode's distributor
+     * territory, each priced at the regulator's standard reference consumption (10,000 kWh/year) —
+     * the same live call the site's own business quote page makes.
+     */
+    getBusinessElectricityQuote(arg0: { postcode: string }): Promise<EnergyaustraliaBusinessQuote>;
+  }
+}
+
 declare namespace BowmarkProvider_epromos {
   // ── ePromos — the unit's own declarations, verbatim ──
 // ePromos' OWN shapes — not a capability contract.
@@ -14037,6 +14511,49 @@ interface etsyListing {
   }
 }
 
+declare namespace BowmarkProvider_evag {
+  // ── EVAG Essen — Public Transit Departures and Schedules — the unit's own declarations, verbatim ──
+interface Departure {
+  line: string;
+  destination: string;
+  minutesUntil: number;
+  platform?: string;
+  delayMinutes?: number;
+}
+
+interface StopSearchResult {
+  id: string;      // what listDepartures takes
+  name: string;
+  city?: string;
+}
+
+interface LineStatus {
+  line: string;
+  status: "normal" | "disruption" | "delay";
+  message?: string;
+}
+
+  /**
+   * Real-time public transit departure information, schedules and service disruptions for Essen,
+   * Germany via EVAG (Essener Verkehrs-AG) / Ruhrbahn, read straight from ifa.ruhrbahn.de's own
+   * JSON backend — no key, no browser.
+   */
+  interface Unit {
+    /**
+     * Real-time departure information for a given stop — line numbers, destinations, and minutes
+     * until departure. Takes the id searchStop returns. THROWS a caller-fixable error rather than
+     * returning [] when ifa.ruhrbahn.de does not recognize the stop id.
+     */
+    listDepartures(stopId: string): Promise<Departure[]>;
+
+    /**
+     * Search for a transit stop or city by name or partial name (e.g. 'Essen', 'Essen
+     * Hauptbahnhof'); returns matching stops with the id listDepartures takes.
+     */
+    searchStop(query: string): Promise<StopSearchResult[]>;
+  }
+}
+
 declare namespace BowmarkProvider_eventsource {
   // ── Event Source — the unit's own declarations, verbatim ──
 interface EventSourceDesign {
@@ -16682,12 +17199,18 @@ interface SearchPlacesArgs {
 interface SearchPlacesResult {
   featureId: string;
   name: string;
+  url: string;
   address: string;
   coordinates: { lat: number; lng: number } | null;
   categories: string[];
   rating?: number;
   reviewCount?: number;
 }
+interface SearchNearbyArgs {
+  query: string;
+  lat: number;
+  lng: number;
+}
 interface GeocodeAddressArgs {
   address: string;
 }
@@ -16714,6 +17237,7 @@ interface GetPlaceArgs {
 interface GetPlaceResult {
   featureId: string;
   name: string;
+  url: string;
   address: string;
   coordinates: { lat: number; lng: number } | null;
   categories: string[];
@@ -16723,6 +17247,10 @@ interface GetPlaceResult {
   rating?: number;
   reviewCount?: number;
   hours?: { day: string; hours: string[] }[];
+  openStatus?: string;
+  accessibility?: string[];
+  warnings?: string[];
+  businessStatus?: "closed";
 }
 interface ListReviewsArgs {
   query: string;
@@ -16734,6 +17262,11 @@ interface Review {
   text: string;
   relativeDate?: string;
 }
+interface ListReviewsResult {
+  reviews: Review[];
+  reviewCount?: number;
+  warnings: string[];
+}
 interface ListRelatedPlacesArgs {
   query: string;
 }
@@ -16783,9 +17316,9 @@ interface Photo {
   /**
    * Local business search on Google Maps — find places by what a person would say, then read the
    * address, hours, rating, reviews, photos, co-located tenants and route. suggestPlaces
-   * (autocomplete), searchPlaces (the door), geocodeAddress, getPlace, listReviews, listPhotos,
-   * listRelatedPlaces, getDirections, resolvePlaceUrl and reverseGeocode are built; everything
-   * else is still a declared stub.
+   * (autocomplete), searchPlaces (the door), searchNearby (the same door, anchored to a point),
+   * geocodeAddress, getPlace, listReviews, listPhotos, listRelatedPlaces, getDirections,
+   * resolvePlaceUrl and reverseGeocode are built; everything else is still a declared stub.
    */
   interface Unit {
     /**
@@ -16797,12 +17330,24 @@ interface Photo {
     /**
      * The door every other Maps function chains off. Takes what a person would say — "coffee shops
      * in Seattle WA", "pizza near Austin TX" — and returns the ranked places Google shows for it:
-     * feature id, name, address, coordinates and categories, plus rating and review count when the
-     * site's response carries them. The location lives in the query text; Google resolves it from
-     * there rather than from a separate coordinate.
+     * feature id, name, address, coordinates and categories, plus rating, review count, weekly
+     * hours and the site's own live open/closed line (openStatus) when the site's response carries
+     * them — so "which of these is open right now" costs no further call. The location lives in
+     * the query text; Google resolves it from there rather than from a separate coordinate.
      */
     searchPlaces(args: SearchPlacesArgs): Promise<SearchPlacesResult[]>;
 
+    /**
+     * searchPlaces anchored to a POINT instead of resolved from the query text — for a caller
+     * holding coordinates (a pin, a phone's GPS, reverseGeocode's own output) rather than a
+     * locality name. Reuses reverseGeocode's own viewport template spliced into searchPlaces'
+     * field mask: "coffee" anchored at a point returns results within a few hundred meters of it,
+     * measured live against two cities. Same result shape as searchPlaces, hours and openStatus
+     * included. Without this, a coordinate query has nowhere to go on searchPlaces and Google
+     * answers from whichever city the request happens to exit near.
+     */
+    searchNearby(args: SearchNearbyArgs): Promise<SearchPlacesResult[]>;
+
     /**
      * A street address, a city, or a business name in — the matching Google Maps place, its
      * feature id and its coordinates out. Rides the same door as searchPlaces (a second reading of
@@ -16824,25 +17369,44 @@ interface Photo {
 
     /**
      * Everything Google Maps shows on one business's panel — name, full address, coordinates,
-     * category, neighborhood, phone, website, rating, review count and weekly hours, each present
-     * only when the site's own response carried it. A THIRD reading of searchPlaces' door: takes
-     * the same resolving query geocodeAddress does (typically a name plus address, since this does
-     * not take a feature id — measured live, neither the raw id nor a cid string resolves through
-     * this door), and throws when the query names a category or list rather than one business.
+     * category, neighborhood, phone, website, rating, review count, weekly hours, the site's own
+     * live open/closed line (e.g. "Closed · Opens 7 AM"), its accessibility labels (e.g.
+     * "Wheelchair accessible entrance") and businessStatus, present and always "closed" ONLY when
+     * the site has flagged the listing permanently closed — each present only when the site's own
+     * response carried it. openStatus is the site's rendered string, not a boolean this provider
+     * computed — hours' display strings carry no timezone, so a caller cannot derive
+     * open-right-now from them without it. accessibility is absent when the site publishes nothing
+     * for that place, never a guess — the field mask carries no other amenity category (Wi-Fi,
+     * outdoor seating, takeout, …) at all. businessStatus reports a CONFIRMED closure honestly
+     * (measured live against Mamnoon, Plum Bistro, Harbor City Restaurant and Copine, all recently
+     * closed) but its absence never means the business is open — Google does not flag every
+     * real-world closure, confirmed live against two long-defunct Toys "R" Us locations that carry
+     * no marker at all. This retries a few times to see past a reduced/rich flap in the site's own
+     * response and merges the richest draw; `warnings` is non-empty when every attempt drew the
+     * reduced record, meaning reviewCount/hours/openStatus could not be confirmed either way
+     * rather than being genuinely absent. A THIRD reading of searchPlaces' door: takes the same
+     * resolving query geocodeAddress does (typically a name plus address, since this does not take
+     * a feature id — measured live, neither the raw id nor a cid string resolves through this
+     * door), and throws when the query names a category or list rather than one business.
      */
     getPlace(args: GetPlaceArgs): Promise<GetPlaceResult>;
 
     /**
-     * The reviews Google Maps shows on a business's own panel — up to 5, each with author, star
-     * rating, review text and the site's own relative date. A FOURTH reading of searchPlaces' door
-     * (the same record getPlace reads, one section further in), not the listugcposts route the
-     * survey planned: that route needed a session token minted by a place-page bootstrap that was
-     * never cracked, but the same reviews the token would have fetched are already sitting in the
-     * panel response. Takes the same resolving query getPlace does. Returns [] for a place with no
-     * reviews rather than throwing; throws only when the query itself does not resolve to one
-     * place.
+     * The reviews Google Maps shows on a business's own panel — a handful, each with author, star
+     * rating, review text and the site's own relative date; the count of reviews RETURNED varies
+     * by response, so this retries a few times and keeps the longest list seen. `reviewCount` is
+     * the site's own TOTAL for the business (the same figure getPlace's own reviewCount reads),
+     * present whenever any attempt carried it — a caller must not read `reviews.length` as the
+     * whole picture, since this is always a preview, never the full set. A FOURTH reading of
+     * searchPlaces' door (the same record getPlace reads, one section further in), not the
+     * listugcposts route the survey planned: that route needed a session token minted by a
+     * place-page bootstrap that was never cracked, but the same reviews the token would have
+     * fetched are already sitting in the panel response. Takes the same resolving query getPlace
+     * does. `reviews` is [] for a place with no reviews; `warnings` says so when the site's own
+     * panel reports reviews that never rendered across every attempt — a thin draw, not a
+     * review-less business. Throws only when the query itself does not resolve to one place.
      */
-    listReviews(args: ListReviewsArgs): Promise<Review[]>;
+    listReviews(args: ListReviewsArgs): Promise<ListReviewsResult>;
 
     /**
      * Other businesses Google Maps lists "At this place" — the site's own label for a shared
@@ -16921,6 +17485,7 @@ interface GoogleNewsArticle {
 interface GoogleNewsSearchResult {
   query: string;
   articles: GoogleNewsArticle[];
+  truncatedBefore?: string;
 }
 interface GoogleNewsTopStories {
   title: string;
@@ -16935,6 +17500,7 @@ interface GoogleNewsPublisherHeadlines {
   publisher: string;
   query: string;
   articles: GoogleNewsArticle[];
+  truncatedBefore?: string;
 }
 interface GoogleNewsLocalHeadlines {
   place: string;
@@ -16987,13 +17553,25 @@ interface GoogleNewsFullCoverage {
      * headline, publisher, publication time and the Google News link, newest first. `query` is
      * exactly what a person would type into Google News' own search box, and Google's own
      * operators work inside it: `when:1h`/`when:1d`/`when:7d` narrows the window,
-     * `site:reuters.com` pins one publisher, quotes pin a phrase and `(a OR b)` unions two
-     * subjects — measured 2026-09-15: `site:reuters.com tesla` returned 100 items of which 100
-     * carried `<source>Reuters</source>`. This is the provider's main door: a caller holding only
-     * words gets in here. A query that matches nothing returns an empty `articles` array rather
-     * than throwing. `locale` — `{ hl, gl, ceid }` — asks for another country/language edition,
-     * e.g. `{ hl: "es-419", gl: "MX", ceid: "MX:es" }` for Mexico; omitted, every field defaults
-     * to the US English edition.
+     * `after:YYYY-MM-DD`/`before:YYYY-MM-DD` pin an explicit date range, `site:reuters.com` pins
+     * one publisher, quotes pin a phrase and `(a OR b)` unions two subjects — measured 2026-09-15:
+     * `site:reuters.com tesla` returned 100 items of which 100 carried `<source>Reuters</source>`.
+     * This is the provider's main door: a caller holding only words gets in here. A query that
+     * matches nothing returns an empty `articles` array rather than throwing. **This feed caps
+     * around a hundred rows, newest first, with no count of its own** — a `when:` window OR an
+     * explicit `after:`/`before:` range wider than what fits is NOT silently cut: when the oldest
+     * row served does not reach the window's or range's start, the result carries
+     * `truncatedBefore` (the oldest served article's own timestamp) so a caller can tell the
+     * answer stopped short (measured 2026-09-18: `"tesla when:7d"` reached only its newest 11.7h;
+     * measured 2026-09-19: an 8-day `after:`/`before:` range reached only its newest ~24.5h, with
+     * over a hundred articles proven missing). **Do not paste `truncatedBefore` into `before:`** —
+     * it is a timestamp and `after:`/`before:` take a whole date in Google's own zone, so the
+     * literal value re-asks the same range forever (measured 2026-09-19: 0 rows on the exact
+     * value, or a repeating query stuck at 109 of 300 real articles). Page with the sibling field
+     * `resumeBefore` instead — a date one day earlier, guaranteed to move — until a call comes
+     * back with neither field. `locale` — `{ hl, gl, ceid }` — asks for another country/language
+     * edition, e.g. `{ hl: "es-419", gl: "MX", ceid: "MX:es" }` for Mexico; omitted, every field
+     * defaults to the US English edition.
      */
     searchNews(query: string, locale?: GoogleNewsLocaleArg): Promise<GoogleNewsSearchResult>;
 
@@ -17022,32 +17600,45 @@ interface GoogleNewsFullCoverage {
     /**
      * Everything Google News has indexed from one publisher — `publisher` is a domain like
      * "reuters.com" or a name like "Reuters" — 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. `site:` takes a DOMAIN, so a NAME is resolved to one through the search
-     * door first (the host dominating that name's own search results) rather than passed straight
-     * to `site:`, where it is mis-parsed as a TLD plus a keyword (measured 2026-09-17: "Al
-     * Jazeera" returned 100 rows, all from the .al ccTLD) — a name the door cannot resolve is
-     * refused rather than answered with the wrong newsroom. 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.
+     * same way `searchNews` takes one, including its `when:`/`after:`/`before:` window operators.
+     * 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. `site:` takes a DOMAIN, so a
+     * NAME is resolved to one through the search door first (the host dominating that name's own
+     * search results) rather than passed straight to `site:`, where it is mis-parsed as a TLD plus
+     * a keyword (measured 2026-09-17: "Al Jazeera" returned 100 rows, all from the .al ccTLD) — a
+     * name the door cannot resolve is refused rather than answered with the wrong newsroom.
+     * Measured 2026-09-15: `site:reuters.com tesla` returned 100 items of which 100 carried a
+     * `<source>` domain on `reuters.com`. **Same truncation caveat as `searchNews`**: a `when:`
+     * window OR an explicit `after:`/`before:` range wider than the feed's ~100-row cap is never
+     * silently cut — the result carries `truncatedBefore` when more exists before that timestamp
+     * (measured 2026-09-18: `listPublisherHeadlines("reuters.com", "when:7d")` reached only its
+     * newest 22h; measured 2026-09-19: an 8-day `after:`/`before:` range reached only its newest
+     * ~24.5h). **Do not paste `truncatedBefore` into `before:`** — page with the sibling field
+     * `resumeBefore` instead, exactly as `searchNews` does; the timestamp re-asks the same range
+     * forever. `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
+     * ("Seattle", "San Francisco"), NOT a ZIP or postal code. 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.
+     * reading that as an empty result would be silently wrong, so this throws instead. A US ZIP
+     * code gets a second, quieter version of the same failure: Google mints a place-shaped channel
+     * for it too ("94103 - Latest - Google News") but with zero headlines, which would otherwise
+     * read as a genuinely quiet news day — measured 2026-09-18, four dense-metro ZIPs all answered
+     * 0 while "Seattle" answered 70 in the same run, and every real place swept (however small)
+     * resolved to at least one headline, so a place-shaped channel with zero items is refused too,
+     * naming a city as the fix. 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>;
 
@@ -17069,8 +17660,10 @@ interface GoogleNewsFullCoverage {
      * 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.
+     * somebody who only holds words. The "Your local news" entry's id is NOT a topic feed — the
+     * site serves it by geo-locating the reader — so `getTopicHeadlines` and `listStories` both
+     * refuse it and name `listLocalHeadlines` instead. `locale` — `{ hl, gl, ceid }` — asks for
+     * another country/language edition's own nav rail; omitted, the US English one.
      */
     listTopics(locale?: GoogleNewsLocaleArg): Promise<GoogleNewsTopic[]>;
 
@@ -17081,13 +17674,17 @@ interface GoogleNewsFullCoverage {
      * `/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.
+     * titled "Technology - Latest - Google News". EIGHT OF THE NINE `listTopics` IDS ARE REACHABLE
+     * WITHOUT AN ACCOUNT; the ninth — "Your local news" — is refused before any request, since the
+     * site serves it by geo-locating the reader rather than from a topic feed (measured
+     * 2026-09-17: that id 404s here and returns zero stories from `listStories`, with no error).
+     * Call `listLocalHeadlines("<city>")` for that entry instead. 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>;
 
@@ -17099,9 +17696,14 @@ interface GoogleNewsFullCoverage {
      * 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.
+     * on this site emits a story id at all, so this is the only door. A `topicId` from
+     * `listTopics`' "Your local news" entry is refused before any request — that entry is not a
+     * topic feed; call `listLocalHeadlines("<city>")` instead (measured 2026-09-17: without this
+     * check the id silently answered 200 with zero stories). `locale` — `{ hl, gl, ceid }` — asks
+     * for another country/language edition of whichever page is read; omitted, the US English one.
+     * The `storyId` each result carries has that same edition baked in, so passing it straight
+     * into `getFullCoverage` with no `locale` argument reads the right edition automatically — see
+     * `getFullCoverage`'s own note.
      */
     listStories(topicId?: string, locale?: GoogleNewsLocaleArg): Promise<GoogleNewsStory[]>;
 
@@ -17118,8 +17720,12 @@ interface GoogleNewsFullCoverage {
      * 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.
+     * under `{ hl: "es-419", gl: "MX", ceid: "MX:es" }`). A `storyId` FROM `listStories` already
+     * carries the edition it was found under, so leaving `locale` unset here reads that SAME
+     * edition automatically — pass an explicit `locale` only to read a story you found some other
+     * way, and it must agree with the id's own encoded edition or the call is refused rather than
+     * silently truncated (measured live 2026-09-17: a wrong edition can render a place or topic
+     * label that reads like a real headline).
      */
     getFullCoverage(storyId: string, locale?: GoogleNewsLocaleArg): Promise<GoogleNewsFullCoverage>;
   }
@@ -19228,13 +19834,15 @@ interface higgsfieldSavedFile {
      * image URLs together with what Higgsfield quoted. `model` defaults to `soul` ($0.094
      * measured); `listModels()` has the rest. Any other key — `aspect_ratio`, `num_images`,
      * `input_images`, `output_format` — is passed to Higgsfield untouched, since each model takes
-     * its own. Waits up to `waitMs` (default 120000) for a terminal state; pass 0 to submit and
-     * return the handle immediately. **The finished images are copied into your Bowmark account
-     * automatically and come back on `files` — use those URLs, not `imageUrls`.** Higgsfield
-     * deletes its own copy after about seven days; a file in your account is yours until you
-     * delete it, and costs storage while you keep it. Pass `save: false` to skip the copy and take
-     * the expiring links. Uses Bowmark's Higgsfield key and charges the generation to your
-     * account; send your own key as the `x-bowmark-vendor-key-higgsfield` header instead.
+     * its own. Waits up to `waitMs` (default 90000, and never longer than the run's own ceiling)
+     * for a terminal state. A wait always happens — a submit that never watches its own result is
+     * a generation Higgsfield bills us for and nobody is charged for — so the floor is 20000.
+     * **The finished images are copied into your Bowmark account automatically and come back on
+     * `files` — use those URLs, not `imageUrls`.** Higgsfield deletes its own copy after about
+     * seven days; a file in your account is yours until you delete it, and costs storage while you
+     * keep it. Pass `save: false` to skip the copy and take the expiring links. Uses Bowmark's
+     * Higgsfield key and charges the generation to your account; send your own key as the
+     * `x-bowmark-vendor-key-higgsfield` header instead.
      */
     generateImage(args: string | { prompt: string; model?: string; waitMs?: number; save?: boolean; [param: string]: unknown }): Promise<higgsfieldGeneration>;
 
@@ -19244,12 +19852,13 @@ interface higgsfieldSavedFile {
      * what Higgsfield quoted. `model` defaults to `hailuo-02-standard` ($0.090 measured, the
      * cheapest live video model); Kling 2.1 Master is $1.400, so check `listModels()` or
      * `estimateCost` before reaching for a big one. Any other key (`duration`, `resolution`,
-     * `input_images`) is passed to Higgsfield untouched. Waits up to `waitMs` (default 240000);
-     * pass 0 to submit and poll with `getRequestStatus` yourself. **A call that waits copies the
-     * finished video into your Bowmark account and returns it on `files` — use that URL, not
-     * `videoUrl`**, because Higgsfield deletes its own copy after about seven days. Pass `save:
-     * false` to skip the copy. A call with `waitMs: 0` saves nothing, since nothing has rendered
-     * yet.
+     * `input_images`) is passed to Higgsfield untouched. Waits up to `waitMs` (default 90000,
+     * clamped to the run's own ceiling). Video usually renders past that, which is normal: you get
+     * `settled: false` and the handle, and collect it with `getRequestStatus`. **A call that waits
+     * copies the finished video into your Bowmark account and returns it on `files` — use that
+     * URL, not `videoUrl`**, because Higgsfield deletes its own copy after about seven days. Pass
+     * `save: false` to skip the copy. A call whose wait runs out saves nothing, since nothing has
+     * rendered yet — collect and download it yourself.
      */
     generateVideo(args: string | { prompt: string; model?: string; waitMs?: number; save?: boolean; [param: string]: unknown }): Promise<higgsfieldGeneration>;
 
@@ -22336,6 +22945,80 @@ interface LegacyHomesalCommunity {
   }
 }
 
+declare namespace BowmarkProvider_letterboxd {
+  // ── Letterboxd — the unit's own declarations, verbatim ──
+interface LetterboxdFilm {
+  slug: string;
+  title: string;
+  year: number | null;
+  url: string;
+  directors: string[];
+  cast: string[];
+  genres: string[];
+  countries: string[];
+  languages: string[];
+  runtimeMinutes: number | null;
+  description: string | null;
+  posterUrl: string | null;
+  averageRating: number | null;
+  ratingCount: number | null;
+  reviewCount: number | null;
+}
+
+interface LetterboxdMemberFilm {
+  slug: string;
+  title: string;
+  year: number | null;
+  url: string;
+}
+
+interface LetterboxdDiaryEntry {
+  filmTitle: string;
+  filmYear: number | null;
+  slug: string;
+  url: string;
+  rating: number | null;
+  watchedDate: string | null;
+  rewatch: boolean;
+  liked: boolean;
+  publishedAt: string | null;
+  reviewText: string | null;
+}
+
+  /**
+   * The social network for film. Reads one film's full record including letterboxd's own
+   * weighted average rating over millions of members, the films a member has logged, and a
+   * member's diary with their star ratings and full review text — all browserless. Also the
+   * library's first provider that can CREATE its own account: signUp drives the real
+   * registration form, solves its hCaptcha and verifies the account from the persona's inbox.
+   */
+  interface Unit {
+    /**
+     * Reads one film's full record — pass the slug from its letterboxd URL, e.g. { slug:
+     * "parasite-2019" }. Returns title, year, directors, cast, genres, countries, languages,
+     * runtime, synopsis and poster, plus `averageRating` (letterboxd's weighted average, 0.5-5),
+     * `ratingCount` and `reviewCount`. That rating is computed over millions of member ratings and
+     * is published nowhere else.
+     */
+    film(args: { slug: string }): Promise<LetterboxdFilm>;
+
+    /**
+     * Lists the films a member has logged, newest first — { member: "davidehrlich" }, with `limit`
+     * capping rows (default 72, max 200). Returns slug, title, year and URL per film, which is
+     * what `film` takes to go deeper on any one of them.
+     */
+    memberFilms(args: { member: string, limit?: number }): Promise<LetterboxdMemberFilm[]>;
+
+    /**
+     * Reads a member's activity feed: every film they logged, with their own star rating, the date
+     * they watched it, whether it was a rewatch, whether they liked it, and the full text of any
+     * review they wrote. The review prose is the part no listing page carries. List and like
+     * activity is skipped.
+     */
+    memberDiary(args: { member: string, limit?: number }): Promise<LetterboxdDiaryEntry[]>;
+  }
+}
+
 declare namespace BowmarkProvider_linkedin {
   // ── LinkedIn — the unit's own declarations, verbatim ──
 interface LinkedinJobSearchResult {
@@ -26343,6 +27026,77 @@ interface OliverwineryShippingAvailability {
   }
 }
 
+declare namespace BowmarkProvider_onthemarket {
+  // ── OnTheMarket — the unit's own declarations, verbatim ──
+interface SearchArgs {
+  location: string;
+  type: "sale" | "rent";
+}
+
+interface OnTheMarketProperty {
+  id: string;
+  title: string;
+  price?: string;
+  location: string;
+  propertyType?: string; // the site's own labels — read the values off a result, never guess one from prose
+  bedrooms?: number;
+  bathrooms?: number;
+  description?: string;
+  url?: string;
+}
+
+  /** Search for residential property listings for sale or rent in the UK. */
+  interface Unit {
+    /** Search for residential properties by location and type (sale or rent) */
+    search(args: SearchArgs): Promise<OnTheMarketProperty[]>;
+  }
+}
+
+declare namespace BowmarkProvider_originenergy_com_au {
+  // ── Origin Energy — the unit's own declarations, verbatim ──
+// Origin Energy's OWN shapes — not a capability contract.
+
+interface OriginBusinessElectricityPlan {
+  title: string;
+  code: string;               // e.g. "E_SMEGOVARIABLEOG_8PC_VAR_AUSGRID_260701_CP"
+  description: string;
+  contractPeriod: number | null;
+  distributor: string | null;       // e.g. "Ausgrid Operations Partnership"
+  tariffName: string | null;        // e.g. "Business, single rate"
+  referenceUsage: string;           // e.g. "10000 kWh / yearly"
+  annualCost: number | null;
+  monthlyCost: number | null;
+  referenceCost: number | null;     // the DMO/VDO benchmark this plan compares against
+  percentSavingVsReference: number | null;
+  isRegulated: boolean;
+}
+
+interface OriginBusinessElectricityQuote {
+  postcode: string;
+  state: string;               // derived from the postcode, not asked of the caller
+  serviceable: boolean;        // false where Origin does not retail electricity (e.g. WA, TAS, NT)
+  plans: OriginBusinessElectricityPlan[];
+}
+
+interface OriginBusinessElectricityQuoteArgs { postcode: string }
+
+  /**
+   * originenergy.com.au business electricity quote — every plan Origin Energy offers in a
+   * postcode's distributor territory, priced at the regulator's standard reference consumption,
+   * the same live call the site's own 'Compare business plans' page makes.
+   */
+  interface Unit {
+    /**
+     * Returns every business electricity plan Origin Energy offers in a postcode's distributor
+     * territory, each priced at the regulator's standard reference consumption (10,000 kWh/year) —
+     * the same live call the site's own 'Compare business plans' page makes. `serviceable: false`
+     * with an empty `plans` array is Origin's own honest answer for a postcode it does not retail
+     * electricity into (WA, TAS, NT), not a failure.
+     */
+    getBusinessElectricityQuote(arg0: OriginBusinessElectricityQuoteArgs): Promise<OriginBusinessElectricityQuote>;
+  }
+}
+
 declare namespace BowmarkProvider_othership {
   // ── Othership — the unit's own declarations, verbatim ──
 // Othership's OWN shapes — not a capability contract.
@@ -26666,6 +27420,62 @@ interface PacificLifestyleHomesListing { id: string; address: string; city: stri
   }
 }
 
+declare namespace BowmarkProvider_packlane {
+  // ── Packlane — the unit's own declarations, verbatim ──
+type MailerBoxSize = "5x3x1.5" | "6x4x3" | "6x5x2.25" | "7x5x3" | "8x6x3" | "9x6x4"
+  | "9x7x2.25" | "9.5x7.75x4" | "10x8x4" | "11.25x9x3" | "12x9x2" | "12x10x4" | "13x10x5" | "14x10x4";
+type MailerBoxMaterial = "white" | "white-b-flute" | "dreamcoat" | "dreamcoat-b-flute" | "kraft" | "kraft-b-flute";
+type PrintSidesOption = "both-sides" | "outside" | "inside" | "blank";
+
+interface GetQuoteArgs {
+  size: MailerBoxSize;
+  material: MailerBoxMaterial;
+  printSides: PrintSidesOption;
+  quantity: number;
+}
+
+interface packlaneQuote {
+  size: MailerBoxSize;
+  material: MailerBoxMaterial;
+  printSides: PrintSidesOption;
+  quantity: number;
+  unitPrice: { amount: number; currency: string };
+  totalPrice: { amount: number; currency: string };
+  sku: string;
+  itemName: string;
+  turnaroundDays: number;
+}
+
+  /** Instant custom Mailer Box quotes from packlane.com. */
+  interface Unit {
+    /**
+     * Prices a custom Mailer Box (size, material, printed sides, quantity) via packlane.com's own
+     * on-page calculator API.
+     */
+    getQuote(args: GetQuoteArgs): Promise<packlaneQuote>;
+  }
+}
+
+declare namespace BowmarkProvider_pawsup {
+  // ── Paws Up — the unit's own declarations, verbatim ──
+interface AvailabilityResult {
+  available: boolean;
+  accommodationType?: string;
+  pricePerNight?: number;
+  currency: string;
+  checkInDate: string;
+  checkOutDate: string;
+  guests: number;
+  warnings?: string[];
+}
+
+  /** Luxury glamping resort availability and accommodations on Paws Up's booking portal. */
+  interface Unit {
+    /** Checks available accommodations and starting rates for a requested stay at Paws Up. */
+    checkAvailability(args: { checkInDate: string; checkOutDate: string; guests?: number }): Promise<AvailabilityResult>;
+  }
+}
+
 declare namespace BowmarkProvider_paypal {
   // ── PayPal — the unit's own declarations, verbatim ──
 interface PaypalEstimateFeeArgs {
@@ -27256,6 +28066,26 @@ interface PizzahutDealsForRender {
   }
 }
 
+declare namespace BowmarkProvider_planning_inspectorate_ni {
+  // ── Planning Inspectorate — National Infrastructure Planning — the unit's own declarations, verbatim ──
+interface PlanningInspectorateProject {
+  id: string;
+  name: string;
+  applicant?: string;
+  stage?: string;
+  url: string;
+}
+
+  /** Search the UK national infrastructure planning register by project name. */
+  interface Unit {
+    /**
+     * Searches the UK national infrastructure planning register by project name or keywords,
+     * returns matching projects with their id, name and register URL.
+     */
+    search(query: string): Promise<PlanningInspectorateProject[]>;
+  }
+}
+
 declare namespace BowmarkProvider_platform_claude_com {
   // ── Claude Developer Platform Docs — the unit's own declarations, verbatim ──
 interface platform_claude_comDoc {
@@ -27443,6 +28273,39 @@ interface positivegridRetailerSearch {
   }
 }
 
+declare namespace BowmarkProvider_postcard_direct_mail {
+  // ── Direct Mail Postcard Quotes — the unit's own declarations, verbatim ──
+interface GetQuoteArgs {
+  quantity: number
+  size?: string
+  stock?: string
+}
+
+interface PostcardQuoteLineItem {
+  size: string
+  stock: string
+  totalPrice: number
+  unitPrice: number
+  currency: string
+}
+
+interface PostcardDirectMailQuoteResponse {
+  quantity: number
+  lineItems: PostcardQuoteLineItem[]
+  estimatedDeliveryDays?: number
+  warnings: string[]
+}
+
+  /** Get postcard printing quotes with pricing by quantity, size, and stock. */
+  interface Unit {
+    /**
+     * Returns pricing for direct mail postcards at the requested quantity with optional size and
+     * stock.
+     */
+    getQuote(args: GetQuoteArgs): Promise<PostcardDirectMailQuoteResponse>;
+  }
+}
+
 declare namespace BowmarkProvider_postiz {
   // ── Postiz — the unit's own declarations, verbatim ──
 interface PostizPost {
@@ -27480,6 +28343,33 @@ interface CreatePostArgs {
   }
 }
 
+declare namespace BowmarkProvider_powys {
+  // ── Powys planning applications — the unit's own declarations, verbatim ──
+interface powysApplication {
+  reference: string;
+  description: string;
+  address: string;
+  applicant: string;
+  dateSubmitted: string;
+  status: string;  // the site's own labels — read the values off a result, never guess one from prose
+  decision?: string;
+}
+
+interface powysSearchResult {
+  results: powysApplication[];
+}
+
+  /** Search Powys County Council planning applications by reference, address, or description. */
+  interface Unit {
+    /**
+     * Searches Powys County Council planning applications. Takes a required search term or
+     * reference (e.g., 'P/2024/0123' for a reference or 'Main Street' for an address) and returns
+     * matching applications with their status and decision details.
+     */
+    search(query: string): Promise<powysSearchResult>;
+  }
+}
+
 declare namespace BowmarkProvider_premierbuildings {
   // ── Premier Portable Buildings — the unit's own declarations, verbatim ──
 interface PremierbuildingsStyle {
@@ -27677,6 +28567,7 @@ interface PrimeVideoCategory {
 interface PrimeVideoCategoryRow {
   heading: string;
   titles: PrimeVideoTitle[];
+  nextPage?: string;
 }
 interface PrimeVideoTop10Entry extends PrimeVideoTitle {
   position: number;
@@ -27743,21 +28634,15 @@ interface PrimeVideoLiveSportsEvent {
      * 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). `options.waysToWatch` narrows by
-     * how you can watch it — "prime" (included with a Prime membership), "channels" (an add-on
-     * subscription) or "rentOrBuy" — the commonest thing a viewer does after typing a query and
-     * the one refinement built so far. The site's other five refinement dimensions (which channel,
-     * HD/UHD, theme, subtitle language, film-or-series) are still not built here: every one of
-     * them rides the same opaque per-page `serviceToken` mechanism (rung 11 — an undocumented
-     * endpoint reached by harvesting the token off the page a search already returned), never a
-     * query parameter, and a hand-constructed query parameter silently returns the unfiltered set
-     * rather than erroring. A query that matches nothing returns an empty array rather than
-     * throwing. A filtered call whose real matches are too few can carry the site's own generic
-     * recommendations under a heading still labelled "Top results" — measured 2026-09-16, not a
-     * defect in this parser: the site does this identically on the unfiltered page's own "More to
-     * explore" row.
-     */
-    searchTitles(query: string, options?: { waysToWatch?: "prime" | "channels" | "rentOrBuy" }): Promise<PrimeVideoTitle[]>;
+     * carries no pagination markers at all (measured 2026-09-15). This function took a
+     * `waysToWatch` refinement option for one day (2026-09-16 to 2026-09-17) — it was WITHDRAWN
+     * after the `qa` pass found the whole "Ways to Watch" refinement block gone from the
+     * logged-out search page, confirmed on two fresh live captures and a real browser (no
+     * `filters`/`p_n_ways_to_watch`/`serviceToken` anywhere in the hydration script or the
+     * rendered DOM; only an unrelated "Free to me" filter survives). 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
@@ -27785,9 +28670,11 @@ interface PrimeVideoLiveSportsEvent {
      * 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.
+     * getTitle(). Reads the SAME page as getTitle, never fetches it twice. A `subscribe` offer's
+     * `channel.benefitId` is the same slug listChannels() surfaces as `benefit` — a best-effort
+     * join, not a guaranteed one, see listChannels()'s own doc for the measured exception. 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>;
 
@@ -27843,8 +28730,13 @@ interface PrimeVideoLiveSportsEvent {
      * 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.
+     * storefront page opens with; every other row is real. **A row carrying more than the 20
+     * titles returned here has `nextPage`** (read the field's own doc) — pass it straight back to
+     * this function to read the next page. That page is genuinely new (measured: at most one
+     * overlapping title, at the boundary), and it never carries its own further `nextPage`, so
+     * this reaches one hop past the first 20, honestly, not an unbounded walk. `searchTitles()`
+     * carries no such field — its results page publishes no pagination markers at all (measured
+     * 2026-09-15), and that absence is a fact about search specifically.
      */
     listCategoryTitles(path: string): Promise<PrimeVideoCategoryRow[]>;
 
@@ -27905,31 +28797,49 @@ interface PrimeVideoLiveSportsEvent {
 
     /**
      * 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:
+     * Britbox, ViX Premium and a hundred-odd more — with the 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.
+     * channelId)); `benefitId`, which `GET /offers?benefitId=<benefitId>` takes to start a
+     * subscription; and `benefit`, the slug that also names which add-on a title's
+     * getWatchOptions() subscribe offer needs (`offers[].channel.benefitId`) — **the ONLY field
+     * that joins the two halves of this provider**, and a best-effort one, see its own doc for the
+     * measured miss. 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 — reads
+     * BOTH `GET /storefront/subscription/default` (the site's own categorized shop, deterministic,
+     * ~102 channels across six categories, each addressed by a `benefit` slug but carrying no
+     * `channelId`/`benefitId`) and `GET /addons` (a rotating shelf of ~80, the only source for
+     * `channelId`/`benefitId`, and offerMessage), merged so a channel present on either carries
+     * the fullest card either door gave it. **Neither door alone was ever complete** — measured
+     * 2026-09-18, the storefront door found 44 channels the addons shelf's shorter rotation
+     * missed, and the addons shelf found 22 the storefront door's own categorization missed
+     * (Peacock Premium Plus, NBA League Pass, Tennis Channel, MLB Network among them) — so this is
+     * the union, not either one. **Still not exhaustive**: one storefront category
+     * ("Entertainment") is short 2 of 22 cards behind its own unbuilt pagination cursor. **Carries
+     * no price.** The dollar strings on either page are a card's own compact offer wording, never
+     * a clean number, so `offerMessage` carries the site's own sentence instead when the card has
+     * one. Most `/addons`-sourced cards carry both `channelId` and `benefitId`; a card with no
+     * channel page of its own (CNN All Access) carries only `benefitId`; a card reached only
+     * through the storefront door carries neither — all 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>;
+     * subscribing to this to watch that" rather than one title. Takes EITHER of the site's two
+     * doors: the channel's uuid off listChannels() (its `channelId`, or a `/channel/<uuid>` URL) —
+     * `GET /channel/<uuid>` — OR its benefit slug off a title's own subscribe offer
+     * (getWatchOptions().offers[].channel.benefitId, or its `/storefront/subscription/<slug>` link
+     * — pass that link straight through, no join needed) — `GET /storefront/subscription/<slug>`.
+     * Both routes read 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. Widened because listChannels()'s
+     * `/addons`-sourced cards are only a rotating slice of the shop, and its storefront-sourced
+     * cards carry no `channelId` at all (see its own summary) — a slug a title names is often
+     * absent from any card a caller could join against, so the slug door needs no `listChannels()`
+     * round-trip at all.
+     */
+    getChannel(channel: string): Promise<PrimeVideoChannelDetail>;
 
     /**
      * List the free live TV ("livetv", off `/livetv`) or news ("news", off `/news`) stations Prime
@@ -27977,6 +28887,20 @@ interface PrimeVideoLiveSportsEvent {
      * failure.
      */
     listLiveSports(): Promise<PrimeVideoLiveSportsEvent[]>;
+
+    /**
+     * What to watch next after this one — the commonest thing anyone says after the credits roll,
+     * and the one ordinary catalogue question the rest of this provider cannot answer at all:
+     * searching the film's own name (searchTitles()) returns its sequels, not a recommendation.
+     * Takes a titleId or a title URL, e.g. one read off searchTitles() or getTitle(). Reads the
+     * SAME cached page as getTitle, never fetches it twice. Returns one row per carousel the
+     * detail page carries below the fold — typically "Customers also watched" (real titles, not
+     * the one just watched or its own sequels) and, when the title belongs to one, "Explore the …
+     * collection" for the rest of the franchise — in the SAME shape listCategoryTitles() returns,
+     * so a caller reads both the same way. A title with no such rows on its page returns an empty
+     * array, a real, if unlikely, answer.
+     */
+    listRelatedTitles(titleId: string): Promise<PrimeVideoCategoryRow[]>;
   }
 }
 
@@ -34295,9 +35219,8 @@ interface ShippingBoxPrice {
 }
 
   /**
-   * Prices Vistaprint's Full-Print Shipping Boxes for a real size, print area and quantity — the
-   * live, quantity-tiered price the site's own PDP configurator computes, with no browser,
-   * account or cart. Custom printed boxes, mailer boxes and packaging boxes.
+   * Prices Vistaprint's Full-Print Shipping Boxes — real, quantity-tiered pricing the site's own
+   * PDP configurator computes, with no browser, account or cart.
    */
   interface Unit {
     /**
@@ -34722,6 +35645,38 @@ interface wellfoundCompanyDetail {
   }
 }
 
+declare namespace BowmarkProvider_wholefoodsmarket {
+  // ── Whole Foods — the unit's own declarations, verbatim ──
+interface Product {
+  id: string;
+  name: string;
+  price?: number;
+  unit?: string;
+}
+
+interface SearchResults {
+  products: Product[];
+  warnings: string[];
+}
+
+  /**
+   * Search Whole Foods product catalog by a SPECIFIC product or category name (e.g. 'organic
+   * apples'). The store name alone ('whole foods') is not a valid query — it requires a product
+   * to search for.
+   */
+  interface Unit {
+    /**
+     * ⚠️ REQUIRED: This function ONLY accepts a SPECIFIC product or category search query (e.g.
+     * 'organic apples', 'sourdough bread'). The store name 'Whole Foods' alone IS NOT A VALID
+     * QUERY. You MUST have a product name from the caller before calling this. If caller only said
+     * 'Whole Foods' with no product: STOP. Ask the caller FIRST: 'What specific product would you
+     * like me to search for at Whole Foods?' Wait for their answer. ONLY THEN call this function
+     * with the product name they give you. Calling without a product query will fail.
+     */
+    search(query: string): Promise<SearchResults>;
+  }
+}
+
 declare namespace BowmarkProvider_winestyles {
   // ── WineStyles — the unit's own declarations, verbatim ──
 interface WinestylesStore {
@@ -35069,6 +36024,275 @@ interface YoutubeVideo {
   thumbnails: { url: string; width: number; height: number }[];
 }
 
+interface YoutubeCaptionTrack {
+  languageCode: string;      // e.g. "en", "de-DE", "pt-BR"
+  name: string;               // the site's own display name, e.g. "English (auto-generated)"
+  isAutoGenerated: boolean;   // true for a track YouTube generated itself, false for a human/uploader one
+  isDefault: boolean;         // true for the track getTranscript reads by default
+}
+
+interface YoutubeComment {
+  commentId: string;
+  author: string;
+  authorChannelId: string | null;
+  text: string;
+  likeCount: string;         // YouTube's own abbreviated text, e.g. "316K" — never an exact number
+  publishedTime: string;     // YouTube's own relative phrase, e.g. "1 year ago"
+  replyCount: number;
+  isPinned: boolean;
+  isHeartedByCreator: boolean;
+  repliesContinuation: string | null; // pass to listCommentReplies as { continuation }; null when replyCount is 0
+}
+
+interface YoutubeCommentPage {
+  comments: YoutubeComment[];
+  continuation: string | null; // pass back as { continuation } for the next page; null on the last
+}
+
+interface YoutubeCommentReply {
+  commentId: string;
+  author: string;
+  authorChannelId: string | null;
+  text: string;
+  likeCount: string;      // same convention as YoutubeComment.likeCount
+  publishedTime: string;  // YouTube's own relative phrase, e.g. "1 year ago"
+  isHeartedByCreator: boolean;
+}
+
+interface YoutubeCommentReplyPage {
+  replies: YoutubeCommentReply[];
+  continuation: string | null; // pass back as { continuation } for the next page; null on the last
+}
+
+interface YoutubeChannelLink {
+  title: string;
+  url: string; // the real destination, decoded off YouTube's own redirect wrapper
+}
+
+interface YoutubeChannel {
+  channelId: string;
+  handle: string | null;       // null for a legacy /c/ or /user/ vanity URL with no @handle
+  title: string;
+  description: string;
+  subscriberCountText: string | null; // YouTube's own abbreviated text, e.g. "517M subscribers"
+  videoCount: number | null;
+  viewCount: number | null;
+  country: string | null;
+  joinedDate: string | null;   // ISO 8601 date
+  links: YoutubeChannelLink[];
+  avatar: string | null;
+  banner: string | null;
+}
+
+interface YoutubeChannelVideo {
+  videoId: string;
+  url: string;
+  title: string;
+  views: string | null;       // YouTube's own abbreviated text, e.g. "101M views"
+  published: string | null;   // YouTube's own phrase, e.g. "11 days ago"
+  publishedAgeSeconds: number | null;
+  length: string | null;      // e.g. "23:28"; null for a live stream
+  thumbnail: string | null;
+}
+
+interface YoutubeChannelVideoPage {
+  videos: YoutubeChannelVideo[];
+  continuation: string | null; // pass back as { continuation } for the next page; null on the last
+}
+
+interface YoutubeChannelShort {
+  videoId: string;
+  url: string;                // https://www.youtube.com/shorts/<id> — a Short has no watch?v= URL
+  title: string;
+  views: string | null;       // YouTube's own abbreviated text WITH "views" already in it, e.g. "13M views"
+  thumbnail: string | null;
+  // no publish date, no length — neither exists anywhere in the Shorts-tab shape
+}
+
+interface YoutubeChannelShortPage {
+  shorts: YoutubeChannelShort[];
+  continuation: string | null; // pass back as { continuation } for the next page; null on the last
+}
+
+type YoutubeChannelLiveStreamStatus = "upcoming" | "live" | "ended";
+
+interface YoutubeChannelLiveStream {
+  videoId: string;
+  url: string;
+  title: string;
+  status: YoutubeChannelLiveStreamStatus;
+  watching: string | null;    // "N watching" (live) or "N waiting" (upcoming); null once ended
+  views: string | null;       // YouTube's own abbreviated text, e.g. "94K views" — ended only
+  scheduledFor: string | null; // e.g. "Scheduled for 9/19/26, 6:00 AM" — upcoming only
+  published: string | null;   // e.g. "Streamed 1 day ago" — ended only
+  publishedAgeSeconds: number | null;
+  length: string | null;      // e.g. "9:05:30" — ended only
+  thumbnail: string | null;
+}
+
+interface YoutubeChannelLiveStreamPage {
+  streams: YoutubeChannelLiveStream[];
+  continuation: string | null; // pass back as { continuation } for the next page; null on the last
+}
+
+interface YoutubeChannelPlaylist {
+  playlistId: string;
+  url: string;
+  title: string;
+  count: string | null;   // YouTube's own badge text, e.g. "197 videos" or "20 episodes" for a podcast
+  updated: string | null; // e.g. "today", "5 days ago" — null when the row carries no update stat
+  thumbnail: string | null;
+}
+
+interface YoutubeChannelPlaylistPage {
+  playlists: YoutubeChannelPlaylist[];
+  continuation: string | null; // pass back as { continuation } for the next page; null on the last
+}
+
+interface YoutubeChannelPostImage {
+  kind: "image";
+  images: string[]; // one or several, largest available URL each
+}
+
+interface YoutubeChannelPostPoll {
+  kind: "poll";
+  choices: string[]; // choice text only — vote counts are hidden from a logged-out viewer
+}
+
+interface YoutubeChannelPostVideo {
+  kind: "video"; // a video the channel shared into this tab — may belong to another channel
+  videoId: string;
+  title: string | null;
+}
+
+type YoutubeChannelPostAttachment =
+  | YoutubeChannelPostImage
+  | YoutubeChannelPostPoll
+  | YoutubeChannelPostVideo
+  | null;
+
+interface YoutubeChannelPost {
+  postId: string;
+  url: string;
+  author: string | null;
+  text: string | null;
+  published: string | null;   // YouTube's own phrase, e.g. "2 weeks ago", "(edited)" appended on an edited post
+  publishedAgeSeconds: number | null;
+  likeCount: string | null;    // YouTube's own abbreviated text, e.g. "407K" — no "likes"
+  commentCount: string | null; // YouTube's own abbreviated text, e.g. "6.7K" — no "comments"
+  attachment: YoutubeChannelPostAttachment;
+}
+
+interface YoutubeChannelPostPage {
+  posts: YoutubeChannelPost[];
+  continuation: string | null; // pass back as { continuation } for the next page; null on the last
+}
+
+interface YoutubeChannelSearchPage {
+  videos: YoutubeSearchVideo[];
+  continuation: string | null; // pass back as { continuation } for the next page; null on the last
+}
+
+interface YoutubeRelatedVideo {
+  videoId: string;
+  url: string;
+  title: string;
+  channel: string | null;
+  channelId: string | null;
+  views: string | null;       // YouTube's own abbreviated text, e.g. "206M" — the bare number, not "206M views"
+  published: string | null;   // YouTube's own phrase, e.g. "16y ago"
+  publishedAgeSeconds: number | null;
+  length: string | null;      // e.g. "3:24"; null for a live stream
+  thumbnail: string | null;
+}
+
+interface YoutubeRelatedVideoPage {
+  videos: YoutubeRelatedVideo[];
+  continuation: string | null; // pass back as { continuation } for the next page; null on the last
+}
+
+interface YoutubeChapter {
+  title: string;
+  startSeconds: number;    // pass to watch?v=<id>&t=<startSeconds>s
+  timeDescription: string; // YouTube's own display text, e.g. "1:03:10"
+}
+
+interface YoutubeLiveChatMessage {
+  authorName: string;
+  authorChannelId: string | null;
+  text: string;
+  timestampUsec: string; // YouTube's own microsecond epoch timestamp, as a string
+}
+
+interface YoutubeLiveChat {
+  open: boolean;               // false when there is no chat to read at all — see notice
+  notice: string | null;       // the site's own sentence when open is false
+  messages: YoutubeLiveChatMessage[];
+  continuation: string | null; // pass back as { continuation } for the next batch; null once the chat has ended
+}
+
+interface YoutubePlaylist {
+  playlistId: string;
+  title: string;
+  description: string;       // "" when the playlist has none (e.g. a channel's auto Uploads playlist)
+  channelId: string | null;
+  channelTitle: string | null;
+  videoCount: number | null;
+  viewCount: number | null;
+  lastUpdated: string | null; // YouTube's own text: an absolute date, or "N days ago" on an Uploads playlist
+  thumbnail: string | null;
+}
+
+interface YoutubePlaylistVideo {
+  videoId: string;
+  url: string;
+  title: string;
+  channelId: string | null;   // the PUBLISHING channel, which can differ from the playlist owner
+  channelTitle: string | null;
+  views: string | null;       // YouTube's own abbreviated text, e.g. "4.9M views"
+  published: string | null;   // YouTube's own phrase, e.g. "5 years ago"
+  publishedAgeSeconds: number | null;
+  length: string | null;      // e.g. "1:00:02"; null for a live stream
+  thumbnail: string | null;
+}
+
+interface YoutubeCreatedChannel {
+  channelId: string;
+  name: string;                // the account's own Google profile name
+  url: string;
+  alreadyExisted: boolean;     // true when the account already had one; nothing was created
+}
+
+interface YoutubeCreatedPlaylist {
+  playlistId: string;
+  title: string;
+  privacy: "private" | "unlisted" | "public";
+  url: string;                 // open this to see it
+}
+
+interface YoutubePlaylistEdit {
+  playlistId: string;
+  added: string[];             // what was sent and accepted, in order — not a per-video receipt
+  url: string;
+}
+
+interface YoutubePlaylistVideoPage {
+  videos: YoutubePlaylistVideo[];
+  continuation: string | null; // pass back as { continuation } for the next page; null on the last
+}
+
+interface YoutubeStreamFormat {
+  itag: number;
+  mimeType: string;
+  bitrate: number;
+  width: number | null;
+  height: number | null;
+  fps: number | null;
+  qualityLabel: string | null;
+  contentLength: string | null;  // null on the muxed entry — YouTube does not publish it there
+  approxDurationMs: string | null;
+}
+
   /**
    * A YouTube video's own caption transcript, read off the site's own Transcript panel —
    * timestamped lines plus the full text as one string. Language selection is not offered yet;
@@ -35084,6 +36308,14 @@ interface YoutubeVideo {
      */
     search(input: { query: string; uploadedWithin?: "today" | "week" | "month" | "year" }): Promise<YoutubeSearchVideo[]>;
 
+    /**
+     * YouTube's own autocomplete for a partial query — the dropdown it shows while somebody is
+     * still typing, in the site's own ranked order. Use it to turn a vague phrase into the wording
+     * YouTube actually indexes before spending a call on `search`. A query matching nothing
+     * returns a real, honest empty array rather than throwing.
+     */
+    suggestSearches(input: { query: string }): Promise<string[]>;
+
     /**
      * Returns a YouTube video's own caption transcript. `video` is a bare 11-character video id or
      * any watch/shorts/embed/live/youtu.be URL. `segments` is [] — a real, honest answer — when
@@ -35110,6 +36342,244 @@ interface YoutubeVideo {
      * watch/shorts/embed/live/youtu.be URL, exactly as `getTranscript` takes it.
      */
     getVideo(input: { video: string }): Promise<YoutubeVideo>;
+
+    /**
+     * What people said under a video — each comment's author, text, like count (YouTube's own
+     * abbreviated text, e.g. "316K"), how long ago it was posted, its reply count, and whether the
+     * thread is pinned or was hearted by the creator. `sortBy` picks YouTube's own "Top" or
+     * "Newest" ordering (default Top) on the first call; pass back `continuation` alone — no
+     * `video` needed, it is self-contained — to read the next page. `continuation` is null once
+     * there are no more pages.
+     */
+    listComments(input: { video: string; sortBy?: "top" | "newest" } | { continuation: string }): Promise<YoutubeCommentPage>;
+
+    /**
+     * The replies under one comment thread, which YouTube hides behind a "N replies" button and
+     * never ships with the thread itself. `continuation` is a thread's own `repliesContinuation`
+     * off a `listComments` row (null when it has no replies) for the first page, or this
+     * function's own returned `continuation` for the next one; it is null once there are no more
+     * pages. Each reply carries its author, text, like count and whether the creator hearted it —
+     * no reply count or pinned flag, since a reply cannot itself be a thread or be pinned.
+     */
+    listCommentReplies(input: { continuation: string }): Promise<YoutubeCommentReplyPage>;
+
+    /**
+     * The videos YouTube itself puts next to this one — the "up next" rail — each with its id,
+     * title, channel, YouTube's own abbreviated view-count text (e.g. "206M", without the word
+     * "views"), upload age, length and thumbnail. `video` is a bare 11-character video id or any
+     * watch/shorts/embed/live/youtu.be URL, exactly as `getTranscript` takes it. Pass back
+     * `continuation` alone — no `video` needed — to read the next page; it is null once YouTube
+     * offers no further "Show more", which some videos never do even on page 1.
+     */
+    listRelatedVideos(input: { video: string } | { continuation: string }): Promise<YoutubeRelatedVideoPage>;
+
+    /**
+     * A video's own chapter markers — the labelled sections YouTube shows on the scrub bar — each
+     * with its title, start time in seconds and YouTube's own display text for that time (e.g.
+     * "1:03:10"). `video` is a bare 11-character video id or any watch/shorts/embed/live/youtu.be
+     * URL, exactly as `getTranscript` takes it. `[]` when the video has no chapters at all — a
+     * real, honest answer, not a failure.
+     */
+    listChapters(input: { video: string }): Promise<YoutubeChapter[]>;
+
+    /**
+     * The messages scrolling past a live stream right now — each with its author, text and
+     * YouTube's own microsecond timestamp. `video` is a bare 11-character video id or any
+     * watch/shorts/embed/live/youtu.be URL, exactly as `getTranscript` takes it, for the FIRST
+     * call; pass back `continuation` alone — no `video` needed — to read what arrived since.
+     * `open` is false, with the site's own `notice` sentence (e.g. "Chat is disabled for this live
+     * stream."), when the stream has never gone live, its chat is off, or it already ended —
+     * nothing in the response tells those three apart. `continuation` is null once the stream
+     * stops offering one.
+     */
+    getLiveChat(input: { video: string } | { continuation: string }): Promise<YoutubeLiveChat>;
+
+    /**
+     * Which languages a video's captions are available in, whether each was written by a
+     * human/uploader or generated by YouTube itself, and which one `getTranscript` reads by
+     * default. `video` is a bare 11-character video id or any watch/shorts/embed/live/youtu.be
+     * URL, exactly as `getTranscript` takes it. `[]` when the video has no captions at all — a
+     * real, honest answer, not a failure. Does not itself return caption text or a language choice
+     * for `getTranscript`, which today always reads the default track.
+     */
+    listCaptionTracks(input: { video: string }): Promise<YoutubeCaptionTrack[]>;
+
+    /**
+     * The renditions a video is actually available in — resolution, frame rate, codec, bitrate,
+     * approximate file size and duration for each video and audio stream YouTube holds. Answers
+     * "is this available in 4K" and "how big is it". It returns the CATALOGUE of formats, not a
+     * playable or downloadable link: see the manifest note on why playable URLs are a separate
+     * (rung 14) problem.
+     */
+    listStreamFormats(input: { video: string }): Promise<YoutubeStreamFormat[]>;
+
+    /**
+     * The videos on one of YouTube's own hashtag pages (`youtube.com/hashtag/<tag>`) — a topic
+     * feed reachable from a bare word, with no channel and no search ranking in the way. Same row
+     * shape `search` returns. `hashtag` is the bare tag, with or without a leading "#". This is a
+     * curated, CAPPED feed rather than a paged one — no tag measured carries a "show more", so
+     * `[]` back means the site had nothing to show ("Not much to see right now"), not that the
+     * call failed.
+     */
+    listHashtagVideos(input: { hashtag: string }): Promise<YoutubeSearchVideo[]>;
+
+    /**
+     * A channel's own page as facts: display name, @handle, an abbreviated subscriber count text
+     * (YouTube never publishes an exact one), the About tab's full description, total video count,
+     * lifetime view count, country, the ISO date it joined, the links it lists (resolved to their
+     * real destination, not YouTube's redirect wrapper), and its avatar and banner images.
+     * `channel` is a channel id (`UC…`), an `@handle`, or a channel URL — not a plain name, which
+     * `findChannel` resolves to an id first. Every field past `channelId`/`handle`/`title` comes
+     * off the About panel; on the rare response that carries no panel at all they come back
+     * null/empty rather than throwing.
+     */
+    getChannel(input: { channel: string }): Promise<YoutubeChannel>;
+
+    /**
+     * What a channel has published, newest first and paged — each video's id, url, title,
+     * YouTube's own abbreviated view-count text (e.g. "101M views"), upload age, length and
+     * thumbnail. `channel` takes a channel id, an @handle, or a channel URL, exactly as
+     * `getChannel` does — not a plain name, which `findChannel` resolves first. Pass back
+     * `continuation` alone — no `channel` needed — to read the next page; it is null once there
+     * are no more pages.
+     */
+    listChannelVideos(input: { channel: string } | { continuation: string }): Promise<YoutubeChannelVideoPage>;
+
+    /**
+     * What a channel has published to its Shorts tab, in the site's own order and paged — each
+     * short's id, its `/shorts/<id>` url, title, and YouTube's own abbreviated view-count text
+     * (e.g. "13M views"). `channel` takes a channel id, an @handle, or a channel URL, exactly as
+     * `listChannelVideos` does. A Short's own page carries no publish date and no length anywhere
+     * in the site's data — YouTube does not publish either for this tab, so neither field exists
+     * on the row. Pass back `continuation` alone — no `channel` needed — to read the next page; it
+     * is null once there are no more pages.
+     */
+    listChannelShorts(input: { channel: string } | { continuation: string }): Promise<YoutubeChannelShortPage>;
+
+    /**
+     * A channel's Live tab, paged — upcoming, in-progress and past broadcasts, in the site's own
+     * order. Each row carries `status` (`"upcoming" | "live" | "ended"`): upcoming carries
+     * `watching` as a waiting-room count and `scheduledFor`; live carries `watching` as a
+     * concurrent viewer count; ended carries `views`, `published` ("Streamed 1 day ago") and
+     * `length`, the same fields `listChannelVideos` returns. `channel` takes a channel id, an
+     * @handle, or a channel URL, exactly as `listChannelVideos` does. A channel that has never
+     * streamed carries no Live tab at all — YouTube answers with its Home tab instead — which
+     * reads back as `{ streams: [], continuation: null }`, the same empty page a channel with a
+     * Live tab and zero streams on it would return. Pass back `continuation` alone — no `channel`
+     * needed — to read the next page; it is null once there are no more pages.
+     */
+    listChannelLiveStreams(input: { channel: string } | { continuation: string }): Promise<YoutubeChannelLiveStreamPage>;
+
+    /**
+     * The playlists a channel has published, in the site's own order and paged — each one's id,
+     * its `/playlist?list=<id>` url, title, YouTube's own badge text ("197 videos", or "20
+     * episodes" for a podcast the channel runs, which lives on this same tab), and its "Updated …"
+     * stat with the prefix stripped ("today", "5 days ago") — null when a playlist carries no
+     * update stat at all. `channel` takes a channel id, an @handle, or a channel URL, exactly as
+     * `listChannelVideos` does. The door from a channel to `getPlaylist` and `listPlaylistVideos`.
+     * Pass back `continuation` alone — no `channel` needed — to read the next page; it is null
+     * once there are no more pages.
+     */
+    listChannelPlaylists(input: { channel: string } | { continuation: string }): Promise<YoutubeChannelPlaylistPage>;
+
+    /**
+     * A channel's Community tab — the text, image and poll posts a creator writes between uploads,
+     * never appearing on any video tab. Each post carries its author, plain text, YouTube's own
+     * relative age ("2 weeks ago", "(edited)" appended on an edited post), abbreviated like and
+     * comment counts ("407K", "6.7K", without the words), and an `attachment` of one of three
+     * kinds — `{ kind: "image", images }` (one or several), `{ kind: "poll", choices }` (choice
+     * text only, no vote counts — hidden from a logged-out viewer), `{ kind: "video", videoId,
+     * title }` (a video the channel shared into the tab, which can belong to another channel
+     * entirely) — or `null` for a text-only post. `channel` takes a channel id, an @handle, or a
+     * channel URL, exactly as `listChannelVideos` does. Pass back `continuation` alone — no
+     * `channel` needed — to read the next page; it is null once there are no more pages.
+     */
+    listChannelPosts(input: { channel: string } | { continuation: string }): Promise<YoutubeChannelPostPage>;
+
+    /**
+     * Search one channel's own videos rather than the whole site — the search box on a channel
+     * page. Returns the same video rows `search` does (id, url, title, channel, upload age,
+     * length, views), scoped to that channel and paged. `channel` takes a channel id, an @handle,
+     * or a channel URL, exactly as `listChannelVideos` does. A channel with no match at all
+     * answers a real, honest empty page rather than throwing. Pass back `continuation` alone — no
+     * `channel`/`query` needed — to read the next page; it is null once there are no more pages.
+     */
+    searchWithinChannel(input: { channel: string; query: string } | { continuation: string }): Promise<YoutubeChannelSearchPage>;
+
+    /**
+     * A playlist's own facts: title, description, the channel that owns it, exact video and view
+     * counts, and when it was last updated (an absolute date on an ordinary playlist, YouTube's
+     * own relative phrase like "5 days ago" on a channel's auto-generated Uploads playlist).
+     * `playlist` is a playlist id or any playlist/watch URL carrying a `list` param — including a
+     * channel's Uploads playlist, whose id is always `"UU" + channelId.slice(2)`.
+     */
+    getPlaylist(input: { playlist: string }): Promise<YoutubePlaylist>;
+
+    /**
+     * The videos inside a playlist, in the playlist's own order and paged — each video's id, url,
+     * title, the channel that PUBLISHED it (not necessarily the playlist owner), YouTube's own
+     * abbreviated view-count text, upload age, length and thumbnail. `playlist` takes the same id
+     * or URL `getPlaylist` does, including a channel's Uploads playlist (`"UU" +
+     * channelId.slice(2)`). Pass back `continuation` alone — no `playlist` needed — to read the
+     * next page; it is null once there are no more pages.
+     */
+    listPlaylistVideos(input: { playlist: string } | { continuation: string }): Promise<YoutubePlaylistVideoPage>;
+
+    /**
+     * The videos on the signed-in account's own YouTube home page — the personalized
+     * recommendation grid, in YouTube's own order, which is what that account actually sees on
+     * youtube.com right now. NEEDS A SIGN-IN and exists nowhere else: it is not in the public Data
+     * API, and logged out the same request answers 200 with an EMPTY grid rather than an error.
+     * Call `bowmark.video_library.homeFeed` rather than this directly.
+     */
+    listHomeFeed(input?: { limit?: number }): Promise<YoutubeSearchVideo[]>;
+
+    /**
+     * The signed-in account's Watch Later queue, newest first, paged like any playlist. NEEDS A
+     * SIGN-IN, and a grant is issued to a capability — call `bowmark.video_library.watchLater`
+     * rather than this directly. Not reachable through YouTube's public Data API at all: Google
+     * removed access to the `WL` list in 2016.
+     */
+    listWatchLater(input?: { continuation?: string }): Promise<YoutubePlaylistVideoPage>;
+
+    /**
+     * The videos the signed-in account has liked, newest first, paged like any playlist. NEEDS A
+     * SIGN-IN — call `bowmark.video_library.liked` rather than this directly.
+     */
+    listLikedVideos(input?: { continuation?: string }): Promise<YoutubePlaylistVideoPage>;
+
+    /**
+     * Creates an EMPTY playlist on the signed-in account and returns its id and URL. `privacy`
+     * defaults to "private". NOT idempotent — YouTube allows duplicate titles, so calling twice
+     * makes two playlists. Title it for the PERSON whose account it lands on: the subject in their
+     * own words, never a tool name, run id or timestamp, and set `description` to what the videos
+     * have in common. NEEDS A SIGN-IN — call `bowmark.video_library.createPlaylist` rather than
+     * this directly.
+     */
+    createPlaylist(input: { title: string; description?: string; privacy?: "private" | "unlisted" | "public" }): Promise<YoutubeCreatedPlaylist>;
+
+    /**
+     * Creates the signed-in Google account's YouTube CHANNEL, using the account's own name and
+     * profile photo — the only thing YouTube's own dialog offers on this path. Most Google
+     * accounts have never had one, and without one YouTube refuses to make a public or unlisted
+     * playlist (a private one works, because that belongs to the account rather than to a
+     * channel). THIS ACCEPTS YOUTUBE'S TERMS OF SERVICE on the account holder's behalf, which is
+     * what their own Create channel button does, so do not call it to work around an error — call
+     * it because the person whose account it is asked for a channel. Idempotent: an account that
+     * already has one gets `alreadyExisted: true` and nothing is created. NEEDS A SIGN-IN.
+     */
+    createChannel(): Promise<YoutubeCreatedChannel>;
+
+    /**
+     * Adds one or many videos to one of the signed-in account's own playlists, as a SINGLE edit
+     * rather than one request per video. Order is preserved: the videos appear in the order they
+     * were sent, measured 2026-09-18. A playlist READ BACK IN THE SAME RUN can still come back
+     * empty — the write is applied but YouTube indexes it a beat later, measured at ~2s — so do
+     * not treat an immediate empty read as a failed add. YouTube permits duplicates, so adding a
+     * video already present adds it again. NEEDS A SIGN-IN — call
+     * `bowmark.video_library.addToPlaylist` rather than this directly.
+     */
+    addToPlaylist(input: { playlist: string; video?: string; videos?: string[] }): Promise<YoutubePlaylistEdit>;
   }
 }
 
@@ -36013,6 +37483,7 @@ interface BowmarkProviders {
   acqualinaresort: BowmarkProvider_acqualinaresort.Unit;
   ai_engineer: BowmarkProvider_ai_engineer.Unit;
   aiper: BowmarkProvider_aiper.Unit;
+  airtable: BowmarkProvider_airtable.Unit;
   ajmadison: BowmarkProvider_ajmadison.Unit;
   allied: BowmarkProvider_allied.Unit;
   alphavantage: BowmarkProvider_alphavantage.Unit;
@@ -36047,6 +37518,7 @@ interface BowmarkProviders {
   ayreshotels: BowmarkProvider_ayreshotels.Unit;
   azazie: BowmarkProvider_azazie.Unit;
   azure: BowmarkProvider_azure.Unit;
+  bahn: BowmarkProvider_bahn.Unit;
   bankmycell: BowmarkProvider_bankmycell.Unit;
   barletta: BowmarkProvider_barletta.Unit;
   barnesfoundation: BowmarkProvider_barnesfoundation.Unit;
@@ -36079,7 +37551,6 @@ interface BowmarkProviders {
   boydsleep: BowmarkProvider_boydsleep.Unit;
   brius: BowmarkProvider_brius.Unit;
   brixton: BowmarkProvider_brixton.Unit;
-  browser_use: BowmarkProvider_browser_use.Unit;
   builder_strucsure_com: BowmarkProvider_builder_strucsure_com.Unit;
   bulletproof: BowmarkProvider_bulletproof.Unit;
   bungalow: BowmarkProvider_bungalow.Unit;
@@ -36128,6 +37599,7 @@ interface BowmarkProviders {
   completehomewarranty_com: BowmarkProvider_completehomewarranty_com.Unit;
   consultnet: BowmarkProvider_consultnet.Unit;
   costco: BowmarkProvider_costco.Unit;
+  countycourt_vic_gov_au: BowmarkProvider_countycourt_vic_gov_au.Unit;
   couponfollow: BowmarkProvider_couponfollow.Unit;
   credibly_com: BowmarkProvider_credibly_com.Unit;
   cruiselakegeneva: BowmarkProvider_cruiselakegeneva.Unit;
@@ -36145,7 +37617,9 @@ interface BowmarkProviders {
   deltadentalma: BowmarkProvider_deltadentalma.Unit;
   dentalplans: BowmarkProvider_dentalplans.Unit;
   detailxperts: BowmarkProvider_detailxperts.Unit;
+  deutschepost: BowmarkProvider_deutschepost.Unit;
   developersopenai: BowmarkProvider_developersopenai.Unit;
+  dfs_rotogrinderssearch: BowmarkProvider_dfs_rotogrinderssearch.Unit;
   dice: BowmarkProvider_dice.Unit;
   dickssportinggoods: BowmarkProvider_dickssportinggoods.Unit;
   dillards: BowmarkProvider_dillards.Unit;
@@ -36158,11 +37632,13 @@ interface BowmarkProviders {
   elase: BowmarkProvider_elase.Unit;
   elevenlabs: BowmarkProvider_elevenlabs.Unit;
   embroker: BowmarkProvider_embroker.Unit;
+  energyaustralia_com_au: BowmarkProvider_energyaustralia_com_au.Unit;
   epromos: BowmarkProvider_epromos.Unit;
   eq3: BowmarkProvider_eq3.Unit;
   equinox_hotels: BowmarkProvider_equinox_hotels.Unit;
   erieinsurance: BowmarkProvider_erieinsurance.Unit;
   etsy: BowmarkProvider_etsy.Unit;
+  evag: BowmarkProvider_evag.Unit;
   eventsource: BowmarkProvider_eventsource.Unit;
   evolutionofsmooth: BowmarkProvider_evolutionofsmooth.Unit;
   evolvemedspa: BowmarkProvider_evolvemedspa.Unit;
@@ -36261,6 +37737,7 @@ interface BowmarkProviders {
   landmarkhw_com: BowmarkProvider_landmarkhw_com.Unit;
   lasikplus: BowmarkProvider_lasikplus.Unit;
   legacyhomesal: BowmarkProvider_legacyhomesal.Unit;
+  letterboxd: BowmarkProvider_letterboxd.Unit;
   linkedin: BowmarkProvider_linkedin.Unit;
   liquiddeath: BowmarkProvider_liquiddeath.Unit;
   liquidspace: BowmarkProvider_liquidspace.Unit;
@@ -36307,23 +37784,30 @@ interface BowmarkProviders {
   nvisioncenters: BowmarkProvider_nvisioncenters.Unit;
   oanda: BowmarkProvider_oanda.Unit;
   oliverwinery: BowmarkProvider_oliverwinery.Unit;
+  onthemarket: BowmarkProvider_onthemarket.Unit;
+  originenergy_com_au: BowmarkProvider_originenergy_com_au.Unit;
   othership: BowmarkProvider_othership.Unit;
   otto: BowmarkProvider_otto.Unit;
   outdoorresearch: BowmarkProvider_outdoorresearch.Unit;
   pacificabeauty: BowmarkProvider_pacificabeauty.Unit;
   pacificcompanies: BowmarkProvider_pacificcompanies.Unit;
   pacificlifestylehomes: BowmarkProvider_pacificlifestylehomes.Unit;
+  packlane: BowmarkProvider_packlane.Unit;
+  pawsup: BowmarkProvider_pawsup.Unit;
   paypal: BowmarkProvider_paypal.Unit;
   perennialsandsutherland: BowmarkProvider_perennialsandsutherland.Unit;
   pilotprotocol: BowmarkProvider_pilotprotocol.Unit;
   pirateship: BowmarkProvider_pirateship.Unit;
   pizzahut: BowmarkProvider_pizzahut.Unit;
+  planning_inspectorate_ni: BowmarkProvider_planning_inspectorate_ni.Unit;
   platform_claude_com: BowmarkProvider_platform_claude_com.Unit;
   polymarket: BowmarkProvider_polymarket.Unit;
   polytex: BowmarkProvider_polytex.Unit;
   poshmark: BowmarkProvider_poshmark.Unit;
   positivegrid: BowmarkProvider_positivegrid.Unit;
+  postcard_direct_mail: BowmarkProvider_postcard_direct_mail.Unit;
   postiz: BowmarkProvider_postiz.Unit;
+  powys: BowmarkProvider_powys.Unit;
   premierbuildings: BowmarkProvider_premierbuildings.Unit;
   prime_video: BowmarkProvider_prime_video.Unit;
   progressive: BowmarkProvider_progressive.Unit;
@@ -36414,6 +37898,7 @@ interface BowmarkProviders {
   waterfurnace: BowmarkProvider_waterfurnace.Unit;
   wearehirschfeld: BowmarkProvider_wearehirschfeld.Unit;
   wellfound: BowmarkProvider_wellfound.Unit;
+  wholefoodsmarket: BowmarkProvider_wholefoodsmarket.Unit;
   winestyles: BowmarkProvider_winestyles.Unit;
   xpresswellnessurgentcare: BowmarkProvider_xpresswellnessurgentcare.Unit;
   ycombinator: BowmarkProvider_ycombinator.Unit;
@@ -88153,9 +89638,11 @@ interface BowmarkLibrary {
   costume_size_check: BowmarkCapability_costume_size_check.Unit;
   coworking: BowmarkCapability_coworking.Unit;
   currency_exchange: BowmarkCapability_currency_exchange.Unit;
+  custom_packaging_quote: BowmarkCapability_custom_packaging_quote.Unit;
   custom_sofa_configurator: BowmarkCapability_custom_sofa_configurator.Unit;
   delivery: BowmarkCapability_delivery.Unit;
   developer_api_key_signup: BowmarkCapability_developer_api_key_signup.Unit;
+  dfs_ownership_projections: BowmarkCapability_dfs_ownership_projections.Unit;
   domain: BowmarkCapability_domain.Unit;
   email: BowmarkCapability_email.Unit;
   entertainment_merch: BowmarkCapability_entertainment_merch.Unit;
@@ -88169,12 +89656,14 @@ interface BowmarkLibrary {
   istanbul_schedules: BowmarkCapability_istanbul_schedules.Unit;
   local_database_gui: BowmarkCapability_local_database_gui.Unit;
   local_html_preview: BowmarkCapability_local_html_preview.Unit;
+  mac_trade_in: BowmarkCapability_mac_trade_in.Unit;
   mcp_registry: BowmarkCapability_mcp_registry.Unit;
   music: BowmarkCapability_music.Unit;
   pcparts: BowmarkCapability_pcparts.Unit;
   pet_boarding: BowmarkCapability_pet_boarding.Unit;
   phone_price: BowmarkCapability_phone_price.Unit;
   phone_trade_in: BowmarkCapability_phone_trade_in.Unit;
+  postcard_direct_mail_quote: BowmarkCapability_postcard_direct_mail_quote.Unit;
   pricing: BowmarkCapability_pricing.Unit;
   products: BowmarkCapability_products.Unit;
   promocodes: BowmarkCapability_promocodes.Unit;
@@ -88187,10 +89676,12 @@ interface BowmarkLibrary {
   search: BowmarkCapability_search.Unit;
   sheds: BowmarkCapability_sheds.Unit;
   shipping: BowmarkCapability_shipping.Unit;
+  stream_channel: BowmarkCapability_stream_channel.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;
+  video_library: BowmarkCapability_video_library.Unit;
   weather: BowmarkCapability_weather.Unit;
   web_form_fields: BowmarkCapability_web_form_fields.Unit;
   wireless: BowmarkCapability_wireless.Unit;