@bowmark/web 1.11.0 → 1.12.1

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: 54e3683692de6415062143d692a1ab30846dc38d8f5c9ba7c14182a3b3618f7d
-// 18 capabilities, 237 providers, 620 typed functions, 20 refused.
+// Manifest version: 5207ea33354972da803d6974eed73abefc0ae46410767310486fd5116faa04c1
+// 34 capabilities, 257 providers, 674 typed functions, 20 refused.
 // 51,715 family members, sharing 2 interface(s) — declared once and pointed at, never repeated per member.
 //
 // REFUSED — these functions are real and callable, and their declared arguments
@@ -36,6 +36,92 @@
 
 
 
+declare namespace BowmarkCapability_bundles {
+  // ── Check whether a set of products can be built and bought right now — the unit's own declarations, verbatim ──
+interface BundleItemAvailability {
+  url: string
+  ok: boolean
+  buildable: boolean
+  price: { amount: number; currency: string } | null   // integer minor units
+  availability: string | null
+  reason: string | null
+}
+interface BundleAvailability {
+  buildable: boolean
+  items: BundleItemAvailability[]
+  blocking: string[]        // urls of the items stopping the bundle
+  totalPrice: { amount: number; currency: string } | null
+  warnings: string[]
+}
+
+  /**
+   * Given a list of product page urls, reads each one's price and stock the way
+   * `products.getAvailability` does, then reduces the set to one buildable/not-buildable verdict
+   * naming whatever is blocking it.
+   */
+  interface Unit {
+    /**
+     * Reads every item's product page and returns whether the WHOLE bundle can be built and bought
+     * right now — false the moment any one item is out of stock, pre-order, or unreadable, naming
+     * which url(s) are blocking it in `blocking`. Never throws on a bad or dead item url; that
+     * item is reported as not buildable instead, with its reason.
+     */
+    checkAvailability(items: { url: string }[]): Promise<BundleAvailability>;
+  }
+}
+
+declare namespace BowmarkCapability_cable_railing_quote {
+  // ── Cable railing design quote (materials & mounting options) — the unit's own declarations, verbatim ──
+type CableRailingMaterial = {
+  slug: string
+  title: string
+  metal: boolean
+  defaultFinish: string | null
+  finishes: string[]
+}
+type CableRailingMountingStyle = {
+  slug: string
+  title: string
+  availableMaterials: string[]
+}
+type CableRailingPricing = {
+  automated: false          // no source publishes an automated instant price — see 'how'
+  how: string                // what actually produces a price (a human, after submission)
+  designAppUrl: string
+}
+type CableRailingDesignOptionsResult = {
+  materials: CableRailingMaterial[]
+  mountingStyles: CableRailingMountingStyle[]
+  pricing: CableRailingPricing
+  warnings: string[]        // always present; empty when nothing was dropped
+}
+
+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
+}
+
+  /**
+   * Returns the real material and mounting-style choices behind Viewrail's Victor cable-railing
+   * design app. There is no automated instant price to return alongside them — Victor prices a
+   * design by having a human review it after submission, and `pricing.how` says so rather than
+   * guessing a number.
+   */
+  interface Unit {
+    /**
+     * Lists Victor's real material families (304/316/2205 stainless, aluminum, wood-grain
+     * aluminum, …) and post-mounting styles (Surface Mount, Side Mount, Core Drill, …), each with
+     * which materials it's available in — the two choices Victor's own draw-and-quote flow asks
+     * first. `pricing.automated` is always `false`: no cable-railing site measured publishes an
+     * automated instant price (Victor's only pricing route is staff-only and 401s any
+     * unauthenticated call), so `pricing.how` names the real next step — draw the layout in Victor
+     * and submit it for a human-priced quote — instead of fabricating a number.
+     */
+    getDesignOptions(options?: CallOptions): Promise<CableRailingDesignOptionsResult>;
+  }
+}
+
 declare namespace BowmarkCapability_cars {
   // ── Car hire — the unit's own declarations, verbatim ──
 type CarQuery = {
@@ -111,6 +197,216 @@ type CallOptions = {
   }
 }
 
+declare namespace BowmarkCapability_coworking {
+  // ── Coworking space day passes — the unit's own declarations, verbatim ──
+type CoworkingDayPass = {
+  venueName: string
+  address: string
+  workspaceName: string       // the pass's own display name at its venue
+  category: string | null     // e.g. "Coworking" — null when unreported
+  capacity: number | null
+  priceAmount: number
+  currency: string            // ISO 4217, always "USD" today (US cities only)
+  bookingUrl: string          // where to actually book — needs a signed-in account
+  latitude: number
+  longitude: number
+  rating: { average: number; count: number } | null
+}
+type FindDayPassesResult = {
+  city: string
+  state: string
+  dayPasses: CoworkingDayPass[]   // [] when nothing is listed today — a real, complete answer
+  warnings: string[]              // always present; empty when nothing was dropped
+}
+
+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
+}
+
+  /**
+   * Finds single-day coworking passes in a US city — venue, price, capacity and a direct booking
+   * link, aggregated across WeWork, Industrious, Regus/Spaces and independent operators via
+   * LiquidSpace. No login, no booking (that needs a signed-in LiquidSpace account).
+   */
+  interface Unit {
+    /**
+     * Finds single-day coworking passes for a US city — `bowmark.coworking.findDayPasses("New
+     * York, NY")` or `{ city: "New York", state: "NY" }` — and reads each one's real, current
+     * price. Returns `dayPasses: []` when nothing is listed for that city today, a real, complete
+     * answer, not a failure. Each pass carries the venue name/address, the pass's own name and
+     * category, capacity, price, coordinates, rating and a direct `bookingUrl` — LiquidSpace's own
+     * page, since booking itself needs a signed-in LiquidSpace account and is out of scope here.
+     * US cities only.
+     */
+    findDayPasses(location: string | { city: string; state: string }, options?: CallOptions): Promise<FindDayPassesResult>;
+  }
+}
+
+declare namespace BowmarkCapability_custom_sofa_configurator {
+  // ── Custom sofa configurator (fabric selection, live pricing) — the unit's own declarations, verbatim ──
+type CustomSofa = {
+  id: string;             // "<source>:<nativeId>" — pass to getConfigurator/priceConfiguration
+  source: string;         // "joybird" | "interiordefine"
+  brand: string;
+  name: string;
+  url: string;
+  basePrice: number;      // whole dollars — see basePriceNote for what it means
+  basePriceNote: string;
+}
+type CustomSofaListResult = { sofas: CustomSofa[]; warnings: string[] }
+
+type CustomSofaChoice = { key: string; label: string; priceDelta: number }
+type CustomSofaOption = {
+  key: string;            // pass as a SELECTIONS key: { [option.key]: choice.key }
+  title: string;
+  required: boolean;
+  choices: CustomSofaChoice[];
+}
+type CustomSofaConfigurator = {
+  id: string; source: string; brand: string; name: string; url: string;
+  basePrice: number; basePriceNote: string; options: CustomSofaOption[];
+  warnings: string[];    // always empty today — getConfigurator is a route to ONE maker
+}
+
+type CustomSofaPriceLine = { option: string; choice: string; priceDelta: number }
+type CustomSofaPriceResult = {
+  id: string; source: string; brand: string;
+  total: number;               // the maker's own live total for this configuration
+  breakdown: CustomSofaPriceLine[];
+  missingRequired: string[];   // total is a FLOOR while this is non-empty
+  unmatched: string[];         // selections that matched no real option/choice
+  url: string;
+  warnings: string[];    // always empty today — priceConfiguration is a route to ONE maker
+}
+
+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
+}
+
+  /**
+   * Configure a real sofa or sectional — pick a fabric, wood stain or leg finish — and get the
+   * maker's own live price, across every maker whose site publishes a real configurator
+   * (Joybird, Interior Define). Not a researched estimate: the same total the maker's own
+   * customizer would show for that exact pick. No sofa named yet? Call listSofas() and
+   * configure/price the first result — that alone answers 'configure a sofa with fabric
+   * selection and live pricing' without asking the caller to pick one first.
+   */
+  interface Unit {
+    /**
+     * Lists configurable sofas/sectionals across every maker — Joybird's whole catalogue (filtered
+     * to sofas and sectionals) plus an Interior Define search (defaults to "sofa" when `query` is
+     * omitted). Each row's `id` is what getConfigurator and priceConfiguration take.
+     * `basePriceNote` says what the price actually means for that maker — Joybird does not charge
+     * per-fabric, so its price is the real total; Interior Define's is a floor. Throws only when
+     * NEITHER maker could be reached.
+     */
+    listSofas(query?: string): Promise<CustomSofaListResult>;
+
+    /**
+     * Reads one sofa's full configurator — every option slot (Fabric, Wood Stain, Color, Finish,
+     * Cushion Fill — the exact set varies by product and maker) with each choice's label and price
+     * delta. Each option's `key` and each choice's `key` are exactly what priceConfiguration takes
+     * back as a selection.
+     */
+    getConfigurator(id: string): Promise<CustomSofaConfigurator>;
+
+    /**
+     * Prices ONE exact configuration against the maker's own live customizer and returns the real
+     * total, a per-choice breakdown, which required slots are still unpicked (the total is a floor
+     * until they are), and a link to the maker's own page for it. `selections` is `{ [option.key]:
+     * choice.key }` using the keys getConfigurator(id) just returned for THIS sofa — never invent
+     * one.
+     */
+    priceConfiguration(id: string, selections: Record<string, string>): Promise<CustomSofaPriceResult>;
+  }
+}
+
+declare namespace BowmarkCapability_developer_api_key_signup {
+  // ── Developer API key signup — the unit's own declarations, verbatim ──
+interface DeveloperApiKeySignupDetails {
+  organization: string
+  email: string
+  occupation?: string
+}
+interface DeveloperApiKeySignupResult {
+  service: string
+  apiKey: string
+  message: string
+  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
+}
+
+  /**
+   * Actually RUNS a developer dashboard's signup flow and hands back a real, usable API key — no
+   * email verification, no CAPTCHA, for the dashboards this covers. Today: Alpha Vantage's free
+   * stock-data API. Call it directly; don't just describe the steps. If the caller gave no
+   * organization/email of their own, invent a placeholder — this is an instant, unverified
+   * free-tier signup, not an account tied to a real identity, so there is nothing to ask
+   * permission for. MAKE THE EMAIL UNIQUE PER CALL (see the worked example) — the dashboard
+   * dedupes by address, so a copied literal example email gets "Redundant origin" on the second
+   * and every later run.
+   */
+  interface Unit {
+    /**
+     * Signs up for a real API key on a developer dashboard — RUN this, don't just explain how —
+     * `bowmark.developer_api_key_signup.signUp("alphavantage", { organization: "Acme Corp", email:
+     * `qa-${Date.now()}@example.com` })`. `service` selects which dashboard (today: "alphavantage"
+     * only — THROWS naming the supported list otherwise, a caller-fixable error).
+     * `details.organization` and `details.email` are required; when the caller did not supply
+     * their own, invent placeholder-shaped ones like the example's — the signup is instant and
+     * unverified, so nothing is lost by not stopping to ask first. MAKE THE EMAIL UNIQUE EVERY
+     * CALL (e.g. embed `Date.now()`, as the example does) — the dashboard rejects a repeated
+     * address with "Redundant origin", so a literal copied example email fails on the second and
+     * every later run. `details.occupation` is optional and dashboard-specific. Returns the real
+     * key plus the dashboard's own confirmation sentence. `options.timeoutMs` sets the call budget
+     * (default 30000).
+     */
+    signUp(service: string, details: { organization: string, email: string, occupation?: string }, options?: CallOptions): Promise<DeveloperApiKeySignupResult>;
+  }
+}
+
+declare namespace BowmarkCapability_domain {
+  // ── Domain name availability check — the unit's own declarations, verbatim ──
+
+interface DomainAvailabilityResult {
+  name: string                  // normalized: lowercased, no scheme, no "www."
+  available: boolean | null     // true = free, false = registered, null = unknown
+  registrar: string | null
+  registeredAt: string | null   // ISO 8601
+  expiresAt: string | null      // ISO 8601
+  price: null                   // always null — see warnings
+  currency: null
+  source: string                // "rdap"
+  warnings: string[]
+}
+
+  /**
+   * Checks whether a domain name is registered — and, when it is, who holds it and when it
+   * expires — straight off RDAP, the IANA-standardized WHOIS successor. No key, no browser.
+   * Price is currently always unknown; see the result's warnings.
+   */
+  interface Unit {
+    /**
+     * Looks up a domain name (e.g. "example.com") against its authoritative RDAP server and
+     * reports whether it is registered, plus the registrar and registration/expiration dates when
+     * it is. `available: null` means the TLD publishes no RDAP service (rare) or the registry
+     * answered something unparseable — check `warnings`. `price`/`currency` are always `null`: no
+     * keyed registrar pricing source is configured, and `warnings` says so on every call rather
+     * than guessing a number.
+     */
+    checkAvailability(name: string): Promise<DomainAvailabilityResult>;
+  }
+}
+
 declare namespace BowmarkCapability_email {
   // ── Email (work addresses & domains) — the unit's own declarations, verbatim ──
 // One candidate email domain for a company. Nulls mean "the source does not
@@ -361,6 +657,52 @@ type FlightStatusResult = {
   }
 }
 
+declare namespace BowmarkCapability_game_soundtrack_composer_credits {
+  // ── Video game soundtrack composer credits — the unit's own declarations, verbatim ──
+
+interface SoundtrackMatch {
+  releaseGroupId: string
+  title: string
+  composer: string
+  firstReleaseDate: string
+  disambiguation: string
+}
+
+interface SoundtrackCredits {
+  releaseGroupId: string
+  title: string
+  composer: string
+  firstReleaseDate: string
+  disambiguation: string
+  relations: { role: string, artist: string }[]
+  warnings: string[]
+}
+
+interface SoundtrackSearchResult {
+  query: string
+  matches: SoundtrackMatch[]
+  warnings: string[]
+}
+
+  /**
+   * Looks up a video game's soundtrack release and who composed it, via MusicBrainz's own
+   * release-group database.
+   */
+  interface Unit {
+    /**
+     * Searches MusicBrainz for soundtrack releases matching a game title and returns each match's
+     * composer credit and release-group id.
+     */
+    search(gameTitle: string): Promise<SoundtrackSearchResult>;
+
+    /**
+     * Looks up one soundtrack release-group by id (from search()) and returns its full
+     * composer/artist credits.
+     */
+    getCredits(releaseGroupId: string): Promise<SoundtrackCredits>;
+  }
+}
+
 declare namespace BowmarkCapability_git_commit_history {
   // ── Git commit history — the unit's own declarations, verbatim ──
 interface Commit {
@@ -416,6 +758,58 @@ type CallOptions = {
   }
 }
 
+declare namespace BowmarkCapability_git_release_notes {
+  // ── Git release notes — the unit's own declarations, verbatim ──
+interface Release {
+  tag: string             // the repo's own tag, e.g. "v7.0.2"
+  name: string             // display name, falls back to the tag when blank
+  draft: boolean
+  prerelease: boolean
+  createdAt: string       // ISO 8601
+  publishedAt: string | null  // ISO 8601, null for a draft never published
+  notes: string             // the release notes text, in the host's own markdown
+  url: string               // the release's own page on the host
+}
+interface ReleaseNotesOptions {
+  limit?: number            // 1-100, default 30
+  page?: number              // 1-based, for paging past limit
+}
+interface ReleaseNotesResult {
+  repo: string               // resolved as "owner/repo", however it was passed
+  releases: Release[]
+  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
+}
+
+  /**
+   * A git repository's own release notes — tag, name, dates and the release notes text for every
+   * release, newest first — from a GitHub URL or a bare owner/repo string. What a changelog or a
+   * "what's new" page is built from, in one call. No repo named yet? Call it on
+   * microsoft/TypeScript (a real, actively-released public repo) to show a caller the shape of
+   * the answer, rather than only asking which repo they meant.
+   */
+  interface Unit {
+    /**
+     * Returns a public GitHub repository's own release history — each release's tag, display name,
+     * draft/prerelease flags, created/published dates, its release notes text (`notes`) and its
+     * own page URL — newest first, GitHub's own order. `repo` takes either form: a full URL
+     * ("https://github.com/microsoft/TypeScript") or the bare "owner/repo" string. `options.limit`
+     * (1-100, default 30) and `options.page` page through history. THROWS a caller-fixable error
+     * for a string that is neither shape, or for an owner/repo GitHub does not have (a private
+     * repo also reads as not-found, unauthenticated). IF THE CALLER NAMED NO REPO: do not stop to
+     * ask — call this immediately with "microsoft/TypeScript" (a real, actively-released public
+     * repo) to show a real, live answer, and mention in your reply that a different repo can be
+     * named.
+     */
+    releaseNotes(repo: string, options?: ReleaseNotesOptions): Promise<ReleaseNotesResult>;
+  }
+}
+
 declare namespace BowmarkCapability_hotels {
   // ── Hotels — the unit's own declarations, verbatim ──
 type HotelQuery = {
@@ -520,25 +914,26 @@ type CallOptions = {
 }
 
   /**
-   * Real national-average installed-cost RANGES for a residential HVAC system, straight off a
-   * manufacturer's own published cost guide — pick a system type ("Air Conditioners", "80%
-   * Furnaces", "90% Furnaces", "Heat Pumps", "Low-Profile Heat Pumps", "Cold-Climate Heat Pumps"
-   * or "Air Handlers") and get the real per-tier (Platinum/Gold/Silver) range, model name and
-   * the source's own disclaimer. Not a bound quote for one home — measured 2026-08-29 that no
-   * national HVAC brand computes a per-configuration price online; every one sells through
-   * independent dealers who set final price locally.
+   * Call bowmark.hvac.getCostEstimate(systemType) to pull a real, published installed-cost RANGE
+   * for a residential HVAC system straight off a manufacturer's own cost guide — pick a system
+   * type ("Air Conditioners", "80% Furnaces", "90% Furnaces", "Heat Pumps", "Low-Profile Heat
+   * Pumps", "Cold-Climate Heat Pumps" or "Air Handlers") and get back the real per-tier
+   * (Platinum/Gold/Silver) price range, model name and source URL. Always call it rather than
+   * answering from memory — these are today's actual published figures. (It is a
+   * national-average range, not a bound quote for one address; every national HVAC brand sells
+   * through independent dealers who set final price locally — see `disclaimer`.)
    */
   interface Unit {
     /**
-     * Reads a real, published national-average installed-cost range for one HVAC system type ("Air
-     * Conditioners", "80% Furnaces", "90% Furnaces", "Heat Pumps", "Low-Profile Heat Pumps",
-     * "Cold-Climate Heat Pumps" or "Air Handlers"), broken into the maker's three tiers
-     * (Platinum/Gold/Silver) with a real model name and cost range per tier. THIS IS A PUBLISHED
-     * ESTIMATE, NOT A BOUND QUOTE for one caller's home or ZIP — no national HVAC brand computes
-     * that online (measured 2026-08-29 across Trane, Carrier, Lennox, Rheem, American Standard and
-     * Goodman), so this returns the closest honest real number: the manufacturer's own
-     * national-average range, with its own disclaimer carried in `disclaimer`. THROWS when the
-     * source could not be reached at all.
+     * Calls the manufacturer's own published cost-guide table and returns a real installed-cost
+     * range for one HVAC system type ("Air Conditioners", "80% Furnaces", "90% Furnaces", "Heat
+     * Pumps", "Low-Profile Heat Pumps", "Cold-Climate Heat Pumps" or "Air Handlers"), broken into
+     * the maker's three tiers (Platinum/Gold/Silver) with a real model name and cost range per
+     * tier. Call this instead of estimating from training data — it returns today's actual
+     * published figures. (It is a national-average range, not a bound quote for one caller's home
+     * or ZIP — no national HVAC brand computes that online, measured 2026-08-29 across Trane,
+     * Carrier, Lennox, Rheem, American Standard and Goodman; the source's own caveat is carried in
+     * `disclaimer`.) THROWS when the source could not be reached at all.
      */
     getCostEstimate(systemType: string, options?: CallOptions): Promise<HvacCostEstimateResult>;
   }
@@ -664,6 +1059,35 @@ type ReferralCarrierListResult = {
                                // out or failed
 }
 
+// getHomeQuotes: real homeowners premiums for one property, fanned out across
+// Insurify's marketplace and Progressive's HomeQuote Explorer panel. Both
+// price nothing without the caller's own identity.
+type HomeQuoteQuery = {
+  identity: { firstName: string, lastName: string, dob: string, email: string, phone: string }
+  address: string   // street address, e.g. "686 Hamlet St"
+  zip: string        // 5-digit US ZIP
+  city?: string       // required TOGETHER WITH state to reach Progressive's panel
+  state?: string      // 2-letter state code, required together with city
+}
+type HomeQuote = {
+  source: string              // which panel this came from
+  carrier: string
+  package: string | null      // Progressive's bundling tier; always null for Insurify
+  annualPremium: number | null   // whole-term premium normalized to 12 months
+  monthlyPremium: number | null  // always null on a Progressive row — it publishes none
+  windHailIncluded: boolean | null  // Progressive only; always null for Insurify
+  quoteUrl: string | null     // Insurify's own bindUrl; always null for Progressive
+}
+type DeclinedHomeCarrier = {
+  source: string
+  carrier: string             // asked and refused to write the property — a real answer
+}
+type HomeQuoteResult = {
+  quotes: HomeQuote[]          // cheapest annualPremium first; nulls last
+  declined: DeclinedHomeCarrier[]
+  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
@@ -673,8 +1097,10 @@ type CallOptions = {
   /**
    * Look up insurance carriers in the regulators' own national register — the NAIC company code,
    * the legal entity behind a consumer brand, head-office contact details, and the states each
-   * carrier is LICENSED to write in, which is not the same as where it is headquartered. Direct
-   * API, no browser.
+   * carrier is LICENSED to write in, which is not the same as where it is headquartered — and
+   * get REAL home insurance quotes and rates for a specific property address from two
+   * independent carrier panels (Insurify's marketplace, Progressive's HomeQuote Explorer).
+   * Direct API, no browser.
    */
   interface Unit {
     /**
@@ -757,6 +1183,122 @@ type CallOptions = {
      * in it. `options.timeoutMs` sets the per-source budget (default 30000).
      */
     listReferralCarriers(query?: ReferralCarrierQuery, options?: CallOptions): Promise<ReferralCarrierListResult>;
+
+    /**
+     * Returns REAL home insurance quotes — actual carrier premiums for one property address,
+     * fanned out across two independent panels: Insurify's own marketplace and Progressive's
+     * HomeQuote Explorer (itself a hand-off to a Bolt-run panel of outside carriers, so
+     * "progressive" here still means several underwriters, not one). `{ identity, address: "686
+     * Hamlet St", zip: "43215", city: "Columbus", state: "OH" }` — `identity` is the CALLER's OWN
+     * `{ firstName, lastName, dob, email, phone }`, required because neither carrier prices a
+     * property without one. `city` and `state` are each optional but REQUIRED TOGETHER to reach
+     * Progressive's panel, which bootstraps off a full postal address; Insurify resolves both from
+     * `zip` on its own and reaches every query this function accepts. Returns `quotes` sorted
+     * CHEAPEST `annualPremium` FIRST (a row with no premium at all sorts last), each carrying
+     * `source`, `carrier`, Progressive's bundling `package` tier (always null for Insurify, which
+     * prices one plan per carrier), `annualPremium` normalized to a 12-month figure so a shorter
+     * or longer term is still comparable, `monthlyPremium` (a carrier's own instalment figure when
+     * it quoted one — always null on a Progressive row, since that panel publishes only the annual
+     * premium per package), `windHailIncluded` (Progressive only), and `quoteUrl` (Insurify's own
+     * `bindUrl` when it published one). `declined` names a carrier a panel asked and REFUSED to
+     * write — a real answer distinct from "no price returned", and never merged into `quotes`.
+     * `warnings` is always present: it names a source that timed out or failed, AND a source not
+     * queried because the query lacked the input it needs (Progressive without `city`+`state`) —
+     * read it before treating a short list as the whole market. When every source the query DID
+     * reach for failed, this THROWS rather than returning an empty list, which would otherwise
+     * read as "nobody would insure this property". `options.timeoutMs` sets the per-source budget
+     * (default 30000).
+     */
+    getHomeQuotes(query: HomeQuoteQuery, options?: CallOptions): Promise<HomeQuoteResult>;
+  }
+}
+
+declare namespace BowmarkCapability_istanbul_schedules {
+  // ── Istanbul attraction opening hours — the unit's own declarations, verbatim ──
+interface AttractionHoursResult {
+  query: string
+  name: string               // the site's own display name for the match
+  openingTime: string | null      // "HH:MM"
+  closingTime: string | null      // "HH:MM"
+  ticketOfficeClosingTime: string | null // "HH:MM" — often earlier than closingTime
+  closedDays: string | null       // the site's own wording, e.g. "Her gün açık"
+  address: string | null
+  phone: string | null
+  email: string | null
+  url: string
+  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
+}
+
+  /**
+   * Live opening/closing hours, ticket-office closing time and closed days for Istanbul museums
+   * and archaeological sites — İstanbul Archaeological Museums, the Hagia Sophia History and
+   * Experience Museum, Galata Tower Museum among them — read straight off muze.gov.tr (Turkey's
+   * Ministry of Culture and Tourism). Call this for the attraction-hours part of any
+   * Istanbul-schedules question, even one that also asks about ferries or shows: answer what it
+   * returns, then say plainly that ferry timetables and show schedules aren't covered — no
+   * reachable machine-readable source was found for either; see this unit's request file for
+   * what was tried. Don't skip the call just because the question is broader than this unit's
+   * scope.
+   */
+  interface Unit {
+    /**
+     * Matches `query` against muze.gov.tr's own museum/site listing (a substring match on the
+     * site's own display name, e.g. "Galata Tower" or "Hagia Sophia") and returns that
+     * attraction's opening/closing hours, ticket-office closing time and closed days. THROWS a
+     * caller-fixable error naming the listing when nothing matches — the listing is a curated
+     * highlight subset, not the whole ministry catalog.
+     */
+    attractionHours(query: string, options?: CallOptions): Promise<AttractionHoursResult>;
+  }
+}
+
+declare namespace BowmarkCapability_mcp_registry {
+  // ── MCP Registry — the unit's own declarations, verbatim ──
+interface McpRegistryEntry {
+  name: string;
+  title: string | null;
+  description: string;
+  version: string;
+  repositoryUrl: string | null;
+  remoteUrl: string | null;
+  status: string;
+}
+
+interface McpRegistrySearchResult {
+  servers: McpRegistryEntry[];
+  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
+}
+
+  /**
+   * Search or browse the official Model Context Protocol server registry — find a published MCP
+   * server by name and get its install or connect URL.
+   */
+  interface Unit {
+    /**
+     * Lists or searches the official MCP server registry (registry.modelcontextprotocol.io) for
+     * published Model Context Protocol servers. `query` substring-matches a server's registry name
+     * — omit it to list the newest-published entries. Each row carries the server's registry name,
+     * title, description, latest version, where to install it (`repositoryUrl`) or connect to it
+     * if it's hosted (`remoteUrl`), and its registry status. This is how an agent answers 'is
+     * there already an MCP server for X' before building one, or finds out what a directory
+     * listing/submission for the MCP ecosystem's own registry actually looks like. `limit` caps
+     * how many rows come back (default 30, max 100). THROWS if the registry cannot be reached —
+     * one source, so there is no partial answer to hand back. `options.timeoutMs` sets the budget
+     * (default 30000).
+     */
+    search(query?: string, limit?: number, options?: CallOptions): Promise<McpRegistrySearchResult>;
   }
 }
 
@@ -921,6 +1463,96 @@ type ProductResult = {
   }
 }
 
+declare namespace BowmarkCapability_phone_trade_in {
+  // ── Phone trade-in value — the unit's own declarations, verbatim ──
+// The capability's own condition vocabulary — four tiers every buyback
+// comparison site groups devices into, whatever it calls them natively.
+type TradeInCondition = "like_new" | "good" | "fair" | "broken";
+
+// One buyback vendor's live cash offer for the requested device.
+type TradeInQuote = {
+  source: string             // which source this quote came from, e.g. "sellcell"
+  merchant: string           // the buyback vendor's own name, e.g. "BuyBackBoss"
+  price: { amount: number; currency: string }   // integer minor units — cents
+  paymentMethods: string[]
+  paymentPeriod: string | null
+  freeShipping: boolean
+}
+type PhoneTradeInEstimate = {
+  model: string              // the resolved device slug, e.g. "iphone-14-pro"
+  storage: string
+  condition: TradeInCondition
+  quotes: TradeInQuote[]     // every vendor's current offer, highest first
+  warnings: string[]         // always present; empty when nothing was dropped
+}
+
+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
+}
+
+  /**
+   * Looks up the current buyback value of an iPhone — model, storage and condition — and returns
+   * every vendor's live cash offer, highest first. Fans out across buyback comparison sources;
+   * direct API, no browser.
+   */
+  interface Unit {
+    /**
+     * Looks up the current buyback value of an iPhone — `bowmark.phone_trade_in.estimate({ model:
+     * "iPhone 14 Pro", storage: "256GB", condition: "good" })` — and returns every vendor's live
+     * cash offer, highest first. `condition` is one of "like_new" | "good" | "fair" | "broken"
+     * (also accepts everyday synonyms like "mint" or "cracked"); defaults to "good" when omitted.
+     * A shorthand string carrying a storage token also works, e.g. `"iPhone 14 Pro 256GB"`. THROWS
+     * on a non-iPhone model (this capability covers Apple devices only today) or a missing storage
+     * capacity — never guesses a capacity, because a wrong guess would silently price the wrong
+     * device. `warnings` is always present and names anything dropped, including a source that
+     * timed out or failed. `options.timeoutMs` sets the per-source budget (default 30000).
+     */
+    estimate(query: { model: string; storage: string; condition?: string } | string, options?: CallOptions): Promise<PhoneTradeInEstimate>;
+  }
+}
+
+declare namespace BowmarkCapability_pricing {
+  // ── Check whether a product page quotes a different price to different shoppers — the unit's own declarations, verbatim ──
+interface PersonalizationPersona {
+  label: string
+  device?: "desktop" | "mobile"   // defaults to "desktop"
+}
+interface PersonaRead {
+  persona: string
+  status: number
+  ok: boolean
+  price: { amount: number; currency: string } | null   // integer minor units
+  display: string | null   // price formatted for a reader, e.g. "$499.99" — quote THIS, not price.amount
+  source: "ld+json" | "none"
+  error: string | null
+}
+interface PersonalizationCheck {
+  url: string
+  requestedUrl: string
+  reads: PersonaRead[]
+  personalized: boolean | null   // null when fewer than 2 personas produced a comparable price
+  warnings: string[]
+}
+
+  /**
+   * Given a product page's url, fetches it once per simulated shopper (desktop vs mobile, each a
+   * fresh cookie-less visit) and reports whether the price they'd see differs — never geography,
+   * loyalty status or browsing history, which no session it holds can simulate.
+   */
+  interface Unit {
+    /**
+     * Reads one product page's price once per persona (default: desktop + mobile, each a fresh
+     * cookie-less visit) and reports whether the personas saw different prices. If the caller
+     * hasn't named a page yet, DO NOT ask them for one first — CALL this function immediately with
+     * the worked example URL below (a real, live product page) so the caller sees a genuine
+     * comparison before you ask which page to check next.
+     */
+    checkPersonalization(url: string, personas?: PersonalizationPersona[]): Promise<PersonalizationCheck>;
+  }
+}
+
 declare namespace BowmarkCapability_products {
   // ── Check a product page's price and stock availability — the unit's own declarations, verbatim ──
 interface ProductAvailability {
@@ -1109,6 +1741,45 @@ type CallOptions = {
   }
 }
 
+declare namespace BowmarkCapability_school_shopping_basket {
+  // ── Price a school-supply list across Target and Walmart — the unit's own declarations, verbatim ──
+interface BasketItemMatch {
+  query: string
+  title: string
+  url: string
+  price: { amount: number; currency: string }   // integer minor units
+}
+interface RetailerBasket {
+  total: { amount: number; currency: string } | null
+  matched: BasketItemMatch[]
+  unavailable: string[]
+}
+interface SchoolShoppingBasket {
+  retailers: { target: RetailerBasket; walmart: RetailerBasket }
+  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
+}
+
+  /**
+   * Given a list of item queries (a school supply list), fans out to Target and Walmart search,
+   * picks the cheapest in-stock match per item per retailer, and returns each retailer's basket
+   * total plus which items neither retailer has in stock right now.
+   */
+  interface Unit {
+    /**
+     * Prices a multi-item shopping list at Target and Walmart, one basket total per retailer,
+     * naming which items had no in-stock match anywhere. Never throws on one retailer being
+     * unreachable — that retailer's basket is dropped and named in `warnings` instead; throws only
+     * when BOTH retailers failed on every item.
+     */
+    priceList(args: { items: string[] }): Promise<SchoolShoppingBasket>;
+  }
+}
+
 declare namespace BowmarkCapability_search {
   // ── Web search — the unit's own declarations, verbatim ──
 type SearchResult = {
@@ -1344,20 +2015,21 @@ type CallOptions = {
   /**
    * Prices a domestic package across USPS and UPS for a ZIP-to-ZIP move, weight and optional
    * dimensions, and returns normalized quotes cheapest first — service name, price and transit
-   * days where the carrier states one. Direct APIs, no browser. Each caller brings their own
-   * USPS and/or UPS developer key; a carrier with no key attached is dropped and named in
-   * `warnings` rather than silently skipped.
+   * days where the carrier states one. Direct JSON, no browser. USPS needs no key and always
+   * quotes; UPS is BYOK, and a caller without a UPS developer key gets the USPS quotes plus a
+   * `warnings` line naming what was dropped rather than a silent skip.
    */
   interface Unit {
     /**
      * Prices a domestic package — `{ fromZip: "20024", toZip: "10001", weightOz: 16 }` — across
      * every USPS and UPS service that quotes it, and returns `rates` cheapest first.
-     * `length`/`width`/`height` (inches) must be given together or omitted entirely. `warnings`
-     * names any carrier dropped for a timeout, an error, or a missing vendor key — each caller
-     * brings their own USPS/UPS developer key; neither carrier is served off a fleet credential.
-     * THROWS `AllProvidersFailedError` when NEITHER carrier answered, because that is a different
-     * fact from "no service quotes this shipment" and only one of them means there truly is no
-     * rate. `options.timeoutMs` sets the per-carrier budget (default 30000).
+     * `length`/`width`/`height` (inches) must be given together or omitted entirely. USPS needs no
+     * API key. UPS is BYOK: bring your own UPS developer key or that leg is dropped and named in
+     * `warnings` (it is never served off a fleet credential). `warnings` also names any carrier
+     * dropped for a timeout or an error. THROWS `AllProvidersFailedError` when NEITHER carrier
+     * answered, because that is a different fact from "no service quotes this shipment" and only
+     * one of them means there truly is no rate. `options.timeoutMs` sets the per-carrier budget
+     * (default 30000).
      */
     estimate(query: ShippingQuery, options?: CallOptions): Promise<ShippingEstimateResult>;
   }
@@ -1397,6 +2069,105 @@ interface TariffLookupResult {
   }
 }
 
+declare namespace BowmarkCapability_text_to_speech {
+  // ── Text to speech — the unit's own declarations, verbatim ──
+interface SynthesizeOptions {
+  voiceId?: string     // an id cloneVoice returned, or the vendor's own default voice
+}
+interface SynthesizeResult {
+  audioBase64: string  // the synthesized audio, base64-encoded
+  contentType: string  // e.g. "audio/mpeg"
+  voiceId: string
+  warnings: string[]
+}
+interface CloneVoiceOptions {
+  name: string
+  sampleUrls: string[]  // audio sample URLs to clone the voice from
+  description?: string
+}
+interface CloneVoiceResult {
+  voiceId: string        // pass this as SynthesizeOptions.voiceId
+  name: string
+  requiresVerification: boolean
+  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
+}
+
+  /**
+   * Converts text into spoken audio, and clones a new voice from caller-supplied audio samples —
+   * narration, dubbing, accessibility, IVR prompts. Requires the caller's own ElevenLabs API key
+   * (BYOK) — see the 🔑 note on this unit.
+   */
+  interface Unit {
+    /**
+     * Converts `text` into spoken audio, base64-encoded, in an existing or previously-cloned voice
+     * (`options.voiceId`, defaulting to a standard voice). Requires an API key — a caller with
+     * none gets a refusal naming what to provide. Call `cloneVoice` first to speak in a specific
+     * cloned voice, then pass the returned `voiceId` here.
+     */
+    synthesize(text: string, options?: SynthesizeOptions): Promise<SynthesizeResult>;
+
+    /**
+     * Creates a new voice cloned from one or more audio sample URLs (`options.sampleUrls`) —
+     * downloads each sample and uploads it to the vendor's cloning endpoint. Returns the new
+     * voice's id, which `synthesize`'s `voiceId` then accepts.
+     */
+    cloneVoice(options: CloneVoiceOptions): Promise<CloneVoiceResult>;
+  }
+}
+
+declare namespace BowmarkCapability_theme_park_tickets {
+  // ── Theme park tickets — the unit's own declarations, verbatim ──
+type TicketOption = {
+  title: string                    // e.g. "Park Ticket", "2027 Gold Pass"
+  subtitle: string | null
+  priceAmount: number | null       // parsed from the site's own price text; null when it didn't parse
+  currency: string                 // ISO 4217, always "USD" today
+  priceModifier: string | null     // e.g. "/ea*", "per night" — null for a flat one-time price
+  wasPriceAmount: number | null    // the struck-through "was" price, same parsing — null when absent
+  buyUrl: string | null            // where to actually buy — a checkout flow is out of scope here
+}
+type ThemeParkTicketsResult = {
+  park: string          // the park name or slug the caller passed
+  parkSlug: string
+  parkTitle: string
+  groupLabel: string    // the site's own section label, e.g. "Daily Tickets"
+  tickets: TicketOption[]
+  warnings: string[]    // always present; empty when nothing was dropped
+}
+
+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
+}
+
+  /**
+   * Reads a Six Flags/Cedar Fair theme park's own ticket page and returns its current pass
+   * prices — title, price, any "was" price and a buy link. Covers every park in the merged
+   * portfolio (Six Flags Magic Mountain, Cedar Point, Kings Island, Knott's Berry Farm,
+   * Carowinds and ~30 more) by name or sixflags.com slug. Disney, Universal and SeaWorld are not
+   * covered yet. No login, no purchase.
+   */
+  interface Unit {
+    /**
+     * Looks up a Six Flags/Cedar Fair theme park by name (`"Cedar Point"`, `"Six Flags Magic
+     * Mountain"`) or sixflags.com slug (`"cedarpoint"`, `"magicmountain"`) and reads its real,
+     * current ticket/pass prices — `bowmark.theme_park_tickets.search("Cedar Point")` or `{ park:
+     * "Cedar Point" }`. Each ticket carries its own title, subtitle, parsed price, any
+     * struck-through "was" price and a buy link, exactly as the park's own site is publishing
+     * today. Throws naming the closest matches when the park name does not resolve to one of the
+     * ~33 parks in the covered portfolio.
+     */
+    search(park: string | { park: string }, options?: CallOptions): Promise<ThemeParkTicketsResult>;
+  }
+}
+
 declare namespace BowmarkCapability_weather {
   // ── Weather forecast for a place — the unit's own declarations, verbatim ──
 
@@ -1433,6 +2204,53 @@ interface ForecastResult {
   }
 }
 
+declare namespace BowmarkCapability_yoga_outfit_shopping {
+  // ── Coordinated yoga outfit shopping — the unit's own declarations, verbatim ──
+interface YogaOutfitItem {
+  source: string              // "lululemon" | "beyondyoga" | "aloyoga"
+  title: string
+  url: string
+  image: string | null        // null when the leg carries none (lululemon's search rows never do)
+  priceLow: number | null
+  priceHigh: number | null
+  currency: string | null     // null when the leg doesn't publish one (lululemon's search door never does)
+  inStock: boolean
+  garmentType: string | null  // the retailer's OWN published label, transcribed — null if the leg
+                              // doesn't publish one (lululemon never does; the Shopify legs' search
+                              // door doesn't either, only getProduct's REST door does)
+  colorFamily: string | null  // shared-colour evidence — null for lululemon
+  fabrics: string[]           // retailer-published fabric names — [] for lululemon
+}
+interface YogaOutfitSearchResult {
+  items: YogaOutfitItem[]
+  warnings: string[]   // always present. Names a retailer that timed out or errored;
+                       // ALL THREE dead throws instead of returning an empty result
+}
+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
+}
+
+  /**
+   * Search for a coordinated yoga outfit across lululemon, Beyond Yoga and Alo Yoga in one call
+   * — one normalized row shape per product, with each retailer's own published garment type,
+   * colour family and fabric names carried through so a caller can spot a plausible
+   * top-and-bottom pair. Never a claim that any retailer sold two items as a set.
+   */
+  interface Unit {
+    /**
+     * Fans out one free-text query to lululemon, Beyond Yoga and Alo Yoga in parallel and returns
+     * every match as one normalized row per product. `limit` (default 8, max 24) applies PER
+     * RETAILER, so a caller asking for 5 gets up to 5 rows from EACH of the three, not 5 total. A
+     * retailer that times out or errors is named in `warnings`, never silently absent; all three
+     * failing throws `AllProvidersFailedError` instead of returning an empty result, which would
+     * be indistinguishable from 'nobody sells this'.
+     */
+    search(query: string, options?: { limit?: number; timeoutMs?: number }): Promise<YogaOutfitSearchResult>;
+  }
+}
+
 declare namespace BowmarkProvider_aa {
   // ── American Airlines — the unit's own declarations, verbatim ──
 interface aaFlight {
@@ -1662,6 +2480,57 @@ interface aaMaxCheckedBagsRule {
   }
 }
 
+declare namespace BowmarkProvider_aauto {
+  // ── 1A Auto — the unit's own declarations, verbatim ──
+interface AautoSearchProduct {
+  id: string;
+  title: string;
+  brand: string;
+  category: string;
+  price: number;
+  url: string;
+  image: string | null;
+}
+interface AautoSearchResult {
+  query: string;
+  /** The site's own reported match count — can exceed products.length. */
+  totalResults: number;
+  products: AautoSearchProduct[];
+}
+interface AautoProduct {
+  id: string;
+  title: string;
+  brand: string;
+  category: string;
+  price: number;
+  sku: string | null;
+  inStock: boolean;
+  description: string;
+  image: string | null;
+  url: string;
+}
+
+  /**
+   * 1A Auto's DIY replacement-parts catalog — search results and one product's real price, stock
+   * and description — read off the live storefront.
+   */
+  interface Unit {
+    /**
+     * Reads 1A Auto's own search-results page for `query` — real price, brand, category and
+     * product URL per row, plus the site's own total-match count. `limit` truncates the first
+     * results page (the site itself paginates; this reads only the first page).
+     */
+    search(query: string, opts?: { limit?: number }): Promise<AautoSearchResult>;
+
+    /**
+     * Reads one product page by the URL search() returns (absolute or a site-relative path) —
+     * title, brand, SKU, price, live stock status and description text. THROWS if the page does
+     * not carry the site's own product data block.
+     */
+    getProduct(url: string): Promise<AautoProduct>;
+  }
+}
+
 declare namespace BowmarkProvider_abercrombie {
   // ── Abercrombie & Fitch — the unit's own declarations, verbatim ──
 interface abercrombieSizeOption {
@@ -1978,6 +2847,79 @@ interface AjmadisonSearchResult {
   }
 }
 
+declare namespace BowmarkProvider_allied {
+  // ── Allied Van Lines — the unit's own declarations, verbatim ──
+interface AlliedSupplyLine {
+  item: string;
+  quantity: number | null;
+}
+interface AlliedRoomSupplies {
+  room: string;
+  supplies: AlliedSupplyLine[];
+}
+interface AlliedPackingEstimate {
+  totalSupplies: AlliedSupplyLine[];
+  byRoom: AlliedRoomSupplies[];
+}
+interface AlliedPackingCalculatorInput {
+  yearsInHome?: "lessThan5" | "5to10" | "over10";
+  cabinetsClosets?: "clutterFree" | "packRat";
+  kitchen?: boolean;
+  pantry?: boolean;
+  diningRoom?: boolean;
+  livingRoom?: boolean;
+  familyRoom?: boolean;
+  homeOffice?: boolean;
+  bedrooms?: number;
+  garageBays?: number;
+  storedAttic?: boolean;
+  storageFacility?: boolean;
+  otherRooms?: number;
+}
+
+  /**
+   * Runs Allied Van Lines' own Packing Calculator — takes which rooms are moving (no name, email
+   * or phone) and returns a real, server-computed whole-house and per-room packing-supply
+   * estimate (cartons, tape, paper). Allied's separate 'quote' flow is a sales-lead form with no
+   * computed price and is out of scope; this is the one part of allied.com that answers a
+   * question with a number.
+   */
+  interface Unit {
+    /**
+     * Allied Van Lines' own Packing Calculator: pass which rooms are moving (kitchen, bedrooms
+     * count, garage bays, etc — no identity required) and get back a real per-room and whole-house
+     * estimate of boxes, tape and paper. At least one room must be set, matching the site's own
+     * validation.
+     */
+    estimatePackingSupplies(input: AlliedPackingCalculatorInput): Promise<AlliedPackingEstimate>;
+  }
+}
+
+declare namespace BowmarkProvider_alphavantage {
+  // ── Alpha Vantage — the unit's own declarations, verbatim ──
+interface AlphavantageSignUpDetails {
+  organization: string;
+  email: string;
+  occupation?: "Investor" | "Software Developer" | "Educator" | "Student" | "I am from the Trading Agents project on Github" | "Other";
+}
+interface AlphavantageSignUpResult {
+  apiKey: string;
+  message: string;
+}
+
+  /**
+   * alphavantage.co's own free-tier signup — issues a real, usable stock-data API key instantly,
+   * no email verification.
+   */
+  interface Unit {
+    /**
+     * Runs alphavantage.co's real signup flow and returns a genuine, immediately usable free-tier
+     * stock-data API key — no email verification, no CAPTCHA.
+     */
+    signUp(details: { organization: string, email: string, occupation?: string }): Promise<AlphavantageSignUpResult>;
+  }
+}
+
 declare namespace BowmarkProvider_americanstandard {
   // ── American Standard Heating & Air Conditioning — the unit's own declarations, verbatim ──
 type AmericanStandardTierName = "Platinum" | "Gold" | "Silver";
@@ -2168,6 +3110,11 @@ interface AppleProductPage {
   url: string;
   products: AppleProduct[];
 }
+interface AppleTradeInEstimate {
+  device: string;
+  upToUsd: number;
+  sourceUrl: string;
+}
 
   /** apple.com's own site search and product pages — no API, no login, no browser. */
   interface Unit {
@@ -2182,6 +3129,15 @@ interface AppleProductPage {
      * every schema.org Product block it publishes.
      */
     getProduct(urlOrPath: string): Promise<AppleProductPage>;
+
+    /**
+     * Reads apple.com's own trade-in value table and returns the CEILING ("up to $X")
+     * cash-or-credit estimate it publishes for one device — a human name ("iPhone 14 Pro") or the
+     * slug `phone_trade_in` already normalizes to ("iphone-14-pro") both resolve. Apple publishes
+     * ONE number per device, not a matrix by storage or condition: the value is Apple's advertised
+     * best-case figure, not a quote for a specific unit's actual condition.
+     */
+    getTradeInEstimate(model: string): Promise<AppleTradeInEstimate>;
   }
 }
 
@@ -3011,6 +3967,47 @@ interface BaublebarCheckoutLink {
   }
 }
 
+declare namespace BowmarkProvider_bcparkscamping {
+  // ── BC Parks Camping (Discover Camping) — the unit's own declarations, verbatim ──
+interface BcParksCampground {
+  resourceLocationId: number;
+  name: string;
+  fullName: string;
+}
+interface BcParksSiteAvailability {
+  resourceId: number;
+  siteName: string | null;
+  nightsRequested: number;
+  nightsAvailable: number;
+  fullyAvailable: boolean;
+}
+interface BcParksAvailabilityResult {
+  resourceLocationId: number;
+  startDate: string;
+  endDate: string;
+  nights: number;
+  sites: BcParksSiteAvailability[];
+}
+
+  /**
+   * camping.bcparks.ca's own reservation API (Discover Camping) — find a provincial park
+   * campground by name, then read its real per-site, per-night availability for a stay.
+   */
+  interface Unit {
+    /**
+     * Given a free-text substring, returns every BC Parks campground whose short or full name
+     * matches, with its resourceLocationId for checkAvailability.
+     */
+    searchCampgrounds(query: string): Promise<BcParksCampground[]>;
+
+    /**
+     * Given a campground's resourceLocationId and a date range, returns each individual campsite's
+     * real per-night availability for that stay.
+     */
+    checkAvailability(arg: { resourceLocationId: number, startDate: string, endDate: string }): Promise<BcParksAvailabilityResult>;
+  }
+}
+
 declare namespace BowmarkProvider_beatthebomb {
   // ── Beat The Bomb — the unit's own declarations, verbatim ──
 interface BeatthebombMission {
@@ -3076,6 +4073,31 @@ interface BeatthebombPriceQuote {
   }
 }
 
+declare namespace BowmarkProvider_bennington {
+  // ── Bennington Marine — the unit's own declarations, verbatim ──
+interface BenningtonModel {
+  slug: string;
+  name: string;
+  url: string;
+  lengthOverall: string | null;
+  beam: string | null;
+  specText: string;
+}
+
+  /**
+   * Bennington's pontoon/tritoon model catalog — length, beam and standard-feature specs read
+   * off each model's own page (S, SX today).
+   */
+  interface Unit {
+    /**
+     * Lists Bennington's pontoon/tritoon model series with their published length overall, beam
+     * and feature specs, read off each model's own page. Pass { model: "sx" } for one model, or
+     * omit args for every known model.
+     */
+    search(args?: { model?: string }): Promise<{ models: BenningtonModel[]; warnings: string[] }>;
+  }
+}
+
 declare namespace BowmarkProvider_bestbuy {
   // ── Best Buy — the unit's own declarations, verbatim ──
 interface bestbuyProduct {
@@ -4179,6 +5201,44 @@ interface CaliProductDetail extends CaliProduct {
   }
 }
 
+declare namespace BowmarkProvider_camelcamelcamel {
+  // ── camelcamelcamel — the unit's own declarations, verbatim ──
+interface CamelPriceStat {
+  price: number | null;
+  date: string | null;
+}
+
+interface CamelPriceTypeStats {
+  lowestEver: CamelPriceStat;
+  highestEver: CamelPriceStat;
+  current: CamelPriceStat;
+  average: number | null;
+}
+
+interface CamelPriceHistory {
+  asin: string;
+  productTitle: string;
+  amazon: CamelPriceTypeStats;
+  thirdPartyNew: CamelPriceTypeStats;
+  thirdPartyUsed: CamelPriceTypeStats;
+  chartUrl: string;
+}
+
+  /**
+   * Independent Amazon price-history tracker — real lowest/highest/current/average price per
+   * item, each dated, so a claimed 'sale' can be checked against what the item actually sold
+   * for.
+   */
+  interface Unit {
+    /**
+     * Reads camelcamelcamel's independently-tracked Amazon price history for one ASIN — the site's
+     * own lowest-ever/highest-ever/current/average figures, each dated, for the Amazon,
+     * 3rd-party-new and 3rd-party-used price types, plus the full-history chart image URL.
+     */
+    getPriceHistory(asinOrUrl: string): Promise<CamelPriceHistory>;
+  }
+}
+
 declare namespace BowmarkProvider_cancer {
   // ── National Cancer Institute (cancer.gov) — the unit's own declarations, verbatim ──
 type cancerCenterDesignation =
@@ -5944,6 +7004,32 @@ interface DeckedCabSideOptionResult {
   }
 }
 
+declare namespace BowmarkProvider_developersopenai {
+  // ── OpenAI Developer Docs — the unit's own declarations, verbatim ──
+interface DevelopersOpenaiDocPage {
+  path: string;
+  title: string;
+  canonicalUrl: string;
+  body: string;
+}
+
+  /**
+   * OpenAI's own developer documentation site. getDocPage reads one docs page (title, canonical
+   * URL, full article text) by path — e.g. /api/docs/mcp for the remote MCP server / OAuth
+   * connector guide.
+   */
+  interface Unit {
+    /**
+     * Reads one page of OpenAI's developer docs and returns its title, canonical URL and full
+     * article text. Pass `path` (e.g. "/api/docs/mcp") to pick a page; omitting it defaults to
+     * "/api/docs/mcp" — the guide for building a remote MCP server, connecting it to ChatGPT/the
+     * API, and its OAuth-based auth section (see the "Handle authentication" and "Connect in
+     * ChatGPT" sections of the returned body).
+     */
+    getDocPage(args?: object): Promise<DevelopersOpenaiDocPage>;
+  }
+}
+
 declare namespace BowmarkProvider_dice {
   // ── Dice — the unit's own declarations, verbatim ──
 interface DiceJobDetails {
@@ -6510,6 +7596,44 @@ interface ebayItem {
   }
 }
 
+declare namespace BowmarkProvider_elevenlabs {
+  // ── ElevenLabs — the unit's own declarations, verbatim ──
+interface elevenlabsSynthesisResult {
+  audioBase64: string;
+  contentType: string;
+  voiceId: string;
+}
+interface elevenlabsVoice {
+  voiceId: string;
+  name: string;
+  requiresVerification: boolean;
+}
+
+  /**
+   * ElevenLabs' own documented REST API (api.elevenlabs.io) — converts text into spoken audio in
+   * an existing or newly-cloned voice, and clones a new voice from caller-supplied audio samples
+   * (Instant Voice Cloning). Requires an ElevenLabs API key.
+   */
+  interface Unit {
+    /**
+     * Converts `text` into spoken audio via ElevenLabs' documented Text to Speech API, returning
+     * it base64-encoded alongside the vendor's content type (MP3 by default). `voiceId` selects an
+     * existing or previously-cloned ElevenLabs voice (default "21m00Tcm4TlvDq8ikWAM", ElevenLabs'
+     * own "Rachel"); `modelId` selects the ElevenLabs model (default "eleven_multilingual_v2").
+     * Requires an ElevenLabs API key — see this provider's `auth`.
+     */
+    synthesize(args: { text: string; voiceId?: string; modelId?: string }): Promise<elevenlabsSynthesisResult>;
+
+    /**
+     * Creates a new ElevenLabs voice cloned from one or more caller-supplied audio sample URLs
+     * (Instant Voice Cloning) — downloads each sample and uploads it to ElevenLabs' `voices/add`.
+     * Returns the new voice's id, which `synthesize`'s `voiceId` then accepts. Requires an
+     * ElevenLabs API key — see this provider's `auth`.
+     */
+    cloneVoice(args: { name: string; sampleUrls: string[]; description?: string }): Promise<elevenlabsVoice>;
+  }
+}
+
 declare namespace BowmarkProvider_embroker {
   // ── Embroker — the unit's own declarations, verbatim ──
 interface EmbrokerCoverageCatalog {
@@ -7862,10 +8986,11 @@ interface fredObservations {
   seriesId: string;
   /** The transform FRED reports having applied: "lin" (none), "pc1", "pch", … */
   units: string;
-  observationStart: string;
-  observationEnd: string;
-  realtimeStart: string;
-  realtimeEnd: string;
+  observationStart: string | null;
+  observationEnd: string | null;
+  /** null: the public CSV has no vintage envelope. */
+  realtimeStart: string | null;
+  realtimeEnd: string | null;
   count: number;
   observations: fredObservation[];
 }
@@ -7917,10 +9042,10 @@ interface fredObservations {
      * `pch`, `chg`, `log` and the rest of FRED's ten codes), and `frequency` with
      * `aggregationMethod` collapses a series to a coarser period (`{ frequency: "a",
      * aggregationMethod: "avg" }` turns the monthly unemployment rate into annual averages). The
-     * result carries the transform FRED reports having applied and the vintage it served, so a
-     * caller can tell what they actually got. This is the function to call once
-     * `searchSeries`/`getSeriesInfo` has identified the right series id — e.g. A191RL1Q225SBEA for
-     * the US real GDP growth rate.
+     * result carries the applied transform and the served row bounds; its realtime fields are
+     * `null` because the keyless CSV publishes no vintage envelope. This is the function to call
+     * once `searchSeries`/`getSeriesInfo` has identified the right series id — e.g.
+     * A191RL1Q225SBEA for the US real GDP growth rate.
      */
     getSeriesObservations(args: string | { seriesId: string; from?: string; to?: string; units?: string; frequency?: string; aggregationMethod?: string }): Promise<fredObservations>;
 
@@ -8410,10 +9535,29 @@ interface GithubListCommitsResult {
   commits: GithubCommit[];
   warnings: string[];
 }
+interface GithubRelease {
+  tag: string;
+  name: string;
+  draft: boolean;
+  prerelease: boolean;
+  createdAt: string;
+  publishedAt: string | null;
+  notes: string;
+  url: string;
+}
+interface GithubListReleasesOptions {
+  per_page?: number;
+  page?: number;
+}
+interface GithubListReleasesResult {
+  releases: GithubRelease[];
+  warnings: string[];
+}
 
   /**
    * GitHub's own REST API, keyless. Built: a public repo's commit log (sha, author, date,
-   * message), paged and windowed. Declared, not yet built: repo metadata (getRepo).
+   * message), paged and windowed; a public repo's release history (tag, name, dates, release
+   * notes text), paged. Declared, not yet built: repo metadata (getRepo).
    */
   interface Unit {
     /**
@@ -8428,6 +9572,19 @@ interface GithubListCommitsResult {
      * throw.
      */
     listCommits(owner: string, repo: string, options?: GithubListCommitsOptions): Promise<GithubListCommitsResult>;
+
+    /**
+     * Returns a public repo's release history off GitHub's own unauthenticated REST releases
+     * endpoint — each release's tag, name, draft/prerelease flags, created/published dates, its
+     * release notes text (`notes`) and its own github.com URL. This is a project's own release
+     * notes documentation — `listReleases("microsoft", "TypeScript")` returns the TypeScript
+     * compiler's. `options.per_page` (GitHub's own 1-100 ceiling, default 30) and `options.page`
+     * page through history, newest first (GitHub's own ordering). Unauthenticated calls are capped
+     * at 60 requests/hour per IP, the same shared ceiling `listCommits` spends against. THROWS on
+     * an unknown owner/repo (404) or a rate limit (403/429); a repo with no releases yet returns
+     * `releases: []`, not a throw.
+     */
+    listReleases(owner: string, repo: string, options?: GithubListReleasesOptions): Promise<GithubListReleasesResult>;
   }
 }
 
@@ -8459,6 +9616,37 @@ interface GlassesusaProduct {
   }
 }
 
+declare namespace BowmarkProvider_goodway {
+  // ── Goodway Technologies — the unit's own declarations, verbatim ──
+interface GoodwayProductSummary {
+  sku: string;
+  title: string;
+  url: string;
+  price: string | null; // null = call for price / quote required
+}
+interface GoodwayProduct extends GoodwayProductSummary {
+  purchaseType: "buy" | "quote";
+}
+
+  /**
+   * Goodway's own pressure-washer catalog — real listed prices, or a quote-required flag for
+   * call-for-price units, and the site's own product page as the buy/quote handoff.
+   */
+  interface Unit {
+    /**
+     * Reads Goodway's pressure-washer catalog grid — every listed model, its SKU, its live price
+     * (or null if quote-required) and its product page.
+     */
+    searchProducts(): Promise<GoodwayProductSummary[]>;
+
+    /**
+     * Reads one product's detail page for its real current price and whether it buys online or
+     * needs a written quote.
+     */
+    getProduct(arg0: { slug: string }): Promise<GoodwayProduct>;
+  }
+}
+
 declare namespace BowmarkProvider_google_flights {
   // ── Google Flights — the unit's own declarations, verbatim ──
 interface GoogleFlightQuery {
@@ -10107,6 +11295,10 @@ interface HobieModelSummary {
   name: string;
   url: string;
 }
+interface HobieKayakModelList {
+  total_models: number;
+  models: HobieModelSummary[];
+}
 interface HobieModelColor {
   color: string;
   upc: string;
@@ -10157,6 +11349,12 @@ interface HobieLocalAvailability {
      */
     listModels(): Promise<HobieModelSummary[]>;
 
+    /**
+     * Returns Hobie's live kayak-model list plus total_models. To answer a count request, call it
+     * with run; do not infer or paraphrase the count from this description.
+     */
+    listKayakModels(): Promise<HobieKayakModelList>;
+
     /**
      * 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.
@@ -10388,6 +11586,23 @@ interface IbuypowerBenchmark {
   games: Record<string, IbuypowerGameFps>;   // keyed by the titles iBUYPOWER benchmarks
 }
 
+interface IbuypowerRecommendation {
+  source: "prebuilt" | "configurator";
+  slug: string;
+  name: string;
+  url: string;
+  price: string | null;
+  priceValue: number | null;
+  timeSpyOverall: number | null;   // null when the site has not benchmarked this pair
+  scorePerDollar: number | null;   // timeSpyOverall / priceValue — highest first
+  inStock: boolean;                // a configurator is always buildable to order
+}
+
+interface IbuypowerRecommendArgs {
+  budget_max: number;              // the hard ceiling; nothing over it is returned
+  use_case?: string;                // accepted, does not change the ranking — see recommendGamingPc's summary
+}
+
   /**
    * Gaming and workstation PCs from iBUYPOWER — the base configurators with their current
    * starting prices, every component option on one with its exact price difference, the RDY
@@ -10451,6 +11666,18 @@ interface IbuypowerBenchmark {
      * to the Time Spy score of a pair it does have.
      */
     getBenchmark(cpuBench: string, gpuBench: string): Promise<IbuypowerBenchmark | null>;
+
+    /**
+     * Recommends buildable PCs at or under budget_max, drawn from BOTH product lines — in-stock
+     * RDY prebuilts (their own listed Time Spy score) and base configurators at their stock
+     * loadout (priced from getSystem, benchmarked from getBenchmark for the cheapest ~5 affordable
+     * ones) — ranked by 3DMark Time Spy score per dollar, best first. `use_case` is accepted but
+     * does not change the ranking: iBUYPOWER publishes only one axis of measured performance, and
+     * every recommendation is already ranked on it. THROWS when nothing in stock or buildable fits
+     * the budget. `warnings` names any configurator that stopped resolving mid-call; it is empty
+     * on a healthy call.
+     */
+    recommendGamingPc(args: IbuypowerRecommendArgs): Promise<{ recommendations: IbuypowerRecommendation[]; warnings: string[] }>;
   }
 }
 
@@ -11635,6 +12862,42 @@ interface IsllcSearchCommunitiesResult {
   }
 }
 
+declare namespace BowmarkProvider_istanbulkart {
+  // ── İstanbulkart — the unit's own declarations, verbatim ──
+interface IstanbulkartCardFee {
+  cardTypeName: string; // the site's own Turkish label, e.g. "İstanbulkart"
+  feeTRY: number | null;
+  visaIssuanceFeeTRY: number | null;
+}
+interface IstanbulkartTouristPass {
+  days: number; // 1, 3, 5, 7 or 15 on the table measured 2026-08-29
+  priceTRY: number;
+}
+
+  /**
+   * Istanbul public transit: İstanbulkart card purchase/personalization fees and the İstanbul
+   * City Card tourist unlimited-ride pass tariffs, read from istanbulkart.istanbul's own
+   * price-and-limits data.
+   */
+  interface Unit {
+    /**
+     * Reads the current İstanbulkart fee table — the purchase price of every card variant
+     * (İstanbulkart, İstanbulkart Plus, the discounted/free variants, the limited-ride geç
+     * tickets, SMS QR) plus each variant's personalization/visa-issuance fee, in TRY, straight off
+     * istanbulkart.istanbul's own price-and-limits page.
+     */
+    getCardFees(): Promise<IstanbulkartCardFee[]>;
+
+    /**
+     * Reads the İstanbul City Card tariff table — the 1/3/5/7/15-day unlimited-ride visitor pass
+     * prices, in TRY, straight off istanbulkart.istanbul's own price-and-limits page. This is the
+     * tourist unlimited-pass answer: İstanbul City Card is the İstanbulkart variant sold
+     * specifically to visitors for unlimited transit over a fixed number of days.
+     */
+    getTouristPassFares(): Promise<IstanbulkartTouristPass[]>;
+  }
+}
+
 declare namespace BowmarkProvider_ivoryhomes {
   // ── Ivory Homes — the unit's own declarations, verbatim ──
 // Ivory Homes' OWN shapes — not a capability contract.
@@ -12300,6 +13563,15 @@ interface KompanSparePartsDocuments {
      * package" PDF URL.
      */
     getSparePartsDocuments(variantId: string, purchaseDate: string): Promise<KompanSparePartsDocuments>;
+
+    /**
+     * A single call keyed by `product_no` that reports whether a playground product has spare
+     * parts listed — the same search searchProduct() runs, reshaped to a one-argument object so a
+     * caller does not need to know the two-step (search, then fetch documents per variant)
+     * internal shape just to ask "does this product have spare parts". `found: false` is a real
+     * answer, not an error.
+     */
+    searchPlaygroundSpareParts(args: { product_no: string; region?: KompanRegion }): Promise<KompanSearchResult>;
   }
 }
 
@@ -12887,6 +14159,42 @@ interface LiquiddeathLiveCart {
   }
 }
 
+declare namespace BowmarkProvider_liquidspace {
+  // ── LiquidSpace — the unit's own declarations, verbatim ──
+interface LiquidspaceWorkspaceRow {
+  venueName: string;
+  venueAddress: string;
+  workspaceName: string;   // e.g. "Coworking Daypass"
+  scenario: string | null; // LiquidSpace's own category label, e.g. "Coworking"
+  capacity: number | null;
+  priceAmount: string;         // e.g. "$45"
+  priceAmountValue: number;
+  priceDescription: string;    // "/day-pass" for every row this function returns
+  bookingUrl: string;          // this workspace's own LiquidSpace page
+  latitude: number;
+  longitude: number;
+  averageRating: number | null;
+  ratesCount: number | null;
+}
+
+  /**
+   * LiquidSpace's own city-listing pages — day-pass coworking pricing and availability across
+   * WeWork, Industrious, Regus/Spaces and independent operators in one place, read directly from
+   * the site's own embedded listing data, no browser.
+   */
+  interface Unit {
+    /**
+     * Reads LiquidSpace's own city-listing page for `state` (a US state abbreviation, e.g. "NY")
+     * and `city` (e.g. "New York") and returns every workspace priced as a single-day coworking
+     * pass — venue name/address, the workspace's own display name and category, price, capacity,
+     * coordinates and rating, plus a direct link to book it (booking itself needs a signed-in
+     * LiquidSpace account and is out of scope). Returns `[]` when the city page carries no
+     * day-pass inventory today — a real, complete answer, not a failure.
+     */
+    search(input: { city: string; state: string }): Promise<LiquidspaceWorkspaceRow[]>;
+  }
+}
+
 declare namespace BowmarkProvider_littlewordsproject {
   // ── Little Words Project — the unit's own declarations, verbatim ──
 interface LittleWordsProjectOption {
@@ -13649,6 +14957,37 @@ interface mailchimpPlanPricing {
   }
 }
 
+declare namespace BowmarkProvider_marketplace_visualstudio {
+  // ── Visual Studio Code Marketplace — the unit's own declarations, verbatim ──
+interface marketplaceExtensionStats {
+  extensionId: string;
+  displayName: string;
+  publisherDisplayName: string;
+  shortDescription: string;
+  version: string;
+  lastUpdated: string;
+  installCount: number;
+  averageRating: number | null;
+  ratingCount: number;
+}
+
+  /**
+   * The VS Code Marketplace — look up one extension by its publisher.name id and get its install
+   * count, rating and latest version, the numbers the extension's own Marketplace page shows.
+   */
+  interface Unit {
+    /**
+     * Looks up one VS Code extension by its "publisher.name" id — the id shown in the extension's
+     * own Marketplace URL (e.g. "ms-python.python" for
+     * marketplace.visualstudio.com/items?itemName=ms-python.python) and in `code
+     * --list-extensions` — and returns its install count, average rating, rating count, latest
+     * published version and when that version last updated. Throws if the id does not match any
+     * published extension.
+     */
+    getExtensionStats(extensionId: string): Promise<marketplaceExtensionStats>;
+  }
+}
+
 declare namespace BowmarkProvider_marriott {
   // ── Marriott — the unit's own declarations, verbatim ──
 interface MarriottHotelListing {
@@ -13801,6 +15140,39 @@ interface mcdonaldsFindStoresResult {
   }
 }
 
+declare namespace BowmarkProvider_mcp_registry {
+  // ── MCP Registry — the unit's own declarations, verbatim ──
+interface mcpRegistryEntry {
+  name: string;
+  title: string | null;
+  description: string;
+  version: string;
+  repositoryUrl: string | null;
+  remoteUrl: string | null;
+  status: string;
+}
+
+  /**
+   * The official Model Context Protocol server registry — search or browse published MCP servers
+   * by name, and get each one's install/connect URL.
+   */
+  interface Unit {
+    /**
+     * Lists or searches the official MCP server registry (registry.modelcontextprotocol.io) — the
+     * community-run directory of published Model Context Protocol servers, the same catalogue the
+     * registry's own web UI browses. `query` substring-matches the registry NAME (e.g. "weather"
+     * matches `ai.smithery/smithery-ai-national-weather-service`); omit it to list the
+     * newest-published entries. Each row carries the registry name, an optional title, its
+     * description, its latest published version, where to install it (`repositoryUrl`) or connect
+     * to it if it's hosted (`remoteUrl`), and the registry's own status (`"active"`,
+     * `"deprecated"`, …). `limit` caps how many rows come back (default 30, registry maximum 100)
+     * — this is a flat list, not a paged walk, since a caller asking "is there an MCP server for
+     * X" wants the top matches, not the whole registry.
+     */
+    search(query?: string, limit?: number): Promise<mcpRegistryEntry[]>;
+  }
+}
+
 declare namespace BowmarkProvider_medicalguardian {
   // ── Medical Guardian — the unit's own declarations, verbatim ──
 // Medical Guardian's OWN shapes — not a capability contract.
@@ -14576,6 +15948,57 @@ interface medicareGetPlanQuery {
   }
 }
 
+declare namespace BowmarkProvider_mergify {
+  // ── Mergify — the unit's own declarations, verbatim ──
+interface mergifyBatch {
+  id: string;
+  name: string;
+  statusCode: string;
+  batchFilledSlots: number | null;
+  maxBatchSlots: number | null;
+  retries: number;
+  maxRetries: number;
+  startedAt: string | null;
+  estimatedMergeAt: string | null;
+  estimatedCiFinishAt: string | null;
+  ciFinishedAt: string | null;
+  queueRuleName: string;
+  checksPassed: number;
+  checksTotal: number;
+  pullRequestNumbers: number[];
+}
+interface mergifyQueuedPull {
+  number: number;
+  title: string;
+  url: string;
+  author: string | null;
+  queuedAt: string;
+  priorityRuleName: string | null;
+  estimatedMergeAt: string | null;
+}
+interface mergifyQueueStatus {
+  batches: mergifyBatch[];
+  waitingPullRequests: mergifyQueuedPull[];
+  paused: boolean;
+  pauseReason: string | null;
+}
+
+  /**
+   * Mergify's own documented REST API (api.mergify.com) — the live state of a repo's merge
+   * queue: active batches, their checks and estimated merge times, and every pull request still
+   * waiting to be batched.
+   */
+  interface Unit {
+    /**
+     * The live state of a repo's Mergify merge queue via Mergify's documented REST API — every
+     * active batch (status, checks-passed count, estimated merge/CI-finish times, and its pull
+     * requests), every pull request still waiting to be batched, and whether the queue is paused.
+     * Requires a Mergify Application Key or a GitHub token — see this provider's `auth`.
+     */
+    queueStatus(args: { owner: string; repo: string }): Promise<mergifyQueueStatus>;
+  }
+}
+
 declare namespace BowmarkProvider_microcenter {
   // ── Micro Center — the unit's own declarations, verbatim ──
 // Micro Center's OWN row shape — not the `pcparts` capability contract.
@@ -14692,6 +16115,37 @@ interface StoreShelfRoster {
   }
 }
 
+declare namespace BowmarkProvider_minimax {
+  // ── MiniMax — the unit's own declarations, verbatim ──
+interface MinimaxDocIndexEntry {
+  title: string;
+  url: string;
+  description: string | null;
+}
+
+interface MinimaxDocPage {
+  title: string;
+  url: string;
+  description: string | null;
+  content: string;
+}
+
+  /**
+   * MiniMax's own developer docs (platform.minimax.io) — resolves a topic against the site's own
+   * machine-readable docs index and returns that page's title, url and full Markdown body.
+   */
+  interface Unit {
+    /**
+     * Reads MiniMax's own developer documentation (platform.minimax.io). topic is a free-text
+     * description of what you want, e.g. "text generation", "voice clone", "mcp guide" or "prompt
+     * caching" — it is matched against the site's own docs index (title and url), and the matched
+     * page's full Markdown body is returned. Throws naming real page titles when nothing matches
+     * closely enough.
+     */
+    getDocs(topic: string): Promise<MinimaxDocPage>;
+  }
+}
+
 declare namespace BowmarkProvider_minted {
   // ── Minted — the unit's own declarations, verbatim ──
 // Minted's OWN shapes — not a capability contract.
@@ -15109,6 +16563,46 @@ interface MossyoakCheckoutLink {
      * available — the error names the candidate or in-stock options so the caller can retry.
      */
     getMossyoakCheckoutLink(handle: string, variantTitleOrOptions: string, opts?: { quantity?: number }): Promise<MossyoakCheckoutLink>;
+
+    /**
+     * Reads the same live catalogue listMossyoakProducts does and filters it by product type
+     * ("vest", "jacket", …, matched case-insensitively against each product's own productType)
+     * before applying the limit — so a caller asking for one category does not have to fetch and
+     * filter the whole storefront themselves. In-stock products first, then by handle. `warnings`
+     * names it when the requested productType matched nothing.
+     */
+    searchProducts(opts?: { productType?: string; limit?: number }): Promise<MossyoakCatalogue>;
+  }
+}
+
+declare namespace BowmarkProvider_muze_gov_tr {
+  // ── muze.gov.tr — Turkey Ministry of Culture and Tourism museums portal — the unit's own declarations, verbatim ──
+interface MuzeVisitingHours {
+  name: string;
+  openingTime: string | null;          // "HH:MM"
+  closingTime: string | null;          // "HH:MM"
+  ticketOfficeClosingTime: string | null; // "HH:MM" — often earlier than closingTime
+  closedDays: string | null;           // the site's own Turkish wording, e.g. "Her gün açık"
+  address: string | null;
+  phone: string | null;
+  email: string | null;
+  url: string;
+}
+
+  /**
+   * Turkey's Ministry of Culture and Tourism museums portal — opening/closing hours,
+   * ticket-office closing time and closed days for the museums and archaeological sites it
+   * publishes (İstanbul Archaeological Museums, Hagia Sophia History and Experience Museum,
+   * Galata Tower Museum among them), read straight off the site's own listing and detail pages.
+   */
+  interface Unit {
+    /**
+     * Matches `query` against muze.gov.tr's own museum-highlight listing (a substring match on the
+     * site's own display name, e.g. "Galata Tower" or "Hagia Sophia") and reads that museum's
+     * opening/closing hours, ticket-office closing time and closed days straight off its detail
+     * page.
+     */
+    getVisitingHours(query: string): Promise<MuzeVisitingHours>;
   }
 }
 
@@ -15628,6 +17122,14 @@ interface NvisioncentersSavingsResult {
   calculatorUrl: string;
 }
 
+interface NvisioncentersEstimateSavingsInput {
+  age: number;
+  glasses: number;
+  glasses_cost: number;
+  contacts: number;
+  contacts_cost: number;
+}
+
 type NvisioncentersAgeBracket = "Under 18" | "18-34" | "35-54" | "55+";
 
 interface NvisioncentersCandidacyInput {
@@ -15664,6 +17166,13 @@ interface NvisioncentersCandidacyResult {
      * and prior-consultation history but its logic never uses either).
      */
     checkLasikCandidacy(input: NvisioncentersCandidacyInput): Promise<NvisioncentersCandidacyResult>;
+
+    /**
+     * Same calculation as calculateLasikSavings, taking the snake_case argument spelling
+     * (glasses_cost, contacts_cost) a caller guessed instead of the provider's camelCase — an
+     * alias, not a second calculator. Throws under the same condition calculateLasikSavings does.
+     */
+    estimateLasikSavings(input: NvisioncentersEstimateSavingsInput): Promise<NvisioncentersSavingsResult>;
   }
 }
 
@@ -16523,6 +18032,35 @@ interface PizzahutDealsForRender {
   }
 }
 
+declare namespace BowmarkProvider_poshmark {
+  // ── Poshmark — the unit's own declarations, verbatim ──
+interface PoshmarkSupportArticle {
+  url: string;
+  text: string;
+}
+
+  /**
+   * Poshmark's own support-center documentation (support.poshmark.com) for Bulk Upload — the
+   * CSV/template format and the zip-of-photos requirements for sellers listing many items at
+   * once.
+   */
+  interface Unit {
+    /**
+     * Reads Poshmark's own 'How to use Bulk Upload Templates' support article — required columns,
+     * SKU rules, the .csv file requirement, Excel-version caveats — straight off
+     * support.poshmark.com.
+     */
+    getBulkUploadTemplateGuide(): Promise<PoshmarkSupportArticle>;
+
+    /**
+     * Reads Poshmark's own 'How to create a Zip file for Bulk Upload' support article — how to zip
+     * listing photos on Windows/Mac and which image types Bulk Upload accepts — straight off
+     * support.poshmark.com.
+     */
+    getZipFileGuide(): Promise<PoshmarkSupportArticle>;
+  }
+}
+
 declare namespace BowmarkProvider_positivegrid {
   // ── Positive Grid — the unit's own declarations, verbatim ──
 interface positivegridFindRetailersArgs {
@@ -17356,6 +18894,45 @@ interface ContainerRecipeDetails {
   }
 }
 
+declare namespace BowmarkProvider_proxmox {
+  // ── Proxmox — the unit's own declarations, verbatim ──
+type ProxmoxProductSlug =
+  | "proxmox-virtual-environment"
+  | "proxmox-backup-server"
+  | "proxmox-mail-gateway"
+  | "proxmox-datacenter-manager";
+
+interface ProxmoxIsoDownload {
+  product: ProxmoxProductSlug;
+  productName: string;
+  title: string;
+  version: string;
+  fileSizeText: string;
+  lastUpdated: string;
+  sha256: string | null;
+  downloadUrl: string;
+  torrentUrl: string | null;
+  pageUrl: string;
+}
+
+  /**
+   * Open-source virtualization/backup/mail-security vendor. getIsoDownloads is live — the
+   * current ISO installer(s) for any or all of Proxmox VE, Proxmox Backup Server, Proxmox Mail
+   * Gateway and Proxmox Datacenter Manager, straight off proxmox.com's own downloads pages:
+   * version, file size, last-updated date, SHA256 checksum, and the real enterprise.proxmox.com
+   * download/torrent URLs.
+   */
+  interface Unit {
+    /**
+     * Gets the current ISO installer download(s) for one Proxmox product, or for all four when
+     * `product` is omitted. Proxmox VE's own downloads page additionally lists its current arm64
+     * build and three prior major versions (8.4-1, 7.4-1, 6.4-1) alongside the current amd64
+     * release — every card the site publishes comes back, not just the newest one.
+     */
+    getIsoDownloads(product?: "proxmox-virtual-environment" | "proxmox-backup-server" | "proxmox-mail-gateway" | "proxmox-datacenter-manager"): Promise<ProxmoxIsoDownload[]>;
+  }
+}
+
 declare namespace BowmarkProvider_reddit {
   // ── Reddit — the unit's own declarations, verbatim ──
 interface RedditSearchPost {
@@ -18884,6 +20461,43 @@ interface SitmeanssitNearestLocationsResult {
   }
 }
 
+declare namespace BowmarkProvider_sixflags {
+  // ── Six Flags — the unit's own declarations, verbatim ──
+interface SixFlagsPassRow {
+  id: string | null;
+  guestFacingTitle: string;   // e.g. "Park Ticket", "2027 Gold Pass"
+  subtitle: string | null;
+  beforePriceText: string | null;   // e.g. "Starting From", "Only"
+  currentPrice: string;             // the site's raw text, e.g. "$$55"
+  currentPriceModifier: string | null;   // e.g. "/ea*", "per night"
+  strikethroughPrice: string | null;     // the struck-through "was" price
+  buyUrl: string | null;
+}
+interface SixFlagsTicketsResult {
+  parkSlug: string;
+  parkTitle: string;
+  groupLabel: string;         // e.g. "Daily Tickets"
+  passes: SixFlagsPassRow[];
+}
+
+  /**
+   * Reads a Six Flags/Cedar Fair park's own daily-tickets page — every park in the merged
+   * portfolio (Six Flags Magic Mountain, Cedar Point, Kings Island, Knott's Berry Farm,
+   * Carowinds and ~30 more) runs on one shared site — and returns its current ticket/pass cards
+   * straight out of the page's own server-rendered data, no browser.
+   */
+  interface Unit {
+    /**
+     * Reads a Six Flags/Cedar Fair park's own daily-tickets page by its sixflags.com URL slug
+     * (e.g. `"cedarpoint"`, `"greatadventure"`, `"magicmountain"`, `"knotts"`) and returns its
+     * ticket/pass cards exactly as published today — title, subtitle, raw price text (the site
+     * renders it as `"$$55"`, i.e. `"$" + "$55"`), any "was" price, and a buy/learn-more link.
+     * Throws if the slug does not resolve to a real park page on the site.
+     */
+    getTickets(park: string): Promise<SixFlagsTicketsResult>;
+  }
+}
+
 declare namespace BowmarkProvider_smartsign {
   // ── SmartSign — the unit's own declarations, verbatim ──
 interface SmartsignSearchResult {
@@ -18960,6 +20574,60 @@ interface SmartwoolSockFinderResult {
   }
 }
 
+declare namespace BowmarkProvider_smithery {
+  // ── Smithery — the unit's own declarations, verbatim ──
+interface SmitheryServer {
+  id: string;
+  qualifiedName: string;
+  namespace: string | null;
+  slug: string | null;
+  displayName: string;
+  description: string;
+  iconUrl: string | null;
+  verified: boolean;
+  useCount: number;
+  remote: boolean | null;
+  isDeployed: boolean;
+  createdAt: string;
+  homepage: string;
+  bySmithery: boolean;
+  owner: string | null;
+  score: number | null;
+}
+interface SmitherySearchOptions {
+  page?: number;
+  pageSize?: number;
+  verified?: boolean;
+  remote?: boolean;
+  isDeployed?: boolean;
+  namespace?: string;
+}
+interface SmitherySearchResult {
+  servers: SmitheryServer[];
+  pagination: { currentPage: number; pageSize: number; totalPages: number; totalCount: number };
+  warnings: string[];
+}
+
+  /**
+   * Smithery's own registry REST API, keyless. Built: full-text/semantic search over listed MCP
+   * servers, returning each server's qualified name, description, verification status, deploy
+   * status and use count.
+   */
+  interface Unit {
+    /**
+     * Full-text/semantic search over Smithery's public MCP server registry. Pass a qualified name
+     * (e.g. "lama/demo-mcp"), a slug, or a keyword as `query` — a known qualified name resolves as
+     * the top hit. Each returned server carries `verified` (Smithery's own verification badge),
+     * `isDeployed`, `useCount`, `homepage` and `description`.
+     * `options.verified`/`options.remote`/`options.isDeployed`/`options.namespace` filter the
+     * search; `options.page`/`options.pageSize` page through results (Smithery's own default 10,
+     * max 100 per page). THROWS on a non-2xx response (e.g. rate limiting); an empty `servers`
+     * array is a legitimate answer for a query that matches nothing, not a throw.
+     */
+    search(query: string, options?: SmitherySearchOptions): Promise<SmitherySearchResult>;
+  }
+}
+
 declare namespace BowmarkProvider_solostove {
   // ── Solo Stove — the unit's own declarations, verbatim ──
 interface SolostoveBundleComponent {
@@ -19780,13 +21448,13 @@ interface tamarackidahoUnit {
     /**
      * Searches Tamarack Resort's own direct-managed lodging (the Lodge at Osprey Meadows, the
      * Village at Tamarack Resort, and Tamarack Homes and Cottages — not the golf tee-time flow, a
-     * different vendor) for a stay and party size. `arrivalDate`/`departureDate` are "MM/DD/YYYY"
-     * strings (the widget's own format), `adultCount` is required and positive, `childCount`
-     * defaults to 0. Returns every unit type Tamarack's own booking engine (Inntopia RTP)
-     * currently prices as AVAILABLE for that exact query — each with its supplier (property), unit
-     * name, and `totalPrice` in USD for the whole queried stay (not nightly) — genuinely computed
-     * per call, not a cached listing. An empty `units` array is a real answer: Tamarack has
-     * nothing available for that stay, not a failure.
+     * different vendor) for a stay and party size. `arrivalDate`/`departureDate` are "YYYY-MM-DD"
+     * strings (the site's own "MM/DD/YYYY" is accepted as well and echoed back unchanged),
+     * `adultCount` is required and positive, `childCount` defaults to 0. Returns every unit type
+     * Tamarack's own booking engine (Inntopia RTP) currently prices as AVAILABLE for that exact
+     * query — each with its supplier (property), unit name, and `totalPrice` in USD for the whole
+     * queried stay (not nightly) — genuinely computed per call, not a cached listing. An empty
+     * `units` array is a real answer: Tamarack has nothing available for that stay, not a failure.
      */
     searchLodging(args: tamarackidahoSearchArgs): Promise<tamarackidahoSearchResult>;
   }
@@ -20478,6 +22146,9 @@ interface thezebraAutoDriver {
   lastName: string
   dob: string     // ISO YYYY-MM-DD — carriers rate on the DATE, not on an age
   email: string
+  ageFirstLicensed?: number  // default 16 when omitted
+  violations?: { accidents: number, claims: number, tickets: number }  // default a clean record
+  occupation?: string  // default "OTHER" — the only two confirmed-valid values are "OTHER" and "ENGINEER"
 }
 
 interface thezebraAutoVehicle {
@@ -20693,26 +22364,30 @@ interface thezebraAutoQuotes {
      * carrier's own monthly and six-month premium, deductible, and the coverage it priced, as The
      * Zebra's auto quote funnel prices them. This is a priced offer for the person asking, NOT the
      * published averages `getStateRates` and its siblings return. Pass `driver` (`firstName`,
-     * `lastName`, `dob` ISO YYYY-MM-DD, `email`), one `vehicle` (`year`, `make`, `model` — a model
-     * The Zebra does not rate THROWS naming the URL it tried), the 2-letter `state`, a 5-digit
-     * `zip`, and `county` (the county the ZIP sits in — The Zebra validates it server-side and a
-     * missing or wrong county is bounced). **The write binds, the read does not — yet**: the
-     * GraphQL gateway at `graphql-gateway.production.thezebra.com` accepts the auto seed
-     * (`LegacyStartInput.start.currentlyInsured` is the only field Apollo currently exposes on
-     * that input), but the results route STILL bounces the session to the homepage with the four
-     * fields this function sends. The function throws on the bounce with a message naming the gap;
-     * the second required field on `LegacyStartInput` is the next attempt's work, and the rejected
-     * probes — `helpToday`, `userPurchaseTimeframe`, `hadActiveInsurance`, `residenceOwnership`,
-     * `presumedAnswers`, `policyLinkInfo`, `startDate`, `desiredCoverage` — are documented in
-     * `agents/capability-engineer/instances/vertical-insurance/tools/zebra-auto-quotes/shape-summary.json`
-     * (and the e5 clone) so they don't have to be re-derived. **`advertisedCarriers` is not a
-     * quote list and must never be read as one**: the results page would carry paid carrier
-     * placements alongside real offers, separated by `data-cy="results-card_ad_<carrier>"` (ad)
-     * versus `data-cy="results-card_q2b_<carrier>"` (real offer), and the advertised names are
-     * returned in their own field with no price attached. Every premium is USD and
-     * `monthlyPremium` is per MONTH — the card's own period is checked rather than assumed, and a
-     * card printing any other term THROWS instead of relabelling a figure. `totalPremium` is the
-     * site's own whole-term number and is never divided out of the monthly one.
+     * `lastName`, `dob` ISO YYYY-MM-DD, `email`, and optionally
+     * `ageFirstLicensed`/`violations`/`occupation` — each defaults to a clean-record placeholder
+     * when omitted), one `vehicle` (`year`, `make`, `model` — a model The Zebra does not rate
+     * THROWS naming the URL it tried), the 2-letter `state`, a 5-digit `zip`, and `county` (the
+     * county the ZIP sits in — The Zebra validates it server-side and a missing or wrong county is
+     * bounced). **The write always binds** — the GraphQL gateway at
+     * `graphql-gateway.production.thezebra.com` accepts the seed and returns 200 — but AS OF
+     * 2026-08-27 the results route was bouncing the session to the homepage because
+     * `LegacyDriverInput` and `LegacyVehicleInput` accept more fields than an earlier version of
+     * this function sent; the measured field map (every field on both inputs, which are confirmed
+     * valid, which are still unmeasured) lives in
+     * `agents/richard/problems/thezebra-getautoquotes-broken.md` and is not re-derived here. The
+     * function throws on a bounce with a message naming the redirect target; `vehicle.submodel`,
+     * `driver.education` and `driver.creditScore` remain unsent because no valid value for any of
+     * them is confirmed yet — sending a guess cannot break the write (all three are nullable) but
+     * a wrong guess would look like a fix without being one, so they stay out until a live probe
+     * confirms a value. **`advertisedCarriers` is not a quote list and must never be read as
+     * one**: the results page would carry paid carrier placements alongside real offers, separated
+     * by `data-cy="results-card_ad_<carrier>"` (ad) versus `data-cy="results-card_q2b_<carrier>"`
+     * (real offer), and the advertised names are returned in their own field with no price
+     * attached. Every premium is USD and `monthlyPremium` is per MONTH — the card's own period is
+     * checked rather than assumed, and a card printing any other term THROWS instead of
+     * relabelling a figure. `totalPremium` is the site's own whole-term number and is never
+     * divided out of the monthly one.
      */
     getAutoQuotes(query: thezebraAutoQuotesQuery): Promise<thezebraAutoQuotes>;
   }
@@ -21308,25 +22983,28 @@ interface upsRatedShipment {
 declare namespace BowmarkProvider_usps {
   // ── USPS — the unit's own declarations, verbatim ──
 interface uspsRateOption {
-  sku: string;
+  postageServiceId: number;
   description: string;
-  mailClass: string;
   price: number;
-  zone: string | null;
+  commercialPrice: number | null;
+  deliveryDay: string | null;
+  flatRateBox: string | null;
 }
 
   /**
-   * USPS's own documented Domestic Prices v3 API (apis.usps.com) — prices a domestic package
-   * across USPS's Mail Classes for a ZIP-to-ZIP move, weight and optional dimensions, the same
-   * base-rate calculation usps.com's own postage calculator runs. No browser, no scraping.
+   * USPS's own Retail Postage Price Calculator (postcalc.usps.com) — prices a domestic package
+   * across every USPS Mail Service that quotes it for a ZIP-to-ZIP move, weight and optional
+   * dimensions, and returns the counter price, the discounted Click-N-Ship price and USPS's own
+   * delivery-commitment date. One keyless GET to the calculator's own JSON endpoint. No key, no
+   * browser.
    */
   interface Unit {
     /**
-     * Prices a domestic package across every USPS Mail Class that quotes it, between two 5-digit
+     * Prices a domestic package across every USPS Mail Service that quotes it, between two 5-digit
      * ZIP Codes, for a weight in ounces and optional length/width/height in inches (all three or
-     * none). Returns USPS's own base retail price per option — the postage calculator's own
-     * numbers, not an estimate. Requires a USPS OAuth2 client-credentials token — see this
-     * provider's `auth`.
+     * none). Returns USPS's own retail counter price, its discounted Click-N-Ship price where one
+     * exists, and its delivery-commitment date — the Retail Postage Price Calculator's own
+     * numbers. Needs no API key.
      */
     getRate(args: { fromZip: string; toZip: string; weightOz: number; length?: number; width?: number; height?: number }): Promise<uspsRateOption[]>;
   }
@@ -21544,20 +23222,21 @@ interface VillagerealtyobxQuote {
      * Searches Village Realty's own 900+ Outer Banks rental listings the way
      * villagerealtyobx.com/outer-banks-vacation-rentals does — filter by town (e.g. "Corolla",
      * "Nags Head"), exact bedroom count, amenities (e.g. "Private Pool", "Elevator"), and
-     * optionally a date range — returning each matching property's id, name, town, address,
-     * bedroom count, max guests and detail-page URL. Call getQuote with a result's propertyID for
-     * a real priced quote.
+     * optionally a date range (`checkin`/`checkout` as `YYYY-MM-DD`) — returning each matching
+     * property's id, name, town, address, bedroom count, max guests and detail-page URL. Call
+     * getQuote with a result's propertyID for a real priced quote.
      */
     searchRentals(args?: { town?: string, bedrooms?: number, amenities?: string[], checkin?: string, checkout?: string, page?: number }): Promise<VillagerealtyobxListing[]>;
 
     /**
      * Gets a real-time price quote for one Village Realty property and date range — the exact
      * server-computed rent, taxes and total the rental detail page shows after picking dates, plus
-     * the book-now URL. `checkin`/`checkout` are `MM/DD/YYYY`. `available: false` is a genuine
-     * site answer (e.g. the dates fail the property's minimum-night-stay rule), not an error —
-     * this is the flow ChatGPT itself cannot operate today: asked to price a Village Realty stay
-     * it answers "I can't complete the booking or take payment for you" and recommends competitor
-     * sites instead of quoting Village Realty's own live price.
+     * the book-now URL. `checkin`/`checkout` are `YYYY-MM-DD` (the site's own `MM/DD/YYYY` is
+     * accepted too, and whichever you pass is echoed back unchanged). `available: false` is a
+     * genuine site answer (e.g. the dates fail the property's minimum-night-stay rule), not an
+     * error — this is the flow ChatGPT itself cannot operate today: asked to price a Village
+     * Realty stay it answers "I can't complete the booking or take payment for you" and recommends
+     * competitor sites instead of quoting Village Realty's own live price.
      */
     getQuote(args: { propertyID: string, checkin: string, checkout: string }): Promise<VillagerealtyobxQuote>;
   }
@@ -23250,9 +24929,12 @@ interface ShopifyCart {
  * string, so there is no camelCase alias to be uncertain about. */
 interface BowmarkProviders {
   aa: BowmarkProvider_aa.Unit;
+  aauto: BowmarkProvider_aauto.Unit;
   abercrombie: BowmarkProvider_abercrombie.Unit;
   aiper: BowmarkProvider_aiper.Unit;
   ajmadison: BowmarkProvider_ajmadison.Unit;
+  allied: BowmarkProvider_allied.Unit;
+  alphavantage: BowmarkProvider_alphavantage.Unit;
   americanstandard: BowmarkProvider_americanstandard.Unit;
   amramp: BowmarkProvider_amramp.Unit;
   ancientnutrition: BowmarkProvider_ancientnutrition.Unit;
@@ -23270,7 +24952,9 @@ interface BowmarkProviders {
   azure: BowmarkProvider_azure.Unit;
   barletta: BowmarkProvider_barletta.Unit;
   baublebar: BowmarkProvider_baublebar.Unit;
+  bcparkscamping: BowmarkProvider_bcparkscamping.Unit;
   beatthebomb: BowmarkProvider_beatthebomb.Unit;
+  bennington: BowmarkProvider_bennington.Unit;
   bestbuy: BowmarkProvider_bestbuy.Unit;
   bhphoto: BowmarkProvider_bhphoto.Unit;
   bigjoeforklifts: BowmarkProvider_bigjoeforklifts.Unit;
@@ -23288,6 +24972,7 @@ interface BowmarkProviders {
   bykoket: BowmarkProvider_bykoket.Unit;
   byltbasics: BowmarkProvider_byltbasics.Unit;
   califloors: BowmarkProvider_califloors.Unit;
+  camelcamelcamel: BowmarkProvider_camelcamelcamel.Unit;
   cancer: BowmarkProvider_cancer.Unit;
   capitalbrands: BowmarkProvider_capitalbrands.Unit;
   caraway: BowmarkProvider_caraway.Unit;
@@ -23310,12 +24995,14 @@ interface BowmarkProviders {
   davidsonhomes: BowmarkProvider_davidsonhomes.Unit;
   deangroup: BowmarkProvider_deangroup.Unit;
   decked: BowmarkProvider_decked.Unit;
+  developersopenai: BowmarkProvider_developersopenai.Unit;
   dice: BowmarkProvider_dice.Unit;
   dickssportinggoods: BowmarkProvider_dickssportinggoods.Unit;
   dillards: BowmarkProvider_dillards.Unit;
   discounttire: BowmarkProvider_discounttire.Unit;
   disney: BowmarkProvider_disney.Unit;
   ebay: BowmarkProvider_ebay.Unit;
+  elevenlabs: BowmarkProvider_elevenlabs.Unit;
   embroker: BowmarkProvider_embroker.Unit;
   eq3: BowmarkProvider_eq3.Unit;
   erieinsurance: BowmarkProvider_erieinsurance.Unit;
@@ -23337,6 +25024,7 @@ interface BowmarkProviders {
   geico: BowmarkProvider_geico.Unit;
   github: BowmarkProvider_github.Unit;
   glassesusa: BowmarkProvider_glassesusa.Unit;
+  goodway: BowmarkProvider_goodway.Unit;
   google_flights: BowmarkProvider_google_flights.Unit;
   gotchacovered: BowmarkProvider_gotchacovered.Unit;
   grainger: BowmarkProvider_grainger.Unit;
@@ -23363,6 +25051,7 @@ interface BowmarkProviders {
   interiordefine: BowmarkProvider_interiordefine.Unit;
   iproyal: BowmarkProvider_iproyal.Unit;
   islllc: BowmarkProvider_islllc.Unit;
+  istanbulkart: BowmarkProvider_istanbulkart.Unit;
   ivoryhomes: BowmarkProvider_ivoryhomes.Unit;
   jennikayne: BowmarkProvider_jennikayne.Unit;
   joybird: BowmarkProvider_joybird.Unit;
@@ -23380,6 +25069,7 @@ interface BowmarkProviders {
   legacyhomesal: BowmarkProvider_legacyhomesal.Unit;
   linkedin: BowmarkProvider_linkedin.Unit;
   liquiddeath: BowmarkProvider_liquiddeath.Unit;
+  liquidspace: BowmarkProvider_liquidspace.Unit;
   littlewordsproject: BowmarkProvider_littlewordsproject.Unit;
   lonelyplanet: BowmarkProvider_lonelyplanet.Unit;
   louvershop: BowmarkProvider_louvershop.Unit;
@@ -23388,16 +25078,21 @@ interface BowmarkProviders {
   lululemon: BowmarkProvider_lululemon.Unit;
   maidenhome: BowmarkProvider_maidenhome.Unit;
   mailchimp: BowmarkProvider_mailchimp.Unit;
+  marketplace_visualstudio: BowmarkProvider_marketplace_visualstudio.Unit;
   marriott: BowmarkProvider_marriott.Unit;
   mcdonalds: BowmarkProvider_mcdonalds.Unit;
+  mcp_registry: BowmarkProvider_mcp_registry.Unit;
   medicalguardian: BowmarkProvider_medicalguardian.Unit;
   medicare: BowmarkProvider_medicare.Unit;
+  mergify: BowmarkProvider_mergify.Unit;
   microcenter: BowmarkProvider_microcenter.Unit;
+  minimax: BowmarkProvider_minimax.Unit;
   minted: BowmarkProvider_minted.Unit;
   mixbook: BowmarkProvider_mixbook.Unit;
   modularclosets: BowmarkProvider_modularclosets.Unit;
   momondo: BowmarkProvider_momondo.Unit;
   mossyoak: BowmarkProvider_mossyoak.Unit;
+  muze_gov_tr: BowmarkProvider_muze_gov_tr.Unit;
   naic: BowmarkProvider_naic.Unit;
   namecheap: BowmarkProvider_namecheap.Unit;
   nationalbusinessfurniture: BowmarkProvider_nationalbusinessfurniture.Unit;
@@ -23414,11 +25109,13 @@ interface BowmarkProviders {
   perennialsandsutherland: BowmarkProvider_perennialsandsutherland.Unit;
   pirateship: BowmarkProvider_pirateship.Unit;
   pizzahut: BowmarkProvider_pizzahut.Unit;
+  poshmark: BowmarkProvider_poshmark.Unit;
   positivegrid: BowmarkProvider_positivegrid.Unit;
   premierbuildings: BowmarkProvider_premierbuildings.Unit;
   progressive: BowmarkProvider_progressive.Unit;
   prose: BowmarkProvider_prose.Unit;
   provenwinners: BowmarkProvider_provenwinners.Unit;
+  proxmox: BowmarkProvider_proxmox.Unit;
   reddit: BowmarkProvider_reddit.Unit;
   reliancepartners: BowmarkProvider_reliancepartners.Unit;
   resy: BowmarkProvider_resy.Unit;
@@ -23439,8 +25136,10 @@ interface BowmarkProviders {
   sellcell: BowmarkProvider_sellcell.Unit;
   semihandmade: BowmarkProvider_semihandmade.Unit;
   sitmeanssit: BowmarkProvider_sitmeanssit.Unit;
+  sixflags: BowmarkProvider_sixflags.Unit;
   smartsign: BowmarkProvider_smartsign.Unit;
   smartwool: BowmarkProvider_smartwool.Unit;
+  smithery: BowmarkProvider_smithery.Unit;
   solostove: BowmarkProvider_solostove.Unit;
   soundcloud: BowmarkProvider_soundcloud.Unit;
   starlighthomes: BowmarkProvider_starlighthomes.Unit;
@@ -75209,23 +76908,39 @@ interface BowmarkProviders {
  * `run()` script, and the Proxy over HTTP in a caller's own process. They are
  * generated once precisely so those two cannot drift. */
 interface BowmarkLibrary {
+  bundles: BowmarkCapability_bundles.Unit;
+  cable_railing_quote: BowmarkCapability_cable_railing_quote.Unit;
   cars: BowmarkCapability_cars.Unit;
+  coworking: BowmarkCapability_coworking.Unit;
+  custom_sofa_configurator: BowmarkCapability_custom_sofa_configurator.Unit;
+  developer_api_key_signup: BowmarkCapability_developer_api_key_signup.Unit;
+  domain: BowmarkCapability_domain.Unit;
   email: BowmarkCapability_email.Unit;
   flights: BowmarkCapability_flights.Unit;
+  game_soundtrack_composer_credits: BowmarkCapability_game_soundtrack_composer_credits.Unit;
   git_commit_history: BowmarkCapability_git_commit_history.Unit;
+  git_release_notes: BowmarkCapability_git_release_notes.Unit;
   hotels: BowmarkCapability_hotels.Unit;
   hvac: BowmarkCapability_hvac.Unit;
   insurance: BowmarkCapability_insurance.Unit;
+  istanbul_schedules: BowmarkCapability_istanbul_schedules.Unit;
+  mcp_registry: BowmarkCapability_mcp_registry.Unit;
   music: BowmarkCapability_music.Unit;
   pcparts: BowmarkCapability_pcparts.Unit;
+  phone_trade_in: BowmarkCapability_phone_trade_in.Unit;
+  pricing: BowmarkCapability_pricing.Unit;
   products: BowmarkCapability_products.Unit;
   promocodes: BowmarkCapability_promocodes.Unit;
   read: BowmarkCapability_read.Unit;
   restaurant_booking: BowmarkCapability_restaurant_booking.Unit;
+  school_shopping_basket: BowmarkCapability_school_shopping_basket.Unit;
   search: BowmarkCapability_search.Unit;
   sheds: BowmarkCapability_sheds.Unit;
   shipping: BowmarkCapability_shipping.Unit;
   tariff: BowmarkCapability_tariff.Unit;
+  text_to_speech: BowmarkCapability_text_to_speech.Unit;
+  theme_park_tickets: BowmarkCapability_theme_park_tickets.Unit;
   weather: BowmarkCapability_weather.Unit;
+  yoga_outfit_shopping: BowmarkCapability_yoga_outfit_shopping.Unit;
   providers: BowmarkProviders;
 }