@bowmark/web 1.9.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: be4cdedcfa4c990cc2208fd7e5f33c2dd386c9c210168b9f2c02f259fbe8fbba
-// 9 capabilities, 141 providers, 422 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,49 @@ 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.
@@ -2155,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.
@@ -4940,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 {
@@ -7537,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 {
@@ -9290,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 {
@@ -10525,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 {
@@ -13777,6 +14237,115 @@ 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 {
@@ -13948,6 +14517,75 @@ 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.
@@ -14578,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.
@@ -15344,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 {
@@ -16712,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 {
@@ -16995,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 {
@@ -17046,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 {
@@ -17868,6 +18790,7 @@ 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;
@@ -17875,6 +18798,7 @@ interface BowmarkProviders {
   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;
@@ -17903,6 +18827,7 @@ interface BowmarkProviders {
   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;
@@ -17923,6 +18848,7 @@ interface BowmarkProviders {
   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;
@@ -17936,6 +18862,7 @@ interface BowmarkProviders {
   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;
@@ -17948,6 +18875,7 @@ interface BowmarkProviders {
   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;
@@ -17968,9 +18896,12 @@ 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;
@@ -17978,6 +18909,7 @@ interface BowmarkProviders {
   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;
@@ -17986,6 +18918,7 @@ 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;
@@ -17999,11 +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;
@@ -69735,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;
 }