@bowmark/web 1.8.0 → 1.10.0

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: b71c060db620c119ab92eac724aab2d9670d3d22f342f754075e353929634db2
-// 9 capabilities, 121 providers, 380 typed functions, 20 refused.
+// Manifest version: cad629ad449ffa7b6e12b0299082209643912c130193213d154764eeb434951f
+// 10 capabilities, 155 providers, 457 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
@@ -102,7 +102,10 @@ type CallOptions = {
      * IATA codes and a city name would come back as an empty list an agent would misread as "no
      * cars available". `warnings` is always present and names anything dropped or clamped —
      * INCLUDING a site that timed out or failed, which quoted nothing and is not the same as an
-     * airport with no availability. `options.timeoutMs` sets the per-site budget (default 30000).
+     * airport with no availability. And when NO site answered at all this THROWS rather than
+     * returning `cars: []`, because those two are the same value and only one of them means there
+     * are no cars: a list you receive is always a list a site actually gave. `options.timeoutMs`
+     * sets the per-site budget (default 30000).
      */
     search(query: CarQuery, limit?: number, options?: CallOptions): Promise<CarSearchResult>;
   }
@@ -315,9 +318,11 @@ type FlightStatusResult = {
      * completely different fact from a site that was never reached, so coverage is NOT inferable
      * from the rows. Read `warnings` before treating them as the whole market: a dropped site
      * means the real cheapest fare may not be here at all. Three of the four sites run one shared
-     * engine, so they tend to fail together. `options.timeoutMs` sets the per-site budget (default
-     * 30000) — a site slower than that is dropped and named, so the answer arrives inside the
-     * calling client's own tool-call limit rather than not at all.
+     * engine, so they tend to fail together — and when ALL FOUR are gone this THROWS instead of
+     * returning `flights: []`, since an empty list would otherwise be indistinguishable from a
+     * route nobody flies. `options.timeoutMs` sets the per-site budget (default 30000) — a site
+     * slower than that is dropped and named, so the answer arrives inside the calling client's own
+     * tool-call limit rather than not at all.
      */
     search(query: FlightQuery, options?: CallOptions): Promise<FlightSearchResult>;
 
@@ -424,8 +429,10 @@ type CallOptions = {
      * multiplying `nightPrice` by the night count on a multi-room search is out by a factor of
      * `rooms`; compare on `price`. `warnings` is always present and names anything dropped or
      * clamped — INCLUDING a site that timed out or failed, which returned nothing and is not the
-     * same as a sold-out destination. This route drives a real browser and is the slowest thing in
-     * the library: 21-26s measured, against `options.timeoutMs`'s 30000 default. RAISE that budget
+     * same as a sold-out destination. And when NO site answered at all this THROWS rather than
+     * returning `hotels: []`, because those two are the same value and only one of them means
+     * there is nowhere to stay. This route drives a real browser and is the slowest thing in the
+     * library: 21-26s measured, against `options.timeoutMs`'s 30000 default. RAISE that budget
      * rather than lowering it if you batch several searches into one call.
      */
     search(query: HotelQuery, limit?: number, options?: CallOptions): Promise<HotelSearchResult>;
@@ -577,8 +584,9 @@ type CallOptions = {
      * would otherwise return a list an agent would misread. `reportCategories` says which
      * regulator reports exist for a carrier, NOT which lines it writes. `warnings` is always
      * present, and a source that timed out or failed is NAMED there — read it before treating an
-     * empty list as "no carrier is licensed there". `options.timeoutMs` sets the per-source budget
-     * (default 30000).
+     * empty list as "no carrier is licensed there". When NO source answered at all this THROWS
+     * instead of returning an empty list, so that misreading is not available. `options.timeoutMs`
+     * sets the per-source budget (default 30000).
      */
     searchCarriers(query: CarrierQuery, limit?: number, options?: CallOptions): Promise<CarrierSearchResult>;
 
@@ -595,7 +603,9 @@ type CallOptions = {
      * only when the query carries neither a zip nor a city+state — one carrier alone is a complete
      * query, not a partial one. `warnings` is always present: a carrier the query lacked input
      * for, or one that timed out or failed, is NAMED there — read it before treating a short list
-     * as the whole answer. `options.timeoutMs` sets the per-carrier budget (default 30000).
+     * as the whole answer. When every carrier the query DID reach for failed, this THROWS rather
+     * than returning an empty list, which would otherwise read as "no agent near you".
+     * `options.timeoutMs` sets the per-carrier budget (default 30000).
      */
     findAgent(query: AgentLocatorQuery, limit?: number, options?: CallOptions): Promise<AgentSearchResult>;
 
@@ -637,8 +647,9 @@ type CallOptions = {
      * answered: this is a published directory with no legitimate empty case, so a missing section
      * or a changed page throws at the provider rather than under-reporting who underwrites the
      * policy. `warnings` is always present and names a source that timed out or failed — with one
-     * source today, read it before trusting a short list is the whole directory.
-     * `options.timeoutMs` sets the per-source budget (default 30000).
+     * source today, read it before trusting a short list is the whole directory. When no source
+     * answered at all this THROWS, so an outage is never handed back as a directory with nothing
+     * in it. `options.timeoutMs` sets the per-source budget (default 30000).
      */
     listReferralCarriers(query?: ReferralCarrierQuery, options?: CallOptions): Promise<ReferralCarrierListResult>;
   }
@@ -697,8 +708,10 @@ type MusicTrackResult = {
      * synthwave") and returns up to `limit` normalized tracks (default 20, max 200), most-played
      * first. Tracks with no reported play count sort last rather than as zero. `warnings` is
      * always present and names anything dropped — INCLUDING a catalogue that timed out or failed,
-     * which returned nothing and is not the same as a query with no matches. `options.timeoutMs`
-     * sets the per-catalogue budget (default 30000).
+     * which returned nothing and is not the same as a query with no matches. And when NO catalogue
+     * answered at all this THROWS rather than returning `tracks: []`, because those two are the
+     * same value and only one of them means nothing matched. `options.timeoutMs` sets the
+     * per-catalogue budget (default 30000).
      */
     search(query: string, limit?: number, options?: CallOptions): Promise<MusicSearchResult>;
 
@@ -783,8 +796,9 @@ type ProductResult = {
      * price-sorted (cheapest first), each tagged with its `store`. A store that is genuinely empty
      * contributes nothing and says nothing; a store that TIMED OUT or FAILED is named in
      * `warnings`, and the two are not the same fact — "the cheapest of three stores" is a wrong
-     * claim when one of them never answered. `options.timeoutMs` sets the per-store budget
-     * (default 30000).
+     * claim when one of them never answered. When ALL THREE never answered this THROWS rather than
+     * returning `offers: []`, because that empty list is the same value as a part nobody stocks.
+     * `options.timeoutMs` sets the per-store budget (default 30000).
      */
     search(query: string, options?: CallOptions): Promise<OfferSearchResult>;
 
@@ -861,6 +875,80 @@ type ReadResult = {
   }
 }
 
+declare namespace BowmarkCapability_search {
+  // ── Web search — the unit's own declarations, verbatim ──
+type SearchResult = {
+  source: string              // which ENGINE produced this row ("bing")
+  rank: number                // 1-based, in that engine's own ranking
+  title: string
+  url: string                 // the destination page, already unwrapped from any
+                              // click-tracker — pass it straight to read.page
+  snippet: string | null      // the engine's blurb; null when it published none
+  published: string | null    // ISO. On `web` this is often the engine's CRAWL
+                              // date, not the page's — do not report it as one
+}
+type SearchWebResult = {
+  query: string
+  engine: string              // who actually answered. With a fallback chain this
+                              // is the difference between the primary engine's
+                              // ranking and the standby's
+  results: SearchResult[]
+  warnings: string[]          // always present. Names every engine tried and
+                              // FAILED before the one that answered
+}
+
+// news adds the two things a news index has and a web index does not
+type NewsResult = SearchResult & {
+  publisher: string | null    // the outlet
+  imageUrl: string | null     // usually the engine's cached thumbnail
+}
+type SearchNewsResult = {
+  query: string
+  engine: string
+  results: NewsResult[]
+  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
+}
+
+  /**
+   * Find pages on the web when you do not already know the URL — the step before read.page.
+   * Returns ranked results with title, destination URL and snippet. `news` is the same read over
+   * news coverage, with real publication dates and the outlet's name. ONE ENGINE TODAY (Bing),
+   * so if it is down this fails rather than degrading — it throws, and never reports an outage
+   * as zero results. Two things that engine cannot do, measured on `web`: it never returns an
+   * empty list even when nothing matches, and it ignores search operators like site:.
+   */
+  interface Unit {
+    /**
+     * Searches the web and returns ranked results — title, destination URL, snippet — from the
+     * first engine in the chain that answers. `engine` names which one that was, and `warnings`
+     * names any that were tried and failed first. Feed a result's `url` straight to
+     * bowmark.read.page to actually read it. TWO THINGS TO KNOW BEFORE YOU TRUST THE ROWS: the
+     * engine NEVER returns an empty list, so results are its best offer rather than proof anything
+     * matched, and it IGNORES operators — a `site:example.com` query is not scoped to that site.
+     * When every engine fails this THROWS rather than returning zero rows, because no engine
+     * reached is not the same as nothing found.
+     */
+    web(query: string | { query: string, limit?: number }, limit?: number, options?: CallOptions): Promise<SearchWebResult>;
+
+    /**
+     * Searches news coverage and returns stories with the headline, the outlet's own article URL,
+     * a summary, the publisher's name and a real publication timestamp. Use this rather than `web`
+     * whenever the question is about what happened or when — `web`'s dates are commonly the
+     * engine's crawl stamp, and these are the story's own. NOT MEASURED on the two limits `web`
+     * declares: nobody has checked whether this feed returns an empty list for a query with no
+     * coverage, or whether it honours operators. Treat both as unknown rather than as working —
+     * `web`'s answers are the ones with fixtures behind them.
+     */
+    news(query: string | { query: string, limit?: number }, limit?: number, options?: CallOptions): Promise<SearchNewsResult>;
+  }
+}
+
 declare namespace BowmarkCapability_sheds {
   // ── Sheds and portable buildings (configure and price) — the unit's own declarations, verbatim ──
 type ShedSize = {
@@ -958,7 +1046,9 @@ type CallOptions = {
      * as well as costing it — a real product image, the roof line and roofing material, the
      * maker's own wall-height spec — and carries `orderUrl`, their own page to go order that
      * build. `warnings` is always present and names a maker that failed, styles that do not build
-     * the size, and a capped fan. `options.timeoutMs` sets the per-maker budget (default 30000).
+     * the size, and a capped fan. When NO maker answered at all this THROWS rather than returning
+     * an empty list — "nobody builds a 12x20" and "nobody could be reached" are otherwise the same
+     * result. `options.timeoutMs` sets the per-maker budget (default 30000).
      */
     quote(request: ShedQuoteRequest, options?: CallOptions): Promise<ShedQuoteResult>;
 
@@ -967,7 +1057,9 @@ type CallOptions = {
      * it can be built in, every real buildable size in FEET, and what the building IS (a real
      * product image, the roof line and roofing material, the maker's own wall-height spec). Use it
      * to see what exists before pricing, or to answer "what sizes do they even make". `warnings`
-     * names any maker that returned nothing, which is not the same as a maker with no styles.
+     * names any maker that returned nothing, which is not the same as a maker with no styles. When
+     * NO maker answered at all this THROWS rather than returning an empty list, because an empty
+     * catalogue and an unreachable one are otherwise the same value.
      */
     listStyles(options?: CallOptions): Promise<ShedStylesResult>;
 
@@ -975,7 +1067,9 @@ type CallOptions = {
      * Looks up the real places that sell a maker's buildings in one US state or Canadian province
      * — full name ("Tennessee") or abbreviation ("TN") — with name, city, phone and the dealer's
      * own page, for handing a priced configuration to somebody who can actually build it. `phone`
-     * is null when the directory lists none, never an empty string.
+     * is null when the directory lists none, never an empty string. `warnings` names any maker
+     * whose directory could not be read, and when NO directory could be read at all this THROWS
+     * rather than returning an empty list, which would read as "no dealers in that state".
      */
     findDealers(state: string, options?: CallOptions): Promise<ShedDealerResult>;
   }
@@ -1646,6 +1740,123 @@ interface AshleyFurnitureStore {
   }
 }
 
+declare namespace BowmarkProvider_asppoolco {
+  // ── ASP - America's Swimming Pool Company — the unit's own declarations, verbatim ──
+// ASP's OWN shapes — not a capability contract.
+
+interface AspLocation {
+  name: string;             // e.g. "ASP - America's Swimming Pool Company of Baldwin County"
+  state: string;             // two-letter state code
+  url: string;                // the location's own site
+  requestServiceUrl: string;  // handoff URL — ASP's own per-location request form
+  phone: string;
+  coverageZips: string[];     // every zip this location's page declares covering
+}
+
+interface AspZipMatch {
+  zip: string;
+  covered: boolean;           // false = no published ASP location covers this zip yet
+  location: AspLocation | null;
+}
+
+  /**
+   * ASP - America's Swimming Pool Company's own 257-location franchise directory — match a zip
+   * code to the exact local ASP franchise that services it (name, phone, coverage) and hand back
+   * that location's own Request Service form URL, the same match/route step ASP's site itself
+   * performs before a homeowner can request service.
+   */
+  interface Unit {
+    /**
+     * Matches a 5-digit US zip code against ASP's 257-location franchise network and returns the
+     * ONE local franchise that services it — name, phone, coverage zips, and its own Request
+     * Service form URL to hand the shopper to. `covered: false` means no published ASP location
+     * covers that zip yet, a real answer, not a failure.
+     */
+    findLocationByZip(zip: string): Promise<AspZipMatch>;
+
+    /**
+     * Lists every ASP franchise location on the public directory — name, state, phone, coverage
+     * zips, site URL and Request Service URL. `state` (optional, two-letter code, e.g. "GA")
+     * narrows to that state.
+     */
+    listLocations(state?: string): Promise<AspLocation[]>;
+  }
+}
+
+declare namespace BowmarkProvider_atlasoceanvoyages {
+  // ── Atlas Ocean Voyages — the unit's own declarations, verbatim ──
+// Atlas Ocean Voyages' OWN shapes — not a capability contract.
+
+interface AtlasVoyageSummary {
+  code: string;              // the site's own itinerary code, e.g. "WVO260815"
+  slug: string;               // the key getVoyage takes
+  title: string;
+  destinations: string[];
+  ship: string;
+  durationNights: number;
+  departDate: string;         // "2026-08-15"
+  endDate: string;
+  startingPrice: number | null;       // null = call-for-fares, not a read failure
+  startingPriceFormatted: string | null;
+  detailUrl: string;
+}
+
+interface AtlasVoyageSearchResult { voyages: AtlasVoyageSummary[]; totalMatched: number }
+
+interface AtlasPortStop { name: string; code: string; arriving: string | null; departing: string | null; atSea: boolean }
+
+interface AtlasCabinPrice { code: string; name: string; totalPrice: number; totalPriceFormatted: string }
+
+interface AtlasVoyageDetail {
+  code: string;
+  slug: string;
+  title: string;
+  heroTitle: string | null;
+  summary: string | null;
+  ship: string;
+  durationNights: number;
+  departDate: string;
+  endDate: string;
+  ports: AtlasPortStop[];
+  cabinPrices: AtlasCabinPrice[];     // only the categories THIS sailing has live pricing for
+  startingPrice: number | null;
+  startingPriceFormatted: string | null;
+  bookingUrl: string;                 // bookings.atlasoceanvoyages.com — the real handoff
+  detailUrl: string;
+}
+
+  /**
+   * Luxury expedition cruise voyage search from Atlas Ocean Voyages — filter the site's own 180
+   * live itineraries by destination, ship, duration and departure date with real starting
+   * prices, then read one voyage's full port-by-port day itinerary, every cabin category the
+   * site has actually priced for that sailing, and the itinerary-code-keyed handoff URL into the
+   * real booking engine.
+   */
+  interface Unit {
+    /**
+     * Runs the /search voyage finder over all 180 currently-published itineraries, filtered by
+     * destination (substring, e.g. "Antarctica"), ship (substring, e.g. "World Voyager"), duration
+     * bounds, departure-date bounds and a free-text title match, sorted by departure date. Takes
+     * no argument for the full unfiltered list (capped at `limit`, default 20, max 50).
+     * `totalMatched` is the count BEFORE the cap, so a caller can tell "20 of 20" from "20 of 61".
+     * `startingPrice` is null on a genuine call-for-fares sailing, never omitted — filter on it
+     * explicitly rather than assuming presence.
+     */
+    searchVoyages(args?: { destination?: string; ship?: string; minDurationNights?: number; maxDurationNights?: number; departAfter?: string; departBefore?: string; query?: string; limit?: number }): Promise<AtlasVoyageSearchResult>;
+
+    /**
+     * Reads one voyage's full detail page: the port-by-port day-by-day schedule (arrival/departure
+     * times, or `atSea: true` for a scenic-cruising leg with no landing), every cabin category the
+     * site has ACTUALLY priced for this specific sailing — never the ship's full rate card, since
+     * a sailing sells out of most categories long before departure — and `bookingUrl`, the
+     * itinerary-code-keyed handoff into bookings.atlasoceanvoyages.com where a caller actually
+     * holds or pays for a cabin. `slug` comes from searchVoyages(). THROWS on an unknown slug,
+     * naming searchVoyages() as the way to find current ones.
+     */
+    getVoyage(slug: string): Promise<AtlasVoyageDetail>;
+  }
+}
+
 declare namespace BowmarkProvider_atlasseniorliving {
   // ── Atlas Senior Living — the unit's own declarations, verbatim ──
 type AtlasCareType = "assisted_living" | "independent_living" | "memory_care" | "respite_care";
@@ -2081,6 +2292,66 @@ interface BigrentzCategoryRow {
   }
 }
 
+declare namespace BowmarkProvider_bing {
+  // ── Bing — the unit's own declarations, verbatim ──
+interface BingWebResult {
+  source: "bing";
+  rank: number;
+  title: string;
+  url: string;
+  snippet: string | null;
+  published: string | null;
+}
+
+interface BingNewsResult {
+  source: "bing";
+  rank: number;
+  title: string;
+  url: string;
+  snippet: string | null;
+  published: string | null;
+  publisher: string | null;
+  imageUrl: string | null;
+}
+
+interface BingSearchResult {
+  query: string;
+  results: BingWebResult[];
+  warnings: string[];
+}
+
+interface BingNewsSearchResult {
+  query: string;
+  results: BingNewsResult[];
+  warnings: string[];
+}
+
+  /**
+   * General web and news search over Bing's index, read off Bing's own RSS output — ten ranked
+   * results per query with title, destination URL, snippet and date. Keyless, browserless, ~5 KB
+   * a call. It never reports 'no matches' and it ignores search operators like site: — both
+   * measured, both declared.
+   */
+  interface Unit {
+    /**
+     * Searches the web and returns the ten results Bing ranked first, with title, destination URL,
+     * snippet and date. TWO LIMITS, neither visible in the response: it NEVER returns an empty
+     * list — a query of three invented words came back with ten confident, unrelated rows — and it
+     * IGNORES search operators, so `site:reddit.com …` is not scoped to reddit. Treat the rows as
+     * Bing's best offer rather than as proof anything matched.
+     */
+    searchWeb(args: { query: string, limit?: number }): Promise<BingSearchResult>;
+
+    /**
+     * Searches news coverage and returns stories with the headline, the outlet's own article URL,
+     * a summary, a real publication timestamp, the publisher name and a thumbnail. Use this rather
+     * than searchWeb when the question is 'what happened' — the web feed's dates are Bing's crawl
+     * stamps, this feed's are the story's.
+     */
+    searchNews(args: { query: string, limit?: number }): Promise<BingNewsSearchResult>;
+  }
+}
+
 declare namespace BowmarkProvider_blenderseyewear {
   // ── Blenders Eyewear — the unit's own declarations, verbatim ──
 // Blenders Eyewear's OWN shapes — not a capability contract.
@@ -2460,6 +2731,89 @@ interface Boydsleep6ZoneResult {
   }
 }
 
+declare namespace BowmarkProvider_brixton {
+  // ── Brixton — the unit's own declarations, verbatim ──
+interface BrixtonVariant {
+  /** Shopify's numeric variant id as a string. */
+  id: string;
+  /** The variant's own label, e.g. "M" or "Black / M" on multi-option products. */
+  title: string;
+  /** String verbatim from the storefront — "30.00" (dollars) on /products.json, "10900" (cents) on /products/<h>.js. */
+  price: string;
+  /** Same scale as price. Null when the variant is not on sale. */
+  compareAtPrice: string | null;
+  /** The store's own SKU. Null on a variant without one. */
+  sku: string | null;
+  /** Whether the variant is purchasable right now. */
+  available: boolean;
+  /** e.g. ["M"] or ["Black", "M"]. */
+  options: string[];
+}
+interface BrixtonProduct {
+  /** The handle is the only stable identifier across the catalogue. */
+  handle: string;
+  title: string;
+  vendor: string;
+  productType: string;
+  url: string;
+  descriptionHtml: string | null;
+  optionNames: string[];
+  variants: BrixtonVariant[];
+  /** Same scale as variants — see BrixtonVariant.price. */
+  priceRange: { min: string; max: string } | null;
+  /** True if ANY variant is purchasable. */
+  inStock: boolean;
+  tags: string[];
+  /** Brixton's own images, in the order the storefront publishes them. */
+  images: string[];
+}
+interface BrixtonCatalogue {
+  /** All matching products, in-stock first, then by handle. */
+  products: BrixtonProduct[];
+  /** What the filter DROPPED, in the same register the rest of the library uses. */
+  warnings: string[];
+}
+interface BrixtonCheckoutLink {
+  /** Shopify's own cart-permalink URL — a GET that adds the line item and redirects into the cart. */
+  url: string;
+  /** The exact variant the link resolved to, read live off the storefront. */
+  variant: BrixtonVariant;
+  /** The product the variant belongs to. */
+  product: BrixtonProduct;
+}
+
+  /**
+   * Brixton apparel and headwear catalogue — every product, its size/color variants, real prices
+   * and stock — read off the live Shopify storefront, plus a live-validated checkout handoff
+   * link.
+   */
+  interface Unit {
+    /**
+     * Reads the live Brixton catalogue as the storefront publishes it — every product, its handle,
+     * title, vendor, description, tags, images and the per-variant price the storefront is quoting
+     * right now. Returns [] on a transport failure. The catalog page is the line and the parse is
+     * the unit of work.
+     */
+    listBrixtonProducts(opts?: { limit?: number }): Promise<BrixtonProduct[]>;
+
+    /**
+     * Reads one product by its handle — every size/color variant, its exact price and whether that
+     * specific variant is purchasable right now. Takes the handle listBrixtonProducts returns.
+     * THROWS on an unknown handle (the store answers a real 404).
+     */
+    getBrixtonProduct(handle: string): Promise<BrixtonProduct>;
+
+    /**
+     * Resolves a product handle + a variant match (either the exact variant title like "M", or a
+     * substring of it) to a real Shopify cart-permalink URL, validated live against the
+     * storefront. THROWS if the handle is unknown, if no variant matches, if the match is
+     * ambiguous (matches more than one variant), or if the matched variant is not currently
+     * available — the error names the candidate or in-stock options so the caller can retry.
+     */
+    getBrixtonCheckoutLink(handle: string, variantTitleOrOptions: string, opts?: { quantity?: number }): Promise<BrixtonCheckoutLink>;
+  }
+}
+
 declare namespace BowmarkProvider_bykoket {
   // ── KOKET — the unit's own declarations, verbatim ──
 interface KoketProductSummary {
@@ -2831,6 +3185,59 @@ interface carsVehicleValue {
   }
 }
 
+declare namespace BowmarkProvider_chantecaille {
+  // ── Chantecaille — the unit's own declarations, verbatim ──
+// Chantecaille's OWN shapes — not a capability contract.
+
+interface QuizQuestion {
+  id: string;
+  code: string;          // e.g. "undertone", "tone", "look", "benefits", "coverage"
+  name: string;           // e.g. "Undertone"
+  question: string;       // the site's own prompt text
+  answers: { id: string; code: string; name: string }[];
+}
+
+interface FoundationSelections {
+  undertone: string;      // e.g. "Cool" — code or name, from getFoundationQuizTaxonomy()
+  skinTone: string;       // e.g. "Medium Deep"
+  skinLook: string;       // e.g. "Smooth and flawless"
+  benefits: string[];     // e.g. ["Hydration"] — [] answers the site's own "Skip"
+  coverage: string;       // e.g. "Light" | "Medium" | "Full"
+}
+
+interface FoundationMatch {
+  name: string;            // e.g. "Future Skin - Maple"
+  score: number;           // the site's own computed match score
+  price: string;
+  displayPrice: string;    // e.g. "$95.00"
+  productUrl: string;      // real product page, this exact shade preselected
+  productImageUrl: string;
+  description: string;
+}
+
+  /**
+   * Chantecaille's own Foundation Shade Match Quiz, reimplemented over its real Cartful
+   * Solutions scoring engine: read the real live question taxonomy, and get real ranked
+   * foundation matches — name, price, product page — computed by the site's own engine for a
+   * stated undertone, skin tone, finish, skincare benefits and coverage.
+   */
+  interface Unit {
+    /**
+     * Reads Chantecaille's real, live Foundation Shade Match Quiz question and answer taxonomy off
+     * its own Cartful Solutions bundle — the real option names to pass to matchFoundation.
+     */
+    getFoundationQuizTaxonomy(): Promise<QuizQuestion[]>;
+
+    /**
+     * Chantecaille's own Foundation Shade Match Quiz, run for real: posts the caller's selections
+     * to the site's own scoring engine and returns the real ranked foundation matches, highest
+     * score first. THROWS naming the real options when a selection does not match the live
+     * taxonomy.
+     */
+    matchFoundation(selections: FoundationSelections): Promise<FoundationMatch[]>;
+  }
+}
+
 declare namespace BowmarkProvider_cheapflights {
   // ── Cheapflights — the unit's own declarations, verbatim ──
 interface KayakQuery {
@@ -3509,6 +3916,120 @@ interface CyberpowerpcPriceResult {
   }
 }
 
+declare namespace BowmarkProvider_davidsonhomes {
+  // ── Davidson Homes — the unit's own declarations, verbatim ──
+// Davidson Homes' OWN shapes — not a capability contract.
+
+interface DavidsonhomesRange { lowest: number | null; highest: number | null }
+
+interface DavidsonhomesRegionSummary {
+  id: string;
+  title: string;
+  path: string;               // the key getRegion takes
+  state: string;
+  homesCount: number;
+  communitiesCount: number;
+  priceRange: DavidsonhomesRange;
+}
+
+interface DavidsonhomesCommunitySummary {
+  id: string;
+  title: string;
+  path: string;               // the key getCommunity takes
+  city: string;
+  state: string;
+  status: string;             // e.g. "Move-In Ready Homes", "Now Selling"
+  bedRange: DavidsonhomesRange;
+  priceRange: DavidsonhomesRange;
+  sqftRange: DavidsonhomesRange;
+  homesCount: number;
+  plansCount: number;
+}
+
+interface DavidsonhomesRegionDetail {
+  title: string;
+  path: string;
+  state: string;               // this region's URL grouping, per the site's own nav
+  stateAbbreviation: string;
+  communities: DavidsonhomesCommunitySummary[];
+}
+
+interface DavidsonhomesHomeSummary {
+  id: string;
+  title: string;               // real street address, e.g. "28 Aurora Circle"
+  path: string;                // the key getHome takes
+  price: number;
+  oldPrice: number | null;
+  sqft: number;
+  beds: number;
+  baths: number;
+  halfBaths: number;
+  status: string;              // e.g. "Active", "Pending"
+  estCompletionMonth: string | null;
+  floorPlanName: string | null;
+}
+
+interface DavidsonhomesCommunityDetail {
+  title: string;
+  path: string;
+  status: string;
+  priceRange: DavidsonhomesRange;
+  sqftRange: DavidsonhomesRange;
+  phone: string | null;
+  plansCount: number;
+  availableHomes: DavidsonhomesHomeSummary[];
+}
+
+interface DavidsonhomesHomeDetail extends DavidsonhomesHomeSummary {
+  description: string | null;
+  garage: number | null;
+  coordinates: { lat: number; lng: number } | null;
+  communityTitle: string;
+  communityPath: string;       // the key getCommunity takes
+}
+
+  /**
+   * Reads Davidson Homes' own 'Find Your Home' search — all live market regions, one region's
+   * communities with real price/bed/sqft ranges and availability status, one community's actual
+   * move-in-ready homes with real street addresses and prices, and one home's full listing
+   * detail — the way the live site's own search would show it.
+   */
+  interface Unit {
+    /**
+     * Lists every market region Davidson Homes currently builds in (state/metro area), each with
+     * its own live homes count, communities count and starting price. The entry point: every
+     * region's `path` is what `getRegion` takes.
+     */
+    listRegions(): Promise<DavidsonhomesRegionSummary[]>;
+
+    /**
+     * Reads one region's own page: every community in it with a real live price/bed/sqft range and
+     * status ("Move-In Ready Homes", "Now Selling", etc). `path` comes from `listRegions()`, e.g.
+     * "states/alabama/huntsville-market-area". THROWS on an unknown path, naming `listRegions()`
+     * as the way to find current ones.
+     */
+    getRegion(path: string): Promise<DavidsonhomesRegionDetail>;
+
+    /**
+     * Reads one community's own page: its ACTUAL available homes right now, each with a real
+     * street address, real price, real sqft/bed/bath count and per-home status ("Active",
+     * "Pending") — never a floor-plan brochure. `path` comes from `getRegion()`, e.g.
+     * "states/alabama/huntsville-market-area/fayetteville/bailey-park". THROWS on an unknown path,
+     * naming `getRegion()` as the way to find current ones.
+     */
+    getCommunity(path: string): Promise<DavidsonhomesCommunityDetail>;
+
+    /**
+     * Reads one specific home's own listing page: address, price, sqft, bed/bath count, status,
+     * garage, coordinates and the site's own listing description. `path` comes from
+     * `getCommunity()` or `getRegion()`'s community list, e.g.
+     * "…/bailey-park/available-homes/28-aurora-circle". THROWS on an unknown path, naming
+     * `getCommunity()` as the way to find current ones.
+     */
+    getHome(path: string): Promise<DavidsonhomesHomeDetail>;
+  }
+}
+
 declare namespace BowmarkProvider_decked {
   // ── DECKED — the unit's own declarations, verbatim ──
 // DECKED's OWN shapes — not a capability contract.
@@ -4288,6 +4809,42 @@ interface EventSourceInquiryContact {
   }
 }
 
+declare namespace BowmarkProvider_evolutionofsmooth {
+  // ── eos Products — the unit's own declarations, verbatim ──
+interface ShadeQuizOption { optionId: string; text: string }
+interface ShadeQuizQuestion { questionPageId: string; questionId: string; title: string; options: ShadeQuizOption[] }
+interface ShadeResult {
+  shadeName: string; price: number; priceFormatted: string;
+  productUrl: string; productId: string; variantId: string; description: string;
+}
+type ShadeQuizAnswerResult =
+  | { done: false; question: ShadeQuizQuestion }
+  | { done: true; result: ShadeResult };
+
+  /**
+   * eos's Dewy Lip Shine Shade Finder quiz (Octane AI) — walks the site's real 5-question quiz
+   * and returns the personalized shade result: name, Shopify product/variant id, price and
+   * product URL, ready for a cart handoff.
+   */
+  interface Unit {
+    /**
+     * Starts eos's Dewy Lip Shine Shade Finder quiz (walking past the site's own unanswerable
+     * intro page automatically) and returns the first real question, with the `quizResponseId`
+     * every following `answerShadeQuizQuestion` call takes.
+     */
+    startShadeQuiz(): Promise<{ quizResponseId: string; question: ShadeQuizQuestion }>;
+
+    /**
+     * Submits one answer (the `questionPageId`/`questionId` from the question just answered, and
+     * the `optionId` of the chosen option) and returns either the next question, or — once all 5
+     * real questions are answered — `{ done: true, result }` with the personalized Dewy Lip Shine
+     * shade: name, Shopify product/variant id, price and product URL. The site's own email-capture
+     * page is skipped automatically.
+     */
+    answerShadeQuizQuestion(quizResponseId: string, questionPageId: string, questionId: string, optionId: string): Promise<ShadeQuizAnswerResult>;
+  }
+}
+
 declare namespace BowmarkProvider_extraspace {
   // ── Extra Space Storage — the unit's own declarations, verbatim ──
 interface ExtraspaceSearchResult {
@@ -4580,6 +5137,58 @@ interface FirstdibsListing {
   }
 }
 
+declare namespace BowmarkProvider_fivestarbathsolutions {
+  // ── Five Star Bath Solutions — the unit's own declarations, verbatim ──
+interface FivestarLocation {
+  id: string;
+  title: string;
+  ownerName: string;
+  phone: string;
+  address: string;
+  state: string;
+  latitude: number;
+  longitude: number;
+  url: string;
+}
+
+interface FivestarDaySlots {
+  date: string;
+  dayOfWeek: string;
+  times: string[];
+}
+
+interface GetAvailableSlotsResult {
+  region: string;
+  usingRegionSlots: boolean;
+  days: FivestarDaySlots[];
+}
+
+  /**
+   * National bath/kitchen remodeling franchise (walk-in tubs, shower/tub conversions).
+   * listLocations and getAvailableSlots are live — listLocations reads the site's own
+   * 176-territory location directory, getAvailableSlots checks a region's real free
+   * design-consultation scheduler and returns the actual open days/times. bookAppointment (the
+   * final booking submit) is a stub — see its notImplemented reason.
+   */
+  interface Unit {
+    /**
+     * Returns every Five Star Bath Solutions franchise territory from the site's own
+     * location-finder directory — geo slug (`id`, what `getAvailableSlots`' `region` argument
+     * takes), title, owner, phone, mailing address, state and lat/long. No arguments.
+     */
+    listLocations(): Promise<FivestarLocation[]>;
+
+    /**
+     * Checks one franchise region's real free design-consultation scheduler and returns the actual
+     * open appointment days and times over the site's own 3-week booking window. Pass `region`
+     * (the geo slug from `listLocations`' `id` field, e.g. "livonia-mi"). Returns whether the
+     * region has its own configured slot table (`usingRegionSlots`) or fell back to the site's
+     * Mon-Sat default, plus the day-by-day list of open times.
+     */
+    getAvailableSlots(args: object): Promise<GetAvailableSlotsResult>;
+  }
+}
+
 declare namespace BowmarkProvider_flightradar24 {
   // ── Flightradar24 — the unit's own declarations, verbatim ──
 interface flightradar24Airline {
@@ -4975,6 +5584,78 @@ interface fordVehicleRecalls {
   }
 }
 
+declare namespace BowmarkProvider_fourseasonsyachts {
+  // ── Four Seasons Yachts — the unit's own declarations, verbatim ──
+interface FourseasonsyachtsVoyage {
+  /** The site's own stable identifier for a sailing — what getVoyageSailing takes. */
+  voyageCode: string;
+  title: string;
+  /** The path segment on fourseasonsyachts.com/voyages/<slug>. */
+  slug: string;
+  /** The site's own free-text category label, e.g. "Grand Mediterranean". */
+  category: string;
+  /** The resolved destination entry's title, when the link resolved; falls back to category. */
+  destination: string;
+  vessel: string;
+  body: string;
+  images: string[];
+  url: string;
+}
+interface FourseasonsyachtsSuite {
+  description: string;
+  totalCabins: number;
+  availableCabins: number;
+  price: number;
+  currency: string;
+}
+interface FourseasonsyachtsSailing {
+  voyageCode: string;
+  sailDays: number;
+  fromPort: string;
+  fromDateTime: string;
+  toPort: string;
+  toDateTime: string;
+  ship: string;
+  suites: FourseasonsyachtsSuite[];
+}
+interface FourseasonsyachtsSearchResult {
+  voyages: FourseasonsyachtsVoyage[];
+  /** What the filter DROPPED, in the same register the rest of the library uses. */
+  warnings: string[];
+}
+
+  /**
+   * Four Seasons Yachts' live Voyage Finder — every published sailing, its region and vessel,
+   * plus the real scheduled departure with per-suite pricing and cabin availability, read off
+   * the site's own booking-engine endpoints.
+   */
+  interface Unit {
+    /**
+     * Reads the live Voyage Finder inventory (50 published itineraries) and filters locally by
+     * region, vessel and/or a free-text keyword against the title/body. Returns real voyageCodes
+     * and slugs — the entry point every other function takes its identifier from. The site
+     * publishes no query/filter endpoint of its own, so the divide is what this function does with
+     * the listing, not how it gets there.
+     */
+    searchVoyages(filters?: { region?: string; vessel?: string; keyword?: string }): Promise<FourseasonsyachtsSearchResult>;
+
+    /**
+     * Reads one voyage's itinerary — its day-by-day description, region, vessel and images — by
+     * voyageCode (server-side filtered, cheap) or by slug (matched locally against the full
+     * listing). THROWS when neither matches.
+     */
+    getVoyage(voyageCodeOrSlug: string): Promise<FourseasonsyachtsVoyage>;
+
+    /**
+     * Reads the REAL scheduled departure for one voyageCode — exact embark/disembark ports and
+     * dates, the ship, and every suite category's live price and cabin availability, straight off
+     * the site's own booking engine. Returns null when the site currently has no scheduled
+     * departure for that voyageCode (an honest empty answer, not a failure).
+     */
+    getVoyageSailing(voyageCode: string): Promise<FourseasonsyachtsSailing | null>;
+  }
+}
+
 declare namespace BowmarkProvider_framebridge {
   // ── Framebridge — the unit's own declarations, verbatim ──
 // Framebridge's OWN shapes — not a capability contract.
@@ -5902,6 +6583,43 @@ interface HandyproCategorySearch {
   }
 }
 
+declare namespace BowmarkProvider_hansons {
+  // ── Hansons — the unit's own declarations, verbatim ──
+interface HansonsSlot {
+  timeSlotID: number;
+  appointmentDate: string;
+  timeSlot: string;
+  virtual: boolean;
+}
+
+interface CheckAvailabilityResult {
+  inServiceArea: boolean;
+  showInHomeFlow: boolean;
+  showVirtualFlow: boolean;
+  message: string;
+  slots: HansonsSlot[];
+}
+
+  /**
+   * Regional home-exterior remodeler (windows/roofing/siding/gutters/bath). checkAvailability is
+   * live — checks a ZIP against Hansons' real Free Estimate scheduler and returns the actual
+   * bookable at-home/virtual slots. bookEstimate (the final booking submit) is a stub — see its
+   * notImplemented reason.
+   */
+  interface Unit {
+    /**
+     * Checks a 5-digit US ZIP (`zipcode`, e.g. "48104") against Hansons' real Free Estimate
+     * scheduler and returns the actual open appointment slots for an at-home or virtual
+     * consultation — the same ZIP-gated availability check the site's own scheduler performs
+     * before it will show a single bookable date. Pass `virtual: true`/`false` to filter to one
+     * consultation type; omit it to get both. Returns whether the ZIP is even in Hansons' service
+     * area, whether each consultation type is currently offered, the site's own status message,
+     * and the slot list (date, display time, and the site's own slot id).
+     */
+    checkAvailability(args: object): Promise<CheckAvailabilityResult>;
+  }
+}
+
 declare namespace BowmarkProvider_harmar {
   // ── Harmar Mobility — the unit's own declarations, verbatim ──
 interface HarmarVehicleModel {
@@ -6046,6 +6764,67 @@ interface HauslabsShadeMatch {
   }
 }
 
+declare namespace BowmarkProvider_haydenhomes {
+  // ── Hayden Homes — the unit's own declarations, verbatim ──
+// Hayden Homes' OWN shapes — not a capability contract.
+
+interface HaydenhomesQuickMoveIn {
+  id: number;
+  planName: string;
+  address: string;
+  city: string;
+  state: string;
+  communityName: string;
+  communityUrl: string;
+  price: number;
+  priceFormatted: string;
+  monthlyPayment: string | null;
+  beds: number | null;
+  baths: number | null;
+  sqft: number | null;
+  stories: number | null;
+  garage: string | null;
+  lot: string | null;
+  status: string;              // "available" | "reserved", the site's own value
+  availabilityLabel: string;   // e.g. "Move-in Now", "Move-in Fall"
+  availabilityDate: string | null;
+  incentive: string | null;
+  imageUrl: string | null;
+  url: string;                 // the listing page — the real next step (tour / contact) lives here
+  canScheduleAppointment: boolean;
+  latitude: number | null;
+  longitude: number | null;
+}
+
+interface HaydenhomesSearchFilters {
+  state?: string;       // two-letter code, e.g. "OR"
+  city?: string;        // fuzzy substring match
+  community?: string;   // fuzzy substring match
+  minBeds?: number;
+  minBaths?: number;
+  minSqft?: number;
+  minPrice?: number;
+  maxPrice?: number;
+  availableOnly?: boolean; // default true
+}
+
+  /**
+   * Hayden Homes' live quick move-in inventory search across Oregon, Washington, Idaho and
+   * Montana — filterable by state, city, community, beds/baths/sqft and price, off the search
+   * page's own server-rendered listing rather than a third-party aggregator's stale mirror.
+   */
+  interface Unit {
+    /**
+     * Runs Hayden Homes' quick move-in search against the site's own live inventory — every home
+     * currently listed across OR/WA/ID/MT, with real address, price, beds/baths/sqft, community
+     * and a listing URL to schedule a tour or contact a sales team. `filters` (all optional):
+     * `state` (e.g. "OR"), `city`, `community`, `minBeds`, `minBaths`, `minSqft`, `minPrice`,
+     * `maxPrice`, `availableOnly` (default true — excludes homes the site has marked reserved).
+     */
+    searchQuickMoveIns(filters?: HaydenhomesSearchFilters): Promise<HaydenhomesQuickMoveIn[]>;
+  }
+}
+
 declare namespace BowmarkProvider_healthcare_gov {
   // ── HealthCare.gov — the unit's own declarations, verbatim ──
 interface healthcare_govPlan {
@@ -7007,6 +7786,71 @@ interface HobieLocalAvailability {
   }
 }
 
+declare namespace BowmarkProvider_holidaybuilders {
+  // ── Holiday Builders — the unit's own declarations, verbatim ──
+// Holiday Builders' OWN shapes — not a capability contract.
+
+interface HolidaybuildersHome {
+  planName: string;
+  location: string;    // the community/city, e.g. "Palm Bay"
+  collection: string;  // e.g. "inspire", "value", "cornerstone"
+  address: string;
+  price: number;
+  priceFormatted: string;
+  sqft: number;
+  beds: number;
+  baths: number;
+  plan: string;
+  status: string;      // "Move-in Ready" | "Coming Soon", the site's own label
+  imageUrl: string | null;
+  url: string;          // the listing page — Request a Tour / Contact Us Today live here
+}
+
+interface HolidaybuildersHomeDetail extends Omit<HolidaybuildersHome, "url"> {
+  url: string;
+  description: string;
+  garage: number | null;
+  coordinates: { lat: number; lng: number } | null;
+  contactUsUrl: string | null;
+  requestTourUrl: string | null; // the WRITE handoff this provider never performs
+}
+
+interface HolidaybuildersSearchFilters {
+  location?: string;      // fuzzy substring match
+  collection?: string;    // exact, case-insensitive
+  minBeds?: number;
+  minBaths?: number;
+  minSqft?: number;
+  minPrice?: number;
+  maxPrice?: number;
+  moveInReadyOnly?: boolean; // default true
+}
+
+  /**
+   * Holiday Builders' live Available Homes inventory across every Florida community — filterable
+   * by location, collection, beds/baths/sqft and price, off the search page's own
+   * server-rendered listing rather than a third-party aggregator's stale mirror — plus one
+   * listing's own full detail and Request-a-Tour handoff.
+   */
+  interface Unit {
+    /**
+     * Runs Holiday Builders' site-wide Available Homes search — every home currently listed across
+     * all Florida communities, with real address, price, beds/baths/sqft, collection and status,
+     * and a listing URL to view details or request a tour. `filters` (all optional): `location`,
+     * `collection`, `minBeds`, `minBaths`, `minSqft`, `minPrice`, `maxPrice`, `moveInReadyOnly`
+     * (default true — excludes homes marked "Coming Soon").
+     */
+    searchAvailableHomes(filters?: HolidaybuildersSearchFilters): Promise<HolidaybuildersHome[]>;
+
+    /**
+     * Reads one home's own listing page — full specs, description, and whether the site's Contact
+     * Us Today / Request a Tour forms are present. `url` is a listing URL from a
+     * `searchAvailableHomes` result.
+     */
+    getHomeDetail(url: string): Promise<HolidaybuildersHomeDetail>;
+  }
+}
+
 declare namespace BowmarkProvider_hunter {
   // ── Hunter — the unit's own declarations, verbatim ──
 interface hunterDomainCandidate {
@@ -8415,6 +9259,75 @@ interface JoybirdPriceResult {
   }
 }
 
+declare namespace BowmarkProvider_joycefactorydirect {
+  // ── Joyce Windows, Sunrooms & Baths — the unit's own declarations, verbatim ──
+interface JoyceCalculatorOption {
+  label: string;
+  answerId: string;
+}
+interface JoyceCalculatorQuestion {
+  page: number;
+  componentId: string;
+  prompt: string;
+  kind: "select" | "quantity";
+  options: JoyceCalculatorOption[] | null;
+}
+interface JoyceWindowCalculatorOptions {
+  calculatorUrl: string;
+  questions: JoyceCalculatorQuestion[];
+}
+
+  /**
+   * Reads the live question/option set behind Joyce Windows' own window-cost calculator (an
+   * involve.me embed) with no browser and no interaction.
+   */
+  interface Unit {
+    /**
+     * Reads the live window-cost calculator's real questions and answer options (styles,
+     * quantities, grade, colors, glass, grids) straight off the page — no interaction needed.
+     */
+    getWindowCalculatorOptions(): Promise<JoyceWindowCalculatorOptions>;
+
+    /**
+     * Reads the live bath-remodel cost calculator's real questions and answer options straight off
+     * the page — no interaction needed. Same involve.me platform and return shape as
+     * getWindowCalculatorOptions.
+     */
+    getBathCalculatorOptions(): Promise<JoyceWindowCalculatorOptions>;
+  }
+}
+
+declare namespace BowmarkProvider_justinwine {
+  // ── JUSTIN Vineyards & Winery — the unit's own declarations, verbatim ──
+interface JustinwineClubPriceRange {
+  quantityLabel: string;
+  bottles: number;
+  min: number;
+  max: number;
+  checkoutUrl: string;
+}
+
+interface JustinwineClubTier {
+  category: string;
+  categorySlug: string;
+  description: string;
+  priceRanges: JustinwineClubPriceRange[];
+}
+
+  /**
+   * JUSTIN Vineyards & Winery's Wine Society club — per-shipment price by tier and quantity,
+   * with the exact join handoff URL, off the club page's own embedded data.
+   */
+  interface Unit {
+    /**
+     * Lists the JUSTIN Wine Society club tiers, each with its per-shipment price range at 4/6/12
+     * bottles and the exact join/checkout URL for that tier+quantity. Pass a category (e.g.
+     * "Isosceles Only") to filter to one tier.
+     */
+    listClubTiers(category?: string): Promise<JustinwineClubTier[]>;
+  }
+}
+
 declare namespace BowmarkProvider_kayak {
   // ── Kayak — the unit's own declarations, verbatim ──
 interface KayakQuery {
@@ -8558,6 +9471,39 @@ interface KayakCar {
   }
 }
 
+declare namespace BowmarkProvider_kingsdown {
+  // ── Kingsdown — the unit's own declarations, verbatim ──
+interface kingsdownBedmatchResult {
+  zoneName: "Gold" | "Green" | "Blue" | "Red";
+  zoneColor: string;
+  scalar: number;
+  findDealerUrl: string;
+  buyUrl: string;
+}
+
+  /**
+   * Kingsdown's own bedMATCH mattress-fit diagnostic (kingsdown.com/bedmatch/) —
+   * getBedMatchResult runs the real questionnaire and returns the live computed support-color
+   * classification (Gold/Green/Blue/Red) plus find-a-dealer and buy-direct handoff URLs.
+   */
+  interface Unit {
+    /**
+     * Runs Kingsdown's live bedMATCH diagnostic for one sleeper profile and returns the real
+     * computed support-color classification (`zoneName`: "Gold" | "Green" | "Blue" | "Red", with
+     * the raw fit `scalar` behind it), plus Kingsdown's own `findDealerUrl` and `buyUrl` handoffs.
+     * Pass `{ name, ageBand, gender, position, heightBand, weightBand, pantBand, shirtBand,
+     * painAreas? }` — every numeric field is the SITE'S OWN bucket code (its radio-button values),
+     * not a raw age/height/weight, because bedMATCH itself only ever rates a band. `ageBand` ∈
+     * {20, 33, 48, 63, 85}; `gender` ∈ {"F","M","N"}; `position` ∈ {1 Back, 2 Side, 3 Stomach};
+     * `heightBand` ∈ {50, 57.5, 63.5, 69, 75.5, 78}; `weightBand`/`pantBand`/`shirtBand` are small
+     * integer bucket codes (1-8 / 1-6 / 1-6). Read-only and account-free — the site's own quiz
+     * asks for nothing but this questionnaire, and this function submits nothing beyond it (no
+     * email, no purchase).
+     */
+    getBedMatchResult(profile: object): Promise<kingsdownBedmatchResult>;
+  }
+}
+
 declare namespace BowmarkProvider_kitchentuneup {
   // ── Kitchen Tune-Up — the unit's own declarations, verbatim ──
 interface KitchentuneupCabinetStyle {
@@ -8658,6 +9604,98 @@ interface KompanSparePartsDocuments {
   }
 }
 
+declare namespace BowmarkProvider_kuiu {
+  // ── KUIU — the unit's own declarations, verbatim ──
+interface KuiuVariant {
+  /** Shopify's numeric variant id as a string. */
+  id: string;
+  /** The variant's own label, e.g. "Vias / M". */
+  title: string;
+  /** String verbatim from the storefront — "129.00" (dollars) on /products.json, "12900" (cents) on /products/<handle>.js. */
+  price: string;
+  /** Same scale as price. Null when the variant is not on sale. */
+  compareAtPrice: string | null;
+  sku: string | null;
+  /** Whether the variant is purchasable right now. */
+  available: boolean;
+  /** e.g. ["Vias", "M"] — camo pattern/color + size. */
+  options: string[];
+}
+interface KuiuProduct {
+  /** The handle is the only stable identifier across the catalogue. */
+  handle: string;
+  title: string;
+  vendor: string;
+  productType: string;
+  url: string;
+  descriptionHtml: string | null;
+  optionNames: string[];
+  variants: KuiuVariant[];
+  priceRange: { min: string; max: string } | null;
+  /** True if ANY variant is purchasable. */
+  inStock: boolean;
+  tags: string[];
+  images: string[];
+}
+interface KuiuSizeMatch {
+  /** The chart size that matched both chest and waist, e.g. "M". Null on no match. */
+  size: string | null;
+  chestRange: string | null;
+  waistRange: string | null;
+  armLengthRange: string | null;
+  /** The size the CHEST measurement alone points to. */
+  chestMatch: string | null;
+  /** The size the WAIST measurement alone points to. */
+  waistMatch: string | null;
+  /** Populated when chest and waist disagree, or neither matched. */
+  warnings: string[];
+}
+interface KuiuCheckoutLink {
+  /** Shopify's own cart-permalink URL — a GET that adds the line item and redirects into the cart. */
+  url: string;
+  variant: KuiuVariant;
+  product: KuiuProduct;
+}
+
+  /**
+   * KUIU's live hunting-apparel catalogue — every product, its camo-pattern/color and size
+   * variants, real prices and stock — plus the storefront's own Find Your Fit men's size chart
+   * and a live-validated checkout handoff link.
+   */
+  interface Unit {
+    /**
+     * Reads the live KUIU catalogue as the storefront publishes it — every product, its handle,
+     * title, vendor, description, tags, images and the per-variant price/stock the storefront is
+     * quoting right now.
+     */
+    listKuiuProducts(opts?: { limit?: number }): Promise<KuiuProduct[]>;
+
+    /**
+     * Reads one product by its handle — every camo-pattern/color and size variant, its exact price
+     * and whether that specific variant is purchasable right now. Takes the handle
+     * listKuiuProducts returns. THROWS on an unknown handle (the store answers a real 404).
+     */
+    getKuiuProduct(handle: string): Promise<KuiuProduct>;
+
+    /**
+     * Maps chest and waist measurements (inches) to KUIU's own published men's apparel size,
+     * reading the storefront's live Find Your Fit chart. Returns the matched size plus each
+     * measurement's OWN match, so a caller can see when chest and waist point at different rows —
+     * a real case on a chart sized primarily by chest.
+     */
+    findKuiuSize(measurements: { chest: number; waist: number }): Promise<KuiuSizeMatch>;
+
+    /**
+     * Resolves a product handle + a variant match (either the exact variant title like "Vias / M",
+     * or a substring of it) to a real Shopify cart-permalink URL, validated live against the
+     * storefront. THROWS if the handle is unknown, if no variant matches, if the match is
+     * ambiguous, or if the matched variant is out of stock — the error names the candidates or
+     * in-stock options so the caller can retry.
+     */
+    getKuiuCheckoutLink(handle: string, variantTitleOrOptions: string, opts?: { quantity?: number }): Promise<KuiuCheckoutLink>;
+  }
+}
+
 declare namespace BowmarkProvider_labcorp {
   // ── Labcorp — the unit's own declarations, verbatim ──
 interface LabcorpTestSummary {
@@ -9141,6 +10179,76 @@ interface FindLocalDealerResult {
   }
 }
 
+declare namespace BowmarkProvider_lovelybride {
+  // ── Lovely Bride — the unit's own declarations, verbatim ──
+interface LovelybrideStore {
+  slug: string;   // e.g. "houston" — what the other two functions take
+  name: string;   // e.g. "Houston"
+  url: string;
+}
+interface LovelybrideAppointmentType {
+  id: number;               // e.g. 66220 — what getAvailableSlots takes
+  description: string;      // e.g. "1. Lovely Bridal Gown Appointment - $50 Fee"
+  durationMinutes: number;  // e.g. 90
+  priceUsd: number | null;
+  priceFormatted: string | null;  // e.g. "$50.00"
+  requiresPaymentInfo: boolean;
+}
+interface LovelybrideStoreInfo {
+  name: string;
+  emailAddress: string | null;
+  phoneNumber: string | null;
+  address: string | null;
+  schedulerUrl: string;  // the BridalLive scheduler page — the write handoff
+}
+interface LovelybrideTimeSlot {
+  startDateTime: string;    // ISO 8601
+  endDateTime: string;      // ISO 8601
+  startDateTimeForView: string;  // e.g. "10:00AM", store-local time
+  location: string | null;  // e.g. "Room 2"
+}
+interface LovelybrideAvailability {
+  storeSlug: string;
+  date: string;              // echoes the requested "YYYY-MM-DD"
+  slots: LovelybrideTimeSlot[];  // [] is a genuine "fully booked" answer
+}
+
+  /**
+   * Reads Lovely Bride's real per-store BridalLive appointment scheduler — every store, a
+   * store's real bookable appointment types and prices, and real open time slots — straight off
+   * lovelybride.com and app.bridallive.com's own private JSON API, no key, no browser.
+   */
+  interface Unit {
+    /**
+     * Lists every Lovely Bride store the site's own store locator links — 19 across the US and one
+     * in London, each with the slug the other two functions take. Takes nothing. The entry point:
+     * a caller asking 'where can I book' has nowhere else to start.
+     */
+    listStores(): Promise<LovelybrideStore[]>;
+
+    /**
+     * Reads one store's real, currently-bookable BridalLive appointment types — each with its real
+     * price and duration exactly as the store's own scheduler quotes it — plus the store's contact
+     * info and the live scheduler URL to hand off to. Takes the slug listStores returns. THROWS
+     * LovelybrideNoOnlineBooking (not caller-fixable — no slug fixes it) when the store's own page
+     * carries no online-booking link at all, which is a real answer for some stores (Charlotte,
+     * measured 2026-08-16), not a parse failure.
+     */
+    getStoreAppointmentTypes(storeSlug: string): Promise<{ store: LovelybrideStoreInfo; appointmentTypes: LovelybrideAppointmentType[] }>;
+
+    /**
+     * Reads the real open appointment slots for one store, one appointment type, and one date
+     * ("YYYY-MM-DD") — the exact slots a shopper would see on the store's own scheduler page.
+     * Takes the appointmentTypeId getStoreAppointmentTypes returns. Returns the requested date
+     * alongside the slots; an empty `slots` array is a genuine answer (the date is fully booked),
+     * never an error. This is a READ only: it does not hold or submit anything — a shopper follows
+     * the store's schedulerUrl (from getStoreAppointmentTypes) to actually book the slot this
+     * function found.
+     */
+    getAvailableSlots(storeSlug: string, appointmentTypeId: number, date: string): Promise<LovelybrideAvailability>;
+  }
+}
+
 declare namespace BowmarkProvider_lufthansa {
   // ── Lufthansa — the unit's own declarations, verbatim ──
 interface LufthansaFlightLeg {
@@ -9461,8 +10569,16 @@ interface LululemonRow {
 interface LululemonSearch {
   query: string;
   products: LululemonRow[];
-  /** How many entries matched before the row cap. */
+  /** How many entries matched IN TOTAL, before the row cap — the size of the
+   * thing you are paging through, not of this page. */
   matched: number;
+  /** Where in the ranked match list this page started. */
+  offset: number;
+  /** The offset that reads the NEXT page, or null at the end of the list. Pass
+   * it back verbatim — it is NOT offset + products.length, because a row that
+   * was reached for and lost is dropped from products and named in warnings, so
+   * a page of 24 can hand back 22 rows. */
+  nextOffset: number | null;
   warnings: string[];
 }
 interface LululemonSimilarProducts {
@@ -9483,10 +10599,16 @@ interface LululemonSimilarProducts {
      * first — id, title, URL, price range, how many colours the style comes in, and whether it is
      * in stock. Ranks over the site's own published product index, then reads the price and colour
      * count per row. A match the pricing catalogue does not carry still comes back, with `priced:
-     * false` and null prices; `matched` says how many matched before the row cap so a caller can
-     * raise `limit` (default 8, max 24).
+     * false` and null prices. PAGED: `matched` is the total match count and `nextOffset` is the
+     * offset that reads the next page, or null at the end — pass it back verbatim rather than
+     * adding `products.length`, since a lost row is dropped from `products` and named in
+     * `warnings`. `limit` is rows per page (default 8, max 24, and each row costs one third-party
+     * read), `offset` where the page starts (default 0). An offset past the end is an empty page,
+     * not an error. A category is just a query — the site's own URL segments (`womens-leggings`,
+     * `men-joggers`) are ranked over, so `{ query: "womens leggings", offset }` walks that
+     * category.
      */
-    search(query: { query: string; limit?: number }): Promise<LululemonSearch>;
+    search(query: { query: string; limit?: number; offset?: number }): Promise<LululemonSearch>;
 
     /**
      * Reads one product's full configurator the way its product page presents it — every colourway
@@ -9809,6 +10931,60 @@ interface mcdonaldsFindStoresResult {
   }
 }
 
+declare namespace BowmarkProvider_medicalguardian {
+  // ── Medical Guardian — the unit's own declarations, verbatim ──
+// Medical Guardian's OWN shapes — not a capability contract.
+
+type MedicalguardianActivityLevel = "Low" | "Medium" | "High";
+type MedicalguardianRiskLevel = "low" | "medium" | "high";
+
+interface MedicalguardianRiskQuestion {
+  id: string;
+  prompt: string;
+  options: Array<{ value: string; score: number }>;
+}
+
+interface MedicalguardianFallRiskAnswers {
+  hearingImpaired: boolean;
+  chronicHealthCondition: boolean;
+  limitedMobility: boolean;
+  activityLevel: MedicalguardianActivityLevel;
+  takesDailyMedications: boolean;
+  travelsAnnually: boolean;
+  homeHasStairs: boolean;
+  drivesDaily: boolean;
+  previouslyFallen: boolean;
+}
+
+interface MedicalguardianFallRiskResult {
+  score: number;          // 0-9
+  riskLevel: MedicalguardianRiskLevel;
+  assessmentUrl: string;
+  deviceSelectionUrl: string;  // the site's own next step — device selection, not built here
+}
+
+  /**
+   * Medical Guardian's own fall-risk assessment (medicalguardian.com/risk-assessment) — a real
+   * 0-9 score and low/medium/high risk level computed exactly as the site computes it, plus the
+   * site's own 'Choose a Device' handoff URL as the real next step.
+   */
+  interface Unit {
+    /**
+     * Returns Medical Guardian's own 9 fall-risk assessment questions, in order, exactly as
+     * medicalguardian.com/risk-assessment asks them — ask them one at a time, then call
+     * assessFallRisk with the answers.
+     */
+    getRiskAssessmentQuestions(): Promise<{ questions: MedicalguardianRiskQuestion[] }>;
+
+    /**
+     * Runs Medical Guardian's own fall-risk scoring — a real, personalized 0-9 score and risk
+     * level, computed exactly as the site's own calculator computes it, no estimate.
+     * `deviceSelectionUrl` is the real next step the site itself sends the user to.
+     */
+    assessFallRisk(answers: MedicalguardianFallRiskAnswers): Promise<MedicalguardianFallRiskResult>;
+  }
+}
+
 declare namespace BowmarkProvider_medicare {
   // ── Medicare.gov — the unit's own declarations, verbatim ──
 interface medicareCounty {
@@ -10983,6 +12159,89 @@ interface KayakCar {
   }
 }
 
+declare namespace BowmarkProvider_mossyoak {
+  // ── Mossy Oak — the unit's own declarations, verbatim ──
+interface MossyoakVariant {
+  /** Shopify's numeric variant id as a string. */
+  id: string;
+  /** The variant's own label, e.g. "Full Foliage / M/L". */
+  title: string;
+  /** String verbatim from the storefront — "149.99" (dollars) on /products.json, "14999" (cents) on /products/<h>.js. */
+  price: string;
+  /** Same scale as price. Null when the variant is not on sale. */
+  compareAtPrice: string | null;
+  /** The store's own SKU. Null on a variant without one. */
+  sku: string | null;
+  /** Whether the variant is purchasable right now. */
+  available: boolean;
+  /** e.g. ["Full Foliage", "M/L"] — camo pattern + combined size. */
+  options: string[];
+}
+interface MossyoakProduct {
+  /** The handle is the only stable identifier across the catalogue. */
+  handle: string;
+  title: string;
+  vendor: string;
+  productType: string;
+  url: string;
+  descriptionHtml: string | null;
+  optionNames: string[];
+  variants: MossyoakVariant[];
+  /** Same scale as variants — see MossyoakVariant.price. */
+  priceRange: { min: string; max: string } | null;
+  /** True if ANY variant is purchasable. */
+  inStock: boolean;
+  tags: string[];
+  /** Mossy Oak's own images, in the order the storefront publishes them. */
+  images: string[];
+}
+interface MossyoakCatalogue {
+  /** All matching products, in-stock first, then by handle. */
+  products: MossyoakProduct[];
+  /** What the filter DROPPED, in the same register the rest of the library uses. */
+  warnings: string[];
+}
+interface MossyoakCheckoutLink {
+  /** Shopify's own cart-permalink URL — a GET that adds the line item and redirects into the cart. */
+  url: string;
+  /** The exact variant the link resolved to, read live off the storefront. */
+  variant: MossyoakVariant;
+  /** The product the variant belongs to. */
+  product: MossyoakProduct;
+}
+
+  /**
+   * Mossy Oak camo-apparel and gear catalogue — every product, its camo-pattern and size
+   * variants, real prices and stock — read off the live Shopify storefront, plus a
+   * live-validated checkout handoff link.
+   */
+  interface Unit {
+    /**
+     * Reads the live Mossy Oak catalogue as the storefront publishes it — every product, its
+     * handle, title, vendor, description, tags, images and the per-variant price the storefront is
+     * quoting right now. Returns [] on a transport failure. The catalog page is the line and the
+     * parse is the unit of work.
+     */
+    listMossyoakProducts(opts?: { limit?: number }): Promise<MossyoakProduct[]>;
+
+    /**
+     * Reads one product by its handle — every camo-pattern/size variant, its exact price and
+     * whether that specific variant is purchasable right now. Takes the handle
+     * listMossyoakProducts returns. THROWS on an unknown handle (the store answers a real 404).
+     */
+    getMossyoakProduct(handle: string): Promise<MossyoakProduct>;
+
+    /**
+     * Resolves a product handle + a variant match (either the exact variant title like "Full
+     * Foliage / M/L", or a substring of it) to a real Shopify cart-permalink URL, validated live
+     * against the storefront. THROWS if the handle is unknown, if no variant matches, if the match
+     * is ambiguous (matches more than one variant), or if the matched variant is not currently
+     * available — the error names the candidate or in-stock options so the caller can retry.
+     */
+    getMossyoakCheckoutLink(handle: string, variantTitleOrOptions: string, opts?: { quantity?: number }): Promise<MossyoakCheckoutLink>;
+  }
+}
+
 declare namespace BowmarkProvider_naic {
   // ── NAIC — the unit's own declarations, verbatim ──
 interface naicCompanyQuery {
@@ -11451,6 +12710,56 @@ interface ottoSearchQuery {
   }
 }
 
+declare namespace BowmarkProvider_outdoorresearch {
+  // ── Outdoor Research — the unit's own declarations, verbatim ──
+interface OutdoorResearchWarrantyPolicy {
+  teamId: string;
+  teamName: string;               // "Outdoor Research"
+  excludedTags: string[];         // e.g. ["Non-OR","warehouse_sale","POS_only","Nikwax"]
+  thirdPartyPurchasesAccepted: boolean;
+  purchaseLocations: string[];    // e.g. ["www.outdoorresearch.com","Other"]
+  replacesFromFullCatalogWhenInStock: boolean;
+  replacesFromFullCatalogWhenOutOfStock: boolean;
+  receiptRequiredForThirdParty: boolean;
+  productPhotoRequiredForThirdParty: boolean;
+  supportEmail: string | null;
+  notFoundMessage: string | null;
+  expiredMessage: string | null;
+}
+interface OutdoorResearchClaimEligibility {
+  eligible: boolean;
+  status: "not_found" | "blocked" | "expired" | "eligible";
+  message: string;                // the site's own wording for this outcome
+  continueUrl: string | null;     // set only when eligible: true
+}
+
+  /**
+   * Reads Outdoor Research's Infinite Guarantee warranty program straight from the ReturnLogic
+   * claim portal's own API — the real program rules, and whether a given order/email can open a
+   * claim right now — no key, no browser.
+   */
+  interface Unit {
+    /**
+     * Reads Outdoor Research's Infinite Guarantee program config straight from the ReturnLogic
+     * claim portal — exclusion tags, in-stock/out-of-stock replacement scenarios, third-party
+     * purchase acceptance and its named purchase locations, receipt/photo requirements, and the
+     * site's own not-found/expired copy. Takes nothing. THROWS rather than returning a placeholder
+     * when the settings endpoint answers without teamId/teamName.
+     */
+    getWarrantyPolicy(): Promise<OutdoorResearchWarrantyPolicy>;
+
+    /**
+     * Starts an Infinite Guarantee claim by order number + email — the same lookup 'File a
+     * Warranty Claim' performs. Returns `eligible: false` with a `status` of
+     * not_found/blocked/expired and the site's own message when the pair does not qualify (a real,
+     * expected answer, not an error) — never throws for those. On `eligible: true`, `continueUrl`
+     * is where the customer would pick items and see per-item eligibility. THROWS only on a
+     * transport failure or an unrecognized response.
+     */
+    checkClaimEligibility(orderNumber: string, email: string): Promise<OutdoorResearchClaimEligibility>;
+  }
+}
+
 declare namespace BowmarkProvider_paypal {
   // ── PayPal — the unit's own declarations, verbatim ──
 interface PaypalEstimateFeeArgs {
@@ -12928,6 +14237,176 @@ interface RedditThread {
   }
 }
 
+declare namespace BowmarkProvider_reliancepartners {
+  // ── Reliance Partners — the unit's own declarations, verbatim ──
+interface ReliancePartnersApplicationSchema {
+  entryUrl: string;
+  steps: Array<{
+    title: string; // "Basic Info" | "Coverage" | "Equipment"
+    fields: Array<{ gfName: string; label: string; type: string; required: boolean; options?: Array<{ value: string; label: string }> }>;
+    repeaters: Array<{ title: string; gfRepeaterId: string; maxItems: number; columns: Array<{ gfName: string; label: string; type: string; required: boolean; options?: Array<{ value: string; label: string }> }> }>;
+  }>;
+}
+
+interface AssembledApplication {
+  valid: boolean;
+  errors: string[];
+  entryUrl: string;
+  formFields: Record<string, string>; // the site's own GF field names
+  summary: string;
+}
+
+  /**
+   * Reliance Partners' own 3-step commercial-trucking insurance application (FMCSA/EIN, per-line
+   * coverage limits, equipment) — reads the live field structure and enumerated catalogs, and
+   * validates + assembles a caller's application against it, ready to submit.
+   */
+  interface Unit {
+    /**
+     * Reads reliancepartners.com/quote/'s live 3-step trucking-insurance application — every
+     * field, and every real enumerated catalog (15 coverage lines, 30 commodities, FMCSA type, all
+     * US states).
+     */
+    getApplicationSchema(): Promise<ReliancePartnersApplicationSchema>;
+
+    /**
+     * Validates a caller's trucking-insurance application against the live schema's own field
+     * requirements and enumerated catalogs, then maps it onto the site's own Gravity Forms field
+     * names — exact, ready to submit. Never submits it; the site's own flow ends in a human
+     * underwriting follow-up, not an instant quote.
+     */
+    assembleApplication(args: object): Promise<AssembledApplication>;
+  }
+}
+
+declare namespace BowmarkProvider_revisionskincare {
+  // ── Revision Skincare — the unit's own declarations, verbatim ──
+type RevisionQuestionType = "single-select" | "multi-select";
+
+interface RevisionQuizOption {
+  title: string;
+}
+
+interface RevisionQuizQuestion {
+  questionId: string;
+  text: string;
+  type: RevisionQuestionType;
+  options: RevisionQuizOption[];
+}
+
+interface RevisionQuizQuestions {
+  quizId: string;
+  channelQuizId: string;
+  subscriberId: string;
+  questions: RevisionQuizQuestion[];
+}
+
+interface RevisionQuizAnswer {
+  questionId: string;
+  type: RevisionQuestionType;
+  answer: string | string[];
+}
+
+interface RevisionRecommendedProduct {
+  productId: string;
+  name: string;
+  description: string;
+  url: string;
+  imageUrl: string;
+  price: number | null;
+  currencyCode: string | null;
+  averageRating: number | null;
+  approvedReviewsCount: number | null;
+}
+
+interface RevisionQuizResult {
+  quizResponseId: string;
+  title: string;
+  subtitle: string;
+  products: RevisionRecommendedProduct[];
+}
+
+  /**
+   * Reads and answers Revision Skincare's own Product Finder Quiz
+   * (revisionskincare.com/pages/skincare-quiz), returning the site's real computed product
+   * recommendations.
+   */
+  interface Unit {
+    /**
+     * Reads the live Product Finder Quiz's real questions, in order, each with its options and
+     * answer type.
+     */
+    getSkincareQuizQuestions(): Promise<RevisionQuizQuestions>;
+
+    /**
+     * Submits a shopper's answers to the Product Finder Quiz and returns the site's real computed
+     * product recommendations.
+     */
+    takeSkincareQuiz(arg: { answers: RevisionQuizAnswer[] }): Promise<RevisionQuizResult>;
+  }
+}
+
+declare namespace BowmarkProvider_rishitea {
+  // ── Rishi Tea & Botanicals — the unit's own declarations, verbatim ──
+interface TeaFinderQuestion {
+  id: string;
+  profileQuestionId: string;
+  text: string;
+  selectionType: "single" | "multi";
+  options: string[];
+  minSelections?: number;
+  maxSelections?: number;
+}
+interface TeaFinderQuiz {
+  quizId: string;
+  channelQuizId: string;
+  questions: TeaFinderQuestion[];
+}
+interface TeaFinderAnswerInput {
+  questionId: string;       // a TeaFinderQuestion.id
+  answer: string | string[]; // string for selectionType "single", string[] for "multi"
+}
+interface TeaFinderProduct {
+  name: string;
+  url: string;
+  description: string;
+  imageUrl: string;
+  averageRating: number | null;
+  approvedReviewsCount: number;
+  price: number | null;
+  currencyCode: string | null;
+}
+interface TeaFinderResult {
+  quizResponseId: string;
+  title: string;
+  subtitle: string | null;
+  products: TeaFinderProduct[];
+  runnerUpProducts: TeaFinderProduct[];
+}
+
+  /**
+   * Rishi Tea's own "Tea Finder" quiz (Okendo Quizzes) — reads the real question set and submits
+   * real answers to get back the site's own personalized tea recommendation.
+   */
+  interface Unit {
+    /**
+     * Reads the live Tea Finder quiz's real question set straight from Okendo's quiz API — every
+     * question's text, whether it takes one answer or several, and its exact option strings. Call
+     * this first: `matchTeaFinderQuiz` needs the caller's answers keyed on each question's own
+     * `id`.
+     */
+    getTeaFinderQuiz(): Promise<TeaFinderQuiz>;
+
+    /**
+     * Submits a full set of answers (one per question `getTeaFinderQuiz` returned) to Okendo's
+     * quiz engine and returns the SAME personalized recommendation the live widget shows — a
+     * title/subtitle and the real recommended products (name, buy link, description, rating,
+     * price) pulled from Rishi's actual catalog, plus a runner-up list.
+     */
+    matchTeaFinderQuiz(quiz: TeaFinderQuiz, answers: TeaFinderAnswerInput[]): Promise<TeaFinderResult>;
+  }
+}
+
 declare namespace BowmarkProvider_ritani {
   // ── Ritani — the unit's own declarations, verbatim ──
 // Ritani's OWN shapes — not a capability contract.
@@ -13038,6 +14517,137 @@ interface RoofmaxxCostEstimate {
   }
 }
 
+declare namespace BowmarkProvider_saatva {
+  // ── Saatva — the unit's own declarations, verbatim ──
+// Saatva's OWN shapes — not a capability contract.
+
+interface MattressQuizAnswers {
+  sleepPosition: "side" | "back" | "stomach";
+  feel: "soft" | "medium" | "firm";
+  sharesBed?: boolean;   // optional — narrows scoring further when given
+}
+
+interface SaatvaVariant {
+  sku: string;
+  name: string;
+  size: string | null;
+  comfortLevel: string | null;   // Saatva's own label, e.g. "Medium Firm"
+  mattressType: string | null;   // "Standard" | "Split" | "Upper-Flex"
+  price: number | null;
+  inStock: boolean;
+  sleepPositions: string[];      // e.g. ["Side Sleeper", "Back Sleeper"]
+  url: string;                   // pre-selected-SKU product page, one click from cart
+}
+
+interface SaatvaMattress {
+  productCode: string;
+  name: string;
+  url: string;
+  variants: SaatvaVariant[];
+}
+
+interface SaatvaRecommendation {
+  productCode: string;
+  name: string;
+  score: number;                 // higher is a better match; ties break on lower price
+  matchedOn: string[];           // plain-language reasons this variant scored
+  bestVariant: SaatvaVariant | null;
+}
+
+  /**
+   * Saatva's mattress catalogue and its own mattress-quiz recommendation logic — every mattress
+   * line Saatva currently sells with every buyable variant's size, comfort level, sleep-position
+   * fit, stock and price, plus a real computed recommendation from stated sleep position,
+   * weight, and firmness preference, each with the exact pre-selected-SKU product link to buy
+   * it.
+   */
+  interface Unit {
+    /**
+     * Lists every mattress product line Saatva currently sells with every buyable variant — size,
+     * comfort level, sleep-position fit, stock and price — read out of the same catalogue the
+     * site's own mattress quiz scores against. Takes nothing. THROWS rather than returning [] when
+     * the page answers without its payload or names no mattress lines, because Saatva always sells
+     * these and an empty array would read as a catalogue that had emptied.
+     */
+    listMattresses(): Promise<SaatvaMattress[]>;
+
+    /**
+     * Runs Saatva's mattress-quiz goal-flow (saatva.com/mattress-quiz) for a stated sleep position
+     * and firmness preference, ranking every mattress line against the SAME live catalogue the
+     * site's own quiz reads and returning the best-matching in-stock variant for each, with its
+     * exact pre-selected-SKU buy link. Ranked highest score first, ties broken by lower price.
+     * `matchedOn` names which stated preferences the top variant actually satisfies. Does NOT
+     * replicate Saatva's internal weighted scoring formula byte-for-byte — that logic is
+     * proprietary client-side JS — it scores each variant's own declared attributes against what
+     * was asked, which is a genuine computation over real data rather than a guess from marketing
+     * copy.
+     */
+    recommendMattress(answers: MattressQuizAnswers): Promise<SaatvaRecommendation[]>;
+  }
+}
+
+declare namespace BowmarkProvider_saltandstone {
+  // ── Salt & Stone — the unit's own declarations, verbatim ──
+// Salt & Stone's OWN shapes — not a capability contract.
+
+interface ScentFamily {
+  handle: string;
+  name: string;             // e.g. "Santal & Vetiver"
+  description: string;      // the site's own mood copy
+  notes: { top: string[]; heart: string[]; base: string[] }; // real fragrance notes
+  url: string;
+}
+
+interface ScentMatch {
+  handle: string;
+  name: string;
+  score: number;            // 0-1 — how much of the caller's preference matched this family's real notes/copy
+  matchedTerms: string[];   // which of the caller's own words matched, and why
+  url: string;
+}
+
+interface ScentProduct {
+  handle: string;           // "body-wash" | "body-mist" | "body-lotion" | "natural-deodorant" | "hand-cream" | "candle"
+  title: string;
+  productType: string;
+  variantId: string;
+  variantTitle: string;
+  price: number;            // dollars, real Shopify variant price
+  compareAtPrice: number | null;
+  available: boolean;       // real live stock flag
+  url: string;              // real product page, this exact variant preselected
+}
+
+  /**
+   * Salt & Stone's own Scent Quiz, reimplemented over its real six named scent families: list
+   * every family's real fragrance notes, compute a real ranked match against a free-text
+   * preference, and shop the real core products (body wash, mist, lotion, deodorant, hand cream,
+   * candle) in the matched scent with real price and availability.
+   */
+  interface Unit {
+    /**
+     * Lists Salt & Stone's real six named scent families, each with its own real top/heart/base
+     * fragrance notes and mood description, read off the site's own collection pages.
+     */
+    listScentFamilies(): Promise<ScentFamily[]>;
+
+    /**
+     * Salt & Stone's own Scent Quiz, reimplemented: computes a real ranked match across all six
+     * scent families by scoring the preference's terms against each family's own published
+     * fragrance notes and description.
+     */
+    matchScent(preferences: string): Promise<ScentMatch[]>;
+
+    /**
+     * Lists the real core products (body wash, body mist, body lotion, deodorant, hand cream,
+     * candle) available in one named scent family, with each one's real price, availability and
+     * product page. THROWS on an unknown family name, naming listScentFamilies() as the way to
+     * find current ones.
+     */
+    getScentProducts(familyName: string): Promise<ScentProduct[]>;
+  }
+}
+
 declare namespace BowmarkProvider_samsclub {
   // ── Sam's Club — the unit's own declarations, verbatim ──
 interface SamsclubInstantSavingsItem {
@@ -13230,6 +14840,50 @@ interface SamsclubMembershipPlan {
   }
 }
 
+declare namespace BowmarkProvider_seakeeper {
+  // ── Seakeeper — the unit's own declarations, verbatim ──
+interface SeakeeperDealer {
+  name: string;
+  address: string;
+  contactName: string;
+  phone: string;
+  email: string;
+  website: string;
+  latitude: number;
+  longitude: number;
+  tier: string;
+  tierLabel: string;
+}
+interface SeakeeperNearbyDealer extends SeakeeperDealer {
+  distanceMiles: number;
+}
+interface SeakeeperNearestDealersResult {
+  zip: string;
+  dealers: SeakeeperNearbyDealer[];
+}
+
+  /**
+   * Reads Seakeeper's own real-time Dealer / Elite Dealer Locator directly (the same admin-ajax
+   * endpoint the site's map runs) — every real gyro-stabilizer dealer worldwide, or the nearest
+   * ones to a US zip ranked by distance with each dealer's real tier (Elite Dealer / Dealer /
+   * Master Technician).
+   */
+  interface Unit {
+    /**
+     * Every real Seakeeper dealer worldwide (name, address, contact, coordinates, tier), read
+     * straight from the locator's own live data endpoint.
+     */
+    listAllDealers(): Promise<SeakeeperDealer[]>;
+
+    /**
+     * Ranks every real Seakeeper dealer by distance from a US zip and returns the nearest `limit`
+     * (default 20, matching the site's own displayed count), each with its real tier and how far
+     * it is.
+     */
+    findNearestDealers(zip: string, limit?: number): Promise<SeakeeperNearestDealersResult>;
+  }
+}
+
 declare namespace BowmarkProvider_sears {
   // ── Sears — the unit's own declarations, verbatim ──
 interface SearsSearchPrice {
@@ -13562,6 +15216,52 @@ interface SemihandmadePriceResult {
   }
 }
 
+declare namespace BowmarkProvider_smartsign {
+  // ── SmartSign — the unit's own declarations, verbatim ──
+interface SmartsignSearchResult {
+  sku: string;
+  name: string;
+  url: string;       // absolute product page URL — what getTemplate takes
+  imageUrl: string;
+}
+interface SmartsignMaterialPricing {
+  name: string;               // e.g. "Aluminum"
+  sizeCode: string;           // SmartSign's own per-material+size code
+  unitPrice: number;          // single-unit price, e.g. 37.94
+  pricingTiers: { qty: number; price: number }[]; // volume-discount ladder, includes qty:1
+}
+interface SmartsignTemplate {
+  sku: string;
+  title: string;
+  url: string;
+  materials: SmartsignMaterialPricing[];
+}
+
+  /**
+   * Reads SmartSign's custom-sign template configurator — search for a template, then read its
+   * real per-material live pricing and volume-discount ladder — straight from smartsign.com's
+   * own pages, no key, no browser.
+   */
+  interface Unit {
+    /**
+     * Runs SmartSign's own site-search suggest endpoint for a free-text query (e.g. "parking
+     * sign", "custom aluminum sign") and returns the matching product/template rows — sku, name,
+     * product URL, thumbnail — deduplicated by URL. The `sku` it returns is what getTemplate
+     * takes. May legitimately return [] for a query that matches nothing.
+     */
+    search(query: string): Promise<SmartsignSearchResult[]>;
+
+    /**
+     * Reads one custom-sign template's product page and returns its title plus every material
+     * option offered — display name, the site's own size+material code, single-unit price, and the
+     * FULL volume-discount ladder (qty tier -> price). THROWS rather than returning an empty
+     * materials list on a retired/mistyped SKU — every real template offers at least one material,
+     * so zero is never an honest answer.
+     */
+    getTemplate(sku: string): Promise<SmartsignTemplate>;
+  }
+}
+
 declare namespace BowmarkProvider_soundcloud {
   // ── SoundCloud — the unit's own declarations, verbatim ──
 // SoundCloud's OWN row shape — not the `music` capability contract.
@@ -14328,6 +16028,69 @@ interface teladocInsuranceCoverage {
   }
 }
 
+declare namespace BowmarkProvider_teneohg {
+  // ── Teneo Hospitality Group — the unit's own declarations, verbatim ──
+// Teneo's OWN shapes — not a capability contract.
+
+interface TeneohgHotelSummary {
+  slug: string;
+  name: string;
+  city: string | null;
+  region: string | null;              // US state code, e.g. "AZ", or a country name
+  profileUrl: string;
+  totalMeetingSpaceSqFt: number | null;
+  largestMeetingSpaceSqFt: number | null;
+  sleepingRooms: number | null;
+  collections: string[];              // e.g. ["Luxury", "Resorts"]
+}
+
+interface TeneohgSearchResult { hotels: TeneohgHotelSummary[]; totalMatched: number; totalScanned: number; pagesScanned: number }
+
+type TeneohgHotelStats = Record<string, string>;  // e.g. { "Meeting Room Space": "156,000 Sq. Ft.", "Number of Sleeping Rooms": "517" }
+
+interface TeneohgRfpHandoff { url: string; hotelsOfInterestValue: string }
+
+interface TeneohgHotelDetail {
+  slug: string;
+  name: string;
+  city: string | null;
+  region: string | null;
+  profileUrl: string;
+  stats: TeneohgHotelStats;
+  rfpHandoff: TeneohgRfpHandoff;      // the public RFP form + what to type into its "Hotels of Interest" field
+}
+
+  /**
+   * Teneo Hospitality Group's own member-hotel directory — search 350+ independent and
+   * small-branded meeting hotels by destination, collection and meeting-space/room-block size
+   * with real specs, then read one hotel's full meeting-space stat block and the RFP hand-off to
+   * actually request a proposal.
+   */
+  interface Unit {
+    /**
+     * Searches Teneo's own member-hotel directory (350+ hotels) by US state (2-letter code, e.g.
+     * "AZ"), country, collection tag substring (e.g. "luxury", "resorts"), minimum total
+     * meeting-space square footage, minimum sleeping-room count and a name/city substring. Uses
+     * one of the site's own curated per-state directory pages when the requested state has one
+     * (faster, pre-filtered), otherwise scans the base listing's pages (bounded by
+     * `maxPagesToScan`, default 8) and filters client-side. `totalMatched` is the count before
+     * `limit` (default 20, max 50) cuts the list; `totalScanned`/`pagesScanned` say how much of
+     * the directory the call actually covered.
+     */
+    searchMemberHotels(args?: { state?: string; country?: string; collection?: string; minMeetingSpaceSqFt?: number; minSleepingRooms?: number; query?: string; limit?: number; maxPagesToScan?: number }): Promise<TeneohgSearchResult>;
+
+    /**
+     * Reads one member hotel's own profile page: every stat its meeting-space and sleeping-room
+     * widgets carry (total/largest/second-largest meeting room space, outdoor space, meeting-room
+     * count, suites, doubles), keyed on the site's own label text, plus `rfpHandoff` — the public
+     * RFP form URL and the exact value to put in its "Hotels of Interest" field to route a request
+     * at this hotel. `slug` comes from searchMemberHotels(). THROWS on an unknown slug, naming
+     * searchMemberHotels() as the way to find current ones.
+     */
+    getMemberHotel(slug: string): Promise<TeneohgHotelDetail>;
+  }
+}
+
 declare namespace BowmarkProvider_therabody {
   // ── Therabody — the unit's own declarations, verbatim ──
 interface TherabodyVariant {
@@ -14913,6 +16676,108 @@ interface thezebraAutoQuotes {
   }
 }
 
+declare namespace BowmarkProvider_tilsonhomes {
+  // ── Tilson Homes — the unit's own declarations, verbatim ──
+interface TilsonhomesPlan {
+  id: number;
+  name: string;
+  displayName: string | null;
+  bed: number | null;
+  bath: number | null;
+  size: number | null;
+  cost: number | null;
+  defaultElevationId: number | null;
+}
+
+interface TilsonhomesElevationDetails {
+  id: number;
+  planName: string | null;
+  caption: string | null;
+  thumb: string | null;
+  bed: number | null;
+  bedMin: number | null;
+  bedMax: number | null;
+  bath: number | null;
+  bathMin: number | null;
+  bathMax: number | null;
+  size: number | null;
+  sizeMin: number | null;
+  sizeMax: number | null;
+  cost: number | null;
+  costMin: number | null;
+  costMax: number | null;
+  description: string | null;
+  finishes: TilsonhomesFinishOption[];
+}
+
+interface TilsonhomesFinishOption {
+  category: string | null;
+  name: string | null;
+  displayName: string | null;
+  swatches: { id: number; name: string | null }[];
+}
+
+  /**
+   * Reads Tilson Homes' Build-On-Your-Land floor plan catalog and each plan's Anewgo-powered
+   * customizer — bed/bath/size range and exterior finish options — the way the live site's
+   * interactive floorplan tool would show them.
+   */
+  interface Unit {
+    /**
+     * Lists Tilson Homes' Build-On-Your-Land floor plans — model name, bed/bath/size and the
+     * default elevation id `getElevationDetails` reads. The entry point: every plan links to a
+     * customizer instance.
+     */
+    listPlans(activeOnly?: boolean): Promise<TilsonhomesPlan[]>;
+
+    /**
+     * Reads one plan's elevation — the exterior style's customization range (how far bed/bath/size
+     * can be pushed by the site's own add-a-room options) and its exterior finish categories
+     * (roof, trim, body, accent) with the swatch currently assigned to each. The read behind 'add
+     * a covered porch and a 4th bedroom, show me the finishes'.
+     */
+    getElevationDetails(elevationId: number | string): Promise<TilsonhomesElevationDetails>;
+  }
+}
+
+declare namespace BowmarkProvider_titlenine {
+  // ── Title Nine — the unit's own declarations, verbatim ──
+// Title Nine's OWN shapes — not a capability contract.
+
+interface TitlenineBraMeasurements {
+  chestInches: number;      // site's calculatable range: 30-46
+  bustInches: number;
+  belowBustInches: number;  // site requires >= 24
+}
+
+interface TitlenineBraSizeResult {
+  bandSize: number;
+  cupCode: string;             // the site's own raw catalog query param, e.g. "DD%2B"
+  cupLabel: string;            // the label shown to the customer, e.g. "M (11D)"
+  sizeLabel: string;           // "<bandSize><cupLabel>", e.g. "40M (11D)"
+  inStock: boolean;            // false for the extended range (n2 >= 9)
+  shopUrl: string | null;      // pre-filtered catalog link, only when inStock
+  unavailableMessage: string | null;
+  calculatorUrl: string;
+}
+
+  /**
+   * Title Nine's own bra-size calculator — real band + cup math off three measurements, computed
+   * exactly as the site computes it, including the extended cup range (up to "M (11D)") that
+   * generic AI knowledge gets wrong — plus the exact 'Shop <size>' catalog link when the size is
+   * in stock.
+   */
+  interface Unit {
+    /**
+     * Runs Title Nine's own bra-size calculator — chest/bust/under-bust in, a real band + cup size
+     * out computed exactly as the site computes it, including Title Nine's own extended cup
+     * labeling past DDD (up to "M (11D)") that generic AI knowledge gets wrong. Returns the exact
+     * 'Shop <size>' catalog link when the size is currently carried online.
+     */
+    calculateBraSize(input: TitlenineBraMeasurements): Promise<TitlenineBraSizeResult>;
+  }
+}
+
 declare namespace BowmarkProvider_topviewtix {
   // ── TopView Sightseeing — the unit's own declarations, verbatim ──
 interface topviewtixPackageDetails {
@@ -15594,6 +17459,74 @@ interface VoluspaQuizIntro {
   }
 }
 
+declare namespace BowmarkProvider_walkerhughes {
+  // ── WalkerHughes Insurance — the unit's own declarations, verbatim ──
+// WalkerHughes' OWN shapes — not a capability contract.
+
+interface WalkerhughesProduct {
+  id: string;         // the exact `product` value /start-quote expects
+  name: string;
+  personal: boolean;  // Personal vs Business, from the site's own toggle
+}
+
+interface WalkerhughesQuoteCatalog {
+  products: WalkerhughesProduct[];
+  applyUrl: string;   // the real /start-quote URL — no query prefill exists
+  sourceUrl: string;
+}
+
+interface WalkerhughesOffice {
+  label: string;       // exact `preferredOffice` value /start-quote expects
+  city: string;
+  state: string;
+  address: string | null;
+  phone: string | null;
+  url: string;         // this office's own detail page
+}
+
+interface WalkerhughesOfficeDirectory {
+  offices: WalkerhughesOffice[];
+  sourceUrl: string;
+}
+
+interface WalkerhughesOfficeMatch extends WalkerhughesOffice {
+  matchedOn: "label" | "city" | "state";
+}
+
+interface WalkerhughesOfficeSearch {
+  query: string;
+  matches: WalkerhughesOfficeMatch[];
+  sourceUrl: string;
+}
+
+  /**
+   * WalkerHughes' real 16-product Personal/Business insurance-quote application catalog and its
+   * real 25-office directory, straight off /start-quote and /locations — list and filter the
+   * product catalog, list and filter offices, and match a caller's free-text location against
+   * the real office directory.
+   */
+  interface Unit {
+    /**
+     * Lists WalkerHughes' real 16-product insurance catalog straight off the /start-quote form's
+     * own <select>, optionally filtered to just Personal or just Business — the same toggle the
+     * live form applies. Includes the real applyUrl handoff.
+     */
+    listQuoteProducts(department?: "Personal" | "Business"): Promise<WalkerhughesQuoteCatalog>;
+
+    /**
+     * Lists WalkerHughes' real 25-office directory straight off /locations' own server-rendered
+     * cards, optionally filtered to one two-letter state.
+     */
+    listOffices(state?: string): Promise<WalkerhughesOfficeDirectory>;
+
+    /**
+     * Matches a free-text location (a city, a two-letter state, or "City, ST") against the real
+     * office directory and returns every match, ranked exact-label > city > state.
+     */
+    findNearestOffice(query: string): Promise<WalkerhughesOfficeSearch>;
+  }
+}
+
 declare namespace BowmarkProvider_walmart {
   // ── Walmart — the unit's own declarations, verbatim ──
 interface walmartStore {
@@ -15661,6 +17594,64 @@ interface walmartSearchResult {
   }
 }
 
+declare namespace BowmarkProvider_waterfurnace {
+  // ── WaterFurnace — the unit's own declarations, verbatim ──
+type WaterfurnaceFuelSource = "gas" | "propane" | "heatpump" | "resistance" | "oil";
+type WaterfurnaceSecondaryFuelSource = "gas" | "propane" | "resistance" | "oil" | "none";
+interface WaterfurnaceHomeDetails {
+  address: string;
+  postalCode: string;
+  homeAgeYears: number;
+  livingSqft: number;
+  basementSqft: number;
+  lotAcreage: number;
+}
+interface WaterfurnaceRecommendedSystem {
+  tier: "good" | "better" | "best";
+  title: string;
+  description: string;
+  highlights: string[];
+}
+interface WaterfurnaceSavingsEstimate {
+  zipCode: string;
+  lat: number;
+  lng: number;
+  currentAnnualCostUsd: number;
+  geothermalAnnualCostUsd: number;
+  annualSavingsUsd: number;
+  savingsBreakdownUsd: { heating: number; cooling: number; hotWater: number };
+  carbonFootprintLbsPerYear: { current: number; geothermal: number; reduction: number };
+  fuelRates: { gas: number; electric: number; oil: number; propane: number };
+  recommendedSystems: WaterfurnaceRecommendedSystem[];
+  warnings: string[];
+}
+
+  /**
+   * WaterFurnace's Savings Calculator, run for real — the site's own computed Free Savings
+   * Report (annual dollar savings, energy comparison, carbon footprint, recommended geothermal
+   * systems) for a real address and fuel source, off its undocumented backend API.
+   */
+  interface Unit {
+    /**
+     * Runs the Savings Calculator's own home-details lookup for an address/zip. Returns the site's
+     * real public-data estimate of home age, living sqft and basement sqft — a fixed fallback
+     * estimate (not an error) when the address isn't in its data source, matching what the
+     * wizard's own UI does.
+     */
+    lookupHomeDetails(input: { address: string; city?: string; state?: string; zipCode: string }): Promise<WaterfurnaceHomeDetails>;
+
+    /**
+     * Runs the Savings Calculator's real backend computation for a home and current fuel source
+     * (gas/propane/electric heat pump/electric resistance/oil) and returns the site's own computed
+     * Free Savings Report: current vs. geothermal annual cost, dollar savings, carbon footprint
+     * reduction, and WaterFurnace's recommended systems. Missing home details are filled from
+     * lookupHomeDetails; a missing lat/lng is resolved from the zip via a keyless geocode. THROWS
+     * if the API's response shape has changed.
+     */
+    estimateGeothermalSavings(input: { zipCode: string; state: string; address?: string; city?: string; fuelSource: WaterfurnaceFuelSource; secondaryFuelSource?: WaterfurnaceSecondaryFuelSource; homeAgeYears?: number; livingSqft?: number; basementSqft?: number; numResidents?: number; winterSetpointF?: number; summerSetpointF?: number; lat?: number; lng?: number }): Promise<WaterfurnaceSavingsEstimate>;
+  }
+}
+
 declare namespace BowmarkProvider_wellfound {
   // ── Wellfound — the unit's own declarations, verbatim ──
 interface wellfoundRow {
@@ -15819,6 +17810,62 @@ interface XpressWaitTime {
   }
 }
 
+declare namespace BowmarkProvider_yorkwallcoverings {
+  // ── York Wallcoverings — the unit's own declarations, verbatim ──
+interface YorkWallcoveringsSearchResult {
+  sku: string;
+  name: string;
+  url: string;
+  price: number;
+}
+
+interface YorkWallcoveringsProduct {
+  sku: string;
+  name: string;
+  url: string;
+  price: number;
+  inStock: boolean;
+  description: string;
+  images: string[];
+}
+
+interface YorkWallcoveringsAddToCartHandoff {
+  sku: string;
+  name: string;
+  url: string;
+  price: number;
+  inStock: boolean;
+  note: string;
+}
+
+  /**
+   * Reads York Wallcoverings' public wallpaper/mural storefront (yorkwallcoverings.com) — search
+   * the catalog by keyword, read a product's live price and stock, and get the handoff to add it
+   * to cart on the real site.
+   */
+  interface Unit {
+    /**
+     * Searches York's live public catalog (wallpaper, wall murals, grasscloth) by keyword — theme,
+     * style, color or brand words all match, since the site's own search covers name and
+     * description — and returns each match's SKU, name, product URL and price.
+     */
+    search(query: string): Promise<YorkWallcoveringsSearchResult[]>;
+
+    /**
+     * Reads one York product page in full — SKU, live price, in-stock/out-of-stock status,
+     * description and images — for a product URL `search` already returned.
+     */
+    getProduct(url: string): Promise<YorkWallcoveringsProduct>;
+
+    /**
+     * Hands back the shopper's own York product page — the exact Add to cart button for this SKU —
+     * since the site's cart requires a per-session ASP.NET token nobody but the shopper can
+     * supply. Writes nothing.
+     */
+    addToCart(url: string): Promise<YorkWallcoveringsAddToCartHandoff>;
+  }
+}
+
 declare namespace BowmarkProvider_yourarborhome {
   // ── Arbor Homes — the unit's own declarations, verbatim ──
 interface ArborHome {
@@ -15870,6 +17917,57 @@ interface SearchHomesFilters {
   }
 }
 
+declare namespace BowmarkProvider_zennioptical {
+  // ── Zenni Optical — the unit's own declarations, verbatim ──
+interface ZenniFrame {
+  sku: string;
+  name: string;
+  price: number;
+  colors: Array<{ sku: string; price: number }>;
+}
+interface ZenniStock {
+  skuId: string;
+  inStock: boolean;
+  quantity: number;
+  backOrderable: boolean;
+  preOrderable: boolean;
+}
+interface ZenniRx {
+  odSph: number;
+  osSph: number;
+  pd: number;
+  birthYear: number;
+}
+interface ZenniLensPriceRow {
+  type: string;
+  minPrice: number;
+  maxPrice: number;
+  subTypes: Array<{ type: string; usage: string; minPrice: number; maxPrice: number; tints: boolean }>;
+}
+
+  /**
+   * Online prescription eyewear. Prices a real frame + Rx + lens-type configuration off the
+   * site's own configurator, and checks live per-SKU stock.
+   */
+  interface Unit {
+    /**
+     * Reads one frame's name, base price and per-color-variant price straight off the product
+     * page's own embedded data. No rendering.
+     */
+    getFrame(skuId: string): Promise<ZenniFrame>;
+
+    /** Checks live per-SKU inventory off Zenni's own inventory endpoint. */
+    checkStock(skuId: string): Promise<ZenniStock>;
+
+    /**
+     * Runs a real prescription through Zenni's own order-configurator wizard (usage type -> manual
+     * Rx entry -> confirm) and returns the priced lens-type matrix the site computes for that
+     * exact Rx — a completed, priced configuration rather than a base frame price.
+     */
+    priceLensConfig(skuId: string, rx: ZenniRx): Promise<ZenniLensPriceRow[]>;
+  }
+}
+
 declare namespace BowmarkFamily_shopify_store {
   // ── Shopify storefronts — the unit's own declarations, verbatim ──
 interface ShopifyVariant {
@@ -16692,26 +18790,32 @@ interface BowmarkProviders {
   aiper: BowmarkProvider_aiper.Unit;
   ajmadison: BowmarkProvider_ajmadison.Unit;
   ashleyfurniture: BowmarkProvider_ashleyfurniture.Unit;
+  asppoolco: BowmarkProvider_asppoolco.Unit;
+  atlasoceanvoyages: BowmarkProvider_atlasoceanvoyages.Unit;
   atlasseniorliving: BowmarkProvider_atlasseniorliving.Unit;
   avis: BowmarkProvider_avis.Unit;
   azure: BowmarkProvider_azure.Unit;
   barletta: BowmarkProvider_barletta.Unit;
   bhphoto: BowmarkProvider_bhphoto.Unit;
   bigrentz: BowmarkProvider_bigrentz.Unit;
+  bing: BowmarkProvider_bing.Unit;
   blenderseyewear: BowmarkProvider_blenderseyewear.Unit;
   bluehaven: BowmarkProvider_bluehaven.Unit;
   bmwusa: BowmarkProvider_bmwusa.Unit;
   boydsleep: BowmarkProvider_boydsleep.Unit;
+  brixton: BowmarkProvider_brixton.Unit;
   bykoket: BowmarkProvider_bykoket.Unit;
   cancer: BowmarkProvider_cancer.Unit;
   caraway: BowmarkProvider_caraway.Unit;
   cars: BowmarkProvider_cars.Unit;
+  chantecaille: BowmarkProvider_chantecaille.Unit;
   cheapflights: BowmarkProvider_cheapflights.Unit;
   chriscraft: BowmarkProvider_chriscraft.Unit;
   classichome: BowmarkProvider_classichome.Unit;
   classpass: BowmarkProvider_classpass.Unit;
   cloudflare: BowmarkProvider_cloudflare.Unit;
   cyberpowerpc: BowmarkProvider_cyberpowerpc.Unit;
+  davidsonhomes: BowmarkProvider_davidsonhomes.Unit;
   decked: BowmarkProvider_decked.Unit;
   dice: BowmarkProvider_dice.Unit;
   dickssportinggoods: BowmarkProvider_dickssportinggoods.Unit;
@@ -16720,10 +18824,13 @@ interface BowmarkProviders {
   embroker: BowmarkProvider_embroker.Unit;
   erieinsurance: BowmarkProvider_erieinsurance.Unit;
   eventsource: BowmarkProvider_eventsource.Unit;
+  evolutionofsmooth: BowmarkProvider_evolutionofsmooth.Unit;
   extraspace: BowmarkProvider_extraspace.Unit;
   firstdibs: BowmarkProvider_firstdibs.Unit;
+  fivestarbathsolutions: BowmarkProvider_fivestarbathsolutions.Unit;
   flightradar24: BowmarkProvider_flightradar24.Unit;
   ford: BowmarkProvider_ford.Unit;
+  fourseasonsyachts: BowmarkProvider_fourseasonsyachts.Unit;
   framebridge: BowmarkProvider_framebridge.Unit;
   fred: BowmarkProvider_fred.Unit;
   geico: BowmarkProvider_geico.Unit;
@@ -16732,13 +18839,16 @@ interface BowmarkProviders {
   grainger: BowmarkProvider_grainger.Unit;
   grandwelcome: BowmarkProvider_grandwelcome.Unit;
   handypro: BowmarkProvider_handypro.Unit;
+  hansons: BowmarkProvider_hansons.Unit;
   harmar: BowmarkProvider_harmar.Unit;
   hauslabs: BowmarkProvider_hauslabs.Unit;
+  haydenhomes: BowmarkProvider_haydenhomes.Unit;
   healthcare_gov: BowmarkProvider_healthcare_gov.Unit;
   hellofresh: BowmarkProvider_hellofresh.Unit;
   hellotend: BowmarkProvider_hellotend.Unit;
   hilton: BowmarkProvider_hilton.Unit;
   hobie: BowmarkProvider_hobie.Unit;
+  holidaybuilders: BowmarkProvider_holidaybuilders.Unit;
   hunter: BowmarkProvider_hunter.Unit;
   ibuypower: BowmarkProvider_ibuypower.Unit;
   insurify: BowmarkProvider_insurify.Unit;
@@ -16746,31 +18856,39 @@ interface BowmarkProviders {
   islllc: BowmarkProvider_islllc.Unit;
   jennikayne: BowmarkProvider_jennikayne.Unit;
   joybird: BowmarkProvider_joybird.Unit;
+  joycefactorydirect: BowmarkProvider_joycefactorydirect.Unit;
+  justinwine: BowmarkProvider_justinwine.Unit;
   kayak: BowmarkProvider_kayak.Unit;
+  kingsdown: BowmarkProvider_kingsdown.Unit;
   kitchentuneup: BowmarkProvider_kitchentuneup.Unit;
   kompan: BowmarkProvider_kompan.Unit;
+  kuiu: BowmarkProvider_kuiu.Unit;
   labcorp: BowmarkProvider_labcorp.Unit;
   linkedin: BowmarkProvider_linkedin.Unit;
   liquiddeath: BowmarkProvider_liquiddeath.Unit;
   lonelyplanet: BowmarkProvider_lonelyplanet.Unit;
   louvershop: BowmarkProvider_louvershop.Unit;
+  lovelybride: BowmarkProvider_lovelybride.Unit;
   lufthansa: BowmarkProvider_lufthansa.Unit;
   lululemon: BowmarkProvider_lululemon.Unit;
   maidenhome: BowmarkProvider_maidenhome.Unit;
   mailchimp: BowmarkProvider_mailchimp.Unit;
   marriott: BowmarkProvider_marriott.Unit;
   mcdonalds: BowmarkProvider_mcdonalds.Unit;
+  medicalguardian: BowmarkProvider_medicalguardian.Unit;
   medicare: BowmarkProvider_medicare.Unit;
   microcenter: BowmarkProvider_microcenter.Unit;
   minted: BowmarkProvider_minted.Unit;
   mixbook: BowmarkProvider_mixbook.Unit;
   modularclosets: BowmarkProvider_modularclosets.Unit;
   momondo: BowmarkProvider_momondo.Unit;
+  mossyoak: BowmarkProvider_mossyoak.Unit;
   naic: BowmarkProvider_naic.Unit;
   namecheap: BowmarkProvider_namecheap.Unit;
   newegg: BowmarkProvider_newegg.Unit;
   oanda: BowmarkProvider_oanda.Unit;
   otto: BowmarkProvider_otto.Unit;
+  outdoorresearch: BowmarkProvider_outdoorresearch.Unit;
   paypal: BowmarkProvider_paypal.Unit;
   pirateship: BowmarkProvider_pirateship.Unit;
   pizzahut: BowmarkProvider_pizzahut.Unit;
@@ -16778,13 +18896,20 @@ interface BowmarkProviders {
   progressive: BowmarkProvider_progressive.Unit;
   prose: BowmarkProvider_prose.Unit;
   reddit: BowmarkProvider_reddit.Unit;
+  reliancepartners: BowmarkProvider_reliancepartners.Unit;
+  revisionskincare: BowmarkProvider_revisionskincare.Unit;
+  rishitea: BowmarkProvider_rishitea.Unit;
   ritani: BowmarkProvider_ritani.Unit;
   roofmaxx: BowmarkProvider_roofmaxx.Unit;
+  saatva: BowmarkProvider_saatva.Unit;
+  saltandstone: BowmarkProvider_saltandstone.Unit;
   samsclub: BowmarkProvider_samsclub.Unit;
+  seakeeper: BowmarkProvider_seakeeper.Unit;
   sears: BowmarkProvider_sears.Unit;
   seegarsfence: BowmarkProvider_seegarsfence.Unit;
   selectblinds: BowmarkProvider_selectblinds.Unit;
   semihandmade: BowmarkProvider_semihandmade.Unit;
+  smartsign: BowmarkProvider_smartsign.Unit;
   soundcloud: BowmarkProvider_soundcloud.Unit;
   statefarm: BowmarkProvider_statefarm.Unit;
   stickergiant: BowmarkProvider_stickergiant.Unit;
@@ -16793,8 +18918,11 @@ interface BowmarkProviders {
   target: BowmarkProvider_target.Unit;
   tatcha: BowmarkProvider_tatcha.Unit;
   teladoc: BowmarkProvider_teladoc.Unit;
+  teneohg: BowmarkProvider_teneohg.Unit;
   therabody: BowmarkProvider_therabody.Unit;
   thezebra: BowmarkProvider_thezebra.Unit;
+  tilsonhomes: BowmarkProvider_tilsonhomes.Unit;
+  titlenine: BowmarkProvider_titlenine.Unit;
   topviewtix: BowmarkProvider_topviewtix.Unit;
   trektravel: BowmarkProvider_trektravel.Unit;
   twiddy: BowmarkProvider_twiddy.Unit;
@@ -16804,10 +18932,14 @@ interface BowmarkProviders {
   villagerealtyobx: BowmarkProvider_villagerealtyobx.Unit;
   visible: BowmarkProvider_visible.Unit;
   voluspa: BowmarkProvider_voluspa.Unit;
+  walkerhughes: BowmarkProvider_walkerhughes.Unit;
   walmart: BowmarkProvider_walmart.Unit;
+  waterfurnace: BowmarkProvider_waterfurnace.Unit;
   wellfound: BowmarkProvider_wellfound.Unit;
   xpresswellnessurgentcare: BowmarkProvider_xpresswellnessurgentcare.Unit;
+  yorkwallcoverings: BowmarkProvider_yorkwallcoverings.Unit;
   yourarborhome: BowmarkProvider_yourarborhome.Unit;
+  zennioptical: BowmarkProvider_zennioptical.Unit;
   "000de82": BowmarkFamily_shopify_store.Unit;
   "001r3iv0": BowmarkFamily_shopify_store.Unit;
   "00246d8e": BowmarkFamily_shopify_store.Unit;
@@ -68539,6 +70671,7 @@ interface BowmarkLibrary {
   music: BowmarkCapability_music.Unit;
   pcparts: BowmarkCapability_pcparts.Unit;
   read: BowmarkCapability_read.Unit;
+  search: BowmarkCapability_search.Unit;
   sheds: BowmarkCapability_sheds.Unit;
   providers: BowmarkProviders;
 }