@bowmark/web 1.7.0 → 1.9.0

package/src/generated/library.d.ts

@@ -5,9 +5,9 @@
 // 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: a400421498212bf60bfaab4808ff698bd8edb4febae1ba86fda5cb9ebc232c1b
-// 9 capabilities, 109 providers, 356 typed functions, 20 refused.
-// 51,714 family members, sharing 2 interface(s) — declared once and pointed at, never repeated per member.
+// Manifest version: be4cdedcfa4c990cc2208fd7e5f33c2dd386c9c210168b9f2c02f259fbe8fbba
+// 9 capabilities, 141 providers, 422 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
 // carry no types, so no honest signature exists. Each one is commented in place
@@ -1646,6 +1646,80 @@ interface AshleyFurnitureStore {
   }
 }
 
+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";
@@ -2029,6 +2103,58 @@ interface StoreStock {
   }
 }
 
+declare namespace BowmarkProvider_bigrentz {
+  // ── BigRentz — the unit's own declarations, verbatim ──
+interface BigrentzEquipmentRow {
+  id: number;
+  name: string;
+  slug: string;
+  permalink: string;
+  categories: { id: number; name: string; slug: string }[];
+  images: { src: string; alt: string }[];
+  inStock: boolean;
+  priced: false;
+  priceNote: string;
+}
+interface BigrentzEquipmentDetail extends BigrentzEquipmentRow {
+  description: string;
+  specSheetUrls: string[];
+}
+interface BigrentzCategoryRow {
+  id: number;
+  name: string;
+  slug: string;
+  count: number;
+  permalink: string;
+}
+
+  /**
+   * BigRentz's own equipment catalog — search, category browse and per-item detail, real data
+   * from their WooCommerce Store API. Live rental pricing is not yet built (site gates it behind
+   * a location + date picker); see getRentalPricing.
+   */
+  interface Unit {
+    /**
+     * Searches BigRentz's equipment catalog by free text (e.g. "boom lift", "40 ft boom lift") and
+     * returns matching rows. Real catalog data — id, name, slug, permalink, category, stock flag,
+     * images — but NOT a real price (see `priceNote` on each row).
+     */
+    search(query: string): Promise<BigrentzEquipmentRow[]>;
+
+    /**
+     * Reads one piece of equipment in full by the slug `search` or `listCategories` returned —
+     * description, spec-sheet PDF links, category and stock flag.
+     */
+    getEquipment(slug: string): Promise<BigrentzEquipmentDetail>;
+
+    /**
+     * Lists BigRentz's equipment categories — id, name, slug, live listing count, category page
+     * URL. Pass `parentSlug` to list a category's children.
+     */
+    listCategories(options?: { parentSlug?: string }): Promise<BigrentzCategoryRow[]>;
+  }
+}
+
 declare namespace BowmarkProvider_blenderseyewear {
   // ── Blenders Eyewear — the unit's own declarations, verbatim ──
 // Blenders Eyewear's OWN shapes — not a capability contract.
@@ -2352,6 +2478,145 @@ interface BmwusaModelListing {
   }
 }
 
+declare namespace BowmarkProvider_boydsleep {
+  // ── Boyd Sleep — the unit's own declarations, verbatim ──
+// Boyd Sleep's OWN shapes — not a capability contract.
+
+type BoydsleepGender = "Male" | "Female" | "Non Binary";
+type BoydsleepSleepPosition = "Side" | "Back" | "Stomach" | "Multi";
+
+interface BoydsleepCalibrationInput {
+  gender: BoydsleepGender;
+  heightInches: number;   // snapped to the site's own height band
+  weightLbs: number;      // snapped to the site's own weight band
+  sleepPosition: BoydsleepSleepPosition;
+}
+
+interface Boydsleep2ZoneResult {
+  supportIndex: number;       // 0-100
+  heightBandInches: number;
+  weightBandLbs: number;
+  setupGuideUrl: string;      // the real next step — no checkout exists on this domain
+  calibratorUrl: string;
+}
+
+interface Boydsleep6ZoneResult {
+  headFoot: number;
+  center: number;
+  heightBandInches: number;
+  weightBandLbs: number;
+  setupGuideUrl: string;
+  calibratorUrl: string;
+}
+
+  /**
+   * Boyd Sleep's own 'Smart Support Number' calibrator for a Nautica Home Smart Zone air bed —
+   * the real personalized 0-100 Support Index (2-zone) or Head/Foot + Center numbers (6-zone),
+   * computed exactly as the site computes them, plus the site's own setup guide as the real next
+   * step (Boyd sells through retail/franchise partners, so there is no DTC checkout on this
+   * domain to route to).
+   */
+  interface Unit {
+    /**
+     * Runs Boyd's own 2-zone Smart Support Number calculation for a Nautica Home Smart Zone air
+     * bed — a real, personalized 0-100 Support Index computed exactly as the site's own calculator
+     * computes it, no estimate. `setupGuideUrl` is the real next step; Boyd sells through
+     * retail/franchise partners, so there is no cart to route to on this domain.
+     */
+    calibrateSupportNumber(input: BoydsleepCalibrationInput): Promise<Boydsleep2ZoneResult>;
+
+    /**
+     * Runs Boyd's own 6-zone Smart Support Number calculation — same inputs as the 2-zone tool,
+     * returns a separate Head/Foot number and a Center (lumbar) number for the 6-zone Nautica Home
+     * Smart Zone bed.
+     */
+    calibrateSixZoneSupportNumber(input: BoydsleepCalibrationInput): Promise<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 {
@@ -2723,6 +2988,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 {
@@ -3401,6 +3719,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.
@@ -4122,6 +4554,100 @@ interface ErieAgent {
   }
 }
 
+declare namespace BowmarkProvider_eventsource {
+  // ── Event Source — the unit's own declarations, verbatim ──
+interface EventSourceDesign {
+  designId: number;
+  visionBoardId: number;
+  roomId: number;
+  designName: string;
+  roomName: string;
+  venueName: string;
+  hasLayouts: boolean;
+  hasTemplates: boolean;
+}
+interface EventSourceShowroom {
+  accessCode: string;
+  showroomName: string;
+  ownerName: string;
+  branded: boolean;
+  underConstruction: boolean;
+  logoUrl: string;
+  eventId: number;
+  venueIds: number[];
+  designs: EventSourceDesign[];
+}
+interface EventSourceVenue {
+  venueId: number;
+  businessName: string;
+  city: string;
+  state: string;
+  zipCode: string;
+  market: string;
+  primaryImageUrl: string;
+  rooms: Array<{ roomId: number; roomName: string; primaryImageUrl: string; active: boolean }>;
+}
+interface EventSourceInquiryContact {
+  inquiryRequestEmail: string;
+  ownerName: string;
+  ownerLogoUrl: string;
+}
+
+  /**
+   * Reads a public Event Source Virtual Design Center showroom (design, venue, inquiry contact)
+   * by its access code — no login.
+   */
+  interface Unit {
+    /**
+     * Reads a public Virtual Design Center showroom by its access code — its design(s), venue and
+     * branding.
+     */
+    getShowroom(code: string): Promise<EventSourceShowroom>;
+
+    /** Reads the real venue/room a showroom's design is staged in. */
+    getShowroomVenue(eventId: number, venueId: number, code: string): Promise<EventSourceVenue>;
+
+    /** Reads who a showroom's Send Inquiry button emails, without submitting anything. */
+    getShowroomInquiryContact(code: string): Promise<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 {
@@ -4809,6 +5335,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.
@@ -5614,6 +6212,72 @@ interface graingerStockRow {
   }
 }
 
+declare namespace BowmarkProvider_grandwelcome {
+  // ── Grand Welcome — the unit's own declarations, verbatim ──
+interface GrandwelcomeRentalRow {
+  rentalId: string;
+  name: string;
+  url: string;
+  location: string;
+  propertyType: string;
+  petFriendly: boolean;
+  priceFromUsd: number | null;
+  priceFromFormatted: string | null;
+  bedrooms: number | null;
+  bathrooms: number | null;
+  guests: number | null;
+  ratingValue: number | null;
+  ratingCount: number | null;
+}
+interface GrandwelcomeRentalDetail {
+  rentalId: string;
+  propertyId: string;
+  name: string;
+  description: string;
+  images: string[];
+  url: string;
+}
+interface GrandwelcomeQuoteFee {
+  label: string;
+  amountUsd: number;
+}
+type GrandwelcomeQuote =
+  | { available: true; propertyId: string; checkin: string; checkout: string; currency: "USD";
+      rentUsd: number; fees: GrandwelcomeQuoteFee[]; feesTotalUsd: number; taxUsd: number;
+      totalUsd: number; bookNowUrl: string }
+  | { available: false; propertyId: string; checkin: string; checkout: string };
+
+  /**
+   * Grand Welcome's own vacation rental search, listing detail, and real-time dated
+   * pricing/booking-link engine — a national franchise's own inventory, live availability and
+   * price, not a stale catalog.
+   */
+  interface Unit {
+    /**
+     * Runs Grand Welcome's own destination search (a market slug like "california-sea-ranch", from
+     * a rental's own page or the destination directory), optionally filtered to a bedroom count,
+     * and returns the live matching listings — name, url, location, type, pet-friendly flag,
+     * advertised "as low as" price, bed/bath/guest counts, rating.
+     */
+    searchRentals(destinationSlug: string, options?: { bedrooms?: number }): Promise<GrandwelcomeRentalRow[]>;
+
+    /**
+     * Reads one rental in full — name, description, photos, and the internal numeric propertyId
+     * getRentalQuote needs — from the rentalId a search result or a grandwelcome.com/rentals/<id>
+     * URL carries.
+     */
+    getRentalDetail(rentalId: string): Promise<GrandwelcomeRentalDetail>;
+
+    /**
+     * Runs the site's own real-time pricing engine for one property and a date range
+     * ("YYYY-MM-DD") — rent, fees, tax, total — and returns the exact Book Now checkout URL for
+     * those dates. `available: false` means the site checked and the property is not free for
+     * those dates, an ordinary answer.
+     */
+    getRentalQuote(propertyId: string, options: { checkin: string; checkout: string }): Promise<GrandwelcomeQuote>;
+  }
+}
+
 declare namespace BowmarkProvider_handypro {
   // ── HandyPro — the unit's own declarations, verbatim ──
 // HandyPro's OWN shapes — not a capability contract.
@@ -5670,6 +6334,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 {
@@ -5814,6 +6515,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 {
@@ -8032,6 +8794,64 @@ interface IsllcSearchCommunitiesResult {
   }
 }
 
+declare namespace BowmarkProvider_jennikayne {
+  // ── Jenni Kayne — the unit's own declarations, verbatim ──
+interface GiftCardDenomination {
+  variantId: string;
+  amount: string;
+  available: boolean;
+}
+interface GiftCardOptions {
+  productUrl: string;
+  denominations: GiftCardDenomination[];
+  timezones: string[];
+}
+interface GiftCardConfig {
+  amount: string;
+  recipientName: string;
+  recipientEmail: string;
+  giftMessage?: string;
+  deliveryDate: string;
+  deliveryTimezone: string;
+}
+interface GiftCardLink {
+  amount: string;
+  variantId: string;
+  recipientName: string;
+  recipientEmail: string;
+  giftMessage: string | null;
+  deliveryDate: string;
+  deliveryTimezone: string;
+  available: boolean;
+  cartUrl: string;
+  checkoutUrl: string;
+  deliveryTimeLeftToShopper: true;
+}
+
+  /**
+   * Jenni Kayne's live gift-card product: read the real denominations and hand the shopper a
+   * checkout link pre-filled with the recipient, message and scheduled delivery date/timezone.
+   */
+  interface Unit {
+    /**
+     * Reads the live Jenni Kayne digital gift-card product — every denomination from $50 to $1,000
+     * with its real variant id and current stock, plus the exact timezone strings the checkout
+     * form accepts. Call this first to know what buildGiftCardLink will accept.
+     */
+    getGiftCardOptions(): Promise<GiftCardOptions>;
+
+    /**
+     * Configures a Jenni Kayne digital gift card — amount, recipient name/email, an optional
+     * message, and a scheduled delivery date + timezone — and returns a checkout link with every
+     * one of those fields already filled in, so the shopper only has to pick a delivery TIME and
+     * pay. THROWS on an unknown amount, an invalid email, a malformed date, or a timezone the
+     * store does not offer — call getGiftCardOptions first to see the live choices. Builds the
+     * link only; nothing is purchased or charged here.
+     */
+    buildGiftCardLink(config: GiftCardConfig): Promise<GiftCardLink>;
+  }
+}
+
 declare namespace BowmarkProvider_joybird {
   // ── Joybird — the unit's own declarations, verbatim ──
 interface JoybirdConfigurator {
@@ -8125,6 +8945,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 {
@@ -8268,6 +9157,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 {
@@ -8702,9 +9624,9 @@ interface LiquiddeathCart {
 interface LiquiddeathLiveCartLine {
   lineId: string;
   variantId: string;
-  variantTitle: string | null;
-  productTitle: string;
+  title: string;
   quantity: number;
+  unitPrice: string;
   lineTotal: string;
 }
 interface LiquiddeathLiveCart {
@@ -8715,9 +9637,7 @@ interface LiquiddeathLiveCart {
   total: string;
   currency: string;
   checkoutUrl: string;
-  countryCode: string | null;
-  createdAt: string | null;
-  updatedAt: string | null;
+  expiresAt: string | null;
 }
 
   /**
@@ -8753,15 +9673,19 @@ interface LiquiddeathLiveCart {
     addToCart(items: LiquiddeathCartItem[]): Promise<LiquiddeathCart>;
 
     /**
-     * Reads a cart the shopper already has, by its id — line items, quantities, per-line and order
-     * totals, and the real checkout URL to hand back. The id is a bearer credential the SHOPPER
-     * holds, and it is the one their cart or checkout LINK carries
-     * (liquiddeath.com/cart/c/<token>?key=<key>), NOT the store's `cart` cookie or /cart.js token
-     * — those are a separate Ajax id space this endpoint answers 'Cart does not exist' for. There
-     * is no way to list or search carts, so a caller without an id cannot get one. Accepts the id
-     * with or without the `?key=` suffix. THROWS when the cart does not exist or has expired —
-     * Shopify drops an unused cart within 30 days and deletes it at checkout — because an empty
-     * cart and a dead link are opposite answers. Does not return shipping options or discounts:
+     * Reads a cart the shopper already has, by its id — line items, quantities, per-unit and
+     * per-line prices, order subtotal and total, the cart's currency and expiry, and the real
+     * checkout URL to hand back. The id is a bearer credential the SHOPPER holds, and it is the
+     * one their cart or checkout LINK carries (liquiddeath.com/cart/c/<token>?key=<key>), NOT the
+     * store's `cart` cookie or /cart.js token — those are a separate Ajax id space this endpoint
+     * answers 'The requested cart does not exist' for. There is no way to list or search carts, so
+     * a caller without an id cannot get one. THE WHOLE id IS REQUIRED, `?key=` included: the store
+     * checks the key's value, so a bare token comes back as a cart that does not exist rather than
+     * as a missing credential, and this refuses it here instead. THROWS when the cart does not
+     * exist or has expired — Shopify drops an unused cart within 30 days and deletes it at
+     * checkout — because an empty cart and a dead link are opposite answers. Each line carries the
+     * store's own joined product-and-variant `title` ("Death Western Hat - Cream/Green"); this
+     * door publishes no separate product title. Does not return shipping options or discounts:
      * both require setting an address on the cart, which is a write this provider does not
      * perform.
      */
@@ -8849,6 +9773,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 {
@@ -9169,8 +10163,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 {
@@ -9191,10 +10193,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
@@ -10691,6 +11699,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 {
@@ -11159,6 +12250,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 {
@@ -12636,6 +13777,67 @@ interface RedditThread {
   }
 }
 
+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.
@@ -12705,6 +13907,109 @@ interface RitaniPriceResult {
   }
 }
 
+declare namespace BowmarkProvider_roofmaxx {
+  // ── Roof Maxx — the unit's own declarations, verbatim ──
+interface RoofmaxxCalculatorSettings {
+  title: string;
+  description: string;
+}
+
+interface RoofmaxxCostEstimateArgs {
+  squareFootage: number;
+  region: "new-england" | "middle-atlantic" | "east-north-central" | "west-north-central" |
+    "south-atlantic" | "east-south-central" | "west-south-central" | "mountain" | "pacific";
+  roofType: "asphalt" | "metal" | "clay" | "wood";
+  roofSlope: "walkable" | "semiWalkable" | "nonWalkable";
+  numOfLevels: "1" | "2" | "3";
+  garageType: "nogarage" | "1car" | "2car";
+}
+
+interface RoofmaxxCostEstimate {
+  low: number;
+  mid: number;
+  high: number;
+}
+
+  /**
+   * Roof Maxx's own Roof Replacement Cost Calculator (roofmaxx.com/learning-hub) — given a
+   * home's size, location and roof details, returns the site's real server-computed low/mid/high
+   * full-replacement-cost estimate.
+   */
+  interface Unit {
+    /** The Roof Replacement Cost Calculator's own admin-configured title and description. */
+    getCalculatorSettings(): Promise<RoofmaxxCalculatorSettings>;
+
+    /**
+     * Runs the real calculator: given square footage, region, roof type, roof slope, garage size
+     * and building levels, returns Roof Maxx's own server-computed low/mid/high
+     * full-replacement-cost tiers.
+     */
+    estimateRoofReplacementCost(arg: RoofmaxxCostEstimateArgs): Promise<RoofmaxxCostEstimate>;
+  }
+}
+
+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 {
@@ -12897,6 +14202,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 {
@@ -13792,6 +15141,52 @@ interface SunHomeSaunasCartResult {
   }
 }
 
+declare namespace BowmarkProvider_tamarackidaho {
+  // ── Tamarack Resort — the unit's own declarations, verbatim ──
+interface tamarackidahoSearchArgs {
+  arrivalDate: string;
+  departureDate: string;
+  adultCount: number;
+  childCount?: number;
+}
+
+interface tamarackidahoSearchResult {
+  arrivalDate: string;
+  departureDate: string;
+  adultCount: number;
+  childCount: number;
+  units: tamarackidahoUnit[];
+}
+
+interface tamarackidahoUnit {
+  supplierId: string;
+  supplierName: string;
+  productId: string;
+  unitName: string;
+  totalPrice: number;
+}
+
+  /**
+   * Tamarack Resort's own direct-managed lodging booking engine (Inntopia RTP) — real
+   * availability and price per unit type for a date range and party size, straight from the
+   * site's own search widget, browserless.
+   */
+  interface Unit {
+    /**
+     * Searches Tamarack Resort's own direct-managed lodging (the Lodge at Osprey Meadows, the
+     * Village at Tamarack Resort, and Tamarack Homes and Cottages — not the golf tee-time flow, a
+     * different vendor) for a stay and party size. `arrivalDate`/`departureDate` are "MM/DD/YYYY"
+     * strings (the widget's own format), `adultCount` is required and positive, `childCount`
+     * defaults to 0. Returns every unit type Tamarack's own booking engine (Inntopia RTP)
+     * currently prices as AVAILABLE for that exact query — each with its supplier (property), unit
+     * name, and `totalPrice` in USD for the whole queried stay (not nightly) — genuinely computed
+     * per call, not a cached listing. An empty `units` array is a real answer: Tamarack has
+     * nothing available for that stay, not a failure.
+     */
+    searchLodging(args: tamarackidahoSearchArgs): Promise<tamarackidahoSearchResult>;
+  }
+}
+
 declare namespace BowmarkProvider_target {
   // ── Target — the unit's own declarations, verbatim ──
 interface targetRow {
@@ -13846,6 +15241,55 @@ interface TargetStoreSearch {
   }
 }
 
+declare namespace BowmarkProvider_tatcha {
+  // ── Tatcha — the unit's own declarations, verbatim ──
+interface TatchaQuizOption {
+  value: string;
+  label: string;
+}
+
+interface TatchaRitualQuizOptions {
+  skinTypes: TatchaQuizOption[];
+  benefits: TatchaQuizOption[];
+  eyeConcerns: TatchaQuizOption[];
+}
+
+interface TatchaRitualProduct {
+  step: string;
+  sku: string;
+  name: string;
+  secondaryName: string;
+  price: string;
+  handle: string;
+  url: string;
+  image: string;
+  usageTime: "AM" | "PM" | "both";
+  description: string;
+  inStock: boolean;
+}
+
+interface TatchaRitual {
+  summary: string;
+  products: TatchaRitualProduct[];
+  handoffUrl: string;
+}
+
+  /**
+   * Runs Tatcha's real "Ritual Finder" skincare quiz — the site's own product-matching backend,
+   * not a generic routine.
+   */
+  interface Unit {
+    /** Reads the live Ritual Finder quiz's real skin-type, benefit and eye-concern menus. */
+    getRitualQuizOptions(): Promise<TatchaRitualQuizOptions>;
+
+    /**
+     * Runs real quiz answers through Tatcha's own personalization backend and returns the real
+     * AM/PM product ritual it recommends.
+     */
+    getPersonalizedRitual(skinType: string, benefits: string[], eyeConcerns?: string[], sensitive?: boolean, owned?: string[]): Promise<TatchaRitual>;
+  }
+}
+
 declare namespace BowmarkProvider_teladoc {
   // ── Teladoc Health — the unit's own declarations, verbatim ──
 interface teladocRow {
@@ -13900,98 +15344,6 @@ interface teladocInsuranceCoverage {
   }
 }
 
-declare namespace BowmarkProvider_tentree {
-  // ── tentree — the unit's own declarations, verbatim ──
-interface TentreeVariant {
-  /** Shopify's numeric variant id as a string. What addToCart takes. */
-  id: string;
-  /** The variant's own label, e.g. "ASHWOOD METEORITE BLACK / ONE". */
-  title: string;
-  /** Decimal string exactly as the store publishes it, e.g. "45.00". */
-  price: string;
-  compareAtPrice: string | null;
-  sku: string | null;
-  /** The store's own per-variant stock flag. */
-  available: boolean;
-  options: string[];
-}
-interface TentreeProduct {
-  handle: string;
-  title: string;
-  productType: string;
-  vendor: string;
-  url: string;
-  optionNames: string[];
-  variants: TentreeVariant[];
-  priceRange: { min: string; max: string } | null;
-  inStock: boolean;
-  tags: string[];
-  descriptionHtml: string | null;
-}
-interface TentreeCartLine {
-  /** Shopify's own line key, which its cart-change endpoints address a line by. */
-  lineKey: string;
-  variantId: string;
-  productTitle: string;
-  /** Null on a single-variant product. */
-  variantTitle: string | null;
-  quantity: number;
-  price: string;
-  lineTotal: string;
-  url: string;
-}
-interface TentreeCart {
-  /** The store's own cart token — a bearer credential, so treat it like one. */
-  token: string;
-  lines: TentreeCartLine[];
-  /** Units, NOT lines: two of one variant is one line and two items. */
-  itemCount: number;
-  subtotal: string;
-  currency: string;
-  cartUrl: string;
-  checkoutUrl: string;
-}
-
-  /**
-   * Sustainable apparel storefront — hats, tees, hoodies and outerwear — with a real guest cart
-   * a caller can fill across several calls.
-   */
-  interface Unit {
-    /**
-     * Searches tentree's live catalogue and returns matching products with their real variants,
-     * current prices and per-variant stock. Matches whole words, so 'tee' finds tees and not
-     * 'steel'. Returns [] when nothing matches, which is an ordinary answer rather than an error.
-     */
-    searchProducts(query: string, opts?: { productType?: string; inStockOnly?: boolean; limit?: number }): Promise<TentreeProduct[]>;
-
-    /**
-     * Reads one product by its handle — every variant, its exact price and whether that specific
-     * size or colour is purchasable right now. Takes the handle searchProducts returns, and its
-     * variants[].id is what addToCart takes. THROWS on an unknown handle (the store answers a real
-     * 404).
-     */
-    getProduct(handle: string): Promise<TentreeProduct>;
-
-    /**
-     * Puts variants into THIS run's own cart on the store and returns the cart as the store
-     * reports it. Really writes — the cart exists on tentree.com from the first call, and it
-     * belongs to this run's cookie jar. Call it several times inside one bowmark.session() and the
-     * lines accumulate; call it across two separate runs and the second cart does not contain the
-     * first's lines. Takes VARIANT ids (getProduct().variants[].id), never handles. Nothing is
-     * bought: checkoutUrl is where a shopper would pay.
-     */
-    addToCart(items: Array<{ variantId: string; quantity?: number }>): Promise<TentreeCart>;
-
-    /**
-     * Reads THIS run's cart back from the store — lines, quantities, per-line and order totals,
-     * and the real cart and checkout URLs. Takes no id: the cart is the one this run's cookie jar
-     * holds, so a fresh run reads an empty cart rather than somebody else's. An empty cart is an
-     * ordinary answer (itemCount 0), not an error.
-     */
-    getCart(): Promise<TentreeCart>;
-  }
-}
-
 declare namespace BowmarkProvider_therabody {
   // ── Therabody — the unit's own declarations, verbatim ──
 interface TherabodyVariant {
@@ -14577,6 +15929,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 {
@@ -14687,6 +16141,72 @@ interface TrekTravelSearchFilters {
   }
 }
 
+declare namespace BowmarkProvider_twiddy {
+  // ── Twiddy & Company Realtors — the unit's own declarations, verbatim ──
+interface TwiddyRentalRow {
+  propertyId: number;
+  propertyNumber: string;
+  name: string;
+  url: string;
+  town: string;
+  distanceToBeach: string;
+  bedrooms: number | null;
+  priceFromUsd: number | null;
+  priceFromFormatted: string | null;
+  ratingValue: number | null;
+  isAvailable: boolean;
+}
+interface TwiddyRentalDetail {
+  propertyId: number;
+  name: string;
+  identifier: string;
+  description: string;
+  streetAddress: string;
+  town: string;
+  petsAllowed: boolean;
+  amenities: string[];
+  numberOfBedrooms: number | null;
+  numberOfBathrooms: number | null;
+  images: string[];
+  url: string;
+}
+type TwiddyQuote =
+  | { available: true; propertyId: number; checkin: string; nights: number; currency: "USD";
+      rentalFeeUsd: number; discountUsd: number; taxUsd: number; totalUsd: number; checkoutUrl: string }
+  | { available: false; propertyId: number; checkin: string; nights: number };
+
+  /**
+   * Twiddy & Company's own Outer Banks vacation rental search and real-time weekly
+   * pricing/booking-handoff engine — a regional owner-operator's own 1,000+ property inventory,
+   * live availability and price, not a stale catalog.
+   */
+  interface Unit {
+    /**
+     * Runs Twiddy's own portfolio-wide search (all 1,000+ managed Outer Banks properties in one
+     * call), optionally filtered to one of the six towns ("Corolla", "Duck", "4x4", "Southern
+     * Shores", "Kitty Hawk", "Kill Devil Hills", "Nags Head") and/or a minimum bedroom count, and
+     * returns the live matching listings — name, url, town, distance to beach, bed count, an "as
+     * low as" headline price, rating.
+     */
+    searchRentals(options?: { town?: string; minBedrooms?: number }): Promise<TwiddyRentalRow[]>;
+
+    /**
+     * Reads one rental in full — description, address, pets-allowed flag, amenities, bed/bath
+     * counts, photos, and the internal numeric propertyId getRentalQuote needs — from the
+     * propertyUrl a search result carries (a twiddy.com/outer-banks/... path or full URL).
+     */
+    getRentalDetail(propertyUrl: string): Promise<TwiddyRentalDetail>;
+
+    /**
+     * Runs the site's own real-time weekly pricing engine for one property and a check-in date
+     * ("YYYY-MM-DD", default 7 nights) — rental fee, discount, tax, total — and returns the exact
+     * booking/checkout URL for that week. `available: false` means the site checked and the
+     * property has no live rate for that week, an ordinary answer.
+     */
+    getRentalQuote(propertyId: number, options: { checkin: string; nights?: number }): Promise<TwiddyQuote>;
+  }
+}
+
 declare namespace BowmarkProvider_ulrichlifestyle {
   // ── Ulrich Lifestyle Structures — the unit's own declarations, verbatim ──
 // Ulrich Lifestyle Structures' OWN shapes — not a capability contract.
@@ -14758,6 +16278,58 @@ interface UlrichPriceResult {
   }
 }
 
+declare namespace BowmarkProvider_vervecoffee {
+  // ── Verve Coffee Roasters — the unit's own declarations, verbatim ──
+interface VervecoffeeSubscription {
+  id: string;
+  handle: string;
+  title: string;
+  priceFormatted: string;
+  url: string;
+}
+interface VervecoffeeCoffeeMatch {
+  id: string;
+  title: string;
+  descriptionHtml: string;
+  startingPriceFormatted: string;
+  url: string;
+  subscriptionPlans: Array<{ name: string; deliveryInterval: string; priceWithDiscount: string }>;
+}
+interface VervecoffeeCoffeeMatchResult {
+  recommendedProducts: VervecoffeeCoffeeMatch[];
+}
+interface CoffeeQuizAnswers {
+  journeyStage: "coffee_curious" | "casual_coffee_lover" | "coffee_connoisseur" | "barista";
+  brewMethod: "pourover" | "coffee_maker" | "espresso" | "french_press" | "aeropress";
+  coffeeStyle: "black" | "milk_or_cream" | "sugar_or_sweetener";
+  roastPreference: "light" | "medium" | "dark" | "not_sure";
+  tastingNote: "chocolate" | "citrus" | "fruits" | "sweet" | "floral" | "nuts";
+}
+
+  /**
+   * Verve Coffee Roasters' Roaster's Choice subscription catalog and its real 'Find Your Coffee
+   * Match' quiz (Octane AI-powered) — drives the same 5 questions the live site asks and returns
+   * the actual subscription it recommends, priced, with a buy link.
+   */
+  interface Unit {
+    /**
+     * Lists Verve's five real Roaster's Choice coffee subscription products (single origin, blend,
+     * espresso, Africa, Latin America) with their live USD price, read off the storefront's own
+     * /products.json catalog.
+     */
+    listRoastersChoiceSubscriptions(): Promise<VervecoffeeSubscription[]>;
+
+    /**
+     * Runs Verve's real 'Find Your Coffee Match' quiz end to end — the same 5 questions the live
+     * Octane AI-powered quiz at /pages/quiz asks every visitor — and returns the actual Roaster's
+     * Choice subscription(s) it recommends, with real USD price and a buy-page link. THROWS if
+     * Verve's quiz has been reconfigured and one of the 5 answer labels no longer matches (see the
+     * error for the live option set).
+     */
+    matchCoffeeSubscription(answers: CoffeeQuizAnswers): Promise<VervecoffeeCoffeeMatchResult>;
+  }
+}
+
 declare namespace BowmarkProvider_viewrail {
   // ── Viewrail — the unit's own declarations, verbatim ──
 interface ViewrailMaterial {
@@ -14798,6 +16370,62 @@ interface ViewrailMountingStyle {
   }
 }
 
+declare namespace BowmarkProvider_villagerealtyobx {
+  // ── Village Realty — the unit's own declarations, verbatim ──
+interface VillagerealtyobxListing {
+  propertyID: string;
+  seoName: string;
+  name: string;
+  town: string;
+  address: string | null;
+  bedrooms: number | null;
+  maxGuests: number | null;
+  photoUrl: string | null;
+  url: string;
+}
+
+interface VillagerealtyobxQuote {
+  propertyID: string;
+  checkin: string;
+  checkout: string;
+  available: boolean;
+  rent: number | null;
+  taxes: number | null;
+  total: number | null;
+  currency: string;
+  bookNowURL: string | null;
+  message: string | null;
+}
+
+  /**
+   * Village Realty's own Outer Banks vacation-rental search and real-time property quote (rent,
+   * taxes, total, book-now link) — the same live pricing their own site computes, no login
+   * required.
+   */
+  interface Unit {
+    /**
+     * Searches Village Realty's own 900+ Outer Banks rental listings the way
+     * villagerealtyobx.com/outer-banks-vacation-rentals does — filter by town (e.g. "Corolla",
+     * "Nags Head"), exact bedroom count, amenities (e.g. "Private Pool", "Elevator"), and
+     * optionally a date range — returning each matching property's id, name, town, address,
+     * bedroom count, max guests and detail-page URL. Call getQuote with a result's propertyID for
+     * a real priced quote.
+     */
+    searchRentals(args?: { town?: string, bedrooms?: number, amenities?: string[], checkin?: string, checkout?: string, page?: number }): Promise<VillagerealtyobxListing[]>;
+
+    /**
+     * Gets a real-time price quote for one Village Realty property and date range — the exact
+     * server-computed rent, taxes and total the rental detail page shows after picking dates, plus
+     * the book-now URL. `checkin`/`checkout` are `MM/DD/YYYY`. `available: false` is a genuine
+     * site answer (e.g. the dates fail the property's minimum-night-stay rule), not an error —
+     * this is the flow ChatGPT itself cannot operate today: asked to price a Village Realty stay
+     * it answers "I can't complete the booking or take payment for you" and recommends competitor
+     * sites instead of quoting Village Realty's own live price.
+     */
+    getQuote(args: { propertyID: string, checkin: string, checkout: string }): Promise<VillagerealtyobxQuote>;
+  }
+}
+
 declare namespace BowmarkProvider_visible {
   // ── Visible — the unit's own declarations, verbatim ──
 interface VisibleDealOffer {
@@ -15057,6 +16685,33 @@ interface VisibleGetPlansResult {
   }
 }
 
+declare namespace BowmarkProvider_voluspa {
+  // ── Voluspa — the unit's own declarations, verbatim ──
+interface VoluspaQuizButton {
+  text: string;
+  action: string;
+  url?: string;
+  selectedValue?: string;
+}
+interface VoluspaQuizIntro {
+  paths: VoluspaQuizButton[];
+  firstQuestionOptions: VoluspaQuizButton[];
+}
+
+  /**
+   * Voluspa's own "Find Your Fragrance" quiz suite — reads the branching quiz's entry paths and
+   * first-question scent-family options straight from the quiz vendor's config.
+   */
+  interface Unit {
+    /**
+     * Reads the fragrance quiz's entry screen — its two branching paths and the FIRST question's
+     * scent-family options for one of them (0 = home fragrance, 1 = personal fragrance/EDP, as the
+     * splash screen lists them; default 0) — decoded from Digioh's own campaign config.
+     */
+    getFragranceQuizIntro(pathIndex?: number): Promise<VoluspaQuizIntro>;
+  }
+}
+
 declare namespace BowmarkProvider_walmart {
   // ── Walmart — the unit's own declarations, verbatim ──
 interface walmartStore {
@@ -15124,6 +16779,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 {
@@ -15236,6 +16949,52 @@ interface wellfoundCompanyDetail {
   }
 }
 
+declare namespace BowmarkProvider_xpresswellnessurgentcare {
+  // ── Xpress Wellness Urgent Care — the unit's own declarations, verbatim ──
+interface XpressFacility {
+  facilityId: string;       // healow facility_id — what checkWaitTime takes
+  name: string;              // e.g. "Manhattan, KS"
+  address: string | null;
+  phone: string | null;
+  detailsUrl: string | null; // the clinic's own page on the marketing site
+  checkinUrl: string;        // the healow openaccess widget URL
+}
+interface XpressWaitTime {
+  facilityId: string;
+  facilityName: string;      // confirmed by the widget's own dataLayer, not assumed
+  address: string | null;
+  phone: string | null;
+  waitTimeText: string;      // the site's own bucketed phrase, e.g. "Under 30 mins"
+  hoursText: string | null;  // e.g. "OPEN - Until 8 PM"
+  url: string;
+}
+
+  /**
+   * Reads Xpress Wellness Urgent Care's clinic roster and each clinic's live healow wait-time /
+   * check-in widget — no key, no browser.
+   */
+  interface Unit {
+    /**
+     * Lists every Xpress Wellness Urgent Care clinic — 40 locations across Oklahoma, Kansas and
+     * one Texas site — with name, address, phone, the clinic's own detail page and the healow
+     * check-in widget URL + facility_id. Takes nothing. The facilityId it returns is what
+     * checkWaitTime takes. THROWS rather than returning [] when the roster page answers with no
+     * clinics — the roster is never honestly empty.
+     */
+    listFacilities(): Promise<XpressFacility[]>;
+
+    /**
+     * Reads one clinic's live estimated wait time, hours-today status and confirmed identity
+     * straight off its healow openaccess widget. facilityId is the numeric id listFacilities
+     * returns (e.g. "10"). Confirms the facility resolved by cross-checking the widget's own
+     * embedded facility name before returning a reading; THROWS with the caller-facing facility_id
+     * named if the widget carries no name (an unknown id) or no wait-time reading (the widget's
+     * markup changed).
+     */
+    checkWaitTime(facilityId: string): Promise<XpressWaitTime>;
+  }
+}
+
 declare namespace BowmarkProvider_yourarborhome {
   // ── Arbor Homes — the unit's own declarations, verbatim ──
 interface ArborHome {
@@ -15606,8 +17365,8 @@ interface ShopifyCart {
 
   /**
    * OSMUND OLSEN — Every Shopify storefront, reached by its own name. One engine over the
-   * platform's two published surfaces — the store's own MCP server at /api/mcp for search, and
-   * the keyless Ajax storefront JSON for products and the cart.
+   * platform's two published surfaces — the store's own UCP MCP server at /api/ucp/mcp for
+   * search, and the keyless Ajax storefront JSON for products and the cart.
    */
   interface Unit {
     /**
@@ -16019,8 +17778,8 @@ interface ShopifyCart {
 
   /**
    * friedrikdev — Every Shopify storefront, reached by its own name. One engine over the
-   * platform's two published surfaces — the store's own MCP server at /api/mcp for search, and
-   * the keyless Ajax storefront JSON for products and the cart.
+   * platform's two published surfaces — the store's own UCP MCP server at /api/ucp/mcp for
+   * search, and the keyless Ajax storefront JSON for products and the cart.
    */
   interface Unit {
     /**
@@ -16109,24 +17868,30 @@ interface BowmarkProviders {
   aiper: BowmarkProvider_aiper.Unit;
   ajmadison: BowmarkProvider_ajmadison.Unit;
   ashleyfurniture: BowmarkProvider_ashleyfurniture.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;
   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;
@@ -16134,19 +17899,25 @@ interface BowmarkProviders {
   discounttire: BowmarkProvider_discounttire.Unit;
   embroker: BowmarkProvider_embroker.Unit;
   erieinsurance: BowmarkProvider_erieinsurance.Unit;
+  eventsource: BowmarkProvider_eventsource.Unit;
+  evolutionofsmooth: BowmarkProvider_evolutionofsmooth.Unit;
   extraspace: BowmarkProvider_extraspace.Unit;
   firstdibs: BowmarkProvider_firstdibs.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;
   google_flights: BowmarkProvider_google_flights.Unit;
   gotchacovered: BowmarkProvider_gotchacovered.Unit;
   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;
@@ -16157,8 +17928,12 @@ interface BowmarkProviders {
   insurify: BowmarkProvider_insurify.Unit;
   interiordefine: BowmarkProvider_interiordefine.Unit;
   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;
   labcorp: BowmarkProvider_labcorp.Unit;
@@ -16166,6 +17941,7 @@ interface BowmarkProviders {
   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;
@@ -16178,11 +17954,13 @@ interface BowmarkProviders {
   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;
@@ -16190,8 +17968,12 @@ interface BowmarkProviders {
   progressive: BowmarkProvider_progressive.Unit;
   prose: BowmarkProvider_prose.Unit;
   reddit: BowmarkProvider_reddit.Unit;
+  rishitea: BowmarkProvider_rishitea.Unit;
   ritani: BowmarkProvider_ritani.Unit;
+  roofmaxx: BowmarkProvider_roofmaxx.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;
@@ -16200,18 +17982,27 @@ interface BowmarkProviders {
   statefarm: BowmarkProvider_statefarm.Unit;
   stickergiant: BowmarkProvider_stickergiant.Unit;
   sunhomesaunas: BowmarkProvider_sunhomesaunas.Unit;
+  tamarackidaho: BowmarkProvider_tamarackidaho.Unit;
   target: BowmarkProvider_target.Unit;
+  tatcha: BowmarkProvider_tatcha.Unit;
   teladoc: BowmarkProvider_teladoc.Unit;
-  tentree: BowmarkProvider_tentree.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;
   ulrichlifestyle: BowmarkProvider_ulrichlifestyle.Unit;
+  vervecoffee: BowmarkProvider_vervecoffee.Unit;
   viewrail: BowmarkProvider_viewrail.Unit;
+  villagerealtyobx: BowmarkProvider_villagerealtyobx.Unit;
   visible: BowmarkProvider_visible.Unit;
+  voluspa: BowmarkProvider_voluspa.Unit;
   walmart: BowmarkProvider_walmart.Unit;
+  waterfurnace: BowmarkProvider_waterfurnace.Unit;
   wellfound: BowmarkProvider_wellfound.Unit;
+  xpresswellnessurgentcare: BowmarkProvider_xpresswellnessurgentcare.Unit;
   yourarborhome: BowmarkProvider_yourarborhome.Unit;
   "000de82": BowmarkFamily_shopify_store.Unit;
   "001r3iv0": BowmarkFamily_shopify_store.Unit;
@@ -58133,6 +59924,7 @@ interface BowmarkProviders {
   tentarte: BowmarkFamily_shopify_store.Unit;
   tenthavenuenorthshop: BowmarkFamily_shopify_store.Unit;
   tenthpine: BowmarkFamily_shopify_store.Unit;
+  tentree: BowmarkFamily_shopify_store.Unit;
   teoapparel: BowmarkFamily_shopify_store.Unit;
   teopanzolcobarcelonnette: BowmarkFamily_shopify_store.Unit;
   tepawines: BowmarkFamily_shopify_store.Unit;