@bowmark/web 1.5.0 → 1.7.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: 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.
+// Manifest version: a400421498212bf60bfaab4808ff698bd8edb4febae1ba86fda5cb9ebc232c1b
+// 9 capabilities, 109 providers, 356 typed functions, 20 refused.
+// 51,714 family members, sharing 2 interface(s) — declared once and pointed at, never repeated per member.
 //
 // 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
@@ -861,6 +861,126 @@ type ReadResult = {
   }
 }
 
+declare namespace BowmarkCapability_sheds {
+  // ── Sheds and portable buildings (configure and price) — the unit's own declarations, verbatim ──
+type ShedSize = {
+  sizeKey: string             // the maker's own key; opaque, meaningful only to source
+  widthFt: number             // FEET, always — the maker's own units are converted away
+  lengthFt: number
+}
+type ShedStyle = {
+  source: string              // which maker — a provider id
+  brand: string               // the maker's brand name, for an answer that names who builds it
+  key: string                 // the maker's own style key
+  label: string               // the style as a customer sees it ("Lofted Barn")
+  sidingOptions: string[]     // siding keys; the first is the maker's standard
+  sizes: ShedSize[]
+  imageUrl: string | null     // a real product image from the maker's own catalogue
+  roofStyle: string | null    // "gable", "gambrel", ...
+  roofing: string | null      // "metal", ...
+  wallHeight: string | null   // the maker's own spec, verbatim, e.g. "left-78-right-78-eave-72"
+}
+type ShedStylesResult = {
+  styles: ShedStyle[]
+  warnings: string[]          // always present; a maker named here returned NOTHING
+}
+
+type ShedQuoteRequest = {
+  widthFt: number             // in feet, as a person says it — "a 12 by 20"
+  lengthFt: number
+  zip: string                 // required; every maker prices regionally
+  style?: string              // style key OR its customer-facing name, matched loosely.
+                              // Omit to price EVERY style that builds the size
+  siding?: string             // omit for the maker's standard siding
+}
+type ShedQuote = {
+  source: string
+  brand: string
+  styleKey: string
+  style: string               // "Lofted Barn"
+  model: string | null        // the maker's model name, where it has one
+  widthFt: number
+  lengthFt: number
+  siding: string              // the siding key this was priced in
+  zip: string
+  region: string              // the maker's own pricing region that zip fell under
+  basePrice: number
+  sidingSurcharge: number     // what the siding added, by the maker's rules; 0 for standard
+  total: number               // basePrice + sidingSurcharge, the maker's own arithmetic
+  currency: string
+  imageUrl: string | null     // what the building looks like, from the maker's catalogue
+  roofStyle: string | null    // "gable", "gambrel", ...
+  roofing: string | null      // "metal", ...
+  wallHeight: string | null   // the maker's own spec, verbatim
+  orderUrl: string            // where to go order THIS build, always present
+}
+type ShedQuoteResult = {
+  quotes: ShedQuote[]         // cheapest first, across every maker that builds the size
+  warnings: string[]          // always present; names a dropped maker, a style that does
+                              // not build the size, and a capped fan
+}
+
+type ShedDealer = {
+  source: string
+  brand: string
+  name: string
+  city: string
+  state: string
+  zip: string
+  phone: string | null        // null when the directory lists none (never "")
+  url: string
+}
+type ShedDealerResult = {
+  dealers: ShedDealer[]
+  warnings: string[]
+}
+
+type CallOptions = {
+  timeoutMs?: number   // per-provider budget in ms, default 30000, clamped to 1000-55000.
+                       // A provider slower than this is DROPPED from the results and
+                       // NAMED in warnings — never silently absent
+}
+
+  /**
+   * Price a portable building the way its maker's own 3D configurator does — give a size in feet
+   * and a zip and get the real regional price for every style that builds it, the exact siding
+   * surcharge rather than a guessed range, a real product image and spec for each one, and the
+   * link to go order it. Plus the maker's real dealer locations by state.
+   */
+  interface Unit {
+    /**
+     * Prices a building at a real size for a real zip, exactly the way the maker's own
+     * configurator does — the regional base price plus the EXACT siding surcharge its rules apply
+     * at that width and region, never a national range or a guessed upcharge. Sizes are in FEET ({
+     * widthFt: 12, lengthFt: 20 }), and both orientations count. Omit `style` to price every style
+     * that builds the size, cheapest first; name it loosely ("lofted barn") when you want one.
+     * `zip` is required because every maker prices regionally. Each quote DESCRIBES the building
+     * as well as costing it — a real product image, the roof line and roofing material, the
+     * maker's own wall-height spec — and carries `orderUrl`, their own page to go order that
+     * build. `warnings` is always present and names a maker that failed, styles that do not build
+     * the size, and a capped fan. `options.timeoutMs` sets the per-maker budget (default 30000).
+     */
+    quote(request: ShedQuoteRequest, options?: CallOptions): Promise<ShedQuoteResult>;
+
+    /**
+     * Lists every building style each maker actually offers — its customer-facing name, the siding
+     * it can be built in, every real buildable size in FEET, and what the building IS (a real
+     * product image, the roof line and roofing material, the maker's own wall-height spec). Use it
+     * to see what exists before pricing, or to answer "what sizes do they even make". `warnings`
+     * names any maker that returned nothing, which is not the same as a maker with no styles.
+     */
+    listStyles(options?: CallOptions): Promise<ShedStylesResult>;
+
+    /**
+     * Looks up the real places that sell a maker's buildings in one US state or Canadian province
+     * — full name ("Tennessee") or abbreviation ("TN") — with name, city, phone and the dealer's
+     * own page, for handing a priced configuration to somebody who can actually build it. `phone`
+     * is null when the directory lists none, never an empty string.
+     */
+    findDealers(state: string, options?: CallOptions): Promise<ShedDealerResult>;
+  }
+}
+
 declare namespace BowmarkProvider_aa {
   // ── American Airlines — the unit's own declarations, verbatim ──
 interface aaFlight {
@@ -1318,6 +1438,94 @@ interface abercrombieStockQuery {
   }
 }
 
+declare namespace BowmarkProvider_aiper {
+  // ── Aiper — the unit's own declarations, verbatim ──
+interface AiperPoolOption {
+  id: string;
+  label: string;
+}
+interface AiperPoolQuestion {
+  id: string;
+  problemName: string;
+  multiSelect: boolean;
+  options: AiperPoolOption[];
+}
+interface AiperPoolAnswerInput {
+  question: string;
+  choice: string | string[];
+}
+interface AiperRecommendedProduct {
+  productId: string;
+  slug: string;
+  name: string;
+  sku: string;
+  price: number;
+  regularPrice: number;
+  url: string;
+  image: string | null;
+}
+interface AiperPoolRecommendation {
+  products: AiperRecommendedProduct[];
+  answers: AiperPoolAnswerInput[];
+  warnings: string[];
+}
+
+  /**
+   * Aiper's Help Me Choose robotic-pool-cleaner finder, run for real — the quiz's own computed
+   * recommendation (model, SKU, real current price, PDP link) for a buyer's pool answers, off
+   * the site's own undocumented API.
+   */
+  interface Unit {
+    /**
+     * Reads the Help Me Choose quiz's live question list — every question in order, with its
+     * option ids and labels. The entry point: recommendPoolCleaner takes answers keyed off these
+     * labels, so a caller normally reads this first (or already knows the labels from a prior
+     * call).
+     */
+    listPoolChooserQuestions(): Promise<AiperPoolQuestion[]>;
+
+    /**
+     * Runs the Help Me Choose quiz's real backend computation for a buyer's answers (given as
+     * question/choice LABELS, matched case-insensitively against listPoolChooserQuestions) and
+     * returns the same computed recommendation the quiz's own terminal page renders: model name,
+     * SKU, real current price, list price, and a PDP URL. THROWS if a question or choice label
+     * doesn't match, or if the site's computed result carries no product list.
+     */
+    recommendPoolCleaner(answers: AiperPoolAnswerInput[]): Promise<AiperPoolRecommendation>;
+  }
+}
+
+declare namespace BowmarkProvider_ajmadison {
+  // ── AJ Madison — the unit's own declarations, verbatim ──
+interface AjmadisonSearchArgs {
+  category: string;              // the site's own category slug, e.g. "refrigerators"
+  filters?: Record<string, string>; // the site's own facet query params, verbatim
+  limit?: number;                 // default 25, clamped to [1, 60]
+}
+
+interface AjmadisonSearchResult {
+  sku: string;
+  name: string;
+  price: number;             // real, current selling price
+  wasPrice: number | null;   // the crossed-out "was" price, when shown
+  url: string;                // this product's own AJ Madison URL
+}
+
+  /**
+   * AJ Madison's real appliance catalog — search runs the site's own category + facet filter
+   * (brand, size/capacity, price band, style, availability) and returns real, currently-listed
+   * products with their live selling price and the product's own AJ Madison URL.
+   */
+  interface Unit {
+    /**
+     * Runs AJ Madison's own category + facet filter and returns real, currently-listed products
+     * (name, real current price, the crossed-out 'was' price when shown, the product's own AJ
+     * Madison URL). Read-only — never adds to cart or checks out.
+     */
+    search(args: AjmadisonSearchArgs): Promise<AjmadisonSearchResult[]>;
+  }
+}
+
 declare namespace BowmarkProvider_ashleyfurniture {
   // ── Ashley Furniture — the unit's own declarations, verbatim ──
 interface AshleyFurnitureSearchArgs {
@@ -1438,6 +1646,47 @@ interface AshleyFurnitureStore {
   }
 }
 
+declare namespace BowmarkProvider_atlasseniorliving {
+  // ── Atlas Senior Living — the unit's own declarations, verbatim ──
+type AtlasCareType = "assisted_living" | "independent_living" | "memory_care" | "respite_care";
+
+interface AtlasCommunity {
+  id: string;
+  name: string;
+  address: string;
+  city: string;
+  state: string;
+  zip: string;
+  phone: string;
+  distanceMiles: number;
+  lat: number;
+  lng: number;
+  url: string;
+}
+
+interface AtlasSearchCommunitiesResult {
+  location: string;
+  geocodedLat: number;
+  geocodedLng: number;
+  careTypes: AtlasCareType[];
+  radiusMiles: number;
+  communities: AtlasCommunity[];
+}
+
+  /**
+   * Atlas Senior Living's own community search (atlasseniorliving.com/our-communities/) — given
+   * a US city/state or ZIP, plus optional care type(s) and radius, returns the real,
+   * distance-sorted set of matching Atlas communities.
+   */
+  interface Unit {
+    /**
+     * Runs the site's own community search: a US location + optional care type(s) and radius,
+     * returns the real, distance-sorted matching Atlas communities.
+     */
+    searchCommunities(arg: { location: string, careTypes?: AtlasCareType[], radiusMiles?: number, maxResults?: number }): Promise<AtlasSearchCommunitiesResult>;
+  }
+}
+
 declare namespace BowmarkProvider_avis {
   // ── Avis — the unit's own declarations, verbatim ──
 interface avisRow {
@@ -2103,6 +2352,71 @@ interface BmwusaModelListing {
   }
 }
 
+declare namespace BowmarkProvider_bykoket {
+  // ── KOKET — the unit's own declarations, verbatim ──
+interface KoketProductSummary {
+  id: string;
+  name: string;
+  url: string;
+  price: number;
+  currency: string;
+  inStock: boolean;
+}
+
+interface KoketProduct {
+  id: string;
+  name: string;
+  url: string;
+  reference: string;
+  price: number;
+  priceFormatted: string;
+  listPrice: number;
+  onSale: boolean;
+  currency: string;
+  inStock: boolean;
+  quantityLeft: number | null;
+  availabilityMessage: string;
+  description: string;
+  images: string[];
+}
+
+interface KoketAddToCartHandoff {
+  id: string;
+  name: string;
+  url: string;
+  price: number;
+  currency: string;
+  inStock: boolean;
+  note: string;
+}
+
+  /**
+   * Reads KOKET's public furniture, lighting and textiles storefront (bykoket.com/shop) — search
+   * the catalog, read a product's live price, stock and description, and get the handoff to add
+   * it to cart on the real site.
+   */
+  interface Unit {
+    /**
+     * Searches KOKET's live public catalog (furniture, lighting, textiles) and returns each
+     * match's id, name, product URL, price and stock status.
+     */
+    searchProducts(query: string): Promise<KoketProductSummary[]>;
+
+    /**
+     * Reads one KOKET product's live page — price (list and current, since KOKET runs promotions),
+     * stock count, availability message, description and images.
+     */
+    getProduct(idOrUrl: string): Promise<KoketProduct>;
+
+    /**
+     * Hands back the shopper's own KOKET product page — the exact Add to cart button for this
+     * product — since the site's cart requires a per-session token nobody but the shopper can
+     * supply. Writes nothing.
+     */
+    addToCart(idOrUrl: string): Promise<KoketAddToCartHandoff>;
+  }
+}
+
 declare namespace BowmarkProvider_cancer {
   // ── National Cancer Institute (cancer.gov) — the unit's own declarations, verbatim ──
 type cancerCenterDesignation =
@@ -2646,6 +2960,75 @@ interface ChriscraftPriceResult {
   }
 }
 
+declare namespace BowmarkProvider_classichome {
+  // ── Classic Home — the unit's own declarations, verbatim ──
+// Classic Home's OWN shapes — not a capability contract.
+
+interface ClassicHomeProduct {
+  handle: string;        // the key getProduct/addToCart take
+  title: string;
+  url: string;
+  priceMin: number;      // dollars — the cheapest real fabric/leather choice
+  priceMax: number;      // dollars — the most expensive (usually top-grain leather)
+  variantCount: number;  // >1 means a real fabric/leather choice exists
+}
+
+interface ClassicHomeVariant {
+  optionValue: string;   // e.g. "Soft Olive", "Dawn-Flax", "ElPaso-Saddle"
+  sku: string;
+  price: number;         // dollars — this exact fabric/leather's own real price
+  available: boolean;
+}
+
+interface ClassicHomeProductDetail {
+  handle: string;
+  title: string;
+  url: string;
+  optionName: string;      // usually "Color" (fabric/leather); "Title" if no real picker
+  variants: ClassicHomeVariant[];
+}
+
+interface ClassicHomeCartHandoff {
+  handle: string;
+  optionValue: string;
+  sku: string;
+  price: number;         // dollars — the real price for this exact fabric/leather
+  available: boolean;
+  productUrl: string;    // finish add-to-cart/checkout on the real product page
+}
+
+  /**
+   * Classic Home's real Made-to-Order fabric/leather catalog and its real, material-specific
+   * Shopify pricing — search real MTO products (sofas, chairs, ottomans), read one product's
+   * real fabric/leather picker, and resolve one exact fabric or leather choice to its real SKU,
+   * price and availability.
+   */
+  interface Unit {
+    /**
+     * Searches Classic Home's real Made-to-Order catalog (sofas, chairs, ottomans) via the site's
+     * own Shopify collection JSON, optionally filtered by a free-text query against the product
+     * title. Returns real products with a real price range read off their own fabric/leather
+     * variants.
+     */
+    searchProducts(query?: string): Promise<ClassicHomeProduct[]>;
+
+    /**
+     * Reads one product's real live fabric/leather picker: every real color/material choice with
+     * its own real price and availability, keyed by the site's own option name. THROWS on an
+     * unknown handle, naming searchProducts() as the way to find current ones.
+     */
+    getProduct(handle: string): Promise<ClassicHomeProductDetail>;
+
+    /**
+     * Resolves ONE exact fabric/leather choice (optionValue from getProduct's own variant list,
+     * e.g. "Soft Olive") to Classic Home's own real price, availability and SKU, plus the product
+     * page to finish add-to-cart/checkout on the site itself. Writes nothing — classichome.com's
+     * robots.txt disallows automated /cart access.
+     */
+    addToCart(handle: string, optionValue: string): Promise<ClassicHomeCartHandoff>;
+  }
+}
+
 declare namespace BowmarkProvider_classpass {
   // ── ClassPass — the unit's own declarations, verbatim ──
 /** Everything /v2/venues publishes about one studio — a superset of
@@ -3621,6 +4004,36 @@ interface DiscounttireTireSizeSearch {
   }
 }
 
+declare namespace BowmarkProvider_embroker {
+  // ── Embroker — the unit's own declarations, verbatim ──
+interface EmbrokerCoverageCatalog {
+  coverageLines: string[];
+  productTypes: string[];
+}
+
+interface EmbrokerQuoteEntryPoint {
+  product: string;
+  productLabel: string;
+  url: string;
+  reachable: boolean;
+}
+
+  /**
+   * Embroker's own coverage catalog and live self-serve quote-wizard entry points for
+   * tech/startup, law firm, cyber, BOP, crime and professional-liability business insurance.
+   */
+  interface Unit {
+    /** Returns Embroker's real coverage-line and policy-product-type catalog. */
+    listCoverageLines(): Promise<EmbrokerCoverageCatalog>;
+
+    /**
+     * Returns the live, confirmed-reachable entry URL for one of Embroker's self-serve
+     * quote-wizard products.
+     */
+    getQuoteEntryPoint(args: { product: string }): Promise<EmbrokerQuoteEntryPoint>;
+  }
+}
+
 declare namespace BowmarkProvider_erieinsurance {
   // ── ERIE Insurance — the unit's own declarations, verbatim ──
 interface ErieAgentQuery {
@@ -3957,6 +4370,50 @@ interface ExtraspaceUnitAvailability {
   }
 }
 
+declare namespace BowmarkProvider_firstdibs {
+  // ── 1stDibs — the unit's own declarations, verbatim ──
+interface FirstdibsSearchResult {
+  name: string;
+  url: string;
+  price: number;
+  priceCurrency: string;
+  availability: string;
+  image: string | null;
+}
+interface FirstdibsCompletingAction {
+  makeOffer: boolean;
+  contactSeller: boolean;
+  purchase: false;
+}
+interface FirstdibsListing {
+  name: string;
+  url: string;
+  description: string;
+  brand: string | null;
+  price: number;
+  priceCurrency: string;
+  completingAction: FirstdibsCompletingAction;
+}
+
+  /**
+   * Search 1stDibs' luxury/vintage marketplace and read a listing's real price plus its concrete
+   * completing action (Make an Offer / Contact Seller) — no login.
+   */
+  interface Unit {
+    /**
+     * Runs 1stDibs' keyword search (or a category-facet URL) and returns real listings with real
+     * price, currency, availability and url.
+     */
+    search(query: string): Promise<FirstdibsSearchResult[]>;
+
+    /**
+     * Reads one listing's real price and its concrete completing action(s) — Make an Offer and/or
+     * Contact Seller, whichever this seller has enabled.
+     */
+    getListing(url: string): Promise<FirstdibsListing>;
+  }
+}
+
 declare namespace BowmarkProvider_flightradar24 {
   // ── Flightradar24 — the unit's own declarations, verbatim ──
 interface flightradar24Airline {
@@ -5004,6 +5461,53 @@ interface GooglePriceGraph {
   }
 }
 
+declare namespace BowmarkProvider_gotchacovered {
+  // ── Gotcha Covered — the unit's own declarations, verbatim ──
+interface GotchaCoveredQuizOption {
+  label: string;
+  imageUrl: string | null;
+}
+interface GotchaCoveredQuizQuestion {
+  step: number;
+  prompt: string;
+  options: GotchaCoveredQuizOption[];
+}
+interface GotchaCoveredQuizQuestions {
+  questions: GotchaCoveredQuizQuestion[];
+}
+interface GotchaCoveredQuizAnswers {
+  colorScheme: string;
+  pattern: string;
+  imageChoice: number | string;
+  destination: string;
+  material: string;
+  item: string;
+}
+interface GotchaCoveredQuizResult {
+  styleName: string;
+  description: string;
+  recommendedProducts: string | null;
+  url: string;
+}
+
+  /**
+   * Reads and answers Gotcha Covered's own 'What Design Style Am I?' window-treatment style
+   * quiz, returning the site's real computed match.
+   */
+  interface Unit {
+    /** Reads the live 'What Design Style Am I?' quiz's real 6 questions and option lists. */
+    getDesignStyleQuizQuestions(): Promise<GotchaCoveredQuizQuestions>;
+
+    /**
+     * Answers all 6 questions of Gotcha Covered's Design Style Quiz (e.g. { colorScheme:
+     * "Metallics Color Scheme", pattern: "Eclectic Pattern", imageChoice: 1, destination: "Spain
+     * Destination", material: "Wood Material", item: "Graphic Rug Item" }) and returns the site's
+     * real computed style match.
+     */
+    takeDesignStyleQuiz(answers: GotchaCoveredQuizAnswers): Promise<GotchaCoveredQuizResult>;
+  }
+}
+
 declare namespace BowmarkProvider_grainger {
   // ── Grainger — the unit's own declarations, verbatim ──
 interface graingerRow {
@@ -5110,6 +5614,206 @@ interface graingerStockRow {
   }
 }
 
+declare namespace BowmarkProvider_handypro {
+  // ── HandyPro — the unit's own declarations, verbatim ──
+// HandyPro's OWN shapes — not a capability contract.
+
+interface HandyproHourlyRate { fromHours: number; toHours: number; pricePerHour: number }
+
+interface HandyproServiceArea {
+  covered: boolean;
+  message?: string;         // present only when covered is false
+  franchiseeName?: string;
+  phone?: string;
+  city?: string;
+  state?: string;
+  formattedAddress?: string;
+  hourlyRates?: HandyproHourlyRate[];
+}
+
+interface HandyproCategoryPrice {
+  categoryId: string;
+  categoryName: string;
+  parentCategoryName: string;
+  pricingKind: "estimate" | "fixedJob" | "unpriced";
+  price: number | null;     // dollars
+  whatsIncluded: string;
+}
+
+interface HandyproCategorySearch {
+  zipcode: string;
+  covered: boolean;
+  message?: string;         // present only when covered is false
+  categories: HandyproCategoryPrice[];
+}
+
+  /**
+   * HandyPro's real service-area coverage and per-category job pricing — checks whether a ZIP is
+   * served by a real local franchisee (with its own live hourly rate table) and prices
+   * HandyPro's actual handyman/home-modification categories (grab bars, appliance install, TV
+   * mounting, painting, and more) for that ZIP, rather than a researched nationwide estimate.
+   */
+  interface Unit {
+    /**
+     * Checks whether a ZIP is served by a real local HandyPro franchisee and returns that
+     * franchisee's own real hourly rate table. covered is false with a message for a ZIP outside
+     * HandyPro's online booking area — an honest, ordinary answer, not an error.
+     */
+    checkServiceArea(zipcode: string): Promise<HandyproServiceArea>;
+
+    /**
+     * Lists HandyPro's real service categories priced for one ZIP's franchisee (a free estimate or
+     * a real fixed job price, and what's included), optionally narrowed by a free-text query (e.g.
+     * "grab bar"). covered is false with a message for a ZIP outside the service area.
+     */
+    searchServiceCategories(zipcode: string, query?: string): Promise<HandyproCategorySearch>;
+  }
+}
+
+declare namespace BowmarkProvider_harmar {
+  // ── Harmar Mobility — the unit's own declarations, verbatim ──
+interface HarmarVehicleModel {
+  make: string;
+  modelId: string;
+  model: string;
+}
+
+interface HarmarChairModel {
+  chairId: string;
+  model: string;
+}
+
+interface HarmarLiftOption {
+  code: string;
+  name: string;
+  description: string;
+  required: boolean;
+}
+
+interface HarmarCompatibleLift {
+  liftId: string;
+  productCode: string;
+  name: string;
+  requiredAccessories: HarmarLiftOption[];
+  optionalAccessories: HarmarLiftOption[];
+}
+
+interface HarmarCompatibleLiftsResult {
+  year: string;
+  vehicleId: string;
+  chairId: string;
+  lifts: HarmarCompatibleLift[];
+}
+
+interface HarmarFindCompatibleLiftsResult extends HarmarCompatibleLiftsResult {
+  vehicleMake: string;
+  vehicleModel: string;
+  chairMake: string;
+  chairModel: string;
+}
+
+  /**
+   * Harmar's Vehicle Compatibility Calculator (calculator.harmar.com) — given a vehicle and a
+   * wheelchair/scooter, returns the real Harmar vehicle lifts that fit that combination.
+   */
+  interface Unit {
+    /**
+     * Every vehicle (make + calculator's own model id) the compatibility calculator has data for
+     * in a given model year.
+     */
+    searchVehicleModels(arg: { year: string }): Promise<HarmarVehicleModel[]>;
+
+    /** Every wheelchair/scooter model the calculator has data for under a given manufacturer make. */
+    searchChairModels(arg: { make: string }): Promise<HarmarChairModel[]>;
+
+    /**
+     * Runs the calculator's own 'Lift Lookup' against its internal vehicle/chair ids and returns
+     * the compatible Harmar lifts.
+     */
+    getCompatibleLifts(arg: { year: string, vehicleId: string, chairId: string }): Promise<HarmarCompatibleLiftsResult>;
+
+    /**
+     * The whole goal-flow in one call: plain vehicle year/make/model + chair make/model, resolved
+     * to the calculator's own ids and run through the real Lift Lookup.
+     */
+    findCompatibleLifts(arg: { year: string, vehicleMake: string, vehicleModel: string, chairMake: string, chairModel: string }): Promise<HarmarFindCompatibleLiftsResult>;
+  }
+}
+
+declare namespace BowmarkProvider_hauslabs {
+  // ── Haus Labs by Lady Gaga — the unit's own declarations, verbatim ──
+interface HauslabsVariant {
+  id: string;
+  title: string;
+  price: string;
+  compareAtPrice: string | null;
+  sku: string | null;
+  available: boolean;
+  options: string[];
+}
+interface HauslabsProduct {
+  handle: string;
+  title: string;
+  vendor: string;
+  productType: string;
+  url: string;
+  descriptionHtml: string | null;
+  optionNames: string[];
+  variants: HauslabsVariant[];
+  priceRange: { min: string; max: string } | null;
+  inStock: boolean;
+  tags: string[];
+  images: string[];
+}
+interface HauslabsShadeMatch {
+  quiz: { family: string; depth: string; undertone: string; hasAddOne: boolean };
+  variant: {
+    number: number;
+    family: string;
+    id: string;
+    sku: string | null;
+    price: string;
+    available: boolean;
+  };
+  product: HauslabsProduct;
+  warnings: string[];
+}
+
+  /**
+   * Haus Labs by Lady Gaga product catalogue — every clean-beauty SKU, its variants, its prices
+   * and what is in stock — read off the live Shopify Plus storefront. The Foundation Shade
+   * Finder is the broadcast wedge: a multi-step quiz ChatGPT cannot operate, mapped locally to
+   * one specific priced shade with the buy-page handoff.
+   */
+  interface Unit {
+    /**
+     * Reads the live Haus Labs catalogue as the storefront publishes it — every product, its
+     * handle, title, vendor, description, tags, images and the per-variant price the storefront is
+     * quoting right now. Optional productType narrows to FACE / LIPS / EYES / SETS / etc. before
+     * the limit. Returns [] on a transport failure (warnings would be on an object envelope; this
+     * is a list). The catalog page is the line and the parse is the unit of work.
+     */
+    listHauslabsProducts(opts?: { limit?: number; productType?: string }): Promise<HauslabsProduct[]>;
+
+    /**
+     * Reads one product by its handle — every variant, its exact price, the image the storefront
+     * is showing and whether that specific variant is purchasable right now. Takes the handle
+     * listHauslabsProducts returns. THROWS on an unknown handle (the store answers a real 404).
+     */
+    getHauslabsProduct(handle: string): Promise<HauslabsProduct>;
+
+    /**
+     * Resolves a buyer's Foundation Lab quiz answers to ONE specific shade: the variant title, the
+     * SKU, the real price, the availability, the buy-page URL. Mirrors the quiz's `shadeLogic`
+     * decision tree natively against Cartful Solutions' published `pd.json` (keyless, browserless)
+     * and resolves the matching variant through /products/<handle>.js for live price and stock.
+     * The quiz is a 5-step Shopify section ChatGPT cannot operate on the buyer's behalf; this
+     * function returns the single shade the quiz's terminal page renders for the same inputs.
+     */
+    runFoundationShadeFinder(input: { family: 'Deep' | 'Medium Deep' | 'Medium' | 'Light Medium' | 'Light' | 'Fair'; depth: 'deeper' | 'medium' | 'lighter'; undertone: 'warm' | 'cool' | 'neutral' | 'rosy' | 'golden'; hasAddOne?: boolean }): Promise<HauslabsShadeMatch>;
+  }
+}
+
 declare namespace BowmarkProvider_healthcare_gov {
   // ── HealthCare.gov — the unit's own declarations, verbatim ──
 interface healthcare_govPlan {
@@ -5999,6 +6703,78 @@ interface hiltonRoomOffer {
   }
 }
 
+declare namespace BowmarkProvider_hobie {
+  // ── Hobie Cat Company — the unit's own declarations, verbatim ──
+interface HobieModelSummary {
+  slug: string;
+  name: string;
+  url: string;
+}
+interface HobieModelColor {
+  color: string;
+  upc: string;
+}
+interface HobieModelColors {
+  slug: string;
+  name: string;
+  defaultColor: string;
+  colors: HobieModelColor[];
+}
+interface HobieDealer {
+  storeId: number;
+  name: string;
+  address: string;
+  city: string;
+  state: string;
+  zip: string;
+  phoneNumber: string;
+  latitude: number;
+  longitude: number;
+  distanceMiles: number;
+  carriesExactColor: boolean;
+  carriesModel: boolean;
+  carriesBrand: boolean;
+  stockStatus: string;
+  stockDisclaimer: string;
+}
+interface HobieLocalAvailability {
+  slug: string;
+  modelName: string;
+  color: string;
+  upc: string;
+  zip: string;
+  dealers: HobieDealer[];
+  dealersCarryingExactColor: number;
+  dealersCarryingModel: number;
+}
+
+  /**
+   * Reads Hobie Cat Company's own real-time 'Find it Locally' dealer-inventory widget directly —
+   * which real dealer near a zip has a specific kayak model, IN A SPECIFIC COLOR, in stock right
+   * now. Kayaks are dealer-distribution only; there is no first-party checkout.
+   */
+  interface Unit {
+    /**
+     * Lists every real kayak model Hobie currently sells (slug, display name, its own hobie.com
+     * URL), read straight from the live /kayaks/ index.
+     */
+    listModels(): Promise<HobieModelSummary[]>;
+
+    /**
+     * Reads one model's real buildable colors, each paired with the exact UPC the local-inventory
+     * widget is keyed on, plus the site's own default color.
+     */
+    listModelColors(slug: string): Promise<HobieModelColors>;
+
+    /**
+     * Runs Hobie's own real-time 'Find it Locally' widget for one model + color near a US zip and
+     * returns real nearby dealers with Hobie's own exact-color / model / brand carrying flags.
+     * `color` defaults to the site's own default color when omitted.
+     */
+    checkLocalAvailability(slug: string, color: string | undefined, zip: string): Promise<HobieLocalAvailability>;
+  }
+}
+
 declare namespace BowmarkProvider_hunter {
   // ── Hunter — the unit's own declarations, verbatim ──
 interface hunterDomainCandidate {
@@ -7215,6 +7991,47 @@ interface InteriorDefineCartHandoff {
   }
 }
 
+declare namespace BowmarkProvider_islllc {
+  // ── Integral Senior Living — the unit's own declarations, verbatim ──
+type IsllcCareType = "assisted_living" | "independent_living" | "memory_care" | "respite_care";
+
+interface IsllcCommunity {
+  id: string;
+  name: string;
+  address: string;
+  city: string;
+  state: string;
+  zip: string;
+  phone: string;
+  careTypes: string;
+  lat: number;
+  lng: number;
+  url: string;
+}
+
+interface IsllcSearchCommunitiesResult {
+  location: string;
+  geocodedLat: number;
+  geocodedLng: number;
+  careTypes: IsllcCareType[];
+  radiusMiles: number;
+  communities: IsllcCommunity[];
+}
+
+  /**
+   * Integral Senior Living's own community locator (islllc.com/communities/) — given a US
+   * city/state or ZIP, plus optional care type(s) and radius, returns the real, nearest-first
+   * set of matching ISL communities.
+   */
+  interface Unit {
+    /**
+     * Runs the site's own community locator: a US location + optional care type(s) and radius,
+     * returns the real, nearest-first matching ISL communities.
+     */
+    searchCommunities(arg: { location: string, careTypes?: IsllcCareType[], radiusMiles?: number, maxResults?: number }): Promise<IsllcSearchCommunitiesResult>;
+  }
+}
+
 declare namespace BowmarkProvider_joybird {
   // ── Joybird — the unit's own declarations, verbatim ──
 interface JoybirdConfigurator {
@@ -7451,6 +8268,106 @@ interface KayakCar {
   }
 }
 
+declare namespace BowmarkProvider_kitchentuneup {
+  // ── Kitchen Tune-Up — the unit's own declarations, verbatim ──
+interface KitchentuneupCabinetStyle {
+  featureDefinitionId: number;
+  name: string;
+  group: string | null;
+  thumbnailUrl: string | null;
+}
+
+interface KitchentuneupVisualization {
+  resultImageUrl: string;
+  appliedFeatureIds: number[];
+}
+
+  /**
+   * Kitchen Tune-Up's own AI Design Tool — the live cabinet door/color/finish catalog, and
+   * photo-in/AI-visualization-out generation, run the way kitchentuneup.com/design-tool/ does.
+   */
+  interface Unit {
+    /**
+     * Reads Kitchen Tune-Up's own AI Design Tool catalog off its visualizer vendor's API — every
+     * cabinet door style / color / finish feature currently enabled for the kitchen visualizer,
+     * with the featureDefinitionId visualizeKitchen needs to apply it. Real catalog data, not a
+     * marketing page scrape.
+     */
+    listCabinetStyles(): Promise<KitchentuneupCabinetStyle[]>;
+
+    /**
+     * Runs a photo through Kitchen Tune-Up's own AI Design Tool the way
+     * kitchentuneup.com/design-tool/ does — uploads the photo plus one or more chosen cabinet
+     * features (from listCabinetStyles) to their visualizer vendor's AI image pipeline and returns
+     * the generated visualization image URL. This is the exact functional gap this packet's ANGLE
+     * fit-check recorded: ChatGPT knows the AI Design Tool exists but explicitly refuses to
+     * operate it ('I can't operate Kitchen Tune-Up's website on your behalf') and bounces the user
+     * back to the site.
+     */
+    visualizeKitchen(args: { photoBase64: string, photoFileName?: string, featureDefinitionIds: number[] }): Promise<KitchentuneupVisualization>;
+  }
+}
+
+declare namespace BowmarkProvider_kompan {
+  // ── KOMPAN Master — the unit's own declarations, verbatim ──
+// KOMPAN Master's OWN shapes — not a capability contract.
+
+type KompanRegion = "region_america" | "region_europe_middleeast" | "region_asia_newzealand" | "region_australia";
+
+interface KompanVariant {
+  id: string;         // pass to getSparePartsDocuments()
+  title: string;       // e.g. "PCM157-0205 | UNIVERSAL CAROUSEL"
+}
+
+interface KompanSearchResult {
+  productNo: string;
+  region: KompanRegion;
+  found: boolean;       // false is a real "no such product number in this region" answer
+  image: string | null;
+  variants: KompanVariant[];
+}
+
+interface KompanDocument {
+  section: string;      // the site's own heading, e.g. "Layout Drawing", "Installation Instruction"
+  label: string;
+  url: string;
+}
+
+interface KompanSparePartsDocuments {
+  variantId: string;
+  purchaseDate: string;
+  title: string | null;
+  documents: KompanDocument[];
+  fullPackageUrl: string | null;   // generated on fetch by the site — the URL to fetch, not a static file
+}
+
+  /**
+   * KOMPAN's own spare-parts / TÜV-certificate / maintenance-manual lookup (KOMPAN Master) —
+   * search a KOMPAN playground product number for its real installed variants, then read the
+   * exact layout drawing, installation instruction, general instruction, on-demand full-package
+   * PDF and language-specific inspection checklists / maintenance manuals for one variant +
+   * purchase date, off the site's own live tool rather than a researched guess.
+   */
+  interface Unit {
+    /**
+     * Searches KOMPAN Master for a product number (e.g. "PCM157") in one region (default
+     * "region_america") and lists every real installed variant of it — each with the internal item
+     * id getSparePartsDocuments() takes. `found: false` is a real, expected answer for a product
+     * number with no record in that region, not an error.
+     */
+    searchProduct(productNo: string, region?: KompanRegion): Promise<KompanSearchResult>;
+
+    /**
+     * Reads the real spare-parts / TÜV-certificate / maintenance-manual documents KOMPAN Master
+     * publishes for one variant (an id from searchProduct()) at one purchase date ("YYYY-MM-DD",
+     * since the site keys the applicable document revision off it) — layout drawing, installation
+     * instruction, general instruction, additional checklists/manuals, and the on-demand "full
+     * package" PDF URL.
+     */
+    getSparePartsDocuments(variantId: string, purchaseDate: string): Promise<KompanSparePartsDocuments>;
+  }
+}
+
 declare namespace BowmarkProvider_labcorp {
   // ── Labcorp — the unit's own declarations, verbatim ──
 interface LabcorpTestSummary {
@@ -7877,6 +8794,61 @@ interface LonelyPlanetSearchResult {
   }
 }
 
+declare namespace BowmarkProvider_louvershop {
+  // ── Louver Shop Shutters — the unit's own declarations, verbatim ──
+interface LouvershopBranch {
+  id: number;
+  name: string;
+  link: string;
+  tel: string;
+}
+
+interface LouvershopLocalArea {
+  zip: string;
+  city: string;
+  state: string;
+  stateCode: string;
+}
+
+interface LouvershopConsultant {
+  id: number;
+  name: string;
+  link: string;
+}
+
+interface LouvershopAvailability {
+  exteriorDecorative: boolean;
+  exteriorSecurity: boolean;
+}
+
+interface FindLocalDealerResult {
+  zip: string;
+  inServiceArea: boolean;
+  branch: LouvershopBranch | null;
+  area: LouvershopLocalArea | null;
+  consultants: LouvershopConsultant[];
+  availability: LouvershopAvailability | null;
+}
+
+  /**
+   * Window treatments (interior/exterior shutters, blinds, shades) dealer network.
+   * findLocalDealer is live — the same lookup the site's own free-quote/consultant-locator forms
+   * run before showing a booking path, given a ZIP. requestConsultation (submitting the actual
+   * in-home consultation request) is a stub — see its notImplemented reason.
+   */
+  interface Unit {
+    /**
+     * Looks up the Louver Shop dealer/branch that covers a US ZIP (`zip`, a 4-5 digit string, e.g.
+     * "30301") — the same lookup the site's own "Free In-Home Design Consultation" form and "Find
+     * a Consultant" locator both run before offering a booking path. Returns whether the ZIP is in
+     * the dealer network, the matched branch (name, phone, page slug), the normalized local area,
+     * the branch's assigned consultants (deduplicated), and per-branch exterior-shutter
+     * availability flags. Recovered from the locator widget's own backend, not guessed at.
+     */
+    findLocalDealer(args: object): Promise<FindLocalDealerResult>;
+  }
+}
+
 declare namespace BowmarkProvider_lufthansa {
   // ── Lufthansa — the unit's own declarations, verbatim ──
 interface LufthansaFlightLeg {
@@ -7976,6 +8948,80 @@ interface LululemonVariant {
   available: boolean;
   price: number | null;
   salePrice: number | null;
+  /** Why this SKU's price is, or is not, a markdown. Derived from price and
+   * salePrice, so it can never disagree with them. */
+  sale: SaleEvidence;
+}
+interface SaleEvidence {
+  /** True only with retailer evidence. NEVER from a low price or a title. */
+  onSale: boolean;
+  currentPrice: number | null;
+  /** The list price, when the markdown is against one. */
+  originalPrice: number | null;
+  /** ISO 4217, or null. ALWAYS null here: this feed publishes bare numbers with
+   * no currency code anywhere in the payload. */
+  currency: string | null;
+  promotionMessage: string | null;
+  evidenceType: "compare_at_price" | "sale_price" | "retailer_sale_badge" | "published_promotion" | "none";
+  /** The retailer text or field the classification rests on, verbatim. */
+  evidenceText: string | null;
+}
+interface ProductImage {
+  /** Absolute HTTPS url. */
+  url: string;
+  altText: string | null;
+  /** The colourway's own colour — sound because lululemon publishes its image
+   * list PER COLOURWAY, so every picture in it is that colour by construction. */
+  color: string | null;
+  colorId: string | null;
+  /** Always [] here: this feed links a picture to a COLOUR, never to a size. */
+  variantIds: string[];
+}
+/** The retailer's own labels. On this door that is audience and nothing else —
+ * the HPDP feed publishes no description, tags, fabric, collection or category.
+ * Every other field is null or [], honestly. */
+interface PublishedProductAttributes {
+  audience: string | null;
+  garmentType: "sports_bra" | "tank" | "crop_top" | "leggings" | "shorts" | "other" | null;
+  categories: string[];
+  collections: string[];
+  fabrics: string[];
+  materials: string[];
+  color: string | null;
+  colorFamily: string | null;
+  pattern: string | null;
+  styleTags: string[];
+  neckline: string | null;
+  strapWidth: string | null;
+  backDesign: string | null;
+  sleeveLength: string | null;
+  rise: string | null;
+  waistband: string | null;
+  inseam: string | null;
+  legShape: string | null;
+  fit: string | null;
+  coverage: string | null;
+}
+/** Shared colour and family — what makes two pieces PLAUSIBLY coordinate. None
+ * of it establishes a set. */
+interface CoordinationMetadata {
+  collectionNames: string[];
+  fabricNames: string[];
+  colorName: string | null;
+  colorId: string | null;
+  colorFamily: string | null;
+  productFamily: string | null;
+}
+/** An EXPLICIT retailer-published relationship. ALWAYS [] on this door: the feed's
+ * only product-to-product relation is the ALGORITHMIC similarity rail, which is
+ * getSimilarProducts. Reading that as a set would turn "the recommender put these
+ * near each other" into "lululemon sells these together". */
+interface RetailerSetEvidence {
+  evidenceType: "official_set" | "shop_the_set" | "complete_the_look" | "matching_piece";
+  evidenceText: string | null;
+  sourceUrl: string | null;
+  setId: string | null;
+  relatedProducts: Array<{ productId: string | null; handle: string | null; title: string | null; url: string | null }>;
 }
 interface LululemonOptionGroup {
   /** The machine name. "size" on every lululemon product measured. */
@@ -7997,6 +9043,13 @@ interface LululemonColorway {
   url: string;
   swatchImage: string | null;
   images: string[];
+  /** The SAME pictures as images, carrying this colourway's colour and colorId.
+   * images stays a bare string[] for existing callers; this is the additive half. */
+  imageAssets: ProductImage[];
+  sale: SaleEvidence;
+  coordination: CoordinationMetadata;
+  /** ISO 4217, or null. Always null — see SaleEvidence.currency. */
+  currency: string | null;
   inStock: boolean;
   optionGroups: LululemonOptionGroup[];
   /** What can be BOUGHT in this colour right now — not the full size run. */
@@ -8024,6 +9077,82 @@ interface LululemonProduct {
   /** Other lengths of the same style. Empty on every product measured — on this
    * site an inseam is its OWN product, not an option. */
   sizeTypes: LululemonSizeType[];
+  attributes: PublishedProductAttributes;
+  coordination: CoordinationMetadata;
+  retailerSetEvidence: RetailerSetEvidence[];
+}
+/** One published product-detail block from the page, verbatim. */
+interface LululemonFeature {
+  heading: string;
+  body: string;
+}
+/** What lululemon's OWN product page publishes about a garment, which the
+ * third-party pricing door does not carry at all. */
+interface LululemonProductAttributes {
+  productId: string;
+  url: string;
+  title: string;
+  /** The site's own ProductGroup category, e.g. "Leggings". */
+  category: string | null;
+  description: string | null;
+  /** Trademarked fabric names off the detail accordion, e.g. ["Nulu"]. */
+  fabrics: string[];
+  fit: string | null;
+  /** "High-Rise" / "Mid-Rise" / "Low-Rise", as the title spells it. */
+  rise: string | null;
+  /** Every detail block, unmapped and in page order. */
+  features: LululemonFeature[];
+  /** The site's own aggregate — the honest one. The pricing door reports 0
+   * reviews on products whose live page shows 22,748. */
+  ratingValue: number | null;
+  reviewCount: number | null;
+  /** Per-FIELD origin for the eight facts above, keyed by the same names. THIS
+   * is how a refused read is told apart from a garment with nothing published:
+   * fabrics [] beside status "absent" is lululemon saying it names no fabric,
+   * and fabrics [] beside status "unreachable" is the page refusing us. Ranking
+   * that treats the two alike silently prefers whichever candidates loaded. */
+  provenance: Record<string, FieldProvenance>;
+  /** The roll-up. On a refused page ratio is 0 and unreachableFields names all
+   * eight — the machine-readable form of the sentence in warnings. */
+  completeness: Completeness;
+  /** What could not be reached. Non-empty means the page refused. */
+  warnings: string[];
+}
+/** Where one field's value came from, and the retailer text behind it. */
+interface FieldProvenance {
+  /** "published" — lululemon stated it. "absent" — the page rendered and said
+   * nothing about this field. "unreachable" — the page refused, so UNKNOWN. */
+  status: "published" | "absent" | "unreachable";
+  /** Which door: "lululemon_pdp_ldjson", "lululemon_pdp_accordion" or
+   * "lululemon_pdp_title". Null when nothing filled it. */
+  source: string | null;
+  /** The retailer's own words the value rests on, for a field derived from
+   * prose. Null for a field the site published as a typed value. */
+  evidence: string | null;
+  /** On "unreachable" only: what was refused. */
+  detail?: string;
+}
+interface Completeness {
+  fields: number;
+  published: number;
+  absent: number;
+  unreachable: number;
+  /** published / fields, to 3dp. */
+  ratio: number;
+  /** The fields that are UNKNOWN rather than known-empty. */
+  unreachableFields: string[];
+  sourcesUsed: string[];
+}
+/** What getProducts returns. PARTIAL by construction — the pricing catalogue
+ * holds ~39% of the ids in lululemon's own sitemap, so ids it does not carry are
+ * NAMED rather than silently dropped or thrown over. */
+interface LululemonProductBatch {
+  /** In the order the ids were passed, not the order they finished. */
+  products: LululemonProduct[];
+  /** Every id that did not read, with the catalogue's own sentence. */
+  missing: Array<{ productId: string; detail: string }>;
+  requested: number;
+  warnings: string[];
 }
 interface LululemonRow {
   id: string;
@@ -8079,6 +9208,30 @@ interface LululemonSimilarProducts {
      */
     getProduct(query: { productId: string }): Promise<LululemonProduct>;
 
+    /**
+     * Reads the full configurator for MANY products in one call — the shape to use when ranking a
+     * candidate set, because a `search` row carries a price range and a colour count but not the
+     * per-colourway sizes, markdown evidence or images a ranking turns on. Returns `products` in
+     * the order the ids were passed. PARTIAL is the normal answer: the pricing catalogue holds
+     * roughly 39% of the ids in lululemon's own sitemap, so ids it does not carry come back in
+     * `missing` with the catalogue's own sentence, and one of them never costs the other rows. At
+     * most 24 ids — the same cap `search` returns — so one full search page is always one batch.
+     */
+    getProducts(query: { productIds: string[] }): Promise<LululemonProductBatch>;
+
+    /**
+     * Reads what lululemon's OWN product page publishes about a garment and the third-party
+     * pricing door does not carry at all: the category the site files it under, the collection
+     * description, the trademarked fabric it is cut from, the fit and the rise, its real review
+     * aggregate, and every product-detail block verbatim. This is the expensive door on this
+     * provider — a headed Google Chrome, ~10-20x the latency of `getProduct` — so call it when the
+     * ATTRIBUTES are the answer and `getProduct` when the price, colourways and sizes are. It
+     * never throws on a refused page: a page that will not render comes back with every field
+     * empty and a `warnings` entry naming it, so an empty `fabrics` is distinguishable from an
+     * unread one.
+     */
+    getProductAttributes(query: { productId: string }): Promise<LululemonProductAttributes>;
+
     /**
      * Returns the products lululemon's own product pages recommend alongside one product — the
      * 'You may also like' rail — as priced rows in the store's own ranked order, de-duplicated to
@@ -8091,6 +9244,82 @@ interface LululemonSimilarProducts {
   }
 }
 
+declare namespace BowmarkProvider_maidenhome {
+  // ── Maiden Home — the unit's own declarations, verbatim ──
+// Maiden Home's OWN shapes — not a capability contract.
+
+interface MaidenHomeVariant {
+  productHandle: string;
+  productTitle: string;
+  productType: string;      // e.g. "Sofa", "Modular Component", "Dining Table"
+  size: string;              // e.g. "85\" Width", or a non-numeric value like "Right-Facing Chaise"
+  woodFinish: string;        // e.g. "Driftwood Ash"
+  sku: string;
+  price: number;
+  priceFormatted: string;
+  available: boolean;
+  url: string;               // the product page, preselecting this exact variant
+}
+
+interface MaidenHomeConfiguratorProduct {
+  handle: string;
+  title: string;
+  productType: string;
+  url: string;
+  sizeOptions: string[];
+  woodFinishOptions: string[];
+  priceRange: { min: number; max: number };
+  variants: MaidenHomeVariant[];
+}
+
+interface MaidenHomeVariantResolution {
+  productQuery: string;
+  size: string;
+  woodFinish: string;
+  matched: boolean;
+  variant: MaidenHomeVariant | null;
+  candidates: MaidenHomeVariant[]; // populated when not narrowed to exactly one real variant
+  message: string;
+}
+
+  /**
+   * Maiden Home's Size x Wood Finish product configurator (sofas, sectionals/modular components,
+   * tables) — list every configurable product, read one product's complete priced variant grid,
+   * and resolve a free-text product + size + wood finish to the exact live price and SKU, off
+   * the storefront's own live catalog rather than a researched estimate or a hedged price range.
+   */
+  interface Unit {
+    /**
+     * Lists every Maiden Home product configurable by Size x Wood Finish (sofas,
+     * sectionals/modular components, tables) from the storefront's own live catalog — every size
+     * and wood-finish option, its live price range and variant count. `query` (optional) narrows
+     * the list by a fuzzy match on the product title or product type, e.g. "chelsea" or "dining
+     * table".
+     */
+    searchConfigurations(query?: string): Promise<MaidenHomeConfiguratorProduct[]>;
+
+    /**
+     * Reads one configurator product's complete Size x Wood Finish variant grid — a handle, e.g.
+     * "the-chelsea-sofa-heritage-belgian-linen-lake" — every size x finish combination, each with
+     * its own exact live price, SKU and availability. THROWS on an unrecognized handle, naming
+     * searchConfigurations() as the way to find current ones.
+     */
+    getProduct(handle: string): Promise<MaidenHomeConfiguratorProduct>;
+
+    /**
+     * Resolves a free-text product (e.g. "Chelsea Sofa Heritage Belgian Linen Lake"), size (e.g.
+     * "85\"") and wood finish (e.g. "Driftwood Ash") to the exact priced variant and its product
+     * URL, mirroring the on-page configurator's own selection flow. `matched: true` with a
+     * populated `variant` means exactly one real variant narrowed to; otherwise `candidates` lists
+     * every real variant the product query DID match, so a caller can narrow with an exact
+     * size/finish rather than guessing again. Never throws for an ambiguous or zero match — an
+     * unmatched product name is the one case this DOES treat as a caller error (throws, naming
+     * searchConfigurations()).
+     */
+    resolveVariant(productQuery: string, size: string, woodFinish: string): Promise<MaidenHomeVariantResolution>;
+  }
+}
+
 declare namespace BowmarkProvider_mailchimp {
   // ── Mailchimp — the unit's own declarations, verbatim ──
 interface mailchimpPlanTier {
@@ -9980,13 +11209,30 @@ interface PaypalFeeSchedule {
   sourceUrl: string;
   tables: PaypalFeeTable[];
 }
+type PaypalConversionKind = "goodsOrServices" | "personal" | "payouts" | "other";
+interface PaypalCurrencyConversionCitation {
+  documentId: string;           // the CMS table id this figure came from, e.g. "FEETB26"
+  feeDataKey: string;           // the exact published value used, e.g. "4.00%"
+  internalName: string;
+}
+interface PaypalGetCurrencyConversionQuoteArgs {
+  kind?: PaypalConversionKind;  // "goodsOrServices" | "personal" | "payouts" | "other"
+  audience?: "consumer";        // defaults to "consumer"; merchant is a separate, unverified page
+  country?: string;             // ISO 3166-1 alpha-2, defaults to "us"; only "us" is verified end-to-end
+}
+interface PaypalCurrencyConversionQuote {
+  kind: PaypalConversionKind;   // which PayPal-conversion context the spread applies to
+  paypalSpread: number;         // 0.04 for goodsOrServices/personal/payouts; 0.03 for "other"
+  citations: { paypal: PaypalCurrencyConversionCitation };
+}
 
   /**
    * PayPal's public, signed-out surfaces: the published consumer and merchant fee schedules, the
-   * fee on one concrete personal (friends-and-family) transaction, 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.
+   * fee on one concrete personal (friends-and-family) transaction, the spread PayPal adds on a
+   * currency conversion, Pay Later instalment plans, PayPal.Me handle lookup, Help Center search
+   * and articles, the binding policy documents, PayPal Shopping cashback offers, crypto prices,
+   * and invoice payer-view reads. Three functions callable today — estimateFee, getFees,
+   * getCurrencyConversionQuote.
    */
   interface Unit {
     /**
@@ -10006,6 +11252,18 @@ interface PaypalFeeSchedule {
      * been fetched.
      */
     getFees(args: PaypalGetFeesArgs): Promise<PaypalFeeSchedule>;
+
+    /**
+     * Reads PayPal's published currency-conversion spread — the half of its fee it DOES disclose —
+     * off the same fees page (FEETB26, 4.00% for goodsOrServices/personal/payouts, 3.00% for
+     * "other"), e.g. getCurrencyConversionQuote({ kind: "goodsOrServices" }) -> { kind:
+     * "goodsOrServices", paypalSpread: 0.04, citations: { paypal: { documentId: "FEETB26",
+     * feeDataKey: "4.00%", internalName: "..." } } }. PayPal does NOT publish the wholesale base
+     * rate, so this function returns only the spread; combining it with a base rate from another
+     * provider (e.g. bowmark.providers.oanda.convertCurrency) is the capability tier's job, not a
+     * single provider's. consumer / us only today.
+     */
+    getCurrencyConversionQuote(args: PaypalGetCurrencyConversionQuoteArgs): Promise<PaypalCurrencyConversionQuote>;
   }
 }
 
@@ -10373,6 +11631,77 @@ interface PizzahutDealsForRender {
   }
 }
 
+declare namespace BowmarkProvider_premierbuildings {
+  // ── Premier Portable Buildings — the unit's own declarations, verbatim ──
+interface PremierbuildingsStyle {
+  key: string;
+  label: string;
+  sidingOptions: string[];
+  sizes: { sizeKey: string; width: number; length: number }[];
+  imageUrl: string | null;   // a real product image from Premier's own catalogue
+  roofStyle: string | null;  // "gable", "gambrel", ...
+  roofing: string | null;    // "metal", ...
+  wallHeight: string | null; // Premier's own encoding in inches, e.g. "left-78-right-78-eave-72"
+}
+interface PremierbuildingsPrice {
+  styleKey: string;
+  model: string;
+  sizeKey: string;
+  width: number;
+  length: number;
+  sidingKey: string;
+  zip: string;
+  region: string;
+  basePrice: number;
+  sidingSurcharge: number;
+  total: number;
+  currency: "USD";
+}
+interface PremierbuildingsDealer {
+  key: string;
+  name: string;
+  city: string;
+  state: string;
+  zip: string;
+  phoneNumber: string;
+  dealerURL: string;
+}
+
+  /**
+   * Reads Premier Portable Buildings' own ShedView 3D configurator pricing catalogue — building
+   * styles, real available sizes, and region-exact siding surcharges — plus its real dealer
+   * directory.
+   */
+  interface Unit {
+    /**
+     * Lists every real building style Premier's ShedView configurator offers (Lofted Barn,
+     * Utility, Cabin, Garage, ...) with its real siding options, every real buildable size (width
+     * x length), and what the building actually IS — a real product image, the roof line and
+     * roofing material, and Premier's own wall-height spec — read straight from the configurator's
+     * own live catalogue.
+     */
+    listBuildingStyles(): Promise<PremierbuildingsStyle[]>;
+
+    /**
+     * Prices one real Premier building configuration exactly the way ShedView itself does: the
+     * base price for `styleKey` + `sizeKey` in the pricing region `zip` falls under, plus the
+     * EXACT siding surcharge Premier's own rules add for `sidingKey` at that width and region (0
+     * for the default "urethane-siding"; a real dollar amount, never a guess, for an alternative
+     * like "metal" — the surcharge genuinely varies by both region and building width).
+     * `sidingKey` defaults to "urethane-siding" (Premier's standard siding) when omitted.
+     */
+    priceBuilding(styleKey: string, sizeKey: string, sidingKey: string | undefined, zip: string): Promise<PremierbuildingsPrice>;
+
+    /**
+     * Looks up Premier's real dealer locations in one US state or Canadian province (accepts
+     * either a full name like "Tennessee" or an abbreviation like "TN") — name, city, phone, and
+     * the dealer's own ShedView URL, straight from Premier's live dealer directory, for handing a
+     * priced configuration off to order.
+     */
+    findDealers(state: string): Promise<PremierbuildingsDealer[]>;
+  }
+}
+
 declare namespace BowmarkProvider_progressive {
   // ── Progressive — the unit's own declarations, verbatim ──
 // Progressive's OWN shapes — not a capability contract.
@@ -11685,6 +13014,55 @@ interface SearsStock {
   }
 }
 
+declare namespace BowmarkProvider_seegarsfence {
+  // ── Seegars Fence Company — the unit's own declarations, verbatim ──
+interface SeegarsBranch {
+  id: number;
+  name: string;
+  address1: string;
+  city: string;
+  state: string;
+  zip: string;
+  salesEmail: string;
+  salesPhone: string;
+  webSite: string;
+  outsideServiceAreaText: string;
+  serviceArea: string;
+}
+
+interface SeegarsGeocodedAddress {
+  address1: string;
+  city: string;
+  state: string;
+  zip: string;
+  displayName: string;
+  latitude: number;
+  longitude: number;
+}
+
+interface CheckServiceAreaResult {
+  address: SeegarsGeocodedAddress;
+  inServiceArea: boolean;
+  branch: SeegarsBranch;
+}
+
+  /**
+   * Fence/gate installer (Carolinas). checkServiceArea is live — geocodes an address and reports
+   * whether it's inside Seegars' service area, plus the branch that would handle it.
+   * estimateFencePrice (the actual priced estimate) is a stub — see its notImplemented reason.
+   */
+  interface Unit {
+    /**
+     * Geocodes a free-text address (`address`, e.g. "301 Fayetteville St, Raleigh, NC 27601")
+     * against Seegars Fence's own address-lookup API, then checks it against the branch's
+     * published service-area polygon — the same check the site's own Fence Price Estimator Tool
+     * performs before it will show any pricing. Returns the normalized address, whether it falls
+     * inside the service area, and the branch (name, phone, email, address) that would handle it.
+     */
+    checkServiceArea(args: object): Promise<CheckServiceAreaResult>;
+  }
+}
+
 declare namespace BowmarkProvider_selectblinds {
   // ── SelectBlinds — the unit's own declarations, verbatim ──
 // SelectBlinds' OWN shapes — not a capability contract.
@@ -12414,6 +13792,60 @@ interface SunHomeSaunasCartResult {
   }
 }
 
+declare namespace BowmarkProvider_target {
+  // ── Target — the unit's own declarations, verbatim ──
+interface targetRow {
+  id: string;
+}
+
+interface TargetStoreHoursInterval {
+  begin_time: string;
+  end_date: string;
+  end_time: string;
+}
+
+interface TargetStoreHoursDay {
+  is_open: boolean;
+  date: string;
+  day_name: string;
+  hours: TargetStoreHoursInterval[];
+}
+
+interface TargetStoreGeoSpec {
+  iso_time_zone_code: string;
+  time_zone_code: string;
+  time_zone_utc_offset_name: string;
+}
+
+interface TargetStore {
+  id: string;
+  slug: string;
+  name: string;
+  address: string;
+  phone: string | null;
+  geoSpec: TargetStoreGeoSpec | null;
+  weeklyHours: TargetStoreHoursDay[];
+}
+
+interface TargetStoreSearch {
+  query: string;
+  stores: TargetStore[];
+  warnings: string[];
+}
+
+  /**
+   * Big-box general merchandise — search, product detail, store stock and store lookup on
+   * target.com.
+   */
+  interface Unit {
+    /**
+     * Searches the store-locator for nearby Targets by ZIP, partial ZIP, city, or street+city, and
+     * returns each store's id, slug, name, address, phone, time-zone and 14-day weekly hours.
+     */
+    findStore(args: { query: string }): Promise<TargetStoreSearch>;
+  }
+}
+
 declare namespace BowmarkProvider_teladoc {
   // ── Teladoc Health — the unit's own declarations, verbatim ──
 interface teladocRow {
@@ -13145,6 +14577,40 @@ interface thezebraAutoQuotes {
   }
 }
 
+declare namespace BowmarkProvider_topviewtix {
+  // ── TopView Sightseeing — the unit's own declarations, verbatim ──
+interface topviewtixPackageDetails {
+  id: number;
+  slug: string;
+  name: string;
+  description: string;
+  url: string;
+  adultsPrice: number | null;
+  kidsPrice: number | null;
+  isAdultOnly: boolean;
+  availableDates: string[];
+  blockedDates: string[];
+  soldOutDates: string[];
+  availableUntil: string | null;
+}
+
+  /**
+   * TopView's NYC hop-on-hop-off bus, Statue of Liberty cruise and bike/walking tour packages —
+   * getPackageDetails reads one package's live price and its own real-time booking calendar
+   * (available/blocked/sold-out dates) off topviewtix.com/new-york/<slug>.
+   */
+  interface Unit {
+    /**
+     * Reads one TopView tour package in full — name, description, adult/kid price, and the site's
+     * OWN live booking calendar (which dates are open, blocked, or sold out, and how far out the
+     * calendar reaches). Takes `slug`, the package's own URL slug off
+     * topviewtix.com/new-york/<slug> (e.g. "hop-on-hop-off-pass"). Throws if the slug doesn't
+     * resolve to a real package (a clean 404) rather than returning an empty row.
+     */
+    getPackageDetails(args: object): Promise<topviewtixPackageDetails>;
+  }
+}
+
 declare namespace BowmarkProvider_trektravel {
   // ── Trek Travel — the unit's own declarations, verbatim ──
 // Trek Travel's OWN shapes — not a capability contract.
@@ -13767,15 +15233,57 @@ interface wellfoundCompanyDetail {
      * experience-requirement text and the hiring startup.
      */
     getJob(args: { url: string }): Promise<wellfoundJobDetail>;
+  }
+}
 
+declare namespace BowmarkProvider_yourarborhome {
+  // ── Arbor Homes — the unit's own declarations, verbatim ──
+interface ArborHome {
+  uniqueName: string;
+  headline: string;
+  status: string;
+  price: number | null;
+  beds: number | null;
+  bathsFull: number | null;
+  bathsHalf: number | null;
+  sqft: number | null;
+  stories: number | null;
+  moveInDate: string | null;
+  address: { street: string; city: string; state: string; postalCode: string };
+  detailUrl: string | null;
+  selfTourUrl: string | null;
+}
+interface SearchHomesFilters {
+  city?: string;
+  minPrice?: number;
+  maxPrice?: number;
+  minBeds?: number;
+  minBaths?: number;
+  minSqft?: number;
+  status?: string;
+}
+
+  /**
+   * Arbor Homes — Indiana/Ohio/Kentucky new-construction homebuilder (Clayton Properties Group).
+   * searchHomes reads its live quick-move-in inventory (price, beds/baths/sqft, status,
+   * availability); getHome reads one listing by id. Both return the site's own NterNow
+   * self-guided-tour booking link where the listing has it enabled.
+   */
+  interface Unit {
     /**
-     * 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.
+     * Reads Arbor Homes' live quick move-in inventory off yourarborhome.com/homes and returns rows
+     * matching the optional filters (city, price range, min beds/baths/sqft, status) — real price,
+     * beds/baths, square footage, an availability date and, where the listing has it enabled,
+     * Arbor's own NterNow self-guided-tour booking link.
      */
-    getCompany(args: { slug: string }): Promise<wellfoundCompanyDetail>;
+    searchHomes(filters?: SearchHomesFilters): Promise<ArborHome[]>;
+
+    /**
+     * Reads one Arbor Homes listing by the `uniqueName` id `searchHomes` returns — the same row,
+     * for a caller that already picked a home and wants its detail-page URL and self-tour link
+     * without re-filtering the whole search.
+     */
+    getHome(uniqueName: string): Promise<ArborHome>;
   }
 }
 
@@ -13793,6 +15301,148 @@ interface ShopifyVariant {
   /** The store's own per-variant stock flag. */
   available: boolean;
   options: string[];
+  /** The same values keyed by the option's own NAME — { Color: "Black", Size: "S" }.
+   * Read THIS to filter by size; options[1] is only the size on a store that
+   * happens to order it second. {} when the two lists cannot be reconciled. */
+  selectedOptions: Record<string, string>;
+  /** The image the STORE linked to this variant. Usually NULL — most storefronts
+   * publish no image-to-variant link at all, and null says so rather than
+   * handing back the first product picture. */
+  image: ProductImage | null;
+  /** Why this price is, or is not, a markdown. */
+  sale: SaleEvidence;
+}
+interface ProductImage {
+  /** Absolute HTTPS url, at the largest rendition the CDN serves. */
+  url: string;
+  /** The retailer's own alt text, or null. */
+  altText: string | null;
+  /** The retailer's colour name for this picture. Set when the store links it,
+   * or when the whole product is ONE colourway (which is how both yoga
+   * retailers publish: one colour per product). Null otherwise. */
+  color: string | null;
+  colorId: string | null;
+  /** Variant ids the STORE linked. [] means it published no link — NOT that the
+   * image belongs to every variant. */
+  variantIds: string[];
+}
+interface SaleEvidence {
+  /** True only with retailer evidence. NEVER set from a low price or from the
+   * word "sale" in a title. */
+  onSale: boolean;
+  currentPrice: string | null;
+  /** The published "was" price. Strictly greater than currentPrice when
+   * evidenceType is "compare_at_price". Null when nothing published one. */
+  originalPrice: string | null;
+  /** ISO 4217, from the storefront's own /meta.json. Null only when that read
+   * failed — never defaulted to "USD", which is wrong on every non-US store. */
+  currency: string | null;
+  promotionMessage: string | null;
+  /** How it was decided. "compare_at_price" is a struck-through price;
+   * "retailer_sale_badge" is a published sale tag; "none" is not on sale. */
+  evidenceType: "compare_at_price" | "sale_price" | "retailer_sale_badge" | "published_promotion" | "none";
+  /** The retailer text or field the classification rests on, verbatim. */
+  evidenceText: string | null;
+}
+/** The retailer's own labels, read off its published tags, category and options.
+ * NEVER inferred from the title or from an image. Null or [] when unpublished,
+ * which is common and is an honest answer. */
+interface PublishedProductAttributes {
+  audience: string | null;
+  garmentType: "sports_bra" | "tank" | "crop_top" | "leggings" | "shorts" | "other" | null;
+  categories: string[];
+  collections: string[];
+  fabrics: string[];
+  materials: string[];
+  color: string | null;
+  colorFamily: string | null;
+  pattern: string | null;
+  styleTags: string[];
+  neckline: string | null;
+  strapWidth: string | null;
+  backDesign: string | null;
+  sleeveLength: string | null;
+  rise: string | null;
+  waistband: string | null;
+  /** How long the GARMENT is — "Cropped", "Midi". What every store's own
+   * `length::` tag fills, on a top exactly as on a bottom. */
+  garmentLength: string | null;
+  /** The inside leg seam and only that. NULL on a top — a tank has no inseam,
+   * and its length is `garmentLength`. */
+  inseam: string | null;
+  legShape: string | null;
+  fit: string | null;
+  coverage: string | null;
+}
+/** Shared colour, fabric, collection and style family — what makes two garments
+ * PLAUSIBLY coordinate. None of it establishes a set. */
+interface CoordinationMetadata {
+  collectionNames: string[];
+  fabricNames: string[];
+  colorName: string | null;
+  colorId: string | null;
+  colorFamily: string | null;
+  /** The store's own grouping key for one style across its colourways. Two
+   * products sharing it are the same garment in two colours. */
+  productFamily: string | null;
+}
+/** An EXPLICIT retailer-published relationship. Shared colour, fabric,
+ * collection or family is NOT this — that is CoordinationMetadata. Usually [].
+ *
+ * Two doors fill it. On a PRODUCT row it comes from the store's tags, and no
+ * store measured publishes a set tag, so it is [] there. getSetEvidence() reads
+ * the other one: the complementary products a MERCHANDISER pinned by hand,
+ * admitted only for rows the store marks pr_prod_strat=pinned. The algorithmic
+ * "related products" feed is never read into this — that is a recommendation
+ * engine's output, not the retailer stating a pairing. */
+interface RetailerSetEvidence {
+  evidenceType: "official_set" | "shop_the_set" | "complete_the_look" | "matching_piece";
+  evidenceText: string | null;
+  sourceUrl: string | null;
+  setId: string | null;
+  relatedProducts: Array<{ productId: string | null; handle: string | null; title: string | null; url: string | null }>;
+}
+/** What getSetEvidence returns. An OBJECT rather than a bare array so the
+ * healthy EMPTY answer is still probeable: productId and sourceUrl exist only
+ * when BOTH hops answered, where an empty evidence list is the ordinary case. */
+interface ShopifySetEvidence {
+  handle: string;
+  /** Shopify's numeric PRODUCT id — the only key the recommendations door takes,
+   * and published by no other function here. */
+  productId: string;
+  /** The product page the pairing is published on. */
+  sourceUrl: string;
+  /** ONLY the rows a merchandiser pinned by hand. [] when they pinned nothing,
+   * which is the common case and is the STORE's answer. At most one entry — one
+   * statement, N related products. Read this for "what did the retailer SAY". */
+  evidence: RetailerSetEvidence[];
+  /** EVERY row the store recommends, pinned AND algorithmic, deduplicated, each
+   * labelled. Read source.by before treating one as the retailer's decision —
+   * the algorithmic rows are usually SUBSTITUTES rather than companions, since
+   * similarity returns the nearest product and the nearest thing to a baby
+   * monitor is another baby monitor. [] when includeAlgorithmic was false. */
+  recommendations: RecommendedProduct[];
+  /** Non-empty when the store returned a FULL page for an intent, which cannot be
+   * told apart from a longer list cut off at the cap. A merchandiser's pairing is
+   * a statement, so a partial one must not read as the whole. */
+  warnings: string[];
+}
+/** One recommended product, with the store's own label for who chose it. */
+interface RecommendedProduct {
+  productId: string | null;
+  handle: string | null;
+  title: string | null;
+  url: string | null;
+  source: RecommendationSource;
+}
+interface RecommendationSource {
+  /** "retailer" when a merchandiser pinned it; "algorithm" otherwise, INCLUDING
+   * a row the store labelled with nothing — an unknown provenance must never
+   * read as a person's decision. */
+  by: "retailer" | "algorithm";
+  /** The store's own token, verbatim and unmapped — "pinned", "jac" (Jaccard),
+   * "e" (embedding), "collection_fallback". Null when the row carried none. */
+  strategy: string | null;
 }
 interface ShopifyProduct {
   handle: string;
@@ -13806,6 +15456,65 @@ interface ShopifyProduct {
   inStock: boolean;
   tags: string[];
   descriptionHtml: string | null;
+  /** The same copy with its markup removed. */
+  descriptionText: string | null;
+  /** ISO 4217, read once per store from its own /meta.json. */
+  currency: string | null;
+  /** When the store's door ANSWERED this row, ISO 8601 UTC. Every field here is
+   * a live fact with a shelf life — the price, the markdown, the per-variant
+   * stock flag — so read it before treating a cached row as current. Stamped per
+   * REQUEST: a getProducts batch carries one stamp per handle, not one per call. */
+  fetchedAt: string;
+  /** Every image the door published, deduplicated, in the store's own order. */
+  images: ProductImage[];
+  attributes: PublishedProductAttributes;
+  /** Per-FIELD origin for `attributes` — keyed by the same field names. Read it
+   * before ranking on a null: "absent" is the store publishing nothing, and is
+   * the store's own answer; "unreachable" is a door we could not read, and means
+   * UNKNOWN. On this store both doors are one request that either answered or
+   * threw, so nothing here is ever "unreachable" — the status exists because the
+   * same vocabulary is used by providers whose page can refuse mid-answer. */
+  attributeProvenance: Record<string, FieldProvenance>;
+  attributeCompleteness: Completeness;
+  coordination: CoordinationMetadata;
+  retailerSetEvidence: RetailerSetEvidence[];
+}
+/** Where one attribute value came from, and the retailer text behind it. */
+interface FieldProvenance {
+  /** "published" — the retailer stated it. "absent" — every door was silent.
+   * "unreachable" — a door that would carry it was refused, so it is UNKNOWN. */
+  status: "published" | "absent" | "unreachable";
+  /** Which door: "shopify_tags", "shopify_product_type", "shopify_color_option"
+   * or "shopify_product_copy". Null when nothing filled it. */
+  source: string | null;
+  /** The retailer's own words the value rests on, verbatim — the tag, or the
+   * sentence out of the description. Null when nothing filled it. */
+  evidence: string | null;
+  /** On "unreachable" only: what was refused. */
+  detail?: string;
+}
+/** The roll-up over one product's attributeProvenance. */
+interface Completeness {
+  fields: number;
+  published: number;
+  absent: number;
+  unreachable: number;
+  /** published / fields, to 3dp. */
+  ratio: number;
+  /** The fields whose value is UNKNOWN rather than known-empty. Read this before
+   * comparing two rows: a row with entries here was not fully looked at. */
+  unreachableFields: string[];
+  sourcesUsed: string[];
+}
+/** What getProducts returns. PARTIAL by design: one handle the store will not
+ * serve costs that row and nothing else, where getProduct throws. */
+interface ShopifyProductBatch {
+  /** In the order the handles were passed, not the order they finished. */
+  products: ShopifyProduct[];
+  /** Every handle the store did not serve, with what it said. */
+  missing: Array<{ handle: string; detail: string }>;
+  requested: number;
+  warnings: string[];
 }
 interface ShopifyCartLine {
   /** Shopify's own line key, which its cart-change endpoints address a line by. */
@@ -13819,6 +15528,70 @@ interface ShopifyCartLine {
   lineTotal: string;
   url: string;
 }
+/** One collection the store publishes — its own merchandised grouping, and the
+ * ONE place either yoga retailer states a set. Membership in a collection the
+ * retailer NAMED "Matching Sets" is a published fact and is admissible as set
+ * evidence; two products being adjacent inside it is NOT, because a position in
+ * a list is not a statement. */
+interface ShopifyCollection {
+  handle: string;
+  title: string;
+  url: string;
+  descriptionHtml: string | null;
+  /** True when the retailer's OWN title or handle names this a set, a matching
+   * piece or a look. Never inferred from what is inside it. */
+  setLike: boolean;
+  productCount: number | null;
+  updatedAt: string | null;
+}
+interface ShopifyCollectionProducts {
+  handle: string;
+  url: string;
+  /** In the RETAILER's own order. Curated collections are merchandised
+   * top-then-bottom; reading a pairing out of that order is the caller's
+   * inference, never this provider's claim. [] is an ordinary answer. */
+  products: ShopifyProduct[];
+  /** Pass back as opts.cursor for the next page, or NULL when this is the last
+   * one. A collection bigger than one page is reachable only through this. */
+  cursor: string | null;
+  /** Empty on an ordinary page. One entry when the walk hit the store platform's
+   * 25,000-row ceiling with the collection unfinished — a TRUNCATION, which a
+   * null cursor on its own would read as the end of the list. */
+  warnings: string[];
+}
+/** One page of a whole-catalogue walk. Advance it with the cursor; there is
+ * deliberately no "fetch everything" call, because every row is a request
+ * against the store and only the caller knows how many candidates it needs. */
+interface ShopifyProductPage {
+  /** In the store's own MERCHANDISED order — not id, not date. The store may
+   * re-merchandise mid-walk, so key on handle rather than assuming pages are
+   * disjoint. */
+  products: ShopifyProduct[];
+  /** Pass back as opts.cursor for the next page. NULL when the store answered a
+   * short page, which is what the end of the catalogue looks like. */
+  cursor: string | null;
+  /** How many rows this page asked the store for. */
+  limit: number;
+  /** Empty on an ordinary page. One entry when the walk stopped at the 25,000-row
+   * ceiling with the catalogue unfinished. */
+  warnings: string[];
+}
+/** What resolveProductUrl hands back — the product a url names, and the variant
+ * its own ?variant= selected. */
+interface ShopifyProductFromUrl {
+  product: ShopifyProduct;
+  /** The variant ?variant= named, or NULL when the url named none — the ordinary
+   * case for a link off a collection page. Also null when it named one the store
+   * no longer publishes, which warnings says. NEVER the first variant instead:
+   * that answers "is my size in stock" about a different size. */
+  variant: ShopifyVariant | null;
+  /** The ?variant= value exactly as the url carried it, kept even when it
+   * matched nothing — a stale link is a fact about the link. */
+  variantIdInUrl: string | null;
+  /** Empty on a clean resolve. One entry when the url named a variant the store
+   * no longer publishes. */
+  warnings: string[];
+}
 interface ShopifyCart {
   /** The store's own cart token — a bearer credential, so treat it like one. */
   token: string;
@@ -13846,10 +15619,70 @@ interface ShopifyCart {
 
     /**
      * Reads one product by handle — every variant, its exact price, its SKU and whether that
-     * specific size or colour is purchasable right now.
+     * specific size or colour is purchasable right now. Pass { withReviews: true } to ALSO get the
+     * star rating and review count from whichever review app the merchant installed; it is off by
+     * default because it costs a second origin and usually the rendered product page too.
      */
     getProduct(handle: string): Promise<ShopifyProduct>;
 
+    /**
+     * Turns a product URL into the product, which is the address a caller actually holds when a
+     * link arrives from a search result, a page or a person. Takes the whole url — origin, market
+     * prefix, ?variant= and #fragment — so nothing has to be stripped down to a bare handle first,
+     * and the variant the url named comes back beside the product instead of being lost. THROWS,
+     * naming the domain, on a url belonging to another storefront. Takes the same { withReviews:
+     * true } option as getProduct, on the same default: a url is another way of naming one
+     * product, so holding a link rather than a handle must not cost a caller the rating.
+     */
+    resolveProductUrl(url: string): Promise<ShopifyProductFromUrl>;
+
+    /**
+     * Reads FULL detail for many products in one call — the shape for ranking a candidate set,
+     * since a search row carries neither the description copy nor the per-variant stock a ranking
+     * turns on. PARTIAL by construction: a search row's handle may 404 on the Ajax product door
+     * (measured 2026-08-05, 2 of 10 sampled members), so one bad handle is named in `missing` and
+     * costs that row alone, where `getProduct` throws and takes the whole set with it. Capped at
+     * 50 handles because each one is a request to the store. Takes the same { withReviews: true }
+     * option, and is the shape to use for it: the review app's key is learned from the first pages
+     * and reused, so ratings for twenty handles cost a handful of page fetches rather than twenty.
+     */
+    getProducts(handles: string[]): Promise<ShopifyProductBatch>;
+
+    /**
+     * Walks the store's WHOLE catalogue a page at a time, in its own merchandised order — the
+     * shape that makes a realistic candidate set reachable at all, since search ranks against a
+     * query and returns one slice. The caller advances a cursor and stops on its own budget or on
+     * a null cursor. There is deliberately no fetch-everything call: every row is a request
+     * against a stranger's storefront, and how many candidates a ranking needs is the caller's
+     * decision rather than one taken once, inside the library, on behalf of every member.
+     */
+    listProducts(opts?: { limit?: number; cursor?: string | null }): Promise<ShopifyProductPage>;
+
+    /**
+     * Lists the store's own merchandised collections. THIS is where a retailer states a SET: a
+     * collection the store itself named "Matching Sets" or "Activewear Sets" carries setLike:
+     * true, and membership in one is published evidence that two garments are sold together.
+     */
+    listCollections(opts?: { limit?: number }): Promise<ShopifyCollection[]>;
+
+    /**
+     * Reads one collection's products in the retailer's own merchandised order, as full product
+     * rows. An empty list is an ordinary answer — several named 'look' collections publish no
+     * products through this door.
+     */
+    getCollection(handle: string, opts?: { limit?: number; cursor?: string | null }): Promise<ShopifyCollectionProducts>;
+
+    /**
+     * Two answers in one call. `evidence` is ONLY what a MERCHANDISER pinned by hand, in the order
+     * they typed it — an explicit retailer statement, and [] on most products, which is the
+     * retailer's own answer. `recommendations` is EVERY row the store returns including the
+     * algorithmic ones, each carrying source.by (retailer | algorithm) and the store's own
+     * strategy token, so a caller can use them without either field lying. The algorithmic rows
+     * are usually SUBSTITUTES rather than companions. Pass includeAlgorithmic: false to skip the
+     * second request.
+     */
+    getSetEvidence(handle: string, opts?: { includeAlgorithmic?: boolean }): Promise<ShopifySetEvidence>;
+
     /**
      * Puts variants into THIS run's own cart on the store and returns the cart the store reports
      * back. A real write: the cart exists on the store from the first call and belongs to this
@@ -13881,6 +15714,148 @@ interface ShopifyVariant {
   /** The store's own per-variant stock flag. */
   available: boolean;
   options: string[];
+  /** The same values keyed by the option's own NAME — { Color: "Black", Size: "S" }.
+   * Read THIS to filter by size; options[1] is only the size on a store that
+   * happens to order it second. {} when the two lists cannot be reconciled. */
+  selectedOptions: Record<string, string>;
+  /** The image the STORE linked to this variant. Usually NULL — most storefronts
+   * publish no image-to-variant link at all, and null says so rather than
+   * handing back the first product picture. */
+  image: ProductImage | null;
+  /** Why this price is, or is not, a markdown. */
+  sale: SaleEvidence;
+}
+interface ProductImage {
+  /** Absolute HTTPS url, at the largest rendition the CDN serves. */
+  url: string;
+  /** The retailer's own alt text, or null. */
+  altText: string | null;
+  /** The retailer's colour name for this picture. Set when the store links it,
+   * or when the whole product is ONE colourway (which is how both yoga
+   * retailers publish: one colour per product). Null otherwise. */
+  color: string | null;
+  colorId: string | null;
+  /** Variant ids the STORE linked. [] means it published no link — NOT that the
+   * image belongs to every variant. */
+  variantIds: string[];
+}
+interface SaleEvidence {
+  /** True only with retailer evidence. NEVER set from a low price or from the
+   * word "sale" in a title. */
+  onSale: boolean;
+  currentPrice: string | null;
+  /** The published "was" price. Strictly greater than currentPrice when
+   * evidenceType is "compare_at_price". Null when nothing published one. */
+  originalPrice: string | null;
+  /** ISO 4217, from the storefront's own /meta.json. Null only when that read
+   * failed — never defaulted to "USD", which is wrong on every non-US store. */
+  currency: string | null;
+  promotionMessage: string | null;
+  /** How it was decided. "compare_at_price" is a struck-through price;
+   * "retailer_sale_badge" is a published sale tag; "none" is not on sale. */
+  evidenceType: "compare_at_price" | "sale_price" | "retailer_sale_badge" | "published_promotion" | "none";
+  /** The retailer text or field the classification rests on, verbatim. */
+  evidenceText: string | null;
+}
+/** The retailer's own labels, read off its published tags, category and options.
+ * NEVER inferred from the title or from an image. Null or [] when unpublished,
+ * which is common and is an honest answer. */
+interface PublishedProductAttributes {
+  audience: string | null;
+  garmentType: "sports_bra" | "tank" | "crop_top" | "leggings" | "shorts" | "other" | null;
+  categories: string[];
+  collections: string[];
+  fabrics: string[];
+  materials: string[];
+  color: string | null;
+  colorFamily: string | null;
+  pattern: string | null;
+  styleTags: string[];
+  neckline: string | null;
+  strapWidth: string | null;
+  backDesign: string | null;
+  sleeveLength: string | null;
+  rise: string | null;
+  waistband: string | null;
+  /** How long the GARMENT is — "Cropped", "Midi". What every store's own
+   * `length::` tag fills, on a top exactly as on a bottom. */
+  garmentLength: string | null;
+  /** The inside leg seam and only that. NULL on a top — a tank has no inseam,
+   * and its length is `garmentLength`. */
+  inseam: string | null;
+  legShape: string | null;
+  fit: string | null;
+  coverage: string | null;
+}
+/** Shared colour, fabric, collection and style family — what makes two garments
+ * PLAUSIBLY coordinate. None of it establishes a set. */
+interface CoordinationMetadata {
+  collectionNames: string[];
+  fabricNames: string[];
+  colorName: string | null;
+  colorId: string | null;
+  colorFamily: string | null;
+  /** The store's own grouping key for one style across its colourways. Two
+   * products sharing it are the same garment in two colours. */
+  productFamily: string | null;
+}
+/** An EXPLICIT retailer-published relationship. Shared colour, fabric,
+ * collection or family is NOT this — that is CoordinationMetadata. Usually [].
+ *
+ * Two doors fill it. On a PRODUCT row it comes from the store's tags, and no
+ * store measured publishes a set tag, so it is [] there. getSetEvidence() reads
+ * the other one: the complementary products a MERCHANDISER pinned by hand,
+ * admitted only for rows the store marks pr_prod_strat=pinned. The algorithmic
+ * "related products" feed is never read into this — that is a recommendation
+ * engine's output, not the retailer stating a pairing. */
+interface RetailerSetEvidence {
+  evidenceType: "official_set" | "shop_the_set" | "complete_the_look" | "matching_piece";
+  evidenceText: string | null;
+  sourceUrl: string | null;
+  setId: string | null;
+  relatedProducts: Array<{ productId: string | null; handle: string | null; title: string | null; url: string | null }>;
+}
+/** What getSetEvidence returns. An OBJECT rather than a bare array so the
+ * healthy EMPTY answer is still probeable: productId and sourceUrl exist only
+ * when BOTH hops answered, where an empty evidence list is the ordinary case. */
+interface ShopifySetEvidence {
+  handle: string;
+  /** Shopify's numeric PRODUCT id — the only key the recommendations door takes,
+   * and published by no other function here. */
+  productId: string;
+  /** The product page the pairing is published on. */
+  sourceUrl: string;
+  /** ONLY the rows a merchandiser pinned by hand. [] when they pinned nothing,
+   * which is the common case and is the STORE's answer. At most one entry — one
+   * statement, N related products. Read this for "what did the retailer SAY". */
+  evidence: RetailerSetEvidence[];
+  /** EVERY row the store recommends, pinned AND algorithmic, deduplicated, each
+   * labelled. Read source.by before treating one as the retailer's decision —
+   * the algorithmic rows are usually SUBSTITUTES rather than companions, since
+   * similarity returns the nearest product and the nearest thing to a baby
+   * monitor is another baby monitor. [] when includeAlgorithmic was false. */
+  recommendations: RecommendedProduct[];
+  /** Non-empty when the store returned a FULL page for an intent, which cannot be
+   * told apart from a longer list cut off at the cap. A merchandiser's pairing is
+   * a statement, so a partial one must not read as the whole. */
+  warnings: string[];
+}
+/** One recommended product, with the store's own label for who chose it. */
+interface RecommendedProduct {
+  productId: string | null;
+  handle: string | null;
+  title: string | null;
+  url: string | null;
+  source: RecommendationSource;
+}
+interface RecommendationSource {
+  /** "retailer" when a merchandiser pinned it; "algorithm" otherwise, INCLUDING
+   * a row the store labelled with nothing — an unknown provenance must never
+   * read as a person's decision. */
+  by: "retailer" | "algorithm";
+  /** The store's own token, verbatim and unmapped — "pinned", "jac" (Jaccard),
+   * "e" (embedding), "collection_fallback". Null when the row carried none. */
+  strategy: string | null;
 }
 interface ShopifyProduct {
   handle: string;
@@ -13894,6 +15869,65 @@ interface ShopifyProduct {
   inStock: boolean;
   tags: string[];
   descriptionHtml: string | null;
+  /** The same copy with its markup removed. */
+  descriptionText: string | null;
+  /** ISO 4217, read once per store from its own /meta.json. */
+  currency: string | null;
+  /** When the store's door ANSWERED this row, ISO 8601 UTC. Every field here is
+   * a live fact with a shelf life — the price, the markdown, the per-variant
+   * stock flag — so read it before treating a cached row as current. Stamped per
+   * REQUEST: a getProducts batch carries one stamp per handle, not one per call. */
+  fetchedAt: string;
+  /** Every image the door published, deduplicated, in the store's own order. */
+  images: ProductImage[];
+  attributes: PublishedProductAttributes;
+  /** Per-FIELD origin for `attributes` — keyed by the same field names. Read it
+   * before ranking on a null: "absent" is the store publishing nothing, and is
+   * the store's own answer; "unreachable" is a door we could not read, and means
+   * UNKNOWN. On this store both doors are one request that either answered or
+   * threw, so nothing here is ever "unreachable" — the status exists because the
+   * same vocabulary is used by providers whose page can refuse mid-answer. */
+  attributeProvenance: Record<string, FieldProvenance>;
+  attributeCompleteness: Completeness;
+  coordination: CoordinationMetadata;
+  retailerSetEvidence: RetailerSetEvidence[];
+}
+/** Where one attribute value came from, and the retailer text behind it. */
+interface FieldProvenance {
+  /** "published" — the retailer stated it. "absent" — every door was silent.
+   * "unreachable" — a door that would carry it was refused, so it is UNKNOWN. */
+  status: "published" | "absent" | "unreachable";
+  /** Which door: "shopify_tags", "shopify_product_type", "shopify_color_option"
+   * or "shopify_product_copy". Null when nothing filled it. */
+  source: string | null;
+  /** The retailer's own words the value rests on, verbatim — the tag, or the
+   * sentence out of the description. Null when nothing filled it. */
+  evidence: string | null;
+  /** On "unreachable" only: what was refused. */
+  detail?: string;
+}
+/** The roll-up over one product's attributeProvenance. */
+interface Completeness {
+  fields: number;
+  published: number;
+  absent: number;
+  unreachable: number;
+  /** published / fields, to 3dp. */
+  ratio: number;
+  /** The fields whose value is UNKNOWN rather than known-empty. Read this before
+   * comparing two rows: a row with entries here was not fully looked at. */
+  unreachableFields: string[];
+  sourcesUsed: string[];
+}
+/** What getProducts returns. PARTIAL by design: one handle the store will not
+ * serve costs that row and nothing else, where getProduct throws. */
+interface ShopifyProductBatch {
+  /** In the order the handles were passed, not the order they finished. */
+  products: ShopifyProduct[];
+  /** Every handle the store did not serve, with what it said. */
+  missing: Array<{ handle: string; detail: string }>;
+  requested: number;
+  warnings: string[];
 }
 interface ShopifyCartLine {
   /** Shopify's own line key, which its cart-change endpoints address a line by. */
@@ -13907,6 +15941,70 @@ interface ShopifyCartLine {
   lineTotal: string;
   url: string;
 }
+/** One collection the store publishes — its own merchandised grouping, and the
+ * ONE place either yoga retailer states a set. Membership in a collection the
+ * retailer NAMED "Matching Sets" is a published fact and is admissible as set
+ * evidence; two products being adjacent inside it is NOT, because a position in
+ * a list is not a statement. */
+interface ShopifyCollection {
+  handle: string;
+  title: string;
+  url: string;
+  descriptionHtml: string | null;
+  /** True when the retailer's OWN title or handle names this a set, a matching
+   * piece or a look. Never inferred from what is inside it. */
+  setLike: boolean;
+  productCount: number | null;
+  updatedAt: string | null;
+}
+interface ShopifyCollectionProducts {
+  handle: string;
+  url: string;
+  /** In the RETAILER's own order. Curated collections are merchandised
+   * top-then-bottom; reading a pairing out of that order is the caller's
+   * inference, never this provider's claim. [] is an ordinary answer. */
+  products: ShopifyProduct[];
+  /** Pass back as opts.cursor for the next page, or NULL when this is the last
+   * one. A collection bigger than one page is reachable only through this. */
+  cursor: string | null;
+  /** Empty on an ordinary page. One entry when the walk hit the store platform's
+   * 25,000-row ceiling with the collection unfinished — a TRUNCATION, which a
+   * null cursor on its own would read as the end of the list. */
+  warnings: string[];
+}
+/** One page of a whole-catalogue walk. Advance it with the cursor; there is
+ * deliberately no "fetch everything" call, because every row is a request
+ * against the store and only the caller knows how many candidates it needs. */
+interface ShopifyProductPage {
+  /** In the store's own MERCHANDISED order — not id, not date. The store may
+   * re-merchandise mid-walk, so key on handle rather than assuming pages are
+   * disjoint. */
+  products: ShopifyProduct[];
+  /** Pass back as opts.cursor for the next page. NULL when the store answered a
+   * short page, which is what the end of the catalogue looks like. */
+  cursor: string | null;
+  /** How many rows this page asked the store for. */
+  limit: number;
+  /** Empty on an ordinary page. One entry when the walk stopped at the 25,000-row
+   * ceiling with the catalogue unfinished. */
+  warnings: string[];
+}
+/** What resolveProductUrl hands back — the product a url names, and the variant
+ * its own ?variant= selected. */
+interface ShopifyProductFromUrl {
+  product: ShopifyProduct;
+  /** The variant ?variant= named, or NULL when the url named none — the ordinary
+   * case for a link off a collection page. Also null when it named one the store
+   * no longer publishes, which warnings says. NEVER the first variant instead:
+   * that answers "is my size in stock" about a different size. */
+  variant: ShopifyVariant | null;
+  /** The ?variant= value exactly as the url carried it, kept even when it
+   * matched nothing — a stale link is a fact about the link. */
+  variantIdInUrl: string | null;
+  /** Empty on a clean resolve. One entry when the url named a variant the store
+   * no longer publishes. */
+  warnings: string[];
+}
 interface ShopifyCart {
   /** The store's own cart token — a bearer credential, so treat it like one. */
   token: string;
@@ -13934,9 +16032,69 @@ interface ShopifyCart {
 
     /**
      * Reads one product by handle — every variant, its exact price, its SKU and whether that
-     * specific size or colour is purchasable right now.
+     * specific size or colour is purchasable right now. Pass { withReviews: true } to ALSO get the
+     * star rating and review count from whichever review app the merchant installed; it is off by
+     * default because it costs a second origin and usually the rendered product page too.
      */
     getProduct(handle: string): Promise<ShopifyProduct>;
+
+    /**
+     * Turns a product URL into the product, which is the address a caller actually holds when a
+     * link arrives from a search result, a page or a person. Takes the whole url — origin, market
+     * prefix, ?variant= and #fragment — so nothing has to be stripped down to a bare handle first,
+     * and the variant the url named comes back beside the product instead of being lost. THROWS,
+     * naming the domain, on a url belonging to another storefront. Takes the same { withReviews:
+     * true } option as getProduct, on the same default: a url is another way of naming one
+     * product, so holding a link rather than a handle must not cost a caller the rating.
+     */
+    resolveProductUrl(url: string): Promise<ShopifyProductFromUrl>;
+
+    /**
+     * Reads FULL detail for many products in one call — the shape for ranking a candidate set,
+     * since a search row carries neither the description copy nor the per-variant stock a ranking
+     * turns on. PARTIAL by construction: a search row's handle may 404 on the Ajax product door
+     * (measured 2026-08-05, 2 of 10 sampled members), so one bad handle is named in `missing` and
+     * costs that row alone, where `getProduct` throws and takes the whole set with it. Capped at
+     * 50 handles because each one is a request to the store. Takes the same { withReviews: true }
+     * option, and is the shape to use for it: the review app's key is learned from the first pages
+     * and reused, so ratings for twenty handles cost a handful of page fetches rather than twenty.
+     */
+    getProducts(handles: string[]): Promise<ShopifyProductBatch>;
+
+    /**
+     * Walks the store's WHOLE catalogue a page at a time, in its own merchandised order — the
+     * shape that makes a realistic candidate set reachable at all, since search ranks against a
+     * query and returns one slice. The caller advances a cursor and stops on its own budget or on
+     * a null cursor. There is deliberately no fetch-everything call: every row is a request
+     * against a stranger's storefront, and how many candidates a ranking needs is the caller's
+     * decision rather than one taken once, inside the library, on behalf of every member.
+     */
+    listProducts(opts?: { limit?: number; cursor?: string | null }): Promise<ShopifyProductPage>;
+
+    /**
+     * Lists the store's own merchandised collections. THIS is where a retailer states a SET: a
+     * collection the store itself named "Matching Sets" or "Activewear Sets" carries setLike:
+     * true, and membership in one is published evidence that two garments are sold together.
+     */
+    listCollections(opts?: { limit?: number }): Promise<ShopifyCollection[]>;
+
+    /**
+     * Reads one collection's products in the retailer's own merchandised order, as full product
+     * rows. An empty list is an ordinary answer — several named 'look' collections publish no
+     * products through this door.
+     */
+    getCollection(handle: string, opts?: { limit?: number; cursor?: string | null }): Promise<ShopifyCollectionProducts>;
+
+    /**
+     * Two answers in one call. `evidence` is ONLY what a MERCHANDISER pinned by hand, in the order
+     * they typed it — an explicit retailer statement, and [] on most products, which is the
+     * retailer's own answer. `recommendations` is EVERY row the store returns including the
+     * algorithmic ones, each carrying source.by (retailer | algorithm) and the store's own
+     * strategy token, so a caller can use them without either field lying. The algorithmic rows
+     * are usually SUBSTITUTES rather than companions. Pass includeAlgorithmic: false to skip the
+     * second request.
+     */
+    getSetEvidence(handle: string, opts?: { includeAlgorithmic?: boolean }): Promise<ShopifySetEvidence>;
   }
 }
 
@@ -13948,7 +16106,10 @@ interface ShopifyCart {
 interface BowmarkProviders {
   aa: BowmarkProvider_aa.Unit;
   abercrombie: BowmarkProvider_abercrombie.Unit;
+  aiper: BowmarkProvider_aiper.Unit;
+  ajmadison: BowmarkProvider_ajmadison.Unit;
   ashleyfurniture: BowmarkProvider_ashleyfurniture.Unit;
+  atlasseniorliving: BowmarkProvider_atlasseniorliving.Unit;
   avis: BowmarkProvider_avis.Unit;
   azure: BowmarkProvider_azure.Unit;
   barletta: BowmarkProvider_barletta.Unit;
@@ -13956,11 +16117,13 @@ interface BowmarkProviders {
   blenderseyewear: BowmarkProvider_blenderseyewear.Unit;
   bluehaven: BowmarkProvider_bluehaven.Unit;
   bmwusa: BowmarkProvider_bmwusa.Unit;
+  bykoket: BowmarkProvider_bykoket.Unit;
   cancer: BowmarkProvider_cancer.Unit;
   caraway: BowmarkProvider_caraway.Unit;
   cars: BowmarkProvider_cars.Unit;
   cheapflights: BowmarkProvider_cheapflights.Unit;
   chriscraft: BowmarkProvider_chriscraft.Unit;
+  classichome: BowmarkProvider_classichome.Unit;
   classpass: BowmarkProvider_classpass.Unit;
   cloudflare: BowmarkProvider_cloudflare.Unit;
   cyberpowerpc: BowmarkProvider_cyberpowerpc.Unit;
@@ -13969,31 +16132,43 @@ interface BowmarkProviders {
   dickssportinggoods: BowmarkProvider_dickssportinggoods.Unit;
   dillards: BowmarkProvider_dillards.Unit;
   discounttire: BowmarkProvider_discounttire.Unit;
+  embroker: BowmarkProvider_embroker.Unit;
   erieinsurance: BowmarkProvider_erieinsurance.Unit;
   extraspace: BowmarkProvider_extraspace.Unit;
+  firstdibs: BowmarkProvider_firstdibs.Unit;
   flightradar24: BowmarkProvider_flightradar24.Unit;
   ford: BowmarkProvider_ford.Unit;
   framebridge: BowmarkProvider_framebridge.Unit;
   fred: BowmarkProvider_fred.Unit;
   geico: BowmarkProvider_geico.Unit;
   google_flights: BowmarkProvider_google_flights.Unit;
+  gotchacovered: BowmarkProvider_gotchacovered.Unit;
   grainger: BowmarkProvider_grainger.Unit;
+  handypro: BowmarkProvider_handypro.Unit;
+  harmar: BowmarkProvider_harmar.Unit;
+  hauslabs: BowmarkProvider_hauslabs.Unit;
   healthcare_gov: BowmarkProvider_healthcare_gov.Unit;
   hellofresh: BowmarkProvider_hellofresh.Unit;
   hellotend: BowmarkProvider_hellotend.Unit;
   hilton: BowmarkProvider_hilton.Unit;
+  hobie: BowmarkProvider_hobie.Unit;
   hunter: BowmarkProvider_hunter.Unit;
   ibuypower: BowmarkProvider_ibuypower.Unit;
   insurify: BowmarkProvider_insurify.Unit;
   interiordefine: BowmarkProvider_interiordefine.Unit;
+  islllc: BowmarkProvider_islllc.Unit;
   joybird: BowmarkProvider_joybird.Unit;
   kayak: BowmarkProvider_kayak.Unit;
+  kitchentuneup: BowmarkProvider_kitchentuneup.Unit;
+  kompan: BowmarkProvider_kompan.Unit;
   labcorp: BowmarkProvider_labcorp.Unit;
   linkedin: BowmarkProvider_linkedin.Unit;
   liquiddeath: BowmarkProvider_liquiddeath.Unit;
   lonelyplanet: BowmarkProvider_lonelyplanet.Unit;
+  louvershop: BowmarkProvider_louvershop.Unit;
   lufthansa: BowmarkProvider_lufthansa.Unit;
   lululemon: BowmarkProvider_lululemon.Unit;
+  maidenhome: BowmarkProvider_maidenhome.Unit;
   mailchimp: BowmarkProvider_mailchimp.Unit;
   marriott: BowmarkProvider_marriott.Unit;
   mcdonalds: BowmarkProvider_mcdonalds.Unit;
@@ -14011,28 +16186,33 @@ interface BowmarkProviders {
   paypal: BowmarkProvider_paypal.Unit;
   pirateship: BowmarkProvider_pirateship.Unit;
   pizzahut: BowmarkProvider_pizzahut.Unit;
+  premierbuildings: BowmarkProvider_premierbuildings.Unit;
   progressive: BowmarkProvider_progressive.Unit;
   prose: BowmarkProvider_prose.Unit;
   reddit: BowmarkProvider_reddit.Unit;
   ritani: BowmarkProvider_ritani.Unit;
   samsclub: BowmarkProvider_samsclub.Unit;
   sears: BowmarkProvider_sears.Unit;
+  seegarsfence: BowmarkProvider_seegarsfence.Unit;
   selectblinds: BowmarkProvider_selectblinds.Unit;
   semihandmade: BowmarkProvider_semihandmade.Unit;
   soundcloud: BowmarkProvider_soundcloud.Unit;
   statefarm: BowmarkProvider_statefarm.Unit;
   stickergiant: BowmarkProvider_stickergiant.Unit;
   sunhomesaunas: BowmarkProvider_sunhomesaunas.Unit;
+  target: BowmarkProvider_target.Unit;
   teladoc: BowmarkProvider_teladoc.Unit;
   tentree: BowmarkProvider_tentree.Unit;
   therabody: BowmarkProvider_therabody.Unit;
   thezebra: BowmarkProvider_thezebra.Unit;
+  topviewtix: BowmarkProvider_topviewtix.Unit;
   trektravel: BowmarkProvider_trektravel.Unit;
   ulrichlifestyle: BowmarkProvider_ulrichlifestyle.Unit;
   viewrail: BowmarkProvider_viewrail.Unit;
   visible: BowmarkProvider_visible.Unit;
   walmart: BowmarkProvider_walmart.Unit;
   wellfound: BowmarkProvider_wellfound.Unit;
+  yourarborhome: BowmarkProvider_yourarborhome.Unit;
   "000de82": BowmarkFamily_shopify_store.Unit;
   "001r3iv0": BowmarkFamily_shopify_store.Unit;
   "00246d8e": BowmarkFamily_shopify_store.Unit;
@@ -51063,6 +53243,7 @@ interface BowmarkProviders {
   santabarbaraforgeandiron: BowmarkFamily_shopify_store.Unit;
   santabarbaranutrients: BowmarkFamily_shopify_store.Unit;
   santaclararealtorstore: BowmarkFamily_shopify_store.Unit;
+  santacruzbicycles: BowmarkFamily_shopify_store.Unit;
   santacruzmountainsclothing: BowmarkFamily_shopify_store.Unit;
   santafesoapranch: BowmarkFamily_shopify_store.Unit;
   santafewineandchilefiesta: BowmarkFamily_shopify_store.Unit;
@@ -65762,5 +67943,6 @@ interface BowmarkLibrary {
   music: BowmarkCapability_music.Unit;
   pcparts: BowmarkCapability_pcparts.Unit;
   read: BowmarkCapability_read.Unit;
+  sheds: BowmarkCapability_sheds.Unit;
   providers: BowmarkProviders;
 }