@bowmark/web 1.21.0 → 1.22.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: 8f74962f532da5df8d2905deb36fe43233b84c4f09f37cb4c76b92a153333d03
-// 46 capabilities, 404 providers, 984 typed functions, 20 refused.
+// Manifest version: 629f1aeb04463086ca99af95377a310bbd807733f6a06b36d16890fbc8e3314d
+// 48 capabilities, 410 providers, 1008 typed functions, 20 refused.
 // 51,715 family members, sharing 2 interface(s) — declared once and pointed at, never repeated per member.
 //
 // REFUSED — these functions are real and callable, and their declared arguments
@@ -36,6 +36,125 @@
 
 
 
+declare namespace BowmarkCapability_booking_links {
+  // ── Booking links — find a person's Calendly or Cal.com link and read its form — the unit's own declarations, verbatim ──
+type BookingPlatform = "calendly" | "cal.com" | "savvycal" | "tidycal" | "zcal" | "hubspot"
+  | "acuity" | "chilipiper" | "google-calendar" | "microsoft-bookings"
+
+// published: READ off a page (foundOn is the citation). archived: read off an old
+// Wayback capture of a page (archivedAt dates it). indexed: Google's site:cal.com search for
+// the name returned it (context quotes the result). name_match: built from the name and
+// it exists — nothing shows the person published it, and a namesake can own it.
+type BookingLinkMethod = "published" | "archived" | "indexed" | "name_match"
+
+interface BookingLinkFinding {
+  url: string
+  platform: BookingPlatform
+  method: BookingLinkMethod        // the strongest way it was found
+  foundBy: BookingLinkMethod[]     // every way it was found
+  foundOn: string | null           // the page it was written on
+  archivedAt: string | null        // YYYY-MM-DD capture date, for "archived"
+  archiveUrl: string | null
+  context: string | null           // the link's anchor text or the words around it
+  ownerName: string | null         // the name the booking page itself shows (name_match)
+  nameConfirmed: boolean           // name_match: page owner carries both names; published/archived: the name is on that page
+}
+
+interface FindBookingLinksInput {
+  name: string          // full name, first and last
+  company?: string       // name or domain — adds "first-company" slugs
+  domain?: string        // their company site: about/team/contact/services pages + homepage scanned
+  github?: string        // a handle READ off a page that names them, never guessed
+  urls?: string[]        // personal site, speaker bio, blog post — any page of theirs
+}
+
+interface FindBookingLinksOptions {
+  archive?: boolean      // read Wayback captures of the domain's about/team/contact pages; default true with a domain
+  search?: boolean       // Google site:cal.com "<name>" via Serper; default true; each search is charged to your account, or send your own key as the x-bowmark-vendor-key-serper header
+  timeoutMs?: number
+}
+
+interface BookingLinkSearch {
+  name: string
+  links: BookingLinkFinding[]   // published first, then archived, then name_match
+  checked: { pagesScanned: number; pagesUnreachable: string[]; archivedPagesRead: number; slugsChecked: string[] }
+  warnings: string[]
+}
+
+interface PublishedBookingLink { url: string; platform: BookingPlatform; context: string; nearbyText: string }
+interface PageScan { url: string; finalUrl: string; status: number; links: PublishedBookingLink[]; warnings: string[] }
+
+interface BookingQuestion { label: string; kind: string; required: boolean; choices: string[] }
+interface BookingEvent { name: string; url: string; description: string | null; durationMinutes: number | null }
+
+interface BookingPage {
+  url: string
+  platform: "calendly" | "cal.com"
+  ownerName: string | null
+  organization: string | null        // the org/team the platform files the account under (Cal.com)
+  avatarUrl: string | null
+  events: BookingEvent[]             // every event a profile lists
+  event: BookingEvent | null         // the event whose form was read; null if several and none named
+  questions: BookingQuestion[]       // everything the form asks
+  qualifyingQuestions: string[]      // the questions beyond name/email/notes — "company", "team size": a sales funnel asks these, a personal chat does not
+  bookable: "open" | "fully_booked" | "closed" | "unknown"   // Cal.com is always "unknown" here; use cal_com.getAvailability
+  nextAvailability: string | null
+  unavailableReason: string | null   // the platform's own words when it cannot be booked
+  warnings: string[]
+}
+
+interface ReadBookingPageOptions { event?: string; timeoutMs?: number }
+
+type CallOptions = {
+  timeoutMs?: number   // per-provider budget in ms, default 30000, clamped to 1000-55000.
+                       // A provider slower than this is DROPPED from the results and
+                       // NAMED in warnings — never silently absent
+}
+
+  /**
+   * Finds the public booking link (Calendly, Cal.com, SavvyCal, HubSpot…) a named person
+   * publishes — on their company's pages, their GitHub, an old archived copy of their site, or
+   * under their own name on Calendly and Cal.com — and reads what the booking form asks and
+   * whether the calendar is open, without booking anything.
+   */
+  interface Unit {
+    /**
+     * Finds a person's public booking links from their name. Runs four searches at once and merges
+     * them, strongest evidence first: links PUBLISHED on their company's
+     * about/team/contact/services pages and homepage, their GitHub profile README, the website
+     * that profile lists and any `urls` of theirs (each with the page it was on and the words
+     * around it); links on ARCHIVED Wayback Machine captures of the company's about/team/contact
+     * pages, dated (catches a link since removed); Cal.com pages Google has INDEXED under their
+     * name (a `site:cal.com "<name>"` Google search through Serper — each search is charged to
+     * your account on Bowmark's key, or send your own as the `x-bowmark-vendor-key-serper` header;
+     * if no key can serve it, it is skipped and named in `warnings`); and their name as a slug on
+     * Calendly and Cal.com, including "first-company" shapes (NAME_MATCH — exists, but a namesake
+     * can own it, so check `ownerName` and tie it to the company). Pass `company` and `domain`
+     * whenever known. Google does not index Calendly pages, so the slug check is the only way to
+     * find those. Never books.
+     */
+    find(person: FindBookingLinksInput, options?: FindBookingLinksOptions): Promise<BookingLinkSearch>;
+
+    /**
+     * Lists every booking link written on one page — hrefs, Cal.com embed buttons
+     * (`data-cal-link`) and plain-text links — with each link's anchor text and the words around
+     * it, ignoring the platforms' own pricing/login/blog pages. Use it on a personal site, a
+     * speaker bio or a newsletter footer.
+     */
+    scanPage(url: string, options?: CallOptions): Promise<PageScan>;
+
+    /**
+     * Reads a Calendly or Cal.com booking page without booking: who owns it, the events it offers,
+     * every question its form asks, `qualifyingQuestions` (anything beyond name/email/notes — a
+     * sales funnel asks for your company, a personal chat does not), and whether it can be booked
+     * (Calendly: open, fully booked, or closed with the platform's own reason). Works on a
+     * fully-booked calendar. A profile with several events returns `event: null` and the list
+     * unless `options.event` names one (slug or part of the name).
+     */
+    read(url: string, options?: ReadBookingPageOptions): Promise<BookingPage>;
+  }
+}
+
 declare namespace BowmarkCapability_bundles {
   // ── Check whether a set of products can be built and bought right now — the unit's own declarations, verbatim ──
 interface BundleItemAvailability {
@@ -291,6 +410,25 @@ type CallOptions = {
   }
 }
 
+declare namespace BowmarkCapability_currency_exchange {
+  // ── Currency exchange — the unit's own declarations, verbatim ──
+interface currency_exchangeResult {
+  rate: number;
+  warnings: string[];
+}
+type CallOptions = {
+  timeoutMs?: number   // per-provider budget in ms, default 30000, clamped to 1000-55000.
+                       // A provider slower than this is DROPPED from the results and
+                       // NAMED in warnings — never silently absent
+}
+
+  /** Get real-time exchange rates between currencies */
+  interface Unit {
+    /** Returns the current exchange rate between two currencies */
+    getRate(from: string, to: string, options?: CallOptions): Promise<currency_exchangeResult>;
+  }
+}
+
 declare namespace BowmarkCapability_custom_sofa_configurator {
   // ── Custom sofa configurator (fabric selection, live pricing) — the unit's own declarations, verbatim ──
 type CustomSofa = {
@@ -4402,11 +4540,59 @@ interface archive_orgAvailability {
   archivedStatus: string | null;     // the original page's own HTTP status when captured
 }
 
+interface archive_orgSnapshotOptions {
+  scope?: "exact" | "prefix";   // default: "prefix" for a bare domain (every page under it), "exact" for a url with a path
+  limit?: number;               // 1-500, default 50 — newest first
+  pathContains?: string[];      // keep only urls whose path contains one of these, e.g. ["about", "team", "contact"]
+}
+
+interface archive_orgSnapshot {
+  timestamp: string;            // YYYYMMDDhhmmss
+  originalUrl: string;
+  archivedUrl: string;          // the browsable capture, web.archive.org/web/<ts>/<url>
+  statusCode: string;
+  mimeType: string;
+}
+
+interface archive_orgSnapshotList {
+  query: string;
+  scope: "exact" | "prefix";
+  snapshots: archive_orgSnapshot[];   // prefix: newest capture of each distinct url; exact: each distinct VERSION of the page
+  warnings: string[];
+}
+
+interface archive_orgSnapshotPage {
+  originalUrl: string;
+  timestamp: string;
+  archivedUrl: string;
+  html: string;                 // the ORIGINAL bytes as captured, without the archive's toolbar or rewritten links
+  warnings: string[];
+}
+
   /**
-   * The Wayback Machine's own public availability lookup — is a site or page archived, and
-   * where.
+   * The Wayback Machine — is a site or page archived, every capture it holds, and the page
+   * itself as it was captured, so a caller can see what a site published before it was changed
+   * or removed.
    */
   interface Unit {
+    /**
+     * Lists what the Wayback Machine has captured, newest first. A bare domain ("humanlayer.dev")
+     * returns the newest capture of every distinct page under it — narrow it with `pathContains:
+     * ["about", "team", "contact"]`. A url with a path returns every distinct VERSION of that one
+     * page, which is the axis that answers "was this ever on the page". Each row carries the
+     * capture timestamp, the original url and its browsable archive url. Use getSnapshot to read
+     * one.
+     */
+    listSnapshots(site: string, opts?: archive_orgSnapshotOptions): Promise<archive_orgSnapshotList>;
+
+    /**
+     * Reads one archived page as it was captured — the original HTML, without the archive's
+     * toolbar or rewritten links — for a url and a `YYYYMMDDhhmmss` timestamp from listSnapshots
+     * (a nearby timestamp is redirected to the closest capture). Use it to find something a page
+     * carried in the past and has since removed.
+     */
+    getSnapshot(url: string, timestamp: string): Promise<archive_orgSnapshotPage>;
+
     /**
      * Checks the Wayback Machine's own public availability endpoint for one site or page — a bare
      * domain ("carpetlandusa.net"), a domain plus path
@@ -5896,15 +6082,17 @@ interface bestbuyProduct {
      * Runs a Best Buy product search the way bestbuy.com's own search box does, via Best Buy's
      * documented Products API, and returns the matching products — name, sale/regular price,
      * online and in-store availability, manufacturer, model number, UPC and review stats.
-     * `pageSize` caps the row count (default 10, Best Buy's own ceiling 100). Requires a Best Buy
-     * developer API key — see this provider's `auth`.
+     * `pageSize` caps the row count (default 10, Best Buy's own ceiling 100). Uses Bowmark's Best
+     * Buy key and charges each request to your account; send your own key as the
+     * `x-bowmark-vendor-key-bestbuy` header instead.
      */
     search(args: string | { query: string; pageSize?: number }): Promise<bestbuyProduct[]>;
 
     /**
      * Looks up one product by Best Buy's own numeric SKU (the id `search`'s rows carry) and
-     * returns its full detail — the same fields as `search`. Requires a Best Buy developer API key
-     * — see this provider's `auth`.
+     * returns its full detail — the same fields as `search`. Uses Bowmark's Best Buy key and
+     * charges each request to your account; send your own key as the
+     * `x-bowmark-vendor-key-bestbuy` header instead.
      */
     getProduct(sku: string | number): Promise<bestbuyProduct>;
   }
@@ -7562,9 +7750,58 @@ interface CalComAvailabilityResult {
   otherEventTypes: CalComEventType[];
 }
 
+interface CalComFormQuestion {
+  label: string;       // what a booker reads
+  name: string;        // Cal.com's own field name ("name", "email", or a custom slug)
+  type: string;        // Cal.com's own type: "name" | "email" | "phone" | "text" | "textarea" | "select" | "radio" | …
+  required: boolean;
+  choices: string[];
+}
+
+interface CalComBookingEvent {
+  title: string;
+  slug: string;
+  url: string;
+  description: string | null;
+  lengthInMinutes: number | null;
+}
+
+interface CalComBookingFormOptions {
+  event?: string;      // which event on a multi-event profile — its slug or part of its title
+}
+
+interface CalComBookingForm {
+  url: string;
+  username: string;
+  eventTypes: CalComEventType[];     // a profile's list; empty when the url already named an event
+  event: CalComBookingEvent | null;  // null when several events exist and none was named
+  ownerName: string | null;
+  organization: string | null;       // the org/team Cal.com itself files the account under
+  avatarUrl: string | null;
+  questions: CalComFormQuestion[];   // only what a booker is shown — hidden and reschedule-only fields dropped
+  warnings: string[];
+}
+
+interface CalComProfileCandidate {
+  slug: string;
+  url: string;                // where the page landed; a one-event profile redirects to that event
+  title: string;              // the page's own <title>
+  ownerName: string | null;   // read off the title
+  nameMatches: boolean;       // ownerName carries BOTH names asked for — a hint, a namesake passes too
+}
+
+interface CalComFindProfilesResult {
+  name: string;
+  company: string | null;
+  slugsChecked: string[];
+  candidates: CalComProfileCandidate[];
+  warnings: string[];
+}
+
   /**
-   * 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.
+   * Cal.com's own public surfaces — find a person's Cal.com page from their name, read the event
+   * types it offers, the questions its booking form asks and who owns it, and the real,
+   * currently-open time slots — no browser, no key.
    */
   interface Unit {
     /**
@@ -7581,6 +7818,28 @@ interface CalComAvailabilityResult {
      * event type and reports the rest in `otherEventTypes`.
      */
     getAvailability(username: string, opts?: CalComAvailabilityOptions): Promise<CalComAvailabilityResult>;
+
+    /**
+     * Reads what a Cal.com booking page will ask before anyone books: the event's
+     * title/description/length, every question on its booking form (only the ones a booker is
+     * actually shown, with choices and whether each is required), the owner's name and avatar, and
+     * the organization or team Cal.com files the account under. Needs no open slot. Takes an event
+     * url ("https://cal.com/alexatallah/15min"), a team or org-subdomain event url, or a profile
+     * url — a profile with several events returns `event: null` and the list unless `opts.event`
+     * names one. Never books anything.
+     */
+    getBookingForm(url: string, opts?: CalComBookingFormOptions): Promise<CalComBookingForm>;
+
+    /**
+     * Finds a person's own Cal.com page from their full name, and optionally their company (pass
+     * it). Checks the slug shapes that measured reliable (first-last, firstlast, lastfirst,
+     * first-company, firstcompany, last-company, and the bare company slug — which often belongs
+     * to a stranger, so read `ownerName`) and returns each page that exists with its own title,
+     * the owner name the title states, and `nameMatches`. A match is a GUESS: a namesake passes,
+     * so tie the page to the company before relying on it. Works on pages no search engine has
+     * indexed.
+     */
+    findProfiles(name: string, company?: string): Promise<CalComFindProfilesResult>;
   }
 }
 
@@ -7629,10 +7888,58 @@ interface CalendlyAvailabilityResult {
   otherEventTypes: CalendlyEventType[];
 }
 
+interface CalendlyFormQuestion {
+  label: string;
+  format: string;     // Calendly's own: "string" | "text" | "phone_number" | "select" | "multi_select" | "radios" | "checkboxes"
+  required: boolean;
+  choices: string[];
+}
+
+interface CalendlyBookingEvent {
+  name: string;
+  slug: string | null;
+  url: string;
+  description: string | null;
+  durationMinutes: number | null;
+}
+
+interface CalendlyBookingFormOptions {
+  event?: string;     // which event on a multi-event profile — its slug or part of its name
+}
+
+interface CalendlyBookingForm {
+  url: string;
+  profileSlug: string | null;         // null for a calendly.com/d/<hash> share link
+  ownerName: string | null;
+  eventTypes: CalendlyEventType[];
+  event: CalendlyBookingEvent | null; // null when several events exist and none was named
+  questions: CalendlyFormQuestion[];  // CUSTOM questions; name + email are always asked on top
+  nextAvailability: string | null;    // null + unavailableReason null = fully booked, not unread
+  unavailableReason: string | null;   // non-null = Calendly says this cannot be booked
+  warnings: string[];
+}
+
+interface CalendlyProfileCandidate {
+  slug: string;
+  url: string;
+  ownerName: string;       // the name the profile itself shows
+  nameMatches: boolean;    // ownerName carries BOTH names asked for — a hint, a namesake passes too
+  timezone: string;
+}
+
+interface CalendlyFindProfilesResult {
+  name: string;
+  company: string | null;
+  slugsChecked: string[];
+  candidates: CalendlyProfileCandidate[];
+  warnings: string[];
+}
+
   /**
-   * 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.
+   * Calendly's own public booking-widget data — find a person's Calendly page from their name,
+   * read the event types it offers, the questions its booking form asks, and the real,
+   * currently-open time slots — read straight off the widget's undocumented JSON endpoints, no
+   * browser, no key.
    */
   interface Unit {
     /**
@@ -7650,6 +7957,29 @@ interface CalendlyAvailabilityResult {
      * first event type and reports the rest in `otherEventTypes`.
      */
     getAvailability(profile: string, opts?: CalendlyAvailabilityOptions): Promise<CalendlyAvailabilityResult>;
+
+    /**
+     * Reads what a Calendly booking page will ask before anyone books: the owner's name, the
+     * event's name/description/duration, every custom form question (with its choices and whether
+     * it is required), the next open time, and Calendly's own reason when the calendar cannot be
+     * booked. Needs no open slot, so it reads a fully-booked calendar too. Takes a profile url
+     * ("https://calendly.com/eric-ciarla"), an event url, or a one-off share link
+     * ("https://calendly.com/d/ctbt-d45-rgb/simbie-ai-demo"). A profile with several events
+     * returns `event: null` and the list unless `opts.event` names one. Never books anything.
+     */
+    getBookingForm(url: string, opts?: CalendlyBookingFormOptions): Promise<CalendlyBookingForm>;
+
+    /**
+     * Finds a person's own Calendly page from their full name, and optionally their company (pass
+     * it — "caleb-firecrawl" is found only by the company shape). Checks the slug shapes that
+     * measured reliable (first-last, firstlast, lastfirst, first-company, firstcompany,
+     * last-company, and the bare company slug — which often belongs to a stranger, so read
+     * `ownerName`) and returns every one that exists with the name the page itself shows and
+     * `nameMatches`. A match is a GUESS: a namesake with the same first and last name passes, so
+     * tie the page to the company before relying on it. Search engines do not index Calendly
+     * pages, so this is the way to find one.
+     */
+    findProfiles(name: string, company?: string): Promise<CalendlyFindProfilesResult>;
   }
 }
 
@@ -10485,6 +10815,19 @@ interface CuriocityListEventsQuery {
   }
 }
 
+declare namespace BowmarkProvider_currency_exchange {
+  // ── ExchangeRate-API — the unit's own declarations, verbatim ──
+interface currency_exchangeRow {
+  rate: number;
+}
+
+  /** Get real-time exchange rates from ExchangeRate-API */
+  interface Unit {
+    /** Returns the current exchange rate between two currencies */
+    getRate(from: string, to: string): Promise<currency_exchangeRow>;
+  }
+}
+
 declare namespace BowmarkProvider_cyberpowerpc {
   // ── CyberPowerPC — the unit's own declarations, verbatim ──
 interface CyberpowerpcConfigurator {
@@ -11025,6 +11368,29 @@ interface DdCartHandoff {
   }
 }
 
+declare namespace BowmarkProvider_dell {
+  // ── Dell — the unit's own declarations, verbatim ──
+interface SearchForumThreadsArgs {
+  query: string;
+}
+
+interface DellForumThread {
+  title: string;
+  url: string;
+  postCount: number;
+}
+
+  /** Search Dell's community forum for discussion threads. */
+  interface Unit {
+    /**
+     * Search Dell community forums for threads matching a query — needs a topic or keywords (e.g.
+     * "storage issues", "laptop battery"), never a bare "search the forum" with nothing to search
+     * for.
+     */
+    searchForumThreads(args: SearchForumThreadsArgs): Promise<DellForumThread[]>;
+  }
+}
+
 declare namespace BowmarkProvider_deltadentalma {
   // ── Delta Dental of Massachusetts — the unit's own declarations, verbatim ──
 // Delta Dental of Massachusetts's OWN shapes — not a capability contract.
@@ -12354,7 +12720,8 @@ interface etsyListing {
      * Searches Etsy's live catalog of active listings by keyword, via Etsy's documented Open API
      * v3, and returns the matching listings — id, title, price, currency, quantity available, tags
      * and the listing's own etsy.com URL. `limit` caps the row count (default 10, Etsy's own
-     * ceiling 100). Requires an Etsy developer API key — see this provider's `auth`.
+     * ceiling 100). Uses Bowmark's Etsy key and charges each request to your account; send your
+     * own key as the `x-bowmark-vendor-key-etsy` header instead.
      */
     search(args: string | { query: string; limit?: number }): Promise<etsyListing[]>;
   }
@@ -14608,6 +14975,19 @@ interface GithubListReleasesResult {
   warnings: string[];
 }
 
+interface GithubProfileReadme {
+  login: string;
+  name: string | null;
+  company: string | null;
+  blog: string | null;            // the website they list on their profile
+  bio: string | null;
+  twitterUsername: string | null;
+  profileUrl: string;
+  readme: string | null;          // the profile README's raw markdown; null when they have none
+  readmeUrl: string | null;
+  warnings: string[];
+}
+
   /**
    * GitHub's own REST API, keyless. Built: a public repo's commit log (sha, author, date,
    * message), paged and windowed; a public repo's release history (tag, name, dates, release
@@ -14639,6 +15019,16 @@ interface GithubListReleasesResult {
      * `releases: []`, not a throw.
      */
     listReleases(owner: string, repo: string, options?: GithubListReleasesOptions): Promise<GithubListReleasesResult>;
+
+    /**
+     * Reads a person's own GitHub profile — display name, company, the website they list, bio, X
+     * handle — and the raw markdown of their profile README (the `<handle>/<handle>` repo GitHub
+     * shows on the profile page), which is where people put a personal site, a booking link or
+     * contact details. Takes a username, `@handle` or github.com url. `readme` is null when they
+     * have no profile README. Unauthenticated calls share GitHub's 60 requests/hour per IP; this
+     * spends two. THROWS on an unknown user or a rate limit.
+     */
+    getProfileReadme(handle: string): Promise<GithubProfileReadme>;
   }
 }
 
@@ -14971,6 +15361,189 @@ interface GooglePriceGraph {
   }
 }
 
+declare namespace BowmarkProvider_google_maps {
+  // ── Google Maps — the unit's own declarations, verbatim ──
+interface GoogleMapsPlace {
+  featureId: string;
+  name: string;
+}
+interface SuggestPlacesArgs {
+  query: string;
+}
+interface SearchPlacesArgs {
+  query: string;
+}
+interface SearchPlacesResult {
+  featureId: string;
+  name: string;
+  address: string;
+  coordinates: { lat: number; lng: number } | null;
+  categories: string[];
+  rating?: number;
+  reviewCount?: number;
+}
+interface GeocodeAddressArgs {
+  address: string;
+}
+interface GeocodeAddressResult {
+  featureId: string;
+  name: string;
+  formattedAddress: string;
+  coordinates: { lat: number; lng: number } | null;
+}
+interface GetPlaceArgs {
+  query: string;
+}
+interface GetPlaceResult {
+  featureId: string;
+  name: string;
+  address: string;
+  coordinates: { lat: number; lng: number } | null;
+  categories: string[];
+  neighborhood?: string;
+  phone?: string;
+  website?: string;
+  rating?: number;
+  reviewCount?: number;
+  hours?: { day: string; hours: string[] }[];
+}
+interface ListReviewsArgs {
+  query: string;
+}
+interface Review {
+  author: string;
+  authorId?: string;
+  rating: number;
+  text: string;
+  relativeDate?: string;
+}
+
+  /**
+   * Local business search on Google Maps — find places by what a person would say, then read the
+   * address, hours, rating, reviews and route. suggestPlaces (autocomplete), searchPlaces (the
+   * door), geocodeAddress, getPlace and listReviews are built; everything else is still a
+   * declared stub.
+   */
+  interface Unit {
+    /**
+     * Google Maps' own autocomplete for a half-typed query — what the search box offers while
+     * somebody types. Returns the completed queries, ready to hand to searchPlaces once it lands.
+     */
+    suggestPlaces(args: SuggestPlacesArgs): Promise<string[]>;
+
+    /**
+     * The door every other Maps function chains off. Takes what a person would say — "coffee shops
+     * in Seattle WA", "pizza near Austin TX" — and returns the ranked places Google shows for it:
+     * feature id, name, address, coordinates and categories, plus rating and review count when the
+     * site's response carries them. The location lives in the query text; Google resolves it from
+     * there rather than from a separate coordinate.
+     */
+    searchPlaces(args: SearchPlacesArgs): Promise<SearchPlacesResult[]>;
+
+    /**
+     * A street address, a city, or a business name in — the matching Google Maps place, its
+     * feature id and its coordinates out. Rides the same door as searchPlaces (a second reading of
+     * the same response), so it only resolves a query that names ONE place; a category or
+     * list-style query throws.
+     */
+    geocodeAddress(args: GeocodeAddressArgs): Promise<GeocodeAddressResult>;
+
+    /**
+     * Everything Google Maps shows on one business's panel — name, full address, coordinates,
+     * category, neighborhood, phone, website, rating, review count and weekly hours, each present
+     * only when the site's own response carried it. A THIRD reading of searchPlaces' door: takes
+     * the same resolving query geocodeAddress does (typically a name plus address, since this does
+     * not take a feature id — measured live, neither the raw id nor a cid string resolves through
+     * this door), and throws when the query names a category or list rather than one business.
+     */
+    getPlace(args: GetPlaceArgs): Promise<GetPlaceResult>;
+
+    /**
+     * The reviews Google Maps shows on a business's own panel — up to 5, each with author, star
+     * rating, review text and the site's own relative date. A FOURTH reading of searchPlaces' door
+     * (the same record getPlace reads, one section further in), not the listugcposts route the
+     * survey planned: that route needed a session token minted by a place-page bootstrap that was
+     * never cracked, but the same reviews the token would have fetched are already sitting in the
+     * panel response. Takes the same resolving query getPlace does. Returns [] for a place with no
+     * reviews rather than throwing; throws only when the query itself does not resolve to one
+     * place.
+     */
+    listReviews(args: ListReviewsArgs): Promise<Review[]>;
+  }
+}
+
+declare namespace BowmarkProvider_google_news {
+  // ── Google News — the unit's own declarations, verbatim ──
+interface GoogleNewsClusterEntry {
+  title: string;
+  link: string;
+  publisher: string;
+}
+interface GoogleNewsArticle {
+  articleId: string;
+  title: string;
+  link: string;
+  publisher: string;
+  publisherUrl: string | null;
+  publishedAt: string | null;
+  cluster: GoogleNewsClusterEntry[];
+}
+interface GoogleNewsSearchResult {
+  query: string;
+  articles: GoogleNewsArticle[];
+}
+interface GoogleNewsTopStories {
+  title: string;
+  clusters: GoogleNewsArticle[];
+}
+interface GoogleNewsTopicHeadlines {
+  section: "World" | "Nation" | "Business" | "Technology" | "Entertainment" | "Sports" | "Science" | "Health";
+  title: string;
+  articles: GoogleNewsArticle[];
+}
+
+  /**
+   * Headlines from every publisher at once — today's top stories as clusters, a section or a
+   * city's local news, and everything indexed about a subject with Google's own when: and site:
+   * operators. searchNews (the door) and topStories are built; everything else is still a
+   * declared stub.
+   */
+  interface Unit {
+    /**
+     * Everything Google News has indexed about a subject, across every publisher at once —
+     * headline, publisher, publication time and the Google News link, newest first. `query` is
+     * exactly what a person would type into Google News' own search box, and Google's own
+     * operators work inside it: `when:1h`/`when:1d`/`when:7d` narrows the window,
+     * `site:reuters.com` pins one publisher, quotes pin a phrase and `(a OR b)` unions two
+     * subjects — measured 2026-09-15: `site:reuters.com tesla` returned 100 items of which 100
+     * carried `<source>Reuters</source>`. This is the provider's main door: a caller holding only
+     * words gets in here. A query that matches nothing returns an empty `articles` array rather
+     * than throwing.
+     */
+    searchNews(query: string): Promise<GoogleNewsSearchResult>;
+
+    /**
+     * What Google News is leading with right now — the front page, as ranked story CLUSTERS rather
+     * than a flat list. Each entry carries the lead headline and publisher plus every other outlet
+     * covering the same story, which is the one thing a single publisher's own feed can never give
+     * a caller asking "what is everyone saying about this today". No arguments: the front page is
+     * the whole ask.
+     */
+    topStories(): Promise<GoogleNewsTopStories>;
+
+    /**
+     * The latest headlines in one of Google News' own eight sections — World, Nation, Business,
+     * Technology, Entertainment, Sports, Science or Health — by section NAME, so a caller who has
+     * only the word "technology" never has to hold an opaque topic id. The name is matched
+     * case-insensitively against the closed list of eight; anything else throws before any request
+     * is made, because an unrecognized section answers 200 with Google News' own app-shell HTML
+     * rather than a 404 (measured 2026-09-15) — reading that as an empty section would be silently
+     * wrong rather than refused.
+     */
+    listTopicHeadlines(section: string): Promise<GoogleNewsTopicHeadlines>;
+  }
+}
+
 declare namespace BowmarkProvider_gostoreit {
   // ── Go Store It — the unit's own declarations, verbatim ──
 interface GetFacilityUnitsArgs { facilityUrl: string; }
@@ -15608,6 +16181,14 @@ interface HavenPricingProgram {
 
 interface HavenPricingProgramsResult { programs: HavenPricingProgram[] }
 
+interface HavenListPricingProgramsResult {
+  property: HavenPropertyDetails;
+  state: string | null;      // read off the caller's own address, e.g. "CA"
+  programs: HavenPricingProgram[]; // filtered to what `state` qualifies for
+}
+
+interface HavenListPricingProgramsArgs { address: string }
+
   /**
    * Haven Energy home battery quoting — read a US address's own property attributes (home size,
    * county, energy-community status) the way Haven's /quote flow does, and read the site's own
@@ -15633,6 +16214,16 @@ interface HavenPricingProgramsResult { programs: HavenPricingProgram[] }
      * county/utility context to narrow to the programs a specific home actually qualifies for.
      */
     getPricingPrograms(): Promise<HavenPricingProgramsResult>;
+
+    /**
+     * One call for the question getPropertyDetails + getPricingPrograms need composing to answer:
+     * which of Haven's active programs does THIS address actually qualify for. Reads the property
+     * attributes and the full program table (the same two live calls the two other functions make)
+     * and filters to the state parsed out of the address string. `state` is null and `programs` is
+     * the full unfiltered table when no 2-letter state code could be read from the address —
+     * Haven's own property-details response never returns one to fall back on.
+     */
+    listPricingPrograms(arg0: HavenListPricingProgramsArgs): Promise<HavenListPricingProgramsResult>;
   }
 }
 
@@ -15697,6 +16288,32 @@ interface HaydenhomesSearchFilters {
   }
 }
 
+declare namespace BowmarkProvider_hccts {
+  // ── hccts.org Online Application Appointment Booking — the unit's own declarations, verbatim ──
+interface ApplicationStatus {
+  available: boolean;
+  formUrl: string;
+  message: string;
+  lastChecked: string;
+}
+
+interface CheckApplicationAvailabilityArgs {
+  refresh?: boolean;
+}
+
+  /**
+   * Checks application availability and appointment scheduling for Highlands' adult education
+   * programs.
+   */
+  interface Unit {
+    /**
+     * Checks if the HCCTS online application form is currently accessible and returns the
+     * application status.
+     */
+    checkApplicationAvailability(args: CheckApplicationAvailabilityArgs): Promise<ApplicationStatus>;
+  }
+}
+
 declare namespace BowmarkProvider_healthcare_gov {
   // ── HealthCare.gov — the unit's own declarations, verbatim ──
 interface healthcare_govPlan {
@@ -19229,12 +19846,14 @@ interface KeepaProduct { asin: string; domainId: number; title: string; csv?: un
 
   /**
    * Keepa's documented Amazon product API — reads a product's native price history and metadata
-   * by ASIN. Requires a caller-provided Keepa API key.
+   * by ASIN. Uses Bowmark's Keepa key and charges each request to your account; send your own
+   * key as the `x-bowmark-vendor-key-keepa` header to spend your own Keepa tokens instead.
    */
   interface Unit {
     /**
      * Reads Keepa's native Amazon product record and compact price-history series for one ASIN.
-     * Requires a caller-provided Keepa API key.
+     * Uses Bowmark's Keepa key and charges each request to your account; send your own key as the
+     * `x-bowmark-vendor-key-keepa` header to spend your own Keepa tokens instead.
      */
     getProduct(args: { asin: string; domain?: number; stats?: number }): Promise<KeepaProductResult>;
   }
@@ -27356,6 +27975,47 @@ interface SemihandmadePriceResult {
   }
 }
 
+declare namespace BowmarkProvider_serper {
+  // ── Serper — the unit's own declarations, verbatim ──
+interface SerperOrganicResult {
+  position: number;
+  title: string;
+  link: string;              // the destination url
+  snippet: string | null;
+  date: string | null;
+}
+
+interface SerperSearchOptions {
+  num?: number;              // 1-100, default 10
+  gl?: string;               // country, e.g. "us"
+  hl?: string;               // language, e.g. "en"
+}
+
+interface SerperSearchResult {
+  query: string;
+  results: SerperOrganicResult[];   // empty only when Google matched nothing
+  credits: number | null;           // Serper credits this search spent
+  warnings: string[];
+}
+
+  /**
+   * Google's own search results as JSON through Serper's API — honours site:, quoted phrases and
+   * every other Google operator, in about a second. Uses Bowmark's Serper key and charges each
+   * search to your account, or your own key sent as the `x-bowmark-vendor-key-serper` header.
+   */
+  interface Unit {
+    /**
+     * Runs a Google search and returns Google's organic results — position, title, destination
+     * url, snippet — with every Google operator honoured. `site:cal.com "Chris Field"` returns
+     * only cal.com pages naming him (cal.com/analytics/quick-chat among them), which is how to
+     * find a page on one site by any words printed on it. An empty `results` is Google matching
+     * nothing. Uses Bowmark's Serper key and charges each search to your account; send your own
+     * key as the `x-bowmark-vendor-key-serper` header to spend your own credits instead.
+     */
+    searchGoogle(query: string, opts?: SerperSearchOptions): Promise<SerperSearchResult>;
+  }
+}
+
 declare namespace BowmarkProvider_sitmeanssit {
   // ── Sit Means Sit — the unit's own declarations, verbatim ──
 interface SitmeanssitLocation {
@@ -32690,6 +33350,7 @@ interface BowmarkProviders {
   cruiselakegeneva: BowmarkProvider_cruiselakegeneva.Unit;
   culturefly: BowmarkProvider_culturefly.Unit;
   curiocity: BowmarkProvider_curiocity.Unit;
+  currency_exchange: BowmarkProvider_currency_exchange.Unit;
   cyberpowerpc: BowmarkProvider_cyberpowerpc.Unit;
   dahlconsulting: BowmarkProvider_dahlconsulting.Unit;
   dansons: BowmarkProvider_dansons.Unit;
@@ -32697,6 +33358,7 @@ interface BowmarkProviders {
   deangroup: BowmarkProvider_deangroup.Unit;
   decked: BowmarkProvider_decked.Unit;
   decksdirect: BowmarkProvider_decksdirect.Unit;
+  dell: BowmarkProvider_dell.Unit;
   deltadentalma: BowmarkProvider_deltadentalma.Unit;
   dentalplans: BowmarkProvider_dentalplans.Unit;
   detailxperts: BowmarkProvider_detailxperts.Unit;
@@ -32754,6 +33416,8 @@ interface BowmarkProviders {
   goloadup: BowmarkProvider_goloadup.Unit;
   goodway: BowmarkProvider_goodway.Unit;
   google_flights: BowmarkProvider_google_flights.Unit;
+  google_maps: BowmarkProvider_google_maps.Unit;
+  google_news: BowmarkProvider_google_news.Unit;
   gostoreit: BowmarkProvider_gostoreit.Unit;
   gotchacovered: BowmarkProvider_gotchacovered.Unit;
   grainger: BowmarkProvider_grainger.Unit;
@@ -32767,6 +33431,7 @@ interface BowmarkProviders {
   hauslabs: BowmarkProvider_hauslabs.Unit;
   havenenergy: BowmarkProvider_havenenergy.Unit;
   haydenhomes: BowmarkProvider_haydenhomes.Unit;
+  hccts: BowmarkProvider_hccts.Unit;
   healthcare_gov: BowmarkProvider_healthcare_gov.Unit;
   heatherwood: BowmarkProvider_heatherwood.Unit;
   hellofresh: BowmarkProvider_hellofresh.Unit;
@@ -32903,6 +33568,7 @@ interface BowmarkProviders {
   selectblinds: BowmarkProvider_selectblinds.Unit;
   sellcell: BowmarkProvider_sellcell.Unit;
   semihandmade: BowmarkProvider_semihandmade.Unit;
+  serper: BowmarkProvider_serper.Unit;
   sitmeanssit: BowmarkProvider_sitmeanssit.Unit;
   sixflags: BowmarkProvider_sixflags.Unit;
   smartsign: BowmarkProvider_smartsign.Unit;
@@ -84690,11 +85356,13 @@ interface BowmarkProviders {
  * `run()` script, and the Proxy over HTTP in a caller's own process. They are
  * generated once precisely so those two cannot drift. */
 interface BowmarkLibrary {
+  booking_links: BowmarkCapability_booking_links.Unit;
   bundles: BowmarkCapability_bundles.Unit;
   cable_railing_quote: BowmarkCapability_cable_railing_quote.Unit;
   cars: BowmarkCapability_cars.Unit;
   costume_size_check: BowmarkCapability_costume_size_check.Unit;
   coworking: BowmarkCapability_coworking.Unit;
+  currency_exchange: BowmarkCapability_currency_exchange.Unit;
   custom_sofa_configurator: BowmarkCapability_custom_sofa_configurator.Unit;
   delivery: BowmarkCapability_delivery.Unit;
   developer_api_key_signup: BowmarkCapability_developer_api_key_signup.Unit;