@bowmark/web 1.12.1 → 1.12.3

package/{src → 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: 5207ea33354972da803d6974eed73abefc0ae46410767310486fd5116faa04c1
-// 34 capabilities, 257 providers, 674 typed functions, 20 refused.
+// Manifest version: 7ac4a9084853ee226f56e4964cb0bb95339c8375142eebd03526a4d6651ae380
+// 39 capabilities, 274 providers, 707 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
@@ -197,6 +197,53 @@ type CallOptions = {
   }
 }
 
+declare namespace BowmarkCapability_costume_size_check {
+  // ── Check one costume character's stock at one size, across Target, Walmart, and Spirit Halloween — the unit's own declarations, verbatim ──
+interface RetailerSizeMatch {
+  title: string
+  url: string
+  price: { amount: number; currency: string } | null
+  inStock: boolean
+}
+interface RetailerSizeResult {
+  matched: RetailerSizeMatch | null   // null + incomplete=false means this retailer
+                                       // answered and has no listing in this size
+  incomplete: boolean                 // true means this retailer's call never
+                                       // answered — matched is NOT a stockout then
+}
+interface CostumeSizeCheck {
+  character: string
+  size: string
+  retailers: { target: RetailerSizeResult; walmart: RetailerSizeResult; spirithalloween: RetailerSizeResult }
+  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 costume character and a size, fans out to Target, Walmart, and Spirit Halloween and
+   * reports whether each retailer has that exact character-and-size combination in stock right
+   * now — the per-size question a plain product search can't answer, because Target and Walmart
+   * bake size into a free-text title and Spirit Halloween only exposes its full size matrix on
+   * the product page.
+   */
+  interface Unit {
+    /**
+     * Checks whether one costume character exists in one size, right now, at Target, Walmart, and
+     * Spirit Halloween. `retailers.<name>.matched` is the listing that named both the character
+     * and the size, or null when that retailer answered and has none. `incomplete: true` means
+     * that retailer's own call never answered — a missed deadline or an error — so `matched: null`
+     * there is NOT a stockout; nothing was learned. Never throws on one or two retailers being
+     * unreachable — the surviving legs still answer and the dropped ones are named in `warnings`;
+     * throws only when all three failed.
+     */
+    checkSize(args: { character: string; size: string }): Promise<CostumeSizeCheck>;
+  }
+}
+
 declare namespace BowmarkCapability_coworking {
   // ── Coworking space day passes — the unit's own declarations, verbatim ──
 type CoworkingDayPass = {
@@ -325,6 +372,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 {
@@ -1258,6 +1345,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 {
@@ -1741,6 +1909,49 @@ type CallOptions = {
   }
 }
 
+declare namespace BowmarkCapability_retail {
+  // ── Retail (general merchandise, multi-store) — the unit's own declarations, verbatim ──
+type RetailOffer = {
+  store: "walmart" | "target" | "bestbuy"  // 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, 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.
+   */
+  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.
+     */
+    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 {
@@ -1750,9 +1961,13 @@ interface BasketItemMatch {
   price: { amount: number; currency: string }   // integer minor units
 }
 interface RetailerBasket {
-  total: { amount: number; currency: string } | null
+  total: { amount: number; currency: string } | null   // sums matched only — a partial
+                                                       // sum whenever incomplete is
+                                                       // non-empty
   matched: BasketItemMatch[]
-  unavailable: string[]
+  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 }
@@ -1771,10 +1986,15 @@ type CallOptions = {
    */
   interface Unit {
     /**
-     * Prices a multi-item shopping list at Target and Walmart, one basket total per retailer,
-     * naming which items had no in-stock match anywhere. 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.
+     * 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>;
   }
@@ -3141,6 +3361,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 {
@@ -3799,6 +4064,44 @@ interface AzureListServicesResult {
   }
 }
 
+declare namespace BowmarkProvider_bankmycell {
+  // ── BankMyCell — the unit's own declarations, verbatim ──
+interface BankmycellOffer {
+  merchant: string;
+  price: number;
+  paymentOptions: string;
+  shippingOptions: { id: string; name: string }[];
+  pricelockTimescale: string | null;
+  paymentTimescale: string | null;
+  checkoutLink: string;
+  reviewsRating: number | null;
+  reviewsCount: number | null;
+}
+interface BankmycellQuoteResult {
+  deviceUrl: string;
+  selections: { capacity: string | null; condition: string | null; carrier: string | null; lockedStatus: string | null };
+  offers: BankmycellOffer[];
+  unavailableMerchants: string[];
+  summary: { minPrice: number | null; maxPrice: number | null; avgPrice: number | null; count: number };
+}
+
+  /**
+   * Live trade-in offers for a phone/device from every merchant BankMyCell compares, for a
+   * chosen capacity/condition/carrier — read off the same pricing endpoint the site's own sell
+   * page polls, instead of parsing prose off the rendered page.
+   */
+  interface Unit {
+    /**
+     * Reads live trade-in offers for the device at a bankmycell.com sell page (e.g.
+     * .../sell/iphone-14-pro), from every merchant the site compares, for the given
+     * capacity/condition/carrier/lockedStatus (each matched against that device's own option
+     * labels, e.g. condition: "Flawless"). Any selection left out uses the page's own default
+     * option for that attribute. THROWS if a selection names an option this device does not offer.
+     */
+    getTradeInQuote(deviceUrl: string, selections?: { capacity?: string; condition?: string; carrier?: string; lockedStatus?: string }): Promise<BankmycellQuoteResult>;
+  }
+}
+
 declare namespace BowmarkProvider_barletta {
   // ── Barletta Boats — the unit's own declarations, verbatim ──
 // Barletta's OWN shapes — not a capability contract.
@@ -6236,6 +6539,43 @@ interface ClasspassSearchResult {
   }
 }
 
+declare namespace BowmarkProvider_claudemarketplaces_com {
+  // ── Claude Marketplaces — the unit's own declarations, verbatim ──
+interface claudeMarketplacesListing {
+  url: string;
+  kind: string;
+  publisher: string;
+  slug: string;
+  name: string;
+  description: string;
+  applicationCategory: string | null;
+  operatingSystem: string | null;
+  codeRepository: string | null;
+  featureList: string[];
+  price: string | null;
+  priceCurrency: string | null;
+}
+
+  /**
+   * A directory of Claude plugin/MCP/skill marketplace listings — fetch one listing's structured
+   * fields (name, description, category, repo, declared tools, price) instead of parsing its
+   * page by hand.
+   */
+  interface Unit {
+    /**
+     * Fetches one MCP server listing page from claudemarketplaces.com — `url` is the listing's
+     * full URL or path, e.g. "https://claudemarketplaces.com/mcp/metroxe/bowmark" or
+     * "/mcp/github/github-mcp-server". Returns the listing's structured fields straight off the
+     * page's own schema.org `SoftwareApplication` record: `name`, `description`,
+     * `applicationCategory`, `operatingSystem`, `codeRepository`, `featureList` (the tool/feature
+     * names the listing declares), and `price`/`priceCurrency`. `publisher`, `kind` and `slug` are
+     * read off the URL path. Only `mcp`-kind listings (`/mcp/<publisher>/<slug>`) are implemented
+     * — `getListing` throws `ClaudeMarketplacesInputError` for any other path shape.
+     */
+    getListing(url: string): Promise<claudeMarketplacesListing>;
+  }
+}
+
 declare namespace BowmarkProvider_cleanairlawncare {
   // ── Clean Air Lawn Care — the unit's own declarations, verbatim ──
 interface CleanAirEstimateAvailability {
@@ -6426,17 +6766,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 {
     /**
@@ -6453,12 +6811,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>;
   }
 }
 
@@ -6658,6 +7026,41 @@ interface CultureFlyCheckoutLink {
   }
 }
 
+declare namespace BowmarkProvider_curiocity {
+  // ── Curiocity — the unit's own declarations, verbatim ──
+interface CuriocityEvent {
+  title: string;             // "Slayyyter – WOR$T GIRL IN THE WORLD TOUR"
+  url: string;                // click-through — the event's own link, or the article's
+  when: string | null;        // "Thursday, Sept. 3, 2026" — free text, as curiocity writes it
+  time: string | null;        // "7 p.m."
+  where: string | null;       // "868 Granville St."
+  cost: string | null;        // "$650+"
+  articleTitle: string;       // the roundup (or single-event) post this came from
+  articleUrl: string;
+  publishedAt: string | null; // the article's own pubDate
+}
+
+interface CuriocityListEventsQuery {
+  city: string; // curiocity's own city slug, e.g. "vancouver", "toronto"
+}
+
+  /**
+   * Curiocity's own city 'things to do' feeds, parsed into individual events — title, when,
+   * time, where, cost and a click-through link — instead of the raw RSS/HTML a caller would
+   * otherwise have to regex apart.
+   */
+  interface Unit {
+    /**
+     * Reads curiocity.com's own 'things to do' feed for one city and returns individual events —
+     * title, when, time, where, cost and a click-through link — parsed out of the site's roundup
+     * posts instead of the raw RSS. `city` is curiocity's own slug (e.g. "vancouver", "toronto").
+     * An empty array is the feed's own answer for a city curiocity does not cover, never invented
+     * here — a block page or a moved endpoint THROWS instead.
+     */
+    listEvents(query: CuriocityListEventsQuery): Promise<CuriocityEvent[]>;
+  }
+}
+
 declare namespace BowmarkProvider_cyberpowerpc {
   // ── CyberPowerPC — the unit's own declarations, verbatim ──
 interface CyberpowerpcConfigurator {
@@ -7566,6 +7969,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 {
@@ -7816,6 +8247,34 @@ interface ErieAgent {
   }
 }
 
+declare namespace BowmarkProvider_etsy {
+  // ── Etsy — the unit's own declarations, verbatim ──
+interface etsyListing {
+  listingId: number;
+  title: string;
+  price: number | null;
+  currencyCode: string | null;
+  quantity: number | null;
+  tags: string[];
+  url: string;
+}
+
+  /**
+   * Etsy's own documented Open API v3 (openapi.etsy.com) — searches active listings on etsy.com
+   * by keyword and returns id, title, price, currency, quantity, tags and the listing's own
+   * etsy.com URL, without scraping etsy.com's search page (which sits behind DataDome).
+   */
+  interface Unit {
+    /**
+     * Searches Etsy's live catalog of active listings by keyword, via Etsy's documented Open API
+     * v3, and returns the matching listings — id, title, price, currency, quantity available, tags
+     * and the listing's own etsy.com URL. `limit` caps the row count (default 10, Etsy's own
+     * ceiling 100). Requires an Etsy developer API key — see this provider's `auth`.
+     */
+    search(args: string | { query: string; limit?: number }): Promise<etsyListing[]>;
+  }
+}
+
 declare namespace BowmarkProvider_eventsource {
   // ── Event Source — the unit's own declarations, verbatim ──
 interface EventSourceDesign {
@@ -9616,6 +10075,78 @@ 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 {
@@ -11370,6 +11901,69 @@ interface HobieLocalAvailability {
   }
 }
 
+declare namespace BowmarkProvider_hodjapasha {
+  // ── Hodjapasha Culture Center — Istanbul whirling-dervish and dance show ticketing — the unit's own declarations, verbatim ──
+interface HodjapashaListingEntry {
+  productId: string;
+  title: string;
+  summary: string | null;
+  duration: string | null;
+  priceFrom: string | null;   // the site's own "from" price, e.g. "$42.22"
+  currency: string | null;
+  url: string;
+}
+interface HodjapashaShowDetail {
+  productId: string;
+  title: string;
+  description: string | null; // the site's own description paragraphs, joined
+  duration: string | null;
+  location: string | null;
+  productCode: string | null;
+  priceFrom: string | null;
+  currency: string | null;
+  url: string;
+}
+interface HodjapashaSession {
+  sessionId: string;
+  label: string;              // e.g. "20:30 - Available"
+}
+interface HodjapashaAvailability {
+  productId: string;
+  date: string;                // YYYY-MM-DD, as queried
+  available: boolean;
+  sessions: HodjapashaSession[];
+  totalPrice: string | null;   // e.g. "1900"
+  currency: string | null;
+}
+
+  /**
+   * The Hodjapasha Culture Center's own Rezdy booking widget for its whirling-dervish (Sema) and
+   * Ottoman/folk dance shows in Istanbul — show list, per-show pricing and description, and
+   * date/party-size availability with session times and total price, read straight off the
+   * widget's own pages.
+   */
+  interface Unit {
+    /**
+     * Reads every show hodjapasha.com's own booking widget lists off /widget/index.php — title,
+     * productId, from-price, duration.
+     */
+    listShows(): Promise<HodjapashaListingEntry[]>;
+
+    /**
+     * Reads one show's full description, adult/child pricing, location and duration off its own
+     * /widget/product-detail.php page.
+     */
+    getShow(productId: string): Promise<HodjapashaShowDetail>;
+
+    /**
+     * Checks the widget's own availability endpoint for a show, YYYY-MM-DD date and party size
+     * (defaults: 1 adult, 0 children), returning the session time(s) offered and the total price,
+     * or `available: false` for a date the show does not run.
+     */
+    getAvailability(productId: string, date: string, opts?: { adults?: number; children?: number }): Promise<HodjapashaAvailability>;
+  }
+}
+
 declare namespace BowmarkProvider_holidaybuilders {
   // ── Holiday Builders — the unit's own declarations, verbatim ──
 // Holiday Builders' OWN shapes — not a capability contract.
@@ -11745,6 +12339,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 {
@@ -13433,6 +14043,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 {
@@ -16115,6 +16743,58 @@ interface StoreShelfRoster {
   }
 }
 
+declare namespace BowmarkProvider_millisaraylar {
+  // ── millisaraylar.gov.tr — Türkiye Presidential Administration of National Palaces — the unit's own declarations, verbatim ──
+interface MillisaraylarPalace {
+  id: string;
+  name: string;
+  url: string;
+}
+interface MillisaraylarVisitingHours {
+  name: string;
+  closedDays: string | null;           // the site's own text, e.g. "Tuesday"
+  ticketOfficeOpeningTime: string | null; // "HH:MM"
+  ticketOfficeClosingTime: string | null; // "HH:MM"
+  url: string;
+}
+interface MillisaraylarTicketPrices {
+  name: string;
+  currency: "TRY";
+  domestic: number | null;
+  domesticStudent: number | null;
+  foreign: number | null;
+  url: string;
+}
+
+  /**
+   * Türkiye's Presidential Administration of National Palaces — the palace/kiosk/pavilion list,
+   * closed days and ticket-office hours, and domestic/domestic-student/foreign ticket prices for
+   * Topkapi Palace, Dolmabahçe Palace, Yıldız Palace, Beylerbeyi Palace and the other sites it
+   * administers, read straight off the site's own ticket-purchase and detail pages.
+   */
+  interface Unit {
+    /**
+     * Reads the full palace/kiosk/pavilion/museum/factory list off millisaraylar.gov.tr's own site
+     * navigation.
+     */
+    getPalaces(): Promise<MillisaraylarPalace[]>;
+
+    /**
+     * Matches `query` against `getPalaces()`'s own listing (a substring match on the site's own
+     * display name, e.g. "Topkapi" or "Dolmabahce") and reads that site's closed day(s) and
+     * ticket-office opening/closing hours off its detail page.
+     */
+    getVisitingHours(query: string): Promise<MillisaraylarVisitingHours>;
+
+    /**
+     * Matches `query` against millisaraylar.gov.tr's own ticket-purchase location list (a narrower
+     * set than `getPalaces` — only what is sold as a standalone ticket) and reads the domestic,
+     * domestic-student and foreign prices (TRY) the site itself quotes.
+     */
+    getTicketPrices(query: string): Promise<MillisaraylarTicketPrices>;
+  }
+}
+
 declare namespace BowmarkProvider_minimax {
   // ── MiniMax — the unit's own declarations, verbatim ──
 interface MinimaxDocIndexEntry {
@@ -16606,6 +17286,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 {
@@ -17105,6 +17822,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.
@@ -17257,6 +18011,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 {
@@ -20749,6 +21566,62 @@ interface ScPlaylist {
   }
 }
 
+declare namespace BowmarkProvider_spirithalloween {
+  // ── Spirit Halloween — the unit's own declarations, verbatim ──
+interface SpiritHalloweenSearchResult {
+  productId: string
+  sku: string
+  name: string
+  url: string
+  image: string | null
+  price: number | null
+  currency: "USD"
+  listedSize: string | null       // the ONE size this listing row is indexed under
+  listedSizeStock: number | null  // that size's stock only — not the full range
+}
+interface SpiritHalloweenSearchResults {
+  query: string
+  category: string
+  results: SpiritHalloweenSearchResult[]
+  totalMatches: number | null
+}
+interface SpiritHalloweenSizeVariant {
+  color: string
+  size: string           // the site's own size label, e.g. "CHILD MEDIUM"
+  price: number
+  inStock: boolean
+  shipStockQuantity: number
+  variantId: string
+}
+interface SpiritHalloweenProduct {
+  productId: string
+  name: string
+  url: string
+  sizes: SpiritHalloweenSizeVariant[]   // every real color/size combination, each with its own live stock
+}
+
+  /**
+   * The licensed Halloween costume specialist — category browse and per-size, per-color live
+   * stock for the lines it carries (today: KPop Demon Hunters).
+   */
+  interface Unit {
+    /**
+     * Browses Spirit Halloween's category listing for a query resolved against a small internal
+     * directory of mapped categories (today: "KPop Demon Hunters" and its characters — rumi, mira,
+     * zoey, saja) — NOT a general free-text site search, which was probed 2026-09-01 and does not
+     * render results server-side. Each result row carries only its OWN listed size's stock; call
+     * getProduct for the full per-size breakdown.
+     */
+    search(args: { query: string; limit?: number }): Promise<SpiritHalloweenSearchResults>;
+
+    /**
+     * Reads one product page's full live size/color matrix — every real variant this product sells
+     * in, each with its own price and in-stock signal — for a product URL returned by search.
+     */
+    getProduct(args: { url: string }): Promise<SpiritHalloweenProduct>;
+  }
+}
+
 declare namespace BowmarkProvider_starlighthomes {
   // ── Starlight Homes — the unit's own declarations, verbatim ──
 // Starlight Homes' OWN shapes — not a capability contract.
@@ -21307,7 +22180,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
 }
 
@@ -21315,8 +22188,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 {
@@ -21330,30 +22203,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>;
   }
@@ -21783,7 +22655,7 @@ interface TherabodyRecommendation {
 
     /**
      * Filters the live catalogue by what a shopper actually needs — device family, audience, and
-     * the features named (percussion, recovery, hot/cold, breath). Returns the matching products
+     * the features named (percussive, recovery, massage, vibration). Returns the matching products
      * with their real prices, ranked by in-stock first. The storefront does not publish a query or
      * filter endpoint, so the function is local filtering on the catalogue listTheragunProducts
      * already returns — the divide is what the function does with the data, not how it gets there.
@@ -22534,6 +23406,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 {
@@ -23629,6 +24549,7 @@ interface walmartSearchResult {
   price: number | null;
   wasPrice: number | null;
   priceRangeMin: number | null;
+  conditionCode: number | null;
   inStock: boolean;
   rating: number | null;
   reviewCount: number;
@@ -23924,6 +24845,36 @@ interface XpressWaitTime {
   }
 }
 
+declare namespace BowmarkProvider_yelp {
+  // ── Yelp — the unit's own declarations, verbatim ──
+interface YelpSearchArgs {
+  term: string;      // e.g. "ramen" — Yelp's own find_desc
+  location: string;  // e.g. "Philadelphia, PA" — Yelp's own find_loc
+  limit?: number;     // default 10, clamped to [1, 30]
+}
+
+interface YelpSearchResult {
+  name: string;
+  url: string;
+  rating: number | null;
+  reviewCount: number | null;
+  priceRange: string | null;   // "$".."$$$$", or null
+  neighborhood: string | null;
+}
+
+  /**
+   * Yelp's own business search — returns real, currently-listed businesses for a search term and
+   * location with Yelp's own star rating, review count, price tier and neighborhood.
+   */
+  interface Unit {
+    /**
+     * Runs Yelp's own business search for a term and location and returns real, currently-listed
+     * businesses with Yelp's own rating, review count, price tier and neighborhood. Read-only.
+     */
+    search(args: YelpSearchArgs): Promise<YelpSearchResult[]>;
+  }
+}
+
 declare namespace BowmarkProvider_yorkwallcoverings {
   // ── York Wallcoverings — the unit's own declarations, verbatim ──
 interface YorkWallcoveringsSearchResult {
@@ -24940,6 +25891,7 @@ interface BowmarkProviders {
   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;
@@ -24950,6 +25902,7 @@ interface BowmarkProviders {
   avis: BowmarkProvider_avis.Unit;
   azazie: BowmarkProvider_azazie.Unit;
   azure: BowmarkProvider_azure.Unit;
+  bankmycell: BowmarkProvider_bankmycell.Unit;
   barletta: BowmarkProvider_barletta.Unit;
   baublebar: BowmarkProvider_baublebar.Unit;
   bcparkscamping: BowmarkProvider_bcparkscamping.Unit;
@@ -24984,6 +25937,7 @@ interface BowmarkProviders {
   chriscraft: BowmarkProvider_chriscraft.Unit;
   classichome: BowmarkProvider_classichome.Unit;
   classpass: BowmarkProvider_classpass.Unit;
+  claudemarketplaces_com: BowmarkProvider_claudemarketplaces_com.Unit;
   cleanairlawncare: BowmarkProvider_cleanairlawncare.Unit;
   cloudflare: BowmarkProvider_cloudflare.Unit;
   clubchampion: BowmarkProvider_clubchampion.Unit;
@@ -24991,6 +25945,7 @@ interface BowmarkProviders {
   couponfollow: BowmarkProvider_couponfollow.Unit;
   cruiselakegeneva: BowmarkProvider_cruiselakegeneva.Unit;
   culturefly: BowmarkProvider_culturefly.Unit;
+  curiocity: BowmarkProvider_curiocity.Unit;
   cyberpowerpc: BowmarkProvider_cyberpowerpc.Unit;
   davidsonhomes: BowmarkProvider_davidsonhomes.Unit;
   deangroup: BowmarkProvider_deangroup.Unit;
@@ -25001,11 +25956,13 @@ 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;
   eq3: BowmarkProvider_eq3.Unit;
   erieinsurance: BowmarkProvider_erieinsurance.Unit;
+  etsy: BowmarkProvider_etsy.Unit;
   eventsource: BowmarkProvider_eventsource.Unit;
   evolutionofsmooth: BowmarkProvider_evolutionofsmooth.Unit;
   executivehomecare: BowmarkProvider_executivehomecare.Unit;
@@ -25024,6 +25981,7 @@ 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;
@@ -25042,10 +26000,12 @@ interface BowmarkProviders {
   hilton: BowmarkProvider_hilton.Unit;
   historymaker: BowmarkProvider_historymaker.Unit;
   hobie: BowmarkProvider_hobie.Unit;
+  hodjapasha: BowmarkProvider_hodjapasha.Unit;
   holidaybuilders: BowmarkProvider_holidaybuilders.Unit;
   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;
@@ -25060,6 +26020,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;
@@ -25086,6 +26047,7 @@ interface BowmarkProviders {
   medicare: BowmarkProvider_medicare.Unit;
   mergify: BowmarkProvider_mergify.Unit;
   microcenter: BowmarkProvider_microcenter.Unit;
+  millisaraylar: BowmarkProvider_millisaraylar.Unit;
   minimax: BowmarkProvider_minimax.Unit;
   minted: BowmarkProvider_minted.Unit;
   mixbook: BowmarkProvider_mixbook.Unit;
@@ -25093,14 +26055,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;
@@ -25142,6 +26107,7 @@ interface BowmarkProviders {
   smithery: BowmarkProvider_smithery.Unit;
   solostove: BowmarkProvider_solostove.Unit;
   soundcloud: BowmarkProvider_soundcloud.Unit;
+  spirithalloween: BowmarkProvider_spirithalloween.Unit;
   starlighthomes: BowmarkProvider_starlighthomes.Unit;
   statefarm: BowmarkProvider_statefarm.Unit;
   stickergiant: BowmarkProvider_stickergiant.Unit;
@@ -25160,6 +26126,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;
@@ -25181,6 +26148,7 @@ interface BowmarkProviders {
   wellfound: BowmarkProvider_wellfound.Unit;
   winestyles: BowmarkProvider_winestyles.Unit;
   xpresswellnessurgentcare: BowmarkProvider_xpresswellnessurgentcare.Unit;
+  yelp: BowmarkProvider_yelp.Unit;
   yorkwallcoverings: BowmarkProvider_yorkwallcoverings.Unit;
   yourarborhome: BowmarkProvider_yourarborhome.Unit;
   youtube: BowmarkProvider_youtube.Unit;
@@ -76911,8 +77879,10 @@ interface BowmarkLibrary {
   bundles: BowmarkCapability_bundles.Unit;
   cable_railing_quote: BowmarkCapability_cable_railing_quote.Unit;
   cars: BowmarkCapability_cars.Unit;
+  costume_size_check: BowmarkCapability_costume_size_check.Unit;
   coworking: BowmarkCapability_coworking.Unit;
   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;
@@ -76924,6 +77894,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;
@@ -76933,6 +77905,7 @@ 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;