@seekora-ai/ui-sdk-react 1.0.0

package/dist/src/index.d.ts

@@ -0,0 +1,2849 @@
+import * as React$1 from 'react';
+import React__default, { ReactNode, CSSProperties } from 'react';
+import { SearchOptions, SearchResponse, SeekoraClient, SearchContext, DataTypesEventPayload } from '@seekora-ai/search-sdk';
+import * as _seekora_ai_ui_sdk_types from '@seekora-ai/ui-sdk-types';
+import { ResultItem, ViewMode, FieldMapping, ThemeConfig, Theme, QuerySuggestionsEventHandlers, HighlightConfig, KeyboardNavConfig, AnimationConfig, QuerySuggestionsClassNames, SuggestionItem as SuggestionItem$2, RecentSearch, DropdownSectionConfig, SuggestionCategory, TrendingSearch, ProductItem, PopularBrand, FilteredTab, QuerySuggestionsVariant, QuerySuggestionsResponse, DropdownRecommendations, TopSearch, RelatedSearch } from '@seekora-ai/ui-sdk-types';
+export { FieldMapping, ResultItem, Theme, ThemeConfig, ViewMode } from '@seekora-ai/ui-sdk-types';
+import { SearchStateManagerConfig, SearchStateManager, HighlightPart, SearchState } from '@seekora-ai/ui-sdk-core';
+export { mergeThemes } from '@seekora-ai/ui-sdk-core';
+
+/**
+ * SearchBar Component
+ *
+ * Interactive search input component with query suggestions support
+ */
+
+interface SearchBarTheme {
+    container?: string;
+    input?: string;
+    inputFocused?: string;
+    suggestionsContainer?: string;
+    suggestionItem?: string;
+    suggestionItemHover?: string;
+    suggestionItemActive?: string;
+    loadingIndicator?: string;
+}
+interface SearchBarProps {
+    placeholder?: string;
+    showSuggestions?: boolean;
+    debounceMs?: number;
+    minQueryLength?: number;
+    maxSuggestions?: number;
+    onSearch?: (query: string, results: any) => void;
+    onQueryChange?: (query: string) => void;
+    onSuggestionSelect?: (suggestion: string) => void;
+    onSearchStateChange?: (state: {
+        results: any;
+        loading: boolean;
+        error: Error | null;
+    }) => void;
+    searchOptions?: Omit<SearchOptions, 'q'>;
+    className?: string;
+    style?: React__default.CSSProperties;
+    theme?: SearchBarTheme;
+    renderSuggestion?: (suggestion: string, index: number) => React__default.ReactNode;
+    renderLoading?: () => React__default.ReactNode;
+}
+declare const SearchBar: React__default.FC<SearchBarProps>;
+
+/**
+ * SearchResults Component
+ *
+ * Displays search results with customizable rendering
+ * Includes keyboard navigation support (arrow keys, Enter to select)
+ */
+
+interface SearchResultsTheme {
+    container?: string;
+    header?: string;
+    resultsList?: string;
+    resultItem?: string;
+    resultItemHover?: string;
+    resultTitle?: string;
+    resultDescription?: string;
+    resultImage?: string;
+    resultPrice?: string;
+    emptyState?: string;
+    loadingState?: string;
+    errorState?: string;
+    pagination?: string;
+}
+interface SearchResultsProps {
+    results?: SearchResponse | null;
+    loading?: boolean;
+    error?: Error | null;
+    onResultClick?: (result: ResultItem, index: number) => void;
+    renderResult?: (result: ResultItem, index: number, isActive?: boolean) => React__default.ReactNode;
+    renderEmpty?: () => React__default.ReactNode;
+    renderLoading?: () => React__default.ReactNode;
+    renderError?: (error: Error) => React__default.ReactNode;
+    className?: string;
+    style?: React__default.CSSProperties;
+    theme?: SearchResultsTheme;
+    itemsPerPage?: number;
+    showPagination?: boolean;
+    /** Display mode: 'list' (default), 'card', or 'grid' */
+    viewMode?: ViewMode;
+    /** Field mapping configuration for extracting data from results */
+    fieldMapping?: FieldMapping;
+    /** Function to extract results array from the response (if custom structure) */
+    extractResults?: (response: any) => any[];
+    /** Enable keyboard navigation (arrow keys, Enter to select) */
+    enableKeyboardNavigation?: boolean;
+    /** Auto-focus the results container */
+    autoFocus?: boolean;
+}
+declare const SearchResults: React__default.FC<SearchResultsProps>;
+
+/**
+ * SearchProvider Component
+ *
+ * Provides Seekora client and context to child components
+ */
+
+interface SearchContextValue {
+    client: SeekoraClient;
+    theme: Theme;
+    enableAnalytics: boolean;
+    autoTrackSearch: boolean;
+    stateManager: SearchStateManager;
+}
+interface SearchProviderProps {
+    client: SeekoraClient;
+    theme?: ThemeConfig;
+    enableAnalytics?: boolean;
+    autoTrackSearch?: boolean;
+    stateManager?: SearchStateManagerConfig;
+    children: ReactNode;
+}
+declare const SearchProvider: React__default.FC<SearchProviderProps>;
+declare const useSearchContext: () => SearchContextValue;
+
+/**
+ * Stats Component
+ *
+ * Displays search statistics (total results, processing time, etc.)
+ */
+
+interface StatsTheme {
+    container?: string;
+    text?: string;
+    highlight?: string;
+    separator?: string;
+}
+interface StatsProps {
+    /** Search results response */
+    results?: SearchResponse | null;
+    /** Custom render function */
+    renderStats?: (stats: {
+        totalResults: number;
+        processingTime?: number;
+        query?: string;
+    }) => React__default.ReactNode;
+    /** Custom className */
+    className?: string;
+    /** Custom styles */
+    style?: React__default.CSSProperties;
+    /** Custom theme */
+    theme?: StatsTheme;
+    /** Show processing time */
+    showProcessingTime?: boolean;
+    /** Show query */
+    showQuery?: boolean;
+    /** Custom separator between stats */
+    separator?: string;
+}
+declare const Stats: React__default.FC<StatsProps>;
+
+/**
+ * Pagination Component
+ *
+ * Displays pagination controls for search results
+ */
+
+interface PaginationTheme {
+    container?: string;
+    list?: string;
+    item?: string;
+    itemActive?: string;
+    itemDisabled?: string;
+    link?: string;
+    ellipsis?: string;
+}
+interface PaginationProps {
+    /** Search results response */
+    results?: SearchResponse | null;
+    /** Current page number (1-indexed) */
+    currentPage?: number;
+    /** Items per page */
+    itemsPerPage?: number;
+    /** Total number of pages */
+    totalPages?: number;
+    /** Callback when page changes */
+    onPageChange?: (page: number) => void;
+    /** Maximum number of page buttons to show */
+    maxPages?: number;
+    /** Show first/last page buttons */
+    showFirstLast?: boolean;
+    /** Show previous/next buttons */
+    showPrevNext?: boolean;
+    /** Custom render function for page button */
+    renderPageButton?: (page: number, isActive: boolean, isDisabled: boolean) => React__default.ReactNode;
+    /** Custom className */
+    className?: string;
+    /** Custom styles */
+    style?: React__default.CSSProperties;
+    /** Custom theme */
+    theme?: PaginationTheme;
+}
+declare const Pagination: React__default.FC<PaginationProps>;
+
+/**
+ * SortBy Component
+ *
+ * Displays sort options for search results
+ * Integrates with SearchStateManager for automatic state sync
+ */
+
+interface SortOption {
+    value: string;
+    label: string;
+}
+interface SortByTheme {
+    container?: string;
+    select?: string;
+    option?: string;
+}
+interface SortByProps {
+    /** Available sort options */
+    options: SortOption[];
+    /** Current sort value (controlled mode - overrides StateManager) */
+    value?: string;
+    /** Default sort value */
+    defaultValue?: string;
+    /** Callback when sort changes */
+    onSortChange?: (value: string) => void;
+    /** Custom render function for select */
+    renderSelect?: (props: {
+        value: string;
+        onChange: (e: React__default.ChangeEvent<HTMLSelectElement>) => void;
+        options: SortOption[];
+    }) => React__default.ReactNode;
+    /** Custom className */
+    className?: string;
+    /** Custom styles */
+    style?: React__default.CSSProperties;
+    /** Custom theme */
+    theme?: SortByTheme;
+    /** Placeholder text */
+    placeholder?: string;
+    /** Whether to sync with SearchStateManager (default: true) */
+    syncWithState?: boolean;
+}
+declare const SortBy: React__default.FC<SortByProps>;
+
+/**
+ * Facets Component
+ *
+ * Displays facet filters for search results
+ */
+
+interface FacetItem {
+    value: string;
+    count: number;
+    selected?: boolean;
+}
+interface Facet {
+    field: string;
+    label?: string;
+    items: FacetItem[];
+}
+interface FacetsTheme {
+    container?: string;
+    facet?: string;
+    facetHeader?: string;
+    facetTitle?: string;
+    facetList?: string;
+    facetItem?: string;
+    facetItemActive?: string;
+    facetItemCount?: string;
+    facetItemLabel?: string;
+    checkbox?: string;
+}
+interface FacetsProps {
+    /** Search results response */
+    results?: SearchResponse | null;
+    /** Custom facets data */
+    facets?: Facet[];
+    /** Callback when facet is selected/deselected */
+    onFacetChange?: (field: string, value: string, selected: boolean) => void;
+    /** Custom render function for facet */
+    renderFacet?: (facet: Facet, index: number) => React__default.ReactNode;
+    /** Custom render function for facet item */
+    renderFacetItem?: (item: FacetItem, facet: Facet, index: number) => React__default.ReactNode;
+    /** Maximum number of items to show per facet */
+    maxItems?: number;
+    /** Show "Show more" button */
+    showMore?: boolean;
+    /** Custom className */
+    className?: string;
+    /** Custom styles */
+    style?: React__default.CSSProperties;
+    /** Custom theme */
+    theme?: FacetsTheme;
+}
+declare const Facets: React__default.FC<FacetsProps>;
+
+/**
+ * CurrentRefinements Component
+ *
+ * Displays currently active filters/refinements with ability to clear them
+ */
+
+interface Refinement {
+    field: string;
+    label?: string;
+    value: string;
+    displayValue?: string;
+}
+interface CurrentRefinementsTheme {
+    container?: string;
+    list?: string;
+    item?: string;
+    label?: string;
+    value?: string;
+    clearButton?: string;
+    clearAllButton?: string;
+}
+interface CurrentRefinementsProps {
+    /** Current refinements */
+    refinements?: Refinement[];
+    /** Callback when a refinement is cleared */
+    onRefinementClear?: (field: string, value: string) => void;
+    /** Callback when all refinements are cleared */
+    onClearAll?: () => void;
+    /** Custom render function for refinement */
+    renderRefinement?: (refinement: Refinement, index: number) => React__default.ReactNode;
+    /** Show "Clear all" button */
+    showClearAll?: boolean;
+    /** Custom className */
+    className?: string;
+    /** Custom styles */
+    style?: React__default.CSSProperties;
+    /** Custom theme */
+    theme?: CurrentRefinementsTheme;
+}
+declare const CurrentRefinements: React__default.FC<CurrentRefinementsProps>;
+
+/**
+ * ClearRefinements Component
+ *
+ * A standalone button to clear all active refinements/filters
+ * Integrates with SearchStateManager for automatic state sync
+ */
+
+interface ClearRefinementsTheme {
+    root?: string;
+    button?: string;
+    buttonDisabled?: string;
+}
+interface ClearRefinementsProps {
+    /** Button text when there are refinements to clear */
+    clearsQuery?: boolean;
+    /** Whether clicking should also clear the search query */
+    resetLabel?: string;
+    /** Button text shown when there are no refinements */
+    disabledLabel?: string;
+    /** Fields to include (if not specified, all fields are included) */
+    includedFields?: string[];
+    /** Fields to exclude from clearing */
+    excludedFields?: string[];
+    /** Callback when refinements are cleared */
+    onClear?: () => void;
+    /** Custom render function */
+    renderButton?: (props: {
+        canClear: boolean;
+        onClick: () => void;
+        disabled: boolean;
+    }) => React__default.ReactNode;
+    /** Custom className */
+    className?: string;
+    /** Custom styles */
+    style?: React__default.CSSProperties;
+    /** Custom theme */
+    theme?: ClearRefinementsTheme;
+    /** Whether to hide when there are no refinements */
+    hideWhenEmpty?: boolean;
+}
+declare const ClearRefinements: React__default.FC<ClearRefinementsProps>;
+
+/**
+ * SearchLayout Component
+ *
+ * Provides a layout structure for search interfaces with sidebar and main content
+ */
+
+interface SearchLayoutTheme {
+    container?: string;
+    sidebar?: string;
+    main?: string;
+    header?: string;
+    footer?: string;
+}
+interface SearchLayoutProps {
+    /** Content to render in the sidebar (filters, facets, etc.) */
+    sidebar?: React__default.ReactNode;
+    /** Content to render in the main area (results, etc.) */
+    children: React__default.ReactNode;
+    /** Header content */
+    header?: React__default.ReactNode;
+    /** Footer content */
+    footer?: React__default.ReactNode;
+    /** Sidebar width */
+    sidebarWidth?: string;
+    /** Custom className */
+    className?: string;
+    /** Custom styles */
+    style?: React__default.CSSProperties;
+    /** Custom theme */
+    theme?: SearchLayoutTheme;
+    /** Show sidebar on mobile */
+    showSidebarOnMobile?: boolean;
+}
+declare const SearchLayout: React__default.FC<SearchLayoutProps>;
+
+/**
+ * RangeInput Component
+ *
+ * Displays a range input for filtering numeric values (e.g., price range)
+ * Integrates with SearchStateManager for automatic state sync
+ */
+
+interface RangeInputTheme {
+    container?: string;
+    label?: string;
+    inputGroup?: string;
+    input?: string;
+    separator?: string;
+    button?: string;
+}
+interface RangeInputProps {
+    /** Field name for the range filter */
+    field: string;
+    /** Label for the range input */
+    label?: string;
+    /** Minimum value */
+    min?: number;
+    /** Maximum value */
+    max?: number;
+    /** Current minimum value (controlled mode) */
+    currentMin?: number;
+    /** Current maximum value (controlled mode) */
+    currentMax?: number;
+    /** Step value for inputs */
+    step?: number;
+    /** Callback when range changes */
+    onRangeChange?: (min: number | undefined, max: number | undefined) => void;
+    /** Custom render function */
+    renderRangeInput?: (props: {
+        min: number | undefined;
+        max: number | undefined;
+        onMinChange: (value: number | undefined) => void;
+        onMaxChange: (value: number | undefined) => void;
+        onApply: () => void;
+    }) => React__default.ReactNode;
+    /** Custom className */
+    className?: string;
+    /** Custom styles */
+    style?: React__default.CSSProperties;
+    /** Custom theme */
+    theme?: RangeInputTheme;
+    /** Show apply button */
+    showApplyButton?: boolean;
+    /** Placeholder text for inputs */
+    placeholder?: {
+        min?: string;
+        max?: string;
+    };
+    /** Whether to sync with SearchStateManager (default: true) */
+    syncWithState?: boolean;
+}
+declare const RangeInput: React__default.FC<RangeInputProps>;
+
+/**
+ * HitsPerPage Component
+ *
+ * A dropdown to let users change the number of displayed hits per page
+ * Integrates with SearchStateManager for automatic state sync
+ */
+
+interface HitsPerPageItem {
+    value: number;
+    label: string;
+    default?: boolean;
+}
+interface HitsPerPageTheme {
+    root?: string;
+    select?: string;
+    option?: string;
+}
+interface HitsPerPageProps {
+    /** Available items per page options */
+    items: HitsPerPageItem[];
+    /** Callback when hits per page changes */
+    onHitsPerPageChange?: (value: number) => void;
+    /** Custom render function for select */
+    renderSelect?: (props: {
+        value: number;
+        onChange: (e: React__default.ChangeEvent<HTMLSelectElement>) => void;
+        items: HitsPerPageItem[];
+    }) => React__default.ReactNode;
+    /** Custom className */
+    className?: string;
+    /** Custom styles */
+    style?: React__default.CSSProperties;
+    /** Custom theme */
+    theme?: HitsPerPageTheme;
+    /** Label text before the select */
+    label?: string;
+    /** Whether to sync with SearchStateManager (default: true) */
+    syncWithState?: boolean;
+}
+declare const HitsPerPage: React__default.FC<HitsPerPageProps>;
+
+/**
+ * InfiniteHits Component
+ *
+ * Displays search results with infinite scroll or "Show More" button
+ * Accumulates results as user loads more pages
+ */
+
+interface InfiniteHitsTheme {
+    root?: string;
+    list?: string;
+    item?: string;
+    loadMore?: string;
+    loadMoreDisabled?: string;
+    loading?: string;
+    empty?: string;
+    sentinel?: string;
+}
+interface InfiniteHitsProps {
+    /** Custom render function for each hit */
+    renderHit?: (hit: ResultItem, index: number) => React__default.ReactNode;
+    /** Custom render for empty state */
+    renderEmpty?: () => React__default.ReactNode;
+    /** Custom render for loading state */
+    renderLoading?: () => React__default.ReactNode;
+    /** Custom render for "Show More" button */
+    renderShowMore?: (props: {
+        isLoading: boolean;
+        isLastPage: boolean;
+        onClick: () => void;
+    }) => React__default.ReactNode;
+    /** Whether to show the "Show More" button (default: true) */
+    showMoreButton?: boolean;
+    /** Whether to use infinite scroll with IntersectionObserver (default: false) */
+    useInfiniteScroll?: boolean;
+    /** Threshold for IntersectionObserver (default: 0.1) */
+    scrollThreshold?: number;
+    /** Field mapping for extracting data from hits */
+    fieldMapping?: FieldMapping;
+    /** Text for "Show More" button */
+    showMoreLabel?: string;
+    /** Text for loading state */
+    loadingLabel?: string;
+    /** Callback when a hit is clicked */
+    onHitClick?: (hit: ResultItem, index: number) => void;
+    /** Custom className */
+    className?: string;
+    /** Custom styles */
+    style?: React__default.CSSProperties;
+    /** Custom theme */
+    theme?: InfiniteHitsTheme;
+    /** Whether to sync with SearchStateManager (default: true) */
+    syncWithState?: boolean;
+}
+declare const InfiniteHits: React__default.FC<InfiniteHitsProps>;
+
+/**
+ * Highlight Component
+ *
+ * Renders highlighted search result text with matching terms emphasized
+ */
+
+interface HighlightTheme {
+    root?: string;
+    highlighted?: string;
+    nonHighlighted?: string;
+}
+interface HighlightProps {
+    /** The search hit containing highlight data */
+    hit: Record<string, any>;
+    /** The attribute to highlight */
+    attribute: string;
+    /** Custom className */
+    className?: string;
+    /** Custom styles */
+    style?: React__default.CSSProperties;
+    /** Custom theme */
+    theme?: HighlightTheme;
+    /** Tag name for root element (default: 'span') */
+    tagName?: keyof JSX.IntrinsicElements;
+    /** Custom render for highlighted parts */
+    renderHighlighted?: (part: HighlightPart, index: number) => React__default.ReactNode;
+    /** Custom render for non-highlighted parts */
+    renderNonHighlighted?: (part: HighlightPart, index: number) => React__default.ReactNode;
+    /** Fallback query for client-side highlighting (when server highlight not available) */
+    query?: string;
+}
+declare const Highlight: React__default.FC<HighlightProps>;
+/**
+ * Snippet Component
+ *
+ * Renders a truncated, highlighted excerpt from search results
+ */
+interface SnippetTheme extends HighlightTheme {
+    ellipsis?: string;
+}
+interface SnippetProps extends Omit<HighlightProps, 'theme'> {
+    /** Maximum length of snippet (default: 100) */
+    maxLength?: number;
+    /** Ellipsis to use when truncating (default: '...') */
+    ellipsis?: string;
+    /** Custom theme */
+    theme?: SnippetTheme;
+}
+declare const Snippet: React__default.FC<SnippetProps>;
+
+/**
+ * HierarchicalMenu Component
+ *
+ * Displays a hierarchical menu for nested category navigation
+ * Example: Electronics > Phones > iPhone
+ */
+
+interface HierarchicalMenuItem {
+    label: string;
+    value: string;
+    count?: number;
+    isRefined?: boolean;
+    data?: HierarchicalMenuItem[];
+}
+interface HierarchicalMenuTheme {
+    root?: string;
+    list?: string;
+    item?: string;
+    itemSelected?: string;
+    itemParent?: string;
+    link?: string;
+    label?: string;
+    count?: string;
+    showMore?: string;
+}
+interface HierarchicalMenuProps {
+    /** Attributes for each level of hierarchy (e.g., ['category.lvl0', 'category.lvl1', 'category.lvl2']) */
+    attributes: string[];
+    /** Separator used in the hierarchical values (default: ' > ') */
+    separator?: string;
+    /** Maximum number of items to show per level (default: 10) */
+    limit?: number;
+    /** Show "Show more" button (default: true) */
+    showMore?: boolean;
+    /** Maximum items when "Show more" is clicked (default: 20) */
+    showMoreLimit?: number;
+    /** Custom render function for items */
+    renderItem?: (item: HierarchicalMenuItem, level: number) => React__default.ReactNode;
+    /** Callback when an item is selected */
+    onSelect?: (value: string, level: number) => void;
+    /** Custom className */
+    className?: string;
+    /** Custom styles */
+    style?: React__default.CSSProperties;
+    /** Custom theme */
+    theme?: HierarchicalMenuTheme;
+    /** Root path (for pre-selecting a category) */
+    rootPath?: string | null;
+    /** Sort by (default: 'name') */
+    sortBy?: 'name' | 'count' | 'isRefined';
+    /** Custom facet data (if not using StateManager) */
+    items?: HierarchicalMenuItem[];
+}
+declare const HierarchicalMenu: React__default.FC<HierarchicalMenuProps>;
+
+/**
+ * RangeSlider Component
+ *
+ * Visual slider for numeric range filtering
+ * Alternative to RangeInput for a more interactive UX
+ */
+
+interface RangeSliderTheme {
+    root?: string;
+    label?: string;
+    slider?: string;
+    track?: string;
+    trackFilled?: string;
+    thumb?: string;
+    values?: string;
+    value?: string;
+}
+interface RangeSliderProps {
+    /** Field name for the range filter */
+    field: string;
+    /** Label for the slider */
+    label?: string;
+    /** Minimum value */
+    min: number;
+    /** Maximum value */
+    max: number;
+    /** Step value (default: 1) */
+    step?: number;
+    /** Current minimum value */
+    currentMin?: number;
+    /** Current maximum value */
+    currentMax?: number;
+    /** Callback when range changes */
+    onRangeChange?: (min: number, max: number) => void;
+    /** Format value for display (default: (v) => v.toString()) */
+    formatValue?: (value: number) => string;
+    /** Custom className */
+    className?: string;
+    /** Custom styles */
+    style?: React__default.CSSProperties;
+    /** Custom theme */
+    theme?: RangeSliderTheme;
+    /** Show current values (default: true) */
+    showValues?: boolean;
+    /** Whether to sync with SearchStateManager (default: true) */
+    syncWithState?: boolean;
+    /** Debounce delay for updates (default: 300ms) */
+    debounceMs?: number;
+}
+declare const RangeSlider: React__default.FC<RangeSliderProps>;
+
+/**
+ * Breadcrumb Component
+ *
+ * Displays the current hierarchical navigation path
+ * Allows users to navigate back to parent categories
+ */
+
+interface BreadcrumbItem {
+    label: string;
+    value: string;
+}
+interface BreadcrumbTheme {
+    root?: string;
+    list?: string;
+    item?: string;
+    link?: string;
+    separator?: string;
+    current?: string;
+}
+interface BreadcrumbProps {
+    /** Attributes for each level of hierarchy */
+    attributes: string[];
+    /** Separator between items (default: ' > ') */
+    separator?: string;
+    /** Root label (default: 'Home') */
+    rootLabel?: string;
+    /** Custom render function for items */
+    renderItem?: (item: BreadcrumbItem, index: number, isLast: boolean) => React__default.ReactNode;
+    /** Custom render for separator */
+    renderSeparator?: () => React__default.ReactNode;
+    /** Callback when an item is clicked */
+    onNavigate?: (item: BreadcrumbItem | null, index: number) => void;
+    /** Custom className */
+    className?: string;
+    /** Custom styles */
+    style?: React__default.CSSProperties;
+    /** Custom theme */
+    theme?: BreadcrumbTheme;
+    /** Custom breadcrumb items (overrides automatic detection) */
+    items?: BreadcrumbItem[];
+}
+declare const Breadcrumb: React__default.FC<BreadcrumbProps>;
+
+/**
+ * MobileFilters Component
+ *
+ * A full-screen filter drawer optimized for mobile devices
+ * Slides in from the side or bottom to display facets and filters
+ */
+
+interface MobileFiltersTheme {
+    overlay?: string;
+    drawer?: string;
+    header?: string;
+    title?: string;
+    closeButton?: string;
+    content?: string;
+    footer?: string;
+    applyButton?: string;
+    clearButton?: string;
+    filterCount?: string;
+}
+interface MobileFiltersProps {
+    /** Whether the drawer is open */
+    isOpen: boolean;
+    /** Callback when drawer should close */
+    onClose: () => void;
+    /** Callback when filters are applied */
+    onApply?: () => void;
+    /** Title text */
+    title?: string;
+    /** Apply button text */
+    applyButtonText?: string;
+    /** Clear button text */
+    clearButtonText?: string;
+    /** Position of the drawer */
+    position?: 'left' | 'right' | 'bottom';
+    /** Children (filter components) */
+    children: React__default.ReactNode;
+    /** Custom className */
+    className?: string;
+    /** Custom theme */
+    theme?: MobileFiltersTheme;
+    /** Show header */
+    showHeader?: boolean;
+    /** Show footer with apply/clear buttons */
+    showFooter?: boolean;
+    /** Show filter count badge */
+    showFilterCount?: boolean;
+    /** Close on backdrop click */
+    closeOnBackdropClick?: boolean;
+    /** Close on escape key */
+    closeOnEscape?: boolean;
+}
+declare const MobileFilters: React__default.FC<MobileFiltersProps>;
+/**
+ * MobileFiltersButton Component
+ *
+ * A button to toggle the MobileFilters drawer
+ */
+interface MobileFiltersButtonProps {
+    /** Callback when clicked */
+    onClick: () => void;
+    /** Button text */
+    text?: string;
+    /** Show filter count */
+    showCount?: boolean;
+    /** Custom className */
+    className?: string;
+    /** Custom styles */
+    style?: React__default.CSSProperties;
+}
+declare const MobileFiltersButton: React__default.FC<MobileFiltersButtonProps>;
+
+/**
+ * Recommendation Components
+ *
+ * Components for displaying product recommendations:
+ * - RelatedProducts: Show related items based on a product
+ * - TrendingItems: Display trending/popular products
+ * - FrequentlyBoughtTogether: Bundle recommendations
+ * - RecentlyViewed: User's recently viewed items
+ */
+
+interface RecommendationItem extends ResultItem {
+    [key: string]: any;
+}
+interface RecommendationTheme {
+    root?: string;
+    title?: string;
+    list?: string;
+    item?: string;
+    image?: string;
+    content?: string;
+    name?: string;
+    price?: string;
+    loading?: string;
+    empty?: string;
+}
+interface BaseRecommendationProps {
+    /** Title for the section */
+    title?: string;
+    /** Maximum items to show */
+    maxItems?: number;
+    /** Custom render function for items */
+    renderItem?: (item: RecommendationItem, index: number) => React__default.ReactNode;
+    /** Callback when item is clicked */
+    onItemClick?: (item: RecommendationItem, index: number) => void;
+    /** Custom className */
+    className?: string;
+    /** Custom styles */
+    style?: React__default.CSSProperties;
+    /** Custom theme */
+    theme?: RecommendationTheme;
+    /** Layout mode */
+    layout?: 'horizontal' | 'grid' | 'list';
+    /** Currency symbol for prices */
+    currencySymbol?: string;
+}
+interface RelatedProductsProps extends BaseRecommendationProps {
+    /** Product ID to get related products for */
+    productId: string;
+    /** Custom items (if not using API) */
+    items?: RecommendationItem[];
+    /** Loading state */
+    loading?: boolean;
+}
+declare const RelatedProducts: React__default.FC<RelatedProductsProps>;
+interface TrendingItemsProps extends BaseRecommendationProps {
+    /** Custom items (if not using API) */
+    items?: RecommendationItem[];
+    /** Loading state */
+    loading?: boolean;
+    /** Facet name for trending (if using facet data) */
+    facetName?: string;
+}
+declare const TrendingItems: React__default.FC<TrendingItemsProps>;
+interface FrequentlyBoughtTogetherProps extends BaseRecommendationProps {
+    /** Product ID to get frequently bought together items for */
+    productId: string;
+    /** Custom items (if not using API) */
+    items?: RecommendationItem[];
+    /** Loading state */
+    loading?: boolean;
+    /** Show "Add all to cart" button */
+    showAddAllButton?: boolean;
+    /** Callback when "Add all" is clicked */
+    onAddAll?: (items: RecommendationItem[]) => void;
+}
+declare const FrequentlyBoughtTogether: React__default.FC<FrequentlyBoughtTogetherProps>;
+interface RecentlyViewedProps extends BaseRecommendationProps {
+    /** Storage key for localStorage */
+    storageKey?: string;
+    /** Custom items (overrides localStorage) */
+    items?: RecommendationItem[];
+}
+declare const RecentlyViewed: React__default.FC<RecentlyViewedProps>;
+/**
+ * Add item to recently viewed (utility function)
+ */
+declare function addToRecentlyViewed(item: RecommendationItem, storageKey?: string, maxItems?: number): void;
+
+/**
+ * QuerySuggestions Component
+ *
+ * Standalone component for displaying query suggestions
+ */
+
+interface SuggestionItem$1 {
+    query: string;
+    count?: number;
+    metadata?: Record<string, any>;
+}
+interface QuerySuggestionsTheme {
+    container?: string;
+    title?: string;
+    suggestionsList?: string;
+    suggestionItem?: string;
+    suggestionItemHover?: string;
+    suggestionItemActive?: string;
+    loadingState?: string;
+    emptyState?: string;
+}
+interface QuerySuggestionsProps {
+    query?: string;
+    maxSuggestions?: number;
+    debounceMs?: number;
+    minQueryLength?: number;
+    onSuggestionClick?: (suggestion: string) => void;
+    renderSuggestion?: (suggestion: SuggestionItem$1, index: number) => React__default.ReactNode;
+    renderLoading?: () => React__default.ReactNode;
+    renderEmpty?: () => React__default.ReactNode;
+    showTitle?: boolean;
+    title?: string;
+    className?: string;
+    style?: React__default.CSSProperties;
+    theme?: QuerySuggestionsTheme;
+}
+declare const QuerySuggestions: React__default.FC<QuerySuggestionsProps>;
+
+/**
+ * QuerySuggestionsDropdown Component
+ *
+ * Classic dropdown variant with:
+ * - Highlighted matches
+ * - Keyboard navigation
+ * - Recent searches
+ * - Customizable styling
+ * - Analytics tracking
+ * - Accessibility support
+ */
+
+interface QuerySuggestionsDropdownProps extends QuerySuggestionsEventHandlers {
+    /** Current query string */
+    query: string;
+    /** Whether the dropdown is visible */
+    isOpen?: boolean;
+    /** Maximum suggestions to display */
+    maxSuggestions?: number;
+    /** Minimum query length to trigger suggestions */
+    minQueryLength?: number;
+    /** Debounce delay in ms */
+    debounceMs?: number;
+    /** Show recent searches section */
+    showRecentSearches?: boolean;
+    /** Maximum recent searches to display */
+    maxRecentSearches?: number;
+    /** Show suggestion counts */
+    showCounts?: boolean;
+    /** Show loading state */
+    showLoading?: boolean;
+    /** Show empty state when no results */
+    showEmptyState?: boolean;
+    /** Highlight configuration */
+    highlight?: HighlightConfig;
+    /** Keyboard navigation configuration */
+    keyboardNav?: KeyboardNavConfig;
+    /** Animation configuration */
+    animation?: AnimationConfig;
+    /** Custom class names */
+    classNames?: QuerySuggestionsClassNames;
+    /** Custom CSS styles */
+    style?: React__default.CSSProperties;
+    /** Custom render for suggestion item */
+    renderSuggestion?: (suggestion: SuggestionItem$2, index: number, isActive: boolean, highlight: (text: string) => React__default.ReactNode) => React__default.ReactNode;
+    /** Custom render for recent search item */
+    renderRecentSearch?: (search: RecentSearch, index: number, isActive: boolean) => React__default.ReactNode;
+    /** Custom render for loading state */
+    renderLoading?: () => React__default.ReactNode;
+    /** Custom render for empty state */
+    renderEmpty?: () => React__default.ReactNode;
+    /** Custom footer content */
+    footer?: React__default.ReactNode;
+    /** Position of dropdown */
+    position?: 'absolute' | 'fixed';
+    /** Dropdown width */
+    width?: string | number;
+    /** Z-index for dropdown */
+    zIndex?: number;
+    /** Input element ref for positioning */
+    inputRef?: React__default.RefObject<HTMLInputElement>;
+    /** Close on click outside */
+    closeOnClickOutside?: boolean;
+    /** Close on escape key */
+    closeOnEscape?: boolean;
+    /** ARIA label */
+    ariaLabel?: string;
+}
+interface QuerySuggestionsDropdownRef {
+    /** Select the currently active item */
+    selectActive: () => void;
+    /** Navigate to next item */
+    navigateNext: () => void;
+    /** Navigate to previous item */
+    navigatePrevious: () => void;
+    /** Reset selection */
+    resetSelection: () => void;
+    /** Get active index */
+    getActiveIndex: () => number;
+    /** Get total items count */
+    getTotalItems: () => number;
+}
+declare const QuerySuggestionsDropdown: React__default.ForwardRefExoticComponent<QuerySuggestionsDropdownProps & React__default.RefAttributes<QuerySuggestionsDropdownRef>>;
+
+/**
+ * RichQuerySuggestions Component
+ *
+ * Advanced multi-section dropdown with:
+ * - Suggestions with categories
+ * - Trending searches
+ * - Recent searches
+ * - Top searches (popular)
+ * - Related searches
+ * - Configurable sections
+ * - Rich styling options
+ */
+
+interface RichQuerySuggestionsProps extends QuerySuggestionsEventHandlers {
+    /** Current query string */
+    query: string;
+    /** Whether the dropdown is visible */
+    isOpen?: boolean;
+    /** Section configuration */
+    sections?: DropdownSectionConfig[];
+    /** Maximum suggestions per section */
+    maxSuggestionsPerSection?: number;
+    /** Minimum query length */
+    minQueryLength?: number;
+    /** Debounce delay in ms */
+    debounceMs?: number;
+    /** Include dropdown recommendations from API */
+    includeDropdownRecommendations?: boolean;
+    /** Include categories in suggestions */
+    includeCategories?: boolean;
+    /** Max categories per suggestion */
+    maxCategories?: number;
+    /** Show suggestion counts */
+    showCounts?: boolean;
+    /** Show category counts */
+    showCategoryCounts?: boolean;
+    /** Show section headers */
+    showSectionHeaders?: boolean;
+    /** Custom class names */
+    classNames?: QuerySuggestionsClassNames;
+    /** Custom CSS styles */
+    style?: React__default.CSSProperties;
+    /** Custom render for suggestion */
+    renderSuggestion?: (suggestion: SuggestionItem$2, isActive: boolean) => React__default.ReactNode;
+    /** Custom render for category pill */
+    renderCategory?: (category: SuggestionCategory) => React__default.ReactNode;
+    /** Custom render for trending item */
+    renderTrendingItem?: (item: TrendingSearch, index: number) => React__default.ReactNode;
+    /** Custom render for recent item */
+    renderRecentItem?: (item: RecentSearch) => React__default.ReactNode;
+    /** Custom header content */
+    header?: React__default.ReactNode;
+    /** Custom footer content */
+    footer?: React__default.ReactNode;
+    /** Dropdown width */
+    width?: string | number;
+    /** Dropdown max height */
+    maxHeight?: string | number;
+    /** Z-index */
+    zIndex?: number;
+    /** ARIA label */
+    ariaLabel?: string;
+    /** Analytics tags */
+    analyticsTags?: string[];
+}
+interface RichQuerySuggestionsRef {
+    getActiveIndex: () => number;
+    setActiveIndex: (index: number) => void;
+    selectActive: () => void;
+    navigateNext: () => void;
+    navigatePrevious: () => void;
+    getTotalItems: () => number;
+}
+declare const RichQuerySuggestions: React__default.ForwardRefExoticComponent<RichQuerySuggestionsProps & React__default.RefAttributes<RichQuerySuggestionsRef>>;
+
+/**
+ * FederatedDropdown Component
+ *
+ * Full-featured federated search dropdown with:
+ * - Multi-column layout (suggestions + products)
+ * - Filtered tabs with product results
+ * - Popular brands
+ * - Trending products
+ * - Category navigation
+ * - Responsive design
+ * - Rich product cards
+ */
+
+interface FederatedDropdownProps extends QuerySuggestionsEventHandlers {
+    /** Current query string */
+    query: string;
+    /** Whether the dropdown is visible */
+    isOpen?: boolean;
+    /** Maximum suggestions to show */
+    maxSuggestions?: number;
+    /** Maximum products to show per section */
+    maxProducts?: number;
+    /** Maximum brands to show */
+    maxBrands?: number;
+    /** Minimum query length */
+    minQueryLength?: number;
+    /** Debounce delay in ms */
+    debounceMs?: number;
+    /** Filtered tabs configuration */
+    filteredTabs?: Array<{
+        id?: string;
+        label: string;
+        filter: string;
+    }>;
+    /** Show products section */
+    showProducts?: boolean;
+    /** Show brands section */
+    showBrands?: boolean;
+    /** Show filtered tabs */
+    showFilteredTabs?: boolean;
+    /** Show recent searches */
+    showRecentSearches?: boolean;
+    /** Layout mode */
+    layout?: 'side-by-side' | 'stacked' | 'full-width';
+    /** Products column width (for side-by-side) */
+    productsColumnWidth?: string;
+    /** Suggestions column width (for side-by-side) */
+    suggestionsColumnWidth?: string;
+    /** Show product prices */
+    showPrices?: boolean;
+    /** Currency symbol */
+    currencySymbol?: string;
+    /** Custom class names */
+    classNames?: QuerySuggestionsClassNames;
+    /** Custom styles */
+    style?: React__default.CSSProperties;
+    /** Custom product card renderer */
+    renderProduct?: (product: ProductItem, index: number) => React__default.ReactNode;
+    /** Custom suggestion renderer */
+    renderSuggestion?: (suggestion: SuggestionItem$2, index: number, isActive: boolean) => React__default.ReactNode;
+    /** Custom brand renderer */
+    renderBrand?: (brand: PopularBrand, index: number) => React__default.ReactNode;
+    /** Custom tab renderer */
+    renderTab?: (tab: FilteredTab, isActive: boolean) => React__default.ReactNode;
+    /** Header content */
+    header?: React__default.ReactNode;
+    /** Footer content */
+    footer?: React__default.ReactNode;
+    /** View all products link */
+    viewAllProductsLink?: string;
+    /** Width */
+    width?: string | number;
+    /** Max height */
+    maxHeight?: string | number;
+    /** Z-index */
+    zIndex?: number;
+    /** Analytics tags */
+    analyticsTags?: string[];
+}
+interface FederatedDropdownRef {
+    getActiveIndex: () => number;
+    setActiveIndex: (index: number) => void;
+    selectActive: () => void;
+    navigateNext: () => void;
+    navigatePrevious: () => void;
+    getActiveTab: () => string | null;
+    setActiveTab: (tabId: string) => void;
+}
+declare const FederatedDropdown: React__default.ForwardRefExoticComponent<FederatedDropdownProps & React__default.RefAttributes<FederatedDropdownRef>>;
+
+/**
+ * SearchBarWithSuggestions Component
+ *
+ * Integrated search bar with query suggestions dropdown.
+ * Combines SearchBar with any of the suggestion dropdown variants.
+ */
+
+interface SearchBarWithSuggestionsProps {
+    /** Dropdown variant to use */
+    variant?: QuerySuggestionsVariant;
+    /** Placeholder text */
+    placeholder?: string;
+    /** Initial query value */
+    initialQuery?: string;
+    /** Controlled query value */
+    value?: string;
+    /** Callback when query changes */
+    onQueryChange?: (query: string) => void;
+    /** Callback when search is submitted */
+    onSearch?: (query: string) => void;
+    /** Callback when suggestion is selected */
+    onSuggestionSelect?: (suggestion: SuggestionItem$2) => void;
+    /** Callback when product is clicked */
+    onProductClick?: (product: ProductItem) => void;
+    /** Show search button */
+    showSearchButton?: boolean;
+    /** Search button text */
+    searchButtonText?: string;
+    /** Show clear button */
+    showClearButton?: boolean;
+    /** Auto focus on mount */
+    autoFocus?: boolean;
+    /** Min query length for suggestions */
+    minQueryLength?: number;
+    /** Max suggestions to show */
+    maxSuggestions?: number;
+    /** Debounce delay (ms) */
+    debounceMs?: number;
+    /** Show recent searches */
+    showRecentSearches?: boolean;
+    /** Show trending when empty */
+    showTrendingOnEmpty?: boolean;
+    /** Include dropdown recommendations */
+    includeDropdownRecommendations?: boolean;
+    /** Filtered tabs config */
+    filteredTabs?: Array<{
+        id?: string;
+        label: string;
+        filter: string;
+    }>;
+    /** Enable analytics tracking */
+    enableAnalytics?: boolean;
+    /** Analytics tags */
+    analyticsTags?: string[];
+    /** Dropdown width */
+    dropdownWidth?: string | number;
+    /** Dropdown max height */
+    dropdownMaxHeight?: string | number;
+    /** Custom class names */
+    classNames?: {
+        wrapper?: string;
+        input?: string;
+        button?: string;
+        clearButton?: string;
+        dropdown?: string;
+    } & QuerySuggestionsClassNames;
+    /** Custom styles */
+    style?: React__default.CSSProperties;
+    /** Input style */
+    inputStyle?: React__default.CSSProperties;
+    /** ARIA label */
+    ariaLabel?: string;
+}
+interface SearchBarWithSuggestionsRef {
+    /** Focus the input */
+    focus: () => void;
+    /** Blur the input */
+    blur: () => void;
+    /** Clear the input */
+    clear: () => void;
+    /** Get current query */
+    getQuery: () => string;
+    /** Set query value */
+    setQuery: (query: string) => void;
+    /** Open dropdown */
+    openDropdown: () => void;
+    /** Close dropdown */
+    closeDropdown: () => void;
+    /** Navigate to next suggestion */
+    navigateNext: () => void;
+    /** Navigate to previous suggestion */
+    navigatePrevious: () => void;
+    /** Select current suggestion */
+    selectCurrent: () => void;
+}
+declare const SearchBarWithSuggestions: React__default.ForwardRefExoticComponent<SearchBarWithSuggestionsProps & React__default.RefAttributes<SearchBarWithSuggestionsRef>>;
+
+/**
+ * Shared Types for Query Suggestions Components
+ *
+ * Data-agnostic types that allow clients to map their own field names
+ */
+
+/** Maps client's data fields to component expected fields */
+interface SuggestionFieldMapping {
+    /** Field path for suggestion text (e.g., "query", "searchTerm", "text") */
+    query: string;
+    /** Field path for suggestion count/popularity */
+    count?: string;
+    /** Field path for object ID */
+    id?: string;
+    /** Field path for categories array */
+    categories?: string;
+    /** Field path for highlighted text */
+    highlighted?: string;
+    /** Custom field mappings */
+    custom?: Record<string, string>;
+}
+/** Maps client's product fields to component expected fields */
+interface ProductFieldMapping {
+    /** Field path for product ID */
+    id: string;
+    /** Field path for product title/name */
+    title: string;
+    /** Field path for product image URL */
+    image?: string;
+    /** Field path for product price */
+    price?: string;
+    /** Field path for original/compare price */
+    comparePrice?: string;
+    /** Field path for product URL */
+    url?: string;
+    /** Field path for brand name */
+    brand?: string;
+    /** Field path for category */
+    category?: string;
+    /** Field path for rating */
+    rating?: string;
+    /** Field path for review count */
+    reviewCount?: string;
+    /** Field path for discount percentage */
+    discount?: string;
+    /** Field path for availability/in stock */
+    inStock?: string;
+    /** Field path for currency */
+    currency?: string;
+    /** Custom field mappings */
+    custom?: Record<string, string>;
+}
+/** Maps client's category/tab fields */
+interface CategoryFieldMapping {
+    id: string;
+    label: string;
+    count?: string;
+    icon?: string;
+    image?: string;
+}
+/** Maps client's brand fields */
+interface BrandFieldMapping {
+    id?: string;
+    name: string;
+    logo?: string;
+    count?: string;
+}
+type DropdownLayout = 'list' | 'two-column' | 'three-column' | 'grid' | 'hero' | 'full-width' | 'mobile-sheet' | 'overlay';
+type ProductCardSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+type ProductCardStyle = 'minimal' | 'standard' | 'detailed' | 'compact' | 'horizontal';
+/** Available dropdown variants */
+type SuggestionDropdownVariant$1 = 'amazon' | 'google' | 'pinterest' | 'spotlight' | 'shopify' | 'mobile-sheet' | 'minimal';
+interface VisualConfig {
+    /** Overall dropdown layout */
+    layout?: DropdownLayout;
+    /** Show/hide shadows */
+    shadows?: boolean;
+    /** Border radius (px or CSS value) */
+    borderRadius?: number | string;
+    /** Animation style */
+    animation?: 'none' | 'fade' | 'slide' | 'scale' | 'spring';
+    /** Animation duration in ms */
+    animationDuration?: number;
+    /** Blur background when open */
+    backdropBlur?: boolean;
+    /** Show dividers between sections */
+    showDividers?: boolean;
+    /** Compact mode (reduced padding) */
+    compact?: boolean;
+}
+type SectionType = 'suggestions' | 'recent' | 'trending' | 'products' | 'categories' | 'brands' | 'collections' | 'pages' | 'custom';
+interface SectionConfig {
+    /** Section identifier */
+    id: SectionType | string;
+    /** Section title (can be ReactNode for custom rendering) */
+    title?: string | ReactNode;
+    /** Whether section is enabled */
+    enabled?: boolean;
+    /** Maximum items to show */
+    maxItems?: number;
+    /** Section display order (lower = higher) */
+    order?: number;
+    /** Section-specific layout override */
+    layout?: 'list' | 'grid' | 'horizontal-scroll' | 'chips';
+    /** Number of columns for grid layout */
+    columns?: number;
+    /** Show "View All" link */
+    showViewAll?: boolean;
+    /** View All link URL or handler */
+    viewAllLink?: string;
+    /** Custom CSS class */
+    className?: string;
+    /** Custom styles */
+    style?: CSSProperties;
+    /** Custom renderer for entire section */
+    render?: (data: any[], config: SectionConfig) => ReactNode;
+    /** Custom renderer for individual items */
+    renderItem?: (item: any, index: number) => ReactNode;
+    /** Empty state message */
+    emptyMessage?: string;
+    /** Icon for section header */
+    icon?: ReactNode;
+}
+interface ProductDisplayConfig {
+    /** Card size */
+    size?: ProductCardSize;
+    /** Card style */
+    style?: ProductCardStyle;
+    /** Show product image */
+    showImage?: boolean;
+    /** Image aspect ratio */
+    imageAspectRatio?: '1:1' | '4:3' | '3:4' | '16:9' | 'auto';
+    /** Show price */
+    showPrice?: boolean;
+    /** Show compare/original price */
+    showComparePrice?: boolean;
+    /** Show discount badge */
+    showDiscount?: boolean;
+    /** Show brand */
+    showBrand?: boolean;
+    /** Show rating */
+    showRating?: boolean;
+    /** Show stock status */
+    showStock?: boolean;
+    /** Show add to cart button */
+    showAddToCart?: boolean;
+    /** Currency symbol */
+    currency?: string;
+    /** Currency position */
+    currencyPosition?: 'before' | 'after';
+    /** Decimal places for price */
+    priceDecimals?: number;
+    /** Truncate title after N lines */
+    titleLines?: number;
+    /** Hover effect */
+    hoverEffect?: 'none' | 'lift' | 'glow' | 'scale' | 'border';
+    /** Image placeholder */
+    imagePlaceholder?: ReactNode;
+    /** Lazy load images */
+    lazyLoadImages?: boolean;
+}
+interface SuggestionDisplayConfig {
+    /** Show search icon */
+    showIcon?: boolean;
+    /** Custom icon */
+    icon?: ReactNode;
+    /** Show hit count */
+    showCount?: boolean;
+    /** Show categories inline */
+    showCategories?: boolean;
+    /** Max categories to show */
+    maxCategories?: number;
+    /** Highlight matching text */
+    highlightMatches?: boolean;
+    /** Highlight style */
+    highlightStyle?: CSSProperties;
+    /** Show arrow on hover */
+    showArrow?: boolean;
+    /** Category click behavior */
+    categoryClickable?: boolean;
+}
+interface DropdownThemeConfig {
+    /** Light/dark mode */
+    mode?: 'light' | 'dark' | 'auto';
+    /** Primary brand color */
+    primaryColor?: string;
+    /** Background color */
+    backgroundColor?: string;
+    /** Surface color (cards, sections) */
+    surfaceColor?: string;
+    /** Text color */
+    textColor?: string;
+    /** Secondary text color */
+    textSecondaryColor?: string;
+    /** Border color */
+    borderColor?: string;
+    /** Hover background */
+    hoverColor?: string;
+    /** Highlight/match color */
+    highlightColor?: string;
+    /** Success color (in stock, etc.) */
+    successColor?: string;
+    /** Error color (out of stock, etc.) */
+    errorColor?: string;
+    /** Font family */
+    fontFamily?: string;
+    /** Base font size */
+    fontSize?: number | string;
+    /** Border radius */
+    borderRadius?: number | string;
+    /** Box shadow */
+    boxShadow?: string;
+    /** Custom CSS variables */
+    cssVariables?: Record<string, string>;
+}
+interface AnalyticsConfig {
+    /** Enable analytics */
+    enabled?: boolean;
+    /** Track suggestion clicks */
+    trackSuggestionClicks?: boolean;
+    /** Track product clicks */
+    trackProductClicks?: boolean;
+    /** Track impressions */
+    trackImpressions?: boolean;
+    /** Impression debounce time (ms) */
+    impressionDebounce?: number;
+    /** Track category clicks */
+    trackCategoryClicks?: boolean;
+    /** Track brand clicks */
+    trackBrandClicks?: boolean;
+    /** Track search submissions */
+    trackSearchSubmit?: boolean;
+    /** Custom analytics tags */
+    tags?: string[];
+    /** User ID for personalization */
+    userId?: string;
+    /** Session ID */
+    sessionId?: string;
+    /** Custom event handler */
+    onEvent?: (eventType: string, data: any) => void;
+}
+interface DropdownEventHandlers<TSuggestion = any, TProduct = any, TCategory = any, TBrand = any> {
+    /** Suggestion selected */
+    onSuggestionSelect?: (suggestion: TSuggestion, index: number) => void;
+    /** Product clicked */
+    onProductClick?: (product: TProduct, index: number) => void;
+    /** Category clicked */
+    onCategoryClick?: (category: TCategory, suggestion?: TSuggestion) => void;
+    /** Brand clicked */
+    onBrandClick?: (brand: TBrand) => void;
+    /** Tab/filter changed */
+    onTabChange?: (tabId: string, tab?: any) => void;
+    /** Recent search clicked */
+    onRecentClick?: (query: string) => void;
+    /** Recent search removed */
+    onRecentRemove?: (query: string) => void;
+    /** Clear all recent searches */
+    onRecentClearAll?: () => void;
+    /** View all clicked */
+    onViewAll?: (section: SectionType | string) => void;
+    /** Search submitted */
+    onSearchSubmit?: (query: string) => void;
+    /** Dropdown opened */
+    onOpen?: () => void;
+    /** Dropdown closed */
+    onClose?: () => void;
+    /** Keyboard navigation */
+    onNavigate?: (direction: 'up' | 'down' | 'left' | 'right', index: number) => void;
+    /** Add to cart clicked (if enabled) */
+    onAddToCart?: (product: TProduct) => void;
+}
+interface AccessibilityConfig {
+    /** ARIA label for dropdown */
+    ariaLabel?: string;
+    /** ARIA labelledby */
+    ariaLabelledBy?: string;
+    /** Announce selection to screen readers */
+    announceSelection?: boolean;
+    /** Custom announcement text */
+    getAnnouncementText?: (item: any, type: string) => string;
+    /** Keyboard navigation enabled */
+    keyboardNavigation?: boolean;
+    /** Focus trap (keep focus within dropdown) */
+    focusTrap?: boolean;
+    /** Auto focus first item */
+    autoFocus?: boolean;
+    /** Close on escape */
+    closeOnEscape?: boolean;
+    /** Close on click outside */
+    closeOnClickOutside?: boolean;
+}
+interface BaseDropdownProps<TSuggestion = any, TProduct = any, TCategory = any, TBrand = any> extends DropdownEventHandlers<TSuggestion, TProduct, TCategory, TBrand> {
+    /** Current search query */
+    query: string;
+    /** Whether dropdown is open/visible */
+    isOpen?: boolean;
+    /** Loading state */
+    loading?: boolean;
+    /** Error state */
+    error?: Error | string | null;
+    /** Suggestion items */
+    suggestions?: TSuggestion[];
+    /** Product items */
+    products?: TProduct[];
+    /** Category/filter tabs */
+    categories?: TCategory[];
+    /** Brand items */
+    brands?: TBrand[];
+    /** Recent searches (strings or objects) */
+    recentSearches?: string[] | Array<{
+        query: string;
+        timestamp?: number;
+    }>;
+    /** Trending searches */
+    trendingSearches?: string[] | TSuggestion[];
+    /** Filtered tabs with products */
+    filteredTabs?: Array<{
+        id: string;
+        label: string;
+        products?: TProduct[];
+        nb_hits?: number;
+        filter?: string;
+    }>;
+    /** Currently active tab ID */
+    activeTab?: string;
+    /** Map suggestion data fields */
+    suggestionFields?: SuggestionFieldMapping;
+    /** Map product data fields */
+    productFields?: ProductFieldMapping;
+    /** Map category data fields */
+    categoryFields?: CategoryFieldMapping;
+    /** Map brand data fields */
+    brandFields?: BrandFieldMapping;
+    /** Section configurations */
+    sections?: SectionConfig[];
+    /** Product display config */
+    productDisplay?: ProductDisplayConfig;
+    /** Suggestion display config */
+    suggestionDisplay?: SuggestionDisplayConfig;
+    /** Visual/layout config */
+    visual?: VisualConfig;
+    /** Theme config */
+    theme?: DropdownThemeConfig;
+    /** Analytics config */
+    analytics?: AnalyticsConfig;
+    /** Accessibility config */
+    accessibility?: AccessibilityConfig;
+    /** Dropdown width */
+    width?: string | number;
+    /** Dropdown max height */
+    maxHeight?: string | number;
+    /** Dropdown min height */
+    minHeight?: string | number;
+    /** Z-index */
+    zIndex?: number;
+    /** Root CSS class */
+    className?: string;
+    /** Root inline styles */
+    style?: CSSProperties;
+    /** CSS classes for parts */
+    classNames?: Partial<DropdownClassNames>;
+    /** Inline styles for parts */
+    styles?: Partial<DropdownStyles>;
+    /** Custom header */
+    header?: ReactNode;
+    /** Custom footer */
+    footer?: ReactNode;
+    /** Custom loading state */
+    renderLoading?: () => ReactNode;
+    /** Custom empty state */
+    renderEmpty?: (query: string) => ReactNode;
+    /** Custom error state */
+    renderError?: (error: Error | string) => ReactNode;
+    /** Reference to input element (for focus management) */
+    inputRef?: React.RefObject<HTMLInputElement>;
+}
+interface DropdownClassNames {
+    root: string;
+    container: string;
+    header: string;
+    content: string;
+    footer: string;
+    section: string;
+    sectionHeader: string;
+    sectionTitle: string;
+    sectionContent: string;
+    sectionViewAll: string;
+    suggestionsList: string;
+    suggestionItem: string;
+    suggestionItemActive: string;
+    suggestionIcon: string;
+    suggestionText: string;
+    suggestionHighlight: string;
+    suggestionCount: string;
+    suggestionCategories: string;
+    suggestionCategory: string;
+    suggestionArrow: string;
+    productsList: string;
+    productCard: string;
+    productCardHover: string;
+    productImage: string;
+    productImagePlaceholder: string;
+    productInfo: string;
+    productTitle: string;
+    productBrand: string;
+    productPrice: string;
+    productComparePrice: string;
+    productDiscount: string;
+    productRating: string;
+    productStock: string;
+    productAddToCart: string;
+    categoriesList: string;
+    categoryItem: string;
+    categoryItemActive: string;
+    categoryIcon: string;
+    categoryLabel: string;
+    categoryCount: string;
+    brandsList: string;
+    brandItem: string;
+    brandLogo: string;
+    brandName: string;
+    recentList: string;
+    recentItem: string;
+    recentIcon: string;
+    recentText: string;
+    recentRemove: string;
+    recentClearAll: string;
+    trendingList: string;
+    trendingItem: string;
+    trendingIcon: string;
+    tabsList: string;
+    tabItem: string;
+    tabItemActive: string;
+    tabCount: string;
+    loading: string;
+    loadingSpinner: string;
+    empty: string;
+    emptyIcon: string;
+    emptyText: string;
+    error: string;
+    errorIcon: string;
+    errorText: string;
+    keyboard: string;
+    keyboardHint: string;
+    keyboardKey: string;
+}
+interface DropdownStyles {
+    root: CSSProperties;
+    container: CSSProperties;
+    header: CSSProperties;
+    content: CSSProperties;
+    footer: CSSProperties;
+    section: CSSProperties;
+    suggestionItem: CSSProperties;
+    productCard: CSSProperties;
+    categoryItem: CSSProperties;
+    brandItem: CSSProperties;
+}
+interface DropdownRef {
+    /** Get currently active/focused index */
+    getActiveIndex: () => number;
+    /** Set active index */
+    setActiveIndex: (index: number) => void;
+    /** Select currently active item */
+    selectActive: () => void;
+    /** Navigate to next item */
+    navigateNext: () => void;
+    /** Navigate to previous item */
+    navigatePrevious: () => void;
+    /** Focus the dropdown */
+    focus: () => void;
+    /** Close the dropdown */
+    close: () => void;
+    /** Get active tab ID (if tabs exist) */
+    getActiveTab?: () => string | null;
+    /** Set active tab */
+    setActiveTab?: (tabId: string) => void;
+    /** Scroll to item */
+    scrollToItem?: (index: number) => void;
+}
+
+/**
+ * MinimalDropdown - Ultra-Clean Minimalist Style
+ *
+ * Features:
+ * - Stripped-down, distraction-free design
+ * - Focus on typography and whitespace
+ * - Subtle animations
+ * - Perfect for editorial/content sites
+ */
+
+interface MinimalDropdownProps extends BaseDropdownProps {
+    /** Show item indices */
+    showIndices?: boolean;
+    /** Show item type labels */
+    showTypeLabels?: boolean;
+    /** Show dividers between sections */
+    showSectionDividers?: boolean;
+    /** Monospace indices */
+    monoIndices?: boolean;
+}
+declare const MinimalDropdown: React__default.ForwardRefExoticComponent<MinimalDropdownProps & React__default.RefAttributes<DropdownRef>>;
+
+/**
+ * MobileSheetDropdown - Mobile-First Bottom Sheet Style
+ *
+ * Features:
+ * - iOS-style bottom sheet with drag handle
+ * - Full-screen overlay with smooth transitions
+ * - Touch-friendly large tap targets
+ * - Swipe to dismiss
+ * - Optimized for small screens
+ */
+
+interface MobileSheetDropdownProps extends BaseDropdownProps {
+    /** Show search input in header */
+    showSearchInput?: boolean;
+    /** Show cancel button */
+    showCancel?: boolean;
+    /** Cancel button text */
+    cancelText?: string;
+    /** Show drag handle */
+    showDragHandle?: boolean;
+    /** Enable swipe to dismiss */
+    swipeToDismiss?: boolean;
+    /** Footer button text */
+    footerButtonText?: string;
+    /** Show footer button */
+    showFooterButton?: boolean;
+}
+declare const MobileSheetDropdown: React__default.ForwardRefExoticComponent<MobileSheetDropdownProps & React__default.RefAttributes<DropdownRef>>;
+
+/**
+ * ShopifyDropdown - Modern E-commerce Style Suggestions
+ *
+ * Features:
+ * - Hero product with large image
+ * - Horizontal product scroll
+ * - Collection/category links
+ * - Clean, modern design
+ * - Quick add to cart
+ */
+
+interface ShopifyDropdownProps extends BaseDropdownProps {
+    /** Show hero product */
+    showHeroProduct?: boolean;
+    /** Show collections/categories */
+    showCollections?: boolean;
+    /** Show add to cart button */
+    showAddToCart?: boolean;
+    /** Add to cart text */
+    addToCartText?: string;
+    /** Show compare price */
+    showComparePrice?: boolean;
+}
+declare const ShopifyDropdown: React__default.ForwardRefExoticComponent<ShopifyDropdownProps & React__default.RefAttributes<DropdownRef>>;
+
+/**
+ * SpotlightDropdown - macOS Spotlight / Command Palette Style
+ *
+ * Features:
+ * - Clean, centered modal design
+ * - Category grouping with keyboard navigation
+ * - Instant preview panel
+ * - Actions/commands support
+ * - Keyboard-first interaction
+ */
+
+interface SpotlightDropdownProps extends BaseDropdownProps {
+    /** Show preview panel */
+    showPreview?: boolean;
+    /** Show as overlay */
+    asOverlay?: boolean;
+    /** Placeholder text */
+    placeholder?: string;
+    /** Show keyboard shortcuts */
+    showShortcuts?: boolean;
+    /** Quick actions */
+    actions?: Array<{
+        id: string;
+        label: string;
+        icon?: React__default.ReactNode;
+        shortcut?: string;
+        onAction: () => void;
+    }>;
+}
+declare const SpotlightDropdown: React__default.ForwardRefExoticComponent<SpotlightDropdownProps & React__default.RefAttributes<DropdownRef>>;
+
+/**
+ * PinterestDropdown - Visual Discovery Style Suggestions
+ *
+ * Features:
+ * - Visually-driven masonry/grid product display
+ * - Large hero images
+ * - Category chips/pills for filtering
+ * - Smooth hover effects with quick preview
+ * - Color palette extraction ready
+ */
+
+interface PinterestDropdownProps extends BaseDropdownProps {
+    /** Show save/pin button on products */
+    showSaveButton?: boolean;
+    /** Save button handler */
+    onSaveProduct?: (product: any) => void;
+    /** Active category ID */
+    activeCategory?: string;
+    /** Show price overlay on hover */
+    showPriceOverlay?: boolean;
+    /** Grid columns */
+    gridColumns?: number;
+    /** Card aspect ratio */
+    cardAspectRatio?: 'square' | 'portrait' | 'landscape';
+}
+declare const PinterestDropdown: React__default.ForwardRefExoticComponent<PinterestDropdownProps & React__default.RefAttributes<DropdownRef>>;
+
+/**
+ * GoogleDropdown - Google-style Clean Search Suggestions
+ *
+ * Features:
+ * - Ultra-clean, minimal design
+ * - Instant suggestions with smooth animations
+ * - Trending searches when empty
+ * - "I'm Feeling Lucky" style quick actions
+ * - Voice search integration ready
+ */
+
+interface GoogleDropdownProps extends BaseDropdownProps {
+    /** Show "I'm Feeling Lucky" button */
+    showFeelingLucky?: boolean;
+    /** Feeling lucky button text */
+    feelingLuckyText?: string;
+    /** Show remove button on recent searches */
+    showRemoveRecent?: boolean;
+    /** Show voice search button */
+    showVoiceSearch?: boolean;
+    /** Voice search handler */
+    onVoiceSearch?: () => void;
+    /** Feeling lucky handler */
+    onFeelingLucky?: (query: string) => void;
+    /** Show trending indicator */
+    showTrendingIndicator?: boolean;
+}
+declare const GoogleDropdown: React__default.ForwardRefExoticComponent<GoogleDropdownProps & React__default.RefAttributes<DropdownRef>>;
+
+/**
+ * AmazonDropdown - Amazon-style Search Suggestions
+ *
+ * Features:
+ * - Department/category scoping in search
+ * - Suggestions with category context
+ * - Product grid with images
+ * - "in Department" suffix for scoped searches
+ * - Clean, functional design
+ */
+
+interface AmazonDropdownProps extends BaseDropdownProps {
+    /** Show department scoping in suggestions */
+    showDepartments?: boolean;
+    /** Current department filter */
+    currentDepartment?: string;
+    /** Available departments */
+    departments?: Array<{
+        id: string;
+        label: string;
+    }>;
+    /** Show Prime badge */
+    showPrime?: boolean;
+    /** Prime icon URL */
+    primeIconUrl?: string;
+}
+declare const AmazonDropdown: React__default.ForwardRefExoticComponent<AmazonDropdownProps & React__default.RefAttributes<DropdownRef>>;
+
+/**
+ * SuggestionSearchBar - Unified Search Component with Premium Dropdowns
+ *
+ * A self-contained search component that:
+ * - Fetches suggestions from the API automatically
+ * - Parses responses internally (no user-side parsing needed)
+ * - Renders any of the 7 premium dropdown variants
+ * - Handles analytics tracking
+ * - Supports recent searches via localStorage
+ * - Fully responsive and mobile-ready
+ *
+ * Usage:
+ * ```tsx
+ * <SuggestionSearchBar
+ *   client={seekoraClient}
+ *   variant="amazon"
+ *   onSearch={(query) => router.push(`/search?q=${query}`)}
+ * />
+ * ```
+ */
+
+interface SuggestionSearchBarProps {
+    /** Seekora client instance - REQUIRED */
+    client: SeekoraClient;
+    /** Dropdown variant to use */
+    variant?: SuggestionDropdownVariant$1;
+    /** Auto-select mobile variant on small screens */
+    autoMobileVariant?: boolean;
+    /** Placeholder text */
+    placeholder?: string;
+    /** Initial/default query */
+    defaultQuery?: string;
+    /** Controlled query value */
+    value?: string;
+    /** Min characters before fetching */
+    minQueryLength?: number;
+    /** Max suggestions to fetch */
+    maxSuggestions?: number;
+    /** Debounce delay in ms */
+    debounceMs?: number;
+    /** Include dropdown recommendations (products, tabs, trending) */
+    includeDropdownRecommendations?: boolean;
+    /** Include categories per suggestion */
+    includeCategories?: boolean;
+    /** Filtered tabs configuration */
+    filteredTabs?: Array<{
+        id?: string;
+        label: string;
+        filter: string;
+    }>;
+    /** Analytics tags */
+    analyticsTags?: string[];
+    /** Enable recent searches */
+    enableRecentSearches?: boolean;
+    /** Max recent searches to store */
+    maxRecentSearches?: number;
+    /** Show products in dropdown */
+    showProducts?: boolean;
+    /** Show trending when empty */
+    showTrendingOnEmpty?: boolean;
+    /** Enable analytics tracking */
+    enableAnalytics?: boolean;
+    /** Analytics configuration */
+    analyticsConfig?: AnalyticsConfig;
+    /** Map suggestion fields to your data */
+    suggestionFields?: SuggestionFieldMapping;
+    /** Map product fields to your data */
+    productFields?: ProductFieldMapping;
+    /** Theme configuration */
+    theme?: DropdownThemeConfig;
+    /** Called when search is submitted */
+    onSearch?: (query: string) => void;
+    /** Called when query changes */
+    onQueryChange?: (query: string) => void;
+    /** Called when a suggestion is selected */
+    onSuggestionSelect?: (suggestion: any, index: number) => void;
+    /** Called when a product is clicked */
+    onProductClick?: (product: any, index: number) => void;
+    /** Called when a category/tab is clicked */
+    onCategoryClick?: (category: any, index: number) => void;
+    /** Called when a tab is changed */
+    onTabChange?: (tabId: string) => void;
+    /** Container class name */
+    className?: string;
+    /** Container style */
+    style?: React__default.CSSProperties;
+    /** Input class name */
+    inputClassName?: string;
+    /** Dropdown width */
+    dropdownWidth?: string | number;
+    /** Dropdown max height */
+    dropdownMaxHeight?: string | number;
+    /** Z-index for dropdown */
+    zIndex?: number;
+    /** Enable caching for suggestions (reduces API calls) */
+    enableCache?: boolean;
+    /** Cache TTL in milliseconds (default: 30000 = 30 seconds) */
+    cacheTtlMs?: number;
+    /** Maximum cache entries (default: 100) */
+    cacheMaxSize?: number;
+}
+interface SuggestionSearchBarRef {
+    focus: () => void;
+    blur: () => void;
+    clear: () => void;
+    getQuery: () => string;
+    setQuery: (query: string) => void;
+    openDropdown: () => void;
+    closeDropdown: () => void;
+    refresh: () => void;
+    /** Clear the suggestions cache */
+    clearCache: () => void;
+    /** Get cache statistics */
+    getCacheStats: () => {
+        size: number;
+        maxSize: number;
+    } | null;
+}
+declare const SuggestionSearchBar: React__default.ForwardRefExoticComponent<SuggestionSearchBarProps & React__default.RefAttributes<SuggestionSearchBarRef>>;
+
+/**
+ * Utility functions for Query Suggestions components
+ */
+
+/**
+ * Extract suggestion fields from raw data
+ */
+declare const extractSuggestion: (item: any, mapping?: SuggestionFieldMapping) => {
+    query: any;
+    count: any;
+    id: any;
+    categories: any;
+    highlighted: any;
+    _raw: any;
+};
+/**
+ * Extract product fields from raw data
+ */
+declare const extractProduct: (item: any, mapping?: ProductFieldMapping) => {
+    id: any;
+    title: any;
+    image: any;
+    price: any;
+    comparePrice: any;
+    url: any;
+    brand: any;
+    category: any;
+    rating: any;
+    reviewCount: any;
+    discount: any;
+    inStock: any;
+    currency: any;
+    _raw: any;
+};
+/**
+ * Extract category fields from raw data
+ */
+declare const extractCategory: (item: any, mapping?: CategoryFieldMapping) => {
+    id: any;
+    label: any;
+    count: any;
+    icon: any;
+    image: any;
+    _raw: any;
+};
+/**
+ * Extract brand fields from raw data
+ */
+declare const extractBrand: (item: any, mapping?: BrandFieldMapping) => {
+    id: any;
+    name: any;
+    logo: any;
+    count: any;
+    _raw: any;
+};
+/**
+ * Format price with currency
+ */
+declare const formatPrice: (value: number | string | undefined, config?: Pick<ProductDisplayConfig, "currency" | "currencyPosition" | "priceDecimals">) => string;
+/**
+ * Highlight matching text in a string
+ */
+declare const highlightText: (text: string, query: string, options?: {
+    tag?: string;
+    className?: string;
+    style?: CSSProperties;
+}) => string;
+declare const getRecentSearches: (storeId?: string) => string[];
+declare const addRecentSearch: (query: string, storeId?: string) => string[];
+declare const removeRecentSearch: (query: string, storeId?: string) => string[];
+declare const clearRecentSearches: (storeId?: string) => void;
+/**
+ * Simple in-memory cache with TTL support for suggestions
+ * Reduces API calls by caching results for quick repeated queries
+ */
+declare class SuggestionsCache {
+    private cache;
+    private maxSize;
+    private defaultTtl;
+    constructor(options?: {
+        maxSize?: number;
+        defaultTtlMs?: number;
+    });
+    /**
+     * Generate a cache key from query and options
+     */
+    generateKey(query: string, options?: Record<string, any>): string;
+    /**
+     * Get cached data if valid (not expired)
+     */
+    get<T>(key: string): T | null;
+    /**
+     * Store data in cache
+     */
+    set<T>(key: string, data: T, ttlMs?: number): void;
+    /**
+     * Check if key exists and is valid
+     */
+    has(key: string): boolean;
+    /**
+     * Clear all cached entries
+     */
+    clear(): void;
+    /**
+     * Clear expired entries
+     */
+    cleanup(): void;
+    /**
+     * Get cache statistics
+     */
+    getStats(): {
+        size: number;
+        maxSize: number;
+    };
+}
+/**
+ * Get the global suggestions cache instance
+ */
+declare const getSuggestionsCache: (options?: {
+    maxSize?: number;
+    defaultTtlMs?: number;
+}) => SuggestionsCache;
+/**
+ * Create a new cache instance (for isolated caching per component)
+ */
+declare const createSuggestionsCache: (options?: {
+    maxSize?: number;
+    defaultTtlMs?: number;
+}) => SuggestionsCache;
+/**
+ * Clear the global cache
+ */
+declare const clearSuggestionsCache: () => void;
+
+/**
+ * Responsive Utilities and Breakpoints
+ *
+ * Shared responsive design utilities for all dropdown components
+ */
+
+declare const breakpoints: {
+    readonly xs: 0;
+    readonly sm: 480;
+    readonly md: 768;
+    readonly lg: 1024;
+    readonly xl: 1280;
+};
+type Breakpoint = keyof typeof breakpoints;
+declare const mediaQueries: {
+    readonly xs: `@media (max-width: ${number}px)`;
+    readonly sm: `@media (min-width: 480px) and (max-width: ${number}px)`;
+    readonly md: `@media (min-width: 768px) and (max-width: ${number}px)`;
+    readonly lg: `@media (min-width: 1024px) and (max-width: ${number}px)`;
+    readonly xl: "@media (min-width: 1280px)";
+    readonly mobile: `@media (max-width: ${number}px)`;
+    readonly tablet: `@media (min-width: 768px) and (max-width: ${number}px)`;
+    readonly desktop: "@media (min-width: 1024px)";
+    readonly touch: "@media (hover: none) and (pointer: coarse)";
+    readonly mouse: "@media (hover: hover) and (pointer: fine)";
+};
+declare const touchTargets: {
+    /** Minimum touch target size per WCAG guidelines */
+    readonly minimum: 44;
+    /** Comfortable touch target size */
+    readonly comfortable: 48;
+    /** Large touch target for primary actions */
+    readonly large: 56;
+};
+interface ResponsiveState {
+    isMobile: boolean;
+    isTablet: boolean;
+    isDesktop: boolean;
+    isTouch: boolean;
+    width: number;
+    height: number;
+    breakpoint: Breakpoint;
+}
+declare const useResponsive: () => ResponsiveState;
+
+/**
+ * Shared Styles Index
+ */
+
+declare const injectGlobalResponsiveStyles: () => void;
+/**
+ * Hook to auto-inject styles on mount
+ */
+declare const useInjectResponsiveStyles: () => void;
+
+declare const SuggestionDropdownVariants: {
+    readonly amazon: React$1.ForwardRefExoticComponent<AmazonDropdownProps & React$1.RefAttributes<DropdownRef>>;
+    readonly google: React$1.ForwardRefExoticComponent<GoogleDropdownProps & React$1.RefAttributes<DropdownRef>>;
+    readonly pinterest: React$1.ForwardRefExoticComponent<PinterestDropdownProps & React$1.RefAttributes<DropdownRef>>;
+    readonly spotlight: React$1.ForwardRefExoticComponent<SpotlightDropdownProps & React$1.RefAttributes<DropdownRef>>;
+    readonly shopify: React$1.ForwardRefExoticComponent<ShopifyDropdownProps & React$1.RefAttributes<DropdownRef>>;
+    readonly 'mobile-sheet': React$1.ForwardRefExoticComponent<MobileSheetDropdownProps & React$1.RefAttributes<DropdownRef>>;
+    readonly minimal: React$1.ForwardRefExoticComponent<MinimalDropdownProps & React$1.RefAttributes<DropdownRef>>;
+};
+type SuggestionDropdownVariant = keyof typeof SuggestionDropdownVariants;
+
+/**
+ * useSeekoraSearch Hook
+ *
+ * Hook for performing searches with the Seekora SDK
+ */
+
+interface UseSeekoraSearchOptions {
+    client: SeekoraClient;
+    autoTrack?: boolean;
+}
+interface UseSeekoraSearchReturn {
+    search: (options: SearchOptions) => Promise<SearchResponse | null>;
+    results: SearchResponse | null;
+    loading: boolean;
+    error: Error | null;
+    context: SearchContext | null;
+    clearResults: () => void;
+}
+declare const useSeekoraSearch: ({ client, autoTrack, }: UseSeekoraSearchOptions) => UseSeekoraSearchReturn;
+
+/**
+ * Common types for Seekora UI SDK
+ */
+
+interface SuggestionItem {
+    query: string;
+    count?: number;
+    metadata?: Record<string, any>;
+}
+
+/**
+ * useQuerySuggestions Hook
+ *
+ * Hook for fetching query suggestions with debouncing
+ */
+
+interface UseQuerySuggestionsOptions {
+    client: SeekoraClient;
+    query: string;
+    enabled?: boolean;
+    debounceMs?: number;
+    maxSuggestions?: number;
+}
+interface UseQuerySuggestionsReturn {
+    suggestions: SuggestionItem[];
+    loading: boolean;
+    error: Error | null;
+}
+declare const useQuerySuggestions: ({ client, query, enabled, debounceMs, maxSuggestions, }: UseQuerySuggestionsOptions) => UseQuerySuggestionsReturn;
+
+/**
+ * Enhanced Query Suggestions Hook
+ *
+ * Provides full support for query suggestions API including:
+ * - Basic suggestions
+ * - Dropdown recommendations (trending, top searches, related)
+ * - Filtered tabs with products
+ * - Recent searches (local storage)
+ * - Analytics tracking
+ */
+
+interface UseQuerySuggestionsEnhancedOptions {
+    /** Seekora client instance */
+    client: SeekoraClient;
+    /** Current search query */
+    query: string;
+    /** Enable/disable the hook */
+    enabled?: boolean;
+    /** Debounce delay in ms */
+    debounceMs?: number;
+    /** Max suggestions to fetch */
+    maxSuggestions?: number;
+    /** Minimum query length to trigger search */
+    minQueryLength?: number;
+    /** Include dropdown recommendations (trending, products, etc.) */
+    includeDropdownRecommendations?: boolean;
+    /** Include categories in suggestions */
+    includeCategories?: boolean;
+    /** Include facets in suggestions */
+    includeFacets?: boolean;
+    /** Max categories per suggestion */
+    maxCategories?: number;
+    /** Max facets per suggestion */
+    maxFacets?: number;
+    /** Filtered tabs configuration */
+    filteredTabs?: Array<{
+        id?: string;
+        label: string;
+        filter: string;
+    }>;
+    /** Minimum popularity threshold */
+    minPopularity?: number;
+    /** Time range for analytics data */
+    timeRange?: '7d' | '30d' | '90d';
+    /** Disable typo tolerance */
+    disableTypoTolerance?: boolean;
+    /** Analytics tags */
+    analyticsTags?: string[];
+    /** Enable recent searches from localStorage */
+    enableRecentSearches?: boolean;
+    /** Max recent searches to store */
+    maxRecentSearches?: number;
+    /** Local storage key for recent searches */
+    recentSearchesKey?: string;
+    /** Callback when suggestions are loaded */
+    onSuggestionsLoaded?: (response: QuerySuggestionsResponse) => void;
+    /** Callback on error */
+    onError?: (error: Error) => void;
+}
+interface UseQuerySuggestionsEnhancedReturn {
+    /** Basic suggestion items */
+    suggestions: SuggestionItem$2[];
+    /** Loading state */
+    loading: boolean;
+    /** Error state */
+    error: Error | null;
+    /** Dropdown recommendations */
+    dropdownRecommendations: DropdownRecommendations | null;
+    /** Trending searches */
+    trendingSearches: TrendingSearch[];
+    /** Top searches */
+    topSearches: TopSearch[];
+    /** Related searches */
+    relatedSearches: RelatedSearch[];
+    /** Popular brands */
+    popularBrands: PopularBrand[];
+    /** Filtered tabs with products */
+    filteredTabs: FilteredTab[];
+    /** Trending products */
+    trendingProducts: ProductItem[];
+    /** Recent searches (from localStorage) */
+    recentSearches: RecentSearch[];
+    /** Processing time in ms */
+    processingTimeMs: number | null;
+    /** Total hits count */
+    totalHits: number;
+    /** Current page */
+    currentPage: number;
+    /** Total pages */
+    totalPages: number;
+    /** Original query */
+    originalQuery: string;
+    /** Add a search to recent searches */
+    addRecentSearch: (query: string, resultsCount?: number) => void;
+    /** Remove a search from recent searches */
+    removeRecentSearch: (query: string) => void;
+    /** Clear all recent searches */
+    clearRecentSearches: () => void;
+    /** Manually refetch suggestions */
+    refetch: () => Promise<void>;
+    /** Check if dropdown has any content to show */
+    hasContent: boolean;
+    /** Get all items for keyboard navigation (flattened) */
+    getAllNavigableItems: () => NavigableItem[];
+}
+interface NavigableItem {
+    type: 'suggestion' | 'recent' | 'trending' | 'product' | 'category' | 'brand' | 'tab';
+    index: number;
+    data: SuggestionItem$2 | RecentSearch | TrendingSearch | ProductItem | SuggestionCategory | PopularBrand | FilteredTab;
+}
+declare function useQuerySuggestionsEnhanced(options: UseQuerySuggestionsEnhancedOptions): UseQuerySuggestionsEnhancedReturn;
+
+/**
+ * Suggestions Analytics Hook
+ *
+ * Provides analytics tracking for query suggestions components:
+ * - Suggestion clicks/selections
+ * - Suggestion impressions
+ * - Product clicks from dropdown
+ * - Category/brand clicks
+ * - Search submissions from suggestions
+ */
+
+interface UseSuggestionsAnalyticsOptions {
+    /** Seekora client instance */
+    client: SeekoraClient;
+    /** Enable analytics tracking */
+    enabled?: boolean;
+    /** Analytics tags to include with all events */
+    analyticsTags?: string[];
+    /** Debounce impression events (ms) */
+    impressionDebounce?: number;
+    /** Track suggestion impressions automatically */
+    trackImpressions?: boolean;
+    /** Track clicks automatically */
+    trackClicks?: boolean;
+}
+interface SuggestionClickEventData {
+    /** The clicked suggestion */
+    suggestion: SuggestionItem$2;
+    /** Position in the list (0-indexed) */
+    position: number;
+    /** Section where the suggestion appeared */
+    section?: 'suggestions' | 'trending' | 'recent' | 'related';
+    /** Original query that triggered suggestions */
+    query?: string;
+    /** Total suggestions shown */
+    totalSuggestions?: number;
+}
+interface ProductClickEventData {
+    /** The clicked product */
+    product: ProductItem;
+    /** Position in the list (0-indexed) */
+    position: number;
+    /** Section where the product appeared */
+    section?: 'products' | 'trending' | 'recommendations' | 'filtered_tab';
+    /** Tab ID if from filtered tab */
+    tabId?: string;
+    /** Original query */
+    query?: string;
+}
+interface SuggestionImpressionEventData {
+    /** Suggestions that were shown */
+    suggestions: SuggestionItem$2[];
+    /** Products that were shown */
+    products?: ProductItem[];
+    /** Categories that were shown */
+    categories?: SuggestionCategory[];
+    /** Brands that were shown */
+    brands?: PopularBrand[];
+    /** Original query */
+    query: string;
+    /** Timestamp when impressions occurred */
+    timestamp: number;
+}
+interface UseSuggestionsAnalyticsReturn {
+    /** Track a suggestion click */
+    trackSuggestionClick: (data: SuggestionClickEventData) => void;
+    /** Track a product click from suggestions dropdown */
+    trackProductClick: (data: ProductClickEventData) => void;
+    /** Track a category click */
+    trackCategoryClick: (category: SuggestionCategory, query?: string) => void;
+    /** Track a brand click */
+    trackBrandClick: (brand: PopularBrand, query?: string) => void;
+    /** Track a tab selection */
+    trackTabSelect: (tab: FilteredTab, query?: string) => void;
+    /** Track recent search click */
+    trackRecentSearchClick: (search: RecentSearch) => void;
+    /** Track trending search click */
+    trackTrendingClick: (trending: TrendingSearch, position: number) => void;
+    /** Track suggestions impression */
+    trackImpression: (data: SuggestionImpressionEventData) => void;
+    /** Track search submission from suggestion */
+    trackSearchSubmit: (query: string, fromSuggestion: boolean, suggestion?: SuggestionItem$2) => void;
+    /** Track dropdown open */
+    trackDropdownOpen: (query: string) => void;
+    /** Track dropdown close */
+    trackDropdownClose: (query: string, selectedSuggestion?: string) => void;
+}
+declare function useSuggestionsAnalytics(options: UseSuggestionsAnalyticsOptions): UseSuggestionsAnalyticsReturn;
+
+/**
+ * useAnalytics Hook
+ *
+ * Hook for tracking analytics events with the Seekora SDK
+ */
+
+interface UseAnalyticsOptions {
+    client: SeekoraClient;
+    enabled?: boolean;
+}
+interface UseAnalyticsReturn {
+    trackEvent: (eventType: string, payload: Partial<DataTypesEventPayload>, context?: SearchContext | Partial<SearchContext>) => Promise<void>;
+    trackClick: (resultId: string, result: any, context?: SearchContext | Partial<SearchContext>, position?: number) => Promise<void>;
+    trackConversion: (resultId: string, result: any, value?: number, currency?: string, context?: SearchContext | Partial<SearchContext>) => Promise<void>;
+    trackBatch: (events: (Partial<DataTypesEventPayload> & {
+        event_name?: string;
+    })[], context?: SearchContext) => Promise<void>;
+}
+declare const useAnalytics: ({ client, enabled, }: UseAnalyticsOptions) => UseAnalyticsReturn;
+
+/**
+ * useSearchState Hook
+ *
+ * React hook for accessing and managing search state via SearchStateManager
+ * Provides reactive state and methods to update search parameters
+ */
+
+interface UseSearchStateReturn {
+    query: string;
+    refinements: Array<{
+        field: string;
+        value: string;
+    }>;
+    currentPage: number;
+    itemsPerPage: number;
+    sortBy?: string;
+    results: SearchState['results'];
+    loading: boolean;
+    error: Error | null;
+    setQuery: (query: string, triggerSearch?: boolean) => void;
+    addRefinement: (field: string, value: string, triggerSearch?: boolean) => void;
+    removeRefinement: (field: string, value: string, triggerSearch?: boolean) => void;
+    clearRefinements: (triggerSearch?: boolean) => void;
+    setPage: (page: number, triggerSearch?: boolean) => void;
+    setSortBy: (sortBy: string, triggerSearch?: boolean) => void;
+    search: (additionalOptions?: Parameters<SearchStateManager['search']>[0]) => Promise<SearchResponse | null>;
+    clear: () => void;
+}
+/**
+ * Hook to access and manage search state
+ * Automatically subscribes to state changes and re-renders when state updates
+ */
+declare const useSearchState: () => UseSearchStateReturn;
+
+/**
+ * useSmartSuggestions Hook
+ *
+ * AI-enhanced query suggestions with intent understanding
+ * Provides context-aware suggestions based on user behavior and query patterns
+ */
+interface SmartSuggestion {
+    text: string;
+    type: 'query' | 'correction' | 'expansion' | 'related' | 'trending';
+    confidence: number;
+    metadata?: {
+        intent?: string;
+        category?: string;
+        correctedFrom?: string;
+        expandedTo?: string[];
+    };
+}
+interface SmartSuggestionsOptions {
+    /** Minimum query length */
+    minQueryLength?: number;
+    /** Maximum suggestions to return */
+    maxSuggestions?: number;
+    /** Debounce delay in ms */
+    debounceMs?: number;
+    /** Enable spell correction */
+    enableSpellCorrection?: boolean;
+    /** Enable query expansion */
+    enableQueryExpansion?: boolean;
+    /** Enable intent detection */
+    enableIntentDetection?: boolean;
+    /** Include trending queries when query is empty */
+    includeTrending?: boolean;
+    /** User context for personalization */
+    userContext?: {
+        recentSearches?: string[];
+        preferences?: Record<string, any>;
+    };
+}
+interface UseSmartSuggestionsReturn {
+    suggestions: SmartSuggestion[];
+    loading: boolean;
+    error: Error | null;
+    /** Detected intent from the query */
+    detectedIntent: string | null;
+    /** Suggested corrections if query has typos */
+    corrections: string[];
+    /** Expanded query terms */
+    expansions: string[];
+    /** Process a query for smart suggestions */
+    getSuggestions: (query: string) => Promise<SmartSuggestion[]>;
+    /** Clear current suggestions */
+    clear: () => void;
+}
+declare function useSmartSuggestions(query: string, options?: SmartSuggestionsOptions): UseSmartSuggestionsReturn;
+
+/**
+ * useNaturalLanguageFilters Hook
+ *
+ * Convert natural language queries to structured filters
+ * Examples:
+ * - "red shirts under $50" → color: red, category: shirts, price: <= 50
+ * - "size large blue jeans" → size: L, color: blue, category: jeans
+ */
+interface ParsedFilter {
+    field: string;
+    value: string;
+    operator: '=' | '>' | '<' | '>=' | '<=' | 'contains';
+    confidence: number;
+    matchedText: string;
+}
+interface NaturalLanguageResult {
+    /** Cleaned query with filter terms removed */
+    cleanedQuery: string;
+    /** Extracted filters */
+    filters: ParsedFilter[];
+    /** Original query */
+    originalQuery: string;
+    /** Whether any filters were detected */
+    hasFilters: boolean;
+}
+interface NaturalLanguageFiltersOptions {
+    /** Custom field mappings */
+    fieldMappings?: Record<string, string>;
+    /** Custom value mappings */
+    valueMappings?: Record<string, Record<string, string>>;
+    /** Whether to auto-apply filters to search state */
+    autoApply?: boolean;
+    /** Currency symbol for price parsing */
+    currencySymbol?: string;
+}
+declare function useNaturalLanguageFilters(options?: NaturalLanguageFiltersOptions): {
+    /** Parse a natural language query */
+    parse: (query: string) => NaturalLanguageResult;
+    /** Apply parsed filters to search state */
+    applyFilters: (filters: ParsedFilter[]) => void;
+    /** Parse and apply in one step */
+    parseAndApply: (query: string) => NaturalLanguageResult;
+};
+/**
+ * Utility to format parsed filters for display
+ */
+declare function formatParsedFilters(filters: ParsedFilter[]): string;
+
+/**
+ * Default Theme
+ */
+
+declare const defaultTheme: Theme;
+
+/**
+ * Dark Theme
+ */
+
+declare const darkTheme: Theme;
+
+/**
+ * Minimal Theme
+ */
+
+declare const minimalTheme: Theme;
+
+/**
+ * Query Suggestions Theme System
+ *
+ * Provides comprehensive theming for query suggestions components including:
+ * - CSS variables for easy customization
+ * - Pre-built theme presets (light, dark, minimal, branded)
+ * - Component-specific style generators
+ * - Responsive utilities
+ */
+
+interface SuggestionsThemeVariables {
+    '--seekora-bg-surface': string;
+    '--seekora-bg-secondary': string;
+    '--seekora-bg-tertiary': string;
+    '--seekora-bg-hover': string;
+    '--seekora-text-primary': string;
+    '--seekora-text-secondary': string;
+    '--seekora-text-tertiary': string;
+    '--seekora-border-color': string;
+    '--seekora-primary': string;
+    '--seekora-primary-light': string;
+    '--seekora-primary-dark': string;
+    '--seekora-highlight-bg': string;
+    '--seekora-success': string;
+    '--seekora-warning': string;
+    '--seekora-error': string;
+    '--seekora-font-family': string;
+    '--seekora-font-size-xs': string;
+    '--seekora-font-size-sm': string;
+    '--seekora-font-size-base': string;
+    '--seekora-font-size-lg': string;
+    '--seekora-font-weight-normal': string;
+    '--seekora-font-weight-medium': string;
+    '--seekora-font-weight-semibold': string;
+    '--seekora-font-weight-bold': string;
+    '--seekora-line-height-tight': string;
+    '--seekora-line-height-normal': string;
+    '--seekora-line-height-relaxed': string;
+    '--seekora-spacing-xs': string;
+    '--seekora-spacing-sm': string;
+    '--seekora-spacing-md': string;
+    '--seekora-spacing-lg': string;
+    '--seekora-spacing-xl': string;
+    '--seekora-border-radius-sm': string;
+    '--seekora-border-radius': string;
+    '--seekora-border-radius-lg': string;
+    '--seekora-border-radius-xl': string;
+    '--seekora-border-radius-full': string;
+    '--seekora-shadow-sm': string;
+    '--seekora-shadow': string;
+    '--seekora-shadow-md': string;
+    '--seekora-shadow-lg': string;
+    '--seekora-shadow-xl': string;
+    '--seekora-transition-fast': string;
+    '--seekora-transition-normal': string;
+    '--seekora-transition-slow': string;
+    '--seekora-z-dropdown': string;
+    '--seekora-z-modal': string;
+    '--seekora-z-tooltip': string;
+}
+declare const lightThemeVariables: SuggestionsThemeVariables;
+declare const darkThemeVariables: SuggestionsThemeVariables;
+declare const minimalThemeVariables: SuggestionsThemeVariables;
+declare const brandPresets: {
+    blue: {
+        '--seekora-primary': string;
+        '--seekora-primary-light': string;
+        '--seekora-primary-dark': string;
+    };
+    green: {
+        '--seekora-primary': string;
+        '--seekora-primary-light': string;
+        '--seekora-primary-dark': string;
+    };
+    purple: {
+        '--seekora-primary': string;
+        '--seekora-primary-light': string;
+        '--seekora-primary-dark': string;
+    };
+    red: {
+        '--seekora-primary': string;
+        '--seekora-primary-light': string;
+        '--seekora-primary-dark': string;
+    };
+    orange: {
+        '--seekora-primary': string;
+        '--seekora-primary-light': string;
+        '--seekora-primary-dark': string;
+    };
+    teal: {
+        '--seekora-primary': string;
+        '--seekora-primary-light': string;
+        '--seekora-primary-dark': string;
+    };
+    pink: {
+        '--seekora-primary': string;
+        '--seekora-primary-light': string;
+        '--seekora-primary-dark': string;
+    };
+};
+/**
+ * Create a complete theme object from variables
+ */
+declare function createSuggestionsTheme(baseTheme?: 'light' | 'dark' | 'minimal', overrides?: Partial<SuggestionsThemeVariables>, brandColor?: keyof typeof brandPresets): SuggestionsThemeVariables;
+/**
+ * Generate complete CSS stylesheet for suggestions components
+ */
+declare function generateSuggestionsStylesheet(theme?: SuggestionsThemeVariables): string;
+/**
+ * Inject suggestions styles into the document
+ */
+declare function injectSuggestionsStyles(theme?: SuggestionsThemeVariables, force?: boolean): void;
+/**
+ * Update injected styles with new theme
+ */
+declare function updateSuggestionsStyles(theme: SuggestionsThemeVariables): void;
+
+declare const createTheme: (config: ThemeConfig) => _seekora_ai_ui_sdk_types.Theme;
+
+export { AmazonDropdown, Breadcrumb, ClearRefinements, CurrentRefinements, Facets, FederatedDropdown, FrequentlyBoughtTogether, GoogleDropdown, HierarchicalMenu, Highlight, HitsPerPage, InfiniteHits, MinimalDropdown, MobileFilters, MobileFiltersButton, MobileSheetDropdown, Pagination, PinterestDropdown, QuerySuggestions, QuerySuggestionsDropdown, RangeInput, RangeSlider, RecentlyViewed, RelatedProducts, RichQuerySuggestions, SearchBar, SearchBarWithSuggestions, SearchLayout, SearchProvider, SearchResults, ShopifyDropdown, Snippet, SortBy, SpotlightDropdown, Stats, SuggestionDropdownVariants, SuggestionSearchBar, SuggestionsCache, TrendingItems, addRecentSearch, addToRecentlyViewed, brandPresets, breakpoints, clearRecentSearches, clearSuggestionsCache, createSuggestionsCache, createSuggestionsTheme, createTheme, darkTheme, darkThemeVariables, defaultTheme, extractBrand, extractCategory, extractProduct, extractSuggestion, formatParsedFilters, formatPrice as formatSuggestionPrice, generateSuggestionsStylesheet, getRecentSearches, getSuggestionsCache, highlightText, injectGlobalResponsiveStyles, injectSuggestionsStyles, lightThemeVariables, mediaQueries, minimalTheme, minimalThemeVariables, removeRecentSearch, touchTargets, updateSuggestionsStyles, useAnalytics, useInjectResponsiveStyles, useNaturalLanguageFilters, useQuerySuggestions, useQuerySuggestionsEnhanced, useResponsive, useSearchContext, useSearchState, useSeekoraSearch, useSmartSuggestions, useSuggestionsAnalytics };
+export type { AnalyticsConfig, BaseDropdownProps, BrandFieldMapping, BreadcrumbItem, BreadcrumbProps, BreadcrumbTheme, CategoryFieldMapping, ClearRefinementsProps, ClearRefinementsTheme, DropdownClassNames, DropdownEventHandlers, DropdownRef, DropdownThemeConfig, FederatedDropdownProps, FederatedDropdownRef, FrequentlyBoughtTogetherProps, HierarchicalMenuItem, HierarchicalMenuProps, HierarchicalMenuTheme, HighlightProps, HighlightTheme, HitsPerPageItem, HitsPerPageProps, HitsPerPageTheme, InfiniteHitsProps, InfiniteHitsTheme, MobileFiltersButtonProps, MobileFiltersProps, MobileFiltersTheme, NaturalLanguageFiltersOptions, NaturalLanguageResult, NavigableItem, ParsedFilter, ProductClickEventData, ProductDisplayConfig, ProductFieldMapping, QuerySuggestionsDropdownProps, QuerySuggestionsDropdownRef, QuerySuggestionsProps, QuerySuggestionsTheme, RangeSliderProps, RangeSliderTheme, RecentlyViewedProps, RecommendationItem, RecommendationTheme, RelatedProductsProps, ResponsiveState, RichQuerySuggestionsProps, RichQuerySuggestionsRef, SearchBarProps, SearchBarTheme, SearchBarWithSuggestionsProps, SearchBarWithSuggestionsRef, SearchProviderProps, SearchResultsProps, SearchResultsTheme, SectionConfig, SmartSuggestion, SmartSuggestionsOptions, SnippetProps, SnippetTheme, SuggestionClickEventData, SuggestionDisplayConfig, SuggestionDropdownVariant, SuggestionFieldMapping, SuggestionImpressionEventData, SuggestionItem$1 as SuggestionItem, SuggestionSearchBarProps, SuggestionSearchBarRef, SuggestionsThemeVariables, TrendingItemsProps, UseQuerySuggestionsEnhancedOptions, UseQuerySuggestionsEnhancedReturn, UseSmartSuggestionsReturn, UseSuggestionsAnalyticsOptions, UseSuggestionsAnalyticsReturn };