@bowmark/web 1.4.0 → 1.6.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: 6368edcbec9d9ee7ceb3fd590c7054ade0542a93e43a39f4f88dc6167c0e36da
-// 8 capabilities, 74 providers, 233 typed functions, 20 refused.
-// 51,712 family members, sharing 2 interface(s) — declared once and pointed at, never repeated per member.
+// Manifest version: 5426792a92faf41fd663aa77ef068ec2f38bcc28d33426a6a565458c7a3b4c42
+// 8 capabilities, 95 providers, 316 typed functions, 20 refused.
+// 51,713 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
@@ -959,10 +959,87 @@ interface aaRetrieveBookingArgs {
   lastName: string;
 }
 
+interface aaBaggageAllowanceArgs {
+  /** The country flown FROM — an ISO-3166 alpha-2 code ("US", "GB") or a country
+   * name in any capitalisation. Not an airport code: American publishes bag fees
+   * by region and its regions are lists of countries, and no surface on its
+   * estate resolves an airport to one. */
+  origin: string;
+  /** The country flown TO, same forms. */
+  destination: string;
+}
+
+interface aaBaggageAllowance {
+  origin: aaBaggageEndpoint;
+  destination: aaBaggageEndpoint;
+  /** Which row of American's fee table this trip landed on, and how. */
+  feeRegion: {
+    label: string;
+    matchedOn: "country" | "region" | "region-members";
+    matchedEndpoint: "origin" | "destination";
+  };
+  checkedBagFees: aaCheckedBagFee[];
+  checkedBagLimits: aaCheckedBagLimits;
+  carryOn: aaCarryOnAllowance;
+  freeCheckedBags: aaFreeCheckedBagRule[];
+  /** Null when American's own bag-count rule names neither end of the trip. */
+  maxCheckedBags: number | null;
+  maxCheckedBagsRules: aaMaxCheckedBagsRule[];
+  footnotes: string[];
+  sources: string[];
+}
+
+interface aaBaggageEndpoint {
+  input: string;
+  countryCode: string;
+  countryName: string;
+  /** Null for a country American files under no bag region — Mexico is the live
+   * case, and the fee table names it directly instead. */
+  region: string | null;
+}
+
+interface aaCheckedBagFee {
+  /** "1", "2", "3", "4+". */
+  bag: string;
+  /** The cell verbatim, e.g. "$0 / $85*". */
+  display: string;
+  /** Every dollar figure in the cell, in the order printed. */
+  amountsUsd: number[];
+  footnoteMarkers: string[];
+}
+
+interface aaCheckedBagLimits {
+  maxLinearInches: number | null;
+  maxLinearCm: number | null;
+  maxWeightPounds: number | null;
+  maxWeightKilos: number | null;
+  notes: string[];
+}
+
+interface aaCarryOnAllowance {
+  carryOnBags: number;
+  personalItems: number;
+  carryOnMaxInches: number[];
+  carryOnMaxCm: number[];
+  personalItemMaxInches: number[];
+  personalItemMaxCm: number[];
+}
+
+interface aaFreeCheckedBagRule {
+  bags: number;
+  qualifiers: string[];
+}
+
+interface aaMaxCheckedBagsRule {
+  count: number;
+  applies: string[];
+}
+
   /**
    * American Airlines' own site — its published fares and award availability, flight status,
-   * reservation lookup, seat maps, baggage allowance and fee schedules. Flight status and
-   * reservation lookup are live and browserless; the rest are declared stubs.
+   * reservation lookup, seat maps, baggage allowance and fee schedules. Flight status,
+   * reservation lookup and the published baggage allowance for a route are live and browserless;
+   * the rest are declared stubs.
    */
   interface Unit {
     // UNTYPED, DELIBERATELY OMITTED — `getFlightStatus({ date, flightNumber, origin, destination })` declares no types for
@@ -970,6 +1047,30 @@ interface aaRetrieveBookingArgs {
     // It is CALLABLE at runtime; `bowmark.providers.aa.getFlightStatus` is a compile error here on purpose.
     // A `(...args: unknown[])` stand-in would compile and tell you nothing.
 
+    /**
+     * American Airlines' published baggage allowance and fees for a ROUTE. `origin` and
+     * `destination` are COUNTRIES — an ISO-3166 alpha-2 code ("US", "GB") or a country name
+     * ("United Kingdom"), matched against American's own country list — because American prices
+     * bags by REGION and publishes its regions as lists of countries ("Bag fees are based on these
+     * regions"). An IATA airport code is refused with a message saying so rather than guessed at.
+     * Returns the fee row American's own table lands that trip on (which region, and whether it
+     * matched on the country or its region), the first, second, third and fourth-bag prices with
+     * every dollar figure printed in each cell plus its footnote markers, the checked-bag weight
+     * and size limits (50 lbs / 23 kgs, 62 in / 158 cm at the time of writing, with First/Business
+     * and Australia/New Zealand qualifications in `notes`), the carry-on and personal-item
+     * dimensions, the free-checked-bag entitlements by AAdvantage status, cabin and cardholder
+     * rule, how many bags American will accept on that trip at all, and the table's own footnotes
+     * verbatim. HONEST LIMITS, because they decide what this can be used for: a cell like "$0 /
+     * $85*" is TWO published prices and the footnotes say which of them a given fare and status
+     * pays — this function returns both rather than picking, since American's public pages do not
+     * price an individual ticket and no open surface on aa.com does either. It throws rather than
+     * guess for a trip where neither end is in American's domestic band (every row of the table
+     * describes the other end of such a trip), and for Cuba, which American prices from two
+     * separate direction-of-travel tables this function deliberately does not read as if they were
+     * the same one.
+     */
+    getBaggageAllowance(arg0: aaBaggageAllowanceArgs): Promise<aaBaggageAllowance>;
+
     /**
      * Reads an existing American Airlines reservation by its six-letter record locator (PNR) and
      * the passenger's last name — nothing is signed into, and both are the caller's own details,
@@ -1337,6 +1438,79 @@ interface AshleyFurnitureStore {
   }
 }
 
+declare namespace BowmarkProvider_avis {
+  // ── Avis — the unit's own declarations, verbatim ──
+interface avisRow {
+  id: string;
+}
+
+interface AvisLocationRow {
+  mnemonic: string;
+  name: string;
+  group: string;
+  address: {
+    line1: string;
+    line2: string | null;
+    city: string;
+    stateCode: string | null;
+    postalCode: string | null;
+    countryCode: string | null;
+    countryName: string | null;
+  };
+  phone: string | null;
+  latitude: number | null;
+  longitude: number | null;
+  drivableDistanceMiles: number | null;
+  is24hoursDropOffAvailable: boolean;
+  isKeyDropLocation: boolean;
+  relPath: string | null;
+}
+
+interface AvisLocationDetail extends AvisLocationRow {
+  hoursOfOperation: {
+    dayOfWeek: number;
+    day: "SUNDAY" | "MONDAY" | "TUESDAY" | "WEDNESDAY" | "THURSDAY" | "FRIDAY" | "SATURDAY";
+    intervals: { openMinute: number; closeMinute: number }[];
+    isClosed: boolean;
+  }[];
+  holidays: { scheduleName: string; date: string }[];
+  associatedLocation: { mnemonic: string | null; name: string | null } | null;
+  isCorporate: boolean;
+  isSelfServiceKiosk: boolean;
+  isFreePickup: boolean;
+  isTruck: boolean;
+  isAvisFirstLocation: boolean;
+  maxLengthOfRental: number | null;
+  locationVehicleCategory: string | null;
+}
+
+  /**
+   * Car rental — availability search, existing-reservation lookup and location directory on
+   * avis.com. searchLocations and getLocation are live; the rest are stubs.
+   */
+  interface Unit {
+    /**
+     * Finds Avis rental locations matching a full city name or an airport code (`query`, e.g.
+     * "Chicago" or "ORD" — an exact token match, not a substring or address search) off the site's
+     * own location-search API, optionally narrowed to one US state (`stateCode`). Returns each
+     * match's station code, display name, site grouping (airport, neighbourhood, city dock, …),
+     * address, phone and coordinates. Empty array on no match, never an error.
+     */
+    searchLocations(args: object): Promise<AvisLocationRow[]>;
+
+    /**
+     * Reads one Avis rental location in full off the site's own location-search API for a station
+     * code (`mnemonic`, e.g. "ORD"). For an airport code, `cityName` is optional and the mnemonic
+     * itself is used; for a non-airport mnemonic the caller must pass the city from a prior
+     * `searchLocations` row. Returns the row's address, phone, latitude/longitude, opening hours
+     * per day (with split shifts that wrap midnight), the holiday schedule, the after-hours
+     * sibling (`associatedLocation`), and the full set of service flags (24h drop-off, key drop,
+     * self-service kiosk, corporate, free pickup, truck, Avis First).
+     */
+    getLocation(args: object): Promise<AvisLocationDetail>;
+  }
+}
+
 declare namespace BowmarkProvider_azure {
   // ── Microsoft Azure — the unit's own declarations, verbatim ──
 interface AzurePriceRow {
@@ -1684,6 +1858,57 @@ interface BlendersEyewearPriceResult {
   }
 }
 
+declare namespace BowmarkProvider_bluehaven {
+  // ── Blue Haven Pools & Spas — the unit's own declarations, verbatim ──
+interface BluehavenPoolDesign {
+  id: number;
+  name: string;
+  category: string;
+  subCategory: string | null;
+}
+
+interface BluehavenSiteFeasibility {
+  matchedAddress: string;
+  coordinates: { lat: number; lng: number };
+  apn: string | null;
+  ownerName: string | null;
+  lotAreaSqFt: number | null;
+  existingStructures: unknown[];
+  nearbyUtilityLines: { name: string; features: unknown[] }[];
+  warnings: string[];
+}
+
+  /**
+   * Blue Haven Pools & Spas' own Canibuild site-planning widget — sited lot feasibility for a
+   * real US address (parcel area, existing structures, nearby utility lines) and their live
+   * inground pool design catalog.
+   */
+  interface Unit {
+    /**
+     * Reads Blue Haven's own live inground pool design catalog off their site-planning widget's
+     * API — every design set (e.g. Oasis, Omega, Oval, Pacific, Rectangle) under every
+     * category/subcategory they currently sell (Pool Studios, Blue Haven Pools, Freeform Pools).
+     * Real catalog data, not a marketing page scrape.
+     */
+    listPoolDesigns(): Promise<BluehavenPoolDesign[]>;
+
+    /**
+     * Runs a US street address through Blue Haven's own site-planning tool the way their homepage
+     * widget does — resolves the address, then reads back the parcel's own lot area, APN/owner
+     * (when on file), any structures the site already has recorded on that parcel, and
+     * utility-line hazards (electrical, oil/gas) near it. This is the address-SITED data ChatGPT's
+     * own knowledge cannot produce (confirmed in this packet's ANGLE fit-check: asked to site a
+     * pool at a real address, it asked the user to upload yard photos or offered a rough satellite
+     * guess, and quoted a national price range instead of anything tied to the parcel). Only
+     * addresses that resolve through Blue Haven's own parcel index carry sited data (most US
+     * residential/commercial street addresses do); a handful of well-known landmark addresses
+     * resolve only to a generic map pin and throw `BluehavenBadRequest`, same as an address with
+     * no match at all.
+     */
+    checkPoolSiteFeasibility(args: { address: string }): Promise<BluehavenSiteFeasibility>;
+  }
+}
+
 declare namespace BowmarkProvider_bmwusa {
   // ── BMW USA — the unit's own declarations, verbatim ──
 interface BmwusaBuiltVehicleOption {
@@ -1740,6 +1965,84 @@ interface BmwusaCpoSearchOptions {
   maxOdometer?: number;
 }
 
+interface BmwusaModelTrim {
+  name: string;
+  modelCode: string | null;
+  zeroToSixty: number | null;
+  horsepower: number | null;
+  startingMsrp: number | null;
+  engineType: string | null;
+  drivetrain: string | null;
+  transmission: string | null;
+  fuelType: string | null;
+  fuelEfficiency: { city: number | null; highway: number | null; combined: number | null; unit: string } | null;
+  seatingCapacity: number | null;
+}
+
+interface BmwusaModel {
+  name: string;
+  series: string;
+  url: string;
+  trims: BmwusaModelTrim[];
+}
+
+interface BmwusaOfferTier {
+  apr: number;
+  months: number;
+}
+
+interface BmwusaLeaseOffer {
+  code: string;
+  description: string;
+  monthlyPayment: number;
+  term: number;
+  msrp: number;
+  downPayment: number;
+  acquisitionFee: number;
+  dueAtSigningExceptNy: number | null;
+  loyaltyCredit: number | null;
+  dealerContribution: string | null;
+  allowedMiles: number | null;
+  chargePerExcessMile: number | null;
+  endOfTermPurchaseOption: number | null;
+  startDate: string;
+  endDate: string;
+}
+
+interface BmwusaFinanceOffer {
+  code: string;
+  description: string;
+  tiers: BmwusaOfferTier[];
+  loyaltyCredit: number | null;
+  startDate: string;
+  endDate: string;
+}
+
+interface BmwusaOffer {
+  modelCode: string;
+  modelName: string;
+  series: string;
+  bodyStyle: string;
+  msrp: number;
+  lease: BmwusaLeaseOffer | null;
+  finance: BmwusaFinanceOffer | null;
+}
+
+interface BmwusaOffersResult {
+  region: string;
+  offers: BmwusaOffer[];
+}
+
+interface BmwusaModelListing {
+  name: string;
+  url: string;
+  bodyStyle: string | null;
+  powertrain: "electric" | "plugInHybrid" | "performance" | "gasoline" | null;
+  msrpFrom: number | null;
+  msrpTo: number | null;
+  trimCount: number;
+}
+
   /**
    * BMW US car shopping: the Build Your Own configurator and its option pricing, live VIN-level
    * new and Certified Pre-Owned dealer inventory near a ZIP, the model lineup with trims and
@@ -1766,6 +2069,102 @@ interface BmwusaCpoSearchOptions {
      * buckets, not raw numbers, so this filters honestly rather than guessing bucket boundaries).
      */
     searchCertifiedPreOwned(zip: string, options?: { radius?: number; limit?: number; model?: string; minYear?: number; maxYear?: number; maxPrice?: number; maxOdometer?: number }): Promise<BmwusaCpoVehicle[]>;
+
+    /**
+     * Reads one BMW model's body-style page (path is the segment of the site's own
+     * /vehicles/...html URL, e.g. 'x-models/x5', '2-series/coupe' — read off bmwusa.com's own
+     * navigation or sitemap.xml) and returns its series, model name, and every trim BMW currently
+     * sells on that page: each trim's own name, its build-your-own model code (the same code
+     * buildVehicle takes), 0-60 time, horsepower, starting MSRP (null when the site shows '--' —
+     * not yet published), engine type, drivetrain, transmission, fuel type, fuel efficiency (MPG
+     * or MPGe) and seating capacity.
+     */
+    getModel(path: string): Promise<BmwusaModel>;
+
+    /**
+     * Lists BMW's current US lease and finance offers for a 5-digit ZIP code (resolved server-side
+     * to a sales region, since the site's own offer objects carry per-region eligibility) — every
+     * model with an active offer, each with its own lease (monthly payment, term, MSRP, down
+     * payment, due-at-signing, allowed miles, loyalty credit) and/or finance (APR tiers, loyalty
+     * credit) terms, exactly as bmwusa.com's own /special-offers.html widget resolves them.
+     */
+    listOffers(zip: string): Promise<BmwusaOffersResult>;
+
+    /**
+     * Lists BMW's current US lineup — every model BMW sells, with its bmwusa.com model-overview
+     * URL, body style, powertrain category (electric / plug-in hybrid / performance / gasoline)
+     * and starting MSRP band — so an agent can resolve a person's vague 'a BMW SUV under $60k'
+     * into the specific models that exist, with their real prices, before looking up any one of
+     * them. Reads /all-bmws.html for the 49-card catalog, then fans out (concurrency 5) to each
+     * model-overview page for MSRP; pages with no trim table (BMW iX, certain M models) still
+     * appear in the result with null MSRPs and null body style rather than dropping the model.
+     */
+    listModels(): Promise<BmwusaModelListing[]>;
+  }
+}
+
+declare namespace BowmarkProvider_bykoket {
+  // ── KOKET — the unit's own declarations, verbatim ──
+interface KoketProductSummary {
+  id: string;
+  name: string;
+  url: string;
+  price: number;
+  currency: string;
+  inStock: boolean;
+}
+
+interface KoketProduct {
+  id: string;
+  name: string;
+  url: string;
+  reference: string;
+  price: number;
+  priceFormatted: string;
+  listPrice: number;
+  onSale: boolean;
+  currency: string;
+  inStock: boolean;
+  quantityLeft: number | null;
+  availabilityMessage: string;
+  description: string;
+  images: string[];
+}
+
+interface KoketAddToCartHandoff {
+  id: string;
+  name: string;
+  url: string;
+  price: number;
+  currency: string;
+  inStock: boolean;
+  note: string;
+}
+
+  /**
+   * Reads KOKET's public furniture, lighting and textiles storefront (bykoket.com/shop) — search
+   * the catalog, read a product's live price, stock and description, and get the handoff to add
+   * it to cart on the real site.
+   */
+  interface Unit {
+    /**
+     * Searches KOKET's live public catalog (furniture, lighting, textiles) and returns each
+     * match's id, name, product URL, price and stock status.
+     */
+    searchProducts(query: string): Promise<KoketProductSummary[]>;
+
+    /**
+     * Reads one KOKET product's live page — price (list and current, since KOKET runs promotions),
+     * stock count, availability message, description and images.
+     */
+    getProduct(idOrUrl: string): Promise<KoketProduct>;
+
+    /**
+     * Hands back the shopper's own KOKET product page — the exact Add to cart button for this
+     * product — since the site's cart requires a per-session token nobody but the shopper can
+     * supply. Writes nothing.
+     */
+    addToCart(idOrUrl: string): Promise<KoketAddToCartHandoff>;
   }
 }
 
@@ -1803,12 +2202,38 @@ interface cancerCentersResult {
   centers: cancerCenterRow[];
 }
 
+type cancerInfoAudience = "patient" | "healthProfessional";
+
+interface cancerInfoSection {
+  /** The PDQ document's own heading, verbatim, e.g. "Stage Information for
+   * Breast Cancer". */
+  heading: string;
+  /** The section's own text, whitespace-normalized. */
+  text: string;
+}
+
+interface cancerInfoSummaryResult {
+  topic: string;
+  audience: cancerInfoAudience;
+  /** The PDQ document's own title, verbatim. */
+  title: string;
+  /** The summary's own page on cancer.gov. */
+  url: string;
+  /** ISO 8601 — the PDQ Editorial Board's own "Updated" date for this exact
+   * document. PDQ is a living, continuously revised document; there is no
+   * honest way to use this text without it. */
+  revisionDate: string;
+  sections: cancerInfoSection[];
+}
+
   /**
    * The US National Cancer Institute: PDQ cancer information, the clinical-trial register,
-   * cancer drugs, NCI-designated cancer centers and the cancer dictionaries. The NCI-Designated
-   * Cancer Center directory (`findCancerCenters`) is callable now — every center's name,
-   * designation type, location and host institution, optionally filtered by state; the other
-   * twelve declared functions are still stubs.
+   * cancer drugs, NCI-designated cancer centers and the cancer dictionaries. Callable now: the
+   * NCI-Designated Cancer Center directory (`findCancerCenters`) — every center's name,
+   * designation type, location and host institution, optionally filtered by state — and
+   * `getCancerInfoSummary` — NCI's own PDQ information summary for a cancer topic, patient or
+   * health-professional version, with its own revision date. The other eleven declared functions
+   * are still stubs.
    */
   interface Unit {
     /**
@@ -1824,6 +2249,121 @@ interface cancerCentersResult {
      * — so `total` and `centers.length` are always equal.
      */
     findCancerCenters(args?: { state?: string }): Promise<cancerCentersResult>;
+
+    /**
+     * NCI's own PDQ information summary for one cancer topic — what the cancer is, its symptoms
+     * and risk factors, how it is diagnosed and staged, the treatment options by stage, and the
+     * prognosis — split into the site's own headed sections, each with its heading and text.
+     * `topic` is cancer.gov's own `/types` path segment (e.g. "breast", "lung", "prostate").
+     * `audience` (default `"patient"`) selects the patient-facing version or the more technical
+     * health-professional one NCI maintains separately; both carry the same `document-dates`
+     * revision block when the topic publishes one. `revisionDate` (ISO 8601) is the PDQ Editorial
+     * Board's own "Updated" date for the exact document returned — PDQ is continuously revised, so
+     * this is not decoration. English only: the Spanish path for the same topic uses different
+     * words, not a parameter substitution on the English slug (breast's HP Spanish page is
+     * `/espanol/tipos/seno/pro/tratamiento-seno-pdq`, not a `breast`/`hp` swap), and reaching it
+     * needs its own resolver over the Spanish `/espanol/tipos` index — unbuilt. Two ways this
+     * throws instead of guessing: `CancerInfoSummaryNotPublishedError` when the topic+audience has
+     * no single consolidated document (NCI is mid-redesign — breast's patient content was migrated
+     * to a task-based hub with no one document or date; its health-professional content is
+     * unaffected), and `CancerInfoSummaryAmbiguousTopicError` when the topic's own index entry
+     * covers more than one genuinely distinct disease, each with its own summary (lung:
+     * non-small-cell and small-cell are both filed under `/types/lung`) — the error names every
+     * option's own URL rather than silently answering for the wrong one.
+     */
+    getCancerInfoSummary(args: { topic: string; audience?: "patient" | "healthProfessional" }): Promise<cancerInfoSummaryResult>;
+  }
+}
+
+declare namespace BowmarkProvider_caraway {
+  // ── Caraway Home — the unit's own declarations, verbatim ──
+interface CarawayVariant {
+  /** Shopify's numeric variant id as a string. */
+  id: string;
+  /** The variant's own label, e.g. "Cream" or "Default Title". */
+  title: string;
+  /** String verbatim from the storefront — "50.00" (dollars) on /products.json, "44500" (cents) on /products/<h>.js. */
+  price: string;
+  /** Same scale as price. Null when the product is not on sale. */
+  compareAtPrice: string | null;
+  /** The store's own SKU. Null on a product without one. */
+  sku: string | null;
+  /** Whether the variant is purchasable right now. */
+  available: boolean;
+  options: string[];
+}
+interface CarawayProduct {
+  /** 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: CarawayVariant[];
+  /** Same scale as variants — see CarawayVariant.price. */
+  priceRange: { min: string; max: string } | null;
+  /** True if ANY variant is purchasable. */
+  inStock: boolean;
+  tags: string[];
+  /** Caraway's own images, in the order the storefront publishes them. */
+  images: string[];
+}
+interface CarawayCatalogue {
+  /** All matching products, in-stock first, then by handle. */
+  products: CarawayProduct[];
+  /** What the filter DROPPED, in the same register the rest of the library uses. */
+  warnings: string[];
+}
+interface CarawayQuizArchetype {
+  /** The archetype slug (e.g. new-customer, 90s-baby). */
+  slug: string;
+  /** Caraway's own copy for the archetype. */
+  label: string;
+  /** Caraway's own one-line archetype blurb. */
+  description: string;
+  /** The product handles the quiz route marks as Recommended. */
+  recommendedHandles: string[];
+}
+interface CarawayQuizResult {
+  /** The archetype the quiz terminal page lands on, with the site copy. */
+  archetype: CarawayQuizArchetype;
+  /** The Recommended rail, in stock first. */
+  recommended: CarawayProduct[];
+  /** What the resolver DROPPED, in the same register the rest of the library uses. */
+  warnings: string[];
+}
+
+  /**
+   * Caraway Home product catalogue — every ceramic cookware piece, its variants, real prices and
+   * stock — read off the live Shopify storefront, plus the buyer-archetype rail the Caraway Home
+   * Quiz terminal renders.
+   */
+  interface Unit {
+    /**
+     * Reads the live Caraway catalogue as Caraway 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.
+     */
+    listCarawayProducts(opts?: { limit?: number }): Promise<CarawayProduct[]>;
+
+    /**
+     * Reads one product by its handle — every variant, its exact price, the image the storefront
+     * is showing and whether that specific variant is purchasable right now. Takes the handle
+     * listCarawayProducts returns. THROWS on an unknown handle (the store answers a real 404).
+     */
+    getCarawayProduct(handle: string): Promise<CarawayProduct>;
+
+    /**
+     * Routes a quiz's buyer-fit answers to a Caraway archetype and resolves the Recommended rail
+     * the quiz terminal page renders. The archetype slug comes from the quiz's terminal URL
+     * (new-customer, 90s-baby, etc.) and the rail is the live catalogue filtered to the products
+     * Caraway marks for that buyer. THROWS on an unknown archetype — the supported set is encoded
+     * inside the function and surfaced via the same module that owns the catalogue.
+     */
+    runCarawayQuiz(answers: { archetype: string }): Promise<CarawayQuizResult>;
   }
 }
 
@@ -1847,6 +2387,15 @@ interface carsListing {
   hotCar: boolean | null;
   dealer: { name: string | null; status: string | null } | null;
 }
+interface carsSearch {
+  appliedFilters: { filter: string; value: string | null }[];
+  totalListings: number;
+  totalPages: number;
+  page: number;
+  pageSize: number;
+  sort: string | null;
+  listingIds: string[];
+}
 interface carsModelResearch {
   year: number;
   make: string;
@@ -1862,14 +2411,41 @@ interface carsModelResearch {
   expertReview: { headline: string; pros: string[]; cons: string[] } | null;
   whatsNew: string | null;
 }
+interface QuoteIdentity {
+  firstName: string;
+  lastName: string;
+  dob: string;
+  email: string;
+  phone: string;
+}
+interface carsVehicleValue {
+  offerCode: string;
+  dealer: { name: string | null; zipCode: string | null } | null;
+  tradeInOffer: number | null;
+  privatePartyValue: number | null;
+  marketLabel: string | null;
+  mileageUsed: number | null;
+  warnings: string[];
+}
 
   /**
    * Cars.com — the US new/used/certified car marketplace: for-sale inventory with dealer asking
    * prices, one listing's full detail, a valuation for a car you already own, and per-model
-   * research (trims, specs, expert and owner reviews). Two functions are built: reading a single
-   * listing in full by its id, and one model year's research overview.
+   * research (trims, specs, expert and owner reviews). Three functions are built: searching the
+   * inventory, reading one listing in full, and reading one year/make/model's research overview.
+   * A fourth — the cash-offer valuation — is built too: callers pass a VIN, a ZIP, and the
+   * caller-supplied identity the 2026-07-31 quote-flow ruling requires, and the function returns
+   * the trade-in offer and private-party value perseus published for the assigned local dealer.
    */
   interface Unit {
+    /**
+     * Searches Cars.com's live for-sale inventory the way its own shopping results page does — by
+     * ZIP and radius, new / used / certified-pre-owned, make, model, price, mileage — and returns
+     * the matching listing ids (each one is a getListing argument verbatim), the total match count
+     * across all pages, and the filter set the service actually applied.
+     */
+    search(args: { zipCode?: string; radiusMiles?: number; stockType?: 'new' | 'used' | 'cpo'; make?: string; model?: string; maxPrice?: string; minPrice?: string; maxMileage?: string; page?: number; pageSize?: number; sort?: string }): Promise<carsSearch>;
+
     /**
      * Reads one cars.com listing in full by its id (the uuid in a /vehicledetail/<id>/ url): VIN,
      * asking price, mileage, year/make/model, stock number, CPO status, EPA highway mpg, the
@@ -1884,6 +2460,17 @@ interface carsModelResearch {
      * year — null/absent exactly where cars.com's own page shows nothing for it.
      */
     getModelResearch(args: { make: string; model: string; year: number }): Promise<carsModelResearch>;
+
+    /**
+     * Reads Cars.com's own cash-offer valuation for a car the caller already owns: the trade-in
+     * offer and the private-party value perseus computed for the dealer's assigned ZIP, with the
+     * dealer and mileage the offer was scoped to. Identity is required (caller-supplied, per the
+     * 2026-07-31 quote-flow ruling) so perseus has a person to assign the offer record to. The
+     * function NEVER calls contactDealer, optinDealer, acceptByCode, smsPictureRequest or
+     * media.create — the contact routes the 2026-08-06 standing decision names as the fence for a
+     * cash-offer appraisal.
+     */
+    getVehicleValue(args: { vin: string; identity: QuoteIdentity; postalCode: string; mileage?: number }): Promise<carsVehicleValue>;
   }
 }
 
@@ -2232,6 +2819,32 @@ interface ClasspassScheduleOptions {
   days?: number;
 }
 
+interface ClasspassSearchQuery {
+  /** Centre of the search, decimal degrees. */
+  lat: number;
+  lon: number;
+  /** Search radius (default 1, clamped to 1-50). */
+  radius: number;
+  /** "mi" (default) or "km". */
+  radiusUnits?: "mi" | "km";
+  /** First day, YYYY-MM-DD. Defaults to TODAY (UTC date). */
+  date?: string;
+  /** Opaque page token from a previous result's `cursor`. */
+  cursor?: string;
+}
+
+interface ClasspassSearchResult {
+  results: ClasspassVenue[];
+  /** Opaque page token. Pass back as `query.cursor`; null when the last page is reached. */
+  cursor: string | null;
+  /** The origin's own session id — stable across pages of one search. */
+  searchId: string;
+  /** Always null: the origin does not publish a total. */
+  totalHits: number | null;
+  /** What this function did to the caller's query (defaults applied). */
+  warnings: string[];
+}
+
   /**
    * ClassPass — fitness, wellness and beauty classes across gyms, studios, spas and salons.
    * `getStudio` reads one studio's whole profile in a single request: what it does, where it is,
@@ -2241,6 +2854,28 @@ interface ClasspassScheduleOptions {
    * search, per-slot availability and membership pricing are declared but not built yet.
    */
   interface Unit {
+    /**
+     * ClassPass's own location search — POST lat/lon/radius and read back the venues in range,
+     * with their identity, address, coordinates, IANA time zone, the activities the venue teaches,
+     * amenities, ratings, distance and the practical details a person needs to decide which to
+     * open. `query.lat` and `query.lon` are required (decimal degrees, finite, in range);
+     * `query.radius` defaults to 1 and is clamped to 1-50; `query.radiusUnits` is `mi` (default)
+     * or `km`; `query.date` is `YYYY-MM-DD` and defaults to TODAY (UTC). Pagination: the response
+     * carries `cursor` (the base64 page token) and `searchId`; pass `cursor` back verbatim as
+     * `query.cursor` on the next call — the body's shape is identical. One call returns up to 50
+     * venues; the origin does not publish a total count, so `totalHits` is always `null` and the
+     * caller pages until `cursor` is also null. Returns `warnings` whenever the function did
+     * anything to the caller's query (radius defaulted, date defaulted) so a caller rendering the
+     * result knows exactly what shape their input landed in. Each venue block carries `activities`
+     * populated (the search response's `schedules[].venue.activities` is a comma-joined string the
+     * parser splits), which `getSchedule`'s venue block does NOT have on a day the studio
+     * publishes nothing — a real difference, not an inconsistency. **`query` shape today:** only
+     * lat/lon/radius/radiusUnits/date/cursor are honored. The help center's rich facets (text
+     * search, activity filter, time-of-day, credit-price band, neighbourhood) are DECLARED on
+     * `search` but NOT WIRED — see manifest `notImplemented`.
+     */
+    search(query: ClasspassSearchQuery): Promise<ClasspassSearchResult>;
+
     /**
      * Reads ONE ClassPass studio's whole profile in a single request — the page a person reads to
      * decide whether a result is worth booking. `studio` is a ClassPass venue id (74359), the
@@ -2378,33 +3013,103 @@ interface CloudflareSearchDomainAvailabilityResult {
   }
 }
 
-declare namespace BowmarkProvider_decked {
-  // ── DECKED — the unit's own declarations, verbatim ──
-// DECKED's OWN shapes — not a capability contract.
-
-type DeckedCabSideOption = "Cab-side Gap" | "Load Floor";
-
-interface DeckedFit {
-  vehicleClass: string;       // the site's own product handle, e.g. "drawers-fullsize"
-  vehicleClassTitle: string;
-  model: string;               // e.g. "Ford F150 (2004-2014)"
-  fitOption: string | null;    // a bed length or wheel base — null for a class with only "Model" (SUV, Service Body)
-  sku: string;
-  price: number;
-  priceFormatted: string;
-  available: boolean;
-  url: string;                 // the class's product page, preselecting this exact variant
-}
-
-interface DeckedVehicleClass {
-  handle: string;
-  title: string;
+declare namespace BowmarkProvider_cyberpowerpc {
+  // ── CyberPowerPC — the unit's own declarations, verbatim ──
+interface CyberpowerpcConfigurator {
+  slug: string;
+  name: string;
   url: string;
-  secondOption: string | null; // "Bed Length" | "Wheel Base" | null
-  fits: DeckedFit[];
+  price: string | null;
+  priceValue: number | null;
+  listPrice: string | null;
+  listPriceValue: number | null;
+  baselineSpecs: string[];
 }
-
-interface DeckedFitmentResult {
+interface CyberpowerpcOption {
+  id: string;
+  name: string;
+  sku: string | null;
+  priceDifference: number;
+  isDefault: boolean;
+}
+interface CyberpowerpcSection {
+  code: string;
+  label: string;
+  category: "Core Components" | "Accessories" | "Software & Service";
+  required: boolean;
+  defaultOptionId: string | null;
+  options: CyberpowerpcOption[];
+}
+interface CyberpowerpcCatalog {
+  slug: string;
+  title: string;
+  basePrice: number;
+  sections: CyberpowerpcSection[];
+}
+interface CyberpowerpcPriceResult {
+  slug: string;
+  basePrice: number;
+  totalPrice: number;
+  lines: { sectionCode: string; sectionLabel: string; optionId: string; optionName: string; priceDifference: number }[];
+}
+
+  /**
+   * Reads and prices CyberPowerPC's real gaming-PC configurators — every component, every
+   * option's exact price.
+   */
+  interface Unit {
+    /**
+     * Lists every base gaming-PC configurator CyberPowerPC currently sells — AMD and Intel,
+     * Mainstream through Extreme — with its slug, current starting price, list price and stock
+     * CPU/GPU/memory/motherboard/storage lines. Takes nothing. The slug it returns is what
+     * getConfigurator and priceBuild take.
+     */
+    listConfigurators(): Promise<CyberpowerpcConfigurator[]>;
+
+    /**
+     * Reads one base configurator's whole component tree — every section (CPU, GPU, memory,
+     * chassis, storage, ...), every option's exact label, SKU and signed price difference versus
+     * that section's default. The section codes and option ids it returns are what priceBuild
+     * takes.
+     */
+    getConfigurator(slug: string): Promise<CyberpowerpcCatalog>;
+
+    /**
+     * Prices an exact build for one configurator given a caller's part selections (one option id
+     * per section code; any section left out uses its own default). Returns the real live total
+     * the site's own configurator computes, plus a per-section breakdown of what each pick added.
+     */
+    priceBuild(slug: string, selections: Record<string, string>): Promise<CyberpowerpcPriceResult>;
+  }
+}
+
+declare namespace BowmarkProvider_decked {
+  // ── DECKED — the unit's own declarations, verbatim ──
+// DECKED's OWN shapes — not a capability contract.
+
+type DeckedCabSideOption = "Cab-side Gap" | "Load Floor";
+
+interface DeckedFit {
+  vehicleClass: string;       // the site's own product handle, e.g. "drawers-fullsize"
+  vehicleClassTitle: string;
+  model: string;               // e.g. "Ford F150 (2004-2014)"
+  fitOption: string | null;    // a bed length or wheel base — null for a class with only "Model" (SUV, Service Body)
+  sku: string;
+  price: number;
+  priceFormatted: string;
+  available: boolean;
+  url: string;                 // the class's product page, preselecting this exact variant
+}
+
+interface DeckedVehicleClass {
+  handle: string;
+  title: string;
+  url: string;
+  secondOption: string | null; // "Bed Length" | "Wheel Base" | null
+  fits: DeckedFit[];
+}
+
+interface DeckedFitmentResult {
   query: string;
   bedLength: string | null;
   matched: boolean;
@@ -2474,6 +3179,34 @@ interface DeckedCabSideOptionResult {
   }
 }
 
+declare namespace BowmarkProvider_dice {
+  // ── Dice — the unit's own declarations, verbatim ──
+interface DiceJobDetails {
+  jobId: string;
+  description: string;
+  skills: string[];
+  warnings: string[];
+}
+interface diceRow {
+  id: string;
+}
+
+  /**
+   * Dice — the US technology-only job board. Reaches each posting's full description and skill
+   * list through Dice's own keyless MCP server at mcp.dice.com/mcp; declares tech-job search,
+   * posting-detail reads, employer profiles and a company's open roles.
+   */
+  interface Unit {
+    /**
+     * Returns one Dice posting in full — the HTML description (the same document the consumer page
+     * renders) and the normalized skills array — by the job id `searchJobs` returns. THROWS on a
+     * missing id, on a non-existent posting (MCP returns isError), and on a transport failure, so
+     * a caller can distinguish "no such job" from "empty result set".
+     */
+    getJob(jobId: string): Promise<DiceJobDetails>;
+  }
+}
+
 declare namespace BowmarkProvider_dickssportinggoods {
   // ── DICK'S Sporting Goods — the unit's own declarations, verbatim ──
 interface dickssportinggoodsDayHours {
@@ -2655,6 +3388,28 @@ interface dillardsProduct {
   variants: dillardsProductVariant[];
 }
 
+interface dillardsStoreRow {
+  storeNumber: string;
+  name: string;
+  address1: string | null;
+  address2: string | null;
+  city: string;
+  state: string;
+  stateCode: string;
+  zip: string;
+  phone: string;
+  url: string;
+  latitude: number | null;
+  longitude: number | null;
+}
+
+interface dillardsFindStoresQuery {
+  state?: string;
+  city?: string;
+  zip?: string;
+  limit?: number;
+}
+
   /**
    * Dillard's department store catalog, store-level stock, store locator and wedding/gift
    * registry search.
@@ -2735,6 +3490,23 @@ interface dillardsProduct {
      * through to its item page rather than handing back an unusable list.
      */
     searchRegistry(query: dillardsRegistrySearchQuery): Promise<dillardsRegistry[]>;
+
+    /**
+     * Finds nearby Dillard's store locations the way the site's own /stores locator does — every
+     * row carrying its `storeNumber` (the 4-digit id `checkStock` accepts as its `store`
+     * argument), mall/anchor `name`, `address1`/`address2`, `city`, full `state` and 2-letter
+     * `stateCode`, 5-digit `zip`, 10-digit `phone`, the per-store detail `url`, and the site's own
+     * `latitude`/`longitude` (null when the row omits either). Pass AT LEAST ONE of `state` (full
+     * name like "Ohio" or 2-letter code like "OH" — an unknown state THROWS, naming the 30 the
+     * site publishes), `city` (exact, case-insensitive match against the site's own `city` field —
+     * a name that does not match returns `[]`), or `zip` (5-digit US ZIP, exact match — the site
+     * publishes one store per ZIP today, so this is "the store at this ZIP" without needing a
+     * centroid lookup). Multiple filters narrow; a `state`+`city` request is a per-state page plus
+     * a client-side city filter. Pass `limit` to trim. A query with no filters THROWS, naming
+     * every one the site supports — an empty-argument call would otherwise hand back the full
+     * 272-store list with no way to tell whether that was what the caller meant.
+     */
+    findStores(query: dillardsFindStoresQuery): Promise<dillardsStoreRow[]>;
   }
 }
 
@@ -2751,6 +3523,21 @@ type DiscounttireLocation =
   | { zip: string }
   | { latitude: number; longitude: number };
 
+/** One tire or wheel, as the site's own product read returns it. Price is
+ *  global across stores (verified at three AZ stores on the same sku on the
+ *  same day, 2026-08-07), so `getProduct` takes no storeCode even though
+ *  productByCode itself requires one. */
+interface DiscounttireProduct {
+  code: string;
+  name: string | null;
+  brand: string | null;
+  size: string | null;
+  productType: string | null;
+  url: string | null;
+  price: { value: number | null; formatted: string | null } | null;
+  source: string;
+}
+
 interface DiscounttireStoreRef {
   code: string;
   name: string | null;
@@ -2806,14 +3593,68 @@ interface DiscounttireStock {
   source: string;
 }
 
+/** A tire size stamped on the sidewall — `225/45R17`. Strings, because the
+ *  site's schema declares every field as `String!`. */
+type TireSize = {
+  diameter: string;
+  width: string;
+  aspectRatio: string;
+};
+
+/** One tire product row from the size search. Same shape the site's own
+ *  `getProduct` reads back, except price + sku + name + brand, plus the
+ *  site's own star rating. */
+interface DiscounttireTireResult {
+  code: string;
+  name: string | null;
+  brand: string | null;
+  size: string | null;
+  productType: string | null;
+  url: string | null;
+  price: { value: number | null; formatted: string | null } | null;
+  /** `0.0`-`5.0`; null when the line has no reviews. */
+  averageRating: number | null;
+}
+
+/** What `searchTiresBySize` returns. */
+interface DiscounttireTireSizeSearch {
+  /** The storeCode the operation was anchored to (a zip resolves to the
+   *  site's nearest store). */
+  storeCode: string;
+  pagination: {
+    currentPage: number | null;
+    numberOfPages: number | null;
+    pageSize: number | null;
+    totalNumberOfResults: number | null;
+  };
+  /** The site's facet names — `Brands`, `Aspect Ratio`, `Price Range`, … */
+  facets: string[];
+  results: DiscounttireTireResult[];
+  source: string;
+}
+
   /**
    * America's largest independent tire and wheel retailer — which tires and wheels actually fit
    * a given vehicle, what they cost, whether they are in stock near a ZIP, when a store can
-   * install them, and the rebates running on them. One function is built: `checkStock` answers
-   * whether a specific tire or wheel is gettable near a ZIP, store or coordinate, and on what
-   * date. The other fourteen are declared stubs.
+   * install them, and the rebates running on them. Three functions are built: `getProduct` reads
+   * one tire or wheel by its sku (name, brand, size, product type, price, product URL),
+   * `checkStock` answers whether a specific tire or wheel is gettable near a ZIP, store or
+   * coordinate, and on what date, and `searchTiresBySize` searches the tires Discount Tire sells
+   * in a given size (or staggered pair) with prices, ratings and the site's pagination. The
+   * other twelve are declared stubs.
    */
   interface Unit {
+    /**
+     * Reads one tire or wheel product by its sku — name, brand, size, product type, product URL,
+     * and price (value and formatted string). Takes the numeric sku the site's product URLs end in
+     * (/p/<code>), or such a URL. Price is global across stores (verified at three AZ stores on
+     * the same sku on the same day, 2026-08-07), so this function takes no storeCode even though
+     * the underlying `productByCode` operation requires one — the requirement is a schema
+     * compliance constraint, not a per-caller choice. Throws on the site's all-null not-found row,
+     * so a delisted sku surfaces as an error rather than as a row whose every field is null.
+     */
+    getProduct(idOrUrl: string): Promise<DiscounttireProduct>;
+
     /**
      * Answers whether one specific tire or wheel is actually gettable near a place, and when — the
      * site's own availability sentence for the store it resolves to ("Available as soon as
@@ -2827,6 +3668,21 @@ interface DiscounttireStock {
      * "on the shelf right now".
      */
     checkStock(idOrUrl: string, location: { zip: string } | { storeCode: string } | { latitude: number; longitude: number }): Promise<DiscounttireStock>;
+
+    /**
+     * Searches the tires Discount Tire sells in a given size (or staggered pair — `front` and a
+     * different `rear`) and returns what is in stock near a place with prices and star ratings.
+     * `front` and `rear` are stamped-on-the-sidewall sizes like `{ diameter: "17", width: "225",
+     * aspectRatio: "45" }` for `225/45R17`; the site's schema refuses any unknown field on a
+     * `TireSizeInput`, so the function does too. `location` is a 5-digit US zip, an exact store
+     * code, or a coordinate — same three forms `checkStock` takes, same resolution path (zip is
+     * geocoded to its centroid first, then the resolved store is the one the GraphQL operation is
+     * anchored to). `pageNumber` and `pageSize` paginate the result set (pageSize capped at 100).
+     * Returns pagination, the site's own facet list, and a list of tire rows. No
+     * `vehicleAssemblyId` is needed — unlike the by-vehicle searches here, the by-size operations
+     * take `vehicleInfo` as optional and the function never asks for one.
+     */
+    searchTiresBySize(args: { front: { diameter: string; width: string; aspectRatio: string }; rear?: { diameter: string; width: string; aspectRatio: string }; location: { zip: string } | { storeCode: string } | { latitude: number; longitude: number }; pageNumber: number; pageSize: number }): Promise<DiscounttireTireSizeSearch>;
   }
 }
 
@@ -3072,14 +3928,38 @@ interface ExtraspaceNearbyFacility {
   distanceMiles: number | null;
 }
 
+interface ExtraspaceAvailabilityResult {
+  storeId: number;
+  /** Normalized the way search's unitSize option is, e.g. "10x10". */
+  unitSize: string;
+  /** Every unit CLASS matching the requested size; empty if the facility carries none. */
+  matches: ExtraspaceUnitAvailability[];
+}
+
+interface ExtraspaceUnitAvailability {
+  sizeDisplay: string;
+  sizeClass: string;
+  widthFeet: number | null;
+  depthFeet: number | null;
+  squareFeet: number | null;
+  /** Whether the site is currently offering THIS class for rent. */
+  available: boolean;
+  unitsAvailable: number | null;
+  streetRate: number | null;
+  webRate: number | null;
+  promotions: string[];
+  features: string[];
+}
+
   /**
    * Extra Space Storage — self-storage facility search and detail. `search` takes a US city or
    * ZIP and returns the nearby facilities its own locator would, nearest first, each with its
    * address, distance, amenities and the real monthly price of the cheapest unit in every size
    * it carries. `getFacility` reads one of them in full: street address, both phone lines,
    * office and gate-access hours, what its units offer, starting prices, rating, driving
-   * directions and the nearby facilities. Per-size availability and published deals are declared
-   * but not built yet.
+   * directions and the nearby facilities. `checkAvailability` checks one specific unit size at
+   * one facility and returns every unit class that matches it, each with its own live
+   * availability and price. Published deals are declared but not built yet.
    */
   interface Unit {
     /**
@@ -3119,6 +3999,70 @@ interface ExtraspaceNearbyFacility {
      * caller-fixable error rather than returning an empty-looking result.
      */
     getFacility(storeId: number | string): Promise<ExtraspaceFacilityDetail>;
+
+    /**
+     * Checks current availability and price for one unit SIZE (e.g. "10x10", "5x15" — width x
+     * depth, in feet) at one Extra Space Storage facility. `storeId` is the same id
+     * `search`/`getFacility` take. Returns every unit CLASS at that facility whose dimensions
+     * match the requested size — a facility routinely lists more than one class of the same
+     * nominal size (a live capture of facility 300125 carries four separate `10' x 10'` classes
+     * with different availability), so this never collapses them to one "best" answer the way
+     * `search`'s roll-up does. Each match reports whether the site is CURRENTLY offering it
+     * (`available`), how many units of that class are free (`unitsAvailable`), both the
+     * struck-through "street" rate and the real "web" rate, any active move-in promotion, and the
+     * class's own features. An empty `matches` array means the facility does not carry that size
+     * at all — a coming-soon facility with zero listed unit classes returns `matches: []` for any
+     * size, with no error, exactly like a fully-open facility that simply does not offer it.
+     * `unitSize` outside `width x depth` form (e.g. "12x40", which nothing in this fixture
+     * carries) is not refused as invalid — it is a value the site may or may not stock, so it is
+     * looked up and answered with an empty array like any other size the facility does not have;
+     * only a string that cannot be PARSED as `<number>x<number>` is a caller error.
+     */
+    checkAvailability(storeId: number | string, unitSize: string): Promise<ExtraspaceAvailabilityResult>;
+  }
+}
+
+declare namespace BowmarkProvider_firstdibs {
+  // ── 1stDibs — the unit's own declarations, verbatim ──
+interface FirstdibsSearchResult {
+  name: string;
+  url: string;
+  price: number;
+  priceCurrency: string;
+  availability: string;
+  image: string | null;
+}
+interface FirstdibsCompletingAction {
+  makeOffer: boolean;
+  contactSeller: boolean;
+  purchase: false;
+}
+interface FirstdibsListing {
+  name: string;
+  url: string;
+  description: string;
+  brand: string | null;
+  price: number;
+  priceCurrency: string;
+  completingAction: FirstdibsCompletingAction;
+}
+
+  /**
+   * Search 1stDibs' luxury/vintage marketplace and read a listing's real price plus its concrete
+   * completing action (Make an Offer / Contact Seller) — no login.
+   */
+  interface Unit {
+    /**
+     * Runs 1stDibs' keyword search (or a category-facet URL) and returns real listings with real
+     * price, currency, availability and url.
+     */
+    search(query: string): Promise<FirstdibsSearchResult[]>;
+
+    /**
+     * Reads one listing's real price and its concrete completing action(s) — Make an Offer and/or
+     * Contact Seller, whichever this seller has enabled.
+     */
+    getListing(url: string): Promise<FirstdibsListing>;
   }
 }
 
@@ -3288,21 +4232,177 @@ interface fordNameplateDirectory {
   nameplates: fordNameplate[];
 }
 
+interface fordOfferProgram {
+  id: string;
+  name: string;
+  /** Ford's own program type, verbatim — "Cash", "APR", and whatever else
+   * Ford introduces. */
+  type: string;
+  /** Whole USD, negative for a discount. null when this program is not a
+   * flat-amount one. */
+  amount: number | null;
+  /** null when this program is not a financing offer. Ford sends one term or
+   * several (e.g. 36/48/60/72/84-month options on the same program). */
+  aprTerms: { apr: number; termMonths: number }[] | null;
+  startDate: string | null;
+  endDate: string | null;
+  disclaimer: string | null;
+  /** Ford's own machine code, e.g. "PC_STANDALONE_APR", "DEALER_CASH". */
+  programType: string | null;
+  /** "Retail" (public), "Private" (military/loyalty/first-responder —
+   * eligibility this function cannot itself verify), "Campaign", or
+   * whatever else Ford uses. */
+  category: string | null;
+  /** True when Ford Motor Credit finances the program. */
+  financeCompany: boolean;
+  /** Ford's own flag for "eligibility depends on something beyond make/model/
+   * ZIP" (military status, trade-in, loyalty). */
+  conditional: boolean;
+}
+
+interface fordTrimOffers {
+  trim: string;
+  programs: fordOfferProgram[];
+}
+
+interface fordOffers {
+  /** The inventory slug this was resolved from, e.g. "f150". */
+  nameplate: string;
+  modelYear: number;
+  /** The ZIP that was searched — incentives are regional. */
+  postalCode: string;
+  /** Ford's own dealer-region code for that ZIP (e.g. "F48B"), when it sends
+   * one. Opaque outside Ford. */
+  region: string | null;
+  trims: fordTrimOffers[];
+}
+
+interface fordVehicleImage {
+  url: string;
+  /** "primary", "exterior" or "interior" — search results carry "primary"
+   * only; this endpoint returns the full set. */
+  role: string;
+  width: number | null;
+  height: number | null;
+}
+
+interface fordVehiclePricing {
+  msrp: number;
+  /** null when Ford has no net figure for this vehicle. */
+  netPriceAfterIncentives: number | null;
+  currency: string;
+  /** Ford's own required legal text — show it alongside any displayed price. */
+  disclaimer: string;
+}
+
+interface fordVehicleAvailability {
+  /** "in_stock", "in_transit", or a new value Ford introduces. */
+  status: string;
+  asOf: string;
+}
+
+interface fordVehicleDealer {
+  name: string;
+  city: string;
+  state: string;
+  distanceMiles: number;
+  phone: string | null;
+  address: string | null;
+  websiteUrl: string | null;
+}
+
+interface fordVehicleOptionPackage {
+  name: string;
+  /** null when Ford prices the package into the vehicle's MSRP rather than
+   * itemizing it. */
+  msrp: number | null;
+}
+
+interface fordVehicle {
+  vin: string;
+  /** The slug `listNameplates` returns, e.g. "f150", "explorer". */
+  nameplate: string;
+  displayName: string;
+  year: number;
+  trim: string;
+  bodyStyle: string | null;
+  powertrain: string | null;
+  drivetrain: string | null;
+  exteriorColor: string | null;
+  pricing: fordVehiclePricing;
+  availability: fordVehicleAvailability;
+  dealer: fordVehicleDealer;
+  images: fordVehicleImage[];
+  /** Canonical detail page — link every vehicle mention here. */
+  vdpUrl: string;
+  optionPackages: fordVehicleOptionPackage[];
+}
+
+interface fordRecallRecord {
+  /** Ford's own campaign identifier, e.g. "23S37", "26S48". */
+  campaignNumber: string | null;
+  title: string | null;
+  /** Issue date as Ford stores it. */
+  issueDate: string | null;
+  description: string | null;
+  safetyRisk: string | null;
+  remedy: string | null;
+  status: string | null;
+  /** True when this is a Field Service Action / Customer Satisfaction Program
+   *  (an FSA, NOT a regulator-mandated recall). */
+  isCustomerSatisfactionProgram: boolean;
+}
+
+interface fordVehicleRecalls {
+  vin: string;
+  vehicle: {
+    year: string | null;
+    make: string | null;
+    model: string | null;
+    bodyStyle: string | null;
+    fuelType: string | null;
+  };
+  recalls: fordRecallRecord[];
+  customerSatisfactionPrograms: fordRecallRecord[];
+  counts: {
+    recallsCount: number;
+    cspCount: number;
+    totalFsaCount: number;
+  };
+  /** True when the page acknowledges an empty result for this VIN (no
+   *  recalls, no FSAs) rather than an error. Ford's own empty-state copy. */
+  noRecalls: boolean;
+  /** True when the upstream recall service failed to answer — the page
+   *  surfaces its own API-error message in that case. */
+  apiError: boolean;
+  warnings: string[];
+}
+
   /**
    * Ford US new-vehicle shopping: live VIN-level dealer inventory near a ZIP, one vehicle by
    * VIN, the model/trim directory and its paint palette, the build-and-price configurator, model
-   * specs and MSRP, current incentives, the dealer locator, and recall lookup by VIN. Two
+   * specs and MSRP, current incentives, the dealer locator, and recall lookup by VIN. Five
    * functions are callable now. The dealer locator returns Ford dealers near a US ZIP with full
    * address, phone, coordinates, per-day sales and service hours, Ford's own capability flags
    * (EV-certified, commercial fleet, pickup-and-delivery) and links to the dealer's own site and
    * inventory. The nameplate directory returns every Ford model inventory can be searched by —
    * slug, display name, aliases, body style, model years and trims — and resolves a person's own
-   * words ("F-150", "mach e", "Super Duty") to the slug the other inventory endpoints take. The
-   * other seven declared functions are still stubs.
+   * words ("F-150", "mach e", "Super Duty") to the slug the other inventory endpoints take.
+   * `getOffers` returns Ford's live, ZIP-regional incentives for a model — cash back, APR
+   * financing (with every term Ford offers, not just the headline one) and any lease programs,
+   * each with its own dates, disclaimer and eligibility category, broken out per trim.
+   * `getVehicle` reads one specific vehicle by VIN — full trim, pricing with Ford's required
+   * disclaimer, availability, the holding dealer's contact details, the FULL image set (exterior
+   * AND interior, not just the one card image a search result carries) and every option package
+   * — and returns `null` rather than throwing when Ford reports the vehicle sold or removed,
+   * which its own docs call a real, non-retryable answer. `getRecalls` returns the open safety
+   * recalls and Customer Satisfaction Programs Ford has published against a VIN — campaign
+   * number, issue date, description, safety risk and remedy for each — splitting
+   * regulator-mandated recalls from Ford's own goodwill FSAs, with `null` for a well-formed VIN
+   * Ford has no record of and an empty result (no recalls, no FSAs) for a known VIN with no open
+   * actions. The other four declared functions are still stubs.
    */
   interface Unit {
-    // NO TYPED SURFACE — every function this unit declares is refused above.
-    // The unit is real and callable at runtime; nothing here can say so in types.
     // UNTYPED, DELIBERATELY OMITTED — `findDealers({ near, radiusMiles, limit })` declares no types for
     // its argument, so there is no honest signature to emit.
     // It is CALLABLE at runtime; `bowmark.providers.ford.findDealers` is a compile error here on purpose.
@@ -3312,6 +4412,52 @@ interface fordNameplateDirectory {
     // its argument, so there is no honest signature to emit.
     // It is CALLABLE at runtime; `bowmark.providers.ford.listNameplates` is a compile error here on purpose.
     // A `(...args: unknown[])` stand-in would compile and tell you nothing.
+
+    /**
+     * Ford's current incentives for one model near a US ZIP — cash back, APR financing (every term
+     * Ford offers on a program, e.g. 36/48/60/72/84-month options, not just the headline rate) and
+     * any lease programs — broken out per trim, each with its start/end date, Ford's own
+     * disclaimer text, its machine program code, and a `category` ("Retail" public vs. "Private"
+     * military/loyalty/first-responder) so a caller can tell a program anyone qualifies for from
+     * one that needs proof this function cannot itself check. `nameplate` is the slug
+     * `listNameplates` returns ("f150", "bronco-sport"); a handful of commercial-chassis
+     * nameplates the inventory API lists have no incentives page at all and are refused by name,
+     * measured rather than guessed. `postalCode` is required — incentives are regional, and the
+     * SAME model/year at two ZIPs 2,000 miles apart returns genuinely different programs. `year`
+     * defaults to the newest model year Ford is currently running incentives on for that
+     * nameplate.
+     */
+    getOffers(args: { nameplate: string; postalCode: string; year?: number }): Promise<fordOffers>;
+
+    /**
+     * Reads one specific vehicle by its 17-character VIN — full trim, exterior color, complete
+     * pricing with Ford's required disclaimer, live availability, the holding dealer's
+     * name/address/phone/website, the FULL image set (`primary`, `exterior` AND `interior` — a
+     * `searchInventory` result carries `primary` only), every option package, and the canonical
+     * `vdpUrl` Ford's own docs say to link on any mention. `vin` is a required argument, matching
+     * Ford's own pattern (17 characters, excluding I/O/Q) and checked locally before spending a
+     * request. Returns `null` — not an error — when Ford answers `VEHICLE_NOT_FOUND`: Ford's own
+     * docs call a 404 here "sold or removed... not a retryable error", so a vehicle that sold
+     * between search and read is a real, unsurprising answer rather than a failure.
+     */
+    getVehicle(vin: string): Promise<fordVehicle | null>;
+
+    /**
+     * Reads the open safety recalls and Customer Satisfaction Programs (FSAs) Ford has published
+     * against one specific VIN, and what each one says to do — the same answer an owner or a
+     * used-car buyer gets on Ford's owner-support recalls page. `vin` is required and locally
+     * validated against the same 17-character pattern `getVehicle` uses (A-H, J-N, P, R-Z, 0-9).
+     * Returns `null` — not an error — when the VIN is well-formed but unknown to Ford (the page
+     * sets `isVinInvalid: true`); the call surfaces `noRecalls: true` for a known VIN with no open
+     * actions, and the response separates regulator-mandated `recalls` from optional
+     * `customerSatisfactionPrograms` (the latter are Ford's free goodwill fixes, NOT safety
+     * recalls). Each record carries Ford's own campaign number, issue date, the free-form
+     * description, the stated safety risk, the prescribed remedy, and the status Ford reports.
+     * When Ford's recall upstream fails, the call returns a successful shape with `apiError: true`
+     * and the upstream's own error message in `warnings` — a transient 5xx shouldn't kill the
+     * caller. No sign-in: the page is public.
+     */
+    getRecalls(vin: string): Promise<fordVehicleRecalls | null>;
   }
 }
 
@@ -3436,9 +4582,42 @@ interface fredSeries {
   notes: string | null;
 }
 
+interface fredCategoryRow {
+  id: number;
+  name: string;
+  parentId: number;
+}
+
+interface fredCategory {
+  id: number;
+  name: string;
+  parentId: number;
+  children: fredCategoryRow[];
+  series: fredSeries[];
+}
+
+interface fredObservation {
+  date: string;
+  /** null where FRED holds no observation for that period — a market holiday in a
+   * daily series, or the first year of a year-over-year transform. */
+  value: number | null;
+}
+
+interface fredObservations {
+  seriesId: string;
+  /** The transform FRED reports having applied: "lin" (none), "pc1", "pch", … */
+  units: string;
+  observationStart: string;
+  observationEnd: string;
+  realtimeStart: string;
+  realtimeEnd: string;
+  count: number;
+  observations: fredObservation[];
+}
+
   /**
-   * US economic data releases and their publication calendar, and the agencies FRED republishes
-   * data from, off the St. Louis Fed's FRED.
+   * US economic data releases and their publication calendar, the agencies FRED republishes data
+   * from, series metadata, and FRED's own category tree, off the St. Louis Fed's FRED.
    */
   interface Unit {
     /**
@@ -3472,6 +4651,34 @@ interface fredSeries {
      * back as a caller-fixable error naming the problem rather than as an empty result.
      */
     getSeriesInfo(seriesId: string): Promise<fredSeries>;
+
+    /**
+     * Reads the actual numbers for a FRED series — the dated observations themselves, oldest
+     * first, with a missing period returned as `value: null` rather than as a `NaN` or a silently
+     * dropped row. Called bare (`getSeriesObservations("GDPC1")`) it returns the series' full
+     * history; `from`/`to` (ISO yyyy-mm-dd) narrow the window. It also runs FRED's own transforms
+     * server-side so a caller never has to recompute one: `units` converts the level to a change
+     * (`pc1` percent change from a year ago — the usual way to read inflation off CPIAUCSL — plus
+     * `pch`, `chg`, `log` and the rest of FRED's ten codes), and `frequency` with
+     * `aggregationMethod` collapses a series to a coarser period (`{ frequency: "a",
+     * aggregationMethod: "avg" }` turns the monthly unemployment rate into annual averages). The
+     * result carries the transform FRED reports having applied and the vintage it served, so a
+     * caller can tell what they actually got. This is the function to call once
+     * `searchSeries`/`getSeriesInfo` has identified the right series id — e.g. A191RL1Q225SBEA for
+     * the US real GDP growth rate.
+     */
+    getSeriesObservations(args: string | { seriesId: string; from?: string; to?: string; units?: string; frequency?: string; aggregationMethod?: string }): Promise<fredObservations>;
+
+    /**
+     * Browses FRED's category tree the way fred.stlouisfed.org/categories does — the category
+     * itself (id/name/parent), its immediate child categories, and the series filed directly under
+     * it (the same shape getSeriesInfo returns per series, so a caller can read
+     * units/frequency/lastUpdated off a browsed result with no second call). Called bare it starts
+     * at the root (id 0). FRED organizes its ~800,000 series into a real hierarchy, so this is how
+     * a caller explores 'what's available in this area' before knowing a series id to look up
+     * directly. An unknown category id comes back as a caller-fixable error.
+     */
+    browseCategory(categoryId?: number): Promise<fredCategory>;
   }
 }
 
@@ -3912,6 +5119,15 @@ interface graingerRow {
   id: string;
 }
 
+interface graingerSearchRow {
+  itemNumber: string;
+  name: string;
+  url: string;
+  brand: string | null;
+  price: { amount: number; currency: string; perUnit: string } | null;
+  thumbnail: string | null;
+}
+
 interface graingerBranchRow {
   branchNumber: string;
   name: string;
@@ -3922,12 +5138,55 @@ interface graingerBranchRow {
   hours: { day: string; hours: string }[];
 }
 
+interface graingerProductRow {
+  itemNumber: string;
+  manufacturerModel: string | null;
+  name: string;
+  description: string | null;
+  brand: string | null;
+  url: string;
+  images: string[];
+  price: { amount: number; currency: string; perUnit: string } | null;
+  specs: { name: string; value: string }[];
+  availabilitySummary: string | null;
+}
+
+interface graingerStockRow {
+  itemNumber: string;
+  zip: string;
+  quantity: number;
+  shipping: { message: string | null; fulfillmentCode: string | null; availKey: string | null } | null;
+  pickup: {
+    message: string | null;
+    fulfillmentCode: string | null;
+    availKey: string | null;
+    branch: {
+      branchCode: string;
+      city: string | null;
+      address: { street: string | null; city: string | null; state: string | null; zip: string | null; country: string | null } | null;
+      url: string | null;
+    } | null;
+  } | null;
+}
+
   /**
-   * Grainger's industrial MRO catalog, product detail, and branch/stock availability —
-   * findBranch is live (nationwide branch directory, address/phone/hours); catalog, product
-   * detail and stock checks are still stubs.
+   * Grainger's industrial MRO catalog, product detail, and branch/stock availability — search
+   * (keyword/category catalog search returning name, item number, brand, price and thumbnail),
+   * findBranch (nationwide branch directory), getProduct (price, pack size, spec table,
+   * availability by item number or URL) and checkStock (shipping-to-zip and
+   * pickup-at-nearest-branch fulfillment estimates) are all live.
    */
   interface Unit {
+    /**
+     * Searches Grainger's industrial MRO catalog by keyword, returning matching products — item
+     * number, name, brand, list price and thumbnail. Takes `query` (free text, e.g. "antistatic
+     * gloves"). A SPECIFIC query resolves to Grainger's own matching leaf category and returns its
+     * real products; a broad query (e.g. "gloves" alone) can resolve to a category-of-categories
+     * browse page one or more levels above any actual product and throws rather than returning an
+     * empty array — narrow the query if that happens.
+     */
+    search(args: object): Promise<graingerSearchRow[]>;
+
     /**
      * Finds Grainger's own U.S. branches near a ZIP, city or state — address, phone, hours and
      * curbside-pickup availability, off the site's own nationwide directory. `zip` matches by its
@@ -3937,6 +5196,99 @@ interface graingerBranchRow {
      * truncating.
      */
     findBranch(args: object): Promise<graingerBranchRow[]>;
+
+    /**
+     * Reads one Grainger product page in full — price and pack size/unit of measure, the full spec
+     * table, the manufacturer's own part number, and a shipping/pickup availability summary. Takes
+     * `itemNumber` (Grainger's own catalog id, e.g. "26K909" — resolves directly, no descriptive
+     * slug needed) or `url` (a full grainger.com product URL). Throws if the item number doesn't
+     * exist (a clean 404) rather than returning an empty row.
+     */
+    getProduct(args: object): Promise<graingerProductRow>;
+
+    /**
+     * Checks real fulfillment availability for one item (`itemNumber` or `url`, same as
+     * `getProduct`) at a caller-supplied `zip` (required, 5-digit US) — both shipping-to-that-zip
+     * and pickup-at-the-nearest-branch-to-that-zip, in one call. Returns the site's own message
+     * text (an arrival/ready-by estimate, never a literal stock count — the site doesn't publish
+     * one) plus its opaque status codes for each mode, and the ACTUAL branch that answered the
+     * pickup half (nearest-to-point, not necessarily one the caller could have named). Optional
+     * `quantity` (default 1) is forwarded to the site.
+     */
+    checkStock(args: object): Promise<graingerStockRow>;
+  }
+}
+
+declare namespace BowmarkProvider_hauslabs {
+  // ── Haus Labs by Lady Gaga — the unit's own declarations, verbatim ──
+interface HauslabsVariant {
+  id: string;
+  title: string;
+  price: string;
+  compareAtPrice: string | null;
+  sku: string | null;
+  available: boolean;
+  options: string[];
+}
+interface HauslabsProduct {
+  handle: string;
+  title: string;
+  vendor: string;
+  productType: string;
+  url: string;
+  descriptionHtml: string | null;
+  optionNames: string[];
+  variants: HauslabsVariant[];
+  priceRange: { min: string; max: string } | null;
+  inStock: boolean;
+  tags: string[];
+  images: string[];
+}
+interface HauslabsShadeMatch {
+  quiz: { family: string; depth: string; undertone: string; hasAddOne: boolean };
+  variant: {
+    number: number;
+    family: string;
+    sku: string | null;
+    price: string;
+    available: boolean;
+  };
+  product: HauslabsProduct;
+  warnings: string[];
+}
+
+  /**
+   * Haus Labs by Lady Gaga product catalogue — every clean-beauty SKU, its variants, its prices
+   * and what is in stock — read off the live Shopify Plus storefront. The Foundation Shade
+   * Finder is the broadcast wedge: a multi-step quiz ChatGPT cannot operate, mapped locally to
+   * one specific priced shade with the buy-page handoff.
+   */
+  interface Unit {
+    /**
+     * Reads the live Haus Labs 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. Optional productType narrows to FACE / LIPS / EYES / SETS / etc. before
+     * the limit. Returns [] on a transport failure (warnings would be on an object envelope; this
+     * is a list). The catalog page is the line and the parse is the unit of work.
+     */
+    listHauslabsProducts(opts?: { limit?: number; productType?: string }): Promise<HauslabsProduct[]>;
+
+    /**
+     * Reads one product by its handle — every variant, its exact price, the image the storefront
+     * is showing and whether that specific variant is purchasable right now. Takes the handle
+     * listHauslabsProducts returns. THROWS on an unknown handle (the store answers a real 404).
+     */
+    getHauslabsProduct(handle: string): Promise<HauslabsProduct>;
+
+    /**
+     * Resolves a buyer's Foundation Lab quiz answers to ONE specific shade: the variant title, the
+     * SKU, the real price, the availability, the buy-page URL. Mirrors the quiz's `shadeLogic`
+     * decision tree natively against Cartful Solutions' published `pd.json` (keyless, browserless)
+     * and resolves the matching variant through /products/<handle>.js for live price and stock.
+     * The quiz is a 5-step Shopify section ChatGPT cannot operate on the buyer's behalf; this
+     * function returns the single shade the quiz's terminal page renders for the same inputs.
+     */
+    runFoundationShadeFinder(input: { family: 'Deep' | 'Medium Deep' | 'Medium' | 'Light Medium' | 'Light' | 'Fair'; depth: 'deeper' | 'medium' | 'lighter'; undertone: 'warm' | 'cool' | 'neutral' | 'rosy' | 'golden'; hasAddOne?: boolean }): Promise<HauslabsShadeMatch>;
   }
 }
 
@@ -4734,6 +6086,72 @@ interface HellofreshRecipeSearchPage {
   }
 }
 
+declare namespace BowmarkProvider_hellotend {
+  // ── Tend Dental — the unit's own declarations, verbatim ──
+interface HellotendMarket {
+  slug: string;            // e.g. "new-york-city"
+  name: string;            // e.g. "New York City"
+  location: { lat: number; lon: number } | null;
+  bookingEnabled: boolean;
+}
+interface HellotendStudio {
+  slug: string;            // e.g. "hells-kitchen" — what listServices takes
+  name: string;
+  market: string;          // e.g. "new-york-city"
+  address: string | null;
+  location: { lat: number; lon: number } | null;
+  openingDate: string | null;
+  serviceCodes: string[];  // ["CLNCHK","WHTNG",...] — the codes this studio accepts
+  bookingEnabled: boolean;
+  familyBookingEnabled: boolean;
+}
+interface HellotendService {
+  code: string | null;     // e.g. "CLNCHK" — null on category-level entries
+  name: string;            // e.g. "Exam"
+  longName: string | null; // e.g. "Dental Exam"
+  description: string | null;
+  bookingDescription: string | null;
+  duration: string | null; // e.g. "70 minutes or less"
+}
+
+  /**
+   * Reads Tend Dental's public booking chain — every market, every studio, every service a
+   * studio offers — straight from hellotend.com's own Next.js data route, no key, no browser.
+   */
+  interface Unit {
+    /**
+     * Lists every market Tend serves — the 6 metros the booking chain currently offers (NYC,
+     * Washington DC, Atlanta, Boston, Chicago, Nashville), with each market's slug, lat/lon and
+     * booking-enabled flag. Takes nothing. The slug it returns is what listStudios and
+     * listServices take. THROWS rather than returning [] when the data route answers without its
+     * payload or names no markets — Tend operates 6 metros and zero is never an honest answer.
+     */
+    listMarkets(): Promise<HellotendMarket[]>;
+
+    /**
+     * Lists every Tend dental studio — 33+ across all markets, with name, slug, market, address,
+     * lat/lon, opening date, the service codes that studio accepts, and whether it offers
+     * family-booking. The market arg is OPTIONAL: omit it to get the full set across all markets,
+     * pass a market slug to filter. THROWS rather than returning [] when the data route answers
+     * without its payload or names no studios; surfaces an unknown market slug as a caller-fixable
+     * error listing the real ones.
+     */
+    listStudios(market?: string): Promise<HellotendStudio[]>;
+
+    /**
+     * Lists the service codes a specific Tend studio offers (Dental Exam CLNCHK, Clear Aligners
+     * INVISALN, Emergency EMGNCY, Sleep Apnea Consult SLPCONS, Cosmetic, Procedures) with each
+     * service's display name, code, duration and short description. The CODE is what a real Tend
+     * booking needs to advance to the time-picker page. The first four carry a code; the last two
+     * (Cosmetic, Procedures) are category-level landing entries that route to sub-flows and are
+     * returned with a null code rather than dropped. THROWS rather than returning [] when the data
+     * route answers without its payload or names no services; surfaces an unknown studio as a
+     * caller-fixable error listing the real ones in that market.
+     */
+    listServices(market: string, studio: string): Promise<HellotendService[]>;
+  }
+}
+
 declare namespace BowmarkProvider_hilton {
   // ── Hilton — the unit's own declarations, verbatim ──
 interface hiltonRoomOffer {
@@ -5979,6 +7397,99 @@ interface InteriorDefineCartHandoff {
   }
 }
 
+declare namespace BowmarkProvider_joybird {
+  // ── Joybird — the unit's own declarations, verbatim ──
+interface JoybirdConfigurator {
+  slug: string;
+  name: string;
+  sku: string;
+  type: string;
+  family: string;
+  url: string;
+  finalPrice: number;
+  originalPrice: number;
+  discountPercent: number;
+}
+interface JoybirdOptionValue {
+  sku: string;
+  value: string;
+  cover: string | null;
+  color: string | null;
+  family: string;
+  tier: number;
+  petFriendly: boolean;
+  performanceFabric: boolean;
+  sustainableFabric: boolean;
+  popular: boolean;
+}
+interface JoybirdOption {
+  id: number;
+  name: string;
+  type: string | null;
+  values: JoybirdOptionValue[];
+}
+interface JoybirdCatalog {
+  slug: string;
+  name: string;
+  sku: string;
+  type: string;
+  family: string;
+  url: string;
+  dimensions: string;
+  finalPrice: number;
+  originalPrice: number;
+  discountPercent: number;
+  promotionStart: string | null;
+  promotionEnd: string | null;
+  options: JoybirdOption[];
+}
+interface JoybirdPriceLine {
+  optionId: number;
+  optionName: string;
+  optionSku: string;
+  valueSku: string;
+  valueName: string;
+}
+interface JoybirdPriceResult {
+  slug: string;
+  sku: string;
+  finalPrice: number;
+  originalPrice: number;
+  discountPercent: number;
+  lines: JoybirdPriceLine[];
+}
+
+  /**
+   * Reads Joybird's real sofa/sectional configurator — every configurable product, every fabric
+   * and wood stain, and the live configured price Joybird's own page shows.
+   */
+  interface Unit {
+    /**
+     * Lists every configurable product Joybird sells — sofas, sectionals, chairs, ottomans, beds,
+     * organised by collection — with its slug, name, current displayed price, list price and
+     * active discount. Takes nothing. The slug it returns is what getConfigurator and
+     * priceConfigurator take.
+     */
+    listConfigurators(): Promise<JoybirdConfigurator[]>;
+
+    /**
+     * Reads one product's full configurator — its dimensions, current price, active promotion
+     * window, and every option slot the product exposes (Fabric, Wood Stain, Orientation, ...)
+     * with the site's full swatch list for each. The slot ids and swatch SKUs it returns are what
+     * priceConfigurator takes.
+     */
+    getConfigurator(slug: string): Promise<JoybirdCatalog>;
+
+    /**
+     * Prices an exact configuration for one product given the caller's swatch picks (one swatch
+     * SKU per slot id; any slot left out uses its first available swatch as a documented default).
+     * Returns the real live total Joybird's own page shows, plus a per-slot breakdown of what was
+     * picked.
+     */
+    priceConfigurator(slug: string, selections: Record<string, string>): Promise<JoybirdPriceResult>;
+  }
+}
+
 declare namespace BowmarkProvider_kayak {
   // ── Kayak — the unit's own declarations, verbatim ──
 interface KayakQuery {
@@ -6134,6 +7645,17 @@ interface LabcorpTestSummary {
   currency: string;       // "USD"
 }
 
+interface LabcorpTestDetail extends LabcorpTestSummary {
+  sampleType: string;        // "Blood & Urine", "Nasal Swab"
+  collectionMethod: string;  // "In person at a Labcorp location"
+  turnaroundTime: string;    // "1-2 days from when your sample arrives at our lab"
+  ageRange: string;          // "18-100", "" if absent
+  metaDescription: string;
+  metaTitle: string;
+  shortDescriptionHtml: string;
+  descriptionHtml: string;
+}
+
   /** Lab test pricing, PSC location lookup and appointment availability from Labcorp. */
   interface Unit {
     /**
@@ -6142,6 +7664,14 @@ interface LabcorpTestSummary {
      * No doctor's visit required to order.
      */
     search(query: string): Promise<LabcorpTestSummary[]>;
+
+    /**
+     * Returns the full OnDemand test detail for one sku — price, descriptions, sample type,
+     * collection method, turnaround time and acceptable age band. Combines the catalog row
+     * (GraphQL) with the specimen/turnaround facts the site renders on the PDP HTML. Pass the sku
+     * returned by `search`.
+     */
+    getTest(sku: string): Promise<LabcorpTestDetail>;
   }
 }
 
@@ -6628,6 +8158,80 @@ interface LululemonVariant {
   available: boolean;
   price: number | null;
   salePrice: number | null;
+  /** Why this SKU's price is, or is not, a markdown. Derived from price and
+   * salePrice, so it can never disagree with them. */
+  sale: SaleEvidence;
+}
+interface SaleEvidence {
+  /** True only with retailer evidence. NEVER from a low price or a title. */
+  onSale: boolean;
+  currentPrice: number | null;
+  /** The list price, when the markdown is against one. */
+  originalPrice: number | null;
+  /** ISO 4217, or null. ALWAYS null here: this feed publishes bare numbers with
+   * no currency code anywhere in the payload. */
+  currency: string | null;
+  promotionMessage: string | null;
+  evidenceType: "compare_at_price" | "sale_price" | "retailer_sale_badge" | "published_promotion" | "none";
+  /** The retailer text or field the classification rests on, verbatim. */
+  evidenceText: string | null;
+}
+interface ProductImage {
+  /** Absolute HTTPS url. */
+  url: string;
+  altText: string | null;
+  /** The colourway's own colour — sound because lululemon publishes its image
+   * list PER COLOURWAY, so every picture in it is that colour by construction. */
+  color: string | null;
+  colorId: string | null;
+  /** Always [] here: this feed links a picture to a COLOUR, never to a size. */
+  variantIds: string[];
+}
+/** The retailer's own labels. On this door that is audience and nothing else —
+ * the HPDP feed publishes no description, tags, fabric, collection or category.
+ * Every other field is null or [], honestly. */
+interface PublishedProductAttributes {
+  audience: string | null;
+  garmentType: "sports_bra" | "tank" | "crop_top" | "leggings" | "shorts" | "other" | null;
+  categories: string[];
+  collections: string[];
+  fabrics: string[];
+  materials: string[];
+  color: string | null;
+  colorFamily: string | null;
+  pattern: string | null;
+  styleTags: string[];
+  neckline: string | null;
+  strapWidth: string | null;
+  backDesign: string | null;
+  sleeveLength: string | null;
+  rise: string | null;
+  waistband: string | null;
+  inseam: string | null;
+  legShape: string | null;
+  fit: string | null;
+  coverage: string | null;
+}
+/** Shared colour and family — what makes two pieces PLAUSIBLY coordinate. None
+ * of it establishes a set. */
+interface CoordinationMetadata {
+  collectionNames: string[];
+  fabricNames: string[];
+  colorName: string | null;
+  colorId: string | null;
+  colorFamily: string | null;
+  productFamily: string | null;
+}
+/** An EXPLICIT retailer-published relationship. ALWAYS [] on this door: the feed's
+ * only product-to-product relation is the ALGORITHMIC similarity rail, which is
+ * getSimilarProducts. Reading that as a set would turn "the recommender put these
+ * near each other" into "lululemon sells these together". */
+interface RetailerSetEvidence {
+  evidenceType: "official_set" | "shop_the_set" | "complete_the_look" | "matching_piece";
+  evidenceText: string | null;
+  sourceUrl: string | null;
+  setId: string | null;
+  relatedProducts: Array<{ productId: string | null; handle: string | null; title: string | null; url: string | null }>;
 }
 interface LululemonOptionGroup {
   /** The machine name. "size" on every lululemon product measured. */
@@ -6649,6 +8253,13 @@ interface LululemonColorway {
   url: string;
   swatchImage: string | null;
   images: string[];
+  /** The SAME pictures as images, carrying this colourway's colour and colorId.
+   * images stays a bare string[] for existing callers; this is the additive half. */
+  imageAssets: ProductImage[];
+  sale: SaleEvidence;
+  coordination: CoordinationMetadata;
+  /** ISO 4217, or null. Always null — see SaleEvidence.currency. */
+  currency: string | null;
   inStock: boolean;
   optionGroups: LululemonOptionGroup[];
   /** What can be BOUGHT in this colour right now — not the full size run. */
@@ -6676,6 +8287,37 @@ interface LululemonProduct {
   /** Other lengths of the same style. Empty on every product measured — on this
    * site an inseam is its OWN product, not an option. */
   sizeTypes: LululemonSizeType[];
+  attributes: PublishedProductAttributes;
+  coordination: CoordinationMetadata;
+  retailerSetEvidence: RetailerSetEvidence[];
+}
+/** One published product-detail block from the page, verbatim. */
+interface LululemonFeature {
+  heading: string;
+  body: string;
+}
+/** What lululemon's OWN product page publishes about a garment, which the
+ * third-party pricing door does not carry at all. */
+interface LululemonProductAttributes {
+  productId: string;
+  url: string;
+  title: string;
+  /** The site's own ProductGroup category, e.g. "Leggings". */
+  category: string | null;
+  description: string | null;
+  /** Trademarked fabric names off the detail accordion, e.g. ["Nulu"]. */
+  fabrics: string[];
+  fit: string | null;
+  /** "High-Rise" / "Mid-Rise" / "Low-Rise", as the title spells it. */
+  rise: string | null;
+  /** Every detail block, unmapped and in page order. */
+  features: LululemonFeature[];
+  /** The site's own aggregate — the honest one. The pricing door reports 0
+   * reviews on products whose live page shows 22,748. */
+  ratingValue: number | null;
+  reviewCount: number | null;
+  /** What could not be reached. Non-empty means the page refused. */
+  warnings: string[];
 }
 interface LululemonRow {
   id: string;
@@ -6731,6 +8373,19 @@ interface LululemonSimilarProducts {
      */
     getProduct(query: { productId: string }): Promise<LululemonProduct>;
 
+    /**
+     * Reads what lululemon's OWN product page publishes about a garment and the third-party
+     * pricing door does not carry at all: the category the site files it under, the collection
+     * description, the trademarked fabric it is cut from, the fit and the rise, its real review
+     * aggregate, and every product-detail block verbatim. This is the expensive door on this
+     * provider — a headed Google Chrome, ~10-20x the latency of `getProduct` — so call it when the
+     * ATTRIBUTES are the answer and `getProduct` when the price, colourways and sizes are. It
+     * never throws on a refused page: a page that will not render comes back with every field
+     * empty and a `warnings` entry naming it, so an empty `fabrics` is distinguishable from an
+     * unread one.
+     */
+    getProductAttributes(query: { productId: string }): Promise<LululemonProductAttributes>;
+
     /**
      * Returns the products lululemon's own product pages recommend alongside one product — the
      * 'You may also like' rail — as priced rows in the store's own ranked order, de-duplicated to
@@ -6743,6 +8398,82 @@ interface LululemonSimilarProducts {
   }
 }
 
+declare namespace BowmarkProvider_maidenhome {
+  // ── Maiden Home — the unit's own declarations, verbatim ──
+// Maiden Home's OWN shapes — not a capability contract.
+
+interface MaidenHomeVariant {
+  productHandle: string;
+  productTitle: string;
+  productType: string;      // e.g. "Sofa", "Modular Component", "Dining Table"
+  size: string;              // e.g. "85\" Width", or a non-numeric value like "Right-Facing Chaise"
+  woodFinish: string;        // e.g. "Driftwood Ash"
+  sku: string;
+  price: number;
+  priceFormatted: string;
+  available: boolean;
+  url: string;               // the product page, preselecting this exact variant
+}
+
+interface MaidenHomeConfiguratorProduct {
+  handle: string;
+  title: string;
+  productType: string;
+  url: string;
+  sizeOptions: string[];
+  woodFinishOptions: string[];
+  priceRange: { min: number; max: number };
+  variants: MaidenHomeVariant[];
+}
+
+interface MaidenHomeVariantResolution {
+  productQuery: string;
+  size: string;
+  woodFinish: string;
+  matched: boolean;
+  variant: MaidenHomeVariant | null;
+  candidates: MaidenHomeVariant[]; // populated when not narrowed to exactly one real variant
+  message: string;
+}
+
+  /**
+   * Maiden Home's Size x Wood Finish product configurator (sofas, sectionals/modular components,
+   * tables) — list every configurable product, read one product's complete priced variant grid,
+   * and resolve a free-text product + size + wood finish to the exact live price and SKU, off
+   * the storefront's own live catalog rather than a researched estimate or a hedged price range.
+   */
+  interface Unit {
+    /**
+     * Lists every Maiden Home product configurable by Size x Wood Finish (sofas,
+     * sectionals/modular components, tables) from the storefront's own live catalog — every size
+     * and wood-finish option, its live price range and variant count. `query` (optional) narrows
+     * the list by a fuzzy match on the product title or product type, e.g. "chelsea" or "dining
+     * table".
+     */
+    searchConfigurations(query?: string): Promise<MaidenHomeConfiguratorProduct[]>;
+
+    /**
+     * Reads one configurator product's complete Size x Wood Finish variant grid — a handle, e.g.
+     * "the-chelsea-sofa-heritage-belgian-linen-lake" — every size x finish combination, each with
+     * its own exact live price, SKU and availability. THROWS on an unrecognized handle, naming
+     * searchConfigurations() as the way to find current ones.
+     */
+    getProduct(handle: string): Promise<MaidenHomeConfiguratorProduct>;
+
+    /**
+     * Resolves a free-text product (e.g. "Chelsea Sofa Heritage Belgian Linen Lake"), size (e.g.
+     * "85\"") and wood finish (e.g. "Driftwood Ash") to the exact priced variant and its product
+     * URL, mirroring the on-page configurator's own selection flow. `matched: true` with a
+     * populated `variant` means exactly one real variant narrowed to; otherwise `candidates` lists
+     * every real variant the product query DID match, so a caller can narrow with an exact
+     * size/finish rather than guessing again. Never throws for an ambiguous or zero match — an
+     * unmatched product name is the one case this DOES treat as a caller error (throws, naming
+     * searchConfigurations()).
+     */
+    resolveVariant(productQuery: string, size: string, woodFinish: string): Promise<MaidenHomeVariantResolution>;
+  }
+}
+
 declare namespace BowmarkProvider_mailchimp {
   // ── Mailchimp — the unit's own declarations, verbatim ──
 interface mailchimpPlanTier {
@@ -7441,6 +9172,96 @@ interface medicareMedigapSearch {
   planTypes: medicareMedigapPlanType[];
 }
 
+interface medicarePlanDetail {
+  /** CMS's contract-plan-segment triple joined by '-', e.g. "S5884-103-0". */
+  id: string;
+  name: string;
+  nameSpanish: string | null;
+  organization: string;
+  contractId: string;
+  planId: string;
+  segmentId: string;
+  year: number;
+  /** CMS's own category string: "Medicare Advantage" / "Medicare Advantage with
+   * Prescription Drug Coverage" / "Medicare Prescription Drug Plan" /
+   * "Special Needs Plan". */
+  category: string;
+  planType: "PLAN_TYPE_PDP" | "PLAN_TYPE_MA" | "PLAN_TYPE_MAPD" | "PLAN_TYPE_SNP";
+  carrierUrl: string | null;
+  contractYear: string;
+  partcPremium: number;
+  partdPremium: number;
+  partbPremiumReduction: number;
+  /** Annual drug deductible in dollars; 0 means none. PDP only. */
+  drugPlanDeductible: number | null;
+  /** Annual in-network OOP maximum, verbatim. Empty when not published. */
+  maximumOopc: string;
+  /** Per-visit cost strings, verbatim. Empty when CMS publishes no figure —
+   * "$0" (a real benefit) and "" (not published) are deliberately distinct. */
+  primaryDoctorVisitCost: string;
+  specialistDoctorVisitCost: string;
+  emergencyCareCost: string;
+  /** MA/MAPD only — null on PDP, which has no primary/specialist visits. */
+  primaryDoctorCostSharing: string | null;
+  specialistDoctorCostSharing: string | null;
+  /** 1-5 in half steps, or null when CMS publishes none (with starRatingNote
+   * naming the reason — e.g. "too new to be rated"). */
+  starRating: number | null;
+  starRatingNote: string | null;
+  lowPerforming: boolean;
+  highPerforming: boolean;
+  /** All false on a PDP — supplemental benefits live on the Part C side. */
+  supplementalBenefits: {
+    silverSneakers: boolean;
+    transportation: boolean;
+    telehealth: boolean;
+    otcDrugs: boolean;
+    homeSafetyDevices: boolean;
+    inHomeSupport: boolean;
+    supportForCaregivers: boolean;
+    healthEducation: boolean;
+    counselingServices: boolean;
+    emergencyResponseDevice: boolean;
+    worldwideEmergency: boolean;
+  };
+  providerCoverage: {
+    /** False on plans with no network (e.g. PFFS); providers is then reliably empty. */
+    hasProviderCoverageData: boolean;
+    providerCount: number;
+  };
+  /** Extra Help / Low-Income Subsidy dollar amounts at each LIS band. */
+  lis: {
+    level100: number;
+    level75: number;
+    level50: number;
+    level25: number;
+  };
+  snpType: string;
+  dsnpIntegrationLevel: string;
+  /** When CMS marks the plan as terminated for the search year. */
+  terminatedWithoutCrosswalk: string | null;
+  /** Empty when the plan is published in full; the SPA hides fields CMS marks
+   * for redaction and the same fields arrive here. */
+  redactions: string[];
+}
+
+interface medicareGetPlanQuery {
+  /** "pdp" | "ma" | "mapd" | "snp" — the caller's MUST match the row they
+   * have in hand. The same (contractId, planId, segmentId) triple does NOT
+   * exist across plan types by design. */
+  planType: "pdp" | "ma" | "mapd" | "snp";
+  /** CMS's contract id (e.g. "S5884" for Part D, "H1234" for Part C). */
+  contractId: string;
+  planId: string;
+  segmentId: string;
+  /** Defaults to the current calendar year — CMS renumbers every January. */
+  year?: number;
+  /** 5-digit US ZIP. Required because the API is keyed on (fips, zip). */
+  zip: string;
+  /** Needed only for the rare ZIP that crosses a state line. */
+  county?: string;
+}
+
   /**
    * The US government's own Medicare site — Medicare Advantage, Part D and Medigap plan search
    * with real drug-cost estimates, the Care Compare directory of doctors, hospitals, nursing
@@ -7547,7 +9368,27 @@ interface medicareMedigapSearch {
      * coordinates — so `radiusFullyScanned` and `matchesInSearchedZips` carry the same
      * walked-radius honesty split `findDoctors` uses, for the identical reason.
      */
-    findHospitals(query: medicareHospitalQuery): Promise<medicareHospitalSearch>;
+    findHospitals(query: medicareHospitalQuery): Promise<medicareHospitalSearch>;
+
+    /**
+     * The full detail of one Part D / MA / MAPD / SNP plan, identified by its CMS
+     * contract-plan-segment triple (e.g. `S5884-103-0` for Part D, `Hxxxx-yyyy-0` for Part C).
+     * Returns the per-visit and per-event cost strings verbatim ('$0', '$20 copay', '20%', or
+     * empty when CMS publishes none), the annual in-network OOP maximum, the supplemental benefits
+     * (dental, fitness, telehealth, OTC drugs, transportation, worldwide emergency — PDPs set them
+     * all to false because the supplemental benefit half is a Part C thing), the CMS star rating
+     * with the explicit reason when none is published (e.g. 'too new to be rated' rather than
+     * rendering a null as a middling rating), the Extra Help / LIS dollar amounts at each band,
+     * the provider-coverage summary, and the carrier's own CMS-published page. `planType` must be
+     * the same discriminator `searchDrugPlans` / a future health-plan search used to find the
+     * triple — the same `(contractId, planId, segmentId)` does NOT exist across plan types by
+     * design, so the wrong one throws. `zip` is required because the API is keyed on (fips, zip),
+     * not on the plan id alone — without it there is no region to ask about. `year` defaults to
+     * the current calendar year. NOTE: the per-visit cost strings are verbatim and the difference
+     * between '$0' (a real zero-cost benefit) and '' (not published) is load-bearing — never
+     * coerce an empty string to 0.
+     */
+    getPlan(arg0: medicareGetPlanQuery): Promise<medicarePlanDetail>;
   }
 }
 
@@ -8472,6 +10313,114 @@ interface ottoSearchQuery {
   }
 }
 
+declare namespace BowmarkProvider_paypal {
+  // ── PayPal — the unit's own declarations, verbatim ──
+interface PaypalEstimateFeeArgs {
+  amount: number;               // > 0, in `currency`
+  currency: string;             // ISO 4217, e.g. "USD"
+  crossBorder: boolean;         // sender and recipient in different countries
+  fundingSource: "balance" | "bank" | "card" | "amexSend";
+}
+interface PaypalFeeCitation {
+  documentId: string;           // the CMS fee-table id this figure came from, e.g. "FEETB20"
+  feeDataKey: string;           // the exact published value used, e.g. "2.90%"
+  internalName: string;
+}
+interface PaypalFeeEstimate {
+  amount: number;
+  currency: string;
+  crossBorder: boolean;
+  fundingSource: "balance" | "bank" | "card" | "amexSend";
+  fee: number;
+  net: number;                  // amount - fee
+  citations: PaypalFeeCitation[];
+}
+interface PaypalGetFeesArgs {
+  audience?: "consumer";        // defaults to "consumer"; merchant is a separate, unverified page
+  country?: string;             // ISO 3166-1 alpha-2, defaults to "us"; only "us" is verified end-to-end
+}
+interface PaypalFeeToken {
+  feeDataKey: string;           // the exact published value, e.g. "2.90%" or "0.30 USD"
+  internalName: string;
+  percent: number | null;       // 0.029 when "2.90%", else null
+  amount: { amount: number; currency: string } | null;  // when "0.30 USD", else null
+}
+interface PaypalFeeRow {
+  labels: string[];             // plain-text label cells, in cell order
+  tokens: PaypalFeeToken[];     // every published fee token on the row, across all columns
+  cells: string[];              // plain-text rendering of each cell, in cell order
+  noFee: boolean;               // true iff the row carries no fee token (PayPal's "No fee" rows)
+  citations: PaypalFeeCitation[];
+}
+interface PaypalFeeTable {
+  documentId: string;           // the CMS fee-table id, e.g. "FEETB20"
+  caption: string;              // PayPal's own caption, e.g. "Sending domestic personal transactions"
+  rows: PaypalFeeRow[];
+}
+interface PaypalFeeSchedule {
+  audience: "consumer";
+  country: string;              // lowercased to match PayPal's URL path, e.g. "us"
+  sourceUrl: string;
+  tables: PaypalFeeTable[];
+}
+type PaypalConversionKind = "goodsOrServices" | "personal" | "payouts" | "other";
+interface PaypalCurrencyConversionCitation {
+  documentId: string;           // the CMS table id this figure came from, e.g. "FEETB26"
+  feeDataKey: string;           // the exact published value used, e.g. "4.00%"
+  internalName: string;
+}
+interface PaypalGetCurrencyConversionQuoteArgs {
+  kind?: PaypalConversionKind;  // "goodsOrServices" | "personal" | "payouts" | "other"
+  audience?: "consumer";        // defaults to "consumer"; merchant is a separate, unverified page
+  country?: string;             // ISO 3166-1 alpha-2, defaults to "us"; only "us" is verified end-to-end
+}
+interface PaypalCurrencyConversionQuote {
+  kind: PaypalConversionKind;   // which PayPal-conversion context the spread applies to
+  paypalSpread: number;         // 0.04 for goodsOrServices/personal/payouts; 0.03 for "other"
+  citations: { paypal: PaypalCurrencyConversionCitation };
+}
+
+  /**
+   * PayPal's public, signed-out surfaces: the published consumer and merchant fee schedules, the
+   * fee on one concrete personal (friends-and-family) transaction, the spread PayPal adds on a
+   * currency conversion, Pay Later instalment plans, PayPal.Me handle lookup, Help Center search
+   * and articles, the binding policy documents, PayPal Shopping cashback offers, crypto prices,
+   * and invoice payer-view reads. Three functions callable today — estimateFee, getFees,
+   * getCurrencyConversionQuote.
+   */
+  interface Unit {
+    /**
+     * Computes what PayPal charges to send a PERSONAL (friends-and-family) payment — domestic or
+     * cross-border, by funding source — off PayPal's own published fee schedule, e.g.
+     * estimateFee({ amount: 100, currency: "USD", crossBorder: false, fundingSource: "card" }) ->
+     * { fee: 3.2, net: 96.8, citations: [...] }. Does not (yet) cover goods-and-services/merchant
+     * transactions, a separate page nobody has walked.
+     */
+    estimateFee(args: PaypalEstimateFeeArgs): Promise<PaypalFeeEstimate>;
+
+    /**
+     * Reads PayPal's published fee schedule for one audience / country pair and returns every fee
+     * table on the page — every row, every published feeDataKey, with documentId-level citations —
+     * so a caller can inspect the schedule itself rather than asking about one amount. Currently
+     * consumer / us only; merchant is on a separate unverified page and other countries have not
+     * been fetched.
+     */
+    getFees(args: PaypalGetFeesArgs): Promise<PaypalFeeSchedule>;
+
+    /**
+     * Reads PayPal's published currency-conversion spread — the half of its fee it DOES disclose —
+     * off the same fees page (FEETB26, 4.00% for goodsOrServices/personal/payouts, 3.00% for
+     * "other"), e.g. getCurrencyConversionQuote({ kind: "goodsOrServices" }) -> { kind:
+     * "goodsOrServices", paypalSpread: 0.04, citations: { paypal: { documentId: "FEETB26",
+     * feeDataKey: "4.00%", internalName: "..." } } }. PayPal does NOT publish the wholesale base
+     * rate, so this function returns only the spread; combining it with a base rate from another
+     * provider (e.g. bowmark.providers.oanda.convertCurrency) is the capability tier's job, not a
+     * single provider's. consumer / us only today.
+     */
+    getCurrencyConversionQuote(args: PaypalGetCurrencyConversionQuoteArgs): Promise<PaypalCurrencyConversionQuote>;
+  }
+}
+
 declare namespace BowmarkProvider_pirateship {
   // ── Pirate Ship — the unit's own declarations, verbatim ──
 interface PirateshipDimensions {
@@ -8652,17 +10601,100 @@ interface PizzahutMenuItemWeight {
   priceCents: number;          // what THIS option costs on THIS variant — varies by size
 }
 
+// ── getMenu ───────────────────────────────────────────────────────────────
+interface PizzahutMenuArgs {
+  storeNumber: string;
+}
+
+interface PizzahutMenuVariant {
+  variantCode: string;
+  name: string | null;
+  priceCents: number;
+  attributes: string[];  // e.g. ["Original Pan® Pizza", "Personal Pan"]
+}
+
+interface PizzahutMenuListItem {
+  productCode: string;
+  name: string | null;
+  description: string | null;
+  categoryCode: string;
+  categoryName: string;
+  currency: string;
+  variants: PizzahutMenuVariant[];
+}
+
+interface PizzahutMenuCategory {
+  categoryCode: string;
+  categoryName: string;
+  items: PizzahutMenuListItem[];
+}
+
+interface PizzahutMenu {
+  storeNumber: string;
+  currency: string;
+  categories: PizzahutMenuCategory[];
+}
+
+// ── getDeals ──────────────────────────────────────────────────────────────
+// Mirrors the public types declared at the top of this file (PizzahutDeals,
+// PizzahutDeal, PizzahutDealImage, PizzahutDealScope) — copied here so the
+// rendered get_library blurb and the catalog signature are types the
+// gateway can resolve. The exported shapes are the source of truth.
+type PizzahutDealScopeForRender = "all" | { storeNumbers: string[] };
+
+interface PizzahutDealImageForRender {
+  url: string;
+  title: string | null;
+}
+
+interface PizzahutDealForRender {
+  position: number | null;
+  code: string;
+  name: string;
+  description: string | null;
+  legalText: string | null;
+  appImage: PizzahutDealImageForRender | null;
+  webImage: PizzahutDealImageForRender | null;
+}
+
+interface PizzahutDealsForRender {
+  storeNumber: string;
+  deals: PizzahutDealForRender[];
+  sources: { name: string; scope: PizzahutDealScopeForRender }[];
+}
+
   /**
    * Pizza Hut's US ordering site. `findStores` returns the stores serving any US address or ZIP,
    * nearest first, with each one's number, hours, distance, phone and the terms of the carryout
-   * and delivery it offers. `getMenuItem` reads one item's full store-level configuration by
-   * name — every size/crust, and every optional topping/sauce/cheese slot with what each choice
-   * costs on THAT variant. `priceOrder` then prices a basket at one of those stores WITHOUT
-   * placing it — line items, subtotal, sales tax, delivery fee and the real total Pizza Hut
-   * would charge, for carryout or to a delivery address, anonymously. Browsing the full menu
-   * list and reading the current deals are still stubs.
+   * and delivery it offers. `getMenu` reads a store's whole menu — every category, every item,
+   * and every variant's price at THAT store. `getMenuItem` reads one item's full store-level
+   * configuration by name — every size/crust, and every optional topping/sauce/cheese slot with
+   * what each choice costs on THAT variant. `getDeals` reads the deals and bundle offers Pizza
+   * Hut is running AT ONE STORE right now, filtered to what is actually redeemable there.
+   * `priceOrder` then prices a basket at one of those stores WITHOUT placing it — line items,
+   * subtotal, sales tax, delivery fee and the real total Pizza Hut would charge, for carryout or
+   * to a delivery address, anonymously.
    */
   interface Unit {
+    /**
+     * Reads a store's whole menu — every category (pizza, wings, pasta, sides, desserts, drinks,
+     * dips, melts, …), every item in each, and each item's variants with their price AT THAT
+     * STORE, all in cents. `storeNumber` comes from `findStores` and is required because Pizza
+     * Hut's prices are store-level — measured 2026-08-07, the same Pepperoni Pizza was $5.50 /
+     * $20.08 at store 026196 (North Hollywood CA) and $6.69 / $12.99 at store 027278 (Plano TX),
+     * all 11 variants differing between the two, so omitting the store would silently return
+     * whatever default the site happens to serve. One GraphQL read returns the whole menu in a
+     * single ~200 KB response (measured 2026-08-07 on store 026196: 20 categories, 138 items, 731
+     * variants, 731/731 with prices), so no fan-out is needed. Bundle items and bare-variant
+     * category items are out of scope — they are not configurable products — same exclusion as
+     * `flattenProductCatalog`. A variant is the priced configuration (size + crust already in
+     * `variantCode`), so a `variantCode` read here plus a `slotCode` / `modifierCode` /
+     * `modifierWeightCode` triple from `getMenuItem` is everything `priceOrder` needs to price a
+     * configured basket. Wholly anonymous: no account, no session, no identity of any kind, same
+     * guest-token read `priceOrder` and `getMenuItem` use.
+     */
+    getMenu(args: { storeNumber: string }): Promise<PizzahutMenu>;
+
     /**
      * Finds the Pizza Hut stores that serve a US location — each store's number, street address,
      * phone, opening hours, straight-line distance, online status, and the terms of every
@@ -8730,6 +10762,91 @@ interface PizzahutMenuItemWeight {
      * identifying.
      */
     getMenuItem(args: { storeNumber: string; item: string; category?: string }): Promise<PizzahutMenuItem>;
+
+    /**
+     * Reads the deals, coupons and bundle offers Pizza Hut is running AT ONE STORE right now —
+     * every deal that applies there, its bundle code, display name, description and legal text, in
+     * the order the site puts them on the deals page. `storeNumber` comes from `findStores` and is
+     * REQUIRED: Pizza Hut runs national deals AND franchise-local ones, and a deal listed but not
+     * available at the caller's store is the honest-vs-misleading line — the function filters by
+     * `MenuDealPageSortOverride.storesList` (a comma-separated list of stores, or the literal
+     * "ALL") so a caller gets only what is actually redeemable where they asked. The store's deals
+     * page lives on Contentful (NOT the Yum storefront GraphQL the rest of the provider hits): the
+     * deals page's own `__NEXT_DATA__.runtimeConfig` publishes `CONTENTFUL_SPACE_ID` +
+     * `CONTENTFUL_ACCESS_TOKEN` + `CONTENTFUL_ENVIRONMENT` + `CONTENTFUL_BASE_URL`, and this reads
+     * them out of the page rather than asking the caller for them. The bootstrap throws on a
+     * missing payload the way `parsePhdConfig` does — a 200 without the runtimeConfig is the
+     * Canadian site, and serving a caller the wrong country’s deals is worse than no answer. The
+     * list is sorted by `dealPagePosition` (1-based, lower = higher up); positions the site leaves
+     * null fall back to a stable code-order tiebreak rather than being treated as "first". Wholly
+     * anonymous, one Contentful read per call.
+     */
+    getDeals(args: { storeNumber: string }): Promise<PizzahutDealsForRender>;
+  }
+}
+
+declare namespace BowmarkProvider_premierbuildings {
+  // ── Premier Portable Buildings — the unit's own declarations, verbatim ──
+interface PremierbuildingsStyle {
+  key: string;
+  label: string;
+  sidingOptions: string[];
+  sizes: { sizeKey: string; width: number; length: number }[];
+}
+interface PremierbuildingsPrice {
+  styleKey: string;
+  model: string;
+  sizeKey: string;
+  width: number;
+  length: number;
+  sidingKey: string;
+  zip: string;
+  region: string;
+  basePrice: number;
+  sidingSurcharge: number;
+  total: number;
+  currency: "USD";
+}
+interface PremierbuildingsDealer {
+  key: string;
+  name: string;
+  city: string;
+  state: string;
+  zip: string;
+  phoneNumber: string;
+  dealerURL: string;
+}
+
+  /**
+   * Reads Premier Portable Buildings' own ShedView 3D configurator pricing catalogue — building
+   * styles, real available sizes, and region-exact siding surcharges — plus its real dealer
+   * directory.
+   */
+  interface Unit {
+    /**
+     * Lists every real building style Premier's ShedView configurator offers (Lofted Barn,
+     * Utility, Cabin, Garage, ...) with its real siding options and every real buildable size
+     * (width x length), read straight from the configurator's own live catalogue.
+     */
+    listBuildingStyles(): Promise<PremierbuildingsStyle[]>;
+
+    /**
+     * Prices one real Premier building configuration exactly the way ShedView itself does: the
+     * base price for `styleKey` + `sizeKey` in the pricing region `zip` falls under, plus the
+     * EXACT siding surcharge Premier's own rules add for `sidingKey` at that width and region (0
+     * for the default "urethane-siding"; a real dollar amount, never a guess, for an alternative
+     * like "metal" — the surcharge genuinely varies by both region and building width).
+     * `sidingKey` defaults to "urethane-siding" (Premier's standard siding) when omitted.
+     */
+    priceBuilding(styleKey: string, sizeKey: string, sidingKey: string | undefined, zip: string): Promise<PremierbuildingsPrice>;
+
+    /**
+     * Looks up Premier's real dealer locations in one US state or Canadian province (accepts
+     * either a full name like "Tennessee" or an abbreviation like "TN") — name, city, phone, and
+     * the dealer's own ShedView URL, straight from Premier's live dealer directory, for handing a
+     * priced configuration off to order.
+     */
+    findDealers(state: string): Promise<PremierbuildingsDealer[]>;
   }
 }
 
@@ -9975,6 +12092,38 @@ interface SearsProduct {
   description: string | null;
   specifications: SearsProductSpecification[];
 }
+interface SearsShippingAvailability {
+  available: boolean;
+  availableQuantity: number | null;
+  ffmType: string | null;
+  shipModes: string[];
+  dcUnitId: string | null;
+  promiseDate: string | null;
+  autoUpgrade: boolean;
+  freeShipping: boolean;
+  freeEligible: boolean;
+  freeQualified: boolean;
+}
+interface SearsStockStore {
+  unitId: string | null;
+  storeName: string | null;
+  storeBrand: string | null;
+  storeAddress: string | null;
+  promiseDate: string | null;
+  ffmType: string | null;
+}
+interface SearsPickupAvailability {
+  available: boolean;
+  stores: SearsStockStore[];
+  message: string | null;
+}
+interface SearsStock {
+  productId: string;
+  zipCode: string;
+  quantity: number;
+  shipping: SearsShippingAvailability | null;
+  pickup: SearsPickupAvailability;
+}
 
   /** Sears' own storefront — product search, product detail, fulfillment/stock and store locator. */
   interface Unit {
@@ -9998,6 +12147,67 @@ interface SearsProduct {
      * default (New York, 10101). THROWS on an id the site does not recognise.
      */
     getProduct(idOrUrl: string, opts?: { zipCode?: string }): Promise<SearsProduct>;
+
+    /**
+     * Answers whether a Sears product is buyable right now — for shipping/delivery AND for
+     * in-store/curbside pickup — the way the product page's own fulfillment panel does, in one
+     * call. `shipping` carries the site's own available quantity, ship modes and promise date.
+     * `pickup.stores` is the stores the site found able to fulfil it near `zipCode` — routinely
+     * empty (Sears' physical footprint has shrunk sharply), which is a real, common answer, not an
+     * error; `pickup.message` carries the site's own explanation when it is. `zipCode` narrows the
+     * search the way the site's own zip cookie does; omit it for the site's own default (New York,
+     * 10101). Takes the product id or URL from `search`/`getProduct` — same as `getProduct`.
+     */
+    checkStock(idOrUrl: string, opts?: { zipCode?: string; quantity?: number }): Promise<SearsStock>;
+  }
+}
+
+declare namespace BowmarkProvider_seegarsfence {
+  // ── Seegars Fence Company — the unit's own declarations, verbatim ──
+interface SeegarsBranch {
+  id: number;
+  name: string;
+  address1: string;
+  city: string;
+  state: string;
+  zip: string;
+  salesEmail: string;
+  salesPhone: string;
+  webSite: string;
+  outsideServiceAreaText: string;
+  serviceArea: string;
+}
+
+interface SeegarsGeocodedAddress {
+  address1: string;
+  city: string;
+  state: string;
+  zip: string;
+  displayName: string;
+  latitude: number;
+  longitude: number;
+}
+
+interface CheckServiceAreaResult {
+  address: SeegarsGeocodedAddress;
+  inServiceArea: boolean;
+  branch: SeegarsBranch;
+}
+
+  /**
+   * Fence/gate installer (Carolinas). checkServiceArea is live — geocodes an address and reports
+   * whether it's inside Seegars' service area, plus the branch that would handle it.
+   * estimateFencePrice (the actual priced estimate) is a stub — see its notImplemented reason.
+   */
+  interface Unit {
+    /**
+     * Geocodes a free-text address (`address`, e.g. "301 Fayetteville St, Raleigh, NC 27601")
+     * against Seegars Fence's own address-lookup API, then checks it against the branch's
+     * published service-area polygon — the same check the site's own Fence Price Estimator Tool
+     * performs before it will show any pricing. Returns the normalized address, whether it falls
+     * inside the service area, and the branch (name, phone, email, address) that would handle it.
+     */
+    checkServiceArea(args: object): Promise<CheckServiceAreaResult>;
   }
 }
 
@@ -10555,40 +12765,286 @@ interface StatefarmBusinessCoverage {
      * different things, so "State Farm will not cover you" can never be mistaken for "we could not
      * read the page".
      */
-    getRentersQuote(query: StatefarmRentersQuoteQuery | string): Promise<StatefarmRentersQuote>;
+    getRentersQuote(query: StatefarmRentersQuoteQuery | string): Promise<StatefarmRentersQuote>;
+
+    /**
+     * Prices a State Farm Business Owners Policy — commercial property and liability bundled — for
+     * one small business, and returns the carrier's own rated numbers: the assumed monthly
+     * instalment, the full 12-month premium, the deductible the price assumes, every named
+     * discount that moved it, and all ~60 coverages in the bundle with which are actually switched
+     * on. Measured 2026-08-01: an accounting LLC in Springfield IL is $52.92/mo and $635 for the
+     * term on a $1,000 deductible with 38 of 60 coverages selected, while an attorneys'
+     * corporation in Austin TX is $57.66/mo and $691.92 with 37 of 59 — the coverage counts differ
+     * because State Farm rates a BOP off state forms, so the SAME business is a different policy
+     * in a different state. This is the commercial line, not a personal one, so it asks for facts
+     * no personal-lines quote does: the trade classification, whether the premises are tenanted or
+     * owner-occupied, floor area, year built, gross annual receipts, headcount and the business
+     * personal property to insure. None of them is defaulted, because a defaulted square footage
+     * returns a real premium for a business that does not exist. It is a RATE LOOKUP that State
+     * Farm will not perform anonymously: the engine refuses to price until it has the owner's
+     * name, date of birth, email and phone, so `identity` is a required argument carrying the
+     * CALLER's own details, passed at call time and never held. The four underwriting answers are
+     * required too and are deliberately not defaulted — State Farm refuses an online quote
+     * outright to a business with a loss in the past five years or an existing State Farm business
+     * policy, so answering those on the caller's behalf would hand back a price the carrier would
+     * not have given them. What comes back is a price, not an offer, and State Farm's own words
+     * for that are returned verbatim as `disclaimer`. Where State Farm declines to quote online it
+     * says WHY rather than returning nothing: `StatefarmBusinessNotQuotable` carries the carrier's
+     * own reason code and a severity, and the two mean opposite things — a SOFT kickout (an
+     * unsupported trade, an owner-occupied building, a religious or government organisation) means
+     * an agent writes that policy, while a HARD one (11 states, a prior loss, an existing policy)
+     * means there is no online quote to be had at all. Commercial auto and workers' compensation
+     * are NOT this function: State Farm's own application router sends commercial auto to a
+     * no-quote page and publishes no online application for workers' comp, contractors or
+     * farm-and-ranch.
+     */
+    getBusinessQuote(query: StatefarmBusinessQuoteQuery): Promise<StatefarmBusinessQuote>;
+  }
+}
+
+declare namespace BowmarkProvider_stickergiant {
+  // ── StickerGiant — the unit's own declarations, verbatim ──
+// StickerGiant's OWN shape — not a capability contract.
+
+interface StickergiantListArgs {
+  format?: string;              // optional material code filter, e.g. "WHP"
+}
+
+interface StickergiantProduct {
+  url: string;                  // The configurator's own entry URL — durable key
+  name: string;                 // "Individual Stickers (Die Cut) - White"
+  sku: string;                  // The site's own material code, e.g. "WHP"
+  priceUsd: string;             // "$37.90" — per-100 stickers starting price
+  priceValue: number;           // Same number unformatted
+  priceCurrency: string;        // "USD"
+  availability: string;         // Schema.org URL, e.g. "https://schema.org/InStock"
+  imageUrl: string;
+}
+
+interface StickergiantBuild {
+  widthInches: number;          // required, from SITE_SIZES
+  heightInches: number;         // required, from SITE_SIZES
+  lamination: "OGL" | "MAL";    // required — Outdoor Gloss / Matte
+  quantity?: number;            // optional — omit for the full 15-tier ladder back
+}
+
+interface StickergiantQuantityPrice {
+  quantity: number;
+  price: number;                // the pricing engine's own total (not the rendered 'Total')
+  pricePerUnit: number;
+}
+
+interface StickergiantPriceResult {
+  selections: {                 // echoes back what the engine actually priced
+    widthInches: number;
+    heightInches: number;
+    lamination: "OGL" | "MAL";
+    product: string;            // "DCU" — the only product the API honors
+    material: string;           // "WHP" — the only material the API honors
+  };
+  selectedQuantity?: StickergiantQuantityPrice;  // when caller passed quantity
+  quantityPrices: StickergiantQuantityPrice[];   // always: the full 15-tier ladder
+}
+
+  /**
+   * StickerGiant's sticker configurator and its published catalog — every sticker SKU on
+   * /custom-stickers with its real starting price, material code and configurator entry URL.
+   */
+  interface Unit {
+    /**
+     * Lists every sticker SKU the /custom-stickers page publishes — name, the configurator's
+     * material URL, the site's own material code (sku), the per-100-stickers starting price the
+     * page carries in its schema.org Product block, the price currency, availability, and the
+     * page's hero image. Optional { format } restricts to one material code (e.g. 'WHP' for Die
+     * Cut White). THROWS rather than returning [] when the page carries no schema.org Product
+     * blocks or when the format filter names an unknown code — both are honest failure modes and
+     * an empty array would read as 'StickerGiant sells no stickers', which is the
+     * confident-wrong-answer failure this provider exists to avoid.
+     */
+    listStickerProducts(args?: StickergiantListArgs): Promise<StickergiantProduct[]>;
+
+    /**
+     * Prices one exact custom-sticker build against Sticker Giant's own live pricing backend (POST
+     * prod.pricing-backend.service.stickergiant.com/item) and returns the full 15-tier quantity
+     * ladder — each tier's price and price-per-unit. With a `quantity` passed, the response also
+     * carries a `selectedQuantity` with the priced value for that exact qty. The returned `price`
+     * is the pricing engine's own canonical number (not the rendered 'Total' on the page, which
+     * carries a small UI markup). THROWS on a missing lamination or out-of-range width/height —
+     * both are caller-fixable.
+     */
+    priceCustomSticker(build: StickergiantBuild): Promise<StickergiantPriceResult>;
+  }
+}
+
+declare namespace BowmarkProvider_sunhomesaunas {
+  // ── Sun Home Saunas — the unit's own declarations, verbatim ──
+// Sun Home Saunas' OWN shapes — not a capability contract.
+
+interface SunHomeSaunasQuizOption {
+  id: string;
+  label: string;
+}
+
+interface SunHomeSaunasQuizQuestion {
+  id: string;          // pass back as answers[].questionId
+  title: string;
+  type: string;        // the site's own node type, e.g. "SIMPLE_MULTI"
+  options: SunHomeSaunasQuizOption[];  // option.id -> answers[].optionIds
+}
+
+interface SunHomeSaunasMatch {
+  handle: string;       // the key addSaunaToCart takes
+  title: string;
+  price: number;        // dollars — real live Shopify price
+  matchScore: number;   // e.g. 5
+  matchOutOf: number;   // e.g. 5 -> the site's own "5/5 match"
+}
+
+interface SunHomeSaunasCartResult {
+  handle: string;
+  title: string;
+  variantId: number;
+  linePrice: number;      // dollars, for the quantity added
+  quantity: number;
+  cartItemCount: number;  // the live cart's total items AFTER this add
+  cartTotal: number;      // dollars — the live cart's total price after this add
+}
+
+  /**
+   * Sun Home Saunas' real Perfect Product Finder quiz — the site's own 5-question buyer quiz,
+   * its real server-computed ranked product matches with live prices, and a real Shopify cart
+   * write for the winning match — no login, no dealer routing.
+   */
+  interface Unit {
+    /**
+     * Reads Sun Home Saunas' real, live Perfect Product Finder quiz straight off its quiz vendor's
+     * own API — the current 5 questions and every real option, with the real ids
+     * getPersonalizedSaunaMatches() needs to answer them.
+     */
+    getSaunaFinderQuestions(): Promise<SunHomeSaunasQuizQuestion[]>;
+
+    /**
+     * Submits real answers (from getSaunaFinderQuestions()) through the same quiz session flow the
+     * site's own UI uses, and returns the site's own SERVER-COMPUTED ranked product matches with
+     * real live prices and a real match score — the exact personalized result a real buyer would
+     * see, never a guess from general knowledge.
+     */
+    getPersonalizedSaunaMatches(answers: {questionId: string, optionIds: string[]}[]): Promise<SunHomeSaunasMatch[]>;
+
+    /**
+     * Adds one real matched sauna (a handle from getPersonalizedSaunaMatches()) to a real Shopify
+     * cart at Sun Home Saunas' own real live price, and reads the cart back to confirm the write
+     * landed. THROWS if the product is currently out of stock.
+     */
+    addSaunaToCart(handle: string, quantity?: number): Promise<SunHomeSaunasCartResult>;
+  }
+}
+
+declare namespace BowmarkProvider_target {
+  // ── Target — the unit's own declarations, verbatim ──
+interface targetRow {
+  id: string;
+}
+
+interface TargetStoreHoursInterval {
+  begin_time: string;
+  end_date: string;
+  end_time: string;
+}
+
+interface TargetStoreHoursDay {
+  is_open: boolean;
+  date: string;
+  day_name: string;
+  hours: TargetStoreHoursInterval[];
+}
+
+interface TargetStoreGeoSpec {
+  iso_time_zone_code: string;
+  time_zone_code: string;
+  time_zone_utc_offset_name: string;
+}
+
+interface TargetStore {
+  id: string;
+  slug: string;
+  name: string;
+  address: string;
+  phone: string | null;
+  geoSpec: TargetStoreGeoSpec | null;
+  weeklyHours: TargetStoreHoursDay[];
+}
+
+interface TargetStoreSearch {
+  query: string;
+  stores: TargetStore[];
+  warnings: string[];
+}
+
+  /**
+   * Big-box general merchandise — search, product detail, store stock and store lookup on
+   * target.com.
+   */
+  interface Unit {
+    /**
+     * Searches the store-locator for nearby Targets by ZIP, partial ZIP, city, or street+city, and
+     * returns each store's id, slug, name, address, phone, time-zone and 14-day weekly hours.
+     */
+    findStore(args: { query: string }): Promise<TargetStoreSearch>;
+  }
+}
+
+declare namespace BowmarkProvider_teladoc {
+  // ── Teladoc Health — the unit's own declarations, verbatim ──
+interface teladocRow {
+  id: string;
+}
+
+interface teladocPricingRow {
+  service: string;
+  priceUsd: number;
+  unit: "visit" | "review" | null;
+  href: string | null;
+}
+
+interface teladocPricing {
+  source: string;
+  disclaimer: string;
+  services: teladocPricingRow[];
+}
+
+interface teladocInsuranceCoverage {
+  source: string;
+  headline: string;
+  headlinePriceUsd: number;
+  services: string[];
+  disclaimer: string;
+}
+
+  /**
+   * Virtual-care company: searches its public Health Library and self-pay visit pricing. Booking
+   * a visit requires a member login and is out of scope.
+   */
+  interface Unit {
+    /**
+     * Returns Teladoc's published self-pay (no-insurance) visit pricing — the per-visit dollar
+     * amount for each service line (24/7 Urgent Care, Nutrition, Dermatology, Mental Health), the
+     * unit (visit vs review), the page's own eligibility disclaimer, and the source URL. THROWS
+     * when the no-insurance tile renders without a price list (a real re-skin, not a zero-priced
+     * answer).
+     */
+    getPricing(): Promise<teladocPricing>;
 
     /**
-     * Prices a State Farm Business Owners Policy — commercial property and liability bundled — for
-     * one small business, and returns the carrier's own rated numbers: the assumed monthly
-     * instalment, the full 12-month premium, the deductible the price assumes, every named
-     * discount that moved it, and all ~60 coverages in the bundle with which are actually switched
-     * on. Measured 2026-08-01: an accounting LLC in Springfield IL is $52.92/mo and $635 for the
-     * term on a $1,000 deductible with 38 of 60 coverages selected, while an attorneys'
-     * corporation in Austin TX is $57.66/mo and $691.92 with 37 of 59 — the coverage counts differ
-     * because State Farm rates a BOP off state forms, so the SAME business is a different policy
-     * in a different state. This is the commercial line, not a personal one, so it asks for facts
-     * no personal-lines quote does: the trade classification, whether the premises are tenanted or
-     * owner-occupied, floor area, year built, gross annual receipts, headcount and the business
-     * personal property to insure. None of them is defaulted, because a defaulted square footage
-     * returns a real premium for a business that does not exist. It is a RATE LOOKUP that State
-     * Farm will not perform anonymously: the engine refuses to price until it has the owner's
-     * name, date of birth, email and phone, so `identity` is a required argument carrying the
-     * CALLER's own details, passed at call time and never held. The four underwriting answers are
-     * required too and are deliberately not defaulted — State Farm refuses an online quote
-     * outright to a business with a loss in the past five years or an existing State Farm business
-     * policy, so answering those on the caller's behalf would hand back a price the carrier would
-     * not have given them. What comes back is a price, not an offer, and State Farm's own words
-     * for that are returned verbatim as `disclaimer`. Where State Farm declines to quote online it
-     * says WHY rather than returning nothing: `StatefarmBusinessNotQuotable` carries the carrier's
-     * own reason code and a severity, and the two mean opposite things — a SOFT kickout (an
-     * unsupported trade, an owner-occupied building, a religious or government organisation) means
-     * an agent writes that policy, while a HARD one (11 states, a prior loss, an existing policy)
-     * means there is no online quote to be had at all. Commercial auto and workers' compensation
-     * are NOT this function: State Farm's own application router sends commercial auto to a
-     * no-quote page and publishes no online application for workers' comp, contractors or
-     * farm-and-ranch.
+     * Returns the with-insurance side of /start/no-insurance — the page's own headline figure (a
+     * literal '$0*' on the live page, since the per-plan price lives behind member.teladoc.com and
+     * is out of scope), the services the page promises are 'Included in your coverage*' (Primary
+     * Care, 24/7 Care, Mental Health, And more!), and the same eligibility disclaimer as
+     * `getPricing`. THROWS when the with-insurance tile renders without its service list, so a
+     * re-skin that drops the second tile or rewrites it in a way this parser cannot read surfaces
+     * as an error rather than an empty answer.
      */
-    getBusinessQuote(query: StatefarmBusinessQuoteQuery): Promise<StatefarmBusinessQuote>;
+    getInsurancePricing(): Promise<teladocInsuranceCoverage>;
   }
 }
 
@@ -10684,6 +13140,82 @@ interface TentreeCart {
   }
 }
 
+declare namespace BowmarkProvider_therabody {
+  // ── Therabody — the unit's own declarations, verbatim ──
+interface TherabodyVariant {
+  /** Shopify's numeric variant id as a string. The future addToCart entry. */
+  id: string;
+  /** The variant's own label, e.g. "Default Title". */
+  title: string;
+  /** Decimal string exactly as the store publishes it, e.g. "54998" (cents). */
+  price: string;
+  /** Same scale as price. Null when the product is not on sale. */
+  compareAtPrice: string | null;
+  /** The store's own SKU. Null on a product without one. */
+  sku: string | null;
+  /** Whether the variant is purchasable right now. */
+  available: boolean;
+  options: string[];
+}
+interface TherabodyProduct {
+  /** 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: TherabodyVariant[];
+  /**
+   * The store's own price scale per endpoint — see TherabodyVariant.price for
+   * why the two strings may differ. Range keeps the same scale as the input.
+   */
+  priceRange: { min: string; max: string } | null;
+  /** True if ANY variant is purchasable. The "is it in stock?" answer. */
+  inStock: boolean;
+  tags: string[];
+  /** Therabody's own images, in the order the storefront publishes them. */
+  images: string[];
+}
+interface TherabodyRecommendation {
+  /** The matching products, in-stock first, then by handle. */
+  products: TherabodyProduct[];
+  /** What the filter DROPPED, in the same register the rest of the library uses. */
+  warnings: string[];
+}
+
+  /**
+   * Therabody (Theragun) product catalogue — every device, its variants, its prices and what is
+   * in stock — read off the live Shopify storefront.
+   */
+  interface Unit {
+    /**
+     * Reads the live Therabody catalogue as Therabody 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 (warnings would be on an object envelope; this
+     * is a list). The catalog page is the line and the parse is the unit of work.
+     */
+    listTheragunProducts(opts?: { limit?: number }): Promise<TherabodyProduct[]>;
+
+    /**
+     * Reads one product by its handle — every variant, its exact price, the image the storefront
+     * is showing and whether that specific variant is purchasable right now. Takes the handle
+     * listTheragunProducts returns. THROWS on an unknown handle (the store answers a real 404).
+     */
+    getTheragunProduct(handle: string): Promise<TherabodyProduct>;
+
+    /**
+     * Filters the live catalogue by what a shopper actually needs — device family, audience, and
+     * the features named (percussion, recovery, hot/cold, breath). Returns the matching products
+     * with their real prices, ranked by in-stock first. The storefront does not publish a query or
+     * filter endpoint, so the function is local filtering on the catalogue listTheragunProducts
+     * already returns — the divide is what the function does with the data, not how it gets there.
+     */
+    recommendTheragun(criteria: { audience?: string; features?: string[]; inStockOnly?: boolean }): Promise<TherabodyRecommendation>;
+  }
+}
+
 declare namespace BowmarkProvider_thezebra {
   // ── The Zebra — the unit's own declarations, verbatim ──
 interface thezebraStateRatesQuery {
@@ -10948,6 +13480,47 @@ interface thezebraRentersQuotes {
   url: string
 }
 
+interface thezebraAutoDriver {
+  firstName: string
+  lastName: string
+  dob: string     // ISO YYYY-MM-DD — carriers rate on the DATE, not on an age
+  email: string
+}
+
+interface thezebraAutoVehicle {
+  year: number    // 4-digit; a model year The Zebra does not rate THROWS
+  make: string    // "Toyota", "Tesla"
+  model: string   // "Camry", "Model 3" — a TRIM is not a page
+}
+
+interface thezebraAutoQuotesQuery {
+  driver: thezebraAutoDriver
+  vehicle: thezebraAutoVehicle
+  state: string   // 2-letter postal code
+  zip: string     // 5 digits
+  county: string  // the county the ZIP sits in — the gateway validates server-side
+}
+
+interface thezebraAutoQuote {
+  carrier: string                       // e.g. "Progressive"
+  carrierSlug: string                   // the site's own slug, e.g. "progressive"
+  monthlyPremium: number                // USD per MONTH; the card's period is asserted
+  sixMonthPremium: number | null        // USD per 6-month policy, where the card publishes one
+  totalPremium: number | null           // USD for the whole term, never derived
+  policyLengthMonths: number | null
+  deductible: number | null
+  coverages: string[]                   // every coverage the card lists, verbatim
+}
+
+interface thezebraAutoQuotes {
+  quotes: thezebraAutoQuote[]           // cheapest monthly premium first; [] is a real answer
+  // The carriers ADVERTISED beside the quotes — paid placements with no price.
+  // Returned under their own name so they can never be read as offers.
+  advertisedCarriers: string[]
+  warnings: string[]                    // names every dropped source / what the gateway refused
+  url: string
+}
+
   /**
    * US insurance comparison marketplace — side-by-side auto, home and renters rates from 100+
    * carriers, plus published rate research by state, city, vehicle, carrier and driver history.
@@ -11121,6 +13694,68 @@ interface thezebraRentersQuotes {
      * homeowners funnel reaches the same results page and publishes no premium anywhere on it.
      */
     getRentersQuotes(query: thezebraRentersQuotesQuery): Promise<thezebraRentersQuotes>;
+
+    /**
+     * Returns REAL auto insurance quotes for one driver and one vehicle at a US ZIP — each
+     * carrier's own monthly and six-month premium, deductible, and the coverage it priced, as The
+     * Zebra's auto quote funnel prices them. This is a priced offer for the person asking, NOT the
+     * published averages `getStateRates` and its siblings return. Pass `driver` (`firstName`,
+     * `lastName`, `dob` ISO YYYY-MM-DD, `email`), one `vehicle` (`year`, `make`, `model` — a model
+     * The Zebra does not rate THROWS naming the URL it tried), the 2-letter `state`, a 5-digit
+     * `zip`, and `county` (the county the ZIP sits in — The Zebra validates it server-side and a
+     * missing or wrong county is bounced). **The write binds, the read does not — yet**: the
+     * GraphQL gateway at `graphql-gateway.production.thezebra.com` accepts the auto seed
+     * (`LegacyStartInput.start.currentlyInsured` is the only field Apollo currently exposes on
+     * that input), but the results route STILL bounces the session to the homepage with the four
+     * fields this function sends. The function throws on the bounce with a message naming the gap;
+     * the second required field on `LegacyStartInput` is the next attempt's work, and the rejected
+     * probes — `helpToday`, `userPurchaseTimeframe`, `hadActiveInsurance`, `residenceOwnership`,
+     * `presumedAnswers`, `policyLinkInfo`, `startDate`, `desiredCoverage` — are documented in
+     * `agents/capability-engineer/instances/vertical-insurance/tools/zebra-auto-quotes/shape-summary.json`
+     * (and the e5 clone) so they don't have to be re-derived. **`advertisedCarriers` is not a
+     * quote list and must never be read as one**: the results page would carry paid carrier
+     * placements alongside real offers, separated by `data-cy="results-card_ad_<carrier>"` (ad)
+     * versus `data-cy="results-card_q2b_<carrier>"` (real offer), and the advertised names are
+     * returned in their own field with no price attached. Every premium is USD and
+     * `monthlyPremium` is per MONTH — the card's own period is checked rather than assumed, and a
+     * card printing any other term THROWS instead of relabelling a figure. `totalPremium` is the
+     * site's own whole-term number and is never divided out of the monthly one.
+     */
+    getAutoQuotes(query: thezebraAutoQuotesQuery): Promise<thezebraAutoQuotes>;
+  }
+}
+
+declare namespace BowmarkProvider_topviewtix {
+  // ── TopView Sightseeing — the unit's own declarations, verbatim ──
+interface topviewtixPackageDetails {
+  id: number;
+  slug: string;
+  name: string;
+  description: string;
+  url: string;
+  adultsPrice: number | null;
+  kidsPrice: number | null;
+  isAdultOnly: boolean;
+  availableDates: string[];
+  blockedDates: string[];
+  soldOutDates: string[];
+  availableUntil: string | null;
+}
+
+  /**
+   * TopView's NYC hop-on-hop-off bus, Statue of Liberty cruise and bike/walking tour packages —
+   * getPackageDetails reads one package's live price and its own real-time booking calendar
+   * (available/blocked/sold-out dates) off topviewtix.com/new-york/<slug>.
+   */
+  interface Unit {
+    /**
+     * Reads one TopView tour package in full — name, description, adult/kid price, and the site's
+     * OWN live booking calendar (which dates are open, blocked, or sold out, and how far out the
+     * calendar reaches). Takes `slug`, the package's own URL slug off
+     * topviewtix.com/new-york/<slug> (e.g. "hop-on-hop-off-pass"). Throws if the slug doesn't
+     * resolve to a real package (a clean 404) rather than returning an empty row.
+     */
+    getPackageDetails(args: object): Promise<topviewtixPackageDetails>;
   }
 }
 
@@ -11271,6 +13906,46 @@ interface UlrichPriceResult {
   }
 }
 
+declare namespace BowmarkProvider_viewrail {
+  // ── Viewrail — the unit's own declarations, verbatim ──
+interface ViewrailMaterial {
+  slug: string;
+  title: string;
+  metal: boolean;
+  defaultFinish: string | null;
+  finishes: string[];
+}
+
+interface ViewrailMountingStyle {
+  slug: string;
+  title: string;
+  availableMaterials: string[];
+}
+
+  /**
+   * Cable railing / floating-stair manufacturer — the material and mounting-style catalog behind
+   * Victor, Viewrail's own draw-and-quote design app (victor.viewrail.com). listMaterials and
+   * listMountingStyles are live; the rest of Victor's option set (infill, posts, handrails,
+   * newels) are stubs.
+   */
+  interface Unit {
+    /**
+     * Lists the metal and metal-look composite families Victor's cable railing configurator offers
+     * (304/316/2205 stainless steel, aluminum, wood-grain aluminum, …), each with whether it's a
+     * true metal, its default finish, and every finish slug it supports — off Victor's own
+     * materials-config API.
+     */
+    listMaterials(): Promise<ViewrailMaterial[]>;
+
+    /**
+     * Lists Victor's post-mounting styles (Surface Mount, Side Mount, SLIM Side Mount, Bump Out
+     * Side Mount, Core Drill, …) and which material families each is available in — the first
+     * choice Victor's own design flow asks a user to make before drawing a run.
+     */
+    listMountingStyles(): Promise<ViewrailMountingStyle[]>;
+  }
+}
+
 declare namespace BowmarkProvider_visible {
   // ── Visible — the unit's own declarations, verbatim ──
 interface VisibleDealOffer {
@@ -11375,15 +14050,91 @@ interface VisibleGetPhoneResult {
   flashSale: VisiblePhoneFlashSale | null;
 }
 
+interface VisibleCoveragePoint {
+  matchedAddress: string | null;
+  city: string | null;
+  state: string | null;
+  zip: string | null;
+  latitude: number;
+  longitude: number;
+}
+
+interface VisibleCheckCoverageResult {
+  input: string;
+  point: VisibleCoveragePoint;
+  tier: "5gUltraWideband" | "5gNationwide" | "4gLte" | "none";
+  fiveGUltraWideband: boolean;
+  fiveGNationwide: boolean;
+  fourGLte: boolean;
+  /** The site's own one-word verdict, forwarded verbatim. Measured to disagree
+   * with the tier flags on a real point — trust the flags over this. */
+  summary: string;
+}
+
+interface VisibleSearchPhone {
+  slug: string;
+  name: string;
+  make: string;
+  deviceOs: string | null;
+  listPrice: number | null;
+  price: number | null;
+  monthlyPrice: number | null;
+  financingTermMonths: number | null;
+  inStock: boolean;
+  preOwned: boolean;
+  fiveG: boolean;
+  eSIMCompatible: boolean;
+  comingSoon: boolean;
+  tradeInEligible: boolean;
+  visiblePaybackEligible: boolean | null;
+  imageUrl: string | null;
+  source: string;
+  flashSale: VisiblePhoneFlashSale | null;
+}
+
+interface VisibleSearchPhonesResult {
+  source: string;
+  totalCatalogueCount: number;
+  filteredCount: number;
+  page: number;
+  pageSize: number;
+  hasMore: boolean;
+  availableMakes: string[];
+  results: VisibleSearchPhone[];
+}
+interface VisiblePlanFeature {
+  label: string | null;
+  items: string[];
+}
+interface VisiblePlan {
+  name: string;
+  monthlyPrice: number;
+  regularPrice: number | null;
+  promoCode: string | null;
+  promoText: string | null;
+  taxesAndFeesIncluded: boolean | null;
+  badge: string | null;
+  ctaCode: string | null;
+  ctaUrl: string | null;
+  features: VisiblePlanFeature[];
+}
+interface VisibleGetPlansResult {
+  source: string;
+  plans: VisiblePlan[];
+}
+
   /**
    * Visible (Verizon's prepaid brand): the promotions running right now — the offer grid with
    * its promo codes and fine print, plus the standing referral, trade-in, payback, Stack'em and
-   * Fios home-internet bundle programmes — and one phone in full from its catalogue slug or URL,
+   * Fios home-internet bundle programmes — one phone in full from its catalogue slug or URL,
    * every storage/colour SKU with its own price, monthly financing terms and live stock,
-   * alongside the specs, images, device-protection plans and eSIM/5G support. Also declared, not
-   * yet built: plan pricing, network coverage by address, bring-your-own-device compatibility,
-   * phone SEARCH across the catalogue, per-device trade-in values, international rates, the
-   * wearable catalogue and the support estate.
+   * alongside the specs, images, device-protection plans and eSIM/5G support — Verizon's real
+   * network coverage at a caller-supplied US address or ZIP, broken down by 5G Ultra Wideband /
+   * 5G Nationwide / 4G LTE rather than a single yes/no — and the three-tier line-up as the plans
+   * page renders it, with each tier's headline price, the running promo and the code that
+   * unlocks it, the marketing badge and the four labelled feature sections. Also declared, not
+   * yet built: bring-your-own-device compatibility, per-device trade-in values, international
+   * rates, the wearable catalogue and the support estate.
    */
   interface Unit {
     /**
@@ -11409,6 +14160,48 @@ interface VisibleGetPhoneResult {
      * that ended months ago.
      */
     getPhone(slugOrUrl: string, options?: { preOwned?: boolean }): Promise<VisibleGetPhoneResult>;
+
+    /**
+     * Returns the phones Visible currently sells, with the headline facts a purchase turns on —
+     * name, make, OS, list price, current price, financed monthly payment and term, in-stock
+     * status, pre-owned vs new, 5G support, eSIM compatibility, trade-in / Payback eligibility,
+     * and the catalogue image. Optional filters narrow by make (Apple, Samsung, Google, Motorola,
+     * TCL), by a `priceMax` the buyer's actually-going-to-pay price (NOT the strikethrough on a
+     * stale flash-sale banner), by 5G support, and by in-stock availability. Pagination is
+     * explicit and client-side over the catalogue's bounded 42-row response — the endpoint does
+     * NOT paginate server-side; every tried pagination parameter is ignored. Joins naturally with
+     * `getPhone`, which takes the same `slug` as its input — `searchPhones` answers "what does
+     * Visible sell?", `getPhone` answers "what does this specific device cost across storage and
+     * colour?".
+     */
+    searchPhones(options?: { make?: string; priceMax?: number; supports5G?: boolean; inStock?: boolean; page?: number; pageSize?: number }): Promise<VisibleSearchPhonesResult>;
+
+    /**
+     * Returns Verizon's real network coverage — the tier that actually determines usable speed (5G
+     * Ultra Wideband, 5G Nationwide, or 4G LTE) — at a caller-supplied US street address or
+     * 5-digit ZIP, straight from the same point-level lookup Verizon's own coverage map (embedded
+     * in visible.com/plans/coverage) queries. Geocodes the input first — a full address via the US
+     * Census Bureau's public geocoder, a bare ZIP via a ZIP-centroid lookup — then reads the tiers
+     * at that exact point, never a national or per-ZIP summary standing in for an address-level
+     * answer. Also returns the site's own one-word verdict ("Best"/"Good"/"Moderate"/"No
+     * Coverage") as `summary`, measured to sometimes DISAGREE with the tier flags — the flags are
+     * the ones to trust.
+     */
+    checkCoverage(addressOrZip: string): Promise<VisibleCheckCoverageResult>;
+
+    /**
+     * Returns the three tiers Visible sells today (Visible, Visible+, Visible+ Pro) as the plans
+     * page renders them — each tier's headline monthly price, the regular price the running promo
+     * unlocks (e.g. $19/mo with code SAVE6 unlocking $25/mo), the promo code itself, the "Taxes &
+     * fees included" guarantee, the marketing badge ("Most popular" / "Best value" / "Ultimate
+     * experience"), the CTA button code that pre-fills /shop/plan-selected, and four labelled
+     * feature sections (Network, Mobile Hotspot, International, The Extras) with every bullet the
+     * page shows. Reads the LIVE page only, never the site's own /docs/visible_plans.md, which is
+     * dated 2025-11-12 and answers the same prompt with two stale tiers and no code. Three tiers
+     * is hard — a future fourth tier changes the answer visibly rather than reading as a
+     * half-broken response.
+     */
+    getPlans(): Promise<VisibleGetPlansResult>;
   }
 }
 
@@ -11536,6 +14329,27 @@ interface wellfoundCompanyRow {
   highlightedRoles: { id: string; title: string; url: string; locations: string[] }[];
 }
 
+interface wellfoundCompanyDetail {
+  id: string;
+  name: string;
+  slug: string;
+  url: string;
+  highConcept: string | null;
+  productDescription: string | null;
+  companySize: string | null;
+  employeesMin: number | null;
+  employeesMax: number | null;
+  markets: string[];
+  stage: string | null;
+  activelyHiring: boolean;
+  badges: { id: string; label: string; tooltip: string | null }[];
+  locations: { slug: string; displayName: string }[];
+  remotePolicy: "remote" | null;
+  companyUrl: string | null;
+  totalRaisedAmount: number | null;
+  logoUrl: string | null;
+}
+
   /**
    * Wellfound (formerly AngelList Talent) — startup job search with salary and equity bands,
    * startup profiles and their open roles.
@@ -11584,6 +14398,95 @@ interface ShopifyVariant {
   /** The store's own per-variant stock flag. */
   available: boolean;
   options: string[];
+  /** The same values keyed by the option's own NAME — { Color: "Black", Size: "S" }.
+   * Read THIS to filter by size; options[1] is only the size on a store that
+   * happens to order it second. {} when the two lists cannot be reconciled. */
+  selectedOptions: Record<string, string>;
+  /** The image the STORE linked to this variant. Usually NULL — most storefronts
+   * publish no image-to-variant link at all, and null says so rather than
+   * handing back the first product picture. */
+  image: ProductImage | null;
+  /** Why this price is, or is not, a markdown. */
+  sale: SaleEvidence;
+}
+interface ProductImage {
+  /** Absolute HTTPS url, at the largest rendition the CDN serves. */
+  url: string;
+  /** The retailer's own alt text, or null. */
+  altText: string | null;
+  /** The retailer's colour name for this picture. Set when the store links it,
+   * or when the whole product is ONE colourway (which is how both yoga
+   * retailers publish: one colour per product). Null otherwise. */
+  color: string | null;
+  colorId: string | null;
+  /** Variant ids the STORE linked. [] means it published no link — NOT that the
+   * image belongs to every variant. */
+  variantIds: string[];
+}
+interface SaleEvidence {
+  /** True only with retailer evidence. NEVER set from a low price or from the
+   * word "sale" in a title. */
+  onSale: boolean;
+  currentPrice: string | null;
+  /** The published "was" price. Strictly greater than currentPrice when
+   * evidenceType is "compare_at_price". Null when nothing published one. */
+  originalPrice: string | null;
+  /** ISO 4217, or null. Null on the REST catalogue door, which publishes no
+   * currency — reported honestly rather than assumed to be USD. */
+  currency: string | null;
+  promotionMessage: string | null;
+  /** How it was decided. "compare_at_price" is a struck-through price;
+   * "retailer_sale_badge" is a published sale tag; "none" is not on sale. */
+  evidenceType: "compare_at_price" | "sale_price" | "retailer_sale_badge" | "published_promotion" | "none";
+  /** The retailer text or field the classification rests on, verbatim. */
+  evidenceText: string | null;
+}
+/** The retailer's own labels, read off its published tags, category and options.
+ * NEVER inferred from the title or from an image. Null or [] when unpublished,
+ * which is common and is an honest answer. */
+interface PublishedProductAttributes {
+  audience: string | null;
+  garmentType: "sports_bra" | "tank" | "crop_top" | "leggings" | "shorts" | "other" | null;
+  categories: string[];
+  collections: string[];
+  fabrics: string[];
+  materials: string[];
+  color: string | null;
+  colorFamily: string | null;
+  pattern: string | null;
+  styleTags: string[];
+  neckline: string | null;
+  strapWidth: string | null;
+  backDesign: string | null;
+  sleeveLength: string | null;
+  rise: string | null;
+  waistband: string | null;
+  inseam: string | null;
+  legShape: string | null;
+  fit: string | null;
+  coverage: string | null;
+}
+/** Shared colour, fabric, collection and style family — what makes two garments
+ * PLAUSIBLY coordinate. None of it establishes a set. */
+interface CoordinationMetadata {
+  collectionNames: string[];
+  fabricNames: string[];
+  colorName: string | null;
+  colorId: string | null;
+  colorFamily: string | null;
+  /** The store's own grouping key for one style across its colourways. Two
+   * products sharing it are the same garment in two colours. */
+  productFamily: string | null;
+}
+/** An EXPLICIT retailer-published relationship. Shared colour, fabric,
+ * collection or family is NOT this — that is CoordinationMetadata. Usually [];
+ * the catalogue door carries no set tags on any store measured. */
+interface RetailerSetEvidence {
+  evidenceType: "official_set" | "shop_the_set" | "complete_the_look" | "matching_piece";
+  evidenceText: string | null;
+  sourceUrl: string | null;
+  setId: string | null;
+  relatedProducts: Array<{ productId: string | null; handle: string | null; title: string | null; url: string | null }>;
 }
 interface ShopifyProduct {
   handle: string;
@@ -11597,6 +14500,14 @@ interface ShopifyProduct {
   inStock: boolean;
   tags: string[];
   descriptionHtml: string | null;
+  /** The same copy with its markup removed. */
+  descriptionText: string | null;
+  currency: string | null;
+  /** Every image the door published, deduplicated, in the store's own order. */
+  images: ProductImage[];
+  attributes: PublishedProductAttributes;
+  coordination: CoordinationMetadata;
+  retailerSetEvidence: RetailerSetEvidence[];
 }
 interface ShopifyCartLine {
   /** Shopify's own line key, which its cart-change endpoints address a line by. */
@@ -11610,6 +14521,30 @@ interface ShopifyCartLine {
   lineTotal: string;
   url: string;
 }
+/** One collection the store publishes — its own merchandised grouping, and the
+ * ONE place either yoga retailer states a set. Membership in a collection the
+ * retailer NAMED "Matching Sets" is a published fact and is admissible as set
+ * evidence; two products being adjacent inside it is NOT, because a position in
+ * a list is not a statement. */
+interface ShopifyCollection {
+  handle: string;
+  title: string;
+  url: string;
+  descriptionHtml: string | null;
+  /** True when the retailer's OWN title or handle names this a set, a matching
+   * piece or a look. Never inferred from what is inside it. */
+  setLike: boolean;
+  productCount: number | null;
+  updatedAt: string | null;
+}
+interface ShopifyCollectionProducts {
+  handle: string;
+  url: string;
+  /** In the RETAILER's own order. Curated collections are merchandised
+   * top-then-bottom; reading a pairing out of that order is the caller's
+   * inference, never this provider's claim. [] is an ordinary answer. */
+  products: ShopifyProduct[];
+}
 interface ShopifyCart {
   /** The store's own cart token — a bearer credential, so treat it like one. */
   token: string;
@@ -11641,6 +14576,20 @@ interface ShopifyCart {
      */
     getProduct(handle: string): Promise<ShopifyProduct>;
 
+    /**
+     * Lists the store's own merchandised collections. THIS is where a retailer states a SET: a
+     * collection the store itself named "Matching Sets" or "Activewear Sets" carries setLike:
+     * true, and membership in one is published evidence that two garments are sold together.
+     */
+    listCollections(opts?: { limit?: number }): Promise<ShopifyCollection[]>;
+
+    /**
+     * Reads one collection's products in the retailer's own merchandised order, as full product
+     * rows. An empty list is an ordinary answer — several named 'look' collections publish no
+     * products through this door.
+     */
+    getCollection(handle: string, opts?: { limit?: number }): Promise<ShopifyCollectionProducts>;
+
     /**
      * Puts variants into THIS run's own cart on the store and returns the cart the store reports
      * back. A real write: the cart exists on the store from the first call and belongs to this
@@ -11672,6 +14621,95 @@ interface ShopifyVariant {
   /** The store's own per-variant stock flag. */
   available: boolean;
   options: string[];
+  /** The same values keyed by the option's own NAME — { Color: "Black", Size: "S" }.
+   * Read THIS to filter by size; options[1] is only the size on a store that
+   * happens to order it second. {} when the two lists cannot be reconciled. */
+  selectedOptions: Record<string, string>;
+  /** The image the STORE linked to this variant. Usually NULL — most storefronts
+   * publish no image-to-variant link at all, and null says so rather than
+   * handing back the first product picture. */
+  image: ProductImage | null;
+  /** Why this price is, or is not, a markdown. */
+  sale: SaleEvidence;
+}
+interface ProductImage {
+  /** Absolute HTTPS url, at the largest rendition the CDN serves. */
+  url: string;
+  /** The retailer's own alt text, or null. */
+  altText: string | null;
+  /** The retailer's colour name for this picture. Set when the store links it,
+   * or when the whole product is ONE colourway (which is how both yoga
+   * retailers publish: one colour per product). Null otherwise. */
+  color: string | null;
+  colorId: string | null;
+  /** Variant ids the STORE linked. [] means it published no link — NOT that the
+   * image belongs to every variant. */
+  variantIds: string[];
+}
+interface SaleEvidence {
+  /** True only with retailer evidence. NEVER set from a low price or from the
+   * word "sale" in a title. */
+  onSale: boolean;
+  currentPrice: string | null;
+  /** The published "was" price. Strictly greater than currentPrice when
+   * evidenceType is "compare_at_price". Null when nothing published one. */
+  originalPrice: string | null;
+  /** ISO 4217, or null. Null on the REST catalogue door, which publishes no
+   * currency — reported honestly rather than assumed to be USD. */
+  currency: string | null;
+  promotionMessage: string | null;
+  /** How it was decided. "compare_at_price" is a struck-through price;
+   * "retailer_sale_badge" is a published sale tag; "none" is not on sale. */
+  evidenceType: "compare_at_price" | "sale_price" | "retailer_sale_badge" | "published_promotion" | "none";
+  /** The retailer text or field the classification rests on, verbatim. */
+  evidenceText: string | null;
+}
+/** The retailer's own labels, read off its published tags, category and options.
+ * NEVER inferred from the title or from an image. Null or [] when unpublished,
+ * which is common and is an honest answer. */
+interface PublishedProductAttributes {
+  audience: string | null;
+  garmentType: "sports_bra" | "tank" | "crop_top" | "leggings" | "shorts" | "other" | null;
+  categories: string[];
+  collections: string[];
+  fabrics: string[];
+  materials: string[];
+  color: string | null;
+  colorFamily: string | null;
+  pattern: string | null;
+  styleTags: string[];
+  neckline: string | null;
+  strapWidth: string | null;
+  backDesign: string | null;
+  sleeveLength: string | null;
+  rise: string | null;
+  waistband: string | null;
+  inseam: string | null;
+  legShape: string | null;
+  fit: string | null;
+  coverage: string | null;
+}
+/** Shared colour, fabric, collection and style family — what makes two garments
+ * PLAUSIBLY coordinate. None of it establishes a set. */
+interface CoordinationMetadata {
+  collectionNames: string[];
+  fabricNames: string[];
+  colorName: string | null;
+  colorId: string | null;
+  colorFamily: string | null;
+  /** The store's own grouping key for one style across its colourways. Two
+   * products sharing it are the same garment in two colours. */
+  productFamily: string | null;
+}
+/** An EXPLICIT retailer-published relationship. Shared colour, fabric,
+ * collection or family is NOT this — that is CoordinationMetadata. Usually [];
+ * the catalogue door carries no set tags on any store measured. */
+interface RetailerSetEvidence {
+  evidenceType: "official_set" | "shop_the_set" | "complete_the_look" | "matching_piece";
+  evidenceText: string | null;
+  sourceUrl: string | null;
+  setId: string | null;
+  relatedProducts: Array<{ productId: string | null; handle: string | null; title: string | null; url: string | null }>;
 }
 interface ShopifyProduct {
   handle: string;
@@ -11685,6 +14723,14 @@ interface ShopifyProduct {
   inStock: boolean;
   tags: string[];
   descriptionHtml: string | null;
+  /** The same copy with its markup removed. */
+  descriptionText: string | null;
+  currency: string | null;
+  /** Every image the door published, deduplicated, in the store's own order. */
+  images: ProductImage[];
+  attributes: PublishedProductAttributes;
+  coordination: CoordinationMetadata;
+  retailerSetEvidence: RetailerSetEvidence[];
 }
 interface ShopifyCartLine {
   /** Shopify's own line key, which its cart-change endpoints address a line by. */
@@ -11698,6 +14744,30 @@ interface ShopifyCartLine {
   lineTotal: string;
   url: string;
 }
+/** One collection the store publishes — its own merchandised grouping, and the
+ * ONE place either yoga retailer states a set. Membership in a collection the
+ * retailer NAMED "Matching Sets" is a published fact and is admissible as set
+ * evidence; two products being adjacent inside it is NOT, because a position in
+ * a list is not a statement. */
+interface ShopifyCollection {
+  handle: string;
+  title: string;
+  url: string;
+  descriptionHtml: string | null;
+  /** True when the retailer's OWN title or handle names this a set, a matching
+   * piece or a look. Never inferred from what is inside it. */
+  setLike: boolean;
+  productCount: number | null;
+  updatedAt: string | null;
+}
+interface ShopifyCollectionProducts {
+  handle: string;
+  url: string;
+  /** In the RETAILER's own order. Curated collections are merchandised
+   * top-then-bottom; reading a pairing out of that order is the caller's
+   * inference, never this provider's claim. [] is an ordinary answer. */
+  products: ShopifyProduct[];
+}
 interface ShopifyCart {
   /** The store's own cart token — a bearer credential, so treat it like one. */
   token: string;
@@ -11728,6 +14798,20 @@ interface ShopifyCart {
      * specific size or colour is purchasable right now.
      */
     getProduct(handle: string): Promise<ShopifyProduct>;
+
+    /**
+     * Lists the store's own merchandised collections. THIS is where a retailer states a SET: a
+     * collection the store itself named "Matching Sets" or "Activewear Sets" carries setLike:
+     * true, and membership in one is published evidence that two garments are sold together.
+     */
+    listCollections(opts?: { limit?: number }): Promise<ShopifyCollection[]>;
+
+    /**
+     * Reads one collection's products in the retailer's own merchandised order, as full product
+     * rows. An empty list is an ordinary answer — several named 'look' collections publish no
+     * products through this door.
+     */
+    getCollection(handle: string, opts?: { limit?: number }): Promise<ShopifyCollectionProducts>;
   }
 }
 
@@ -11740,23 +14824,30 @@ interface BowmarkProviders {
   aa: BowmarkProvider_aa.Unit;
   abercrombie: BowmarkProvider_abercrombie.Unit;
   ashleyfurniture: BowmarkProvider_ashleyfurniture.Unit;
+  avis: BowmarkProvider_avis.Unit;
   azure: BowmarkProvider_azure.Unit;
   barletta: BowmarkProvider_barletta.Unit;
   bhphoto: BowmarkProvider_bhphoto.Unit;
   blenderseyewear: BowmarkProvider_blenderseyewear.Unit;
+  bluehaven: BowmarkProvider_bluehaven.Unit;
   bmwusa: BowmarkProvider_bmwusa.Unit;
+  bykoket: BowmarkProvider_bykoket.Unit;
   cancer: BowmarkProvider_cancer.Unit;
+  caraway: BowmarkProvider_caraway.Unit;
   cars: BowmarkProvider_cars.Unit;
   cheapflights: BowmarkProvider_cheapflights.Unit;
   chriscraft: BowmarkProvider_chriscraft.Unit;
   classpass: BowmarkProvider_classpass.Unit;
   cloudflare: BowmarkProvider_cloudflare.Unit;
+  cyberpowerpc: BowmarkProvider_cyberpowerpc.Unit;
   decked: BowmarkProvider_decked.Unit;
+  dice: BowmarkProvider_dice.Unit;
   dickssportinggoods: BowmarkProvider_dickssportinggoods.Unit;
   dillards: BowmarkProvider_dillards.Unit;
   discounttire: BowmarkProvider_discounttire.Unit;
   erieinsurance: BowmarkProvider_erieinsurance.Unit;
   extraspace: BowmarkProvider_extraspace.Unit;
+  firstdibs: BowmarkProvider_firstdibs.Unit;
   flightradar24: BowmarkProvider_flightradar24.Unit;
   ford: BowmarkProvider_ford.Unit;
   framebridge: BowmarkProvider_framebridge.Unit;
@@ -11764,13 +14855,16 @@ interface BowmarkProviders {
   geico: BowmarkProvider_geico.Unit;
   google_flights: BowmarkProvider_google_flights.Unit;
   grainger: BowmarkProvider_grainger.Unit;
+  hauslabs: BowmarkProvider_hauslabs.Unit;
   healthcare_gov: BowmarkProvider_healthcare_gov.Unit;
   hellofresh: BowmarkProvider_hellofresh.Unit;
+  hellotend: BowmarkProvider_hellotend.Unit;
   hilton: BowmarkProvider_hilton.Unit;
   hunter: BowmarkProvider_hunter.Unit;
   ibuypower: BowmarkProvider_ibuypower.Unit;
   insurify: BowmarkProvider_insurify.Unit;
   interiordefine: BowmarkProvider_interiordefine.Unit;
+  joybird: BowmarkProvider_joybird.Unit;
   kayak: BowmarkProvider_kayak.Unit;
   labcorp: BowmarkProvider_labcorp.Unit;
   linkedin: BowmarkProvider_linkedin.Unit;
@@ -11778,6 +14872,7 @@ interface BowmarkProviders {
   lonelyplanet: BowmarkProvider_lonelyplanet.Unit;
   lufthansa: BowmarkProvider_lufthansa.Unit;
   lululemon: BowmarkProvider_lululemon.Unit;
+  maidenhome: BowmarkProvider_maidenhome.Unit;
   mailchimp: BowmarkProvider_mailchimp.Unit;
   marriott: BowmarkProvider_marriott.Unit;
   mcdonalds: BowmarkProvider_mcdonalds.Unit;
@@ -11792,22 +14887,32 @@ interface BowmarkProviders {
   newegg: BowmarkProvider_newegg.Unit;
   oanda: BowmarkProvider_oanda.Unit;
   otto: BowmarkProvider_otto.Unit;
+  paypal: BowmarkProvider_paypal.Unit;
   pirateship: BowmarkProvider_pirateship.Unit;
   pizzahut: BowmarkProvider_pizzahut.Unit;
+  premierbuildings: BowmarkProvider_premierbuildings.Unit;
   progressive: BowmarkProvider_progressive.Unit;
   prose: BowmarkProvider_prose.Unit;
   reddit: BowmarkProvider_reddit.Unit;
   ritani: BowmarkProvider_ritani.Unit;
   samsclub: BowmarkProvider_samsclub.Unit;
   sears: BowmarkProvider_sears.Unit;
+  seegarsfence: BowmarkProvider_seegarsfence.Unit;
   selectblinds: BowmarkProvider_selectblinds.Unit;
   semihandmade: BowmarkProvider_semihandmade.Unit;
   soundcloud: BowmarkProvider_soundcloud.Unit;
   statefarm: BowmarkProvider_statefarm.Unit;
+  stickergiant: BowmarkProvider_stickergiant.Unit;
+  sunhomesaunas: BowmarkProvider_sunhomesaunas.Unit;
+  target: BowmarkProvider_target.Unit;
+  teladoc: BowmarkProvider_teladoc.Unit;
   tentree: BowmarkProvider_tentree.Unit;
+  therabody: BowmarkProvider_therabody.Unit;
   thezebra: BowmarkProvider_thezebra.Unit;
+  topviewtix: BowmarkProvider_topviewtix.Unit;
   trektravel: BowmarkProvider_trektravel.Unit;
   ulrichlifestyle: BowmarkProvider_ulrichlifestyle.Unit;
+  viewrail: BowmarkProvider_viewrail.Unit;
   visible: BowmarkProvider_visible.Unit;
   walmart: BowmarkProvider_walmart.Unit;
   wellfound: BowmarkProvider_wellfound.Unit;
@@ -17278,6 +20383,7 @@ interface BowmarkProviders {
   avedaisland: BowmarkFamily_shopify_store.Unit;
   avenatheme: BowmarkFamily_shopify_store.Unit;
   avenidabresil: BowmarkFamily_shopify_store.Unit;
+  aventon: BowmarkFamily_shopify_store.Unit;
   aventsbyaugust: BowmarkFamily_shopify_store.Unit;
   aventureextension: BowmarkFamily_shopify_store.Unit;
   avenues3: BowmarkFamily_shopify_store.Unit;