@bowmark/web 1.12.0 → 1.12.2

package/src/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: 30acf97e882124423eecad144b20c278a6e81b46e839c2063822661efc063ea6
-// 32 capabilities, 253 providers, 665 typed functions, 20 refused.
+// Manifest version: 4367aae3846695ff98e8537819e01ea3e2b841043d73690123b839fb07c2a19a
+// 38 capabilities, 266 providers, 693 typed functions, 20 refused.
 // 51,715 family members, sharing 2 interface(s) — declared once and pointed at, never repeated per member.
 //
 // REFUSED — these functions are real and callable, and their declared arguments
@@ -36,6 +36,40 @@
 
 
 
+declare namespace BowmarkCapability_bundles {
+  // ── Check whether a set of products can be built and bought right now — the unit's own declarations, verbatim ──
+interface BundleItemAvailability {
+  url: string
+  ok: boolean
+  buildable: boolean
+  price: { amount: number; currency: string } | null   // integer minor units
+  availability: string | null
+  reason: string | null
+}
+interface BundleAvailability {
+  buildable: boolean
+  items: BundleItemAvailability[]
+  blocking: string[]        // urls of the items stopping the bundle
+  totalPrice: { amount: number; currency: string } | null
+  warnings: string[]
+}
+
+  /**
+   * Given a list of product page urls, reads each one's price and stock the way
+   * `products.getAvailability` does, then reduces the set to one buildable/not-buildable verdict
+   * naming whatever is blocking it.
+   */
+  interface Unit {
+    /**
+     * Reads every item's product page and returns whether the WHOLE bundle can be built and bought
+     * right now — false the moment any one item is out of stock, pre-order, or unreadable, naming
+     * which url(s) are blocking it in `blocking`. Never throws on a bad or dead item url; that
+     * item is reported as not buildable instead, with its reason.
+     */
+    checkAvailability(items: { url: string }[]): Promise<BundleAvailability>;
+  }
+}
+
 declare namespace BowmarkCapability_cable_railing_quote {
   // ── Cable railing design quote (materials & mounting options) — the unit's own declarations, verbatim ──
 type CableRailingMaterial = {
@@ -291,6 +325,46 @@ type CallOptions = {
   }
 }
 
+declare namespace BowmarkCapability_delivery {
+  // ── Food-delivery fee comparison — the unit's own declarations, verbatim ──
+type DeliveryFeeQuote = {
+  app: string                  // which app quoted this, e.g. "doordash"
+  name: string
+  deliveryFee: number | null   // the app's own advertised delivery fee, before a cart is built
+  url: string
+  rating: number | null
+}
+type CompareDeliveryFeesResult = {
+  query: string
+  quotes: DeliveryFeeQuote[]   // every store any queried app returned
+  warnings: string[]           // always present; empty when nothing was dropped
+}
+
+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
+}
+
+  /**
+   * Runs a free-text restaurant search on DoorDash and returns each store's own advertised
+   * delivery fee, rating and ETA — the fee shown before a cart is built. Uber Eats is declared
+   * but not yet wired (its search stub isn't built); a full delivery+service+tax+tip checkout
+   * TOTAL needs a real cart and address and is separately not-yet-built on both apps.
+   */
+  interface Unit {
+    /**
+     * Runs a free-text search — `bowmark.delivery.compareDeliveryFees("pad thai austin tx")` —
+     * across the delivery apps this library covers (DoorDash today) and returns every matching
+     * store tagged with which app quoted it, that app's own advertised delivery fee, rating and
+     * listing URL. This is the fee shown on the app's OWN results card before a cart is built, not
+     * a full checkout total (delivery + service fee + tax + tip after a real cart and address) —
+     * see the capability blurb for what that needs.
+     */
+    compareDeliveryFees(query: string | { query: string; limit?: number }, options?: CallOptions): Promise<CompareDeliveryFeesResult>;
+  }
+}
+
 declare namespace BowmarkCapability_developer_api_key_signup {
   // ── Developer API key signup — the unit's own declarations, verbatim ──
 interface DeveloperApiKeySignupDetails {
@@ -1224,6 +1298,87 @@ type CallOptions = {
   }
 }
 
+declare namespace BowmarkCapability_local_database_gui {
+  // ── Browse a local database GUI's tables — the unit's own declarations, verbatim ──
+interface DbGuiTable {
+  name: string | null       // a <caption>, the nearest preceding heading, or an
+                            // aria-label/data-testid naming it — null if nothing does
+  columns: string[]          // "col_1", "col_2", … when the table has no header row
+  rows: Record<string, string>[]
+  rowCount: number           // the real count, even when rows[] was cut
+  truncated: boolean
+}
+interface DbGuiBrowseOptions {
+  maxTables?: number         // default 25
+  maxRowsPerTable?: number   // default 200
+}
+interface DbGuiBrowseResult {
+  tables: DbGuiTable[]
+  navLinks: string[]         // candidate table/collection names from a sidebar-shaped nav
+  warnings: string[]
+}
+
+  /**
+   * Turns the HTML of a local database GUI (Adminer, phpMyAdmin, pgAdmin, Drizzle Studio,
+   * mongo-express, or anything similar running on the caller's own localhost) into typed tables
+   * and a candidate table list — Bowmark cannot navigate a caller-private address itself, so
+   * this takes the page the caller's own agent already has and structures it. Read-only; nothing
+   * here can submit or modify a row.
+   */
+  interface Unit {
+    /**
+     * Parses the HTML of a local database GUI page (e.g. the caller's own agent read it off
+     * http://localhost:<port> — Bowmark cannot reach that address itself) and returns every
+     * <table> on the page as structured rows keyed by column name, plus a `navLinks` list of
+     * candidate table/collection names pulled from a sidebar-shaped nav. `options.maxTables`
+     * (default 25) and `options.maxRowsPerTable` (default 200) cap how much is kept; a cut table
+     * reports its real `rowCount` and `truncated: true`. Never throws on odd markup — an empty or
+     * table-less page comes back with `tables: []` and a warning rather than an error.
+     */
+    browse(html: string, options?: DbGuiBrowseOptions): Promise<DbGuiBrowseResult>;
+  }
+}
+
+declare namespace BowmarkCapability_local_html_preview {
+  // ── Preview local HTML (structure, text, links, forms — read-only) — the unit's own declarations, verbatim ──
+
+interface PreviewHeading { level: number; text: string }
+interface PreviewLink { text: string; href: string | null }
+interface PreviewImage { src: string | null; alt: string | null }
+interface PreviewForm { action: string | null; method: string; fieldCount: number }
+
+interface PreviewOptions {
+  maxChars?: number   // default 20000; over it, text is cut + truncated:true
+}
+
+interface HtmlPreviewResult {
+  title: string | null
+  text: string                 // visible text, block structure kept as blank lines
+  chars: number
+  truncated: boolean
+  headings: PreviewHeading[]
+  links: PreviewLink[]
+  images: PreviewImage[]
+  forms: PreviewForm[]         // inventory only — nothing here submits a form
+  wordCount: number
+  warnings: string[]
+}
+
+  /**
+   * Render an HTML file or fragment the caller already has and get back its title, text,
+   * headings, links, images and forms — no network, no browser, nothing executed or submitted.
+   */
+  interface Unit {
+    /**
+     * Parses supplied HTML (a local file's contents, or a fragment) and returns a structured
+     * preview: title, readable text, headings, links, images and a read-only form inventory. Never
+     * executes scripts, never fetches anything, never submits a form — it only reads the markup
+     * you already have.
+     */
+    render(html: string, options?: PreviewOptions): Promise<HtmlPreviewResult>;
+  }
+}
+
 declare namespace BowmarkCapability_mcp_registry {
   // ── MCP Registry — the unit's own declarations, verbatim ──
 interface McpRegistryEntry {
@@ -1707,6 +1862,94 @@ type CallOptions = {
   }
 }
 
+declare namespace BowmarkCapability_retail {
+  // ── Retail (general merchandise, multi-store) — the unit's own declarations, verbatim ──
+type RetailOffer = {
+  store: "walmart" | "target"    // where this offer is from
+  title: string                  // the product as the store lists it
+  price: number | null           // USD; null if unpriced
+  wasPrice: number | null        // the pre-markdown price, when the store publishes one
+  url: string | null             // product page
+  inStock: boolean               // this store's OWN in-stock signal — not comparable
+                                  // across stores as one normalized fact
+}
+type RetailSearchResult = {
+  results: RetailOffer[]   // ONE query across ALL stores, price-sorted (cheapest first)
+  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
+}
+
+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
+}
+
+  /**
+   * General-merchandise retail across Walmart and Target — 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.
+   */
+  interface Unit {
+    /**
+     * Searches Walmart and Target in parallel for a keyword and returns one price-sorted list of
+     * offers across both stores, each tagged with which store it's from. `warnings` names any
+     * store that did not answer, so a caller can tell a genuinely cheaper/only offer from one
+     * where a store simply timed out.
+     */
+    search(args: { query: string }): Promise<RetailSearchResult>;
+  }
+}
+
+declare namespace BowmarkCapability_school_shopping_basket {
+  // ── Price a school-supply list across Target and Walmart — the unit's own declarations, verbatim ──
+interface BasketItemMatch {
+  query: string
+  title: string
+  url: string
+  price: { amount: number; currency: string }   // integer minor units
+}
+interface RetailerBasket {
+  total: { amount: number; currency: string } | null   // sums matched only — a partial
+                                                       // sum whenever incomplete is
+                                                       // non-empty
+  matched: BasketItemMatch[]
+  unavailable: string[]   // this retailer ANSWERED and has no in-stock priced match
+  incomplete: string[]    // this retailer's search never answered — NOT out of stock,
+                          // nothing was learned; retry with fewer items or more time
+}
+interface SchoolShoppingBasket {
+  retailers: { target: RetailerBasket; walmart: RetailerBasket }
+  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
+}
+
+  /**
+   * Given a list of item queries (a school supply list), fans out to Target and Walmart search,
+   * picks the cheapest in-stock match per item per retailer, and returns each retailer's basket
+   * total plus which items neither retailer has in stock right now.
+   */
+  interface Unit {
+    /**
+     * Prices a multi-item shopping list at Target and Walmart, one basket total per retailer. An
+     * item the retailer answered about and does not stock is in `unavailable`; an item whose
+     * search never answered is in `incomplete` and is NOT a stockout — nothing was learned about
+     * it, and the retailer's total is then a partial sum. Every incomplete item is also named in
+     * `warnings`. Never throws on one retailer being unreachable — that retailer's basket is
+     * dropped and named in `warnings` instead; throws only when BOTH retailers failed on every
+     * item. Walmart drives a real browser per item and every item is searched at once, so a long
+     * list is what costs time: price fewer items per call before reaching for a larger
+     * `timeoutMs`.
+     */
+    priceList(args: { items: string[] }): Promise<SchoolShoppingBasket>;
+  }
+}
+
 declare namespace BowmarkCapability_search {
   // ── Web search — the unit's own declarations, verbatim ──
 type SearchResult = {
@@ -2407,6 +2650,57 @@ interface aaMaxCheckedBagsRule {
   }
 }
 
+declare namespace BowmarkProvider_aauto {
+  // ── 1A Auto — the unit's own declarations, verbatim ──
+interface AautoSearchProduct {
+  id: string;
+  title: string;
+  brand: string;
+  category: string;
+  price: number;
+  url: string;
+  image: string | null;
+}
+interface AautoSearchResult {
+  query: string;
+  /** The site's own reported match count — can exceed products.length. */
+  totalResults: number;
+  products: AautoSearchProduct[];
+}
+interface AautoProduct {
+  id: string;
+  title: string;
+  brand: string;
+  category: string;
+  price: number;
+  sku: string | null;
+  inStock: boolean;
+  description: string;
+  image: string | null;
+  url: string;
+}
+
+  /**
+   * 1A Auto's DIY replacement-parts catalog — search results and one product's real price, stock
+   * and description — read off the live storefront.
+   */
+  interface Unit {
+    /**
+     * Reads 1A Auto's own search-results page for `query` — real price, brand, category and
+     * product URL per row, plus the site's own total-match count. `limit` truncates the first
+     * results page (the site itself paginates; this reads only the first page).
+     */
+    search(query: string, opts?: { limit?: number }): Promise<AautoSearchResult>;
+
+    /**
+     * Reads one product page by the URL search() returns (absolute or a site-relative path) —
+     * title, brand, SKU, price, live stock status and description text. THROWS if the page does
+     * not carry the site's own product data block.
+     */
+    getProduct(url: string): Promise<AautoProduct>;
+  }
+}
+
 declare namespace BowmarkProvider_abercrombie {
   // ── Abercrombie & Fitch — the unit's own declarations, verbatim ──
 interface abercrombieSizeOption {
@@ -2723,6 +3017,54 @@ interface AjmadisonSearchResult {
   }
 }
 
+declare namespace BowmarkProvider_allied {
+  // ── Allied Van Lines — the unit's own declarations, verbatim ──
+interface AlliedSupplyLine {
+  item: string;
+  quantity: number | null;
+}
+interface AlliedRoomSupplies {
+  room: string;
+  supplies: AlliedSupplyLine[];
+}
+interface AlliedPackingEstimate {
+  totalSupplies: AlliedSupplyLine[];
+  byRoom: AlliedRoomSupplies[];
+}
+interface AlliedPackingCalculatorInput {
+  yearsInHome?: "lessThan5" | "5to10" | "over10";
+  cabinetsClosets?: "clutterFree" | "packRat";
+  kitchen?: boolean;
+  pantry?: boolean;
+  diningRoom?: boolean;
+  livingRoom?: boolean;
+  familyRoom?: boolean;
+  homeOffice?: boolean;
+  bedrooms?: number;
+  garageBays?: number;
+  storedAttic?: boolean;
+  storageFacility?: boolean;
+  otherRooms?: number;
+}
+
+  /**
+   * Runs Allied Van Lines' own Packing Calculator — takes which rooms are moving (no name, email
+   * or phone) and returns a real, server-computed whole-house and per-room packing-supply
+   * estimate (cartons, tape, paper). Allied's separate 'quote' flow is a sales-lead form with no
+   * computed price and is out of scope; this is the one part of allied.com that answers a
+   * question with a number.
+   */
+  interface Unit {
+    /**
+     * Allied Van Lines' own Packing Calculator: pass which rooms are moving (kitchen, bedrooms
+     * count, garage bays, etc — no identity required) and get back a real per-room and whole-house
+     * estimate of boxes, tape and paper. At least one room must be set, matching the site's own
+     * validation.
+     */
+    estimatePackingSupplies(input: AlliedPackingCalculatorInput): Promise<AlliedPackingEstimate>;
+  }
+}
+
 declare namespace BowmarkProvider_alphavantage {
   // ── Alpha Vantage — the unit's own declarations, verbatim ──
 interface AlphavantageSignUpDetails {
@@ -2969,6 +3311,51 @@ interface AppleTradeInEstimate {
   }
 }
 
+declare namespace BowmarkProvider_aquaphoenixsci {
+  // ── AquaPhoenix Scientific — the unit's own declarations, verbatim ──
+// aquaphoenixsci's OWN shapes — not a capability contract.
+
+interface AquaphoenixsciListing {
+  sku: string;
+  name: string;
+  path: string;            // pass to getProduct()
+  price: number | null;    // dollars, or null when gated behind a business account
+  requiresBusinessAccount: boolean;
+}
+
+interface AquaphoenixsciProduct {
+  sku: string;
+  name: string;
+  path: string;
+  price: number | null;    // dollars, or null when gated behind a business account
+  requiresBusinessAccount: boolean;
+  inStock: boolean;
+  checkoutUrl: string;     // the real product page — add-to-cart / checkout entry point
+}
+
+  /**
+   * AquaPhoenix Scientific's real catalog storefront (water/chemical testing and feed-control
+   * equipment) — browse a category for real SKUs and prices, and read one product's real price,
+   * stock status and add-to-cart/checkout URL.
+   */
+  interface Unit {
+    /**
+     * Lists real products in one of AquaPhoenix's catalog categories, e.g.
+     * "testing-supplies/test-kits" or "feed-and-control-equipment/pumps-accessories" — real SKU,
+     * name, product path, and either a real anonymous price or a note that the SKU requires a
+     * business account. THROWS naming the closed set of real category paths on an unknown one.
+     */
+    browseCategory(category: string): Promise<AquaphoenixsciListing[]>;
+
+    /**
+     * Reads one product's real detail page — SKU, name, price (when anonymously priced), stock
+     * status, and the real product URL to hand to the shopper as the add-to-cart / checkout entry
+     * point. THROWS naming browseCategory() as the way to find a real path on an unknown one.
+     */
+    getProduct(path: string): Promise<AquaphoenixsciProduct>;
+  }
+}
+
 declare namespace BowmarkProvider_archipelago {
   // ── Archipelago — the unit's own declarations, verbatim ──
 interface ArchipelagoAsset {
@@ -5029,6 +5416,44 @@ interface CaliProductDetail extends CaliProduct {
   }
 }
 
+declare namespace BowmarkProvider_camelcamelcamel {
+  // ── camelcamelcamel — the unit's own declarations, verbatim ──
+interface CamelPriceStat {
+  price: number | null;
+  date: string | null;
+}
+
+interface CamelPriceTypeStats {
+  lowestEver: CamelPriceStat;
+  highestEver: CamelPriceStat;
+  current: CamelPriceStat;
+  average: number | null;
+}
+
+interface CamelPriceHistory {
+  asin: string;
+  productTitle: string;
+  amazon: CamelPriceTypeStats;
+  thirdPartyNew: CamelPriceTypeStats;
+  thirdPartyUsed: CamelPriceTypeStats;
+  chartUrl: string;
+}
+
+  /**
+   * Independent Amazon price-history tracker — real lowest/highest/current/average price per
+   * item, each dated, so a claimed 'sale' can be checked against what the item actually sold
+   * for.
+   */
+  interface Unit {
+    /**
+     * Reads camelcamelcamel's independently-tracked Amazon price history for one ASIN — the site's
+     * own lowest-ever/highest-ever/current/average figures, each dated, for the Amazon,
+     * 3rd-party-new and 3rd-party-used price types, plus the full-history chart image URL.
+     */
+    getPriceHistory(asinOrUrl: string): Promise<CamelPriceHistory>;
+  }
+}
+
 declare namespace BowmarkProvider_cancer {
   // ── National Cancer Institute (cancer.gov) — the unit's own declarations, verbatim ──
 type cancerCenterDesignation =
@@ -6216,17 +6641,35 @@ interface ClubchampionFittingsMenu {
   activePromoTerms: string | null;
 }
 
-interface ClubchampionAvailability {
+interface ClubchampionFitter {
+  id: string;            // the id checkAvailability takes
+  name: string;
+  locationId: string;
+  locationName: string;  // the studio name listStudios() and getFittings() use
+  timezone: string;
+  handedness: string[];
+  specialties: string[];
+  locationBayCount: number;
+}
+
+interface ClubchampionSlot {
+  start: string;   // ISO instant, e.g. "2026-09-08T10:00:00.000Z"
+  end: string;
+  status: string;  // the site's own word, e.g. "available"
   resourceId: string;
+}
+
+interface ClubchampionAvailability {
+  resourceId: string;         // the fitter id, echoed back
   range: { start: string; end: string };
-  mode: string;      // the site's own live/cached indicator
-  slots: unknown[];  // the site's own slot list, verbatim — empty is a real answer
+  mode: string;               // the site's own live/cached indicator
+  slots: ClubchampionSlot[];  // verbatim — empty is a real answer
 }
 
   /**
-   * Club Champion's live studio directory, real per-store fitting pricing, and real open-slot
-   * availability checks — the same booking widget backend the site itself calls. Rung 10, no
-   * browser.
+   * Club Champion's live studio directory, its fitters, real per-store fitting pricing, and real
+   * open-slot availability on a named fitter's calendar — the same booking widget backend the
+   * site itself calls. Rung 10, no browser.
    */
   interface Unit {
     /**
@@ -6243,12 +6686,22 @@ interface ClubchampionAvailability {
     getFittings(storeName: string): Promise<ClubchampionFittingsMenu>;
 
     /**
-     * Checks real, live open-slot availability for one fitting product (a `productId` from
-     * getFittings()) over a "YYYY-MM-DD"..."YYYY-MM-DD" date range — the same live check the
-     * site's own booking widget makes. An empty `slots` array is the site's real answer, not an
+     * Reads the live list of every Club Champion fitter (~396 across the chain) — the person a
+     * fitting is booked with, and the only id checkAvailability accepts. Pass a studio name from
+     * listStudios(), e.g. "Bellevue", to get just that studio's fitters.
+     */
+    listFitters(storeName?: string): Promise<ClubchampionFitter[]>;
+
+    /**
+     * Checks real, live open-slot availability on one FITTER's calendar (an `id` from
+     * listFitters()) over a "YYYY-MM-DD"..."YYYY-MM-DD" range — the same live check the site's own
+     * booking widget makes. A fitting `productId` from getFittings() is a DIFFERENT id space and
+     * the site answers it with an empty list, so pass a fitter id. Optional `durationMinutes` and
+     * `fittingType` mirror what the widget sends. An empty `slots` array is the site's real answer
+     * — a closed day, a booked-out fitter, or a date past the ~60-day booking horizon — not an
      * error.
      */
-    checkAvailability(resourceId: string, start: string, end: string): Promise<ClubchampionAvailability>;
+    checkAvailability(fitterId: string, start: string, end: string, durationMinutes?: number, fittingType?: string): Promise<ClubchampionAvailability>;
   }
 }
 
@@ -7356,6 +7809,34 @@ interface DisneyTicketPrice {
   }
 }
 
+declare namespace BowmarkProvider_doordash {
+  // ── DoorDash — the unit's own declarations, verbatim ──
+interface DoordashSearchArgs {
+  query: string;   // free text, e.g. "pad thai austin tx" — DoorDash resolves location itself
+  limit?: number;  // default 10, clamped to [1, 30]
+}
+
+interface DoordashSearchResult {
+  name: string;
+  url: string;
+  deliveryFee: number | null;  // DoorDash's own advertised delivery fee, in dollars
+  rating: number | null;
+  etaMinutes: number | null;
+}
+
+  /**
+   * DoorDash's own store search — returns real, currently-listed stores for a free-text query
+   * with the delivery fee, rating and ETA DoorDash itself advertises on the results card.
+   */
+  interface Unit {
+    /**
+     * Runs DoorDash's own store search for a free-text query and returns real, currently-listed
+     * stores with DoorDash's own advertised delivery fee, rating and ETA. Read-only.
+     */
+    search(args: DoordashSearchArgs): Promise<DoordashSearchResult[]>;
+  }
+}
+
 declare namespace BowmarkProvider_ebay {
   // ── eBay — the unit's own declarations, verbatim ──
 interface ebayItem {
@@ -8776,10 +9257,11 @@ interface fredObservations {
   seriesId: string;
   /** The transform FRED reports having applied: "lin" (none), "pc1", "pch", … */
   units: string;
-  observationStart: string;
-  observationEnd: string;
-  realtimeStart: string;
-  realtimeEnd: string;
+  observationStart: string | null;
+  observationEnd: string | null;
+  /** null: the public CSV has no vintage envelope. */
+  realtimeStart: string | null;
+  realtimeEnd: string | null;
   count: number;
   observations: fredObservation[];
 }
@@ -8831,10 +9313,10 @@ interface fredObservations {
      * `pch`, `chg`, `log` and the rest of FRED's ten codes), and `frequency` with
      * `aggregationMethod` collapses a series to a coarser period (`{ frequency: "a",
      * aggregationMethod: "avg" }` turns the monthly unemployment rate into annual averages). The
-     * result carries the transform FRED reports having applied and the vintage it served, so a
-     * caller can tell what they actually got. This is the function to call once
-     * `searchSeries`/`getSeriesInfo` has identified the right series id — e.g. A191RL1Q225SBEA for
-     * the US real GDP growth rate.
+     * result carries the applied transform and the served row bounds; its realtime fields are
+     * `null` because the keyless CSV publishes no vintage envelope. This is the function to call
+     * once `searchSeries`/`getSeriesInfo` has identified the right series id — e.g.
+     * A191RL1Q225SBEA for the US real GDP growth rate.
      */
     getSeriesObservations(args: string | { seriesId: string; from?: string; to?: string; units?: string; frequency?: string; aggregationMethod?: string }): Promise<fredObservations>;
 
@@ -9405,6 +9887,109 @@ interface GlassesusaProduct {
   }
 }
 
+declare namespace BowmarkProvider_goloadup {
+  // ── LoadUp — the unit's own declarations, verbatim ──
+// LoadUp's OWN shapes — not a capability contract.
+
+interface GoloadupItemType {
+  id: string;               // the key getQuote's items take
+  name: string;
+  category: string | null;  // e.g. "COUCH", "MATTRESS"
+  aliases: string[];        // alternate names the site matches this item on
+  pickupAllowed: boolean;
+  pickupPrice: number | null;      // national base price — getQuote is the real, ZIP-priced number
+  assemblyAllowed: boolean;
+  assemblyPrice: number | null;
+  disassemblyAllowed: boolean;
+  disassemblyPrice: number | null;
+}
+
+interface GoloadupQuoteItem { itemId: string; quantity: number }
+
+interface GoloadupQuote {
+  validServiceArea: boolean;  // false = ZIP is outside LoadUp's service area, other fields are placeholders
+  validZip: boolean;          // false = ZIP itself is not recognized
+  basePrice: number;          // the area/trip fee added on top of the items
+  total: number;              // the guaranteed total for exactly these items at this ZIP
+  totalFormatted: string;     // "$124.00"
+  taxAmount: number;
+  minimumPrice: number;       // the floor LoadUp charges regardless of what's selected
+  minimumPriceApplied: boolean;
+  sameDayAllowed: boolean;
+  bookingUrl: string;         // hand the shopper here to finish scheduling
+}
+
+interface GoloadupServiceAvailability {
+  validZip: boolean;
+  inService: boolean;
+  sameDayAllowed: boolean;
+  estimationAllowed: boolean;
+  retailAssembliesAllowed: boolean;
+}
+
+  /**
+   * LoadUp's own item-selector and live pricing engine for junk removal, donation and furniture
+   * pickup — the current catalog of items with base prices, a real ZIP-specific guaranteed quote
+   * for an exact set of items, and whether/how a ZIP is served, all off the same GraphQL API the
+   * site's own booking widget calls.
+   */
+  interface Unit {
+    /**
+     * Returns LoadUp's full current catalog of pickupable items (couches, mattresses, appliances,
+     * and 400+ more), each with its category, alternate names, and national base
+     * pickup/assembly/disassembly prices. The `id` on each row is what getQuote's items take —
+     * this is the entry point every quote starts from.
+     */
+    getPricingCatalog(): Promise<GoloadupItemType[]>;
+
+    /**
+     * Prices an EXACT set of items (e.g. [{ itemId: "7412", quantity: 1 }] for one Couch/Loveseat)
+     * at a real ZIP code against LoadUp's live pricing engine — the same call its own booking
+     * widget makes. Returns the guaranteed total, whether the ZIP falls under the site's
+     * minimum-price floor, and same-day availability. `validServiceArea: false` means the ZIP is
+     * real but outside LoadUp's coverage, not an error — check it before reading `total`.
+     */
+    getQuote(zip: string, items: GoloadupQuoteItem[]): Promise<GoloadupQuote>;
+
+    /**
+     * Checks whether and how LoadUp serves one ZIP code, independent of any specific items — in
+     * service, same-day pickup allowed, and whether retail assembly is offered there.
+     */
+    checkServiceAvailability(zip: string): Promise<GoloadupServiceAvailability>;
+  }
+}
+
+declare namespace BowmarkProvider_goodway {
+  // ── Goodway Technologies — the unit's own declarations, verbatim ──
+interface GoodwayProductSummary {
+  sku: string;
+  title: string;
+  url: string;
+  price: string | null; // null = call for price / quote required
+}
+interface GoodwayProduct extends GoodwayProductSummary {
+  purchaseType: "buy" | "quote";
+}
+
+  /**
+   * Goodway's own pressure-washer catalog — real listed prices, or a quote-required flag for
+   * call-for-price units, and the site's own product page as the buy/quote handoff.
+   */
+  interface Unit {
+    /**
+     * Reads Goodway's pressure-washer catalog grid — every listed model, its SKU, its live price
+     * (or null if quote-required) and its product page.
+     */
+    searchProducts(): Promise<GoodwayProductSummary[]>;
+
+    /**
+     * Reads one product's detail page for its real current price and whether it buys online or
+     * needs a written quote.
+     */
+    getProduct(arg0: { slug: string }): Promise<GoodwayProduct>;
+  }
+}
+
 declare namespace BowmarkProvider_google_flights {
   // ── Google Flights — the unit's own declarations, verbatim ──
 interface GoogleFlightQuery {
@@ -11053,6 +11638,10 @@ interface HobieModelSummary {
   name: string;
   url: string;
 }
+interface HobieKayakModelList {
+  total_models: number;
+  models: HobieModelSummary[];
+}
 interface HobieModelColor {
   color: string;
   upc: string;
@@ -11103,6 +11692,12 @@ interface HobieLocalAvailability {
      */
     listModels(): Promise<HobieModelSummary[]>;
 
+    /**
+     * Returns Hobie's live kayak-model list plus total_models. To answer a count request, call it
+     * with run; do not infer or paraphrase the count from this description.
+     */
+    listKayakModels(): Promise<HobieKayakModelList>;
+
     /**
      * Reads one model's real buildable colors, each paired with the exact UPC the local-inventory
      * widget is keyed on, plus the site's own default color.
@@ -11493,6 +12088,22 @@ interface IdentitygroupMountOptionResult {
   }
 }
 
+declare namespace BowmarkProvider_ihg {
+  // ── IHG Hotels & Resorts — the unit's own declarations, verbatim ──
+interface ihgRow { id: string; brandCode: string; availabilityStatus: string; lowestCashOnlyCost: { baseAmount: string; ratePlanType: string | null } | null; highestCashOnlyCost: { baseAmount: string; ratePlanType: string | null } | null; propertyCurrency: string | null; distance: number | null; distanceKm: number | null; }
+
+  /** IHG live hotel availability search across its brand portfolio. */
+  interface Unit {
+    /**
+     * Searches IHG's live cash availability for a destination and increasing ISO
+     * check-in/check-out dates. Returns IHG's hotel mnemonic, brand code, availability status,
+     * cash-price range, currency and distance; IHG's availability endpoint does not include
+     * display names.
+     */
+    search(args: { destination: string; checkIn: string; checkOut: string; adults?: number; rooms?: number; radius?: number }): Promise<ihgRow[]>;
+  }
+}
+
 declare namespace BowmarkProvider_instagram {
   // ── Instagram — the unit's own declarations, verbatim ──
 interface InstagramProfile {
@@ -13181,6 +13792,24 @@ interface KayakCar {
   }
 }
 
+declare namespace BowmarkProvider_keepa {
+  // ── Keepa — the unit's own declarations, verbatim ──
+interface KeepaProductResult { product: KeepaProduct; tokensLeft: number | null; tokensConsumed: number | null; refillRate: number | null; }
+interface KeepaProduct { asin: string; domainId: number; title: string; csv?: unknown[]; stats?: Record<string, unknown>; }
+
+  /**
+   * Keepa's documented Amazon product API — reads a product's native price history and metadata
+   * by ASIN. Requires a caller-provided Keepa API key.
+   */
+  interface Unit {
+    /**
+     * Reads Keepa's native Amazon product record and compact price-history series for one ASIN.
+     * Requires a caller-provided Keepa API key.
+     */
+    getProduct(args: { asin: string; domain?: number; stats?: number }): Promise<KeepaProductResult>;
+  }
+}
+
 declare namespace BowmarkProvider_kingsdown {
   // ── Kingsdown — the unit's own declarations, verbatim ──
 interface kingsdownBedmatchResult {
@@ -16354,6 +16983,43 @@ interface MuzeVisitingHours {
   }
 }
 
+declare namespace BowmarkProvider_myollie {
+  // ── Ollie — the unit's own declarations, verbatim ──
+interface OllieMealPlanOption {
+  planType: string;
+  planTypeName: string;
+  startingPricePerWeek: number;
+  availableCadences: number[];
+  defaultCadence: number;
+}
+
+interface GetMealPlanResult {
+  weightLbs: number;
+  activityLevel: "Low" | "Moderate" | "High";
+  plans: OllieMealPlanOption[];
+  checkoutUrl: string;
+}
+
+  /**
+   * Fresh dog food subscription. getMealPlan is live — the same
+   * weight/activity/neuter-status-driven meal plan and REAL per-plan weekly price the site's own
+   * onboarding quiz computes, given a dog's weight, activity level and neuter status. Returns
+   * all four plan tiers (Fresh, Baked, Mixed, Half Fresh) with this dog's own computed starting
+   * price, plus a checkout link that carries the answers forward.
+   */
+  interface Unit {
+    /**
+     * Computes Ollie's personalized fresh-food meal plan and REAL weekly price for a dog, given
+     * `weightLbs` (number, e.g. 45), `activityLevel` ("Low"|"Moderate"|"High"), `isNeutered`
+     * (boolean) and optional `gender` ("Male"|"Female"). Returns all four plan tiers (Fresh,
+     * Baked, Mixed, Half Fresh) each with this dog's own computed `startingPricePerWeek` — not a
+     * marketing-page range — plus a `checkoutUrl` that carries the answers into the site's own
+     * checkout. Recovered from the onboarding quiz's own API, not guessed at.
+     */
+    getMealPlan(args: object): Promise<GetMealPlanResult>;
+  }
+}
+
 declare namespace BowmarkProvider_naic {
   // ── NAIC — the unit's own declarations, verbatim ──
 interface naicCompanyQuery {
@@ -16853,6 +17519,43 @@ interface StoreStock {
   }
 }
 
+declare namespace BowmarkProvider_nutrafol {
+  // ── Nutrafol — the unit's own declarations, verbatim ──
+interface RootCause {
+  category: "Stress" | "Metabolism" | "Nutrition" | "Lifestyle" | "Hormone" | "Aging";
+  severity: string;          // the site's own label, e.g. "NEEDS SUPPORT", "MODERATE", "NORMAL"
+  description: string | null;
+  signs: string[];
+}
+interface HairWellnessAssessment {
+  rootCauses: RootCause[];
+}
+interface QuizOverview {
+  description: string;
+  rootCauseCategories: string[];
+}
+
+  /**
+   * Nutrafol's own Hair Wellness Quiz — assessHairWellness runs the real root-cause assessment
+   * and returns its own computed per-category severities (Stress, Metabolism, Nutrition,
+   * Lifestyle, Hormone, Aging), the personalized output the site's marketing pages only
+   * describe.
+   */
+  interface Unit {
+    /**
+     * Runs Nutrafol's own Hair Wellness Quiz along its default answer path and returns the site's
+     * real computed root-cause severities. Read-only — never adds to cart or checks out.
+     */
+    assessHairWellness(): Promise<HairWellnessAssessment>;
+
+    /**
+     * Reads the Hair Wellness Quiz's own static intro page — its real description and the six
+     * root-cause categories it screens for — with a plain browserless fetch.
+     */
+    getQuizOverview(): Promise<QuizOverview>;
+  }
+}
+
 declare namespace BowmarkProvider_nvisioncenters {
   // ── NVISION Eye Centers — the unit's own declarations, verbatim ──
 // NVISION's OWN shapes — not a capability contract.
@@ -17005,6 +17708,69 @@ interface OliverwineryShippingAvailability {
   }
 }
 
+declare namespace BowmarkProvider_othership {
+  // ── Othership — the unit's own declarations, verbatim ──
+// Othership's OWN shapes — not a capability contract.
+
+interface OthershipLocation {
+  id: string;              // the key getClassSchedule's locationId takes
+  name: string;             // e.g. "Adelaide", "Flatiron", "Williamsburg"
+  city: string;
+  stateProvince: string;
+  formattedAddress: string;
+  timezone: string;
+  currencyCode: string;
+  regionName: string | null; // e.g. "Toronto", "NYC"
+}
+
+interface OthershipClass {
+  id: string;
+  name: string;              // e.g. "Guided Up: Arctic Tundra - 60 min"
+  description: string;
+  durationMinutes: number;
+  classroomName: string;
+  instructorNames: string[];
+  tags: string[];             // e.g. ["Guided", "Sun Pass"]
+  startDateTime: string;      // ISO 8601 with the location's own UTC offset
+  bookingStartDateTime: string;
+  availableSpotCount: number; // real, live — 0 means fully booked, not "not offered"
+  capacity: number;
+  spotCountIsPublic: boolean;
+  isCancelled: boolean;
+}
+
+interface OthershipClassSchedule {
+  classes: OthershipClass[];
+  totalCount: number;   // may exceed classes.length if the range was too broad — see warnings
+  scheduleUrl: string;   // hand the visitor here to finish booking
+  warnings: string[];
+}
+
+  /**
+   * Othership's real, live class schedule and seat availability across its Toronto and NYC
+   * sauna/ice-bath/breathwork studios — the same data its Mariana Tek booking widget shows, read
+   * directly rather than through a JS embed nothing outside a real browser can render.
+   */
+  interface Unit {
+    /**
+     * Returns every Othership studio location (Toronto's Adelaide and Yorkville, NYC's Flatiron
+     * and Williamsburg) with its site id, city, address and timezone. The `id` on each row is what
+     * getClassSchedule's locationId takes — this is the entry point every schedule search starts
+     * from.
+     */
+    getLocations(): Promise<OthershipLocation[]>;
+
+    /**
+     * Searches one Othership location's real, live class schedule between two YYYY-MM-DD dates —
+     * sauna, ice bath and breathwork sessions with instructor names, duration, tags and the actual
+     * seats left right now, off the same Mariana Tek API the site's own booking widget calls.
+     * `availableSpotCount: 0` means fully booked, not unavailable; `scheduleUrl` is where to send
+     * someone to finish booking.
+     */
+    getClassSchedule(locationId: string, startDate: string, endDate: string): Promise<OthershipClassSchedule>;
+  }
+}
+
 declare namespace BowmarkProvider_otto {
   // ── OTTO — the unit's own declarations, verbatim ──
 interface ottoProduct {
@@ -21055,7 +21821,7 @@ interface SunHomeSaunasQuizOption {
 interface SunHomeSaunasQuizQuestion {
   id: string;          // pass back as answers[].questionId
   title: string;
-  type: string;        // the site's own node type, e.g. "SIMPLE_MULTI"
+  type: string;        // the site's own Digioh question type, e.g. "DIGIOH_PRQ"
   options: SunHomeSaunasQuizOption[];  // option.id -> answers[].optionIds
 }
 
@@ -21063,8 +21829,8 @@ interface SunHomeSaunasMatch {
   handle: string;       // the key addSaunaToCart takes
   title: string;
   price: number;        // dollars — real live Shopify price
-  matchScore: number;   // e.g. 5
-  matchOutOf: number;   // e.g. 5 -> the site's own "5/5 match"
+  matchScore: number;   // selected answers that positively weighted this product
+  matchOutOf: number;   // submitted answer selections
 }
 
 interface SunHomeSaunasCartResult {
@@ -21078,30 +21844,29 @@ interface SunHomeSaunasCartResult {
 }
 
   /**
-   * Sun Home Saunas' real Perfect Product Finder quiz — the site's own 5-question buyer quiz,
-   * its real server-computed ranked product matches with live prices, and a real Shopify cart
-   * write for the winning match — no login, no dealer routing.
+   * Sun Home Saunas' live Digioh buyer quiz — its current questions, published product-ranking
+   * rules, real Shopify prices, and a real cart write for a recommended product — no login or
+   * dealer routing.
    */
   interface Unit {
     /**
-     * Reads Sun Home Saunas' real, live Perfect Product Finder quiz straight off its quiz vendor's
-     * own API — the current 5 questions and every real option, with the real ids
+     * Reads Sun Home Saunas' real, live Digioh buyer quiz from its published breakpoint
+     * configuration — every current question and answer button, with the ids
      * getPersonalizedSaunaMatches() needs to answer them.
      */
     getSaunaFinderQuestions(): Promise<SunHomeSaunasQuizQuestion[]>;
 
     /**
-     * Submits real answers (from getSaunaFinderQuestions()) through the same quiz session flow the
-     * site's own UI uses, and returns the site's own SERVER-COMPUTED ranked product matches with
-     * real live prices and a real match score — the exact personalized result a real buyer would
-     * see, never a guess from general knowledge.
+     * Applies real answers (from getSaunaFinderQuestions()) to the live Digioh `prq_keywords`
+     * rules the site's quiz publishes, then returns the site's own weighted ranking with real
+     * current Shopify prices — never a general-knowledge guess.
      */
     getPersonalizedSaunaMatches(answers: {questionId: string, optionIds: string[]}[]): Promise<SunHomeSaunasMatch[]>;
 
     /**
-     * Adds one real matched sauna (a handle from getPersonalizedSaunaMatches()) to a real Shopify
-     * cart at Sun Home Saunas' own real live price, and reads the cart back to confirm the write
-     * landed. THROWS if the product is currently out of stock.
+     * Adds one real matched product (a handle from getPersonalizedSaunaMatches()) to a real
+     * Shopify cart at Sun Home Saunas' own real live price, and reads the cart back to confirm the
+     * write landed. THROWS if the product is currently out of stock.
      */
     addSaunaToCart(handle: string, quantity?: number): Promise<SunHomeSaunasCartResult>;
   }
@@ -21894,6 +22659,9 @@ interface thezebraAutoDriver {
   lastName: string
   dob: string     // ISO YYYY-MM-DD — carriers rate on the DATE, not on an age
   email: string
+  ageFirstLicensed?: number  // default 16 when omitted
+  violations?: { accidents: number, claims: number, tickets: number }  // default a clean record
+  occupation?: string  // default "OTHER" — the only two confirmed-valid values are "OTHER" and "ENGINEER"
 }
 
 interface thezebraAutoVehicle {
@@ -22109,26 +22877,30 @@ interface thezebraAutoQuotes {
      * carrier's own monthly and six-month premium, deductible, and the coverage it priced, as The
      * Zebra's auto quote funnel prices them. This is a priced offer for the person asking, NOT the
      * published averages `getStateRates` and its siblings return. Pass `driver` (`firstName`,
-     * `lastName`, `dob` ISO YYYY-MM-DD, `email`), one `vehicle` (`year`, `make`, `model` — a model
-     * The Zebra does not rate THROWS naming the URL it tried), the 2-letter `state`, a 5-digit
-     * `zip`, and `county` (the county the ZIP sits in — The Zebra validates it server-side and a
-     * missing or wrong county is bounced). **The write binds, the read does not — yet**: the
-     * GraphQL gateway at `graphql-gateway.production.thezebra.com` accepts the auto seed
-     * (`LegacyStartInput.start.currentlyInsured` is the only field Apollo currently exposes on
-     * that input), but the results route STILL bounces the session to the homepage with the four
-     * fields this function sends. The function throws on the bounce with a message naming the gap;
-     * the second required field on `LegacyStartInput` is the next attempt's work, and the rejected
-     * probes — `helpToday`, `userPurchaseTimeframe`, `hadActiveInsurance`, `residenceOwnership`,
-     * `presumedAnswers`, `policyLinkInfo`, `startDate`, `desiredCoverage` — are documented in
-     * `agents/capability-engineer/instances/vertical-insurance/tools/zebra-auto-quotes/shape-summary.json`
-     * (and the e5 clone) so they don't have to be re-derived. **`advertisedCarriers` is not a
-     * quote list and must never be read as one**: the results page would carry paid carrier
-     * placements alongside real offers, separated by `data-cy="results-card_ad_<carrier>"` (ad)
-     * versus `data-cy="results-card_q2b_<carrier>"` (real offer), and the advertised names are
-     * returned in their own field with no price attached. Every premium is USD and
-     * `monthlyPremium` is per MONTH — the card's own period is checked rather than assumed, and a
-     * card printing any other term THROWS instead of relabelling a figure. `totalPremium` is the
-     * site's own whole-term number and is never divided out of the monthly one.
+     * `lastName`, `dob` ISO YYYY-MM-DD, `email`, and optionally
+     * `ageFirstLicensed`/`violations`/`occupation` — each defaults to a clean-record placeholder
+     * when omitted), one `vehicle` (`year`, `make`, `model` — a model The Zebra does not rate
+     * THROWS naming the URL it tried), the 2-letter `state`, a 5-digit `zip`, and `county` (the
+     * county the ZIP sits in — The Zebra validates it server-side and a missing or wrong county is
+     * bounced). **The write always binds** — the GraphQL gateway at
+     * `graphql-gateway.production.thezebra.com` accepts the seed and returns 200 — but AS OF
+     * 2026-08-27 the results route was bouncing the session to the homepage because
+     * `LegacyDriverInput` and `LegacyVehicleInput` accept more fields than an earlier version of
+     * this function sent; the measured field map (every field on both inputs, which are confirmed
+     * valid, which are still unmeasured) lives in
+     * `agents/richard/problems/thezebra-getautoquotes-broken.md` and is not re-derived here. The
+     * function throws on a bounce with a message naming the redirect target; `vehicle.submodel`,
+     * `driver.education` and `driver.creditScore` remain unsent because no valid value for any of
+     * them is confirmed yet — sending a guess cannot break the write (all three are nullable) but
+     * a wrong guess would look like a fix without being one, so they stay out until a live probe
+     * confirms a value. **`advertisedCarriers` is not a quote list and must never be read as
+     * one**: the results page would carry paid carrier placements alongside real offers, separated
+     * by `data-cy="results-card_ad_<carrier>"` (ad) versus `data-cy="results-card_q2b_<carrier>"`
+     * (real offer), and the advertised names are returned in their own field with no price
+     * attached. Every premium is USD and `monthlyPremium` is per MONTH — the card's own period is
+     * checked rather than assumed, and a card printing any other term THROWS instead of
+     * relabelling a figure. `totalPremium` is the site's own whole-term number and is never
+     * divided out of the monthly one.
      */
     getAutoQuotes(query: thezebraAutoQuotesQuery): Promise<thezebraAutoQuotes>;
   }
@@ -22275,6 +23047,54 @@ interface TitlenineBraSizeResult {
   }
 }
 
+declare namespace BowmarkProvider_tmobile {
+  // ── T-Mobile — the unit's own declarations, verbatim ──
+interface TmobileSku {
+  id: string;
+  listPriceUsd: number;
+  monthlyPaymentUsd: number | null;
+  contractTermMonths: number | null;
+}
+interface TmobileTradeInCredit {
+  deviceLabel: string;
+  creditUsd: number;
+}
+interface TmobilePromotion {
+  promoId: string;
+  displayName: string;
+  headlineCreditUsd: number;
+  tradeInCredits: TmobileTradeInCredit[];
+}
+interface TmobileTradeInMatch {
+  model: string;
+  promoId: string;
+  promoDisplayName: string;
+  creditUsd: number;
+}
+interface TmobileUpgradeOffer {
+  devicePath: string;
+  sourceUrl: string;
+  sku: TmobileSku;
+  promotions: TmobilePromotion[];
+  tradeInMatch: TmobileTradeInMatch | null;
+}
+
+  /**
+   * t-mobile.com's own device-page pricing call — real list price, real monthly financing, and
+   * the site's own per-trade-in-device credit tiers, read through a real browser session (the
+   * site signs every pricing request).
+   */
+  interface Unit {
+    /**
+     * Reads one t-mobile.com device page's own pricing call (list price, monthly financing, and
+     * every applicable promotion's per-trade-in-device credit tier) and, when `tradeInModel` is
+     * given, resolves the BEST matching credit across all of them — e.g. "iPhone 13" against a
+     * page carrying tiers like "Save $830: iPhone 13".
+     */
+    getUpgradeOffer(arg: { devicePath: string; tradeInModel?: string }): Promise<TmobileUpgradeOffer>;
+  }
+}
+
 declare namespace BowmarkProvider_topviewtix {
   // ── TopView Sightseeing — the unit's own declarations, verbatim ──
 interface topviewtixPackageDetails {
@@ -23370,6 +24190,7 @@ interface walmartSearchResult {
   price: number | null;
   wasPrice: number | null;
   priceRangeMin: number | null;
+  conditionCode: number | null;
   inStock: boolean;
   rating: number | null;
   reviewCount: number;
@@ -24670,15 +25491,18 @@ interface ShopifyCart {
  * string, so there is no camelCase alias to be uncertain about. */
 interface BowmarkProviders {
   aa: BowmarkProvider_aa.Unit;
+  aauto: BowmarkProvider_aauto.Unit;
   abercrombie: BowmarkProvider_abercrombie.Unit;
   aiper: BowmarkProvider_aiper.Unit;
   ajmadison: BowmarkProvider_ajmadison.Unit;
+  allied: BowmarkProvider_allied.Unit;
   alphavantage: BowmarkProvider_alphavantage.Unit;
   americanstandard: BowmarkProvider_americanstandard.Unit;
   amramp: BowmarkProvider_amramp.Unit;
   ancientnutrition: BowmarkProvider_ancientnutrition.Unit;
   andersenwindows: BowmarkProvider_andersenwindows.Unit;
   apple: BowmarkProvider_apple.Unit;
+  aquaphoenixsci: BowmarkProvider_aquaphoenixsci.Unit;
   archipelago: BowmarkProvider_archipelago.Unit;
   ashleyfurniture: BowmarkProvider_ashleyfurniture.Unit;
   asppoolco: BowmarkProvider_asppoolco.Unit;
@@ -24711,6 +25535,7 @@ interface BowmarkProviders {
   bykoket: BowmarkProvider_bykoket.Unit;
   byltbasics: BowmarkProvider_byltbasics.Unit;
   califloors: BowmarkProvider_califloors.Unit;
+  camelcamelcamel: BowmarkProvider_camelcamelcamel.Unit;
   cancer: BowmarkProvider_cancer.Unit;
   capitalbrands: BowmarkProvider_capitalbrands.Unit;
   caraway: BowmarkProvider_caraway.Unit;
@@ -24739,6 +25564,7 @@ interface BowmarkProviders {
   dillards: BowmarkProvider_dillards.Unit;
   discounttire: BowmarkProvider_discounttire.Unit;
   disney: BowmarkProvider_disney.Unit;
+  doordash: BowmarkProvider_doordash.Unit;
   ebay: BowmarkProvider_ebay.Unit;
   elevenlabs: BowmarkProvider_elevenlabs.Unit;
   embroker: BowmarkProvider_embroker.Unit;
@@ -24762,6 +25588,8 @@ interface BowmarkProviders {
   geico: BowmarkProvider_geico.Unit;
   github: BowmarkProvider_github.Unit;
   glassesusa: BowmarkProvider_glassesusa.Unit;
+  goloadup: BowmarkProvider_goloadup.Unit;
+  goodway: BowmarkProvider_goodway.Unit;
   google_flights: BowmarkProvider_google_flights.Unit;
   gotchacovered: BowmarkProvider_gotchacovered.Unit;
   grainger: BowmarkProvider_grainger.Unit;
@@ -24783,6 +25611,7 @@ interface BowmarkProviders {
   hunter: BowmarkProvider_hunter.Unit;
   ibuypower: BowmarkProvider_ibuypower.Unit;
   identitygroup: BowmarkProvider_identitygroup.Unit;
+  ihg: BowmarkProvider_ihg.Unit;
   instagram: BowmarkProvider_instagram.Unit;
   insurify: BowmarkProvider_insurify.Unit;
   interiordefine: BowmarkProvider_interiordefine.Unit;
@@ -24797,6 +25626,7 @@ interface BowmarkProviders {
   justinwine: BowmarkProvider_justinwine.Unit;
   kaleidescape: BowmarkProvider_kaleidescape.Unit;
   kayak: BowmarkProvider_kayak.Unit;
+  keepa: BowmarkProvider_keepa.Unit;
   kingsdown: BowmarkProvider_kingsdown.Unit;
   kitchentuneup: BowmarkProvider_kitchentuneup.Unit;
   kompan: BowmarkProvider_kompan.Unit;
@@ -24830,14 +25660,17 @@ interface BowmarkProviders {
   momondo: BowmarkProvider_momondo.Unit;
   mossyoak: BowmarkProvider_mossyoak.Unit;
   muze_gov_tr: BowmarkProvider_muze_gov_tr.Unit;
+  myollie: BowmarkProvider_myollie.Unit;
   naic: BowmarkProvider_naic.Unit;
   namecheap: BowmarkProvider_namecheap.Unit;
   nationalbusinessfurniture: BowmarkProvider_nationalbusinessfurniture.Unit;
   newageproducts: BowmarkProvider_newageproducts.Unit;
   newegg: BowmarkProvider_newegg.Unit;
+  nutrafol: BowmarkProvider_nutrafol.Unit;
   nvisioncenters: BowmarkProvider_nvisioncenters.Unit;
   oanda: BowmarkProvider_oanda.Unit;
   oliverwinery: BowmarkProvider_oliverwinery.Unit;
+  othership: BowmarkProvider_othership.Unit;
   otto: BowmarkProvider_otto.Unit;
   outdoorresearch: BowmarkProvider_outdoorresearch.Unit;
   pacificabeauty: BowmarkProvider_pacificabeauty.Unit;
@@ -24897,6 +25730,7 @@ interface BowmarkProviders {
   thibautdesign: BowmarkProvider_thibautdesign.Unit;
   tilsonhomes: BowmarkProvider_tilsonhomes.Unit;
   titlenine: BowmarkProvider_titlenine.Unit;
+  tmobile: BowmarkProvider_tmobile.Unit;
   topviewtix: BowmarkProvider_topviewtix.Unit;
   travelinsured: BowmarkProvider_travelinsured.Unit;
   trawickinternational: BowmarkProvider_trawickinternational.Unit;
@@ -76645,10 +77479,12 @@ interface BowmarkProviders {
  * `run()` script, and the Proxy over HTTP in a caller's own process. They are
  * generated once precisely so those two cannot drift. */
 interface BowmarkLibrary {
+  bundles: BowmarkCapability_bundles.Unit;
   cable_railing_quote: BowmarkCapability_cable_railing_quote.Unit;
   cars: BowmarkCapability_cars.Unit;
   coworking: BowmarkCapability_coworking.Unit;
   custom_sofa_configurator: BowmarkCapability_custom_sofa_configurator.Unit;
+  delivery: BowmarkCapability_delivery.Unit;
   developer_api_key_signup: BowmarkCapability_developer_api_key_signup.Unit;
   domain: BowmarkCapability_domain.Unit;
   email: BowmarkCapability_email.Unit;
@@ -76660,6 +77496,8 @@ interface BowmarkLibrary {
   hvac: BowmarkCapability_hvac.Unit;
   insurance: BowmarkCapability_insurance.Unit;
   istanbul_schedules: BowmarkCapability_istanbul_schedules.Unit;
+  local_database_gui: BowmarkCapability_local_database_gui.Unit;
+  local_html_preview: BowmarkCapability_local_html_preview.Unit;
   mcp_registry: BowmarkCapability_mcp_registry.Unit;
   music: BowmarkCapability_music.Unit;
   pcparts: BowmarkCapability_pcparts.Unit;
@@ -76669,6 +77507,8 @@ interface BowmarkLibrary {
   promocodes: BowmarkCapability_promocodes.Unit;
   read: BowmarkCapability_read.Unit;
   restaurant_booking: BowmarkCapability_restaurant_booking.Unit;
+  retail: BowmarkCapability_retail.Unit;
+  school_shopping_basket: BowmarkCapability_school_shopping_basket.Unit;
   search: BowmarkCapability_search.Unit;
   sheds: BowmarkCapability_sheds.Unit;
   shipping: BowmarkCapability_shipping.Unit;