@magicx-eng/ai-autocomplete-vanilla 0.7.0 → 0.9.0

package/README.md

@@ -15,6 +15,7 @@ A framework-agnostic vanilla JS/TypeScript library that provides a guided AI-pow
 - **Keyboard navigation** — arrow keys, enter to submit, tab to autocomplete, backspace to un-bold the last completed param
 - **Client-side filtering** — instant substring filtering on every keystroke
 - **Option overrides** — inject or dynamically generate client-side options per suggestion type
+- **Product strip (opt-in)** — plug in any platform's product search and the dropdown renders a horizontal row of product cards below the options; the SDK owns the UI, your integration owns only `fetch` and `transform`
 - **Controlled & uncontrolled** — works out of the box or integrates with external state
 - **Accessible** — ARIA combobox 1.2 pattern with `role="listbox"`, `aria-activedescendant`
 - **IME-safe** — composition events are buffered so input text is committed once, after composition ends
@@ -87,6 +88,13 @@ const ac = new AIAutocomplete(container, {
   // Focus
   autoFocus: true,           // focus the input on mount (Tier 1 only)
 
+  // Product strip (opt-in). Omit it and nothing changes: no request, no markup.
+  products: {
+    fetch: (query, signal) => myPlatform.search(query, { signal }),
+    transform: (raw) => mapToProducts(raw),
+    limit: 8,
+  },
+
   // Custom submit button (Tier 1 only)
   // - undefined (default): renders the built-in arrow button
   // - null: no submit button at all
@@ -100,6 +108,7 @@ const ac = new AIAutocomplete(container, {
   onParamsChange: (params) => { ... },
   onFocus: () => { ... },
   onBlur: () => { ... },
+  onProductSelect: (product) => { ... },   // see "Product strip"
 
   // Controlled mode
   value: "initial text",
@@ -116,6 +125,7 @@ ac.reset();                    // Clear everything, re-fetch, and start a new se
 ac.destroy();                  // Remove DOM, listeners, timers
 ac.setMode("dark");            // Switch color mode
 ac.update({ animations: false, optionsPosition: "above" });
+ac.selectProduct(product);     // Emit onProductSelect (Tier 3 / custom strips)
 ```
 
 > **Tier 1 auto-resets** after both Enter key and built-in submit-button clicks — your `onSubmit` runs, then the SDK clears the input and starts a new session. You don't need to call `ac.reset()` yourself in Tier 1.
@@ -128,6 +138,109 @@ ac.update({ animations: false, optionsPosition: "above" });
 
 > **Caret placement after a completion** — whenever a completed param is added (by any means — option click, exact-match typing, or re-edit), the caret lands right after the trailing space following the bold so typing can continue immediately. A space is inserted if one wasn't already there.
 
+### Product strip
+
+Opt in with `products` and the dropdown renders a horizontal row of product
+cards below the options grid. Every platform (Shopify today, others later) has
+its own search endpoint and its own response shape, so the SDK owns the UI and
+the integration owns only the fetching and the mapping.
+
+```ts
+import { AIAutocomplete, type Product } from "@magicx-eng/ai-autocomplete-vanilla";
+
+new AIAutocomplete(container, {
+  apiConfig: { apiKey: "..." },
+
+  products: {
+    // You own the request entirely — auth headers, GraphQL body, locale
+    // prefixes, whatever the platform needs. Honour the signal: the SDK aborts
+    // it as soon as a newer query supersedes this one.
+    fetch: (query, signal) =>
+      fetch("/api/2024-10/graphql.json", {
+        method: "POST",
+        headers: { "X-Shopify-Storefront-Access-Token": token },
+        body: JSON.stringify({ query: SEARCH_QUERY, variables: { q: query } }),
+        signal,
+      }).then((r) => r.json()),
+
+    // Pure mapping, kept out of `fetch` so you can unit-test it without a
+    // network. Fold it into `fetch` and return the array if you prefer.
+    transform: (raw) =>
+      raw.data.products.nodes.map((node) => ({
+        id: node.id,
+        title: node.title,
+        url: node.onlineStoreUrl,
+        imageUrl: node.featuredImage?.url ?? null,
+        price: formatMoney(node.priceRange.minVariantPrice),  // you know the currency
+        vendor: node.vendor,
+      })),
+
+    limit: 8,   // applied by the SDK, after transform
+  },
+
+  // Selection emits — the SDK never navigates.
+  onProductSelect: (product) => {
+    window.location.assign(product.url);   // …or add to cart, or fill the input
+  },
+});
+```
+
+`Product` is exactly six fields; only `id`, `title` and `url` are required:
+
+```ts
+type Product = {
+  id: string;
+  title: string;
+  url: string;
+  imageUrl?: string | null;   // null renders the placeholder tile
+  price?: string;             // pre-formatted by you
+  vendor?: string;
+};
+```
+
+**What the SDK guarantees**
+
+- **One fetch cadence.** The product search rides the same debounce, the same
+  `AbortController` and the same version guard as `/suggest` — there is no
+  second timer to drift out of step. A query that never triggers a suggestions
+  request (e.g. one still narrowing the current option list) doesn't trigger a
+  product search either.
+- **Empty queries never reach you.** On mount and after `reset()` the strip
+  simply clears.
+- **Out-of-order responses are dropped.** A slow response for an older query is
+  never rendered over a newer one.
+- **Failure is silent.** A rejected `fetch` or a throwing `transform` clears the
+  strip, logs once, and leaves the suggestions half untouched — no `error`
+  state, no `onError`, no effect on `isLoading`.
+- **The two halves are independent.** The panel opens if *either* has content,
+  so products keep it open when option filtering empties the list, and
+  suggestions render normally when there are no products. `dropdownTrigger`
+  (`manual` / `hidden`) still gates the panel as before — products don't
+  overrule an explicit opt-out of an auto-opening panel.
+
+**Selection and links.** Cards are real `<a href>` elements, so cmd/ctrl-click,
+middle-click and "copy link address" behave natively. A plain left click is
+intercepted (`preventDefault`) and emits `onProductSelect` instead — the SDK
+never navigates on your behalf.
+
+`product.url` is used verbatim — the SDK trusts your `transform` output and
+does not sanitise it, so validate the URL there if the platform response isn't
+fully under your control. (Angular additionally runs its own `[href]`
+sanitiser, so unrecognised schemes like `myapp://…` are rewritten to
+`unsafe:…` in that package only.)
+
+**Accessibility.** The strip is a `role="group"` labelled "Products"; each card
+is a `role="option"` in the tab order, activated with Enter or Space, with a
+visible focus ring. Tabbing into the strip does not close the panel. The row
+scrolls horizontally by trackpad, wheel, touch and keyboard; the page never
+scrolls sideways and the scrollbar chrome is hidden in all engines.
+
+`update({ products })` swaps the integration (and clears the current cards);
+`update({ products: undefined })` turns the strip off. Either way the strip
+repopulates on the *next* `/suggest` request rather than immediately — the
+product search rides that one scheduler, and changing the config doesn't itself
+change the query.
+
 #### Custom submit button
 
 ```ts
@@ -176,6 +289,8 @@ input.addEventListener("blur", () => ac.setFocused(false));
 
 Pills always render inside the dropdown in this mode. The library creates the dropdown DOM inside your container — you just provide the element and wire up your input's events.
 
+The [product strip](#product-strip) works here too: pass `products` / `onProductSelect` exactly as in Tier 1 and the strip renders inside the dropdown the library owns.
+
 > Focus/blur wiring is required when `dropdownTrigger` is `"auto"` (the default) — the dropdown only opens while the input is focused. Without `setFocused()`, the dropdown will never open.
 
 ---
@@ -244,6 +359,7 @@ unsub();
 | `isLoading` | `boolean` | Fetch in progress. The Tier 1 / Tier 2 renderers gate the loading skeleton additionally on `!inSelectionAnimation` and `!editingParam`. |
 | `inSelectionAnimation` | `boolean` | True for the 500 ms after a user-initiated option tap so the streak animation can finish before the dropdown switches to the loading skeleton. |
 | `editingParam` | `CompletedParamState \| null` | When non-null, the user is re-editing a bold completed param; cached options remain visible and the loading skeleton is suppressed. |
+| `products` | `Product[]` | Results of the latest product search (empty unless `products` is configured). See [Product strip](#product-strip) — Tier 3 consumers render their own cards and call `selectProduct(product)` to emit `onProductSelect`. |
 | `isReady` | `boolean` | Server indicates query is complete |
 | `error` | `Error \| null` | Last fetch error |
 
@@ -349,7 +465,9 @@ const offA = ac.on("change", logToAnalytics);
 const offB = ac.on("change", syncToStore);
 ```
 
-Events: `submit`, `error`, `change`, `paramsChange`, `stateChange`, `focus`, `blur`.
+Events: `submit`, `error`, `change`, `paramsChange`, `stateChange`, `focus`, `blur`, `productSelect`.
+
+**Errors in your callbacks are contained.** A listener that throws is logged to the console (once per event per instance) and the remaining listeners still run — the SDK's own state is unaffected, so a bug in one handler can't stall the widget. The same holds for `subscribe()` listeners and `optionOverrides` functions; an override that throws falls back to that suggestion's existing options rather than blanking the list. One exception is deliberate: if an `onSubmit` handler throws, Tier 1 skips its auto-reset so the user's typed query isn't cleared out from under a failed submit.
 
 Constructor callbacks (`onSubmit`, `onChange`, etc.) are registered once at construction as the initial listener for that event. Use `on()` for any additional or replacement listeners. **`update()` does not swap event listeners** — use `on()` for dynamic listener management.
 
@@ -391,6 +509,21 @@ Override these on the container element. All built-in defaults use `:where()` (z
 | `--aia-scrollbar-thumb` | `rgba(0, 0, 0, 0.3)` | `rgba(0, 0, 0, 0.3)` | Color of the option list's scrollbar thumb (Firefox + WebKit). |
 | `--aia-streak-rgb` | `99, 102, 241` | `255, 255, 255` | Comma-separated RGB triplet used to tint the option-selection streak animation (consumed via `rgba(var(--aia-streak-rgb), …)`). |
 | `--aia-streak-glass-bg` | `rgba(99, 102, 241, 0.1)` | `rgba(255, 255, 255, 0.1)` | Background fill for the streak's glass-pill effect. |
+| `--aia-product-card-width` | `116px` | `116px` | Width of a product card in the strip. The media tile is square, so this also sets its height. |
+| `--aia-product-gap` | `8px` | `8px` | Gap between product cards. |
+| `--aia-product-bg` | `transparent` | `transparent` | Product card background. |
+| `--aia-product-bg-active` | `--aia-option-bg` | `--aia-option-bg` | Product card background on hover. |
+| `--aia-product-media-bg` | `--aia-skeleton-bg` | `--aia-skeleton-bg` | Fill behind the product image, and of the placeholder tile when a product has no image. |
+| `--aia-product-placeholder-color` | `--aia-option-color` | `--aia-option-color` | Glyph color of the no-image placeholder tile. |
+| `--aia-product-title-color` | `--aia-option-color-selected` | `--aia-option-color-selected` | Product title text. Follows the option colors by default, so theming the panel moves suggestions and products together. |
+| `--aia-product-price-color` | `--aia-option-color-selected` | `--aia-option-color-selected` | Product price text. |
+| `--aia-product-vendor-color` | `--aia-option-color` | `--aia-option-color` | Product vendor line. |
+| `--aia-product-focus-ring` | `--aia-option-color-selected` | `--aia-option-color-selected` | Focus ring drawn on a keyboard-focused card. |
+| `--aia-products-label-color` | `--aia-option-color` | `--aia-option-color` | "Products" section label. |
+| `--aia-product-title-font-size` | `12px` | `12px` | Product title font size. |
+| `--aia-product-price-font-size` | `11px` | `11px` | Product price font size. |
+| `--aia-product-vendor-font-size` | `10px` | `10px` | Product vendor font size. |
+| `--aia-products-label-font-size` | `11px` | `11px` | Section label font size. |
 | `--aia-skeleton-bg` | `rgba(189, 189, 189, 0.25)` | `#1a1b1d` | Fill color for the loading skeleton bars and the masked text in cached pills/options. |
 
 ### Per-mode Overrides
@@ -424,7 +557,11 @@ For styling beyond the CSS variables, target these stable `data-aia-*` attribute
 | `[data-aia-pill]` | Each unfilled-suggestion pill |
 | `[data-aia-pillbar]` | Pill bar container inside the dropdown |
 | `[data-aia-option]` | Each suggestion option |
-| `[data-aia-dropdown]` | The dropdown root (listbox) |
+| `[data-aia-dropdown]` | The dropdown root (listbox). Carries `data-aia-has-products` while the product strip has cards. |
+| `[data-aia-products]` | Product strip section (label + row) |
+| `[data-aia-products-row]` | The horizontally scrolling row of cards |
+| `[data-aia-product]` | Each product card |
+| `[data-aia-product-placeholder]` | Media tile of a card whose product has no image |
 
 Completed params render as inline `<strong>` elements inside the editor. Override their weight with `[data-aia-input] strong { font-weight: 700; }` (the built-in style uses `:where()` so any consumer selector wins without `!important`).
 

package/dist/index.d.mts

@@ -147,6 +147,66 @@ interface AccessTokenResult {
 }
 type APIConfig = APIKeyConfig | AccessTokenConfig;
 type OptionOverrides = Record<string, (query: string) => SuggestionOption[]>;
+/**
+ * A single product card in the dropdown's product strip.
+ *
+ * Platform-agnostic on purpose: every integration (Shopify today, others
+ * later) maps its own search response onto exactly these fields, so the SDK
+ * renders one strip regardless of where the results came from. Only `id`,
+ * `title` and `url` are required — the card reflows when any of the rest is
+ * missing. Do NOT grow this shape casually; a new field is a new contract
+ * every integration has to satisfy.
+ */
+interface Product {
+    /** Stable identity — used as the render key, so it must be unique per result set. */
+    id: string;
+    title: string;
+    /** Destination for the card's `href`. Selection does not navigate; see `onProductSelect`. */
+    url: string;
+    /** Absent/null renders the placeholder tile — plenty of catalogues have no images. */
+    imageUrl?: string | null;
+    /** Pre-formatted by the integration, which is the side that knows the currency. */
+    price?: string;
+    vendor?: string;
+}
+/**
+ * Opt-in product-search wiring. Absent (the default) means the SDK never
+ * fetches and never renders a strip — behaviour is byte-for-byte what it was
+ * before products existed.
+ */
+interface ProductsConfig {
+    /**
+     * Runs the platform's product search. The integration owns the request
+     * entirely — auth headers, GraphQL body, locale prefixes, whatever the
+     * platform needs — and must honour `signal`: the SDK aborts it the moment a
+     * newer query supersedes this one.
+     *
+     * Called on the SDK's own fetch cadence (the same debounce that drives
+     * `/suggest`), never on a timer of its own, and never with an empty query.
+     */
+    fetch: (query: string, signal: AbortSignal) => Promise<unknown>;
+    /**
+     * Maps the platform's raw payload onto `Product[]`. Kept separate from
+     * `fetch` so integrations can unit-test the mapping without a network; fold
+     * it into `fetch` and return the mapped array if you prefer.
+     *
+     * A throw here is treated exactly like a rejected fetch: the strip clears,
+     * the suggestions half is untouched.
+     *
+     * The output is trusted: `Product.url` goes straight onto the card's `href`
+     * with no sanitisation, and modifier / middle clicks are deliberately left
+     * to the browser. If the platform response is not fully under your control,
+     * validate the URL inside `transform`.
+     *
+     * One cross-framework caveat: Angular's `[href]` binding runs its own URL
+     * sanitiser, so a scheme it doesn't recognise (`myapp://…`) is rewritten to
+     * `unsafe:myapp://…` there while vanilla and React emit it verbatim. Stick
+     * to http/https if the same integration has to serve all three packages.
+     */
+    transform: (raw: unknown) => Product[];
+    /** Optional cap the SDK applies after `transform`. */
+    limit?: number;
+}
 interface AutocompleteResult {
     query: string;
     raw_query: string;
@@ -188,6 +248,13 @@ interface CoreInputState {
         snapshot: Suggestion[];
     } | null;
     suggestions: Suggestion[];
+    /**
+     * Results of the latest product search, already transformed and capped by
+     * `opts.products.limit`. Always empty when `opts.products` is unconfigured.
+     * Cleared on an empty query and on a failed fetch/transform, so the strip
+     * never shows results belonging to an older query.
+     */
+    products: Product[];
     activeDropdownIndex: number;
     newParamId: string | null;
     isLoading: boolean;
@@ -289,6 +356,13 @@ interface CoreOptions {
      * arrow button. Clicks on the provided element bubble up and trigger submit.
      */
     submitButton?: HTMLElement | null;
+    /**
+     * Opt-in product strip. When set, the dropdown renders a horizontal row of
+     * product cards below the options grid, fed by the integration's own search
+     * endpoint on the SDK's existing fetch cadence. Omit it and nothing about
+     * the dropdown changes — no request, no markup, no layout shift.
+     */
+    products?: ProductsConfig;
     onSubmit?: (result: AutocompleteResult) => void;
     onError?: (error: Error) => void;
     onChange?: (text: string) => void;
@@ -298,6 +372,13 @@ interface CoreOptions {
     onFocus?: () => void;
     /** Called when the input loses focus (or `setFocused(false)` is called). */
     onBlur?: () => void;
+    /**
+     * Called when the user activates a product card. The SDK does NOT navigate —
+     * the integration decides what a selection means (open the PDP, add to cart,
+     * fill the input, …). Modifier / middle clicks are left to the browser so
+     * cmd-click and "copy link address" keep working, and don't fire this.
+     */
+    onProductSelect?: (product: Product) => void;
     value?: string;
     completedParams?: CompletedParamState[];
     /**
@@ -318,8 +399,9 @@ type AIAutocompleteEvents = {
     stateChange: [state: CoreState];
     focus: [];
     blur: [];
+    productSelect: [product: Product];
 };
-type CoreUpdateOptions = Partial<Omit<CoreOptions, "onSubmit" | "onError" | "onChange" | "onParamsChange" | "onStateChange" | "onFocus" | "onBlur">>;
+type CoreUpdateOptions = Partial<Omit<CoreOptions, "onSubmit" | "onError" | "onChange" | "onParamsChange" | "onStateChange" | "onFocus" | "onBlur" | "onProductSelect">>;
 declare class AIAutocomplete {
     private inputStore;
     private store;
@@ -328,6 +410,7 @@ declare class AIAutocomplete {
     private fetchController;
     private keyboardController;
     private pillsController;
+    private productsController;
     private reEdit;
     private modeController;
     private container;
@@ -336,6 +419,12 @@ declare class AIAutocomplete {
     private domRefs;
     private dropdownRefs;
     private timers;
+    /** One per instance — see {@link ConsumerBoundary}. Shared by the emitter, `subscribe()` and `optionOverrides`. */
+    private boundary;
+    /** Identity of the raw override record the wrapped copy below was built from. */
+    private rawOverrides;
+    private wrappedOverrides;
+    private subscriberCount;
     private emitter;
     private sessionId;
     private readonly emitSubmit;
@@ -351,15 +440,54 @@ declare class AIAutocomplete {
     setActivePill(index: number): void;
     removeLastParam(): void;
     /**
-     * Backspace inside a completed param: drop the param's "completed" status so
-     * it renders as plain (un-bold) text, AND remove one grapheme before the
-     * caret — same single-character delete a normal Backspace would do. The
-     * remaining text stays in the input so the user can continue editing what
-     * they had typed instead of losing the whole phrase.
+     * Locate the chip whose rendered text covers `offset`.
+     *
+     * Walks the derived `segments` — the exact thing the editor renders — rather
+     * than re-deriving param positions here. That keeps chip hit-testing in step
+     * with `deriveSegments` by construction (including params whose text repeats
+     * earlier in the input, and identified params that had to dodge completed
+     * coverage) instead of hand-mirroring its walk in a third place.
+     *
+     * Both chip kinds are returned: completed and identified render as visually
+     * identical chips, so both must behave atomically under Backspace. Re-edit
+     * remains completed-only — see `startEditingParamAtCaret`.
+     */
+    private findChipSpanAt;
+    /** Drop a located chip from whichever param array owns it. */
+    private withoutChip;
+    /**
+     * Backspace at the caret. A chip is atomic: the caret sits beside it, never
+     * within it, so the two positions mean different things.
+     *
+     * - Caret exactly at the chip's trailing edge (the position a Backspace over
+     *   the following space leaves you in): delete the WHOLE chip, the way a
+     *   chip-style token behaves. Collapses the space seam it leaves behind so
+     *   the surrounding words don't end up double-spaced.
+     * - Caret strictly inside the chip (only reachable by clicking into it):
+     *   drop the param so its text renders plain, and remove one grapheme — the
+     *   user keeps the phrase they had and can edit it by hand.
+     *
+     * Applies to both chip kinds. Completed and identified params render
+     * identically, so they must delete identically; only the array the param is
+     * dropped from differs.
      *
      * Returns true when a param was reconciled (caller should `preventDefault`).
      */
     removeParamAtCaret(offset: number): boolean;
+    /**
+     * ArrowLeft while the caret sits at a completed pill's trailing edge selects
+     * the pill rather than moving the caret into it: re-edit turns on, the pill
+     * renders highlighted, and the dropdown shows its cached options. The caret
+     * stays put at the trailing edge — it never enters the pill.
+     *
+     * Identified chips are excluded: they carry no cached options and are
+     * deliberately not re-editable (see `renderEditable`), even though Backspace
+     * treats them atomically like any other chip.
+     *
+     * Returns true when re-edit started (caller should `preventDefault` so the
+     * browser doesn't step the caret inside the `<strong>`).
+     */
+    startEditingParamAtCaret(offset: number): boolean;
     /**
      * Set the editor caret at the given plain-text offset. Uses the core's own
      * `domRefs.input` in "full" mode; falls back to the wrapper-provided
@@ -378,10 +506,25 @@ declare class AIAutocomplete {
     handleCaretAfterInput(offset: number | null): void;
     handleCaretMove(offset: number | null): void;
     setActiveDropdownIndex(index: number): void;
+    /**
+     * Announce a product selection. The rendered cards call this on activation;
+     * headless consumers rendering their own strip call it themselves.
+     *
+     * Emitting is the entire behaviour — the SDK deliberately does not navigate
+     * to `product.url`, because only the integration knows whether a selection
+     * means "open the PDP", "add to cart" or "drop the title into the input".
+     */
+    selectProduct(product: Product): void;
     handleTextChange(value: string): void;
     handleKeyDown(e: KeyboardEvent): void;
     setFocused(focused: boolean): void;
-    /** Subscribe to state changes. Listener receives the full (input + derived) shape. */
+    /**
+     * Subscribe to state changes. Listener receives the full (input + derived) shape.
+     *
+     * Consumer code, so it gets the same isolation as the `on*` events: a throw
+     * is contained and reported rather than unwinding into the `store.set` that
+     * triggered the notification. See {@link ConsumerBoundary}.
+     */
     subscribe(listener: (state: CoreState) => void): () => void;
     getState(): CoreState;
     get listboxId(): string;
@@ -399,6 +542,24 @@ declare class AIAutocomplete {
     selectOption(option: SuggestionOption): void;
     private startSelectionAnimationTimer;
     private fireTelemetry;
+    /**
+     * `this.opts` with every `optionOverrides` entry wrapped in the instance's
+     * {@link ConsumerBoundary}.
+     *
+     * The derive layer calls these functions on the SDK's stack — from
+     * `getState()`, and from inside the store's notification drain — so an
+     * un-wrapped throw would unwind whatever internal operation triggered the
+     * derive and abort delivery of every queued notification with it, taking the
+     * instance down rather than just the override. Wrapped, a failed override
+     * answers `undefined` and each call site falls back to the server's options.
+     *
+     * Memoized on the raw record's identity so a swapped integration is
+     * re-wrapped while a stable one isn't re-wrapped on every derive. Note
+     * `update({ optionOverrides })` only becomes visible on the next store write
+     * — the derived layer memoizes on inputs identity, and `update` doesn't
+     * invalidate it for this key. Pre-existing, and unchanged by the wrapping.
+     */
+    private deriveOpts;
     private setupContainer;
     private buildAndRenderFull;
     private buildAndRenderDropdown;
@@ -603,4 +764,4 @@ declare function withSkippedParams(completed: CompletedParam[], skipped: Skipped
  */
 declare function buildSubmitResult(text: string, completedParams: CompletedParamState[], skippedParams?: SkippedParamState[]): AutocompleteResult;
 
-export { AIAutocomplete, type APIConfig, type APIKeyConfig, ATTRIBUTION_URL, type AccessTokenConfig, type AccessTokenResult, type AppearanceMode, type AutocompleteRequest, type AutocompleteResponse, type AutocompleteResult, type CompletedParam, type CompletedParamState, type CoreOptions, type CoreState, type IdentifiedParam, type IdentifiedParamState, type InputItem, ModeController, type OptionOverrides, type RecentlySuggested, type RenderMode, SKIPPED_PARAM_TEXT, type Segment, type SkippedParamState, type Store, type Suggestion, type SuggestionOption, type TaskKind, buildAttributionUrl, buildQuery, buildSubmitResult, createStore, cursorIsAtEnd, extractPlainText, getCursorOffset, getFooterHint, plainTextLength, previousGraphemeBoundary, renderEditableContent, setCursorOffset, withSkippedParams };
+export { AIAutocomplete, type APIConfig, type APIKeyConfig, ATTRIBUTION_URL, type AccessTokenConfig, type AccessTokenResult, type AppearanceMode, type AutocompleteRequest, type AutocompleteResponse, type AutocompleteResult, type CompletedParam, type CompletedParamState, type CoreOptions, type CoreState, type IdentifiedParam, type IdentifiedParamState, type InputItem, ModeController, type OptionOverrides, type Product, type ProductsConfig, type RecentlySuggested, type RenderMode, SKIPPED_PARAM_TEXT, type Segment, type SkippedParamState, type Store, type Suggestion, type SuggestionOption, type TaskKind, buildAttributionUrl, buildQuery, buildSubmitResult, createStore, cursorIsAtEnd, extractPlainText, getCursorOffset, getFooterHint, plainTextLength, previousGraphemeBoundary, renderEditableContent, setCursorOffset, withSkippedParams };