@bowmark/web 1.12.1 → 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: 5207ea33354972da803d6974eed73abefc0ae46410767310486fd5116faa04c1
-// 34 capabilities, 257 providers, 674 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
@@ -325,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 {
@@ -1258,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 {
@@ -1741,6 +1862,46 @@ 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 {
@@ -1750,9 +1911,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 +1936,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 +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 {
@@ -6426,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 {
     /**
@@ -6453,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>;
   }
 }
 
@@ -7566,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 {
@@ -9616,6 +9887,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 {
@@ -11745,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 {
@@ -13433,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 {
@@ -16606,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 {
@@ -17105,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.
@@ -17257,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 {
@@ -21307,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
 }
 
@@ -21315,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 {
@@ -21330,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>;
   }
@@ -22534,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 {
@@ -23629,6 +24190,7 @@ interface walmartSearchResult {
   price: number | null;
   wasPrice: number | null;
   priceRangeMin: number | null;
+  conditionCode: number | null;
   inStock: boolean;
   rating: number | null;
   reviewCount: number;
@@ -24940,6 +25502,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;
@@ -25001,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;
@@ -25024,6 +25588,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;
@@ -25046,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;
@@ -25060,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;
@@ -25093,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;
@@ -25160,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;
@@ -76913,6 +77484,7 @@ interface BowmarkLibrary {
   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;
@@ -76924,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;
@@ -76933,6 +77507,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;