@bowmark/web 1.3.0 → 1.5.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: 80346d8cf36c785e2b7fe0a77a87e5a51fa97ceb04ea11c951c71a9f7f75ad8e
-// 8 capabilities, 71 providers, 214 typed functions, 20 refused.
-// 51,711 family members, sharing 2 interface(s) — declared once and pointed at, never repeated per member.
+// Manifest version: 75ed32aa210bc375ea259fb61276ab65363d6b123ba60e63283bdfa36a58a3d5
+// 8 capabilities, 87 providers, 294 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
@@ -232,6 +232,71 @@ type BookingOptionsResult = {
                             // sellers are not in here. Empty means nothing dropped.
 }
 
+// Give EITHER flightNumber OR both origin and destination, plus date and airline.
+type FlightStatusQuery = {
+  airline: string          // IATA carrier code, e.g. "AA" — routes to the airline
+                            // that flies it; there is no default to guess
+  date: string              // the flight's ORIGIN date, ISO "2026-08-04"
+  flightNumber?: string     // "100", "2005", or "AA2005"
+  origin?: string           // IATA code — with destination, returns every NONSTOP
+  destination?: string      // that airline flies on the route that day
+}
+
+// One leg's status, at one end of the flight.
+type FlightStatusAirport = {
+  airportCode: string
+  cityName: string | null
+  gate: string | null        // null is UNKNOWN, not "no gate" — normal for a flight
+                              // weeks out
+  terminal: string | null
+  state: string | null
+  country: string | null
+  baggageClaim: string | null   // arrival end only
+  scheduledTime: string | null  // ISO 8601 WITH the airport's own UTC offset
+  estimatedTime: string | null
+  actualTime: string | null     // what happened, once it has; null before the event
+  scheduledBoardingTime: string | null   // departure end only
+  estimatedBoardingTime: string | null
+}
+
+type FlightStatusLeg = {
+  flightNumber: string
+  airlineCode: string
+  flightStatus: string | null      // the airline's own wording, verbatim
+  flightStatusKey: string | null   // a stable key behind the wording — branch on
+                                    // this, not the display string
+  flightStatusColor: string | null   // the airline's own severity colour, where
+                                      // it publishes one (GREEN, ORANGE, RED, ...)
+  canceled: boolean
+  diverted: boolean
+  inFlight: boolean
+  landed: boolean
+  departure: FlightStatusAirport
+  arrival: FlightStatusAirport
+  equipment: {
+    tailNumber: string | null
+    equipmentCode: string | null
+    iataName: string | null
+    displayName: string | null    // e.g. "Airbus A321neo"
+  }
+  disruptionMessage: string | null   // the airline's own passenger-facing prose
+  codeShare: boolean
+  operatedBy: string | null
+  marketingCarrier: string | null
+  wifiAvailable: boolean | null
+  powerPortAvailable: boolean | null
+}
+
+type FlightStatusResult = {
+  date: string                  // echoed back, "YYYY-MM-DD"
+  flightNumber: string | null   // null in route mode
+  origin: string | null
+  destination: string | null
+  flights: FlightStatusLeg[]    // EMPTY IS AN ANSWER: no such flight that day
+  warnings: string[]            // always present, same contract as every other
+                                 // function on this capability
+}
+
   /**
    * Search flights with one call and get back normalized, price-sorted results (the same
    * physical flight appears once). Each result carries the site it came from (`site`) and every
@@ -270,6 +335,24 @@ type BookingOptionsResult = {
      * on, whose sellers are not included.
      */
     getBookingOptions(flight: FlightResult, options?: CallOptions): Promise<BookingOptionsResult>;
+
+    /**
+     * A flight's live status, checked directly with the airline that flies it. Pass `airline` (an
+     * IATA carrier code, e.g. "AA") plus `date` (the flight's ORIGIN date, ISO "2026-08-04") and
+     * EITHER `flightNumber` OR both `origin` and `destination` (IATA airport codes) to get every
+     * nonstop that airline flies on that route that day. Each returned leg carries the airline's
+     * own status wording and a stable status key to branch on, the
+     * canceled/diverted/inFlight/landed booleans, scheduled/estimated/actual times at both ends as
+     * ISO strings with each airport's own UTC offset, gate, terminal and baggage claim, the
+     * aircraft, codeshare and operating carrier, and the airline's passenger-facing disruption
+     * message. THROWS for an `airline` no provider behind this capability implements, naming which
+     * ones can answer — there is no default carrier to guess, unlike `search`, which has no
+     * caller-supplied identity to route on in the first place. An empty `flights` array is a real
+     * answer: that airline flies no such flight that day, not a failure. `warnings` is always
+     * present, same contract as every other function here, though today it can only ever report a
+     * clamped `timeoutMs` — a single-carrier route has no fan-out to go thin.
+     */
+    getFlightStatus(query: FlightStatusQuery, options?: CallOptions): Promise<FlightStatusResult>;
   }
 }
 
@@ -446,6 +529,29 @@ type CarrierLicensing = {
   warnings: string[]         // always present; a timeoutMs clamp notice today
 }
 
+// listReferralCarriers: whose paper a referral/marketplace program's quote
+// actually places — a fact the quote row itself never states.
+type ReferralCarrierQuery = {
+  line?: string  // narrow to one property line, e.g. "homeowners" — NOT a closed
+                 // enum; an unmatched value throws, naming the lines the
+                 // directory actually publishes. Omit for the whole directory.
+}
+type ReferralCarrier = {
+  source: string             // which referral program this came from
+  name: string                // as the directory writes it
+  lines: string[]             // every property line this carrier is listed under
+  url: string | null          // the directory's own link for this carrier
+  ownedBySource: boolean | null  // true only for the referral program's OWN
+                                  // paper; null when the directory linked
+                                  // nothing for this row, so it said nothing
+                                  // to derive an answer from
+}
+type ReferralCarrierListResult = {
+  carriers: ReferralCarrier[]  // alphabetical by name
+  warnings: string[]           // always present; names a source that timed
+                               // out or failed
+}
+
 type CallOptions = {
   timeoutMs?: number   // per-provider budget in ms, default 30000, clamped to 1000-55000.
                        // A provider slower than this is DROPPED from the results and
@@ -516,6 +622,25 @@ type CallOptions = {
      * result to hand back. `options.timeoutMs` sets the budget (default 30000).
      */
     getLicensing(naicCode: string, options?: CallOptions): Promise<CarrierLicensing>;
+
+    /**
+     * Lists the carriers a referral/marketplace program actually places business with — the fact a
+     * quote row never states on its face. Reads Progressive's own published directory of outside
+     * property carriers (homeowners, renters, condo, dwelling-fire, manufactured-home) today. Call
+     * with no argument for the whole directory (16 carriers currently) or `{ line: "homeowners" }`
+     * to narrow to one line — `line` is NOT a closed enum; an unrecognized value THROWS naming the
+     * lines the directory actually publishes, because inventing a fixed list here would silently
+     * drop a line the site adds later. Each row carries every line that carrier is listed under
+     * (`lines`) and `ownedBySource` — true ONLY when the row is the referral program's own paper,
+     * derived from the directory's own linking rather than from name matching, and null when the
+     * directory linked nothing for that row. NEVER returns an empty list from a source that
+     * answered: this is a published directory with no legitimate empty case, so a missing section
+     * or a changed page throws at the provider rather than under-reporting who underwrites the
+     * policy. `warnings` is always present and names a source that timed out or failed — with one
+     * source today, read it before trusting a short list is the whole directory.
+     * `options.timeoutMs` sets the per-source budget (default 30000).
+     */
+    listReferralCarriers(query?: ReferralCarrierQuery, options?: CallOptions): Promise<ReferralCarrierListResult>;
   }
 }
 
@@ -789,18 +914,179 @@ interface aaFlightStatusResult {
   flights: aaFlight[];
 }
 
+interface aaReservation {
+  recordLocator: string;
+  status: string | null;
+  bookingTime: string | null;
+  passengers: aaReservationPassenger[];
+  itinerary: aaReservationSlice[];
+}
+
+interface aaReservationPassenger {
+  firstName: string | null;
+  lastName: string | null;
+  passengerID: string | null;
+  paxType: string | null;
+  loyaltyNumber: string | null;
+  ticketNumbers: string[];
+}
+
+interface aaReservationSlice {
+  segments: aaReservationSegment[];
+}
+
+interface aaReservationSegment {
+  flightNumber: string | null;
+  marketingCarrierCode: string | null;
+  operatingCarrierCode: string | null;
+  cabinType: string | null;
+  bookingCode: string | null;
+  departureDateTime: string | null;
+  legs: aaReservationLeg[];
+}
+
+interface aaReservationLeg {
+  originAirportCode: string | null;
+  originCity: string | null;
+  destinationAirportCode: string | null;
+  destinationCity: string | null;
+}
+
+interface aaRetrieveBookingArgs {
+  /** Exactly six letters — American's own record-locator format. */
+  recordLocator: string;
+  /** The passenger's last name, exactly as it appears on the reservation. */
+  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 is 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 {
-    // 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 — `getFlightStatus({ date, flightNumber, origin, destination })` declares no types for
     // its argument, so there is no honest signature to emit.
     // 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,
+     * passed at call time. Returns the record locator, American's own status string, when the
+     * booking was made, every passenger (name, passenger id, fare type, loyalty number, ticket
+     * numbers), and the itinerary as slices of flown segments (flight number, marketing and
+     * operating carrier codes, cabin, booking class, departure time, and each leg's
+     * origin/destination airport and city). Throws when the locator and last name do not both
+     * match a real reservation — American validates the pair together, so a real locator paired
+     * with the wrong last name answers exactly like one that does not exist at all; there is no
+     * way to tell those two cases apart from the outside. HONEST LIMIT: the not-found path is
+     * live-verified; the success shape above is reconstructed from American's own client code and
+     * has not been observed on the wire, since no consenting real booking was available to test it
+     * — see `retrieve-booking.ts` for what that means for field accuracy.
+     */
+    retrieveBooking(arg0: aaRetrieveBookingArgs): Promise<aaReservation>;
   }
 }
 
@@ -902,6 +1188,54 @@ interface abercrombieSearchQuery {
   maxItems?: number;
 }
 
+interface abercrombieStoreStock {
+  store: abercrombieStore;
+  inventoryStatus: string;
+  availableQuantity: number;
+  inStock: boolean;
+  availableFrom: string | null;
+  availableFromLabel: string | null;
+}
+
+interface abercrombieStock {
+  productId: string;
+  sku: string;
+  productName: string | null;
+  color: string | null;
+  url: string;
+  sizeLabel: string;
+  sizePrimary: string | null;
+  sizeSecondary: string | null;
+  primaryDimension: string | null;
+  secondaryDimension: string | null;
+  inStockOnline: boolean;
+  onlineQuantity: number;
+  onlineStatus: string;
+  preorderEligible: boolean;
+  price: number | null;
+  listPrice: number | null;
+  onSale: boolean;
+  currency: string;
+  findInStoreEligible: boolean;
+  pickupEligible: boolean;
+  stores: abercrombieStoreStock[] | null;
+}
+
+interface abercrombieStockQuery {
+  url?: string;
+  id?: string;
+  size?: string;
+  sizePrimary?: string;
+  sizeSecondary?: string;
+  sku?: string;
+  zip?: string;
+  city?: string;
+  state?: string;
+  radiusMiles?: number;
+  maxStores?: number;
+  brand?: "adult" | "kids" | "both";
+}
+
   /**
    * Abercrombie & Fitch's own storefront — product search, product detail, size/store stock,
    * store locator, current deals and gift card balance.
@@ -943,6 +1277,29 @@ interface abercrombieSearchQuery {
      */
     findStores(query: abercrombieStoreQuery): Promise<abercrombieStore[]>;
 
+    /**
+     * Answers whether ONE size of ONE colourway is buyable RIGHT NOW — online, and at the stores
+     * near a place you name. Identify the product with `url` or `id`, then the size with either
+     * `size` (the site's own label, e.g. "32 X Regular" or "M"), or `sizePrimary`+`sizeSecondary`,
+     * or a `sku` you already hold. Add `zip` OR `city`+`state` to also get per-store stock; omit
+     * all three and `stores` comes back `null` — "you did not ask", which is deliberately distinct
+     * from `[]`, "asked, and no store nearby carries it". Returns the resolved `sku`, the size and
+     * its dimension names, the online answer (`inStockOnline`, a real `onlineQuantity` — the site
+     * publishes counts like 305, not a flag — the site's own `onlineStatus` word,
+     * `preorderEligible`, price/listPrice/onSale), whether the colourway is eligible for the
+     * site's find-in-store and pick-up-in-store journeys at all, and one row per nearby store
+     * carrying that store's full record plus its `inventoryStatus`, `availableQuantity`, `inStock`
+     * and the date it expects the item. **`inStock` is the strict question and is NOT `status !==
+     * "Unavailable"`**: the site's commonest store answer is `Backorderable` with quantity 0,
+     * which means "we will order it for you", not "it is on the shelf" — so `inStock` is true only
+     * for `Available` WITH a quantity above zero. **An ambiguous size THROWS rather than
+     * guessing**: "26" names three lengths on a jean, and answering for one of them would be a
+     * wrong answer on a 200. A `sku` is looked up across the whole style and answers for the
+     * colourway it really belongs to, not the one in the url. This is the per-SIZE, per-STORE
+     * question; `getProduct` answers the different one of what sizes and colours a style comes in.
+     */
+    checkStock(query: abercrombieStockQuery): Promise<abercrombieStock>;
+
     /**
      * Searches or browses Abercrombie's live catalog the way the site's own search bar and
      * category navigation do. Pass EITHER `query` (free text, e.g. "wide leg jeans") OR `category`
@@ -1081,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 {
@@ -1428,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 {
@@ -1484,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
@@ -1510,6 +2069,236 @@ 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_cancer {
+  // ── National Cancer Institute (cancer.gov) — the unit's own declarations, verbatim ──
+type cancerCenterDesignation =
+  | "Comprehensive Cancer Center"
+  | "Clinical Cancer Center"
+  | "Basic Laboratory Cancer Center";
+
+interface cancerCenterRow {
+  name: string;
+  /** The center's own detail page on cancer.gov. */
+  url: string;
+  /** NCI's own state grouping — the authoritative field to filter on. */
+  state: string;
+  /** The "City, State" line the page publishes, verbatim. */
+  location: string;
+  /** A second location aside the page publishes for a few centers, e.g.
+   * "(in addition to facilities in Florida and Minnesota)" — present on a
+   * center that operates comprehensive facilities in more than one state and
+   * is cross-listed under each. */
+  locationNote?: string;
+  /** The parent university or health system, when distinct from the center's
+   * own name. Absent for freestanding centers (their own name IS the
+   * institution). */
+  hostInstitution?: string;
+  designation: cancerCenterDesignation;
+}
+
+interface cancerCentersResult {
+  /** Every center when no `state` filter is given; only the matching ones
+   * otherwise. */
+  total: number;
+  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. 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 {
+    /**
+     * The NCI-Designated Cancer Centers — the institutions NCI itself certifies as meeting its
+     * standards for cancer research and care — each with its name, its designation type
+     * (Comprehensive, Clinical, or Basic Laboratory), its city and state, its parent university or
+     * health system when it has one, and the link to its own cancer.gov detail page. `state`
+     * (NCI's own state name, e.g. "California", "Hawai'i", "District of Columbia", matched
+     * case-insensitively but exactly — no fuzzy matching) filters to that state; omitted, every
+     * center is returned. A center that operates comprehensive facilities in more than one state
+     * (Mayo Clinic Cancer Center) is cross-listed under each, with `locationNote` naming its other
+     * locations. This is the whole directory in one document — NCI does not filter it server-side
+     * — 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>;
   }
 }
 
@@ -1533,6 +2322,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;
@@ -1548,17 +2346,44 @@ 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 {
     /**
-     * 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
+     * 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
      * listing's ZIP and first-listed date, the site's own price badge, and the selling dealer.
      */
     getListing(listingId: string): Promise<carsListing>;
@@ -1570,6 +2395,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>;
   }
 }
 
@@ -1616,6 +2452,34 @@ interface KayakBookingOption {
   seatsRemaining: number | null;
 }
 
+interface KayakHotelQuery {
+  location: string;   // IATA airport code, e.g. "SFO", or a resolvable city
+  checkIn: string;    // YYYY-MM-DD
+  checkOut: string;   // YYYY-MM-DD
+  adults?: number;    // default 2
+  rooms?: number;     // default 1
+}
+
+// Cheapflights's OWN row shape for stays.
+interface KayakHotel {
+  id: string;
+  name: string;
+  price: number | null;        // per NIGHT, cheapest seller (normalized, see below)
+  totalPrice: number | null;   // the WHOLE stay — what rows are sorted on
+  currency: string;
+  seller: string;              // who sells that rate ("Priceline")
+  sellerCount: number | null;  // how many sellers quoted this property
+  stars: number | null;        // property stars, 1-5
+  score: number | null;        // guest score out of 10
+  reviewCount: number | null;
+  propertyType: string;        // "Hotel", "Motel", "Apartment"
+  neighborhood: string | null;
+  city: string | null;
+  distance: string | null;     // "11.7 mi", as the site renders it
+  distanceFrom: string | null; // what that distance is measured from
+  url: string;                 // deep link to the property
+}
+
 interface KayakCarQuery {
   pickup: string;          // IATA airport code, e.g. "SFO"
   dropoff?: string;        // defaults to pickup
@@ -1672,6 +2536,13 @@ interface KayakCar {
      */
     getBookingOptions(flight: KayakFlight): Promise<KayakBookingOption[]>;
 
+    /**
+     * Runs the stays search on cheapflights.com and returns priced properties for a destination
+     * and date range, cheapest TOTAL first. Interaction-gated: the prices only exist after the
+     * site's own multi-phase supplier poll completes.
+     */
+    searchHotels(query: KayakHotelQuery): Promise<KayakHotel[]>;
+
     /**
      * Runs the car-hire search on cheapflights.com and returns priced vehicles for a pickup
      * location and date range, cheapest-first. Interaction-gated: the prices only exist after the
@@ -1777,6 +2648,49 @@ interface ChriscraftPriceResult {
 
 declare namespace BowmarkProvider_classpass {
   // ── ClassPass — the unit's own declarations, verbatim ──
+/** Everything /v2/venues publishes about one studio — a superset of
+ *  ClasspassVenue, so anything holding one can hold the other. */
+interface ClasspassStudio extends ClasspassVenue {
+  /** What the studio does. On THIS function it comes from the venue record's own
+   *  tag block, so it is correct even on a day the studio publishes no classes. */
+  activities: string[];
+  /** ISO-3166 alpha-2, e.g. "US", "GB". */
+  country: string | null;
+  /** The site's neighbourhood label ("South Charlotte"). Null where it publishes none. */
+  neighborhood: string | null;
+  /** The metro area the studio is sold in ("Charlotte Metro", "London Metro"). */
+  metroArea: string | null;
+  description: string | null;
+  /** The studio's OWN site, not its ClassPass page. Null where it publishes none. */
+  website: string | null;
+  phone: string | null;
+  instagram: string | null;
+  facebook: string | null;
+  twitter: string | null;
+  /** Real photographs, largest first. ClassPass's generic fallback placeholders are
+   *  dropped — a placeholder passed off as the studio is worse than nothing. */
+  photos: string[];
+  logo: string | null;
+  /** Only the attributes the studio asserts, e.g. ["lgbtq_friendly",
+   *  "wheelchair_accessible"]. A false flag means "not claimed" and is dropped. */
+  inclusivity: string[];
+  bookingWindow: string | null;
+  whenToArrive: string | null;
+  whatToBring: string | null;
+  howToGetThere: string | null;
+  proTip: string | null;
+  cancellationPolicy: string | null;
+  /** null where the site holds no policy (it sends the sentinel "UNKNOWN"). */
+  lateCancellation: string | null;
+  demandSignals: string[];
+  /** ClassPass's own published fraction (0-1). Returned under the site's own name
+   *  and NOT relabelled a saving — the site does not document its basis. There is
+   *  no credit price on this record; per-class cost is getSchedule's `credits`. */
+  averageDiscount: number | null;
+  outOfNetwork: boolean;
+  spots: number | null;
+}
+
 interface ClasspassSchedule {
   venue: ClasspassVenue;
   /** Dates covered, YYYY-MM-DD in the venue's zone, ascending. A day with no
@@ -1840,14 +2754,83 @@ 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.
-   * `getSchedule` reads one studio's bookable timetable for a day or a week: every session with
-   * its start time, instructor, duration, credit price and whether it is still open. Studio and
-   * class search, the studio profile, per-slot availability and membership pricing are declared
-   * but not built yet.
+   * `getStudio` reads one studio's whole profile in a single request: what it does, where it is,
+   * its rating, amenities, photos, contact routes and the practical booking prose. `getSchedule`
+   * reads that studio's bookable timetable for a day or a week: every session with its start
+   * time, instructor, duration, credit price and whether it is still open. Studio and class
+   * 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
+     * alias in its public URL ("barrys-charlotte"), or the studio URL itself; all three are
+     * accepted. Returns identity and branch (a chain's locations differ only by `subtitle`), the
+     * full address with coordinates, IANA time zone, neighbourhood and metro area, the studio's
+     * own description, what it actually does (`activities`), amenities and the inclusivity
+     * attributes it asserts, its rating and how many reviews back it, real photographs
+     * (ClassPass's generic `fallback.jpg` placeholders are dropped rather than passed off as the
+     * studio), its own website, phone and socials, and the practical prose a booker needs —
+     * booking window, when to arrive, what to bring, how to get there, and the cancellation
+     * policies. NOTE ON PRICE: this record carries NO credit figure, measured across four venues —
+     * the only price-ish field ClassPass publishes here is `averageDiscount`, its own undocumented
+     * fraction, returned under its own name rather than relabelled as a saving. What a class COSTS
+     * is per-session and comes from `getSchedule`'s `credits`, which is both exact and free of a
+     * second request. A studio that has left ClassPass throws a caller-fixable error quoting the
+     * site's own reason ("Venue disabled") rather than returning a hollow profile.
+     */
+    getStudio(studio: number | string): Promise<ClasspassStudio>;
+
     /**
      * Reads ONE ClassPass studio's bookable timetable — what a person can actually book there, and
      * when. `studio` is a ClassPass venue id (74359), the alias in its public URL
@@ -1965,6 +2948,76 @@ interface CloudflareSearchDomainAvailabilityResult {
   }
 }
 
+declare namespace BowmarkProvider_cyberpowerpc {
+  // ── CyberPowerPC — the unit's own declarations, verbatim ──
+interface CyberpowerpcConfigurator {
+  slug: string;
+  name: string;
+  url: string;
+  price: string | null;
+  priceValue: number | null;
+  listPrice: string | null;
+  listPriceValue: number | null;
+  baselineSpecs: string[];
+}
+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.
@@ -2061,6 +3114,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 {
@@ -2212,6 +3293,58 @@ interface dillardsRegistry {
   items: dillardsRegistryItem[];
 }
 
+interface dillardsGetProductQuery {
+  url: string;
+}
+
+interface dillardsProductVariant {
+  sku: string;
+  color: string;
+  size: string | null;
+  shipsOnline: boolean;
+}
+
+interface dillardsProduct {
+  id: string;
+  catentryId: string;
+  name: string;
+  brand: string | null;
+  url: string;
+  description: string | null;
+  image: string | null;
+  images: string[];
+  priceLow: number | null;
+  priceHigh: number | null;
+  listPrice: number | null;
+  onSale: boolean;
+  rating: number | null;
+  reviewCount: number;
+  colorCount: number;
+  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.
@@ -2257,6 +3390,19 @@ interface dillardsRegistry {
      */
     checkStock(query: dillardsCheckStockQuery): Promise<dillardsStockResult>;
 
+    /**
+     * Reads one product's own page — full name, brand, description, primary image plus every
+     * gallery shot, current price range, pre-markdown `listPrice` and the site's own `onSale`
+     * flag, star rating and review count (both null/0 when the product has no reviews yet — the
+     * site omits the field entirely rather than publishing a zero), `colorCount` (distinct
+     * colourways), and `variants[]`, every size/color combination the page lists with its own sku
+     * and `shipsOnline` flag. Pass `url` exactly as `search` returns it in a row's own `url`.
+     * **This is a summary, not a store check** — `variants[].shipsOnline` is the product's own
+     * online-availability flag, independent of any physical store; whether ONE exact size/color is
+     * in stock at a named store is `checkStock`'s job, not this one's.
+     */
+    getProduct(query: dillardsGetProductQuery): Promise<dillardsProduct>;
+
     /**
      * Searches Dillard's wedding/gift registry (dillards.com/registry) — a distinctive Dillard's
      * feature, not a generic department-store search — and returns the matching registry's own
@@ -2279,6 +3425,23 @@ interface dillardsRegistry {
      * 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[]>;
   }
 }
 
@@ -2295,6 +3458,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;
@@ -2350,14 +3528,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
@@ -2371,6 +3603,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>;
   }
 }
 
@@ -2616,14 +3863,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 {
     /**
@@ -2663,6 +3934,26 @@ 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>;
   }
 }
 
@@ -2832,52 +4123,254 @@ interface fordNameplateDirectory {
   nameplates: fordNameplate[];
 }
 
-  /**
-   * 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
-   * 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.
-   */
-  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.
-    // A `(...args: unknown[])` stand-in would compile and tell you nothing.
+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;
+}
 
-    // UNTYPED, DELIBERATELY OMITTED — `listNameplates({ match })` declares no types for
-    // 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.
-  }
+interface fordTrimOffers {
+  trim: string;
+  programs: fordOfferProgram[];
 }
 
-declare namespace BowmarkProvider_framebridge {
-  // ── Framebridge — the unit's own declarations, verbatim ──
-// Framebridge's OWN shapes — not a capability contract.
+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 FramebridgeFrameStyle {
-  productId: string;   // the key getConfigurator/priceConfiguration take
-  handle: string;       // the site's own product/moulding permalink
-  title: string;
+interface fordVehicleImage {
   url: string;
-  priceRangeMin: number; // dollars — the cheapest size x conveyance combo
-  priceRangeMax: number;
+  /** "primary", "exterior" or "interior" — search results carry "primary"
+   * only; this endpoint returns the full set. */
+  role: string;
+  width: number | null;
+  height: number | null;
 }
 
-interface FramebridgeSizeOption {
-  size: string;          // "XS" | "S" | "M" | "L" | "XL" | "GR" | "XG" | "MG"
-  conveyance: "Digital" | "Physical";
-  price: number;         // this exact combination's own real price
-  variantId: string;
-}
+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. 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.
+   * `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 {
+    // 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.
+    // A `(...args: unknown[])` stand-in would compile and tell you nothing.
+
+    // UNTYPED, DELIBERATELY OMITTED — `listNameplates({ match })` declares no types for
+    // 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>;
+  }
+}
+
+declare namespace BowmarkProvider_framebridge {
+  // ── Framebridge — the unit's own declarations, verbatim ──
+// Framebridge's OWN shapes — not a capability contract.
+
+interface FramebridgeFrameStyle {
+  productId: string;   // the key getConfigurator/priceConfiguration take
+  handle: string;       // the site's own product/moulding permalink
+  title: string;
+  url: string;
+  priceRangeMin: number; // dollars — the cheapest size x conveyance combo
+  priceRangeMax: number;
+}
+
+interface FramebridgeSizeOption {
+  size: string;          // "XS" | "S" | "M" | "L" | "XL" | "GR" | "XG" | "MG"
+  conveyance: "Digital" | "Physical";
+  price: number;         // this exact combination's own real price
+  variantId: string;
+}
 
 interface FramebridgeMatOption {
   code: string;          // the value priceConfiguration's mats[] takes, e.g. "WH02"
@@ -2980,9 +4473,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 {
     /**
@@ -3016,6 +4542,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>;
   }
 }
 
@@ -3456,6 +5010,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;
@@ -3466,12 +5029,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
@@ -3481,6 +5087,26 @@ 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>;
   }
 }
 
@@ -4278,6 +5904,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 {
@@ -5523,6 +7215,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 {
@@ -5678,6 +7463,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 {
     /**
@@ -5686,6 +7482,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>;
   }
 }
 
@@ -6161,6 +7965,132 @@ interface LufthansaBaggageAllowance {
   }
 }
 
+declare namespace BowmarkProvider_lululemon {
+  // ── lululemon — the unit's own declarations, verbatim ──
+interface LululemonVariant {
+  /** The identifier lululemon's own checkout uses, e.g. "us_117376359". */
+  sku: string;
+  /** Which option each dimension is set to, e.g. { size: "4" }. */
+  options: Record<string, string>;
+  /** The store's own availability flag for this exact SKU. */
+  available: boolean;
+  price: number | null;
+  salePrice: number | null;
+}
+interface LululemonOptionGroup {
+  /** The machine name. "size" on every lululemon product measured. */
+  type: string;
+  /** The site's own label for the picker, e.g. "Size". */
+  label: string;
+  options: { value: string; label: string }[];
+}
+interface LululemonColorway {
+  /** lululemon's own colour code, e.g. "TRUE-NAVY". */
+  colorId: string;
+  color: string;
+  colorFamily: string | null;
+  price: number | null;
+  /** Set only when this colourway is marked down. */
+  salePrice: number | null;
+  promoMessage: string | null;
+  /** The product URL pinned to this colour, as the store publishes it. */
+  url: string;
+  swatchImage: string | null;
+  images: string[];
+  inStock: boolean;
+  optionGroups: LululemonOptionGroup[];
+  /** What can be BOUGHT in this colour right now — not the full size run. */
+  variants: LululemonVariant[];
+}
+interface LululemonSizeType {
+  /** A sibling product that is the same style in another length. */
+  productId: string;
+  size: string;
+  selected: boolean;
+}
+interface LululemonProduct {
+  id: string;
+  title: string;
+  brand: string;
+  url: string;
+  /** The store's own audience attribute, e.g. "women". */
+  gender: string | null;
+  rating: number | null;
+  reviewCount: number | null;
+  inStock: boolean;
+  priceLow: number | null;
+  priceHigh: number | null;
+  colorways: LululemonColorway[];
+  /** 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[];
+}
+interface LululemonRow {
+  id: string;
+  title: string;
+  url: string;
+  priceLow: number | null;
+  priceHigh: number | null;
+  colorCount: number | null;
+  inStock: boolean | null;
+  /** False when the row came from the site's product index and the catalogue
+   * behind the prices does not carry it. id and url still work. */
+  priced: boolean;
+}
+interface LululemonSearch {
+  query: string;
+  products: LululemonRow[];
+  /** How many entries matched before the row cap. */
+  matched: number;
+  warnings: string[];
+}
+interface LululemonSimilarProducts {
+  seedProductId: string;
+  products: LululemonRow[];
+  totalRanked: number | null;
+  warnings: string[];
+}
+
+  /**
+   * lululemon's athletic apparel catalogue — search it, and read one product's full
+   * configurator: every colourway with its own price and images, the size options, and which
+   * exact SKUs are buyable right now.
+   */
+  interface Unit {
+    /**
+     * Searches lululemon's catalogue by free text and returns matching product rows, closest match
+     * first — id, title, URL, price range, how many colours the style comes in, and whether it is
+     * in stock. Ranks over the site's own published product index, then reads the price and colour
+     * count per row. A match the pricing catalogue does not carry still comes back, with `priced:
+     * false` and null prices; `matched` says how many matched before the row cap so a caller can
+     * raise `limit` (default 8, max 24).
+     */
+    search(query: { query: string; limit?: number }): Promise<LululemonSearch>;
+
+    /**
+     * Reads one product's full configurator the way its product page presents it — every colourway
+     * with its own price, sale price, promo message, swatch, image set and URL; the size picker
+     * listing the sizes that colourway can CURRENTLY SELL; and one entry per sellable SKU with the
+     * store's own id, so a caller can answer 'which colours can I get in a 6 right now'. This feed
+     * expresses sold-out by OMISSION rather than by a flag — measured across all three captured
+     * fixtures, the picker and the SKU list are the same set in all 61 colourways and `available`
+     * is true on 363 of 363 SKUs — so presence is the stock signal and `available` is passed
+     * through rather than relied on.
+     */
+    getProduct(query: { productId: string }): Promise<LululemonProduct>;
+
+    /**
+     * 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
+     * one row per style. It is the store's ranking, not ours, and it does NOT reliably surface the
+     * same garment in another length: measured on the Align 25" pant, none of the six recommended
+     * rows was a sibling inseam even though the sitemap carries them, so reaching another length
+     * is a `search`.
+     */
+    getSimilarProducts(query: { productId: string; limit?: number }): Promise<LululemonSimilarProducts>;
+  }
+}
+
 declare namespace BowmarkProvider_mailchimp {
   // ── Mailchimp — the unit's own declarations, verbatim ──
 interface mailchimpPlanTier {
@@ -6206,6 +8136,29 @@ interface mailchimpPlanPricing {
   }
 }
 
+declare namespace BowmarkProvider_marriott {
+  // ── Marriott — the unit's own declarations, verbatim ──
+interface MarriottHotelListing {
+  id: string;      // marsha code
+  name: string;
+  brand: string;
+  url: string;
+  place: string;    // the resolved place slug, e.g. "usa-maryland"
+}
+
+  /** Marriott Bonvoy hotel search, award availability, reservations and property details. */
+  interface Unit {
+    /**
+     * Lists Marriott-family properties published on the site's own hotel-sitemap directory for one
+     * US state or country (`place`, e.g. "Maryland", "France" — never a bare city or landmark,
+     * which this directory does not index per property). `query` (optional) narrows the list by a
+     * case-insensitive substring match against each property's own display name, which often but
+     * not always carries a city. Returns each property's marsha id, name, brand and overview URL.
+     */
+    findHotels(args: { place: string; query?: string }): Promise<MarriottHotelListing[]>;
+  }
+}
+
 declare namespace BowmarkProvider_mcdonalds {
   // ── McDonald's — the unit's own declarations, verbatim ──
 interface mcdonaldsMenuItem {
@@ -6538,6 +8491,101 @@ interface medicareNursingHomeSearch {
   homes: medicareNursingHome[];
 }
 
+interface medicareHospitalMeasureGroup {
+  /** How many measures CMS defines for this group nationally. */
+  measuresInGroup: number | null;
+  /** How many of them THIS hospital actually reported — can be fewer than
+   * `measuresInGroup`; the gap is itself informative. */
+  measuresReported: number | null;
+  /** Null for `patientExperience`/`timelyAndEffectiveCare` — CMS publishes no
+   * national-average comparison for those two groups, only a rate. */
+  better: number | null;
+  noDifferent: number | null;
+  worse: number | null;
+  /** CMS's own footnote code(s), verbatim — occasionally more than one,
+   * comma-separated. */
+  footnote: string | null;
+}
+
+interface medicareHospital {
+  /** CMS Certification Number — the same id `findNursingHomes` and
+   * `findDoctors`'s hospital affiliations key on. */
+  ccn: string;
+  name: string;
+  address: string;
+  city: string;
+  state: string;
+  zip: string;
+  phone: string | null;
+  county: string | null;
+  /** Straight-line miles to the CENTROID OF THIS HOSPITAL'S OWN ZIP, not its
+   * street address — this dataset carries no coordinates at all, the same gap
+   * `findDoctors`'s clinician file has. Everyone sharing a ZIP shares a
+   * distance, and a large rural ZIP carries real slack. */
+  distanceMiles: number;
+  /** e.g. "Acute Care Hospitals", "Critical Access Hospitals", "Psychiatric",
+   * "Childrens", "Rural Emergency Hospital". Never "Long-term" — that type
+   * belongs to `findRehabAndLongTermCareFacilities`. */
+  hospitalType: string;
+  ownershipType: string | null;
+  emergencyServices: boolean;
+  birthingFriendly: boolean;
+  /** 1-5, or null when CMS publishes none — about 40% of hospitals nationally
+   * carry no overall rating, mostly because they don't participate in the
+   * reporting programs this rating requires, not because they scored poorly.
+   * A null is NOT a bad rating; read it with `overallRatingFootnote`. */
+  overallRating: number | null;
+  /** Can be present even alongside a real star rating — always surface it. */
+  overallRatingFootnote: string | null;
+  /** The measure GROUPS behind the star, not just the rollup. */
+  measureGroups: {
+    mortality: medicareHospitalMeasureGroup;
+    safety: medicareHospitalMeasureGroup;
+    readmission: medicareHospitalMeasureGroup;
+    patientExperience: medicareHospitalMeasureGroup;
+    timelyAndEffectiveCare: medicareHospitalMeasureGroup;
+  };
+}
+
+interface medicareHospitalQuery {
+  /** 5-digit US ZIP, placed via the Census Bureau's ZCTA centroid. Either this
+   * or a `latitude`/`longitude` pair is required. */
+  zip?: string;
+  latitude?: number;
+  longitude?: number;
+  /** Straight-line miles, default 25, max 100. */
+  radiusMiles?: number;
+  /** Max hospitals returned, default 20. `matchesInSearchedZips` reports the
+   * unlimited-by-`limit` count for the ZIPs actually searched. */
+  limit?: number;
+}
+
+interface medicareHospitalSearch {
+  origin: {
+    zip: string | null;
+    latitude: number;
+    longitude: number;
+    source: "zcta-centroid" | "caller";
+  };
+  radiusMiles: number;
+  /** ZIP Code Tabulation Areas the Census Bureau places inside the radius. */
+  zipsInRadius: number;
+  /** How many of them this call actually queried, nearest-batch-first. */
+  zipsSearched: number;
+  /** FALSE when the walk stopped before every ranked ZIP was queried —
+   * normally because `limit` was already satisfied. Read it before describing
+   * the result as "every hospital in the radius". */
+  radiusFullyScanned: boolean;
+  /** Hospitals found in the ZIPs actually searched, before `limit` — NOT a
+   * radius-wide total when `radiusFullyScanned` is false. */
+  matchesInSearchedZips: number;
+  /** CMS's own publication date for this extract. Not "today" — CMS refreshes
+   * quarterly. */
+  dataAsOf: string | null;
+  /** Nearest first. */
+  hospitals: medicareHospital[];
+}
+
 /** Whether a clinician takes Medicare's approved amount as payment in full.
  * NOT a boolean, and that is load-bearing: CMS's `ind_assgn` is only ever "Y"
  * or "M" — never "N" — so "does not take Medicare" is not a state this data can
@@ -6663,17 +8711,188 @@ interface medicareClinicianSearch {
   clinicians: medicareClinician[];
 }
 
+interface medicareMedigapDiscountRange {
+  min: number;
+  max: number;
+}
+
+/** How the premium changes with the buyer's age. Attained-age premiums RISE with
+ * age; issue-age and community-rated do not (community additionally moves with
+ * inflation for everyone at once, regardless of age). "unknown" is a real,
+ * intended value — see `ratingMethodRaw` on the policy it appears on — never a
+ * parse failure. */
+type medicareMedigapRatingMethod = "attainedAge" | "issueAge" | "communityRated" | "unknown";
+
+interface medicareMedigapPolicy {
+  /** The insurer, exactly as CMS lists it. A parenthetical suffix like
+   * "(Standard I)" is the SAME company selling this plan type under more than one
+   * underwriting tier, each priced separately — do not dedupe by a company name
+   * with the parenthetical stripped. */
+  company: string;
+  ratingMethod: medicareMedigapRatingMethod;
+  /** CMS's raw rate-type string, kept ONLY when `ratingMethod` is "unknown" — a
+   * value CMS started publishing after this mapping was written. Null whenever
+   * `ratingMethod` is one of the three known values. */
+  ratingMethodRaw: string | null;
+  monthlyRateMin: number;
+  monthlyRateMax: number;
+  address: string;
+  phoneNumber: string;
+  website: string | null;
+  /** A married/related-household discount, when this insurer offers one. Priced
+   * SEPARATELY from `householdDiscountRoommate` — one existing does not imply
+   * the other does. */
+  householdDiscountStandard: medicareMedigapDiscountRange | null;
+  /** An unrelated-adults-sharing-a-residence discount, priced separately from
+   * `householdDiscountStandard` and frequently absent when that one is present. */
+  householdDiscountRoommate: medicareMedigapDiscountRange | null;
+}
+
+interface medicareMedigapPlanType {
+  /** CMS's discriminator minus its "MEDIGAP_PLAN_TYPE_" prefix — "A", "HIGH_F", or
+   * a Minnesota/Wisconsin waiver type ("MN_BASIC", "WI_HIGH_DEDUCTIBLE", …). Pass
+   * this back as `searchMedigapPlans`'s `planType` argument to re-fetch just
+   * this one type. */
+  planType: string;
+  /** The range Medicare.gov reports ACROSS every insurer selling this plan type
+   * here, before picking one. Null means the `planType` filter named a type the
+   * overview did not list as offered here — `policies` is then reliably empty
+   * too, and null is the honest value rather than a fabricated 0. */
+  monthlyRateMin: number | null;
+  monthlyRateMax: number | null;
+  householdDiscountStandard: medicareMedigapDiscountRange | null;
+  householdDiscountRoommate: medicareMedigapDiscountRange | null;
+  /** Every insurer selling this plan type here. */
+  policies: medicareMedigapPolicy[];
+}
+
+interface medicareMedigapQuery {
+  /** 5-digit US ZIP. */
+  zip: string;
+  /** Omit to fetch every plan type the state offers. A result's own `planType`
+   * (`'G'`, `'HIGH_F'`, or a waiver state's `'MN_BASIC'`) fetches just that one. */
+  planType?: string;
+  /** Only needed for the rare ZIP that crosses a STATE line — Medigap is priced
+   * by state, so the wrong side returns a different market, not an error. */
+  county?: string;
+}
+
+interface medicareMedigapSearch {
+  zip: string;
+  /** Resolved from the ZIP, never taken from the caller — Medigap is priced by
+   * state and a wrong one silently returns an empty result rather than an error. */
+  state: string;
+  county: medicareCounty;
+  countiesConsidered: medicareCounty[];
+  /** Empty is a real, honest answer for a state/ZIP CMS reports no Medigap market
+   * data for — never a sign this call failed. */
+  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
    * homes, home health, hospice and dialysis providers with CMS quality ratings, the A-to-Z
-   * coverage database, and what Medicare itself costs this year. Part D drug-plan search, the
-   * doctor-and-clinician directory (specialties, group practice, hospital affiliations by name,
-   * and whether they accept Medicare assignment), the nursing-home directory with CMS's full
-   * Five-Star record (component ratings, staffing hours, fines, payment denials and Special
-   * Focus status), and the Medicare cost reference (premiums, deductibles, coinsurance tiers and
-   * the Part B/Part D income brackets) are callable now; the other fifteen declared functions
-   * are still stubs.
+   * coverage database, and what Medicare itself costs this year. Part D drug-plan search,
+   * Medigap plan search (every insurer selling each plan type, with its rating method and any
+   * household discount), the doctor-and-clinician directory (specialties, group practice,
+   * hospital affiliations by name, and whether they accept Medicare assignment), the
+   * nursing-home directory with CMS's full Five-Star record (component ratings, staffing hours,
+   * fines, payment denials and Special Focus status), the hospital directory with CMS's overall
+   * rating AND the five measure groups behind it (mortality, safety, readmission, patient
+   * experience, timely and effective care), and the Medicare cost reference (premiums,
+   * deductibles, coinsurance tiers and the Part B/Part D income brackets) are callable now; the
+   * other thirteen declared functions are still stubs.
    */
   interface Unit {
     // UNTYPED, DELIBERATELY OMITTED — `searchDrugPlans({ zip, year, county, limit })` declares no types for
@@ -6730,6 +8949,63 @@ interface medicareClinicianSearch {
      * `dataAsOf` carries CMS's own publication date — this is a periodic extract, not a live read.
      */
     findDoctors(query: medicareClinicianQuery): Promise<medicareClinicianSearch>;
+
+    /**
+     * The Medigap (Medicare Supplement) plan types sold in a ZIP's state, each with the insurers
+     * selling it, their premium range, their RATING METHOD (attained-age — rises with age;
+     * issue-age or community-rated — does not) and any household discount. `zip` is a 5-digit US
+     * ZIP; `county` disambiguates the rare ZIP that crosses a STATE line (Medigap is priced by
+     * state, not region), the same shape as `searchDrugPlans`'s own `county`. Omit `planType` to
+     * fetch every plan type the state offers (Minnesota and Wisconsin price under their own
+     * federal waiver — `MN_BASIC`, `WI_HIGH_DEDUCTIBLE`, etc. — rather than the national letters,
+     * and this function returns exactly what the state offers); pass a result's own `planType`
+     * (e.g. `'G'`, `'HIGH_F'`) to fetch just that one, one call instead of every letter's. NOTE
+     * the field the manifest exists for: two policies can share the same letter (which by law
+     * means identical coverage) and today's premium, and still diverge by hundreds of dollars a
+     * year within a decade purely because one is `attainedAge` and the other is not — never rank
+     * or recommend a Medigap policy on premium alone without surfacing `ratingMethod`.
+     */
+    searchMedigapPlans(arg0: medicareMedigapQuery): Promise<medicareMedigapSearch>;
+
+    /**
+     * The Medicare-registered hospitals near a place, nearest first, each with CMS's overall star
+     * rating AND the five measure groups behind it (mortality, safety, readmission, patient
+     * experience, timely and effective care — each with how many measures the hospital reported
+     * and, for the first three, how many beat/matched/trailed the national average), the hospital
+     * type (acute care, critical access, psychiatric, children's, rural emergency, VA, DoD — never
+     * the long-term/rehab types `findRehabAndLongTermCareFacilities` covers), ownership, whether
+     * it offers emergency services, and CMS's birthing-friendly designation. Pass a 5-digit `zip`
+     * (placed via the Census Bureau's ZCTA centroid) or a `latitude`/`longitude` pair;
+     * `radiusMiles` defaults to 25 (max 100) and `limit` to 20. NOTE the two things that make this
+     * answer honest. (1) `overallRating` is null for roughly 40% of hospitals nationally — mostly
+     * small or non-reporting facilities, not poor performers — and is never the whole story: read
+     * it alongside `measureGroups`, since a hospital can report zero of a group's measures and
+     * still carry an overall star from the groups it does report. (2) `distanceMiles` is to the
+     * centroid of the hospital's own ZIP, not its street address — this dataset carries no
+     * coordinates — so `radiusFullyScanned` and `matchesInSearchedZips` carry the same
+     * walked-radius honesty split `findDoctors` uses, for the identical reason.
+     */
+    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>;
   }
 }
 
@@ -7598,6 +9874,34 @@ interface ottoProduct {
   sizes: { label: string; selected: boolean; available: boolean }[];
   colors: { label: string; selected: boolean; available: boolean; image: string | null }[];
 }
+interface ottoSearchPrice {
+  currentAmount: number;
+  currentDisplay: string;
+  suggestedRetailAmount: number | null;
+  suggestedRetailDisplay: string | null;
+  comparativeAmount: number | null;
+  comparativeDisplay: string | null;
+  onSale: boolean;
+  isStartingPrice: boolean;
+}
+interface ottoSearchResult {
+  productId: string;
+  variationId: string;
+  articleNumber: string;
+  url: string;
+  name: string;
+  brand: string;
+  price: ottoSearchPrice;
+  availability: { state: string; detail: string };
+  thumbnail: string | null;
+  rating: { value: number; count: number } | null;
+  matchType: string;
+  totalCount: number;
+}
+interface ottoSearchQuery {
+  query: string;
+  limit?: number;
+}
 
   /** German online marketplace — fashion, furniture, electronics and more. */
   interface Unit {
@@ -7609,6 +9913,99 @@ interface ottoProduct {
      * retired listing).
      */
     getProduct(url: string): Promise<ottoProduct>;
+
+    /**
+     * Searches OTTO's catalog for a free-text keyword the way the site's own search bar does,
+     * across its whole marketplace (OTTO's own catalog and third-party sellers) and returns
+     * matching rows: price (current + UVP + the site's own comparison price when it publishes
+     * one), availability, brand, rating and a thumbnail. `matchType` on each row is the site's own
+     * retrieval-type token ("hybrid" for a real keyword match, "semantic" when nothing matched
+     * literally and the site is showing similar items instead — OTTO's engine almost never returns
+     * a hard empty result). Returns one page (up to ~150 rows); `totalCount` on each row is the
+     * site's own total match count across every page. `url` feeds `getProduct` directly for OTTO's
+     * own catalog rows; a third-party marketplace row's URL does not match `getProduct`'s current
+     * `-C<id>/` pattern.
+     */
+    search(query: ottoSearchQuery): Promise<ottoSearchResult[]>;
+  }
+}
+
+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[];
+}
+
+  /**
+   * PayPal's public, signed-out surfaces: the published consumer and merchant fee schedules, the
+   * fee on one concrete personal (friends-and-family) transaction, currency-conversion quotes
+   * and the spread PayPal adds, 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. Two functions callable today — estimateFee, getFees.
+   */
+  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>;
   }
 }
 
@@ -7751,15 +10148,141 @@ interface PizzahutPricedLineItem {
   specialInstructions: string | null;
 }
 
+// ── getMenuItem ───────────────────────────────────────────────────────────
+interface PizzahutMenuItem {
+  storeNumber: string;
+  productCode: string;   // pass this + a variantCode below to priceOrder
+  name: string | null;
+  description: string | null;
+  category: string | null;
+  currency: string;
+  variants: PizzahutMenuItemVariant[];
+}
+
+interface PizzahutMenuItemVariant {
+  variantCode: string;   // the priced configuration — size and crust are IN this code
+  name: string | null;
+  priceCents: number;    // this variant's OWN starting price
+  attributes: string[];  // e.g. ["Original Pan® Pizza", "Personal Pan"]
+  slots: PizzahutMenuItemSlot[];
+  servingSize: { quantity: number; unit: string } | null;
+  allergens: { allergen: string; presence: string }[];
+}
+
+interface PizzahutMenuItemSlot {
+  slotCode: string;                    // e.g. "slot_pizza_cheese", "slot_toppings"
+  name: string | null;
+  minAllowedSelections: number;
+  maxAllowedSelections: number | null; // null = no cap the site publishes
+  modifiers: PizzahutMenuItemModifier[];
+}
+
+interface PizzahutMenuItemModifier {
+  modifierCode: string;
+  name: string | null;
+  weights: PizzahutMenuItemWeight[];   // portion/intensity choices for this modifier
+}
+
+interface PizzahutMenuItemWeight {
+  modifierWeightCode: string;  // pass slotCode + modifierCode + this to priceOrder's modifiers
+  name: string | null;         // e.g. "Light", "Regular", "Extra"
+  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. `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. Reading the store menu and
-   * the current deals are declared and 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
@@ -7806,6 +10329,47 @@ interface PizzahutPricedLineItem {
      * cart so totals never accumulate across calls.
      */
     priceOrder(order: { storeNumber: string; items: { productCode: string; variantCode: string; quantity?: number; modifiers?: { slotCode: string; modifierCode: string; modifierWeightCode: string }[]; specialInstructions?: string }[]; fulfillment?: "carryout" | "delivery"; deliveryAddress?: { address: string; address2?: string; city: string; state: string; zip: string; deliveryInstructions?: string; phone?: string }; requestedTime?: string; promoCode?: string }): Promise<PizzahutPricedOrder>;
+
+    /**
+     * Reads one menu item in full for a store — every size/crust it comes in, each one's own
+     * starting price, and every optional slot (sauce, cheese, toppings, seasoning, cut) with what
+     * each choice costs ON THAT VARIANT, plus nutrition serving size and allergens where the site
+     * publishes them. `storeNumber` comes from `findStores`. `getMenu` (the sibling function that
+     * would normally hand out a `productCode` to browse by) is still a stub, so `item` is a NAME
+     * instead — "Pepperoni Pizza" — matched first as an exact `productCode` if you already have
+     * one, then an exact case-insensitive name, then a substring; `category` (a code like "pizza"
+     * or a display name like "Pizza") narrows the search when a name alone is ambiguous. Zero
+     * matches or more than one both throw as caller-fixable, the second one listing every
+     * candidate's name, category and `productCode` so a retry can pick one exactly.
+     * **Configuration prices are per VARIANT, not per product** — measured 2026-08-06 on the same
+     * Pepperoni Pizza, Extra Cheese is +$0.50 on a Personal Pan, +$2.89 on a Medium, +$3.39 on a
+     * Large, so this returns each variant's own priced slot tree rather than one flat add-on price
+     * for the whole item. A `variantCode` plus a `slotCode`/`modifierCode`/`modifierWeightCode`
+     * triple read here is exactly what `priceOrder` takes to price a configured basket. Wholly
+     * anonymous, same guest-token read `priceOrder` uses — no account, no session, nothing
+     * 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>;
   }
 }
 
@@ -9029,6 +11593,60 @@ interface SearsSearchQuery {
   zipCode?: string;
   limit?: number;
 }
+interface SearsProductPrice {
+  currentAmount: number;
+  currentDisplay: string;
+  regularAmount: number | null;
+  regularDisplay: string | null;
+  onSale: boolean;
+}
+interface SearsProductSpecification {
+  label: string;
+  attributes: string[];
+}
+interface SearsProduct {
+  productId: string;
+  url: string;
+  name: string;
+  brand: string | null;
+  price: SearsProductPrice;
+  inStock: boolean;
+  images: string[];
+  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 {
@@ -9042,6 +11660,28 @@ interface SearsSearchQuery {
      * further paging parameter this function reaches.
      */
     search(query: SearsSearchQuery): Promise<SearsSearchResult[]>;
+
+    /**
+     * Reads one Sears product in full: name, brand, current and regular price, whether it's in
+     * stock, every image and the site's own full labelled spec sheet (dimensions, features,
+     * overview). Takes the product id or full URL from Sears's own "/p-<id>" pattern — `search`
+     * returns both, so the ordinary path is a `search` row's `id` or `url`. `zipCode` narrows
+     * price/availability the way the site's own zip cookie does; omit it for the site's own
+     * 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>;
   }
 }
 
@@ -9636,6 +12276,198 @@ interface StatefarmBusinessCoverage {
   }
 }
 
+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_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>;
+
+    /**
+     * 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.
+     */
+    getInsurancePricing(): Promise<teladocInsuranceCoverage>;
+  }
+}
+
 declare namespace BowmarkProvider_tentree {
   // ── tentree — the unit's own declarations, verbatim ──
 interface TentreeVariant {
@@ -9728,6 +12560,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 {
@@ -9992,6 +12900,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.
@@ -10165,6 +13114,34 @@ 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>;
   }
 }
 
@@ -10315,6 +13292,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 {
@@ -10419,15 +13436,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 {
     /**
@@ -10453,6 +13546,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>;
   }
 }
 
@@ -10480,12 +13615,38 @@ interface walmartStore {
   services: Array<{ name: string; displayName: string; phone: string | null }>;
 }
 
+interface walmartSearchResult {
+  itemId: string;
+  name: string;
+  brand: string | null;
+  url: string;
+  image: string | null;
+  price: number | null;
+  wasPrice: number | null;
+  priceRangeMin: number | null;
+  inStock: boolean;
+  rating: number | null;
+  reviewCount: number;
+  sponsored: boolean;
+  totalMatches: number;
+}
+
   /**
-   * Walmart.com — product search, product detail, store-level stock, store locator and more. One
-   * function built: finding nearby stores by ZIP, with address, hours, phone and department
-   * availability.
+   * Walmart.com — product search, product detail, store-level stock, store locator and more. Two
+   * functions built: keyword search across the catalog, and finding nearby stores by ZIP with
+   * address, hours, phone and department availability.
    */
   interface Unit {
+    /**
+     * Searches walmart.com's catalog for a keyword and returns matching products — item id, name,
+     * brand, price (plus the pre-markdown price and the cheapest OTHER purchase option's price
+     * when the site names a range), image, in-stock flag, rating, review count and whether the row
+     * is a sponsored placement — the way the site's own search bar does. Returns the site's own
+     * first results page (organic rows only, its own trending/related carousels excluded) in the
+     * site's own default relevance order.
+     */
+    search(args: { query: string; limit?: number }): Promise<walmartSearchResult[]>;
+
     /**
      * Finds nearby Walmart stores for a 5-digit US ZIP code — address, phone, hours,
      * geo-coordinates, distance, which fulfilment methods each store supports (curbside pickup,
@@ -10516,6 +13677,26 @@ interface wellfoundRow {
   equityMax: number | null;
 }
 
+interface wellfoundJobDetail {
+  id: string;
+  title: string;
+  url: string;
+  descriptionHtml: string;
+  employmentType: string | null;
+  experienceLevel: string | null;
+  remote: boolean;
+  locations: string[];
+  remoteLocations: string[];
+  compensationRaw: string | null;
+  salaryMin: number | null;
+  salaryMax: number | null;
+  salaryCurrency: "USD" | null;
+  equityMin: number | null;
+  equityMax: number | null;
+  datePosted: string | null;
+  company: { name: string; slug: string | null; url: string | null; website: string | null; logoUrl: string | null };
+}
+
 interface wellfoundCompanyRow {
   id: string;
   name: string;
@@ -10534,6 +13715,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.
@@ -10556,6 +13758,24 @@ interface wellfoundCompanyRow {
      * filters over the fields the search itself returns.
      */
     searchCompanies(args: object): Promise<wellfoundCompanyRow[]>;
+
+    /**
+     * Reads one job posting in full the way its own detail page does — takes the `url` a
+     * `searchJobs`/`searchCompanies` row already carries (a bare id 404s, measured 2026-08-06) —
+     * returning the full description, salary band, equity range (both parsed off the header chip;
+     * equity has no structured-data field on this site), location, remote policy, the site's own
+     * experience-requirement text and the hiring startup.
+     */
+    getJob(args: { url: string }): Promise<wellfoundJobDetail>;
+
+    /**
+     * Reads one startup's `/company/<slug>` profile — the longer product description (HTML), the
+     * full market tagging, location tags with display names, the explicitly-set Remote policy,
+     * total raised, the company's own website, every badge verbatim, and the same `companySize`
+     * band `searchCompanies` already decodes — the context a candidate weighs a startup on before
+     * applying to it. Takes the `slug` a `searchCompanies` row already carries.
+     */
+    getCompany(args: { slug: string }): Promise<wellfoundCompanyDetail>;
   }
 }
 
@@ -10729,17 +13949,23 @@ 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;
+  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;
@@ -10754,18 +13980,22 @@ interface BowmarkProviders {
   grainger: BowmarkProvider_grainger.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;
   liquiddeath: BowmarkProvider_liquiddeath.Unit;
   lonelyplanet: BowmarkProvider_lonelyplanet.Unit;
   lufthansa: BowmarkProvider_lufthansa.Unit;
+  lululemon: BowmarkProvider_lululemon.Unit;
   mailchimp: BowmarkProvider_mailchimp.Unit;
+  marriott: BowmarkProvider_marriott.Unit;
   mcdonalds: BowmarkProvider_mcdonalds.Unit;
   medicare: BowmarkProvider_medicare.Unit;
   microcenter: BowmarkProvider_microcenter.Unit;
@@ -10778,6 +14008,7 @@ 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;
   progressive: BowmarkProvider_progressive.Unit;
@@ -10790,10 +14021,15 @@ interface BowmarkProviders {
   semihandmade: BowmarkProvider_semihandmade.Unit;
   soundcloud: BowmarkProvider_soundcloud.Unit;
   statefarm: BowmarkProvider_statefarm.Unit;
+  stickergiant: BowmarkProvider_stickergiant.Unit;
+  sunhomesaunas: BowmarkProvider_sunhomesaunas.Unit;
+  teladoc: BowmarkProvider_teladoc.Unit;
   tentree: BowmarkProvider_tentree.Unit;
+  therabody: BowmarkProvider_therabody.Unit;
   thezebra: BowmarkProvider_thezebra.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;
@@ -16264,6 +19500,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;
@@ -17598,6 +20835,7 @@ interface BowmarkProviders {
   beyondthemeatsuit: BowmarkFamily_shopify_store.Unit;
   beyondthenotes: BowmarkFamily_shopify_store.Unit;
   beyondtheshimmer: BowmarkFamily_shopify_store.Unit;
+  beyondyoga: BowmarkFamily_shopify_store.Unit;
   beyourstheme: BowmarkFamily_shopify_store.Unit;
   beyoursthemeclothing: BowmarkFamily_shopify_store.Unit;
   beyoursthemefashion: BowmarkFamily_shopify_store.Unit;