@bowmark/web 1.18.0 → 1.19.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: 91a69720e3caaa44f20031f9902b213daadc2093c895452fe8b71d88e0c2380c
+// 45 capabilities, 379 providers, 936 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
@@ -2228,18 +2228,48 @@ 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.
    */
   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>;
 
@@ -2611,23 +2641,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 }
-interface InspectedForm { action: string | null; method: string; fields: FormField[] }
-interface FormInspectionResult { url: string; title: string | null; forms: InspectedForm[]; fieldCount: number; warnings: string[] }
+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[]
+}
+
+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 +3366,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; }
@@ -5938,6 +6051,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 {
@@ -5955,13 +6071,40 @@ interface BingNewsSearchResult {
   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
@@ -7187,6 +7330,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.
@@ -12227,6 +12497,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 +12562,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 +12737,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 +12947,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 +13438,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 {
@@ -17583,6 +18065,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 {
@@ -18464,6 +18975,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 {
@@ -25076,6 +25623,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 {
@@ -28353,6 +28946,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 {
@@ -31032,6 +31660,7 @@ 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;
@@ -31102,6 +31731,8 @@ interface BowmarkProviders {
   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;
@@ -31177,16 +31808,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;
@@ -31233,6 +31869,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;
@@ -31248,6 +31885,7 @@ interface BowmarkProviders {
   kompan: BowmarkProvider_kompan.Unit;
   kuiu: BowmarkProvider_kuiu.Unit;
   labcorp: BowmarkProvider_labcorp.Unit;
+  landmarkhw_com: BowmarkProvider_landmarkhw_com.Unit;
   lasikplus: BowmarkProvider_lasikplus.Unit;
   legacyhomesal: BowmarkProvider_legacyhomesal.Unit;
   linkedin: BowmarkProvider_linkedin.Unit;
@@ -31322,6 +31960,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;
@@ -31365,6 +32004,7 @@ 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;