@bowmark/web 1.18.0 → 1.20.0

package/dist/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: 12940343b1f8c9228a6b145e3e5125fe143419901694198fcc8789af04b5dc2e
-// 45 capabilities, 367 providers, 913 typed functions, 20 refused.
+// Manifest version: f9bdccf83883a14360d78c1b4f364bcb1ed422bd4bc56bd1b722b7a00105291c
+// 46 capabilities, 401 providers, 978 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
@@ -2182,6 +2182,32 @@ type CallOptions = {
   }
 }
 
+declare namespace BowmarkCapability_script_execution {
+  // ── How to write and run a script against the Bowmark library — the unit's own declarations, verbatim ──
+
+interface ScriptExecutionGuide {
+  loop: string[]
+  language: string[]
+  globals: string[]
+  statuses: Record<string, string>
+  warnings: string[]
+}
+
+  /**
+   * Explains the get_library -> write script -> run loop, the sandbox's language rules, its
+   * ambient globals, and what each run status means — a static reference, not a site wrapper.
+   */
+  interface Unit {
+    /**
+     * Returns the loop for doing a task (get_library, then a script, then run), the sandbox's
+     * language rules and ambient globals, and what each run envelope status
+     * (ok/partial/error/needs_user) means. Static and deterministic — it describes the platform
+     * itself, not any one site.
+     */
+    guide(): Promise<ScriptExecutionGuide>;
+  }
+}
+
 declare namespace BowmarkCapability_search {
   // ── Web search — the unit's own declarations, verbatim ──
 type SearchResult = {
@@ -2228,18 +2254,50 @@ type CallOptions = {
    * news coverage, with real publication dates and the outlet's name. ONE ENGINE TODAY (Bing),
    * so if it is down this fails rather than degrading — it throws, and never reports an outage
    * as zero results. Two things that engine cannot do, measured on `web`: it never returns an
-   * empty list even when nothing matches, and it ignores search operators like site:.
+   * empty list even when nothing matches — including for a long-tail query it has nothing
+   * confident to say about, e.g. an obscure company name plus "pricing" — and it ignores search
+   * operators like site:. `warnings` now flags the extreme case of the first — every returned
+   * row sharing not one word with the query, or every row matching only a generic word like
+   * "pricing" while the name you searched for is absent from all of them — but a
+   * partially-relevant substitution is not caught. A THIRD limit, measured 2026-09-11 and the
+   * one that hits ordinary research: it answers a MULTI-WORD query by reducing it to the single
+   * most popular word in it and returning that word's results — "React useEffect dependency
+   * array" comes back as React's homepage — and quoting, shortening or site-scoping the query
+   * does not change it. `warnings` now flags four shapes. Three read the words: no returned row
+   * sharing a word with the query, every row matching only a generic word like "pricing", or
+   * fewer than half the query's subject words appearing anywhere in the results. The fourth asks
+   * the engine the SAME query twice down the same exit — an answer that differs the second time
+   * is a random decoy, because an answerable query is stable across repeats (measured
+   * 2026-09-12). A merely partial substitution is still not caught. For `news`, keep queries to
+   * 2–3 words: OR-joined and more-than-three-term queries are unsupported and return an empty
+   * feed; short-query zeros remain ambiguous and carry a retry warning.
    */
   interface Unit {
     /**
      * Searches the web and returns ranked results — title, destination URL, snippet — from the
      * first engine in the chain that answers. `engine` names which one that was, and `warnings`
      * names any that were tried and failed first. Feed a result's `url` straight to
-     * bowmark.read.page to actually read it. TWO THINGS TO KNOW BEFORE YOU TRUST THE ROWS: the
-     * engine NEVER returns an empty list, so results are its best offer rather than proof anything
-     * matched, and it IGNORES operators — a `site:example.com` query is not scoped to that site.
-     * When every engine fails this THROWS rather than returning zero rows, because no engine
-     * reached is not the same as nothing found.
+     * bowmark.read.page to actually read it. THREE THINGS TO KNOW BEFORE YOU TRUST THE ROWS. (1)
+     * The engine NEVER returns an empty list, so results are its best offer rather than proof
+     * anything matched — a long-tail query (an obscure company name plus "pricing", say) can come
+     * back with ten confident rows about something else entirely. (2) It IGNORES operators — a
+     * `site:example.com` query is not scoped to that site. (3) MEASURED 2026-09-11, AND THE ONE
+     * THAT HITS ORDINARY RESEARCH: it answers a MULTI-WORD query by reducing it to the single most
+     * popular word in it and returning that word's results. "React useEffect dependency array"
+     * comes back as React's own homepage, and a nine-word query naming a company, a job and a
+     * protocol came back as the results for the one two-letter acronym in it. Quoting the proper
+     * noun, shortening the query and site-scoping it were all tried on the same queries and all
+     * returned the identical substituted set, so rewriting the query does not help — search the
+     * ONE thing you most need, or read a URL you already know. `warnings` flags four shapes. Three
+     * read the words: no row sharing a single word with the query, every row matching only a
+     * generic word like "pricing" while the subject you named is absent, or fewer than half the
+     * query's subject words appearing anywhere in the results. The fourth reads the engine's own
+     * behaviour and is the reliable one: the query is asked TWICE down the same exit, and an
+     * answer that comes back different the second time is a random decoy rather than a bad ranking
+     * — measured 2026-09-12, an answerable query repeats identically while an unanswerable one
+     * returns a fresh unrelated set every time. A partially-relevant substitution is still not
+     * caught. When every engine fails this THROWS rather than returning zero rows, because no
+     * engine reached is not the same as nothing found.
      */
     web(query: string | { query: string, limit?: number }, limit?: number, options?: CallOptions): Promise<SearchWebResult>;
 
@@ -2253,8 +2311,9 @@ type CallOptions = {
      * response looks like. Measured 2026-09-08: five identical calls for one query on one route
      * inside ten seconds returned 4, 3, 2, 3 and 0 rows, and two exits disagreed (0 against 3) on
      * that query in the same minute. Every zero therefore arrives carrying a warning saying so;
-     * RETRY before reporting that nothing has been written about something. Still NOT MEASURED:
-     * whether this feed honours search operators — treat that as unknown.
+     * retry short queries before reporting that nothing has been written about something. Keep
+     * queries to 2–3 words: OR-joined and more-than-three-term queries are unsupported on this
+     * feed, so split them into separate calls instead of retrying.
      */
     news(query: string | { query: string, limit?: number }, limit?: number, options?: CallOptions): Promise<SearchNewsResult>;
   }
@@ -2611,23 +2670,80 @@ interface ForecastResult {
 }
 
 declare namespace BowmarkCapability_web_form_fields {
-  // ── Inspect a web form and count its fields — the unit's own declarations, verbatim ──
+  // ── Inspect, fill and drive a multi-step web form — the unit's own declarations, verbatim ──
+
+interface FormField { name: string | null; label: string | null; type: string; required: boolean; options?: string[] }
+interface InspectedForm { action: string | null; method: string; fields: FormField[]; frameUrl?: string | null }
+
+type FormOptions = {
+  strategy?: "auto" | "fetch" | "browser"  // default "auto" — plain GET, browser only if it found nothing
+  open?: string                            // the control that opens the form: a CSS selector or its visible text
+  timeoutMs?: number                       // default 30000
+}
+
+type FormInspectionResult = {
+  url: string
+  title: string | null
+  forms: InspectedForm[]
+  fieldCount: number
+  servedBy: "fetch" | "browser"      // which rung paid for this
+  escalated: boolean                 // the GET was tried and found nothing
+  escalationReason: string | null    // set even under strategy:"fetch", so under-reading is visible
+  openedWith: string | null          // the control that was clicked to reveal the form
+  multiStep: boolean                 // more steps follow; the count is the visible step only
+  stepLabel: string | null           // the form's own "Step 2 of 4", when it prints one
+  warnings: string[]
+}
 
-interface FormField { name: string | null; label: string | null; type: string; required: boolean }
-interface InspectedForm { action: string | null; method: string; fields: FormField[] }
-interface FormInspectionResult { url: string; title: string | null; forms: InspectedForm[]; fieldCount: number; warnings: string[] }
+type FormFillOptions = {
+  open?: string        // the control that opens the form, if you already know it
+  timeoutMs?: number   // default 30000
+  advance?: boolean     // click "Next"/"Continue" once values are written. default false
+  submit?: boolean       // click the control that COMMITS the form. default false. wins over advance
+}
+
+type FormFillResult = {
+  url: string
+  filled: string[]           // the values keys that matched a field and were written
+  notFound: string[]         // the values keys nothing on the page matched
+  advanced: boolean           // a Next/Continue control was found and clicked
+  submitted: boolean          // a submit/book/place-order control was found and clicked
+  openedWith: string | null
+  multiStep: boolean          // the step now on screen continues past this one
+  stepLabel: string | null
+  warnings: string[]
+}
 
   /**
-   * Fetches a public web page and inventories every visible form field: its label, name, type
-   * and required-ness. Read-only: it never fills or submits a form.
+   * Inventories every field a web form asks for — label, name, type, choices and required-ness —
+   * including a booking or quote widget that only appears after a click and mounts in its own
+   * iframe. `getFields` is read-only. `fillForm` writes answers into those same fields and can
+   * click 'Next'/'Continue' to advance a multi-step flow, or the control that finally commits it
+   * — one call, one step; call it again for the next step.
    */
   interface Unit {
     /**
-     * Reads a public page and returns its forms plus a total field count. Each field includes its
-     * label when the markup supplies one, name, type and required-ness. It never fills, clicks or
-     * submits anything; a page with client-rendered forms or no HTML form gets an honest warning.
+     * Reads a page and returns its forms plus a total field count, each field with its label,
+     * name, type, choices and required-ness. Takes a plain GET first and opens a browser only when
+     * that finds no fields — then it clicks the control that reveals the form (a `Book Online`
+     * button, say) and reads the widget's own cross-origin iframe. It clicks exactly that one
+     * control: it never types, never picks an option and never submits, so a multi-step flow comes
+     * back as the visible step plus `multiStep: true`.
      */
-    getFields(url: string): Promise<FormInspectionResult>;
+    getFields(url: string, options?: FormOptions): Promise<FormInspectionResult>;
+
+    /**
+     * Opens the page (and the booking/quote widget behind a button, exactly as `getFields` does),
+     * then writes `values` into whatever fields match — keyed by a field's `name` or a word or two
+     * of its label, matched fuzzily so the site's own wording doesn't have to be exact. Always
+     * opens a browser: filling is an interaction, not a read. Pass `advance: true` to click
+     * 'Next'/'Continue' once everything is written, or `submit: true` to click the control that
+     * actually commits the form (submit wins if both are set). One call is one step — call it
+     * again with the next step's `values` to walk a wizard forward. `notFound` names any `values`
+     * key nothing on the page matched, so a caller who guessed a label wrong sees that rather than
+     * silence.
+     */
+    fillForm(url: string, values: Record<string, string>, options?: FormFillOptions): Promise<FormFillResult>;
   }
 }
 
@@ -3279,6 +3395,32 @@ interface abercrombieStockQuery {
   }
 }
 
+declare namespace BowmarkProvider_abqplumb {
+  // ── Albuquerque Plumbing, Heating & Cooling — the unit's own declarations, verbatim ──
+interface AbqPlumbIssueType { id: number; name: string; division: string | null; }
+interface AbqPlumbServiceType { id: number; name: string; issueTypes: AbqPlumbIssueType[]; }
+interface AbqPlumbAppointmentRequest { serviceTypeId: number; issueTypeId: number; }
+interface AbqPlumbAppointmentSlot { startTime: string; endTime: string; }
+
+  /**
+   * Albuquerque Plumbing, Heating & Cooling's public booking-widget services and live
+   * appointment slots, with no customer details needed.
+   */
+  interface Unit {
+    /**
+     * Lists the services and issue types in ABQ Plumb's own booking widget. The entry point:
+     * getAvailability takes a serviceTypeId and issueTypeId this returns.
+     */
+    listServices(): Promise<AbqPlumbServiceType[]>;
+
+    /**
+     * Returns ABQ Plumb's currently-open appointment slots for one service and issue type from
+     * listServices. This reads availability only; it never submits a booking.
+     */
+    getAvailability(input: AbqPlumbAppointmentRequest): Promise<AbqPlumbAppointmentSlot[]>;
+  }
+}
+
 declare namespace BowmarkProvider_acerentacar {
   // ── ACE Rent A Car — the unit's own declarations, verbatim ──
 interface AcerentacarSearchArgs { pickupLocationCode: string; pickupDate: string; dropoffDate: string; pickupTime?: string; dropoffTime?: string; }
@@ -3387,6 +3529,33 @@ interface AcqualinaRoomAvailability {
   }
 }
 
+declare namespace BowmarkProvider_ai_engineer {
+  // ── AI Engineer — the unit's own declarations, verbatim ──
+interface AiEngineerSpeaker {
+  name: string;
+  title: string;
+  company: string;
+  speakerHandle: string;
+  url: string;
+}
+
+  /** Conference speakers and speaker information from the AI Engineer conference. */
+  interface Unit {
+    /**
+     * Lists all speakers at the AI Engineer conference with their names, titles, companies, and
+     * speaker page URLs.
+     */
+    listSpeakers(): Promise<{ speakers: AiEngineerSpeaker[] }>;
+
+    /**
+     * Returns detailed information about one speaker from the AI Engineer conference, including
+     * name, title, company, and speaker page URL. THROWS if the handle is not on the current
+     * roster — check it with listSpeakers() first.
+     */
+    getSpeaker(args: { speakerHandle: string }): Promise<AiEngineerSpeaker>;
+  }
+}
+
 declare namespace BowmarkProvider_aiper {
   // ── Aiper — the unit's own declarations, verbatim ──
 interface AiperPoolOption {
@@ -4466,6 +4635,49 @@ interface AspZipMatch {
   }
 }
 
+declare namespace BowmarkProvider_astoundgroup {
+  // ── Astound Group — the unit's own declarations, verbatim ──
+// Astound Group's OWN shapes — not a capability contract.
+
+interface AstoundgroupSitemapPage {
+  url: string;
+  lastmod: string | null;
+}
+
+interface AstoundgroupContactField {
+  name: string;
+  label: string;
+  type: string;
+  required: boolean;
+}
+
+interface AstoundgroupContactForm {
+  url: string;
+  action: string;
+  fields: AstoundgroupContactField[];
+}
+
+  /**
+   * Astound Group's own site index (sitemap.xml) and its Get in Touch contact form's real fields
+   * — name, label, type and required — parsed from the site's server-rendered markup rather than
+   * a caller re-reading raw HTML.
+   */
+  interface Unit {
+    /**
+     * Lists every page astoundgroup.com's own sitemap.xml publishes, each with its own url and
+     * last-modified date — use this to find the contact page or any other page without guessing a
+     * path.
+     */
+    listPages(): Promise<AstoundgroupSitemapPage[]>;
+
+    /**
+     * Reads Astound Group's contact form (astoundgroup.com/contact-us by default) and returns its
+     * real fields — name, label, input type and whether it's required.
+     */
+    getContactForm(url?: string): Promise<AstoundgroupContactForm>;
+  }
+}
+
 declare namespace BowmarkProvider_atlasoceanvoyages {
   // ── Atlas Ocean Voyages — the unit's own declarations, verbatim ──
 // Atlas Ocean Voyages' OWN shapes — not a capability contract.
@@ -4662,6 +4874,24 @@ interface AutocampProperty {
   }
 }
 
+declare namespace BowmarkProvider_avalonmalibu_com {
+  // ── Avalon Malibu — the unit's own declarations, verbatim ──
+interface AvalonMalibuInsuranceField { name: string; label: string; type: string; required: boolean; options: string[]; }
+interface AvalonMalibuInsuranceForm { url: string; fields: AvalonMalibuInsuranceField[]; }
+
+  /**
+   * Avalon Malibu's public insurance-verification form, with real field labels and select
+   * choices, read without submitting health or insurance data.
+   */
+  interface Unit {
+    /**
+     * Reads Avalon Malibu's /insurance verification form and returns its named fields, labels,
+     * types, required flags and select choices. It never submits the form.
+     */
+    getInsuranceForm(url?: string): Promise<AvalonMalibuInsuranceForm>;
+  }
+}
+
 declare namespace BowmarkProvider_avantstay {
   // ── AvantStay — the unit's own declarations, verbatim ──
 interface AvantstayProperty {
@@ -5938,6 +6168,9 @@ interface BingSearchResult {
   query: string;
   results: BingWebResult[];
   warnings: string[];
+  substituted: boolean          // true when any of the four checks below judged these
+                                // rows to answer a DIFFERENT query. The machine-readable
+                                // form of the verdict warnings states in prose
 }
 
 interface BingNewsSearchResult {
@@ -5949,29 +6182,92 @@ interface BingNewsSearchResult {
   /**
    * General web and news search over Bing's index, read off Bing's own RSS output — ten ranked
    * results per query with title, destination URL, snippet and date. Keyless, browserless, ~5 KB
-   * a call. It never reports 'no matches' and it ignores search operators like site: — both
-   * measured, both declared.
+   * a call. Web never reports 'no matches' and ignores search operators like site:. News can be
+   * empty, but OR-joined or more-than-three-term queries are unsupported and are warned as
+   * malformed instead of retried.
    */
   interface Unit {
     /**
      * Searches the web and returns the ten results Bing ranked first, with title, destination URL,
-     * snippet and date. TWO LIMITS, neither visible in the response: it NEVER returns an empty
-     * list — a query of three invented words came back with ten confident, unrelated rows — and it
-     * IGNORES search operators, so `site:reddit.com …` is not scoped to reddit. Treat the rows as
-     * Bing's best offer rather than as proof anything matched.
+     * snippet and date. THREE LIMITS. (1) It NEVER returns an empty list — a query of three
+     * invented words came back with ten confident, unrelated rows, and a long-tail query (an
+     * obscure company name plus "pricing", say) can get the same substituted treatment. (2) It
+     * IGNORES search operators, so `site:reddit.com …` is not scoped to reddit. (3) MEASURED
+     * 2026-09-11, and the one that hits ordinary research: it answers a MULTI-WORD query by
+     * reducing it to the single most popular word in it and returning that word's results — "React
+     * useEffect dependency array" comes back as React's own homepage, and a nine-word query naming
+     * a company, a job and a protocol came back as the results for the one two-letter acronym in
+     * it. Quoting the proper noun, shortening the query and site-scoping it were all tried and all
+     * returned the identical substituted set, so rewriting the query does not help. `warnings`
+     * flags four shapes. Three read the words: no row sharing a single word with the query, every
+     * row matching only a generic word like "pricing" while the thing you named is absent, or
+     * fewer than half the query's subject words appearing anywhere in the results. The fourth
+     * reads Bing's own behaviour and is the reliable one — the query is asked TWICE down the same
+     * exit, and an answer that differs the second time is a random decoy, because a query Bing can
+     * actually answer is stable across repeats (measured 2026-09-12: 1.00 repeat overlap on every
+     * answerable query, 0.00 on every unanswerable one, nothing in between). A partially-relevant
+     * result set is still not caught, so treat the rows as Bing's best offer rather than as proof
+     * anything matched.
      */
     searchWeb(args: { query: string, limit?: number }): Promise<BingSearchResult>;
 
+    /**
+     * Searches the web through a browser to bing.com instead of reading the RSS feed — same
+     * results shape. It does NOT fix relevance: measured 2026-09-12 from the fleet's own egress,
+     * it substitutes on exactly the queries the RSS feed substitutes on, on a residential exit and
+     * a datacenter one alike (the earlier claim that a browser answers multi-word queries
+     * correctly was measured from a laptop and confounded the client with the network). Kept as a
+     * standby that can rescue a query the primary drops. Expensive: holds a browser pool slot for
+     * ~4s per call. Use searchWeb instead, and let the search capability choose when to fall back
+     * to this version.
+     */
+    searchWebBrowser(args: { query: string, limit?: number }): Promise<BingSearchResult>;
+
     /**
      * Searches news coverage and returns stories with the headline, the outlet's own article URL,
      * a summary, a real publication timestamp, the publisher name and a thumbnail. Use this rather
      * than searchWeb when the question is 'what happened' — the web feed's dates are Bing's crawl
-     * stamps, this feed's are the story's.
+     * stamps, this feed's are the story's. Keep each query to 2–3 words: OR-joined and
+     * more-than-three-term queries return an empty feed and are warned as unsupported, so split
+     * them into separate calls rather than retrying.
      */
     searchNews(args: { query: string, limit?: number }): Promise<BingNewsSearchResult>;
   }
 }
 
+declare namespace BowmarkProvider_bionicpo {
+  // ── BionicPO — the unit's own declarations, verbatim ──
+interface InquiryService {
+  id: string;
+  name: string;
+  category: string;
+  description?: string;
+}
+
+interface ServiceDetails {
+  id: string;
+  name: string;
+  description: string;
+  formFields: FormField[];
+}
+
+interface FormField {
+  name: string;
+  type: string;
+  required: boolean;
+  label?: string;
+}
+
+  /** Query inquiry and service details from BionicPO's services directory. */
+  interface Unit {
+    /** List BionicPO inquiry and service categories from the inquiry-services page. */
+    listInquiryServices(): Promise<{ services: InquiryService[]; warnings: string[] }>;
+
+    /** Get a BionicPO inquiry service's form fields and details. */
+    getInquiryServiceDetails(serviceName: string): Promise<ServiceDetails>;
+  }
+}
+
 declare namespace BowmarkProvider_bishops {
   // ── Bishops Cuts/Color — the unit's own declarations, verbatim ──
 interface BishopsLocationLink {
@@ -6861,6 +7157,49 @@ interface BrixtonCheckoutLink {
   }
 }
 
+declare namespace BowmarkProvider_builder_strucsure_com {
+  // ── StrucSure Home Warranty — the unit's own declarations, verbatim ──
+interface StrucsureRegistrationState {
+  id: number;
+  code: string;
+  name: string;
+  registered: boolean;
+}
+interface StrucsureOption {
+  id: number;
+  name: string;
+}
+interface StrucsureEnrollmentType extends StrucsureOption {
+  isDefault: boolean;
+  contractorTypeId: number;
+}
+interface StrucsureNewConstructionFields {
+  foundationTypes: StrucsureOption[];
+  homeTypes: StrucsureOption[];
+  enrollmentTypes: StrucsureEnrollmentType[];
+}
+
+  /**
+   * StrucSure Home Warranty's new-construction builder registration form: recognized states,
+   * foundation types, home types and warranty terms, read from the portal's own reference-data
+   * API.
+   */
+  interface Unit {
+    /**
+     * Lists the states StrucSure Home Warranty's builder registration portal recognizes, and which
+     * are currently open for registration.
+     */
+    listRegistrationStates(): Promise<StrucsureRegistrationState[]>;
+
+    /**
+     * Returns the foundation-type, home-type and warranty-term (enrollment-type) choices for
+     * StrucSure's new-construction builder registration form, before any registration is
+     * submitted.
+     */
+    getNewConstructionRegistrationFields(): Promise<StrucsureNewConstructionFields>;
+  }
+}
+
 declare namespace BowmarkProvider_bulletproof {
   // ── Bulletproof 360 — the unit's own declarations, verbatim ──
 interface BulletproofStore {
@@ -7187,6 +7526,133 @@ interface CabinsforyouSearchArgs {
   }
 }
 
+declare namespace BowmarkProvider_cal_com {
+  // ── Cal.com — the unit's own declarations, verbatim ──
+interface CalComEventType {
+  slug: string;
+  title: string;
+  id: number;
+  lengthInMinutes: number | null;
+  description: string | null;
+  url: string;
+}
+
+interface CalComEventTypesResult {
+  username: string;
+  eventTypes: CalComEventType[];
+}
+
+interface CalComSlot {
+  start: string;
+}
+
+interface CalComDay {
+  date: string;
+  slots: CalComSlot[];
+}
+
+interface CalComAvailabilityOptions {
+  daysAhead?: number;
+}
+
+interface CalComAvailabilityResult {
+  username: string;
+  eventType: CalComEventType;
+  days: CalComDay[];
+  otherEventTypes: CalComEventType[];
+}
+
+  /**
+   * Cal.com's own documented, keyless public API — the event types a booking page offers and the
+   * real, currently-open time slots for one of them — no browser, no key.
+   */
+  interface Unit {
+    /**
+     * Lists every event type a Cal.com username currently publishes — the entry point. Takes the
+     * bare username (e.g. "humanlayer") or the full url a caller was given (e.g.
+     * "https://cal.com/humanlayer"), and returns each event's title, slug, id and length.
+     */
+    getEventTypes(username: string): Promise<CalComEventTypesResult>;
+
+    /**
+     * Returns the real, currently-open time slots for one Cal.com event type — accepts a bare
+     * username ("humanlayer"), a username url, or a specific event url
+     * ("https://cal.com/humanlayer/code"). Given a bare username, it picks that username's first
+     * event type and reports the rest in `otherEventTypes`.
+     */
+    getAvailability(username: string, opts?: CalComAvailabilityOptions): Promise<CalComAvailabilityResult>;
+  }
+}
+
+declare namespace BowmarkProvider_calendly {
+  // ── Calendly — the unit's own declarations, verbatim ──
+interface CalendlyEventType {
+  slug: string;
+  name: string;
+  uuid: string;
+  url: string;
+  description: string | null;
+}
+
+interface CalendlyProfile {
+  slug: string;
+  name: string;
+  timezone: string;
+}
+
+interface CalendlyEventTypesResult {
+  profile: CalendlyProfile;
+  eventTypes: CalendlyEventType[];
+}
+
+interface CalendlySlot {
+  startTime: string;
+  inviteesRemaining: number;
+}
+
+interface CalendlyDay {
+  date: string;
+  status: string;  // the site's own labels — read the values off a result, never guess one from prose
+  slots: CalendlySlot[];
+}
+
+interface CalendlyAvailabilityOptions {
+  timezone?: string;
+  daysAhead?: number;
+}
+
+interface CalendlyAvailabilityResult {
+  profileSlug: string;
+  eventType: CalendlyEventType;
+  timezone: string;
+  days: CalendlyDay[];
+  otherEventTypes: CalendlyEventType[];
+}
+
+  /**
+   * Calendly's own public booking-widget data — the event types a scheduling page offers and the
+   * real, currently-open time slots for one of them — read straight off the widget's
+   * undocumented JSON endpoints, no browser, no key.
+   */
+  interface Unit {
+    /**
+     * Lists every event type a Calendly profile currently offers — the entry point. Takes the bare
+     * profile slug a person books under (e.g. "jason-frazier") or the full url a caller was given
+     * (e.g. "https://calendly.com/jason-frazier"), and returns each event's name, slug, uuid and
+     * its own bookable url.
+     */
+    getEventTypes(profile: string): Promise<CalendlyEventTypesResult>;
+
+    /**
+     * Returns the real, currently-open time slots for one Calendly event type — accepts a bare
+     * profile slug ("jason-frazier"), a profile url, or a specific event url
+     * ("https://calendly.com/jason-frazier/15min"). Given a bare profile, it picks that profile's
+     * first event type and reports the rest in `otherEventTypes`.
+     */
+    getAvailability(profile: string, opts?: CalendlyAvailabilityOptions): Promise<CalendlyAvailabilityResult>;
+  }
+}
+
 declare namespace BowmarkProvider_caliberhealth {
   // ── Caliber Healthcare Solutions — the unit's own declarations, verbatim ──
 // Caliber Healthcare Solutions' OWN shapes — not a capability contract.
@@ -9679,6 +10145,57 @@ interface code_claude_comDocLink {
   }
 }
 
+declare namespace BowmarkProvider_compass_living {
+  // ── Compass Living — the unit's own declarations, verbatim ──
+interface CommunityWithForms {
+  name: string;
+  url: string;
+  contactFormFields: string[];
+  warnings: string[];
+}
+
+  /** Discover senior living communities and their contact-form fields. */
+  interface Unit {
+    /**
+     * Lists communities with their contact-form field labels, optionally capped at `limit`
+     * communities.
+     */
+    listCommunities(limit?: number): Promise<CommunityWithForms[]>;
+  }
+}
+
+declare namespace BowmarkProvider_completehomewarranty_com {
+  // ── Complete Home Warranty — the unit's own declarations, verbatim ──
+// Complete Home Warranty's OWN shape — not a capability contract.
+
+interface CompletehomewarrantyComPlan {
+  name: string;               // e.g. "Essential Plan"
+  price: number;               // monthly price in priceCurrency
+  priceCurrency: string;
+  coverageSummary: string;     // e.g. "Essential Home Warranty — 3 Appliances + HVAC"
+}
+
+  /**
+   * Reads Complete Home Warranty's own published plan catalog — real monthly price and coverage
+   * summary for each of its four home-warranty plans — straight off the plans page's own
+   * structured data, no browser and no parsing prose.
+   */
+  interface Unit {
+    /**
+     * Lists Complete Home Warranty's current published plans — name, monthly price and coverage
+     * summary for each — straight off the plans page's own structured data.
+     */
+    listPlans(): Promise<CompletehomewarrantyComPlan[]>;
+
+    /**
+     * Reads one plan by name (e.g. "Essential Plan") — its monthly price and coverage summary.
+     * `name` is a plan name from `listPlans()`. THROWS on an unknown name, naming `listPlans()` as
+     * the way to find current ones.
+     */
+    getPlan(name: string): Promise<CompletehomewarrantyComPlan>;
+  }
+}
+
 declare namespace BowmarkProvider_consultnet {
   // ── ConsultNet — the unit's own declarations, verbatim ──
 // ConsultNet's OWN shapes — not a capability contract.
@@ -9715,6 +10232,25 @@ interface ConsultnetJobSearchQuery {
   }
 }
 
+declare namespace BowmarkProvider_costco {
+  // ── Costco — the unit's own declarations, verbatim ──
+interface CostcoProduct {
+  itemNumber: string;
+  title: string;
+  brand: string | null;
+  imageUrl: string | null;
+}
+
+  /** Search Costco's product catalog by keyword. */
+  interface Unit {
+    /**
+     * Runs a search on Costco's product catalog and returns matching items (title, brand, item
+     * number, image). Does not return price — see the module header.
+     */
+    search(query: string): Promise<CostcoProduct[]>;
+  }
+}
+
 declare namespace BowmarkProvider_couponfollow {
   // ── CouponFollow — the unit's own declarations, verbatim ──
 interface CouponFollowOffer {
@@ -12227,6 +12763,31 @@ interface ExtraspaceUnitAvailability {
   }
 }
 
+declare namespace BowmarkProvider_faceforwardaesthetics {
+  // ── Face Forward Aesthetics — the unit's own declarations, verbatim ──
+interface FaceForwardAestheticsLocation { id: string; name: string; address: string | null; phone: string | null; }
+interface FaceForwardAestheticsService { id: string; name: string; description: string | null; durationMinutes: number | null; price: number | null; }
+interface FaceForwardAestheticsAvailability { centerId: string; serviceId: string; date: string; slots: { time: string }[]; }
+
+  /**
+   * Face Forward Aesthetics' live Zenoti locations, service catalog, and bookable appointment
+   * slots — no login, no PII, and no browser.
+   */
+  interface Unit {
+    /** Lists Face Forward Aesthetics' real bookable Zenoti locations (9 centers, OH/IN/NV/PA). */
+    listLocations(): Promise<FaceForwardAestheticsLocation[]>;
+
+    /** Lists a location's live Zenoti services, prices, and durations. */
+    listServices(centerId: string, query?: string): Promise<FaceForwardAestheticsService[]>;
+
+    /**
+     * Reads real open appointment slots for a service and date; an empty list is a real
+     * fully-booked answer.
+     */
+    checkAvailability(centerId: string, serviceId: string, date: string): Promise<FaceForwardAestheticsAvailability>;
+  }
+}
+
 declare namespace BowmarkProvider_facerealityskincare {
   // ── Face Reality Skincare — the unit's own declarations, verbatim ──
 interface FaceRealitySkincareEstheticianRow {
@@ -12267,6 +12828,38 @@ interface FaceRealitySkincareEstheticianRow {
   }
 }
 
+declare namespace BowmarkProvider_fbsappliance {
+  // ── Factory Builder Stores (FBS Appliance) — the unit's own declarations, verbatim ──
+interface FbsapplianceSearchArgs {
+  category: string;   // the site's own catalog slug, e.g. "built-in-refrigerators"
+  limit?: number;     // default 24, clamped to [1, 60]
+}
+
+interface FbsapplianceSearchResult {
+  name: string;
+  modelNumber: string;         // may end in a literal "..." when the grid clips it
+  price: number;                // real, current selling price
+  wasPrice: number | null;      // the crossed-out "was" price, when shown
+  availableAt: string | null;   // the city the grid names, when it names one
+  url: string;                   // this product's own FBS Appliance URL
+}
+
+  /**
+   * FBS Appliance's real catalog across 8 Texas showrooms — searchAppliances runs the site's own
+   * category grid and returns real, currently-listed appliances with live selling price, any
+   * sale/was price, model number, and which store the grid shows it in stock at.
+   */
+  interface Unit {
+    /**
+     * Runs FBS Appliance's own category grid and returns real, currently-listed appliances (name,
+     * model number, real current price, the crossed-out 'was' price when shown, the store the grid
+     * names as having it, and the product's own FBS Appliance URL). Read-only — never adds to cart
+     * or checks out.
+     */
+    searchAppliances(args: FbsapplianceSearchArgs): Promise<FbsapplianceSearchResult[]>;
+  }
+}
+
 declare namespace BowmarkProvider_fieldstonehomes {
   // ── Fieldstone Homes — the unit's own declarations, verbatim ──
 interface FieldstonehomesSearchArgs { city?: string; homeType?: string; minPrice?: number; maxPrice?: number; minBeds?: number; minSqft?: number; }
@@ -12410,6 +13003,56 @@ interface FirstdibsListing {
   }
 }
 
+declare namespace BowmarkProvider_fitness1440 {
+  // ── FITNESS:1440 — the unit's own declarations, verbatim ──
+// FITNESS:1440's OWN shapes — not a capability contract.
+
+interface Fitness1440Location {
+  state: string;
+  city: string;
+}
+
+interface Fitness1440ListLocationsArgs {
+  state?: string;
+}
+
+interface Fitness1440ListLocationsResult {
+  locations: Fitness1440Location[];
+  states: string[];
+}
+
+interface Fitness1440DayPassRequestArgs {
+  state: string;
+  city: string;
+}
+
+interface Fitness1440DayPassRequestInfo {
+  state: string;
+  city: string;
+  requestUrl: string; // the WRITE handoff this provider never submits
+  requiredFields: string[];
+}
+
+  /**
+   * FITNESS:1440's own live day-pass request form (/request-day-pass/) — the real state → city
+   * cascade of clubs currently taking free day-pass requests, off the site's own server-rendered
+   * form, plus the form's own handoff for one confirmed location.
+   */
+  interface Unit {
+    /**
+     * Reads FITNESS:1440's own live day-pass form and returns the state → city cascade it
+     * currently renders, optionally filtered to one state.
+     */
+    listLocations(args?: Fitness1440ListLocationsArgs): Promise<Fitness1440ListLocationsResult>;
+
+    /**
+     * Validates one state/city pair against the live cascade and returns the day-pass form's own
+     * URL and required fields — the handoff a caller completes the request at.
+     */
+    getDayPassRequestInfo(args: Fitness1440DayPassRequestArgs): Promise<Fitness1440DayPassRequestInfo>;
+  }
+}
+
 declare namespace BowmarkProvider_fivebelow {
   // ── Five Below — the unit's own declarations, verbatim ──
 interface FiveBelowVariant {
@@ -12570,6 +13213,71 @@ interface flightradar24ArrivalsBoard {
   }
 }
 
+declare namespace BowmarkProvider_fluencecorp {
+  // ── Fluence Corporation — the unit's own declarations, verbatim ──
+interface ConcentrationSet {
+  COD: number;
+  TKN: number;
+  NO3N: number;
+  DisolvedOxygen?: number;
+}
+
+interface SludgeConcentrationSet {
+  TSSConcentration: number;
+  COD?: number;
+  TKN?: number;
+  NO3N?: number;
+  DisolvedOxygen?: number;
+  VSS_TSS_Ratio?: number;
+}
+
+interface PowerConsumer {
+  name: string;
+  consumption: number;
+  count: number;
+  operation: number;
+}
+
+interface EnergyConsumptionInput {
+  influentFlow: number;
+  sludgeFlow?: number;
+  influent: ConcentrationSet;
+  effluent: ConcentrationSet;
+  sludge: SludgeConcentrationSet;
+  elevation: number;
+  temperature: number;
+  power: Record<string, PowerConsumer>;
+}
+
+interface EnergyConsumptionResult {
+  NEC: number;
+  NEC_T_P: number;
+  NOR: number;
+  LR_COD: number;
+  LR_TKN: number;
+  LR_NO3N: number;
+  LR_DisolvedOxygen: number;
+  totalPower: number;
+  barometricPressure: number;
+  effluentFlow: number;
+  level: 0 | 1 | 2 | 3;
+}
+
+  /**
+   * Computes Normalized Energy Consumption (NEC, kWh/kg) for a wastewater-treatment plant design
+   * per ISO 21939 — the exact calculation Fluence's own Energy Consumption Calculator performs,
+   * reimplemented locally with no network call.
+   */
+  interface Unit {
+    /**
+     * Computes Normalized Energy Consumption (NEC, kWh/kg) for a wastewater treatment plant design
+     * per ISO 21939, from design flows, influent/sludge/effluent concentrations, environmental
+     * conditions and a power-consumer list.
+     */
+    calculateEnergyConsumption(args: EnergyConsumptionInput): Promise<EnergyConsumptionResult>;
+  }
+}
+
 declare namespace BowmarkProvider_ford {
   // ── Ford — the unit's own declarations, verbatim ──
 interface fordDayHours {
@@ -12996,6 +13704,46 @@ interface HubspotPageForms {
   }
 }
 
+declare namespace BowmarkProvider_fortressbp {
+  // ── Fortress Building Products — the unit's own declarations, verbatim ──
+interface fortressbpRecommendation {
+  productName: string | null;
+  imageUrl: string;
+  path: string[];
+}
+interface fortressbpNextQuestion {
+  prompt: string;
+  options: string[];
+}
+type fortressbpRow =
+  | ({ complete: true } & fortressbpRecommendation)
+  | ({ complete: false } & fortressbpNextQuestion);
+interface ListProductTypesResult {
+  productTypes: string[];
+}
+interface RecommendProductArgs {
+  selections: string[];
+}
+
+  /**
+   * Fortress Building Products' own Simplifinder product-recommendation tool (fencing, framing,
+   * pergolas), reimplemented from the site's own decision tree.
+   */
+  interface Unit {
+    /**
+     * Reads Simplifinder's own top-level product-type choices (Fencing / Framing / Pergolas) off
+     * the live page.
+     */
+    listProductTypes(): Promise<ListProductTypesResult>;
+
+    /**
+     * Walks Simplifinder's own decision tree with the labels chosen so far and returns either the
+     * recommended product or the next question to ask.
+     */
+    recommendProduct(args: RecommendProductArgs): Promise<fortressbpRow>;
+  }
+}
+
 declare namespace BowmarkProvider_fourseasonsyachts {
   // ── Four Seasons Yachts — the unit's own declarations, verbatim ──
 interface FourseasonsyachtsVoyage {
@@ -13985,6 +14733,54 @@ interface GlassesusaSearchResult {
   }
 }
 
+declare namespace BowmarkProvider_gobrightwing {
+  // ── Brightwing — the unit's own declarations, verbatim ──
+interface JobListing { id: string; title: string; location: string; workType: string; payMin?: number; payMax?: number; payCurrency?: string; postedDate?: string; }
+
+interface JobDetails extends JobListing { description: string; applyUrl: string; requirements?: string[]; }
+
+interface SearchJobsArgs { keyword?: string; location?: string; workType?: string; }
+
+interface GetJobDetailsArgs { jobId: string; }
+
+  /** Search Brightwing's job listings by keyword, location and work type, with live pay ranges. */
+  interface Unit {
+    /**
+     * Search Brightwing's live job listings by keyword, location, and work type. Returns matching
+     * postings with pay ranges.
+     */
+    searchJobs(args: SearchJobsArgs): Promise<JobListing[]>;
+
+    /** Get full details for a specific job posting, including description and apply link. */
+    getJobDetails(args: GetJobDetailsArgs): Promise<JobDetails>;
+  }
+}
+
+declare namespace BowmarkProvider_golf_com {
+  // ── GOLF.com Course Finder — the unit's own declarations, verbatim ──
+interface GolfComCourse { id: string; name: string; city: string; state: string; country: string; courseType: string | null; holes: number | null; startingFee: number | null; }
+interface GolfComCourseDetail extends GolfComCourse { address: string | null; phone: string | null; bookingUrl: string | null; golfNowUrl: string | null; }
+
+  /**
+   * GOLF.com's Course Finder: search real courses by name, city or ZIP, then read a course's
+   * address, phone and its own tee-time or trip-booking handoff. This provider discovers booking
+   * options; it never submits a reservation.
+   */
+  interface Unit {
+    /**
+     * Searches GOLF.com's Course Finder by course name, city or ZIP. Returns actual course rows,
+     * not location suggestions; pass a returned id to getCourse.
+     */
+    findCourses(query: string): Promise<GolfComCourse[]>;
+
+    /**
+     * Reads one Course Finder record including its address, phone, and the course's own
+     * tee-time/trip booking handoff when published. It does not reserve a tee time.
+     */
+    getCourse(id: string): Promise<GolfComCourseDetail>;
+  }
+}
+
 declare namespace BowmarkProvider_goloadup {
   // ── LoadUp — the unit's own declarations, verbatim ──
 // LoadUp's OWN shapes — not a capability contract.
@@ -14175,6 +14971,31 @@ interface GooglePriceGraph {
   }
 }
 
+declare namespace BowmarkProvider_gostoreit {
+  // ── Go Store It — the unit's own declarations, verbatim ──
+interface GetFacilityUnitsArgs { facilityUrl: string; }
+interface GoStoreItFacility { name: string; address: string; city: string; state: string; zip: string | null; amenities: string[]; startingPrice: number | null; facilityUrl: string; }
+interface GoStoreItUnit { size: string; category: string; amenities: string[]; monthlyPrice: number; standardMonthlyPrice: number | null; promotion: string | null; }
+
+  /**
+   * Go Store It — live public self-storage unit inventory, amenity details, and monthly online
+   * prices from a chosen facility.
+   */
+  interface Unit {
+    /**
+     * Searches Go Store It's public facility results by city, state, or ZIP and returns matching
+     * facility URLs, addresses, amenities, and starting prices.
+     */
+    findFacilities(query: string): Promise<GoStoreItFacility[]>;
+
+    /**
+     * Reads a public Go Store It facility page's live rendered inventory, prices, and amenity
+     * details.
+     */
+    getFacilityUnits(args: GetFacilityUnitsArgs): Promise<GoStoreItUnit[]>;
+  }
+}
+
 declare namespace BowmarkProvider_gotchacovered {
   // ── Gotcha Covered — the unit's own declarations, verbatim ──
 interface GotchaCoveredQuizOption {
@@ -14407,6 +15228,77 @@ type GrandwelcomeQuote =
   }
 }
 
+declare namespace BowmarkProvider_greatlakesbrewing {
+  // ── Great Lakes Brewing Co. — the unit's own declarations, verbatim ──
+interface GreatlakesbrewingEGiftCardOptions { presetAmounts: number[]; customAmount: { min: number; max: number; wholeDollarsOnly: boolean }; handlingFee: number; sleevePrice: number; checkoutUrl: string; }
+interface PriceGreatlakesbrewingEGiftCardArgs { amount: number; sleeve?: boolean; }
+interface GreatlakesbrewingEGiftCardPrice extends GreatlakesbrewingEGiftCardOptions { amount: number; sleeve: boolean; total: number; }
+
+  /**
+   * Great Lakes Brewing Co.'s live eGift-card configuration: current preset/custom
+   * denominations, gift-card-only handling fee, optional sleeve price, and a read-only total
+   * before checkout.
+   */
+  interface Unit {
+    /**
+     * Reads Great Lakes Brewing Co.'s live public eGift-card form: its preset denominations,
+     * permitted custom-amount range, gift-card-only handling fee, optional sleeve price and the
+     * official checkout handoff URL.
+     */
+    getEGiftCardOptions(): Promise<GreatlakesbrewingEGiftCardOptions>;
+
+    /**
+     * Calculates a Great Lakes Brewing Co. eGift-card total from a whole-dollar card value and
+     * optional sleeve, using the live public form's permitted range and gift-card-only fees.
+     * Returns the official eGift-card page for the shopper to complete checkout themselves; never
+     * creates a cart or order.
+     */
+    priceEGiftCard(args: PriceGreatlakesbrewingEGiftCardArgs): Promise<GreatlakesbrewingEGiftCardPrice>;
+  }
+}
+
+declare namespace BowmarkProvider_greatlakesdentaltech {
+  // ── Great Lakes Dental Technologies — the unit's own declarations, verbatim ──
+interface GldtProductSummary {
+  sku: string;
+  name: string;
+  price: number;
+  category: string | null;
+  url: string;
+}
+interface GldtSearchResult {
+  products: GldtProductSummary[];
+  total: number;
+}
+interface GldtProduct {
+  sku: string;
+  name: string;
+  price: number;
+  inStock: boolean;
+  stockMessage: string | null;
+  url: string;
+}
+
+  /**
+   * Great Lakes Dental Technologies' own orthodontic/dental catalog — searches ~4,000 SKUs and
+   * reads real, live price and stock straight off their storefront.
+   */
+  interface Unit {
+    /**
+     * Searches Great Lakes Dental Tech's own storefront catalog for what a buyer would type
+     * ("intraoral scanner", "sleep appliance") and returns matching products with the URL
+     * getProduct takes.
+     */
+    search(query: string, limit?: number): Promise<GldtSearchResult>;
+
+    /**
+     * Reads one product's real, current price and live stock status straight off its own page,
+     * plus the page's own URL — where the real Add to Cart action lives.
+     */
+    getProduct(url: string): Promise<GldtProduct>;
+  }
+}
+
 declare namespace BowmarkProvider_hamptonwaterwine {
   // ── Hampton Water Wine Co. — the unit's own declarations, verbatim ──
 interface HamptonWaterRetailer {
@@ -17583,6 +18475,35 @@ interface IvoryHomesSearchFilters {
   }
 }
 
+declare namespace BowmarkProvider_jasmine_dilucci {
+  // ── Jasmine DiLucci Life Coaching — the unit's own declarations, verbatim ──
+interface FormField {
+  name?: string;
+  type?: string;
+  label?: string;
+  step?: string;
+  options?: string[];
+}
+
+interface ApplicationFormSchema {
+  step?: string;
+  fields: FormField[];
+}
+
+interface GetApplicationFormSchemaArgs {
+  includeOptions?: boolean;
+}
+
+  /** Extracts application form structure from Jasmine DiLucci's coaching application funnel. */
+  interface Unit {
+    /**
+     * Returns the structure of the application funnel's DQ step: field names, labels, and step
+     * markers.
+     */
+    getApplicationFormSchema(args?: { includeOptions?: boolean }): Promise<ApplicationFormSchema>;
+  }
+}
+
 declare namespace BowmarkProvider_jennikayne {
   // ── Jenni Kayne — the unit's own declarations, verbatim ──
 interface GiftCardDenomination {
@@ -18422,6 +19343,30 @@ interface KuiuCheckoutLink {
   }
 }
 
+declare namespace BowmarkProvider_kwworldwide {
+  // ── KW Worldwide — the unit's own declarations, verbatim ──
+interface KwworldwideHubspotFormReference {
+  pageUrl: string;
+  formUrl: string;
+  portalId: string;
+  guid: string;
+}
+
+  /**
+   * Recovers the HubSpot portalId/formId pair kwworldwide.com's contact page loads client-side
+   * after hydration — for forms_hubspot_com.getFormDefinition, since the page's own HTML never
+   * carries them.
+   */
+  interface Unit {
+    /**
+     * Fetches a kwworldwide.com page (defaults to the contact page) and recovers the HubSpot
+     * portalId/formId pair its client-side embed loads after hydration — the page's own HTML never
+     * carries them — as a forms.hubspot.com URL ready for forms_hubspot_com.getFormDefinition.
+     */
+    findContactForm(pageUrl?: string): Promise<KwworldwideHubspotFormReference>;
+  }
+}
+
 declare namespace BowmarkProvider_labcorp {
   // ── Labcorp — the unit's own declarations, verbatim ──
 interface LabcorpTestSummary {
@@ -18464,6 +19409,42 @@ interface LabcorpTestDetail extends LabcorpTestSummary {
   }
 }
 
+declare namespace BowmarkProvider_landmarkhw_com {
+  // ── Landmark Home Warranty — the unit's own declarations, verbatim ──
+interface LandmarkhwComOrderState {
+  code: string;
+  name: string;
+}
+interface LandmarkhwComPropertyType {
+  id: string;
+  name: string;
+  units: number;
+}
+interface LandmarkhwComOrderOptionsArgs {
+  stateCode: string;
+}
+interface LandmarkhwComOrderOptions {
+  state: LandmarkhwComOrderState;
+  propertyTypes: LandmarkhwComPropertyType[];
+  orderUrl: string;
+}
+
+  /**
+   * Landmark Home Warranty's public order-form choices: market states and property types, read
+   * from server-rendered bootstrap data.
+   */
+  interface Unit {
+    /** Lists the states where Landmark Home Warranty's public order form currently offers coverage. */
+    listOrderStates(): Promise<LandmarkhwComOrderState[]>;
+
+    /**
+     * Returns the property-type choices for a Landmark Home Warranty order in one supported state,
+     * before any quote or order is submitted.
+     */
+    getOrderFormOptions(args: LandmarkhwComOrderOptionsArgs): Promise<LandmarkhwComOrderOptions>;
+  }
+}
+
 declare namespace BowmarkProvider_lasikplus {
   // ── LasikPlus — the unit's own declarations, verbatim ──
 interface LasikPlusCenter {
@@ -21635,6 +22616,76 @@ interface MuzeVisitingHours {
   }
 }
 
+declare namespace BowmarkProvider_my_auroramedicalspa_com {
+  // ── Aurora Medical Spa — the unit's own declarations, verbatim ──
+// Aurora Medical Spa's OWN shapes — not a capability contract.
+
+interface AuroraStoreHours { weekday: number; open: string; close: string }
+
+interface AuroraLocation {
+  locationId: number;   // the id getServiceCategories/getServices/getProviders take
+  name: string; fullName: string;
+  address: string; city: string; state: string; zip: string;
+  phone: string; email: string;
+  lat: number | null; lng: number | null;
+  storeHours: AuroraStoreHours[];
+}
+
+interface AuroraLocationSearchFilters { state?: string; city?: string }
+
+interface AuroraServiceCategory {
+  categoryId: number;   // the id getServices' categoryId takes
+  name: string;
+}
+
+interface AuroraService {
+  serviceId: number;    // the id getProviders' serviceId takes
+  name: string;
+  priceFrom: number;     // the site's own starting price, in dollars
+  durationMinutes: number;
+  description: string;
+}
+
+interface AuroraProvider {
+  providerId: number;   // -1 is the site's own "First Available" option
+  name: string;
+  title: string | null;
+}
+
+  /**
+   * Reads Aurora Medical Spa's own live booking options — its locations, the treatment
+   * categories and services each one offers online with starting price and duration, and which
+   * providers can perform a given service — off the site's own Korvue booking-platform REST API,
+   * the way its booking page reads the same data client-side.
+   */
+  interface Unit {
+    /**
+     * Lists every Aurora Medical Spa location (9 today), optionally narrowed by US state or city.
+     * Each row carries the locationId getServiceCategories/getServices/getProviders take, plus
+     * address, phone, email, lat/lng and store hours.
+     */
+    listLocations(filters?: AuroraLocationSearchFilters): Promise<AuroraLocation[]>;
+
+    /**
+     * Lists the treatment categories one location offers online (Botox, Injectable Treatments,
+     * HydraFacial, Kybella, …). Each row carries the categoryId getServices takes.
+     */
+    getServiceCategories(locationId: number): Promise<AuroraServiceCategory[]>;
+
+    /**
+     * Reads the live bookable services in one category at one location — name, starting price,
+     * duration and description. Each row carries the serviceId getProviders takes.
+     */
+    getServices(locationId: number, categoryId: number): Promise<AuroraService[]>;
+
+    /**
+     * Lists the providers who can perform one service at one location, including the site's own -1
+     * 'First Available' option.
+     */
+    getProviders(locationId: number, serviceId: number): Promise<AuroraProvider[]>;
+  }
+}
+
 declare namespace BowmarkProvider_myollie {
   // ── Ollie — the unit's own declarations, verbatim ──
 interface OllieMealPlanOption {
@@ -22809,6 +23860,25 @@ interface AssembledApplication {
   }
 }
 
+declare namespace BowmarkProvider_pacificlifestylehomes {
+  // ── Pacific Lifestyle Homes — the unit's own declarations, verbatim ──
+interface PacificLifestyleHomesSearchArgs { city?: "Camas" | "Ridgefield" | "Vancouver"; minBedrooms?: number; minBathrooms?: number; minPrice?: number; maxPrice?: number; }
+interface PacificLifestyleHomesListing { id: string; address: string; city: string; state: string; price: number; bedrooms: number; bathrooms: number; sqft: number; availability: string; url: string; }
+
+  /**
+   * Searches Pacific Lifestyle Homes' current Southwest Washington available-home inventory;
+   * prefer it when live home price, availability, or a listing handoff matters.
+   */
+  interface Unit {
+    /**
+     * Searches Pacific Lifestyle Homes' live available-home listings in Camas, Ridgefield, or
+     * Vancouver, Washington. Returns current price, beds, baths, sqft, availability, and the
+     * detail-page handoff URL.
+     */
+    searchAvailableHomes(args?: PacificLifestyleHomesSearchArgs): Promise<PacificLifestyleHomesListing[]>;
+  }
+}
+
 declare namespace BowmarkProvider_paypal {
   // ── PayPal — the unit's own declarations, verbatim ──
 interface PaypalEstimateFeeArgs {
@@ -23472,6 +24542,31 @@ interface polymarketMarket {
   }
 }
 
+declare namespace BowmarkProvider_polytex {
+  // ── Poly-Tex — the unit's own declarations, verbatim ──
+interface PolytexProduct { name: string; url: string; price: number | null; }
+interface PolytexOption { name: string; values: string[]; }
+interface PolytexProductDetail extends PolytexProduct { sku: string | null; options: PolytexOption[]; availability: string | null; checkoutUrl: string; }
+
+  /**
+   * Poly-Tex's live greenhouse and greenhouse-hardware storefront: find current products and
+   * prices, then read selectable options and checkout handoff.
+   */
+  interface Unit {
+    /**
+     * Searches Poly-Tex's live greenhouse catalog by product words, returning current product
+     * names, prices, and URLs.
+     */
+    searchProducts(query: string): Promise<PolytexProduct[]>;
+
+    /**
+     * Reads one Poly-Tex product's current price, selectable size or bundle options, shipping
+     * availability, and checkout handoff URL.
+     */
+    getProduct(url: string): Promise<PolytexProductDetail>;
+  }
+}
+
 declare namespace BowmarkProvider_poshmark {
   // ── Poshmark — the unit's own declarations, verbatim ──
 interface PoshmarkSupportArticle {
@@ -25076,6 +26171,52 @@ interface RitaniPriceResult {
   }
 }
 
+declare namespace BowmarkProvider_rivian {
+  // ── Rivian — the unit's own declarations, verbatim ──
+type RivianLeaseTrim = "premium";
+type RivianLeaseTermMonths = 24 | 36;
+type RivianLeaseAnnualMileage = 10000 | 12000 | 15000;
+type RivianLeaseCreditTier = "excellent" | "veryGood" | "good";
+
+interface RivianLeaseEstimateArgs {
+  trim: RivianLeaseTrim;
+  termMonths: RivianLeaseTermMonths;
+  annualMileage: RivianLeaseAnnualMileage;
+  creditTier: RivianLeaseCreditTier;
+  downPayment: number;
+}
+
+interface RivianLeaseEstimate {
+  model: "R1T";
+  trim: RivianLeaseTrim;
+  vehiclePrice: number;
+  destinationFee: number;
+  acquisitionFee: number;
+  monthlyPayment: number;
+  downPayment: number;
+  amountDueAtSigning: number;
+  residualValue: number;
+  termMonths: number;
+  annualMileage: number;
+  isLeaseEligible: boolean;
+}
+
+  /**
+   * Prices a real Rivian R1T lease through rivian.com's own R1 Shop payment-estimate calculator
+   * — monthly payment, amount due at signing, acquisition fee and residual value for a chosen
+   * term, mileage allowance, credit tier and down payment.
+   */
+  interface Unit {
+    /**
+     * Prices a real Rivian R1T Premium lease — monthly payment, amount due at signing, acquisition
+     * fee and residual value — for a chosen term (24 or 36 months), annual mileage allowance
+     * (10,000/12,000/15,000), credit tier and cash down payment, through rivian.com's own R1 Shop
+     * payment-estimate calculator. Only the Premium trim has a verified option combo today.
+     */
+    estimateLeasePayment(args: RivianLeaseEstimateArgs): Promise<RivianLeaseEstimate>;
+  }
+}
+
 declare namespace BowmarkProvider_roofmaxx {
   // ── Roof Maxx — the unit's own declarations, verbatim ──
 interface RoofmaxxCalculatorSettings {
@@ -27110,6 +28251,32 @@ interface SunlightenPriceListing {
   }
 }
 
+declare namespace BowmarkProvider_tagtrans_net {
+  // ── TAG Trans — the unit's own declarations, verbatim ──
+interface TagtransShipmentRateField { id: string; label: string; required: boolean; }
+interface TagtransShipmentRateForm { formUrl: string; recipient: string; subject: string; fields: TagtransShipmentRateField[]; services: string[]; }
+interface CreateTagtransShipmentRateEmailArgs { name: string; phone: string; email: string; service: string; company?: string; shipFrom?: string; shipTo?: string; desiredShippingDate?: string; desiredDeliveryDate?: string; details?: string; }
+interface TagtransShipmentRateEmail { mailtoUrl: string; recipient: string; subject: string; body: string; }
+
+  /**
+   * TAG Trans's public freight shipment-rate request form: its current fields and services, plus
+   * a prefilled email handoff the site itself uses.
+   */
+  interface Unit {
+    /**
+     * Returns TAG Trans's current public shipment-rate request fields, service choices, and the
+     * page URL without sending a request.
+     */
+    getShipmentRateForm(): Promise<TagtransShipmentRateForm>;
+
+    /**
+     * Builds TAG Trans's own prefilled mailto handoff for a freight shipment-rate request; it does
+     * not send the email.
+     */
+    createShipmentRateEmail(args: CreateTagtransShipmentRateEmailArgs): Promise<TagtransShipmentRateEmail>;
+  }
+}
+
 declare namespace BowmarkProvider_tamarackidaho {
   // ── Tamarack Resort — the unit's own declarations, verbatim ──
 interface tamarackidahoSearchArgs {
@@ -28353,6 +29520,41 @@ interface topviewtixPackageSummary {
   }
 }
 
+declare namespace BowmarkProvider_totalplastics {
+  // ── Total Plastics — the unit's own declarations, verbatim ──
+interface TotalplasticsQuoteFormField {
+  id: string;
+  type: string;
+  label: string;
+  required: boolean;
+  options: string[];
+}
+interface TotalplasticsQuoteFormFields {
+  title: string;
+  formUrl: string;
+  fields: TotalplasticsQuoteFormField[];
+}
+
+  /**
+   * Total Plastics' own "Request a Quote" form — a POWR widget embedded on /contact-us/, not on
+   * /quote/ — read directly off POWR's server-rendered config.
+   */
+  interface Unit {
+    /**
+     * Reads Total Plastics' live "Request a Quote" form and returns its field schema — label,
+     * type, required, and options per field.
+     */
+    getQuoteFormFields(): Promise<TotalplasticsQuoteFormFields>;
+
+    /**
+     * Reads one named field off the live "Request a Quote" form — e.g. "Material Type" or "Annual
+     * Plastics Spend" — and returns its option list, so a caller can pick a valid value before
+     * submitting.
+     */
+    getQuoteFormFieldOptions(label: string): Promise<TotalplasticsQuoteFormField>;
+  }
+}
+
 declare namespace BowmarkProvider_travelinsured {
   // ── Travel Insured International — the unit's own declarations, verbatim ──
 interface TravelinsuredDestination {
@@ -28648,6 +29850,74 @@ interface TrophysignaturehomesComparison {
   }
 }
 
+declare namespace BowmarkProvider_tryalma_com {
+  // ── Alma — US immigration legal services — the unit's own declarations, verbatim ──
+interface SearchResult {
+  title: string;
+  url: string;
+  summary?: string;
+}
+
+interface SearchResponse {
+  results: SearchResult[];
+  warnings: string[];
+}
+
+interface Page {
+  url: string;
+  title: string;
+  category: string;
+}
+
+interface ListPagesResponse {
+  pages: Page[];
+  warnings: string[];
+}
+
+interface SearchArgs {
+  query: string;
+}
+
+  /** Search Alma's immigration legal services content and site navigation. */
+  interface Unit {
+    /** Search Alma's content, including pages, resources, and team member profiles. */
+    search(query: string): Promise<SearchResponse>;
+
+    /** List all pages and sections available on the Alma website by category. */
+    listPages(): Promise<ListPagesResponse>;
+  }
+}
+
+declare namespace BowmarkProvider_tweethunter {
+  // ── Tweet Hunter — the unit's own declarations, verbatim ──
+interface TweetHunterFeature {
+  name: string;
+  description: string;
+}
+
+interface TweetHunterFeatureCategory {
+  name: string;
+}
+
+  /**
+   * Publicly advertised Tweet Hunter features for writing, scheduling, analyzing, and automating
+   * an X account.
+   */
+  interface Unit {
+    /**
+     * Lists Tweet Hunter's publicly advertised X-account features, including scheduling,
+     * analytics, automation, and content-writing tools.
+     */
+    listFeatures(): Promise<TweetHunterFeature[]>;
+
+    /**
+     * Lists Tweet Hunter's public feature categories: content creation, X analytics and growth,
+     * and automation.
+     */
+    listFeatureCategories(): Promise<TweetHunterFeatureCategory[]>;
+  }
+}
+
 declare namespace BowmarkProvider_twiddy {
   // ── Twiddy & Company Realtors — the unit's own declarations, verbatim ──
 interface TwiddyRentalRow {
@@ -28842,6 +30112,61 @@ interface UlrichPriceResult {
   }
 }
 
+declare namespace BowmarkProvider_upkeepstl_com {
+  // ── UPKEEP Home Maintenance Plans — the unit's own declarations, verbatim ──
+interface UpkeepstlPricedOption {
+  id: string;
+  name: string;
+  priceUsd: number;
+}
+interface UpkeepstlAddOn extends UpkeepstlPricedOption {
+  kind: "checkbox" | "quantity";
+  maxQuantity?: number;
+}
+interface UpkeepstlWarrantyTerm {
+  id: string;
+  years: number;
+  imageUrl: string;
+}
+interface UpkeepstlPlanBuilder {
+  homeTypes: UpkeepstlPricedOption[];
+  plans: UpkeepstlPricedOption[];
+  upgrades: UpkeepstlPricedOption[];
+  addOns: UpkeepstlAddOn[];
+  warrantyTerms: UpkeepstlWarrantyTerm[];
+  paymentOptions: { id: string; name: string }[];
+  formUrl: string;
+}
+interface UpkeepstlEstimate {
+  termTotalUsd: number;
+  perYearUsd: number;
+  warrantyYears: number;
+  planId: string;
+  homeTypeId: string;
+  upgradeId: string;
+  addOnIds: string[];
+  applianceQuantity: number;
+}
+
+  /**
+   * Reads UPKEEP STL's home-maintenance-plan builder — plan tiers, home types, add-ons, warranty
+   * terms and their prices — and estimates a plan's total cost, with no submission.
+   */
+  interface Unit {
+    /**
+     * Reads UPKEEP's public plan-builder schema: home types, plan tiers, the upgrade tier,
+     * itemized add-ons, warranty terms and payment options, each carrying the site's own price.
+     */
+    getPlanBuilder(): Promise<UpkeepstlPlanBuilder>;
+
+    /**
+     * Computes the total contract price and per-year price for one plan selection, using ids from
+     * getPlanBuilder() and the site's own published prices. No submission, no identity.
+     */
+    estimatePlanCost(args: { planId: string; homeTypeId: string; warrantyYears: number; upgradeId?: string; addOnIds?: string[]; applianceQuantity?: number }): Promise<UpkeepstlEstimate>;
+  }
+}
+
 declare namespace BowmarkProvider_ups {
   // ── UPS — the unit's own declarations, verbatim ──
 interface upsRatedShipment {
@@ -29705,6 +31030,48 @@ interface WaterfurnaceSavingsEstimate {
   }
 }
 
+declare namespace BowmarkProvider_wearehirschfeld {
+  // ── Hirschfeld — the unit's own declarations, verbatim ──
+// Hirschfeld's OWN shapes — not a capability contract.
+
+interface WearehirschfeldSitemapPage {
+  url: string;
+  lastmod: string | null;
+}
+
+interface WearehirschfeldContactField {
+  name: string;
+  label: string;
+  type: string;
+  required: boolean;
+}
+
+interface WearehirschfeldContactForm {
+  url: string;
+  fields: WearehirschfeldContactField[];
+}
+
+  /**
+   * Hirschfeld's own page index (page-sitemap.xml) and its Connect contact form's real fields —
+   * name, label, type and required — parsed from the site's server-rendered markup rather than a
+   * caller guessing contact-page paths.
+   */
+  interface Unit {
+    /**
+     * Lists every page wearehirschfeld.com's own page-sitemap.xml publishes, each with its own url
+     * and last-modified date — use this to find the connect/contact page or any other page without
+     * guessing a path.
+     */
+    listPages(): Promise<WearehirschfeldSitemapPage[]>;
+
+    /**
+     * Reads Hirschfeld's contact form (wearehirschfeld.com/connect/ by default) and returns its
+     * real fields — name, label, input type and whether it's required.
+     */
+    getContactForm(url?: string): Promise<WearehirschfeldContactForm>;
+  }
+}
+
 declare namespace BowmarkProvider_wellfound {
   // ── Wellfound — the unit's own declarations, verbatim ──
 interface wellfoundRow {
@@ -31032,9 +32399,11 @@ interface BowmarkProviders {
   aa: BowmarkProvider_aa.Unit;
   aauto: BowmarkProvider_aauto.Unit;
   abercrombie: BowmarkProvider_abercrombie.Unit;
+  abqplumb: BowmarkProvider_abqplumb.Unit;
   acerentacar: BowmarkProvider_acerentacar.Unit;
   achosahw: BowmarkProvider_achosahw.Unit;
   acqualinaresort: BowmarkProvider_acqualinaresort.Unit;
+  ai_engineer: BowmarkProvider_ai_engineer.Unit;
   aiper: BowmarkProvider_aiper.Unit;
   ajmadison: BowmarkProvider_ajmadison.Unit;
   allied: BowmarkProvider_allied.Unit;
@@ -31057,10 +32426,12 @@ interface BowmarkProviders {
   artpix3d: BowmarkProvider_artpix3d.Unit;
   ashleyfurniture: BowmarkProvider_ashleyfurniture.Unit;
   asppoolco: BowmarkProvider_asppoolco.Unit;
+  astoundgroup: BowmarkProvider_astoundgroup.Unit;
   atlasoceanvoyages: BowmarkProvider_atlasoceanvoyages.Unit;
   atlasseniorliving: BowmarkProvider_atlasseniorliving.Unit;
   audibel: BowmarkProvider_audibel.Unit;
   autocamp: BowmarkProvider_autocamp.Unit;
+  avalonmalibu_com: BowmarkProvider_avalonmalibu_com.Unit;
   avantstay: BowmarkProvider_avantstay.Unit;
   avis: BowmarkProvider_avis.Unit;
   ayreshotels: BowmarkProvider_ayreshotels.Unit;
@@ -31083,6 +32454,7 @@ interface BowmarkProviders {
   bigjoeforklifts: BowmarkProvider_bigjoeforklifts.Unit;
   bigrentz: BowmarkProvider_bigrentz.Unit;
   bing: BowmarkProvider_bing.Unit;
+  bionicpo: BowmarkProvider_bionicpo.Unit;
   bishops: BowmarkProvider_bishops.Unit;
   blackstoneproducts: BowmarkProvider_blackstoneproducts.Unit;
   blenderseyewear: BowmarkProvider_blenderseyewear.Unit;
@@ -31097,11 +32469,14 @@ interface BowmarkProviders {
   boydsleep: BowmarkProvider_boydsleep.Unit;
   brius: BowmarkProvider_brius.Unit;
   brixton: BowmarkProvider_brixton.Unit;
+  builder_strucsure_com: BowmarkProvider_builder_strucsure_com.Unit;
   bulletproof: BowmarkProvider_bulletproof.Unit;
   bungalow: BowmarkProvider_bungalow.Unit;
   bykoket: BowmarkProvider_bykoket.Unit;
   byltbasics: BowmarkProvider_byltbasics.Unit;
   cabinsforyou: BowmarkProvider_cabinsforyou.Unit;
+  cal_com: BowmarkProvider_cal_com.Unit;
+  calendly: BowmarkProvider_calendly.Unit;
   caliberhealth: BowmarkProvider_caliberhealth.Unit;
   califloors: BowmarkProvider_califloors.Unit;
   camelcamelcamel: BowmarkProvider_camelcamelcamel.Unit;
@@ -31138,7 +32513,10 @@ interface BowmarkProviders {
   cloudflare: BowmarkProvider_cloudflare.Unit;
   clubchampion: BowmarkProvider_clubchampion.Unit;
   code_claude_com: BowmarkProvider_code_claude_com.Unit;
+  compass_living: BowmarkProvider_compass_living.Unit;
+  completehomewarranty_com: BowmarkProvider_completehomewarranty_com.Unit;
   consultnet: BowmarkProvider_consultnet.Unit;
+  costco: BowmarkProvider_costco.Unit;
   couponfollow: BowmarkProvider_couponfollow.Unit;
   credibly_com: BowmarkProvider_credibly_com.Unit;
   cruiselakegeneva: BowmarkProvider_cruiselakegeneva.Unit;
@@ -31177,16 +32555,21 @@ interface BowmarkProviders {
   evolvemedspa: BowmarkProvider_evolvemedspa.Unit;
   executivehomecare: BowmarkProvider_executivehomecare.Unit;
   extraspace: BowmarkProvider_extraspace.Unit;
+  faceforwardaesthetics: BowmarkProvider_faceforwardaesthetics.Unit;
   facerealityskincare: BowmarkProvider_facerealityskincare.Unit;
+  fbsappliance: BowmarkProvider_fbsappliance.Unit;
   fieldstonehomes: BowmarkProvider_fieldstonehomes.Unit;
   firstamericahomes: BowmarkProvider_firstamericahomes.Unit;
   firstdibs: BowmarkProvider_firstdibs.Unit;
+  fitness1440: BowmarkProvider_fitness1440.Unit;
   fivebelow: BowmarkProvider_fivebelow.Unit;
   fivestarbathsolutions: BowmarkProvider_fivestarbathsolutions.Unit;
   flightradar24: BowmarkProvider_flightradar24.Unit;
+  fluencecorp: BowmarkProvider_fluencecorp.Unit;
   ford: BowmarkProvider_ford.Unit;
   formax: BowmarkProvider_formax.Unit;
   forms_hubspot_com: BowmarkProvider_forms_hubspot_com.Unit;
+  fortressbp: BowmarkProvider_fortressbp.Unit;
   fourseasonsyachts: BowmarkProvider_fourseasonsyachts.Unit;
   framebridge: BowmarkProvider_framebridge.Unit;
   fred: BowmarkProvider_fred.Unit;
@@ -31198,12 +32581,17 @@ interface BowmarkProviders {
   github: BowmarkProvider_github.Unit;
   glama: BowmarkProvider_glama.Unit;
   glassesusa: BowmarkProvider_glassesusa.Unit;
+  gobrightwing: BowmarkProvider_gobrightwing.Unit;
+  golf_com: BowmarkProvider_golf_com.Unit;
   goloadup: BowmarkProvider_goloadup.Unit;
   goodway: BowmarkProvider_goodway.Unit;
   google_flights: BowmarkProvider_google_flights.Unit;
+  gostoreit: BowmarkProvider_gostoreit.Unit;
   gotchacovered: BowmarkProvider_gotchacovered.Unit;
   grainger: BowmarkProvider_grainger.Unit;
   grandwelcome: BowmarkProvider_grandwelcome.Unit;
+  greatlakesbrewing: BowmarkProvider_greatlakesbrewing.Unit;
+  greatlakesdentaltech: BowmarkProvider_greatlakesdentaltech.Unit;
   hamptonwaterwine: BowmarkProvider_hamptonwaterwine.Unit;
   handypro: BowmarkProvider_handypro.Unit;
   hansons: BowmarkProvider_hansons.Unit;
@@ -31233,6 +32621,7 @@ interface BowmarkProviders {
   islllc: BowmarkProvider_islllc.Unit;
   istanbulkart: BowmarkProvider_istanbulkart.Unit;
   ivoryhomes: BowmarkProvider_ivoryhomes.Unit;
+  jasmine_dilucci: BowmarkProvider_jasmine_dilucci.Unit;
   jennikayne: BowmarkProvider_jennikayne.Unit;
   joybird: BowmarkProvider_joybird.Unit;
   joycefactorydirect: BowmarkProvider_joycefactorydirect.Unit;
@@ -31247,7 +32636,9 @@ interface BowmarkProviders {
   kitchentuneup: BowmarkProvider_kitchentuneup.Unit;
   kompan: BowmarkProvider_kompan.Unit;
   kuiu: BowmarkProvider_kuiu.Unit;
+  kwworldwide: BowmarkProvider_kwworldwide.Unit;
   labcorp: BowmarkProvider_labcorp.Unit;
+  landmarkhw_com: BowmarkProvider_landmarkhw_com.Unit;
   lasikplus: BowmarkProvider_lasikplus.Unit;
   legacyhomesal: BowmarkProvider_legacyhomesal.Unit;
   linkedin: BowmarkProvider_linkedin.Unit;
@@ -31282,6 +32673,7 @@ interface BowmarkProviders {
   momondo: BowmarkProvider_momondo.Unit;
   mossyoak: BowmarkProvider_mossyoak.Unit;
   muze_gov_tr: BowmarkProvider_muze_gov_tr.Unit;
+  my_auroramedicalspa_com: BowmarkProvider_my_auroramedicalspa_com.Unit;
   myollie: BowmarkProvider_myollie.Unit;
   naic: BowmarkProvider_naic.Unit;
   namecheap: BowmarkProvider_namecheap.Unit;
@@ -31300,6 +32692,7 @@ interface BowmarkProviders {
   outdoorresearch: BowmarkProvider_outdoorresearch.Unit;
   pacificabeauty: BowmarkProvider_pacificabeauty.Unit;
   pacificcompanies: BowmarkProvider_pacificcompanies.Unit;
+  pacificlifestylehomes: BowmarkProvider_pacificlifestylehomes.Unit;
   paypal: BowmarkProvider_paypal.Unit;
   perennialsandsutherland: BowmarkProvider_perennialsandsutherland.Unit;
   pilotprotocol: BowmarkProvider_pilotprotocol.Unit;
@@ -31307,6 +32700,7 @@ interface BowmarkProviders {
   pizzahut: BowmarkProvider_pizzahut.Unit;
   platform_claude_com: BowmarkProvider_platform_claude_com.Unit;
   polymarket: BowmarkProvider_polymarket.Unit;
+  polytex: BowmarkProvider_polytex.Unit;
   poshmark: BowmarkProvider_poshmark.Unit;
   positivegrid: BowmarkProvider_positivegrid.Unit;
   premierbuildings: BowmarkProvider_premierbuildings.Unit;
@@ -31322,6 +32716,7 @@ interface BowmarkProviders {
   revisionskincare: BowmarkProvider_revisionskincare.Unit;
   rishitea: BowmarkProvider_rishitea.Unit;
   ritani: BowmarkProvider_ritani.Unit;
+  rivian: BowmarkProvider_rivian.Unit;
   roofmaxx: BowmarkProvider_roofmaxx.Unit;
   rover: BowmarkProvider_rover.Unit;
   rvshare: BowmarkProvider_rvshare.Unit;
@@ -31351,6 +32746,7 @@ interface BowmarkProviders {
   summerfridaysquiz: BowmarkProvider_summerfridaysquiz.Unit;
   sunhomesaunas: BowmarkProvider_sunhomesaunas.Unit;
   sunlighten: BowmarkProvider_sunlighten.Unit;
+  tagtrans_net: BowmarkProvider_tagtrans_net.Unit;
   tamarackidaho: BowmarkProvider_tamarackidaho.Unit;
   target: BowmarkProvider_target.Unit;
   tatcha: BowmarkProvider_tatcha.Unit;
@@ -31365,14 +32761,18 @@ interface BowmarkProviders {
   titlenine: BowmarkProvider_titlenine.Unit;
   tmobile: BowmarkProvider_tmobile.Unit;
   topviewtix: BowmarkProvider_topviewtix.Unit;
+  totalplastics: BowmarkProvider_totalplastics.Unit;
   travelinsured: BowmarkProvider_travelinsured.Unit;
   trawickinternational: BowmarkProvider_trawickinternational.Unit;
   trektravel: BowmarkProvider_trektravel.Unit;
   trojanstorage: BowmarkProvider_trojanstorage.Unit;
   trophysignaturehomes: BowmarkProvider_trophysignaturehomes.Unit;
+  tryalma_com: BowmarkProvider_tryalma_com.Unit;
+  tweethunter: BowmarkProvider_tweethunter.Unit;
   twiddy: BowmarkProvider_twiddy.Unit;
   uhc_smallbusiness: BowmarkProvider_uhc_smallbusiness.Unit;
   ulrichlifestyle: BowmarkProvider_ulrichlifestyle.Unit;
+  upkeepstl_com: BowmarkProvider_upkeepstl_com.Unit;
   ups: BowmarkProvider_ups.Unit;
   usps: BowmarkProvider_usps.Unit;
   vbt: BowmarkProvider_vbt.Unit;
@@ -31386,6 +32786,7 @@ interface BowmarkProviders {
   walkerhughes: BowmarkProvider_walkerhughes.Unit;
   walmart: BowmarkProvider_walmart.Unit;
   waterfurnace: BowmarkProvider_waterfurnace.Unit;
+  wearehirschfeld: BowmarkProvider_wearehirschfeld.Unit;
   wellfound: BowmarkProvider_wellfound.Unit;
   winestyles: BowmarkProvider_winestyles.Unit;
   xpresswellnessurgentcare: BowmarkProvider_xpresswellnessurgentcare.Unit;
@@ -83153,6 +84554,7 @@ interface BowmarkLibrary {
   restaurant_booking: BowmarkCapability_restaurant_booking.Unit;
   retail: BowmarkCapability_retail.Unit;
   school_shopping_basket: BowmarkCapability_school_shopping_basket.Unit;
+  script_execution: BowmarkCapability_script_execution.Unit;
   search: BowmarkCapability_search.Unit;
   sheds: BowmarkCapability_sheds.Unit;
   shipping: BowmarkCapability_shipping.Unit;