@magicx-eng/ai-autocomplete-vanilla 0.20.2 → 0.21.0

package/README.md

@@ -16,7 +16,8 @@ A framework-agnostic vanilla JS/TypeScript library that provides a guided AI-pow
 - **Client-side filtering** — instant substring filtering on every keystroke
 - **Datepicker** — date parameters are answered with a calendar instead of an option list. Click a day or navigate with the arrow keys; the date is committed the way it would be written — `Tuesday` for a date inside the next week, `March 23` for one later this year, `March 23 2027` for another year. Tapping a committed date re-opens the calendar on the month that text names now — for a weekday name, that is the next such day, not the one originally picked. A parameter whose options are written as spans (`September 11 - October 13`) gets the same calendar answered in two clicks, committed as one range.
 - **Option overrides** — supply the options for a parameter yourself: a fixed list, a computed one, or one fetched from your own search endpoint as the user types
-- **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`
+- **Product strip** — the dropdown renders a horizontal row of product cards below the options, filled by default with the items the `/suggest` response reports as matching the query; plug in your own product search instead with `products`, or turn the strip off with `showProducts: false`
+- **Catalog report** — every response says which of the query's constraints the catalog applied, which it had to drop, and how many items are left, on `customFields` / `custom_fields`
 - **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
@@ -99,7 +100,10 @@ const ac = new AIAutocomplete(container, {
   // this is only for sending the styles somewhere else. See "Shadow DOM".
   styleRoot: undefined,
 
-  // Product strip (opt-in). Omit it and nothing changes: no request, no markup.
+  // Product strip. Shown by default from the items the /suggest response
+  // reports; false renders no strip.
+  showProducts: true,
+  // Custom source for the strip. Omit it and the server's items are shown.
   products: {
     fetch: (query, signal) => myPlatform.search(query, { signal }),
     transform: (raw) => mapToProducts(raw),
@@ -153,10 +157,80 @@ ac.getResult();                // The AutocompleteResult as it stands right now
 
 ### 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.
+The dropdown renders a horizontal row of product cards below the options grid
+whenever it has products to show. By default those are the items the
+`/suggest` response itself reports as matching the query — no configuration,
+no extra request: the cards land in the same state write as the suggestions,
+so what the strip shows and what the pills offer always describe the same
+narrowing.
+
+```ts
+import { AIAutocomplete } from "@magicx-eng/ai-autocomplete-vanilla";
+
+new AIAutocomplete(container, {
+  apiConfig: { apiKey: "..." },
+  // Selection emits — the SDK never navigates.
+  onProductSelect: (product) => {
+    if (product.url) window.location.assign(product.url);   // …or add to cart, or fill the input
+  },
+});
+```
+
+Each server item becomes a `Product` with `id` (the item's stable id), `title`,
+`price` (the item's lowest price, verbatim as the catalog spells it — the
+currency is yours to add), `vendor`, `imageUrl`, and a **relative** `url` of
+`/products/{handle}` — the right link for a widget running on the storefront
+itself. An item the catalog has no handle for gets no `url`: its card is still
+activatable and still emits `onProductSelect`, it just has nothing for
+cmd-click to open. `productFromMatchedItem` / `productsFromCustomFields` are
+exported for a hand-rolled strip that wants the same mapping.
+
+Set `showProducts: false` to render no strip at all. The catalog report
+(below) stays readable either way.
+
+#### The catalog report (`customFields`)
+
+Every response that read the catalog also says what it did with the query, and
+the SDK exposes that as `customFields` on state (and as `custom_fields` on
+`AutocompleteResult`, so `onResult` / `getResult()` carry it too):
+
+```ts
+ac.subscribe((state) => {
+  const report = state.customFields;
+  if (!report) return;                         // no catalog was read for this response
+  count.textContent = `${report.items.total} results`;
+  if (report.dropped_filters.length > 0) {
+    // e.g. { param: "Color", value: "Chartreuse", op: "eq" } — the shopper asked
+    // for a colour no item carries, so the results ignore it. Say so.
+    note.textContent = `No match for ${report.dropped_filters.map((f) => f.value).join(", ")}`;
+  }
+});
+```
+
+- `applied_filters` / `dropped_filters` — the constraints the server read out
+  of the query as `{ param, value, op }` (`op` is one of `eq`, `ne`, `lt`,
+  `lte`, `gt`, `gte`), split into the ones the catalog answered and the ones it
+  could not (a parameter it does not have, a bound that is not a number, a
+  value no item carries). The items answer the applied set, so the dropped
+  list is what tells "87 black t-shirts" from "no black item, so here are
+  t-shirts". Both are always arrays.
+- `items.total` — how many items the applied filters left standing. It also
+  moves with the query's own words, so it drops as a typed word starts
+  matching a title. `items.matched` is the list the strip renders, capped by
+  the server; it is empty (with a non-zero `total`) when nothing narrowed the
+  catalog, where listing arbitrary items as matches would mislead.
+- `null` means the response carried no report — no catalog was read for it
+  (a product with no catalog, the starting state, a response with no
+  option-bearing parameter to offer). That is "no news", not an empty
+  catalog. The strip clears on such a response rather than keeping an older
+  query's items.
+
+#### Your own product search (`products`)
+
+To source the cards from your own search instead — a platform with its own
+endpoint and response shape — set `products`. The SDK owns the UI; you own
+only the fetching and the mapping. The server's items are then not rendered
+(they stay readable on `customFields`).
 
 ```ts
 import { AIAutocomplete, type Product } from "@magicx-eng/ai-autocomplete-vanilla";
@@ -191,20 +265,19 @@ new AIAutocomplete(container, {
     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
+    if (product.url) window.location.assign(product.url);
   },
 });
 ```
 
-`Product` is exactly six fields; only `id`, `title` and `url` are required:
+`Product` is exactly six fields; only `id` and `title` are required:
 
 ```ts
 type Product = {
   id: string;
   title: string;
-  url: string;
+  url?: string;               // absent = a card with no link (still activatable)
   imageUrl?: string | null;   // null renders the placeholder tile
   price?: string;             // pre-formatted by you
   vendor?: string;
@@ -238,7 +311,7 @@ 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]`
+fully under your control. (Angular additionally runs its own `href`
 sanitiser, so unrecognised schemes like `myapp://…` are rewritten to
 `unsafe:…` in that package only.)
 
@@ -248,11 +321,11 @@ 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.
+`update({ products })` swaps the integration and clears the current cards; the
+strip repopulates on the *next* `/suggest` request, since the product search
+rides that one scheduler and changing the config doesn't itself change the
+query. `update({ products: undefined })` hands the strip back to the server's
+items at once, and `update({ showProducts })` empties or restores it at once.
 
 #### Custom submit button
 
@@ -400,7 +473,7 @@ 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.
+The [product strip](#product-strip) works here too: it renders inside the dropdown the library owns, from the server's items by default, and `products` / `showProducts` / `onProductSelect` behave exactly as in Tier 1.
 
 > 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.
 
@@ -482,7 +555,8 @@ unsub();
 | `isSearchingOptions` | `boolean` | True while an [option override](#option-overrides) for the parameter on screen has been asked and hasn't answered. Render the same skeleton you render for `isLoading`; the built-in dropdowns do. |
 | `inSelectionAnimation` | `boolean` | True for the 500 ms after a user-initiated option tap so the press 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`. |
+| `products` | `Product[]` | What the product strip shows: the items the latest response reported as matching the query, or the results of a custom `products` search. See [Product strip](#product-strip) — Tier 3 consumers render their own cards and call `selectProduct(product)` to emit `onProductSelect`. |
+| `customFields` | `CustomFieldsReport \| null` | The catalog report the latest response carried — applied and dropped filters, and the matching items' count and list — or `null` when it carried none. See [The catalog report](#the-catalog-report-customfields). |
 | `isReady` | `boolean` | Server indicates query is complete |
 | `error` | `Error \| null` | Last fetch error |
 
@@ -591,6 +665,7 @@ The structured query as the SDK currently understands it. The same object is pas
 | `completed_params` | `CompletedParam[]` | Filled parameter values in query order, followed by any the user skipped (see below). |
 | `identified_params` | `IdentifiedParam[]` | Parameters the server recognised in the user's own words, as `{ type, value }` — e.g. `{ type: "due_date", value: "Friday" }` when the user typed "by Friday" instead of picking a date. They are not tokenized in `raw_query`, and they are tentative: each response replaces the set, and an entry drops out as soon as its text is edited away. |
 | `is_ready` | `boolean` | Whether the server considers the query complete enough to act on. |
+| `custom_fields?` | `CustomFieldsReport` | What catalog grounding did for the latest applied response, when it read a catalog at all — see [Product strip](#product-strip). `applied_filters` and `dropped_filters` list the query's constraints as `{ param, value, op }`; `items.total` is how many items the applied ones left standing and `items.matched` the ones the strip renders. Absent (no key) when the response carried no report. |
 
 #### Reading the query as it's built
 

package/dist/index.d.mts

@@ -74,12 +74,93 @@ interface AutocompleteResponse {
         input: InputItem[];
         suggestions: Suggestion[];
         is_ready?: boolean;
+        /**
+         * What catalog grounding did for this request. Absent whenever no
+         * catalog was read — see {@link CustomFieldsReport}.
+         */
+        custom_fields?: CustomFieldsReport;
     };
     meta: {
         request_id: string;
         request_at: string;
     };
 }
+/** Comparison an {@link ExpressedFilter} applies to its value. */
+type FilterOp = "eq" | "ne" | "lt" | "lte" | "gt" | "gte";
+/**
+ * One constraint the server read out of the query — a parameter, a value and
+ * how the two compare ("price", "100", "lt").
+ */
+interface ExpressedFilter {
+    param: string;
+    value: string;
+    op: FilterOp;
+}
+/**
+ * One catalog item the query narrowed down to, in the shape needed to render
+ * it. Only `source_id` and `title` are always present.
+ */
+interface MatchedItem {
+    /** Stable identity of the item within the catalog. */
+    source_id: string;
+    /** The item's id in the platform it was imported from, when it has one. */
+    origin_id?: string;
+    title: string;
+    /**
+     * The item's lowest price, verbatim as the catalog spells it ("131.00").
+     * Not formatted for display: the currency is the storefront's to add.
+     */
+    price?: string;
+    vendor?: string;
+    /**
+     * The platform's URL slug for the item, not a URL. The SDK builds a relative
+     * `/products/{handle}` link from it for the product strip, which is right for
+     * a widget running on the storefront itself.
+     */
+    handle?: string;
+    image_url?: string;
+}
+/** The items the applied filters left standing. */
+interface MatchedItems {
+    /**
+     * How many items the query narrowed the catalog to — `matched.length` at
+     * most, and larger when the list was capped. Also counts what the query's own
+     * words matched, so it drops as a typed word starts matching a title.
+     */
+    total: number;
+    /**
+     * The items themselves, capped by the server. Empty with a non-zero `total`
+     * when nothing narrowed the catalog: naming arbitrary items as matches would
+     * be worse than naming none.
+     */
+    matched: MatchedItem[];
+}
+/**
+ * What catalog grounding did for a request, as opposed to what it decided to
+ * ask next.
+ *
+ * Absent from a response whenever no catalog was read: a product with no
+ * catalog, a starting-state response, or a request whose suggestions offer no
+ * option-bearing parameter. Treat absence as "no news", not as an empty
+ * catalog.
+ *
+ * `applied_filters` and `dropped_filters` are what make `items` interpretable:
+ * the items answer the applied set, so without the dropped one "87 black
+ * t-shirts" and "no black item, so here are t-shirts" look identical. Both
+ * lists are always present, so a consumer reads `[]` rather than guarding a
+ * null.
+ */
+interface CustomFieldsReport {
+    /** Constraints the catalog read actually ran under. */
+    applied_filters: ExpressedFilter[];
+    /**
+     * Constraints the query expressed that the catalog could not answer — a
+     * parameter it does not have, a bound that is not a number, or a value no
+     * item carries. `items` were narrowed without them.
+     */
+    dropped_filters: ExpressedFilter[];
+    items: MatchedItems;
+}
 interface CompletedParamState extends CompletedParam {
     id: string;
     text: string;
@@ -205,19 +286,24 @@ type OptionOverrides = Record<string, OptionOverride>;
 /**
  * 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.
+ * Platform-agnostic on purpose: the server's matched items (the default
+ * source) and every custom integration (Shopify search today, others later)
+ * map onto exactly these fields, so the SDK renders one strip regardless of
+ * where the results came from. Only `id` and `title` 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 source 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;
+    /**
+     * Destination for the card's `href`. Absent, the card has no link — it is
+     * still activatable and still emits `onProductSelect`, but cmd-click and
+     * "copy link address" have nothing to open. Selection never navigates; 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. */
@@ -225,9 +311,13 @@ interface Product {
     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.
+ * Custom product-search wiring for the strip. Absent (the default), the strip
+ * shows the items the `/suggest` response itself reports as matching the query
+ * (`custom_fields.items`), with no extra request. Set it to source the cards
+ * from your own search instead: the server's items are then never rendered
+ * (they stay readable on `customFields`), and the SDK fetches through this
+ * config on its own cadence. To render no strip at all, set `showProducts`
+ * to false.
  */
 interface ProductsConfig {
     /**
@@ -289,6 +379,12 @@ interface AutocompleteResult {
     identified_params: IdentifiedParam[];
     /** Whether the server considers the query complete enough to act on. */
     is_ready: boolean;
+    /**
+     * What catalog grounding did for the latest applied response — the filters
+     * it applied and dropped, and the items they left standing. Present only
+     * when that response carried the block; see {@link CustomFieldsReport}.
+     */
+    custom_fields?: CustomFieldsReport;
 }
 
 /** A calendar month on screen. `month` is 0-based, matching `Date#getMonth`. */
@@ -458,12 +554,26 @@ interface CoreInputState {
     } | 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.
+     * What the product strip shows. By default the items the latest `/suggest`
+     * response reported as matching the query (`custom_fields.items.matched`,
+     * mapped onto `Product`), replaced on every response and empty when the
+     * response carried none — so the strip never shows items belonging to an
+     * older query. With `opts.products` configured, the results of the latest
+     * custom search instead, already transformed and capped by its `limit`,
+     * cleared on an empty query and on a failed fetch/transform. Always empty
+     * while `opts.showProducts` is false.
      */
     products: Product[];
+    /**
+     * The catalog grounding report the latest applied response carried, or null
+     * when it carried none. Replaced wholesale per response, so it always
+     * describes the suggestions on screen: which of the query's constraints the
+     * catalog applied, which it had to drop, and how many items (and which) the
+     * applied ones left standing. Null is "no news", not an empty catalog — a
+     * response reads no catalog when it has no option-bearing parameter to
+     * offer. See {@link CustomFieldsReport}.
+     */
+    customFields: CustomFieldsReport | null;
     /**
      * The consumer's {@link OptionSource} request for the pill on screen — the
      * active suggestion, or the completed param being re-edited. `type` is the
@@ -724,10 +834,23 @@ interface CoreOptions {
      */
     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.
+     * When true (default), the dropdown renders a horizontal row of product
+     * cards below the options grid whenever it has products to show: by default
+     * the items the `/suggest` response reports as matching the query, or the
+     * results of a custom `products` search. Set to false to render no strip and
+     * run no custom search; `customFields` stays readable either way.
+     *
+     * Turning it back on restores the server's items at once — they are already
+     * in the store — while a custom `products` config repopulates on the next
+     * request, since its search rides the suggest cadence.
+     */
+    showProducts?: boolean;
+    /**
+     * Custom source for the product strip. Omit it and the strip shows the items
+     * the `/suggest` response itself reports (`custom_fields.items`), with no
+     * extra request. Set it and the dropdown is fed by your own search endpoint
+     * on the SDK's existing fetch cadence instead; the server's items are then
+     * not rendered.
      */
     products?: ProductsConfig;
     /** Called when the user submits (Enter, or the submit button in Tier 1). */
@@ -1669,6 +1792,31 @@ declare function getFooterHint(optionHighlighted: boolean, isInputEmpty: boolean
  */
 declare function toWireIdentifiedParams(params: IdentifiedParamState[]): IdentifiedParam[];
 
+/**
+ * Where the product strip links a server-matched item to. The server ships a
+ * bare `handle` on purpose: the only shop domain it holds is the internal one,
+ * and an absolute link built from it would send a shopper off the storefront
+ * the widget is running on. A relative path resolves against the page the
+ * widget is on, which for a storefront embed is the shop itself.
+ */
+declare const PRODUCT_PATH_PREFIX = "/products/";
+/**
+ * Maps one item the `/suggest` response reported onto the strip's `Product`
+ * shape. Pure, so a Tier 3 consumer rendering its own strip from
+ * `customFields` gets the same cards the built-in one draws.
+ *
+ * An item without a `handle` yields a card without a `url`: still activatable,
+ * still emitting `onProductSelect`, just nothing for cmd-click to open.
+ */
+declare function productFromMatchedItem(item: MatchedItem): Product;
+/**
+ * The strip's contents for a response's catalog report. `null` — no block on
+ * the response — is an empty strip rather than "keep the previous one": the
+ * previous items answered a previous query, and a strip must never show
+ * results belonging to an older one.
+ */
+declare function productsFromCustomFields(report: CustomFieldsReport | null | undefined): Product[];
+
 declare class ModeController {
     private container;
     private mode;
@@ -1730,6 +1878,13 @@ interface SubmitResultExtras {
     identifiedParams?: IdentifiedParamState[];
     /** Server's "query is complete" verdict (`state.isReady`). Default: false. */
     isReady?: boolean;
+    /**
+     * The catalog grounding report the latest response carried
+     * (`state.customFields`). Default: none, and the result then has no
+     * `custom_fields` key at all — mirroring the wire, where the block is absent
+     * rather than null when no catalog was read.
+     */
+    customFields?: CustomFieldsReport | null;
 }
 /**
  * Builds the `AutocompleteResult` handed to `onSubmit` and `onResult`: the
@@ -1743,4 +1898,4 @@ interface SubmitResultExtras {
  */
 declare function buildSubmitResult(text: string, completedParams: CompletedParamState[], skippedParams?: SkippedParamState[], extras?: SubmitResultExtras): 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, DATE_RANGE_META_END, DATE_RANGE_META_START, type DateMonthView, type DateRange, type DateSelection, type FormatType, type IdentifiedParam, type IdentifiedParamState, type InputItem, type LooseDateOptions, ModeController, OPTIONS_GRID_MOBILE_QUERY, OPTION_ENTER_DELAY_VAR, OPTION_ENTER_FADE_MS, OPTION_ENTER_RISE_MS, OPTION_ENTER_RISE_PX, OPTION_ENTER_STAGGER_MS, type OptionOverride, type OptionOverrides, type OptionsGridLayout, type OptionsGridPlan, PLACEHOLDER_FADE_OUT_MS, PLACEHOLDER_LEAVING_ATTR, PLACEHOLDER_SWAP_GAP_MS, PLACEHOLDER_TYPE_MS, PLACEHOLDER_WORD_PAUSE_MS, type Product, type ProductsConfig, RANGE_SEPARATOR, type RecentlySuggested, type RenderMode, SCROLL_ARROW_ATTR, SCROLL_ARROW_BOTTOM_VAR, SCROLL_ARROW_CLASS, SCROLL_ARROW_FADE_MS, SCROLL_ARROW_LABEL, SCROLL_ARROW_SCROLL_IDLE_MS, SCROLL_ARROW_VISIBLE_ATTR, SKIPPED_PARAM_TEXT, type ScrollArrowArgs, type ScrollArrowController, type Segment, type SkippedParamState, type Store, type SubmitResultExtras, type Suggestion, type SuggestionOption, type TaskKind, WEEKDAY_LABELS, addMonths, attachScrollArrow, buildAttributionUrl, buildDateOptions, buildQuery, buildSubmitResult, cellDay, cellIso, computeOptionsGridLayout, createStore, cursorIsAtEnd, dateCellMarks, dateSelectionFor, extractPlainText, formatAbsoluteDate, formatDate, formatDateRange, getCursorOffset, getFooterHint, identifiedParamLabel, isCalendarFormat, isOptionsGridMobileViewport, isoDate, measureOptionsGrid, monthLabel, needsOptionsGridMeasurement, optionEnterDelayMs, optionLabel, optionsEntranceDurationMs, optionsGridTemplateColumns, parseDate, parseLooseDate, parseLooseDateRange, plainTextLength, planOptionsGrid, previousGraphemeBoundary, renderEditableContent, resolveFormatType, resolveIdentifiedDate, sanitizeOptionIconSvg, scrollCaretIntoView, selectedIsoFromText, selectedRangeFor, setCursorOffset, toWireIdentifiedParams, visibleDateRange, 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 CustomFieldsReport, DATE_RANGE_META_END, DATE_RANGE_META_START, type DateMonthView, type DateRange, type DateSelection, type ExpressedFilter, type FilterOp, type FormatType, type IdentifiedParam, type IdentifiedParamState, type InputItem, type LooseDateOptions, type MatchedItem, type MatchedItems, ModeController, OPTIONS_GRID_MOBILE_QUERY, OPTION_ENTER_DELAY_VAR, OPTION_ENTER_FADE_MS, OPTION_ENTER_RISE_MS, OPTION_ENTER_RISE_PX, OPTION_ENTER_STAGGER_MS, type OptionOverride, type OptionOverrides, type OptionsGridLayout, type OptionsGridPlan, PLACEHOLDER_FADE_OUT_MS, PLACEHOLDER_LEAVING_ATTR, PLACEHOLDER_SWAP_GAP_MS, PLACEHOLDER_TYPE_MS, PLACEHOLDER_WORD_PAUSE_MS, PRODUCT_PATH_PREFIX, type Product, type ProductsConfig, RANGE_SEPARATOR, type RecentlySuggested, type RenderMode, SCROLL_ARROW_ATTR, SCROLL_ARROW_BOTTOM_VAR, SCROLL_ARROW_CLASS, SCROLL_ARROW_FADE_MS, SCROLL_ARROW_LABEL, SCROLL_ARROW_SCROLL_IDLE_MS, SCROLL_ARROW_VISIBLE_ATTR, SKIPPED_PARAM_TEXT, type ScrollArrowArgs, type ScrollArrowController, type Segment, type SkippedParamState, type Store, type SubmitResultExtras, type Suggestion, type SuggestionOption, type TaskKind, WEEKDAY_LABELS, addMonths, attachScrollArrow, buildAttributionUrl, buildDateOptions, buildQuery, buildSubmitResult, cellDay, cellIso, computeOptionsGridLayout, createStore, cursorIsAtEnd, dateCellMarks, dateSelectionFor, extractPlainText, formatAbsoluteDate, formatDate, formatDateRange, getCursorOffset, getFooterHint, identifiedParamLabel, isCalendarFormat, isOptionsGridMobileViewport, isoDate, measureOptionsGrid, monthLabel, needsOptionsGridMeasurement, optionEnterDelayMs, optionLabel, optionsEntranceDurationMs, optionsGridTemplateColumns, parseDate, parseLooseDate, parseLooseDateRange, plainTextLength, planOptionsGrid, previousGraphemeBoundary, productFromMatchedItem, productsFromCustomFields, renderEditableContent, resolveFormatType, resolveIdentifiedDate, sanitizeOptionIconSvg, scrollCaretIntoView, selectedIsoFromText, selectedRangeFor, setCursorOffset, toWireIdentifiedParams, visibleDateRange, withSkippedParams };