@bowmark/web 1.5.0 → 1.6.0

package/src/generated/library.d.ts

@@ -5,8 +5,8 @@
 // rather than imported. An `import` or `export` at the top level of this file would
 // turn it into a module and every declaration below would stop being global.
 //
-// Manifest version: 75ed32aa210bc375ea259fb61276ab65363d6b123ba60e63283bdfa36a58a3d5
-// 8 capabilities, 87 providers, 294 typed functions, 20 refused.
+// Manifest version: 5426792a92faf41fd663aa77ef068ec2f38bcc28d33426a6a565458c7a3b4c42
+// 8 capabilities, 95 providers, 316 typed functions, 20 refused.
 // 51,713 family members, sharing 2 interface(s) — declared once and pointed at, never repeated per member.
 //
 // REFUSED — these functions are real and callable, and their declared arguments
@@ -2103,6 +2103,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 =
@@ -3957,6 +4022,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 {
@@ -5110,6 +5219,79 @@ interface graingerStockRow {
   }
 }
 
+declare namespace BowmarkProvider_hauslabs {
+  // ── Haus Labs by Lady Gaga — the unit's own declarations, verbatim ──
+interface HauslabsVariant {
+  id: string;
+  title: string;
+  price: string;
+  compareAtPrice: string | null;
+  sku: string | null;
+  available: boolean;
+  options: string[];
+}
+interface HauslabsProduct {
+  handle: string;
+  title: string;
+  vendor: string;
+  productType: string;
+  url: string;
+  descriptionHtml: string | null;
+  optionNames: string[];
+  variants: HauslabsVariant[];
+  priceRange: { min: string; max: string } | null;
+  inStock: boolean;
+  tags: string[];
+  images: string[];
+}
+interface HauslabsShadeMatch {
+  quiz: { family: string; depth: string; undertone: string; hasAddOne: boolean };
+  variant: {
+    number: number;
+    family: string;
+    sku: string | null;
+    price: string;
+    available: boolean;
+  };
+  product: HauslabsProduct;
+  warnings: string[];
+}
+
+  /**
+   * Haus Labs by Lady Gaga product catalogue — every clean-beauty SKU, its variants, its prices
+   * and what is in stock — read off the live Shopify Plus storefront. The Foundation Shade
+   * Finder is the broadcast wedge: a multi-step quiz ChatGPT cannot operate, mapped locally to
+   * one specific priced shade with the buy-page handoff.
+   */
+  interface Unit {
+    /**
+     * Reads the live Haus Labs catalogue as the storefront publishes it — every product, its
+     * handle, title, vendor, description, tags, images and the per-variant price the storefront is
+     * quoting right now. Optional productType narrows to FACE / LIPS / EYES / SETS / etc. before
+     * the limit. Returns [] on a transport failure (warnings would be on an object envelope; this
+     * is a list). The catalog page is the line and the parse is the unit of work.
+     */
+    listHauslabsProducts(opts?: { limit?: number; productType?: string }): Promise<HauslabsProduct[]>;
+
+    /**
+     * Reads one product by its handle — every variant, its exact price, the image the storefront
+     * is showing and whether that specific variant is purchasable right now. Takes the handle
+     * listHauslabsProducts returns. THROWS on an unknown handle (the store answers a real 404).
+     */
+    getHauslabsProduct(handle: string): Promise<HauslabsProduct>;
+
+    /**
+     * Resolves a buyer's Foundation Lab quiz answers to ONE specific shade: the variant title, the
+     * SKU, the real price, the availability, the buy-page URL. Mirrors the quiz's `shadeLogic`
+     * decision tree natively against Cartful Solutions' published `pd.json` (keyless, browserless)
+     * and resolves the matching variant through /products/<handle>.js for live price and stock.
+     * The quiz is a 5-step Shopify section ChatGPT cannot operate on the buyer's behalf; this
+     * function returns the single shade the quiz's terminal page renders for the same inputs.
+     */
+    runFoundationShadeFinder(input: { family: 'Deep' | 'Medium Deep' | 'Medium' | 'Light Medium' | 'Light' | 'Fair'; depth: 'deeper' | 'medium' | 'lighter'; undertone: 'warm' | 'cool' | 'neutral' | 'rosy' | 'golden'; hasAddOne?: boolean }): Promise<HauslabsShadeMatch>;
+  }
+}
+
 declare namespace BowmarkProvider_healthcare_gov {
   // ── HealthCare.gov — the unit's own declarations, verbatim ──
 interface healthcare_govPlan {
@@ -7976,6 +8158,80 @@ interface LululemonVariant {
   available: boolean;
   price: number | null;
   salePrice: number | null;
+  /** Why this SKU's price is, or is not, a markdown. Derived from price and
+   * salePrice, so it can never disagree with them. */
+  sale: SaleEvidence;
+}
+interface SaleEvidence {
+  /** True only with retailer evidence. NEVER from a low price or a title. */
+  onSale: boolean;
+  currentPrice: number | null;
+  /** The list price, when the markdown is against one. */
+  originalPrice: number | null;
+  /** ISO 4217, or null. ALWAYS null here: this feed publishes bare numbers with
+   * no currency code anywhere in the payload. */
+  currency: string | null;
+  promotionMessage: string | null;
+  evidenceType: "compare_at_price" | "sale_price" | "retailer_sale_badge" | "published_promotion" | "none";
+  /** The retailer text or field the classification rests on, verbatim. */
+  evidenceText: string | null;
+}
+interface ProductImage {
+  /** Absolute HTTPS url. */
+  url: string;
+  altText: string | null;
+  /** The colourway's own colour — sound because lululemon publishes its image
+   * list PER COLOURWAY, so every picture in it is that colour by construction. */
+  color: string | null;
+  colorId: string | null;
+  /** Always [] here: this feed links a picture to a COLOUR, never to a size. */
+  variantIds: string[];
+}
+/** The retailer's own labels. On this door that is audience and nothing else —
+ * the HPDP feed publishes no description, tags, fabric, collection or category.
+ * Every other field is null or [], honestly. */
+interface PublishedProductAttributes {
+  audience: string | null;
+  garmentType: "sports_bra" | "tank" | "crop_top" | "leggings" | "shorts" | "other" | null;
+  categories: string[];
+  collections: string[];
+  fabrics: string[];
+  materials: string[];
+  color: string | null;
+  colorFamily: string | null;
+  pattern: string | null;
+  styleTags: string[];
+  neckline: string | null;
+  strapWidth: string | null;
+  backDesign: string | null;
+  sleeveLength: string | null;
+  rise: string | null;
+  waistband: string | null;
+  inseam: string | null;
+  legShape: string | null;
+  fit: string | null;
+  coverage: string | null;
+}
+/** Shared colour and family — what makes two pieces PLAUSIBLY coordinate. None
+ * of it establishes a set. */
+interface CoordinationMetadata {
+  collectionNames: string[];
+  fabricNames: string[];
+  colorName: string | null;
+  colorId: string | null;
+  colorFamily: string | null;
+  productFamily: string | null;
+}
+/** An EXPLICIT retailer-published relationship. ALWAYS [] on this door: the feed's
+ * only product-to-product relation is the ALGORITHMIC similarity rail, which is
+ * getSimilarProducts. Reading that as a set would turn "the recommender put these
+ * near each other" into "lululemon sells these together". */
+interface RetailerSetEvidence {
+  evidenceType: "official_set" | "shop_the_set" | "complete_the_look" | "matching_piece";
+  evidenceText: string | null;
+  sourceUrl: string | null;
+  setId: string | null;
+  relatedProducts: Array<{ productId: string | null; handle: string | null; title: string | null; url: string | null }>;
 }
 interface LululemonOptionGroup {
   /** The machine name. "size" on every lululemon product measured. */
@@ -7997,6 +8253,13 @@ interface LululemonColorway {
   url: string;
   swatchImage: string | null;
   images: string[];
+  /** The SAME pictures as images, carrying this colourway's colour and colorId.
+   * images stays a bare string[] for existing callers; this is the additive half. */
+  imageAssets: ProductImage[];
+  sale: SaleEvidence;
+  coordination: CoordinationMetadata;
+  /** ISO 4217, or null. Always null — see SaleEvidence.currency. */
+  currency: string | null;
   inStock: boolean;
   optionGroups: LululemonOptionGroup[];
   /** What can be BOUGHT in this colour right now — not the full size run. */
@@ -8024,6 +8287,37 @@ interface LululemonProduct {
   /** Other lengths of the same style. Empty on every product measured — on this
    * site an inseam is its OWN product, not an option. */
   sizeTypes: LululemonSizeType[];
+  attributes: PublishedProductAttributes;
+  coordination: CoordinationMetadata;
+  retailerSetEvidence: RetailerSetEvidence[];
+}
+/** One published product-detail block from the page, verbatim. */
+interface LululemonFeature {
+  heading: string;
+  body: string;
+}
+/** What lululemon's OWN product page publishes about a garment, which the
+ * third-party pricing door does not carry at all. */
+interface LululemonProductAttributes {
+  productId: string;
+  url: string;
+  title: string;
+  /** The site's own ProductGroup category, e.g. "Leggings". */
+  category: string | null;
+  description: string | null;
+  /** Trademarked fabric names off the detail accordion, e.g. ["Nulu"]. */
+  fabrics: string[];
+  fit: string | null;
+  /** "High-Rise" / "Mid-Rise" / "Low-Rise", as the title spells it. */
+  rise: string | null;
+  /** Every detail block, unmapped and in page order. */
+  features: LululemonFeature[];
+  /** The site's own aggregate — the honest one. The pricing door reports 0
+   * reviews on products whose live page shows 22,748. */
+  ratingValue: number | null;
+  reviewCount: number | null;
+  /** What could not be reached. Non-empty means the page refused. */
+  warnings: string[];
 }
 interface LululemonRow {
   id: string;
@@ -8079,6 +8373,19 @@ interface LululemonSimilarProducts {
      */
     getProduct(query: { productId: string }): Promise<LululemonProduct>;
 
+    /**
+     * Reads what lululemon's OWN product page publishes about a garment and the third-party
+     * pricing door does not carry at all: the category the site files it under, the collection
+     * description, the trademarked fabric it is cut from, the fit and the rise, its real review
+     * aggregate, and every product-detail block verbatim. This is the expensive door on this
+     * provider — a headed Google Chrome, ~10-20x the latency of `getProduct` — so call it when the
+     * ATTRIBUTES are the answer and `getProduct` when the price, colourways and sizes are. It
+     * never throws on a refused page: a page that will not render comes back with every field
+     * empty and a `warnings` entry naming it, so an empty `fabrics` is distinguishable from an
+     * unread one.
+     */
+    getProductAttributes(query: { productId: string }): Promise<LululemonProductAttributes>;
+
     /**
      * Returns the products lululemon's own product pages recommend alongside one product — the
      * 'You may also like' rail — as priced rows in the store's own ranked order, de-duplicated to
@@ -8091,6 +8398,82 @@ interface LululemonSimilarProducts {
   }
 }
 
+declare namespace BowmarkProvider_maidenhome {
+  // ── Maiden Home — the unit's own declarations, verbatim ──
+// Maiden Home's OWN shapes — not a capability contract.
+
+interface MaidenHomeVariant {
+  productHandle: string;
+  productTitle: string;
+  productType: string;      // e.g. "Sofa", "Modular Component", "Dining Table"
+  size: string;              // e.g. "85\" Width", or a non-numeric value like "Right-Facing Chaise"
+  woodFinish: string;        // e.g. "Driftwood Ash"
+  sku: string;
+  price: number;
+  priceFormatted: string;
+  available: boolean;
+  url: string;               // the product page, preselecting this exact variant
+}
+
+interface MaidenHomeConfiguratorProduct {
+  handle: string;
+  title: string;
+  productType: string;
+  url: string;
+  sizeOptions: string[];
+  woodFinishOptions: string[];
+  priceRange: { min: number; max: number };
+  variants: MaidenHomeVariant[];
+}
+
+interface MaidenHomeVariantResolution {
+  productQuery: string;
+  size: string;
+  woodFinish: string;
+  matched: boolean;
+  variant: MaidenHomeVariant | null;
+  candidates: MaidenHomeVariant[]; // populated when not narrowed to exactly one real variant
+  message: string;
+}
+
+  /**
+   * Maiden Home's Size x Wood Finish product configurator (sofas, sectionals/modular components,
+   * tables) — list every configurable product, read one product's complete priced variant grid,
+   * and resolve a free-text product + size + wood finish to the exact live price and SKU, off
+   * the storefront's own live catalog rather than a researched estimate or a hedged price range.
+   */
+  interface Unit {
+    /**
+     * Lists every Maiden Home product configurable by Size x Wood Finish (sofas,
+     * sectionals/modular components, tables) from the storefront's own live catalog — every size
+     * and wood-finish option, its live price range and variant count. `query` (optional) narrows
+     * the list by a fuzzy match on the product title or product type, e.g. "chelsea" or "dining
+     * table".
+     */
+    searchConfigurations(query?: string): Promise<MaidenHomeConfiguratorProduct[]>;
+
+    /**
+     * Reads one configurator product's complete Size x Wood Finish variant grid — a handle, e.g.
+     * "the-chelsea-sofa-heritage-belgian-linen-lake" — every size x finish combination, each with
+     * its own exact live price, SKU and availability. THROWS on an unrecognized handle, naming
+     * searchConfigurations() as the way to find current ones.
+     */
+    getProduct(handle: string): Promise<MaidenHomeConfiguratorProduct>;
+
+    /**
+     * Resolves a free-text product (e.g. "Chelsea Sofa Heritage Belgian Linen Lake"), size (e.g.
+     * "85\"") and wood finish (e.g. "Driftwood Ash") to the exact priced variant and its product
+     * URL, mirroring the on-page configurator's own selection flow. `matched: true` with a
+     * populated `variant` means exactly one real variant narrowed to; otherwise `candidates` lists
+     * every real variant the product query DID match, so a caller can narrow with an exact
+     * size/finish rather than guessing again. Never throws for an ambiguous or zero match — an
+     * unmatched product name is the one case this DOES treat as a caller error (throws, naming
+     * searchConfigurations()).
+     */
+    resolveVariant(productQuery: string, size: string, woodFinish: string): Promise<MaidenHomeVariantResolution>;
+  }
+}
+
 declare namespace BowmarkProvider_mailchimp {
   // ── Mailchimp — the unit's own declarations, verbatim ──
 interface mailchimpPlanTier {
@@ -9980,13 +10363,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 +10406,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 +10785,71 @@ 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 }[];
+}
+interface PremierbuildingsPrice {
+  styleKey: string;
+  model: string;
+  sizeKey: string;
+  width: number;
+  length: number;
+  sidingKey: string;
+  zip: string;
+  region: string;
+  basePrice: number;
+  sidingSurcharge: number;
+  total: number;
+  currency: "USD";
+}
+interface PremierbuildingsDealer {
+  key: string;
+  name: string;
+  city: string;
+  state: string;
+  zip: string;
+  phoneNumber: string;
+  dealerURL: string;
+}
+
+  /**
+   * Reads Premier Portable Buildings' own ShedView 3D configurator pricing catalogue — building
+   * styles, real available sizes, and region-exact siding surcharges — plus its real dealer
+   * directory.
+   */
+  interface Unit {
+    /**
+     * Lists every real building style Premier's ShedView configurator offers (Lofted Barn,
+     * Utility, Cabin, Garage, ...) with its real siding options and every real buildable size
+     * (width x length), read straight from the configurator's own live catalogue.
+     */
+    listBuildingStyles(): Promise<PremierbuildingsStyle[]>;
+
+    /**
+     * Prices one real Premier building configuration exactly the way ShedView itself does: the
+     * base price for `styleKey` + `sizeKey` in the pricing region `zip` falls under, plus the
+     * EXACT siding surcharge Premier's own rules add for `sidingKey` at that width and region (0
+     * for the default "urethane-siding"; a real dollar amount, never a guess, for an alternative
+     * like "metal" — the surcharge genuinely varies by both region and building width).
+     * `sidingKey` defaults to "urethane-siding" (Premier's standard siding) when omitted.
+     */
+    priceBuilding(styleKey: string, sizeKey: string, sidingKey: string | undefined, zip: string): Promise<PremierbuildingsPrice>;
+
+    /**
+     * Looks up Premier's real dealer locations in one US state or Canadian province (accepts
+     * either a full name like "Tennessee" or an abbreviation like "TN") — name, city, phone, and
+     * the dealer's own ShedView URL, straight from Premier's live dealer directory, for handing a
+     * priced configuration off to order.
+     */
+    findDealers(state: string): Promise<PremierbuildingsDealer[]>;
+  }
+}
+
 declare namespace BowmarkProvider_progressive {
   // ── Progressive — the unit's own declarations, verbatim ──
 // Progressive's OWN shapes — not a capability contract.
@@ -11685,6 +12162,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 +12940,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 +13725,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 +14381,6 @@ interface wellfoundCompanyDetail {
      * experience-requirement text and the hiring startup.
      */
     getJob(args: { url: string }): Promise<wellfoundJobDetail>;
-
-    /**
-     * Reads one startup's `/company/<slug>` profile — the longer product description (HTML), the
-     * full market tagging, location tags with display names, the explicitly-set Remote policy,
-     * total raised, the company's own website, every badge verbatim, and the same `companySize`
-     * band `searchCompanies` already decodes — the context a candidate weighs a startup on before
-     * applying to it. Takes the `slug` a `searchCompanies` row already carries.
-     */
-    getCompany(args: { slug: string }): Promise<wellfoundCompanyDetail>;
   }
 }
 
@@ -13793,6 +14398,95 @@ interface ShopifyVariant {
   /** The store's own per-variant stock flag. */
   available: boolean;
   options: string[];
+  /** The same values keyed by the option's own NAME — { Color: "Black", Size: "S" }.
+   * Read THIS to filter by size; options[1] is only the size on a store that
+   * happens to order it second. {} when the two lists cannot be reconciled. */
+  selectedOptions: Record<string, string>;
+  /** The image the STORE linked to this variant. Usually NULL — most storefronts
+   * publish no image-to-variant link at all, and null says so rather than
+   * handing back the first product picture. */
+  image: ProductImage | null;
+  /** Why this price is, or is not, a markdown. */
+  sale: SaleEvidence;
+}
+interface ProductImage {
+  /** Absolute HTTPS url, at the largest rendition the CDN serves. */
+  url: string;
+  /** The retailer's own alt text, or null. */
+  altText: string | null;
+  /** The retailer's colour name for this picture. Set when the store links it,
+   * or when the whole product is ONE colourway (which is how both yoga
+   * retailers publish: one colour per product). Null otherwise. */
+  color: string | null;
+  colorId: string | null;
+  /** Variant ids the STORE linked. [] means it published no link — NOT that the
+   * image belongs to every variant. */
+  variantIds: string[];
+}
+interface SaleEvidence {
+  /** True only with retailer evidence. NEVER set from a low price or from the
+   * word "sale" in a title. */
+  onSale: boolean;
+  currentPrice: string | null;
+  /** The published "was" price. Strictly greater than currentPrice when
+   * evidenceType is "compare_at_price". Null when nothing published one. */
+  originalPrice: string | null;
+  /** ISO 4217, or null. Null on the REST catalogue door, which publishes no
+   * currency — reported honestly rather than assumed to be USD. */
+  currency: string | null;
+  promotionMessage: string | null;
+  /** How it was decided. "compare_at_price" is a struck-through price;
+   * "retailer_sale_badge" is a published sale tag; "none" is not on sale. */
+  evidenceType: "compare_at_price" | "sale_price" | "retailer_sale_badge" | "published_promotion" | "none";
+  /** The retailer text or field the classification rests on, verbatim. */
+  evidenceText: string | null;
+}
+/** The retailer's own labels, read off its published tags, category and options.
+ * NEVER inferred from the title or from an image. Null or [] when unpublished,
+ * which is common and is an honest answer. */
+interface PublishedProductAttributes {
+  audience: string | null;
+  garmentType: "sports_bra" | "tank" | "crop_top" | "leggings" | "shorts" | "other" | null;
+  categories: string[];
+  collections: string[];
+  fabrics: string[];
+  materials: string[];
+  color: string | null;
+  colorFamily: string | null;
+  pattern: string | null;
+  styleTags: string[];
+  neckline: string | null;
+  strapWidth: string | null;
+  backDesign: string | null;
+  sleeveLength: string | null;
+  rise: string | null;
+  waistband: string | null;
+  inseam: string | null;
+  legShape: string | null;
+  fit: string | null;
+  coverage: string | null;
+}
+/** Shared colour, fabric, collection and style family — what makes two garments
+ * PLAUSIBLY coordinate. None of it establishes a set. */
+interface CoordinationMetadata {
+  collectionNames: string[];
+  fabricNames: string[];
+  colorName: string | null;
+  colorId: string | null;
+  colorFamily: string | null;
+  /** The store's own grouping key for one style across its colourways. Two
+   * products sharing it are the same garment in two colours. */
+  productFamily: string | null;
+}
+/** An EXPLICIT retailer-published relationship. Shared colour, fabric,
+ * collection or family is NOT this — that is CoordinationMetadata. Usually [];
+ * the catalogue door carries no set tags on any store measured. */
+interface RetailerSetEvidence {
+  evidenceType: "official_set" | "shop_the_set" | "complete_the_look" | "matching_piece";
+  evidenceText: string | null;
+  sourceUrl: string | null;
+  setId: string | null;
+  relatedProducts: Array<{ productId: string | null; handle: string | null; title: string | null; url: string | null }>;
 }
 interface ShopifyProduct {
   handle: string;
@@ -13806,6 +14500,14 @@ interface ShopifyProduct {
   inStock: boolean;
   tags: string[];
   descriptionHtml: string | null;
+  /** The same copy with its markup removed. */
+  descriptionText: string | null;
+  currency: string | null;
+  /** Every image the door published, deduplicated, in the store's own order. */
+  images: ProductImage[];
+  attributes: PublishedProductAttributes;
+  coordination: CoordinationMetadata;
+  retailerSetEvidence: RetailerSetEvidence[];
 }
 interface ShopifyCartLine {
   /** Shopify's own line key, which its cart-change endpoints address a line by. */
@@ -13819,6 +14521,30 @@ interface ShopifyCartLine {
   lineTotal: string;
   url: string;
 }
+/** One collection the store publishes — its own merchandised grouping, and the
+ * ONE place either yoga retailer states a set. Membership in a collection the
+ * retailer NAMED "Matching Sets" is a published fact and is admissible as set
+ * evidence; two products being adjacent inside it is NOT, because a position in
+ * a list is not a statement. */
+interface ShopifyCollection {
+  handle: string;
+  title: string;
+  url: string;
+  descriptionHtml: string | null;
+  /** True when the retailer's OWN title or handle names this a set, a matching
+   * piece or a look. Never inferred from what is inside it. */
+  setLike: boolean;
+  productCount: number | null;
+  updatedAt: string | null;
+}
+interface ShopifyCollectionProducts {
+  handle: string;
+  url: string;
+  /** In the RETAILER's own order. Curated collections are merchandised
+   * top-then-bottom; reading a pairing out of that order is the caller's
+   * inference, never this provider's claim. [] is an ordinary answer. */
+  products: ShopifyProduct[];
+}
 interface ShopifyCart {
   /** The store's own cart token — a bearer credential, so treat it like one. */
   token: string;
@@ -13850,6 +14576,20 @@ interface ShopifyCart {
      */
     getProduct(handle: string): Promise<ShopifyProduct>;
 
+    /**
+     * Lists the store's own merchandised collections. THIS is where a retailer states a SET: a
+     * collection the store itself named "Matching Sets" or "Activewear Sets" carries setLike:
+     * true, and membership in one is published evidence that two garments are sold together.
+     */
+    listCollections(opts?: { limit?: number }): Promise<ShopifyCollection[]>;
+
+    /**
+     * Reads one collection's products in the retailer's own merchandised order, as full product
+     * rows. An empty list is an ordinary answer — several named 'look' collections publish no
+     * products through this door.
+     */
+    getCollection(handle: string, opts?: { limit?: number }): Promise<ShopifyCollectionProducts>;
+
     /**
      * Puts variants into THIS run's own cart on the store and returns the cart the store reports
      * back. A real write: the cart exists on the store from the first call and belongs to this
@@ -13881,6 +14621,95 @@ interface ShopifyVariant {
   /** The store's own per-variant stock flag. */
   available: boolean;
   options: string[];
+  /** The same values keyed by the option's own NAME — { Color: "Black", Size: "S" }.
+   * Read THIS to filter by size; options[1] is only the size on a store that
+   * happens to order it second. {} when the two lists cannot be reconciled. */
+  selectedOptions: Record<string, string>;
+  /** The image the STORE linked to this variant. Usually NULL — most storefronts
+   * publish no image-to-variant link at all, and null says so rather than
+   * handing back the first product picture. */
+  image: ProductImage | null;
+  /** Why this price is, or is not, a markdown. */
+  sale: SaleEvidence;
+}
+interface ProductImage {
+  /** Absolute HTTPS url, at the largest rendition the CDN serves. */
+  url: string;
+  /** The retailer's own alt text, or null. */
+  altText: string | null;
+  /** The retailer's colour name for this picture. Set when the store links it,
+   * or when the whole product is ONE colourway (which is how both yoga
+   * retailers publish: one colour per product). Null otherwise. */
+  color: string | null;
+  colorId: string | null;
+  /** Variant ids the STORE linked. [] means it published no link — NOT that the
+   * image belongs to every variant. */
+  variantIds: string[];
+}
+interface SaleEvidence {
+  /** True only with retailer evidence. NEVER set from a low price or from the
+   * word "sale" in a title. */
+  onSale: boolean;
+  currentPrice: string | null;
+  /** The published "was" price. Strictly greater than currentPrice when
+   * evidenceType is "compare_at_price". Null when nothing published one. */
+  originalPrice: string | null;
+  /** ISO 4217, or null. Null on the REST catalogue door, which publishes no
+   * currency — reported honestly rather than assumed to be USD. */
+  currency: string | null;
+  promotionMessage: string | null;
+  /** How it was decided. "compare_at_price" is a struck-through price;
+   * "retailer_sale_badge" is a published sale tag; "none" is not on sale. */
+  evidenceType: "compare_at_price" | "sale_price" | "retailer_sale_badge" | "published_promotion" | "none";
+  /** The retailer text or field the classification rests on, verbatim. */
+  evidenceText: string | null;
+}
+/** The retailer's own labels, read off its published tags, category and options.
+ * NEVER inferred from the title or from an image. Null or [] when unpublished,
+ * which is common and is an honest answer. */
+interface PublishedProductAttributes {
+  audience: string | null;
+  garmentType: "sports_bra" | "tank" | "crop_top" | "leggings" | "shorts" | "other" | null;
+  categories: string[];
+  collections: string[];
+  fabrics: string[];
+  materials: string[];
+  color: string | null;
+  colorFamily: string | null;
+  pattern: string | null;
+  styleTags: string[];
+  neckline: string | null;
+  strapWidth: string | null;
+  backDesign: string | null;
+  sleeveLength: string | null;
+  rise: string | null;
+  waistband: string | null;
+  inseam: string | null;
+  legShape: string | null;
+  fit: string | null;
+  coverage: string | null;
+}
+/** Shared colour, fabric, collection and style family — what makes two garments
+ * PLAUSIBLY coordinate. None of it establishes a set. */
+interface CoordinationMetadata {
+  collectionNames: string[];
+  fabricNames: string[];
+  colorName: string | null;
+  colorId: string | null;
+  colorFamily: string | null;
+  /** The store's own grouping key for one style across its colourways. Two
+   * products sharing it are the same garment in two colours. */
+  productFamily: string | null;
+}
+/** An EXPLICIT retailer-published relationship. Shared colour, fabric,
+ * collection or family is NOT this — that is CoordinationMetadata. Usually [];
+ * the catalogue door carries no set tags on any store measured. */
+interface RetailerSetEvidence {
+  evidenceType: "official_set" | "shop_the_set" | "complete_the_look" | "matching_piece";
+  evidenceText: string | null;
+  sourceUrl: string | null;
+  setId: string | null;
+  relatedProducts: Array<{ productId: string | null; handle: string | null; title: string | null; url: string | null }>;
 }
 interface ShopifyProduct {
   handle: string;
@@ -13894,6 +14723,14 @@ interface ShopifyProduct {
   inStock: boolean;
   tags: string[];
   descriptionHtml: string | null;
+  /** The same copy with its markup removed. */
+  descriptionText: string | null;
+  currency: string | null;
+  /** Every image the door published, deduplicated, in the store's own order. */
+  images: ProductImage[];
+  attributes: PublishedProductAttributes;
+  coordination: CoordinationMetadata;
+  retailerSetEvidence: RetailerSetEvidence[];
 }
 interface ShopifyCartLine {
   /** Shopify's own line key, which its cart-change endpoints address a line by. */
@@ -13907,6 +14744,30 @@ interface ShopifyCartLine {
   lineTotal: string;
   url: string;
 }
+/** One collection the store publishes — its own merchandised grouping, and the
+ * ONE place either yoga retailer states a set. Membership in a collection the
+ * retailer NAMED "Matching Sets" is a published fact and is admissible as set
+ * evidence; two products being adjacent inside it is NOT, because a position in
+ * a list is not a statement. */
+interface ShopifyCollection {
+  handle: string;
+  title: string;
+  url: string;
+  descriptionHtml: string | null;
+  /** True when the retailer's OWN title or handle names this a set, a matching
+   * piece or a look. Never inferred from what is inside it. */
+  setLike: boolean;
+  productCount: number | null;
+  updatedAt: string | null;
+}
+interface ShopifyCollectionProducts {
+  handle: string;
+  url: string;
+  /** In the RETAILER's own order. Curated collections are merchandised
+   * top-then-bottom; reading a pairing out of that order is the caller's
+   * inference, never this provider's claim. [] is an ordinary answer. */
+  products: ShopifyProduct[];
+}
 interface ShopifyCart {
   /** The store's own cart token — a bearer credential, so treat it like one. */
   token: string;
@@ -13937,6 +14798,20 @@ interface ShopifyCart {
      * specific size or colour is purchasable right now.
      */
     getProduct(handle: string): Promise<ShopifyProduct>;
+
+    /**
+     * Lists the store's own merchandised collections. THIS is where a retailer states a SET: a
+     * collection the store itself named "Matching Sets" or "Activewear Sets" carries setLike:
+     * true, and membership in one is published evidence that two garments are sold together.
+     */
+    listCollections(opts?: { limit?: number }): Promise<ShopifyCollection[]>;
+
+    /**
+     * Reads one collection's products in the retailer's own merchandised order, as full product
+     * rows. An empty list is an ordinary answer — several named 'look' collections publish no
+     * products through this door.
+     */
+    getCollection(handle: string, opts?: { limit?: number }): Promise<ShopifyCollectionProducts>;
   }
 }
 
@@ -13956,6 +14831,7 @@ 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;
@@ -13971,6 +14847,7 @@ interface BowmarkProviders {
   discounttire: BowmarkProvider_discounttire.Unit;
   erieinsurance: BowmarkProvider_erieinsurance.Unit;
   extraspace: BowmarkProvider_extraspace.Unit;
+  firstdibs: BowmarkProvider_firstdibs.Unit;
   flightradar24: BowmarkProvider_flightradar24.Unit;
   ford: BowmarkProvider_ford.Unit;
   framebridge: BowmarkProvider_framebridge.Unit;
@@ -13978,6 +14855,7 @@ interface BowmarkProviders {
   geico: BowmarkProvider_geico.Unit;
   google_flights: BowmarkProvider_google_flights.Unit;
   grainger: BowmarkProvider_grainger.Unit;
+  hauslabs: BowmarkProvider_hauslabs.Unit;
   healthcare_gov: BowmarkProvider_healthcare_gov.Unit;
   hellofresh: BowmarkProvider_hellofresh.Unit;
   hellotend: BowmarkProvider_hellotend.Unit;
@@ -13994,6 +14872,7 @@ interface BowmarkProviders {
   lonelyplanet: BowmarkProvider_lonelyplanet.Unit;
   lufthansa: BowmarkProvider_lufthansa.Unit;
   lululemon: BowmarkProvider_lululemon.Unit;
+  maidenhome: BowmarkProvider_maidenhome.Unit;
   mailchimp: BowmarkProvider_mailchimp.Unit;
   marriott: BowmarkProvider_marriott.Unit;
   mcdonalds: BowmarkProvider_mcdonalds.Unit;
@@ -14011,22 +14890,26 @@ 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;