@bowmark/web 1.8.0 → 1.9.0

package/src/generated/library.d.ts

@@ -5,8 +5,8 @@
 // rather than imported. An `import` or `export` at the top level of this file would
 // turn it into a module and every declaration below would stop being global.
 //
-// Manifest version: b71c060db620c119ab92eac724aab2d9670d3d22f342f754075e353929634db2
-// 9 capabilities, 121 providers, 380 typed functions, 20 refused.
+// Manifest version: 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
@@ -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";
@@ -2460,6 +2534,89 @@ interface Boydsleep6ZoneResult {
   }
 }
 
+declare namespace BowmarkProvider_brixton {
+  // ── Brixton — the unit's own declarations, verbatim ──
+interface BrixtonVariant {
+  /** Shopify's numeric variant id as a string. */
+  id: string;
+  /** The variant's own label, e.g. "M" or "Black / M" on multi-option products. */
+  title: string;
+  /** String verbatim from the storefront — "30.00" (dollars) on /products.json, "10900" (cents) on /products/<h>.js. */
+  price: string;
+  /** Same scale as price. Null when the variant is not on sale. */
+  compareAtPrice: string | null;
+  /** The store's own SKU. Null on a variant without one. */
+  sku: string | null;
+  /** Whether the variant is purchasable right now. */
+  available: boolean;
+  /** e.g. ["M"] or ["Black", "M"]. */
+  options: string[];
+}
+interface BrixtonProduct {
+  /** The handle is the only stable identifier across the catalogue. */
+  handle: string;
+  title: string;
+  vendor: string;
+  productType: string;
+  url: string;
+  descriptionHtml: string | null;
+  optionNames: string[];
+  variants: BrixtonVariant[];
+  /** Same scale as variants — see BrixtonVariant.price. */
+  priceRange: { min: string; max: string } | null;
+  /** True if ANY variant is purchasable. */
+  inStock: boolean;
+  tags: string[];
+  /** Brixton's own images, in the order the storefront publishes them. */
+  images: string[];
+}
+interface BrixtonCatalogue {
+  /** All matching products, in-stock first, then by handle. */
+  products: BrixtonProduct[];
+  /** What the filter DROPPED, in the same register the rest of the library uses. */
+  warnings: string[];
+}
+interface BrixtonCheckoutLink {
+  /** Shopify's own cart-permalink URL — a GET that adds the line item and redirects into the cart. */
+  url: string;
+  /** The exact variant the link resolved to, read live off the storefront. */
+  variant: BrixtonVariant;
+  /** The product the variant belongs to. */
+  product: BrixtonProduct;
+}
+
+  /**
+   * Brixton apparel and headwear catalogue — every product, its size/color variants, real prices
+   * and stock — read off the live Shopify storefront, plus a live-validated checkout handoff
+   * link.
+   */
+  interface Unit {
+    /**
+     * Reads the live Brixton catalogue as the storefront publishes it — every product, its handle,
+     * title, vendor, description, tags, images and the per-variant price the storefront is quoting
+     * right now. Returns [] on a transport failure. The catalog page is the line and the parse is
+     * the unit of work.
+     */
+    listBrixtonProducts(opts?: { limit?: number }): Promise<BrixtonProduct[]>;
+
+    /**
+     * Reads one product by its handle — every size/color variant, its exact price and whether that
+     * specific variant is purchasable right now. Takes the handle listBrixtonProducts returns.
+     * THROWS on an unknown handle (the store answers a real 404).
+     */
+    getBrixtonProduct(handle: string): Promise<BrixtonProduct>;
+
+    /**
+     * Resolves a product handle + a variant match (either the exact variant title like "M", or a
+     * substring of it) to a real Shopify cart-permalink URL, validated live against the
+     * storefront. THROWS if the handle is unknown, if no variant matches, if the match is
+     * ambiguous (matches more than one variant), or if the matched variant is not currently
+     * available — the error names the candidate or in-stock options so the caller can retry.
+     */
+    getBrixtonCheckoutLink(handle: string, variantTitleOrOptions: string, opts?: { quantity?: number }): Promise<BrixtonCheckoutLink>;
+  }
+}
+
 declare namespace BowmarkProvider_bykoket {
   // ── KOKET — the unit's own declarations, verbatim ──
 interface KoketProductSummary {
@@ -2831,6 +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 {
@@ -3509,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.
@@ -4288,6 +4612,42 @@ interface EventSourceInquiryContact {
   }
 }
 
+declare namespace BowmarkProvider_evolutionofsmooth {
+  // ── eos Products — the unit's own declarations, verbatim ──
+interface ShadeQuizOption { optionId: string; text: string }
+interface ShadeQuizQuestion { questionPageId: string; questionId: string; title: string; options: ShadeQuizOption[] }
+interface ShadeResult {
+  shadeName: string; price: number; priceFormatted: string;
+  productUrl: string; productId: string; variantId: string; description: string;
+}
+type ShadeQuizAnswerResult =
+  | { done: false; question: ShadeQuizQuestion }
+  | { done: true; result: ShadeResult };
+
+  /**
+   * eos's Dewy Lip Shine Shade Finder quiz (Octane AI) — walks the site's real 5-question quiz
+   * and returns the personalized shade result: name, Shopify product/variant id, price and
+   * product URL, ready for a cart handoff.
+   */
+  interface Unit {
+    /**
+     * Starts eos's Dewy Lip Shine Shade Finder quiz (walking past the site's own unanswerable
+     * intro page automatically) and returns the first real question, with the `quizResponseId`
+     * every following `answerShadeQuizQuestion` call takes.
+     */
+    startShadeQuiz(): Promise<{ quizResponseId: string; question: ShadeQuizQuestion }>;
+
+    /**
+     * Submits one answer (the `questionPageId`/`questionId` from the question just answered, and
+     * the `optionId` of the chosen option) and returns either the next question, or — once all 5
+     * real questions are answered — `{ done: true, result }` with the personalized Dewy Lip Shine
+     * shade: name, Shopify product/variant id, price and product URL. The site's own email-capture
+     * page is skipped automatically.
+     */
+    answerShadeQuizQuestion(quizResponseId: string, questionPageId: string, questionId: string, optionId: string): Promise<ShadeQuizAnswerResult>;
+  }
+}
+
 declare namespace BowmarkProvider_extraspace {
   // ── Extra Space Storage — the unit's own declarations, verbatim ──
 interface ExtraspaceSearchResult {
@@ -4975,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.
@@ -5902,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 {
@@ -6046,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 {
@@ -8415,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 {
@@ -8558,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 {
@@ -9141,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 {
@@ -9461,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 {
@@ -9483,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
@@ -10983,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 {
@@ -11451,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 {
@@ -12928,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.
@@ -13038,6 +13948,68 @@ interface 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 {
@@ -13230,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 {
@@ -14913,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 {
@@ -15661,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 {
@@ -16692,6 +17868,7 @@ 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;
@@ -16702,16 +17879,19 @@ interface BowmarkProviders {
   bluehaven: BowmarkProvider_bluehaven.Unit;
   bmwusa: BowmarkProvider_bmwusa.Unit;
   boydsleep: BowmarkProvider_boydsleep.Unit;
+  brixton: BowmarkProvider_brixton.Unit;
   bykoket: BowmarkProvider_bykoket.Unit;
   cancer: BowmarkProvider_cancer.Unit;
   caraway: BowmarkProvider_caraway.Unit;
   cars: BowmarkProvider_cars.Unit;
+  chantecaille: BowmarkProvider_chantecaille.Unit;
   cheapflights: BowmarkProvider_cheapflights.Unit;
   chriscraft: BowmarkProvider_chriscraft.Unit;
   classichome: BowmarkProvider_classichome.Unit;
   classpass: BowmarkProvider_classpass.Unit;
   cloudflare: BowmarkProvider_cloudflare.Unit;
   cyberpowerpc: BowmarkProvider_cyberpowerpc.Unit;
+  davidsonhomes: BowmarkProvider_davidsonhomes.Unit;
   decked: BowmarkProvider_decked.Unit;
   dice: BowmarkProvider_dice.Unit;
   dickssportinggoods: BowmarkProvider_dickssportinggoods.Unit;
@@ -16720,10 +17900,12 @@ interface BowmarkProviders {
   embroker: BowmarkProvider_embroker.Unit;
   erieinsurance: BowmarkProvider_erieinsurance.Unit;
   eventsource: BowmarkProvider_eventsource.Unit;
+  evolutionofsmooth: BowmarkProvider_evolutionofsmooth.Unit;
   extraspace: BowmarkProvider_extraspace.Unit;
   firstdibs: BowmarkProvider_firstdibs.Unit;
   flightradar24: BowmarkProvider_flightradar24.Unit;
   ford: BowmarkProvider_ford.Unit;
+  fourseasonsyachts: BowmarkProvider_fourseasonsyachts.Unit;
   framebridge: BowmarkProvider_framebridge.Unit;
   fred: BowmarkProvider_fred.Unit;
   geico: BowmarkProvider_geico.Unit;
@@ -16732,8 +17914,10 @@ interface BowmarkProviders {
   grainger: BowmarkProvider_grainger.Unit;
   grandwelcome: BowmarkProvider_grandwelcome.Unit;
   handypro: BowmarkProvider_handypro.Unit;
+  hansons: BowmarkProvider_hansons.Unit;
   harmar: BowmarkProvider_harmar.Unit;
   hauslabs: BowmarkProvider_hauslabs.Unit;
+  haydenhomes: BowmarkProvider_haydenhomes.Unit;
   healthcare_gov: BowmarkProvider_healthcare_gov.Unit;
   hellofresh: BowmarkProvider_hellofresh.Unit;
   hellotend: BowmarkProvider_hellotend.Unit;
@@ -16746,7 +17930,10 @@ interface BowmarkProviders {
   islllc: BowmarkProvider_islllc.Unit;
   jennikayne: BowmarkProvider_jennikayne.Unit;
   joybird: BowmarkProvider_joybird.Unit;
+  joycefactorydirect: BowmarkProvider_joycefactorydirect.Unit;
+  justinwine: BowmarkProvider_justinwine.Unit;
   kayak: BowmarkProvider_kayak.Unit;
+  kingsdown: BowmarkProvider_kingsdown.Unit;
   kitchentuneup: BowmarkProvider_kitchentuneup.Unit;
   kompan: BowmarkProvider_kompan.Unit;
   labcorp: BowmarkProvider_labcorp.Unit;
@@ -16754,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;
@@ -16766,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;
@@ -16778,9 +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;
@@ -16795,6 +17988,8 @@ interface BowmarkProviders {
   teladoc: BowmarkProvider_teladoc.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;
@@ -16805,6 +18000,7 @@ interface BowmarkProviders {
   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;